@brainervirus/workit-core 1.1.1 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/src/core/authority.ts

@@ -23,6 +23,7 @@ import {
   type Utc,
 } from "./task-contract";
 import { TaskStore } from "./task-store";
+import { currentWriterOwnsTask } from "./workers";
 
 export type NativeAuthorityContext = {
   now: Utc;
@@ -542,6 +543,27 @@ export const storedDecisionApplicable = (
       verifyDecisionContentAtRoot(store.root, entry.data.binding).ok,
   );
 
+const approvalAuthorityMatches = (
+  store: TaskStore,
+  task: TaskRecord,
+  approval: Provenance,
+  current: Provenance,
+): boolean => {
+  if (approval.kind !== "host_observed" || approval.receipts.length === 0) return false;
+  if (provenanceMatches(approval, current)) return true;
+  const session = current.kind === "host_observed" ? current.session : null;
+  if (!session || session.kind !== "host") return false;
+  const workspace = store.readWorkspace();
+  return (
+    workspace.ok &&
+    workspace.data !== null &&
+    currentWriterOwnsTask(task, workspace.data, {
+      host: session.host,
+      actor: session.handle,
+    })
+  );
+};
+
 const validateAction = (
   store: TaskStore,
   task: TaskRecord,
@@ -574,11 +596,7 @@ const validateAction = (
     return failure("permission_denied", "native reservation authority does not match decision");
   if (decision.response !== "approved")
     return failure("permission_denied", "decision was rejected");
-  if (
-    entry.provenance.kind !== "host_observed" ||
-    entry.provenance.receipts.length === 0 ||
-    !provenanceMatches(entry.provenance, authority.provenance)
-  )
+  if (!approvalAuthorityMatches(store, task, entry.provenance, authority.provenance))
     return failure("permission_denied", "action approval lacks native receipt assurance");
   // Standing auto-approval receipts carry no live question. They authorize
   // only while the referenced workspace rule still covers the operation —
@@ -793,7 +811,7 @@ export function settleAction(input: SettleActionInput): Result<Entry<Decision>>
       if (!entry) return failure("not_found", "decision not found");
       if (!authorityDecisionMatches(authority, entry.data))
         return failure("permission_denied", "native settlement authority does not match decision");
-      if (!provenanceMatches(entry.provenance, authority.provenance))
+      if (!approvalAuthorityMatches(input.store, current, entry.provenance, authority.provenance))
         return failure("permission_denied", "native settlement caller does not match approval");
       if (entry.data.purpose !== "action" || entry.data.digest !== decisionDigest(entry.data))
         return failure("permission_denied", "decision binding is invalid");
@@ -931,7 +949,7 @@ export function reconcileAction(input: ReconcileActionInput): Result<Entry<Decis
         return failure("not_found", "decision not found");
       if (
         !authorityDecisionMatches(authority, entry.data) ||
-        !provenanceMatches(entry.provenance, authority.provenance)
+        !approvalAuthorityMatches(input.store, current, entry.provenance, authority.provenance)
       )
         return failure("permission_denied", "native reconciliation caller does not match approval");
       if (

package/src/core/auto-approval.ts

@@ -13,9 +13,10 @@ import {
   type Revision,
   type TaskRecord,
 } from "./task-contract";
-import type { TaskStore } from "./task-store";
+import { TaskStore } from "./task-store";
 import type { WorkitCore } from "./task-engine";
 import type { Decision } from "./task-contract";
+import { currentWriterOwnsTask } from "./workers";
 
 /** Action classes auto-approval can cover. Unknown classes never match. */
 export const AUTO_CLASSES = ["branch", "commit", "push", "pr", "merge"] as const;
@@ -154,14 +155,10 @@ export const verifyStandingApproval = (
 ): Result<Provenance> => {
   if (task.status !== "active")
     return failure("invalid_transition", "only active tasks can authorize actions");
-  const session = task.intent?.provenance?.session;
-  if (
-    !session ||
-    session.kind !== "host" ||
-    session.host !== caller.host ||
-    session.handle !== caller.actor
-  )
-    return failure("permission_denied", "standing approval requires the lead session");
+  const workspace = new TaskStore(root).readWorkspace();
+  if (!workspace.ok) return workspace as Result<never>;
+  if (!workspace.data || !currentWriterOwnsTask(task, workspace.data, caller))
+    return failure("permission_denied", "standing approval requires the current writer session");
   const standing = binding.standing;
   if (!standing || typeof standing.workspace !== "string" || typeof standing.class !== "string")
     return failure("invalid_input", "standing approval needs a workspace and class");
@@ -243,19 +240,14 @@ export const standingAutoApplies = (
   const listed = store.listTasks();
   const workspace = store.readWorkspace();
   if (!listed.ok || !workspace.ok || !workspace.data) return null;
-  const matches = listed.data.filter(
-    (task) =>
-      task.status === "active" &&
-      task.workspaceId === workspace.data!.id &&
-      task.intent?.provenance?.session?.kind === "host" &&
-      (task.intent.provenance.session as { host?: unknown; handle?: unknown }).host === host &&
-      (task.intent.provenance.session as { host?: unknown; handle?: unknown }).handle === actor,
+  const task = listed.data.find((task) =>
+    currentWriterOwnsTask(task, workspace.data!, { host, actor }),
   );
-  if (matches.length !== 1) return null;
+  if (!task) return null;
   const resolved = resolveAutoApproval(store.root);
   if (resolved.status !== "on") return null;
   return {
-    task: matches[0],
+    task,
     workspaceId: workspace.data.id,
     workspaceRevision: workspace.data.revision,
     cls,

package/src/core/external-action-effects.ts

@@ -25,7 +25,15 @@ import {
 } from "./youtrack";
 import fs from "node:fs";
 import path from "node:path";
-import { failure, success, sha256, type Caller, type Result, type Ref } from "./task-contract";
+import {
+  failure,
+  success,
+  sha256,
+  type Caller,
+  type Owner,
+  type Result,
+  type Ref,
+} from "./task-contract";
 import { changelogApply, changelogApplyPreview } from "./changelog";
 import type { ExternalActionRequest } from "./external-action";
 import { externalActionDescriptor, externalActionRequest } from "./external-action";
@@ -33,7 +41,7 @@ import { normalizeChainSteps } from "./authority";
 import { resolveInside, run as coreRun } from "../core";
 import { vcsConfig } from "./vcs-config";
 import { detectCommitFlavor, matchCommitFlavor, type CommitFlavor } from "./commit-flavors";
-import { assertProductWriteAllowed } from "./workers";
+import { assertProductWriteAllowed, currentWriterOwnsTask } from "./workers";
 import { TaskStore } from "./task-store";
 
 const run = (root: string, args: string[]) => {
@@ -201,26 +209,22 @@ const localAction = (operation: ExternalActionRequest["operation"]): boolean =>
   operation === "git.commit" ||
   operation === "git.push" ||
   operation === "hosting.pull_request" ||
+  operation === "hosting.merge" ||
   operation === "changelog.apply";
 
 export const assertLocalExternalActionWriter = (
   root: string,
   caller: { host: Caller["host"]; actor: string },
   paths: string[] = ["."],
-): Result<null> => {
+): Result<Owner> => {
   const store = new TaskStore(root);
   const listed = store.listTasks();
   const workspace = store.readWorkspace();
   if (!listed.ok) return listed as Result<never>;
   if (!workspace.ok) return workspace as Result<never>;
   if (!workspace.data) return failure("not_found", "workspace not found");
-  const candidates = listed.data.filter(
-    (task) =>
-      task.status === "active" &&
-      task.workspaceId === workspace.data!.id &&
-      task.intent.provenance.session?.kind === "host" &&
-      task.intent.provenance.session.host === caller.host &&
-      task.intent.provenance.session.handle === caller.actor,
+  const candidates = listed.data.filter((task) =>
+    currentWriterOwnsTask(task, workspace.data!, caller),
   );
   if (candidates.length !== 1)
     return failure("permission_denied", "local external action requires exactly one active task");
@@ -231,7 +235,7 @@ export const assertLocalExternalActionWriter = (
     paths,
     store,
   });
-  return allowed.ok ? success(null, null, null) : (allowed as Result<never>);
+  return allowed;
 };
 
 const safePath = (root: string, value: string): string | null => {
@@ -248,16 +252,29 @@ const branchCreationBaseline = (
   root: string,
   target: string,
   base: string,
-): { base_branch: string; target_exists: boolean; remote_base: string | null } => {
+): {
+  base_branch: string;
+  target_exists: boolean;
+  remote_base: string | null;
+  target_head: string | null;
+} => {
   const exists =
     gitValue(root, ["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]) !== null;
-  if (exists) return { base_branch: base, target_exists: true, remote_base: null };
+  if (exists)
+    return {
+      base_branch: base,
+      target_exists: true,
+      remote_base: null,
+      target_head: gitValue(root, ["rev-parse", `refs/heads/${target}`]),
+    };
   const remote = run(root, ["ls-remote", "origin", `refs/heads/${base}`]);
   const sha = remote.exitCode === 0 ? remote.stdout.trim().split(/\s+/)[0] : "";
+  const remoteBase = /^[0-9a-f]{40}$/.test(sha ?? "") ? (sha as string) : null;
   return {
     base_branch: base,
     target_exists: false,
-    remote_base: /^[0-9a-f]{40}$/.test(sha ?? "") ? (sha as string) : null,
+    remote_base: remoteBase,
+    target_head: remoteBase,
   };
 };
 
@@ -408,6 +425,9 @@ export const approvedResolvedExternalAction = (content: string): Result<Resolved
   try {
     const value = JSON.parse(content) as { operation?: unknown; payload?: unknown };
     if (
+      value.operation !== "git.branch_setup" &&
+      value.operation !== "git.commit" &&
+      value.operation !== "git.push" &&
       value.operation !== "hosting.pull_request" &&
       value.operation !== "hosting.merge" &&
       value.operation !== "changelog.apply" &&
@@ -425,6 +445,28 @@ export const approvedResolvedExternalAction = (content: string): Result<Resolved
     if (!request.ok || !resolved || typeof resolved !== "object")
       return failure("invalid_input", "approved hosting target is incomplete");
     const target = resolved as Record<string, unknown>;
+    if (
+      value.operation === "git.commit" &&
+      (typeof target.head !== "string" ||
+        typeof target.staged !== "string" ||
+        typeof payload.message !== "string")
+    )
+      return failure("invalid_input", "approved Git commit target is incomplete");
+    if (
+      value.operation === "git.push" &&
+      (typeof target.branch !== "string" ||
+        typeof target.commit !== "string" ||
+        typeof target.remote !== "string")
+    )
+      return failure("invalid_input", "approved Git push target is incomplete");
+    if (
+      value.operation === "git.branch_setup" &&
+      (typeof target.head !== "string" ||
+        (payload.action === "reapply_stash"
+          ? typeof target.stash_commit !== "string"
+          : typeof payload.target_branch !== "string" || typeof target.target_head !== "string"))
+    )
+      return failure("invalid_input", "approved Git branch target is incomplete");
     if (
       value.operation === "hosting.pull_request" &&
       (typeof target.marker !== "string" ||
@@ -452,7 +494,11 @@ export const approvedResolvedExternalAction = (content: string): Result<Resolved
     )
       return failure("invalid_input", "approved changelog target is incomplete");
     if (
+      value.operation !== "git.branch_setup" &&
+      value.operation !== "git.commit" &&
+      value.operation !== "git.push" &&
       value.operation !== "hosting.pull_request" &&
+      value.operation !== "hosting.merge" &&
       value.operation !== "changelog.apply" &&
       (typeof target.marker !== "string" ||
         typeof target.baseUrl !== "string" ||
@@ -463,7 +509,7 @@ export const approvedResolvedExternalAction = (content: string): Result<Resolved
     return success(null, null, {
       request: request.data,
       descriptorPayload: value.payload,
-      marker: String(target.marker),
+      ...(typeof target.marker === "string" ? { marker: target.marker } : {}),
     });
   } catch {
     return failure("invalid_input", "approved action descriptor is invalid");
@@ -499,8 +545,9 @@ export const readHostingAction = async (
   resolved: ResolvedExternalAction,
   actionRef: Ref,
 ): Promise<Result<HostingReadEvidence>> => {
-  if (resolved.request.operation !== "hosting.pull_request" || !resolved.marker)
-    return unknownHostingEvidence("hosting.pull_request");
+  const operation = resolved.request.operation;
+  if ((operation !== "hosting.pull_request" && operation !== "hosting.merge") || !resolved.marker)
+    return unknownHostingEvidence(operation);
   try {
     const cfg = vcsConfig("load", root);
     if (
@@ -509,7 +556,7 @@ export const readHostingAction = async (
       !cfg.provider ||
       (cfg.provider !== "github" && cfg.provider !== "gitlab")
     )
-      return unknownHostingEvidence("hosting.pull_request");
+      return unknownHostingEvidence(operation);
     const remote = pushRemote(root);
     const repo = remote ? remoteRepo(remote) : null;
     const approved = resolved.descriptorPayload as {
@@ -549,7 +596,7 @@ export const readHostingAction = async (
         remoteProvider(approvedRemote) !== cfg.provider) ||
       remoteParts(approvedRemote)?.host !== apiHost
     )
-      return unknownHostingEvidence("hosting.pull_request");
+      return unknownHostingEvidence(operation);
     const token = fs.readFileSync(cfg.tokenPath, "utf8").trim();
     const headers = { Authorization: `Bearer ${token}`, Accept: "application/vnd.github+json" };
     const url =
@@ -559,15 +606,14 @@ export const readHostingAction = async (
     const response = await fetch(url, {
       headers: cfg.provider === "gitlab" ? { "PRIVATE-TOKEN": token } : headers,
     });
-    if (!response.ok) return unknownHostingEvidence("hosting.pull_request");
+    if (!response.ok) return unknownHostingEvidence(operation);
     const values: unknown = await response.json();
     // A full page is intentionally treated as truncated until pagination is added.
-    if (!Array.isArray(values) || values.length >= 100)
-      return unknownHostingEvidence("hosting.pull_request");
+    if (!Array.isArray(values) || values.length >= 100) return unknownHostingEvidence(operation);
     const records: Record<string, unknown>[] = [];
     for (const item of values) {
       if (!item || typeof item !== "object" || Array.isArray(item))
-        return unknownHostingEvidence("hosting.pull_request");
+        return unknownHostingEvidence(operation);
       const record = item as Record<string, unknown>;
       const body = record.body ?? record.description;
       const base = record.base;
@@ -609,35 +655,48 @@ export const readHostingAction = async (
         typeof shaValue !== "string" ||
         (typeof idValue !== "string" && typeof idValue !== "number")
       )
-        return unknownHostingEvidence("hosting.pull_request");
+        return unknownHostingEvidence(operation);
       records.push(record);
     }
-    const matches = records.filter((item): item is Record<string, unknown> => {
-      const body = String(
-        (item as Record<string, unknown>).body ??
-          (item as Record<string, unknown>).description ??
-          "",
-      );
-      const base = (item as Record<string, unknown>).base as Record<string, unknown> | undefined;
-      const head = (item as Record<string, unknown>).head as Record<string, unknown> | undefined;
-      const itemTarget =
-        cfg.provider === "github" ? base?.ref : (item as Record<string, unknown>).target_branch;
-      const itemSource =
-        cfg.provider === "github" ? head?.ref : (item as Record<string, unknown>).source_branch;
-      const itemSha = cfg.provider === "github" ? head?.sha : (item as Record<string, unknown>).sha;
+    const matches = records.filter((item) => {
+      const body = String(item.body ?? item.description ?? "");
+      const base = item.base as Record<string, unknown> | undefined;
+      const head = item.head as Record<string, unknown> | undefined;
+      const itemTarget = cfg.provider === "github" ? base?.ref : item.target_branch;
+      const itemSource = cfg.provider === "github" ? head?.ref : item.source_branch;
+      const itemSha = cfg.provider === "github" ? head?.sha : item.sha;
+      const merged =
+        cfg.provider === "github"
+          ? typeof item.merged_at === "string"
+          : item.state === "merged" || typeof item.merged_at === "string";
       return (
-        body.includes(resolved.marker!) &&
+        (operation === "hosting.merge" ? merged : body.includes(resolved.marker!)) &&
         itemTarget === target &&
         itemSource === branch &&
         itemSha === sourceCommit
       );
     });
-    if (matches.length !== 1) return unknownHostingEvidence("hosting.pull_request");
+    if (
+      operation === "hosting.merge" &&
+      records.some((item) => {
+        const base = item.base as Record<string, unknown> | undefined;
+        const head = item.head as Record<string, unknown> | undefined;
+        return (
+          (cfg.provider === "github" ? base?.ref : item.target_branch) === target &&
+          (cfg.provider === "github" ? head?.ref : item.source_branch) === branch &&
+          (cfg.provider === "github"
+            ? typeof item.merged_at !== "string"
+            : item.state !== "merged" && typeof item.merged_at !== "string")
+        );
+      })
+    )
+      return unknownHostingEvidence(operation);
+    if (matches.length !== 1) return unknownHostingEvidence(operation);
     const item = matches[0];
     const id = item.number ?? item.iid ?? item.id;
-    if (typeof id !== "string" && typeof id !== "number")
-      return unknownHostingEvidence("hosting.pull_request");
+    if (typeof id !== "string" && typeof id !== "number") return unknownHostingEvidence(operation);
     const evidenceDigest = sha256({
+      operation,
       provider: cfg.provider,
       id,
       marker: resolved.marker,
@@ -658,7 +717,7 @@ export const readHostingAction = async (
       data: { provider: cfg.provider, id },
     });
   } catch {
-    return unknownHostingEvidence("hosting.pull_request");
+    return unknownHostingEvidence(operation);
   }
 };
 
@@ -812,14 +871,112 @@ export const readYouTrackAction = async (
   }
 };
 
+export const readLocalAction = async (
+  root: string,
+  resolved: ResolvedExternalAction,
+  actionRef: Ref,
+): Promise<Result<HostingReadEvidence>> => {
+  const operation = resolved.request.operation;
+  const target = (resolved.descriptorPayload as { resolved?: Record<string, unknown> }).resolved;
+  if (!target) return unknownHostingEvidence(operation);
+  let observed: Record<string, unknown> | null = null;
+  if (operation === "git.commit") {
+    const commit = gitValue(root, ["rev-parse", "HEAD"]);
+    const parent = commit ? gitValue(root, ["rev-parse", `${commit}^`]) : null;
+    const message = commit ? gitValue(root, ["show", "-s", "--format=%B", commit]) : null;
+    const diff =
+      commit && parent
+        ? gitRaw(root, ["diff", "--raw", "-z", "--no-ext-diff", "--no-textconv", parent, commit])
+        : null;
+    if (
+      commit &&
+      parent === target.head &&
+      message === resolved.request.payload.message &&
+      diff !== null &&
+      sha256(diff) === target.staged
+    )
+      observed = { commit, parent, message, staged: target.staged };
+  } else if (operation === "git.push") {
+    const branch = target.branch;
+    const commit = target.commit;
+    const approvedRemote = target.remote;
+    const currentRemote = pushRemote(root);
+    const currentIdentity = currentRemote ? credentialFreeRemote(currentRemote) : null;
+    if (
+      typeof branch === "string" &&
+      typeof commit === "string" &&
+      typeof approvedRemote === "string" &&
+      currentIdentity === approvedRemote
+    ) {
+      const remote = run(root, ["ls-remote", currentRemote!, `refs/heads/${branch}`]);
+      const remoteCommit = remote.exitCode === 0 ? remote.stdout.trim().split(/\s+/)[0] : null;
+      if (remoteCommit === commit) observed = { branch, commit, remote: approvedRemote };
+    }
+  } else if (operation === "git.branch_setup") {
+    const targetBranch = resolved.request.payload.target_branch;
+    const sdd = resolved.request.payload.sdd_dir;
+    if (resolved.request.payload.action === "reapply_stash" && typeof sdd === "string") {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(path.join(sdd, "manifest.json"), "utf8")) as {
+          stash_ref?: unknown;
+        };
+        const stashes = gitRaw(root, ["stash", "list", "--format=%H"]);
+        if (
+          typeof target.stash_commit === "string" &&
+          manifest.stash_ref === undefined &&
+          stashes !== null &&
+          !stashes.split("\n").includes(target.stash_commit)
+        )
+          observed = { stash_commit: target.stash_commit };
+      } catch {}
+    } else if (
+      typeof targetBranch === "string" &&
+      typeof sdd === "string" &&
+      gitValue(root, ["branch", "--show-current"]) === targetBranch &&
+      typeof target.target_head === "string" &&
+      gitValue(root, ["rev-parse", "HEAD"]) === target.target_head
+    ) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(path.join(sdd, "manifest.json"), "utf8")) as {
+          branch?: unknown;
+        };
+        if (manifest.branch === targetBranch) observed = { branch: targetBranch };
+      } catch {}
+    }
+  } else if (operation === "changelog.apply") {
+    const afterDigest = target.afterDigest;
+    const preview = changelogApplyPreview({ ...resolved.request.payload, workspace_root: root });
+    if (!preview.error && typeof afterDigest === "string" && preview.beforeDigest === afterDigest)
+      observed = { target: target.target, afterDigest };
+  }
+  if (!observed) return unknownHostingEvidence(operation);
+  const evidenceDigest = sha256({ operation, observed });
+  return success(null, null, {
+    outcome: "succeeded",
+    evidenceDigest,
+    observation: {
+      kind: "provider_read",
+      actionRef,
+      outcome: "succeeded",
+      evidenceDigest,
+    },
+  });
+};
+
 export const readExternalAction = async (
   root: string,
   resolved: ResolvedExternalAction,
   actionRef: Ref,
 ): Promise<Result<HostingReadEvidence>> =>
-  resolved.request.operation === "hosting.pull_request"
-    ? readHostingAction(root, resolved, actionRef)
-    : readYouTrackAction(root, resolved, actionRef);
+  resolved.request.operation === "git.branch_setup" ||
+  resolved.request.operation === "git.commit" ||
+  resolved.request.operation === "git.push" ||
+  resolved.request.operation === "changelog.apply"
+    ? readLocalAction(root, resolved, actionRef)
+    : resolved.request.operation === "hosting.pull_request" ||
+        resolved.request.operation === "hosting.merge"
+      ? readHostingAction(root, resolved, actionRef)
+      : readYouTrackAction(root, resolved, actionRef);
 
 const youTrackBase = (): string | null => {
   try {
@@ -905,6 +1062,17 @@ export const resolveExternalActionRequest = (
           action === "reapply_stash" || !target_branch
             ? { base_branch: policy.defaultTargetBranch }
             : branchCreationBaseline(root, target_branch, policy.defaultTargetBranch);
+        let stashTarget: { stash_ref: string; stash_commit: string } | undefined;
+        if (action === "reapply_stash") {
+          try {
+            const manifest = JSON.parse(
+              fs.readFileSync(path.join(sdd_dir, "manifest.json"), "utf8"),
+            ) as { stash_ref?: unknown };
+            const stash_ref = typeof manifest.stash_ref === "string" ? manifest.stash_ref : "";
+            const stash_commit = stash_ref ? gitValue(root, ["rev-parse", stash_ref]) : null;
+            if (stash_ref && stash_commit) stashTarget = { stash_ref, stash_commit };
+          } catch {}
+        }
         const normalized = {
           operation: request.operation,
           payload: {
@@ -919,7 +1087,7 @@ export const resolveExternalActionRequest = (
           request: normalized,
           descriptorPayload: {
             ...normalized.payload,
-            resolved: { head, dirty, ...creation },
+            resolved: { head, dirty, ...creation, ...stashTarget },
           },
         });
       }
@@ -1106,7 +1274,9 @@ export const resolveExternalActionRequest = (
             outcome: "not_started",
             fields: [{ path: "source_branch", reason: "protected branch" }],
           });
-        const source_commit = gitValue(root, ["rev-parse", "HEAD"]);
+        const source_commit = source_branch
+          ? gitValue(root, ["rev-parse", "--verify", `refs/heads/${source_branch}`])
+          : null;
         const remote = pushRemote(root);
         const identity = remote ? credentialFreeRemote(remote) : null;
         if (
@@ -1521,7 +1691,7 @@ export const executeResolvedExternalAction = async (
     typeof resolvedDetails.resolved?.beforeExists === "boolean"
       ? resolvedDetails.resolved.beforeExists
       : undefined;
-  return executeConcreteExternalAction(
+  const result = await executeConcreteExternalAction(
     fresh.data.request,
     root,
     fresh.data.marker,
@@ -1532,4 +1702,13 @@ export const executeResolvedExternalAction = async (
     beforeDigest,
     beforeExists,
   );
+  if (!result.ok && result.code === "external_outcome_unknown" && caller) {
+    const observed = await readLocalAction(root, fresh.data, {
+      kind: "host",
+      host: caller.host,
+      handle: `local-recovery:${fresh.data.request.operation}`,
+    });
+    if (observed.ok) return success(null, null, { recovered: true });
+  }
+  return result;
 };

package/src/core/external-action.ts

@@ -18,6 +18,12 @@ import { chainStepKey, normalizeChainSteps, type ChainStep } from "./authority";
 import * as z from "zod";
 import { execFileSync } from "node:child_process";
 
+const chainStepSchema = z.union([
+  z.string().min(1),
+  z.object({ branch: z.string().min(1) }).strict(),
+  z.object({ pr: z.literal(true) }).strict(),
+]);
+
 export type AuthorizedActionInput = {
   core: WorkitCore;
   taskId: Id;
@@ -60,7 +66,7 @@ const externalActionSchema = z.discriminatedUnion("operation", [
       payload: z
         .object({
           message: z.string().min(1).optional(),
-          plan_steps: z.array(z.string().min(1)).optional(),
+          plan_steps: z.array(chainStepSchema).min(1).max(32).optional(),
           plan_branch: z.string().min(1).optional(),
         })
         .strict(),
@@ -225,9 +231,26 @@ export const externalActionDescriptor = (operation: string, payload: unknown): s
       : {}),
   });
 
+/**
+ * Plan reservations never execute a git commit. A git.commit whose resolved
+ * payload carries a plan_steps array records the listed chain once and lets
+ * each listed single commit execute later under that authorization. Adapters
+ * must return plan success without running the commit effect, both for prior
+ * approvals and standing auto-approval; otherwise the reservation fails as a
+ * single commit requiring a message. Returns the listed count, else null.
+ */
+export const planReservationLength = (
+  operation: string,
+  descriptorPayload: unknown,
+): number | null => {
+  if (operation !== "git.commit") return null;
+  const payload = (descriptorPayload ?? {}) as { plan_steps?: unknown };
+  return Array.isArray(payload.plan_steps) ? payload.plan_steps.length : null;
+};
+
 /** Compact host-facing help for the fixed optional-action surface. */
 export const externalActionHelp =
-  "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; hosting.merge {target_branch?,source_branch?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
+  "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message?; plan_steps?: (string | {branch:string} | {pr:true})[]; plan_branch?}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; hosting.merge {target_branch?,source_branch?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind: git|pr|youtrack|github_issue|gitlab_issue|changelog|release|affected,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
 
 export const externalActionRef = (
   host: "opencode" | "pi" | "workit_cli",
@@ -251,14 +274,7 @@ export const externalActionState = (
     return failure("storage_error", "external action state is unavailable");
   if (!workspace.data) return failure("not_found", "workspace not found");
   const candidates = listed.data.flatMap((task) => {
-    if (
-      task.status !== "active" ||
-      task.workspaceId !== workspace.data!.id ||
-      task.intent.provenance.session?.kind !== "host" ||
-      task.intent.provenance.session.host !== host ||
-      task.intent.provenance.session.handle !== actor
-    )
-      return [];
+    if (task.status !== "active" || task.workspaceId !== workspace.data!.id) return [];
     return task.decisions
       .filter(
         (entry) =>
@@ -273,8 +289,8 @@ export const externalActionState = (
     return failure(
       "permission_denied",
       candidates.length === 0
-        ? "no approved action is bound to this session"
-        : "multiple approved actions match this session",
+        ? "no approved action is bound to the active task"
+        : "multiple approved actions match the active task",
     );
   return success(workspace.data.revision, null, { ...candidates[0], workspace: workspace.data });
 };
@@ -414,12 +430,6 @@ export const approvedPlanCommit = (
   if (!workspace.data) return failure("not_found", "workspace not found");
   const matches = listed.data.flatMap((task) => {
     if (task.status !== "active" || task.workspaceId !== workspace.data!.id) return [];
-    if (
-      task.intent.provenance.session?.kind !== "host" ||
-      task.intent.provenance.session.host !== host ||
-      task.intent.provenance.session.handle !== actor
-    )
-      return [];
     return task.decisions.flatMap((entry) => {
       const decision = entry.data;
       if (
@@ -464,12 +474,7 @@ export type ChainStepQuery =
   | { operation: "git.branch_setup"; target: string }
   | { operation: "hosting.pull_request" };
 
-/**
- * Match one branch or PR step of a chain authorization: same session-bound
- * search as plan commits, next unconsumed step of the right kind, lease
- * intact. Commit steps stay on the plan path; this covers the steps plans
- * could never express.
- */
+/** Match the next branch or PR step of an active chain authorization. */
 export const approvedChainStep = (
   store: TaskStore,
   host: string,
@@ -483,12 +488,6 @@ export const approvedChainStep = (
   if (!workspace.data) return failure("not_found", "workspace not found");
   const matches = listed.data.flatMap((task) => {
     if (task.status !== "active" || task.workspaceId !== workspace.data!.id) return [];
-    if (
-      task.intent.provenance.session?.kind !== "host" ||
-      task.intent.provenance.session.host !== host ||
-      task.intent.provenance.session.handle !== actor
-    )
-      return [];
     return task.decisions.flatMap((entry) => {
       const decision = entry.data;
       if (
@@ -734,21 +733,15 @@ export const approvedBranchSetupIntent = (
   operation: string,
 ) => {
   const current = branchSetupIntent(operation);
-  if (!current) return failure("permission_denied", "no approved action is bound to this session");
+  if (!current)
+    return failure("permission_denied", "no approved action is bound to the active task");
   const listed = store.listTasks();
   const workspace = store.readWorkspace();
   if (!listed.ok || !workspace.ok)
     return failure("storage_error", "external action state is unavailable");
   if (!workspace.data) return failure("not_found", "workspace not found");
   const candidates = listed.data.flatMap((task) => {
-    if (
-      task.status !== "active" ||
-      task.workspaceId !== workspace.data!.id ||
-      task.intent.provenance.session?.kind !== "host" ||
-      task.intent.provenance.session.host !== host ||
-      task.intent.provenance.session.handle !== actor
-    )
-      return [];
+    if (task.status !== "active" || task.workspaceId !== workspace.data!.id) return [];
     return task.decisions
       .filter(
         (entry) =>
@@ -772,8 +765,8 @@ export const approvedBranchSetupIntent = (
     return failure(
       "permission_denied",
       matches.length === 0
-        ? "no approved action is bound to this session"
-        : "multiple approved actions match this session",
+        ? "no approved action is bound to the active task"
+        : "multiple approved actions match the active task",
     );
   return success(workspace.data.revision, null, { ...matches[0], workspace: workspace.data });
 };

package/src/core/support-matrix.ts

@@ -7,7 +7,10 @@
 export const SUPPORT_MATRIX = {
   bun: "1.4.1",
   node: { minimum: "24", current: "24.20.0" },
-  opencode: { minimum: "1.15.0", current: "1.18.30" },
+  // The object-form dual entry (server() + setup()) only loads from
+  // 1.18.29+; the supported floor is 1.18.30 so no host can pass doctor while
+  // being unable to load the entry shape.
+  opencode: { minimum: "1.18.30", current: "1.18.30" },
   // Codex is a qualification host, not a runtime dependency: the CLI version
   // below is the one live qualification evidence covers. The doctor warns when
   // an installed CLI drifts ahead so a fresh install never silently outruns

package/src/core/task-contract.ts

@@ -658,6 +658,7 @@ export const workerSchema = z
     assignment: assignmentSchema,
     state: z.enum(["assigned", "dispatching", "running", "cancelling", "stopped", "unknown"]),
     session: refSchema.nullable(),
+    coordinator: refSchema.optional(),
     report: workerReportSchema.nullable(),
   })
   .strict();
@@ -808,6 +809,8 @@ export const taskSummarySchema = z
   })
   .strict();
 export type TaskSummary = z.infer<typeof taskSummarySchema>;
+export const taskListItemSchema = taskSummarySchema.omit({ policy: true, requirements: true });
+export type TaskListItem = z.infer<typeof taskListItemSchema>;
 export const exportBundleSchema = z
   .object({
     schemaVersion: z.literal(1),
@@ -838,11 +841,15 @@ const taskOperations = {
     expectedWorkspaceRevision: revision.nullable().optional(),
     intent: intentSchema,
   }),
-  list: operation({ action: z.literal("list") }),
+  list: operation({
+    action: z.literal("list"),
+    status: z.enum(["open", "closed", "all"]).optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+  }),
   inspect: operation({
     action: z.literal("inspect"),
     ...taskId,
-    view: z.enum(["summary", "full"]),
+    view: z.enum(["summary", "full"]).optional(),
   }),
   revise: operation({
     action: z.literal("revise"),
@@ -870,7 +877,7 @@ const taskOperations = {
     ...taskId,
     ...revisions,
     expectedWorkspaceRevision: revision.optional(),
-    authorityRefs: z.array(refSchema),
+    authorityRefs: z.array(refSchema).optional(),
   }),
   close: operation({
     action: z.literal("close"),

package/src/core/task-engine.ts

@@ -29,6 +29,7 @@ import {
   type Result,
   type Scope,
   type TaskRecord,
+  type TaskListItem,
   type TaskSummary,
   type TaskView,
   type Utc,
@@ -152,6 +153,7 @@ type WorkerAuthority = {
   expectedWorkspaceRevision: string;
   state: NativeWorkerObservation["state"];
   session: NativeWorkerObservation["session"];
+  report: NativeWorkerObservation["report"] | null;
   provenance: Provenance;
   owner: object;
   store: TaskStore;
@@ -280,6 +282,7 @@ const verifyNativeWorker = (
     expectedWorkspaceRevision: expected.expectedWorkspaceRevision,
     state: expected.state,
     session: expected.session,
+    report: expected.report ?? null,
     provenance: result.data,
     ...binding,
   });
@@ -305,7 +308,8 @@ const takeWorker = (
     value.expectedRevision !== expected.expectedRevision ||
     value.expectedWorkspaceRevision !== expected.expectedWorkspaceRevision ||
     value.state !== expected.state ||
-    !sameValue(value.session, expected.session)
+    !sameValue(value.session, expected.session) ||
+    !sameValue(value.report, expected.report ?? null)
   )
     return null;
   return value;
@@ -361,6 +365,8 @@ const applyWorkerLifecycle = (input: ObserveWorkerLifecycleInput): Result<Entry<
     return failure("invalid_transition", "worker already has an observed session");
   if (notStarted && !["dispatching", "cancelling"].includes(entry.data.state))
     return failure("invalid_transition", "worker launch was not claimed");
+  if (input.report && input.state !== "stopped")
+    return failure("invalid_input", "worker reports require a stopped worker");
   if (
     (input.state === "running" ||
       input.state === "cancelling" ||
@@ -383,6 +389,7 @@ const applyWorkerLifecycle = (input: ObserveWorkerLifecycleInput): Result<Entry<
       ...entry.data,
       state: terminalCancel ? ("cancelling" as const) : input.state,
       session: input.session,
+      report: entry.data.report ?? input.report ?? null,
     },
   } satisfies Entry<Worker>;
   const shouldClear =
@@ -402,6 +409,7 @@ const applyWorkerLifecycle = (input: ObserveWorkerLifecycleInput): Result<Entry<
   if (
     entry.data.state === nextEntry.data.state &&
     sameValue(entry.data.session, input.session) &&
+    sameValue(entry.data.report, nextEntry.data.report) &&
     !shouldClear &&
     !shouldUncertain
   )
@@ -858,7 +866,7 @@ export class WorkitCore {
     });
   }
 
-  task(request: unknown): Result<TaskSummary | TaskSummary[] | TaskView> {
+  task(request: unknown): Result<TaskSummary | TaskListItem[] | TaskView> {
     const root = this.contextRootError();
     if (!root.ok) return root as Result<never>;
     const parsed = parseOperation("task", request);
@@ -887,20 +895,43 @@ export class WorkitCore {
       case "list": {
         const listed = this.store.listTasks();
         if (!listed.ok) return listed as Result<never>;
-        const summaries: TaskSummary[] = [];
-        for (const task of listed.data) {
-          const summary = this.summary(task);
-          if (!summary.ok) return summary;
-          summaries.push(summary.data);
-        }
-        return success(null, null, summaries);
+        const status = input.status ?? "open";
+        const limit = input.limit ?? 20;
+        const selected = listed.data
+          .filter((task) =>
+            status === "all"
+              ? true
+              : status === "closed"
+                ? task.status === "closed"
+                : task.status !== "closed",
+          )
+          .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+          .slice(0, limit);
+        if (selected.length === 0) return success(null, null, []);
+        const workspace = this.store.readWorkspace();
+        if (!workspace.ok) return workspace as Result<never>;
+        if (!workspace.data) return failure("not_found", "workspace not found");
+        const tasks = selected.map((task): TaskListItem => ({
+          id: task.id,
+          revision: task.revision,
+          workspaceRevision: workspace.data!.revision,
+          createdAt: task.createdAt,
+          updatedAt: task.updatedAt,
+          runtime: task.runtime ?? null,
+          objective: task.intent.data.objective,
+          status: task.status,
+          closure: task.closure,
+          progress: task.progress,
+          writer: task.status === "closed" ? null : workspace.data!.writer,
+        }));
+        return success(null, null, tasks);
       }
       case "inspect": {
         const task = this.store.readTask(input.taskId);
         if (!task.ok) return task as Result<never>;
         const helper = this.helperTaskGuard(task.data, true);
         if (!helper.ok) return helper as Result<never>;
-        if (input.view === "summary") return this.summary(task.data);
+        if ((input.view ?? "summary") === "summary") return this.summary(task.data);
         return this.view(task.data);
       }
       case "pause":
@@ -1344,11 +1375,14 @@ export class WorkitCore {
       const evaluations = evaluateEvidence(task.data, current.data);
       const verified = evidence.some((entry) => {
         const evaluation = evaluations.find((item) => item.evidenceId === entry.id);
-        return findingVerificationPasses(finding.data.candidateId, {
-          kind: entry.data.kind,
-          candidateId: entry.data.candidateId,
-          status: evaluation?.status ?? "missing",
-        });
+        return (
+          entry.recordedAt >= finding.recordedAt &&
+          findingVerificationPasses(finding.data.candidateId, {
+            kind: entry.data.kind,
+            candidateId: entry.data.candidateId,
+            status: evaluation?.status ?? "missing",
+          })
+        );
       });
       if (!verified)
         return failure("permission_denied", "fixed findings require passing verification evidence");
@@ -1451,7 +1485,18 @@ export class WorkitCore {
       if (task.data.status !== "active")
         return failure("invalid_transition", "paused or closed tasks cannot assign workers");
       if (!bindingCovers(task.data.intent.data.scope, input.assignment.scope))
-        return failure("permission_denied", "worker assignment is outside task scope");
+        return failure("permission_denied", "worker assignment is outside task scope", {
+          fields: [
+            {
+              path: "assignment.scope",
+              reason: `paths ${JSON.stringify(input.assignment.scope.paths)} must be contained by lead paths ${JSON.stringify(task.data.intent.data.scope.paths)}`,
+            },
+            {
+              path: "task.intent.scope",
+              reason: `lead paths are ${JSON.stringify(task.data.intent.data.scope.paths)}`,
+            },
+          ],
+        });
       if (
         input.assignment.decisionIds.some(
           (id: string) => !task.data.decisions.some((entry) => entry.id === id),
@@ -1739,7 +1784,15 @@ export class WorkitCore {
                   ...item,
                   recordedAt: mutation.now,
                   provenance: attested.data,
-                  data: { ...item.data, state: "dispatching" as const },
+                  data: {
+                    ...item.data,
+                    state: "dispatching" as const,
+                    coordinator: {
+                      kind: "host" as const,
+                      host: this.context.caller.host,
+                      handle: this.context.caller.actor,
+                    },
+                  },
                 }
               : item,
           ),
@@ -1828,6 +1881,7 @@ export class WorkitCore {
         expectedWorkspaceRevision: input.expectedWorkspaceRevision,
         state: "stopped",
         session: null,
+        report: null,
         provenance: attested.data,
         owner: this.authorityOwner,
         store: this.store,
@@ -2205,11 +2259,16 @@ export class WorkitCore {
     const workspace = this.store.readWorkspace();
     if (!workspace.ok) return workspace as Result<never>;
     if (!workspace.data) return failure("not_found", "workspace not found");
-    const current = captureCandidate(this.store.root, task.intent.data.scope, environment());
+    const historical = task.status === "closed" ? task.candidates.at(-1) : undefined;
+    const current = historical
+      ? success(null, null, historical)
+      : captureCandidate(this.store.root, task.intent.data.scope, environment());
     if (!current.ok) return current as Result<never>;
+    const evaluationWorkspace =
+      task.status === "closed" ? { ...workspace.data, writer: null } : workspace.data;
     const requirements = evaluateRequirements(
       task,
-      workspace.data,
+      evaluationWorkspace,
       this.context.capabilities,
       current.data,
       this.store.root,
@@ -2228,7 +2287,7 @@ export class WorkitCore {
       progress: task.progress,
       policy: task.policy,
       requirements,
-      writer: workspace.data.writer,
+      writer: evaluationWorkspace.writer,
     });
   }
 
@@ -2236,11 +2295,16 @@ export class WorkitCore {
     const workspace = this.store.readWorkspace();
     if (!workspace.ok) return workspace as Result<never>;
     if (!workspace.data) return failure("not_found", "workspace not found");
-    const current = captureCandidate(this.store.root, task.intent.data.scope, environment());
+    const historical = task.status === "closed" ? task.candidates.at(-1) : undefined;
+    const current = historical
+      ? success(null, null, historical)
+      : captureCandidate(this.store.root, task.intent.data.scope, environment());
     if (!current.ok) return current as Result<never>;
+    const evaluationWorkspace =
+      task.status === "closed" ? { ...workspace.data, writer: null } : workspace.data;
     const requirements = evaluateRequirements(
       task,
-      workspace.data,
+      evaluationWorkspace,
       this.context.capabilities,
       current.data,
       this.store.root,
@@ -2248,7 +2312,7 @@ export class WorkitCore {
     );
     return success(task.revision, workspace.data.revision, {
       task,
-      workspace: workspace.data,
+      workspace: evaluationWorkspace,
       capabilities: this.context.capabilities,
       requirements,
       evidence: evaluateEvidence(task, current.data),
@@ -2357,8 +2421,6 @@ export class WorkitCore {
       (status === "active" && task.data.status !== "paused")
     )
       return failure("invalid_transition", `cannot transition ${task.data.status} to ${status}`);
-    if (status === "active" && input.authorityRefs.length === 0)
-      return failure("permission_denied", "resuming a task requires authority references");
     const workspace = this.store.readWorkspace();
     if (!workspace.ok) return workspace as Result<never>;
     if (!workspace.data) return failure("not_found", "workspace not found");
@@ -2403,7 +2465,7 @@ export class WorkitCore {
         )
       )
         return failure("recovery_required", "imported task requires resume reconciliation");
-      if (!validResumeApproval(task.data, workspace.data, input.authorityRefs, this.context))
+      if (!validResumeApproval(task.data, workspace.data, input.authorityRefs ?? [], this.context))
         return failure("permission_denied", "imported resume requires native destination approval");
       resumeCandidate = current.data.candidate;
     }
@@ -2552,9 +2614,7 @@ export class WorkitCore {
         success(context.revision, null, {
           ...value,
           status: "closed",
-          candidates: value.candidates.some((item) => item.id === withCandidate.id)
-            ? value.candidates
-            : [...value.candidates, withCandidate],
+          candidates: taskForView.candidates,
           closure: {
             outcome: closure.data.outcome,
             at: context.now,

package/src/core/task-evaluation.ts

@@ -412,17 +412,15 @@ export const resolveBinding = (
   };
 };
 
-/** One shared verification predicate for fixed findings: a passed
- * check/review counts when the finding is unscoped or the evidence is
- * bound to the finding's candidate. Used by the auto-reopen scan, the
- * resolve gate, and closure — one predicate, one error code each. */
+/** Evidence evaluation establishes freshness against the current tree;
+ * the finding's original candidate identifies where the defect was found. */
 export const findingVerificationPasses = (
   findingCandidateId: string | null | undefined,
   evidence: { kind: string; candidateId: string | null | undefined; status: string },
 ): boolean =>
   evidence.status === "passed" &&
   (evidence.kind === "check" || evidence.kind === "review") &&
-  ((findingCandidateId ?? null) === null || evidence.candidateId === findingCandidateId);
+  ((findingCandidateId ?? null) === null || evidence.candidateId != null);
 const applicableDecision = (
   task: TaskRecord,
   workspace: WorkspaceRecord,

package/src/core/workers.ts

@@ -11,6 +11,7 @@ import {
   type Revision,
   type TaskRecord,
   type Worker,
+  type WorkerReport,
   type WorkspaceRecord,
 } from "./task-contract";
 import { TaskStore } from "./task-store";
@@ -31,6 +32,7 @@ export type NativeWorkerObservation = {
   expectedWorkspaceRevision: Revision;
   state: WorkerState;
   session: HostSession | null;
+  report?: WorkerReport;
   observation: unknown;
 };
 
@@ -132,6 +134,21 @@ export type ProductWriteInput = {
   store?: TaskStore;
 };
 
+export const currentWriterOwnsTask = (
+  task: TaskRecord,
+  workspace: WorkspaceRecord,
+  caller: { host: string; actor: string },
+): boolean => {
+  const owner = workspace.writer?.owner;
+  return (
+    task.status === "active" &&
+    task.workspaceId === workspace.id &&
+    owner?.taskId === task.id &&
+    owner.session.host === caller.host &&
+    owner.session.handle === caller.actor
+  );
+};
+
 /** Check the authoritative workspace owner and the caller's role. File paths
  *  are host-policy territory: only malformed paths are rejected here, never
  *  out-of-scope ones. */

package/src/core.ts

@@ -125,6 +125,7 @@ export {
   externalActionRef,
   externalActionDescriptor,
   externalActionHelp,
+  planReservationLength,
   externalActionRequest,
   matchesNativeExternalAction,
   nativeExternalActionObservation,