-- 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 handoff_to_task_id IS NULL 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, plan_document, source, identity, binding_id, binding_version, outputs, review_gate, rereview_rounds, org_id, park_class, park_blocker, handoff_from_task_id, handoff_to_task_id 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. -- A non-empty draft_yaml makes the task a test run: it is pinned to that -- definition and its source is 'test'. 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, workflow_definition_yaml, workflow_definition_digest) SELECT sqlc.arg(owner), sqlc.arg(repo), number.last_number, sqlc.arg(title), sqlc.arg(body), 'chat', sqlc.arg(workflow), CASE WHEN sqlc.arg(draft_yaml)::text = '' THEN 'chat' ELSE 'test' END, sqlc.arg(identity), owner_org.id, sqlc.arg(inputs), sqlc.arg(origin), sqlc.arg(draft_yaml)::text, sqlc.arg(draft_digest)::text 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) AND m.org_id = sqlc.narg(scope_org)::text LIMIT 1), (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 -- Chat tasks that finished, wait for approval or have a pull request open, -- whose state has not reached their conversation yet. SELECT * FROM tasks WHERE origin <> '' AND outcome_posted_status <> status AND status IN ('merged', 'rejected', 'dead', 'closed_wont_do', 'completed', 'waiting_approval', 'pr_open') AND handoff_to_task_id IS NULL AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org)) ORDER BY id LIMIT 50; -- name: MarkOutcomePosted :exec -- Records the status whose state reached the task's conversation. A caller -- that names none (an older archied) marks the current status, so a mixed -- deploy cannot leave a posted state looking unposted forever. UPDATE tasks SET outcome_posted_status = COALESCE(NULLIF(sqlc.arg(posted)::text, ''), status) WHERE id = sqlc.arg(id); -- name: StampTaskBinding :exec -- The capture's signature result is spelled as the access context spells it. UPDATE tasks SET binding_id = @binding_id, binding_version = @binding_version, binding_signature = c.signature, binding_addr = c.remote_addr FROM (SELECT CASE WHEN authenticated THEN 'valid' WHEN unsigned THEN 'unsigned' ELSE 'unverified' END AS signature, remote_addr FROM captures WHERE captures.id = @capture_id) c WHERE tasks.id = @id; -- 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, plan_document = @plan_document, 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, resume_from = @resume_from::text, resume_results = @resume_results::jsonb, resume_history = @resume_history::jsonb, 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: TaskRetryCount :one -- Read under the lock the park's guard takes, so the escalation decision -- cannot interleave with a retry. SELECT retry_count 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_decision 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, park_blocker = CASE WHEN $2 = 'parked' THEN '' ELSE park_blocker 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, park_blocker = $5, 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) WHERE handoff_to_task_id IS NULL 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_decision', 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_decision', 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_decision', 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, resume_history = 'null', workflow_definition_yaml = CASE WHEN @current_definition::bool THEN '' ELSE workflow_definition_yaml END, workflow_definition_digest = CASE WHEN @current_definition::bool THEN '' ELSE workflow_definition_digest END, workflow_definition_version = CASE WHEN @current_definition::bool THEN 0 ELSE workflow_definition_version END, park_reason = '', park_class = 'needs_decision', 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_decision', 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' AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org)); -- name: NextTaskID :one SELECT nextval(pg_get_serial_sequence('tasks', 'id'))::bigint; -- name: MarkHandedOff :execrows -- The run leaves the item's unique key before its successor takes it. UPDATE tasks SET handoff_to_task_id = sqlc.arg(successor_id), updated_at = now() WHERE id = sqlc.arg(id) AND handoff_to_task_id IS NULL; -- name: InsertHandoffTask :one -- The successor run carries the work item and the decisions made on it; its -- run state (attempts, branch, outputs, review state) starts fresh. INSERT INTO tasks (id, owner, repo, issue_number, title, body, labels, workflow, source, identity, org_id, workspace_id, inputs, plan, plan_document, binding_id, binding_version, binding_signature, binding_addr, origin, call_parent_task_id, call_depth, handoff_from_task_id) SELECT sqlc.arg(successor_id), t.owner, t.repo, t.issue_number, t.title, t.body, t.labels, sqlc.arg(workflow), t.source, t.identity, t.org_id, t.workspace_id, t.inputs, t.plan, t.plan_document, t.binding_id, t.binding_version, t.binding_signature, t.binding_addr, t.origin, t.call_parent_task_id, t.call_depth, t.id FROM tasks t WHERE t.id = sqlc.arg(id) RETURNING *;