* fix(webui): accept the merge task action The action whitelist omitted merge, so the dashboard's Merge button on a pr_open task was refused with 400 unknown action. Closes: archie-core-slpoz * fix(workflow): give each parallel branch its own outputs Branches shared the task's Outputs map, so concurrent declared-output writes raced (or were lost when the map started nil). Each branch now writes a copy; join merges new outputs in branch-name order and refuses one written by two branches as a second write. Closes: archie-core-3a7w2 * fix(postgres): dispatch captures oldest first and keep pending ones ListUndispatchedCaptures ordered newest first and listed captures no binding can match (failed HMAC), so sustained intake starved older work and bad signatures held the batch. It is now oldest first and lists only dispatchable captures. Count retention no longer evicts a capture that is still pending for an armed binding. The daemon lists only sources with an enabled workflow, so captures waiting on a disabled one do not hold the oldest-first batch. Closes: archie-core-2et4b, archie-core-o0s0z * fix(ui): refuse renaming a workflow onto an existing id Saving upserts by id, so editing a workflow's id to another workflow's id removed the open one and overwrote the other. The editor now refuses that save and says why. Closes: archie-core-wpoz8 * fix(workflow): reject unknown step settings at save Step factories decoded settings with yaml.Node.Decode, which drops keys it does not know, and settings-less steps ignored settings entirely, so a misspelt key (readOnly for read_only) saved and silently did nothing. Every factory now decodes strictly and settings-less steps refuse settings; ParseDefinition runs the factories, so the save refuses them. Closes: archie-core-8b5nk * fix(postgres): keep a stored capture when its prune fails InsertCapture committed the capture, then returned the prune's error, so intake answered 500 and a sender without a delivery header retried into a duplicate capture and a duplicate dispatch. A failed prune is now logged and the stored capture's id returned. Closes: archie-core-3miuh * fix(crondelivery): fail and advance a job no runner can deliver Router.Run returned nil for a kind with no runner, so the engine reported a successful run while the schedule never advanced and the job fired on every tick. The run now fails with the refusal, which the engine reports, and the schedule advances (a one-shot is removed). The router's own refusal event is gone with it. Closes: archie-core-s6ahh * fix(taskactions): stop the runs of cancelled callees CancelExecution cancelled a caller's waited-on callees in the store, but only the caller's run was stopped, so callee containers ran to the end. CancelExecution now returns the callees it cancelled (nested included) in place of the step ids nobody read, and every cancelling action stops their runs too. Closes: archie-core-9labz * fix(workflow): treat a zero json.Number as false in when Task inputs and step results decode numbers as json.Number, which truthy did not unpack, so when: inputs.count held for a count of 0. Closes: archie-core-uv270 * fix(webui): read a workflow's runs with a workflow-filtered page The workflows page and the canvas run picker filtered the newest 100 tasks of every workflow client-side, so on a busy instance a workflow's older runs were invisible. GET /api/tasks takes a workflow filter, carried through the State Store's Tasks request to the query, and both views ask for the selected workflow's runs. Closes: archie-core-tpiw1 * fix(ui): load the restored workflow into the editor Restore Defaults saved the shipped definition but left the open draft in the editor, still marked unsaved, so a later save re-applied it. The editor now reloads the restored definition. Closes: archie-core-85e7w
272 lines
13 KiB
SQL
272 lines
13 KiB
SQL
-- name: ClaimNextTask :one
|
|
-- FOR UPDATE SKIP LOCKED replaces the SQLite single-writer assumption: two
|
|
-- claimers running at once take different rows instead of blocking, so the
|
|
-- daemon no longer depends on holding the only connection to the file.
|
|
-- The claim also starts the attempt's output set empty: outputs is
|
|
-- attempt-scoped, so nothing the previous attempt wrote survives
|
|
-- (docs/prds/workflow-call-outputs.md).
|
|
UPDATE tasks
|
|
SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
|
|
WHERE id = (
|
|
SELECT id FROM tasks
|
|
WHERE status = 'queued'
|
|
ORDER BY id
|
|
FOR UPDATE SKIP LOCKED
|
|
LIMIT 1
|
|
)
|
|
RETURNING *;
|
|
|
|
-- name: TaskByID :one
|
|
SELECT * FROM tasks WHERE id = sqlc.arg(id) AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org));
|
|
|
|
-- name: TaskByIssue :one
|
|
SELECT * FROM tasks WHERE owner = sqlc.arg(owner) AND repo = sqlc.arg(repo) AND issue_number = sqlc.arg(issue_number)
|
|
AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org));
|
|
|
|
-- name: TaskByPR :one
|
|
-- OpenTaskByPR is the live-task lookup: it only resolves a PR the task is
|
|
-- currently tracking as open, so a merged or rejected task does not read as
|
|
-- the owner of a PR number it no longer holds.
|
|
SELECT * FROM tasks WHERE owner = sqlc.arg(owner) AND repo = sqlc.arg(repo) AND pr_number = sqlc.arg(pr_number) AND status = sqlc.arg(status)
|
|
AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org));
|
|
|
|
-- name: ListTaskSummaries :many
|
|
-- The dashboard's list. This projection is deliberately narrow: Plan gates
|
|
-- the "Decision required" panel and Source labels the row, and widening it
|
|
-- back would send rows without them. outputs rides it because the task row's
|
|
-- own structured result is part of the summary a caller or the dashboard
|
|
-- reads (docs/prds/workflow-call-outputs.md, "Storage and wire").
|
|
-- review_gate and rereview_rounds join it deliberately: the offer the gate
|
|
-- wrote is what the operator reads before answering it
|
|
-- (docs/prds/pr-review-operator-response.md, "The review the operator
|
|
-- answers"), and the round count is the cap's visible half.
|
|
SELECT id, owner, repo, issue_number, title, status, workflow,
|
|
pr_number, tokens_used, iterations, attempt, park_reason, retry_count,
|
|
created_at, updated_at, plan, source, identity, binding_id, binding_version,
|
|
outputs, review_gate, rereview_rounds
|
|
FROM tasks
|
|
WHERE (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org))
|
|
AND (cardinality(@statuses::text[]) = 0 OR status = ANY(@statuses::text[]))
|
|
AND (@workflow::text = '' OR workflow = @workflow::text)
|
|
AND (sqlc.narg(before_updated)::timestamptz IS NULL
|
|
OR (updated_at, id) < (sqlc.narg(before_updated)::timestamptz, @before_id::bigint))
|
|
ORDER BY updated_at DESC, id DESC
|
|
LIMIT @page_limit;
|
|
|
|
-- name: CountTasksByStatus :many
|
|
SELECT status, count(*)::int AS count FROM tasks WHERE (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org)) GROUP BY status;
|
|
|
|
-- name: InsertChatTask :one
|
|
-- The synthetic issue number keeps chat-sourced tasks off the forge's real
|
|
-- issue numbers; chat_issue_numbers is the single source of truth for it, and
|
|
-- bumping its row serializes concurrent inserts in one repository.
|
|
-- fallback_issue_number is only the seed for a repo's first chat task -- the
|
|
-- passed value is not the issue number that lands.
|
|
-- inputs is the chat task's own workflow inputs; a binding dispatch passes
|
|
-- its inputs here too, so this insert is the single writer of the column and
|
|
-- StampTaskBinding adds only the provenance.
|
|
-- The task runs in its identity's org; a caller confined to another org
|
|
-- inserts nothing, so it cannot start work under an identity it does not own.
|
|
WITH number AS (
|
|
INSERT INTO chat_issue_numbers (owner, repo, last_number)
|
|
VALUES (sqlc.arg(owner), sqlc.arg(repo), sqlc.arg(fallback_issue_number)::bigint + 1)
|
|
ON CONFLICT (owner, repo) DO UPDATE SET last_number = chat_issue_numbers.last_number + 1
|
|
RETURNING last_number
|
|
)
|
|
INSERT INTO tasks (owner, repo, issue_number, title, body, labels, workflow, source, identity, org_id, inputs, origin)
|
|
SELECT
|
|
sqlc.arg(owner), sqlc.arg(repo), number.last_number,
|
|
sqlc.arg(title), sqlc.arg(body), 'chat', sqlc.arg(workflow), 'chat', sqlc.arg(identity),
|
|
owner_org.id,
|
|
sqlc.arg(inputs),
|
|
sqlc.arg(origin)
|
|
FROM number, (SELECT COALESCE(
|
|
(SELECT a.org_id FROM org_agents a WHERE a.identity_id = sqlc.arg(identity)),
|
|
(SELECT m.org_id FROM memberships m WHERE m.identity_id = sqlc.arg(identity)
|
|
ORDER BY m.created_at, m.org_id, m.workspace_id NULLS LAST LIMIT 1),
|
|
'org-sys'
|
|
) AS id) AS owner_org
|
|
WHERE sqlc.narg(scope_org)::text IS NULL OR owner_org.id = sqlc.narg(scope_org)
|
|
RETURNING *;
|
|
|
|
-- name: ActiveTasksByOrigin :many
|
|
-- The queued and running tasks one conversation created, for its /stop.
|
|
SELECT * FROM tasks
|
|
WHERE origin = sqlc.arg(origin) AND origin <> '' AND status IN ('queued', 'running') AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org))
|
|
ORDER BY id;
|
|
|
|
-- name: UnpostedOutcomes :many
|
|
-- Finished chat tasks whose outcome has not reached their conversation yet.
|
|
SELECT * FROM tasks
|
|
WHERE origin <> '' AND NOT outcome_posted
|
|
AND status IN ('merged', 'rejected', 'dead', 'closed_wont_do', 'completed')
|
|
AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org))
|
|
ORDER BY id
|
|
LIMIT 50;
|
|
|
|
-- name: MarkOutcomePosted :exec
|
|
UPDATE tasks SET outcome_posted = true WHERE id = $1;
|
|
|
|
-- name: StampTaskBinding :exec
|
|
UPDATE tasks SET binding_id = $2, binding_version = $3 WHERE id = $1;
|
|
|
|
-- name: UpdateTask :exec
|
|
-- An update without a definition keeps the stored pin: a task's own
|
|
-- credential sends none, so it cannot replace the definition it runs.
|
|
UPDATE tasks SET workflow = @workflow, branch = @branch, plan = @plan, notes = @notes,
|
|
pr_number = @pr_number, tokens_used = @tokens_used, iterations = @iterations, park_reason = @park_reason,
|
|
watch_comment_id = @watch_comment_id, retry_count = @retry_count, remediation_rounds = @remediation_rounds,
|
|
review_payload = @review_payload,
|
|
workflow_definition_version = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_version ELSE @workflow_definition_version END,
|
|
workflow_definition_digest = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_digest ELSE @workflow_definition_digest END,
|
|
workflow_definition_yaml = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_yaml ELSE @workflow_definition_yaml::text END,
|
|
outputs = @outputs, review_gate = @review_gate, rereview_rounds = @rereview_rounds,
|
|
retry_mode = @retry_mode, updated_at = now()
|
|
WHERE id = @id;
|
|
|
|
-- name: RereviewRounds :one
|
|
-- Read under the lock LockTaskStatus takes in the same transaction, so the
|
|
-- cap decision and the increment it guards cannot interleave with a second
|
|
-- response write.
|
|
SELECT rereview_rounds FROM tasks WHERE id = $1;
|
|
|
|
-- name: LockTaskStatus :one
|
|
-- Locks the task's row and returns its current status, so the staleness and
|
|
-- transition-table checks that decide a guarded write hold against a
|
|
-- concurrent claim or transition until the update in the same transaction.
|
|
SELECT status FROM tasks WHERE id = $1 FOR UPDATE;
|
|
|
|
-- name: TransitionTask :execrows
|
|
-- Arriving at 'parked' also records why. The class is normalized by the
|
|
-- caller, so an unknown value persists as needs_human rather than as itself.
|
|
UPDATE tasks
|
|
SET status = $2,
|
|
park_reason = CASE WHEN $2 = 'parked' THEN $3 ELSE park_reason END,
|
|
park_class = CASE WHEN $2 = 'parked' THEN $4 ELSE park_class END,
|
|
updated_at = now()
|
|
WHERE id = $1 AND status = $5;
|
|
|
|
-- name: InsertTransition :exec
|
|
INSERT INTO transitions (task_id, from_status, to_status, detail, org_id, workspace_id)
|
|
SELECT t.id, sqlc.arg(from_status), sqlc.arg(to_status), sqlc.arg(detail), t.org_id, t.workspace_id
|
|
FROM tasks t WHERE t.id = sqlc.arg(task_id);
|
|
|
|
-- name: ParkTask :execrows
|
|
UPDATE tasks
|
|
SET status = 'parked', park_reason = $2, park_class = $3, updated_at = now()
|
|
WHERE id = $1 AND status = $4;
|
|
|
|
-- name: ClearTerminalTasks :execrows
|
|
DELETE FROM tasks
|
|
WHERE status IN ('merged', 'rejected', 'dead', 'closed_wont_do', 'completed')
|
|
AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org));
|
|
|
|
-- name: RecoverStaleTasks :execrows
|
|
UPDATE tasks SET status = 'queued', updated_at = now() WHERE status = 'running';
|
|
|
|
-- name: EnqueueIssue :execrows
|
|
-- The org is derived from the identity at the one place a task row is
|
|
-- written (an agent's assignment, else a membership, else the default org);
|
|
-- uniqueness follows the record's identity: two orgs may work the same
|
|
-- issue under their own identities, one may not work it twice.
|
|
INSERT INTO tasks (owner, repo, issue_number, title, body, labels, identity, org_id, workspace_id)
|
|
VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7,
|
|
COALESCE(
|
|
(SELECT a.org_id FROM org_agents a WHERE a.identity_id = $7),
|
|
(SELECT m.org_id FROM memberships m WHERE m.identity_id = $7
|
|
ORDER BY m.created_at, m.org_id, m.workspace_id NULLS LAST LIMIT 1),
|
|
'org-sys'
|
|
),
|
|
'default'
|
|
)
|
|
ON CONFLICT (org_id, identity, owner, repo, issue_number) DO NOTHING;
|
|
|
|
-- name: ClaimByIssue :one
|
|
-- The claim starts the attempt's output set empty, as ClaimNextTask does:
|
|
-- outputs is attempt-scoped (docs/prds/workflow-call-outputs.md).
|
|
UPDATE tasks SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
|
|
WHERE owner = $1 AND repo = $2 AND issue_number = $3 AND status = 'queued'
|
|
RETURNING *;
|
|
|
|
-- name: BeginRemediationTask :execrows
|
|
-- A remediation must continue the branch its pull request lives on, so it
|
|
-- records that dispatch mode explicitly (taskstate.RetryContinuePushedWork)
|
|
-- rather than leaving prepareWorkspace to infer it from the workflow.
|
|
UPDATE tasks SET status = 'queued', workflow = 'remediate', park_reason = '', park_class = 'needs_human', review_payload = $2, retry_mode = 'continue_pushed_work', resume_from = '', resume_results = '{}', updated_at = now()
|
|
WHERE id = $1 AND status = 'pr_open';
|
|
|
|
-- name: AppendPendingReview :execrows
|
|
-- A distinct review that arrived while a remediation owned the task. The two
|
|
-- containment tests are the dedup: a re-delivered reaction, or a poll that
|
|
-- re-publishes a review already queued, appends nothing, and one already
|
|
-- active in review_payload is not queued to run a second time.
|
|
UPDATE tasks SET pending_reviews = CASE
|
|
WHEN review_payload = $2::text THEN pending_reviews
|
|
WHEN pending_reviews @> jsonb_build_array($2::text) THEN pending_reviews
|
|
ELSE pending_reviews || jsonb_build_array($2::text)
|
|
END,
|
|
updated_at = now()
|
|
WHERE id = $1 AND status IN ('queued', 'running') AND workflow = 'remediate';
|
|
|
|
-- name: PromotePendingReview :execrows
|
|
-- The run that owned the task returned it to pr_open with reviews still
|
|
-- waiting: the oldest becomes the active payload and the task is queued
|
|
-- again, so it is remediated after the run that just finished.
|
|
UPDATE tasks SET status = 'queued', workflow = 'remediate', park_reason = '',
|
|
park_class = 'needs_human',
|
|
review_payload = pending_reviews->>0, pending_reviews = pending_reviews - 0,
|
|
retry_mode = 'continue_pushed_work', resume_from = '', resume_results = '{}',
|
|
updated_at = now()
|
|
WHERE id = $1 AND status = 'pr_open' AND workflow = 'remediate'
|
|
AND jsonb_array_length(pending_reviews) > 0;
|
|
|
|
-- name: LockReviewUnits :one
|
|
-- The remediation's review units, locked so a comment merge cannot race the
|
|
-- claim that freezes the active unit or the promotion of a pending one.
|
|
SELECT status, workflow, review_payload, pending_reviews::text AS pending_reviews
|
|
FROM tasks WHERE id = $1 FOR UPDATE;
|
|
|
|
-- name: SetReviewUnits :exec
|
|
UPDATE tasks SET review_payload = $2, pending_reviews = CAST(CAST(sqlc.arg(pending_reviews) AS text) AS jsonb), updated_at = now()
|
|
WHERE id = $1;
|
|
|
|
-- name: SetReviewCursors :execrows
|
|
UPDATE tasks SET review_cursor = $2, watch_comment_id = $3, updated_at = now()
|
|
WHERE id = $1 AND status = 'pr_open';
|
|
|
|
-- name: RequeueTask :execrows
|
|
UPDATE tasks SET status = 'queued',
|
|
workflow = CASE WHEN @workflow::text = '' THEN workflow ELSE @workflow::text END,
|
|
park_reason = '', park_class = 'needs_human', updated_at = now()
|
|
WHERE id = @id AND status = @from_status;
|
|
|
|
-- name: RetryTask :execrows
|
|
UPDATE tasks SET status = 'queued', retry_count = retry_count + 1,
|
|
workflow = CASE WHEN @workflow::text = '' THEN workflow ELSE @workflow::text END,
|
|
retry_mode = @retry_mode::text,
|
|
resume_from = @resume_from::text, resume_results = @resume_results::jsonb,
|
|
park_reason = '', park_class = 'needs_human', updated_at = now()
|
|
WHERE id = @id AND status = @from_status;
|
|
|
|
-- name: RespondReviewGateTask :execrows
|
|
-- The review gate response write (docs/prds/pr-review-operator-response.md,
|
|
-- Decision 2): one guarded requeue beside RetryTask/BeginRemediation. The
|
|
-- from-status guard and the transition table live in the store's transaction
|
|
-- around this statement; the rereview cap is enforced HERE, in the row, so
|
|
-- two simultaneous re-reviews cannot spend a round the cap forbids. An
|
|
-- approve passes rereview=false and bumps nothing.
|
|
UPDATE tasks SET status = 'queued',
|
|
review_gate = @gate::text,
|
|
rereview_rounds = rereview_rounds + CASE WHEN @rereview::bool THEN 1 ELSE 0 END,
|
|
park_reason = '', park_class = 'needs_human', updated_at = now()
|
|
WHERE id = @id AND status = @from_status
|
|
AND (@rereview::bool = false OR rereview_rounds < @cap::bigint);
|
|
|
|
-- name: ArchiveTaskDelete :execrows
|
|
DELETE FROM tasks WHERE id = $1 AND status = $2;
|
|
|
|
-- name: ListOpenPRs :many
|
|
SELECT id, owner, repo, issue_number, pr_number, status, source, identity, attempt, review_cursor, watch_comment_id, outputs
|
|
FROM tasks WHERE status = 'pr_open';
|