@amistio/cli 0.1.51 → 0.1.53

package/README.md

@@ -37,7 +37,8 @@ Tool session reuse is bounded. One-shot tool sessions close after successful com
 
 Repository brain auto-sync is disabled until the repository link option is enabled in the app. After pairing, run `amistio sync watch` from the paired checkout to push recognized external brain Markdown/MDX files and explicit HTML artifacts under `docs/html/<area>/`, including local ADRs, plans, prompts, workflows, memory, context, architecture, and feature docs, to the app for review. Markdown is the default generation format; HTML appears only when a runner or user explicitly generated an HTML artifact. `amistio run --watch` also runs the same cycle between work polls when the option is enabled. The CLI skips templates, unsupported paths, oversized files, unchanged managed docs, and conflicts instead of silently overwriting web state.
 
-Repository autopilot is disabled until the repository link option is enabled in the app. When enabled, Amistio can attach an audited low-risk autopilot authorization to eligible runner work, including generated brain approval, impact preview, issue diagnosis, security posture scan, app evaluation cleanup, low-risk implementation handoff, safe requeue, and implementation verification. The Runner panel shows and updates safe work scopes, allowed candidate types, max risk, optional runner binding, daily/concurrent/failure budgets, expiry/review/cooldown windows, and pause state. The CLI shows authorization id, candidate id/type, outcome, policy version, and work kind in `amistio work list`, claim logs, runner prompts, and milestone activity. Autopilot does not widen local runner permissions: pairing, supported work kinds, runner identity, Git worktree isolation, redaction, local-tool permission controls, and unsafe/review-required/blocked/repeated-blocker/paused/budget stops still apply.
+Repository autonomy is disabled until the repository link option is enabled in the app. When enabled, Amistio can attach an audited low-risk autonomy-contract authorization to eligible runner work, including generated brain approval, impact preview, issue diagnosis, security posture scan, app evaluation cleanup, Test scans, implementation Test gates, low-risk implementation handoff, safe requeue, and implementation verification. The Runner panel shows and updates safe work scopes, allowed candidate types, max risk, optional runner binding, daily/concurrent/failure budgets, expiry/review/cooldown windows, and pause state. The CLI shows authorization id, candidate id/type, outcome, policy version, and work kind in `amistio work list`, claim logs, runner prompts, and milestone activity. Autonomy does not widen local runner permissions: pairing, supported work kinds, runner identity, Git worktree isolation, redaction, local-tool permission controls, and unsafe/review-required/blocked/repeated-blocker/paused/budget stops still apply.
+Organization workspace autonomy contracts can be changed only by `org:admin` members.
 
 After pairing, confirm that at least one local AI tool is available:
 
@@ -59,7 +60,7 @@ amistio run --watch --execution-profile hostWorktree
 amistio run --watch --execution-profile hostWorktreeWithSetup --setup-package-manager-install
 amistio run --watch --execution-profile dockerWorkspace
 amistio run --watch --tool opencode --provider anthropic --model-id claude-opus-4.6 --reasoning-effort xhigh
-amistio run --watch --max-concurrent-work 2 --tool opencode
+amistio run --watch --max-concurrent-work 1 --tool opencode
 amistio run --watch --background --tool opencode
 AMISTIO_HOST_HELPER_PATH=$(command -v amistio-host-helper) amistio host-helper status
 AMISTIO_HOST_HELPER_PATH=$(command -v amistio-host-helper) amistio host-helper conformance
@@ -82,17 +83,25 @@ When `--tool codex` uses the Codex SDK, intermediate progress can be quiet until
 
 `amistio runner smoke-session-lifecycle` runs a local no-claim smoke for the runner tool-session lifecycle. It does not contact the API, claim production work, inspect source, or mutate local runner state; it verifies that completed one-shot sessions close, active sessions are treated as in use, stale sessions are not selected for reuse, and fresh related reusable sessions can still continue.
 
-The runner advertises its supported work kinds in heartbeats. Current runners can claim read-only `projectContextRefresh` jobs from the workspace Context panel and create due runner-driven refreshes when no fresh approved map exists. Context refreshes inspect the paired checkout locally without modifying files and submit only bounded summaries, slices, entities, relations, safe citations, confidence, freshness, and repo-relative paths. If a submitted context refresh contains unsafe evidence, unsafe paths, or a map too large to store safely, Amistio marks the refresh failed with a safe reason instead of storing the rejected raw result. Approved maps are reused as context packs for source-aware assistant and impact-preview work. Current runners can also claim read-only issue diagnosis jobs from the web Issues panel, generate root-cause analysis and a proposed fix, and submit that result without modifying source. They can claim manual read-only `appEvaluationScan` jobs from the workspace Evaluate panel and create at most one due hourly evaluation during normal watch/background polling when app evaluation is enabled for the repository link. Evaluation results contain bounded summaries, safe evidence, suggested actions, lifecycle proposals, and repo-relative paths only. Current runners can also claim manual read-only `securityPostureScan` jobs from the workspace Security panel and create due daily posture checks during normal watch/background polling. Security scan results contain bounded summaries, standard references, safe evidence, and repo-relative paths only. Current runners can claim manual read-only `testQualityScan` jobs from the workspace Test panel and create one due daily Test scan per repository when Test quality is enabled. Test scans run only existing lint, typecheck, test, coverage, build, or verify commands and submit bounded command summaries, coverage summaries, safe findings, blocked reasons, warnings, and repo-relative paths. Missing tests, missing coverage, low coverage, failing checks, flaky tests, and test gaps create reviewable plan-backed findings in the app. Current runners also claim `implementationTestGate` jobs before implementation completion, PR handoff, or runner-managed push; a passing gate is required unless the web Test panel records an audited override. Blocked implementation Test gates submit structured Test findings, such as `blockedEnvironment`, with safe evidence, a suggested action, and a verification plan. Current runners can claim read-only `implementationVerification` jobs from Tasks to prove whether completed implementation work actually landed; verification submits bounded acceptance-criteria evidence, checks, gaps, outcome, and recommendation without mutating source. Source, secrets, environment variables, command lines, process lists, credentials, provider sessions, and arbitrary local paths stay local. Implementation or cleanup is queued separately only after the user approves an issue analysis, app evaluation finding, security remediation plan, or Test quality plan in the app.
+The runner advertises its supported work kinds in heartbeats. Current runners can claim read-only `projectContextRefresh` jobs from the workspace Context panel and create due runner-driven refreshes when no fresh approved map exists. Context refreshes inspect the paired checkout locally without modifying files and submit only bounded summaries, slices, entities, relations, safe citations, confidence, freshness, and repo-relative paths. If a submitted context refresh contains unsafe evidence, unsafe paths, or a map too large to store safely, Amistio marks the refresh failed with a safe reason instead of storing the rejected raw result. Approved maps are reused as context packs for source-aware assistant and impact-preview work.
+
+Current runners can also claim read-only issue diagnosis jobs from the web Issues panel, generate root-cause analysis and a proposed fix, and submit that result without modifying source. They can claim manual read-only `appEvaluationScan` jobs from the workspace Evaluate panel and create adaptive runner-driven evaluations during normal watch/background polling when app evaluation is enabled for the repository link; fresh clean evidence is skipped when there is no active app-evaluation finding to act on. Evaluation results contain bounded summaries, safe evidence, suggested actions, lifecycle proposals, and repo-relative paths only. Current runners can also claim manual read-only `securityPostureScan` jobs from the workspace Security panel and create due daily posture checks during normal watch/background polling. Security scan results contain bounded summaries, standard references, safe evidence, and repo-relative paths only.
+
+Current runners can claim manual read-only `testQualityScan` jobs from the workspace Test panel and create one due daily Test scan per repository when Test quality is enabled. Under a repository autonomy contract, `testQualityScan` and `implementationTestGate` are delegated evidence work instead of another approval interruption. Test scans run only existing lint, typecheck, test, coverage, build, or verify commands and submit bounded command summaries, coverage summaries, safe findings, blocked reasons, warnings, and repo-relative paths. Missing tests, missing coverage, low coverage, failing checks, flaky tests, and test gaps create autonomous repair work when delegated or reviewable plan-backed findings when not. Current runners also claim `implementationTestGate` jobs before implementation completion, PR handoff, or runner-managed push; a passing gate is required unless the web Test panel records an audited override. Blocked implementation Test gates submit structured Test findings, such as `blockedEnvironment`, with safe evidence, a suggested action, and a verification plan. Current runners can claim read-only `implementationVerification` jobs from Tasks to prove whether completed implementation work actually landed; verification submits bounded acceptance-criteria evidence, checks, gaps, outcome, and recommendation without mutating source. Source, secrets, environment variables, command lines, process lists, credentials, provider sessions, and arbitrary local paths stay local. Implementation or cleanup is queued separately only when a repository autonomy contract or explicit approval authorizes it.
+
+Runner-driven app evaluation, Test quality, and Security posture signals skip fresh clean evidence when no active finding, failed/blocked gate, or exception needs action. If an implementation Test gate fails or blocks under an enabled repository autonomy contract, Amistio queues one deduped low-risk test-repair implementation work item so the runner can continue from validation failure into repair instead of waiting for another approval.
 
 Approved implementation work uses Git as the handoff boundary. During worktree preflight, the runner locally copies eligible ignored root dotenv files such as `.env.local` or `.env.test.local` from the paired checkout into the implementation worktree when the target is missing and ignored, so local tests can use the same machine configuration. Dotenv values, variable names, file contents, and local paths are not uploaded to Amistio, and copied dotenv files stay ignored so PR handoff does not commit them. Before local AI/tool execution starts, implementation work checks PR handoff readiness: GitHub remote support, default-branch fetch, Git commit identity, local `gh` authentication, and repository visibility. After the local tool completes successfully, the runner materializes approved Markdown, MDX, and HTML project-brain artifacts for the same work scope into the isolated worktree before final Git status, then classifies the final diff. Source-implementation work must include source, config, test, or other implementation-affecting changes before the runner opens or reuses a PR. If only project-brain or documentation artifacts changed, Amistio completes the work as no implementation produced instead of opening a misleading implementation PR. App-evaluation proof and lifecycle-cleanup actions are queued with explicit docs-only expected outcomes, so safe proof notes and plan metadata updates can create docs-only PRs without being mislabeled as source implementation. Other explicit docs-only work can also create docs-only PRs. No-change completion requires no source changes and no approved artifact changes, and runner-created no-change worktrees are removed after final clean checks. Prepare the runner machine with Git commit identity, fetch/push permission to the linked remote, and `gh auth status`. If artifact materialization, commit, fetch/rebase, push, or PR creation fails, the work item is blocked with safe recovery choices; source files and patches are not uploaded to Amistio. The Work panel can queue scoped Retry handoff or Retry cleanup commands only to the runner that owns the preserved worktree for the same work item, branch, and worktree key. Retry handoff can publish a clean preserved local-only implementation commit without rerunning the implementation prompt. Rebase conflicts capture bounded repo-relative conflict files and try `git rebase --abort` so the implementation branch can be retried or manually reviewed without leaving an active rebase. Dirty, unmerged, or ambiguous worktrees are preserved rather than discarded.
 
 Failed or stale work can be requeued from the web Tasks panel. Requeue creates a new linked work attempt and preserves the original terminal attempt for audit history; Requeue safe sends one backend batch that recomputes safe candidates, reports already-active and skipped rows, and still uses linked attempts. Requeue is blocked while equivalent work is already active, when the paired runner does not advertise the needed work kind, or when the latest linked attempt repeats the same sanitized blocker fingerprint. Repeated runner setup, handoff, policy, verification, and worktree blockers require root-cause repair before another linked attempt. Completed implementation status is separate from proof: queue `implementationVerification` from Tasks when a plan needs source-aware evidence before cleanup or implementation status decisions.
 
+Patch-context failures are typed recovery states. If a local tool reports a stale `apply_patch` context miss, such as an expected-lines mismatch, the runner marks the work with patch-drift recovery metadata and safe next actions instead of uploading raw patch output or leaving a generic failed row. Retryable API failures during implementation finalization are staged in the user-level Amistio finalization outbox and replayed before the runner claims more work, so a transient `500` does not require rerunning the local AI tool. When completion queues a required implementation Test gate, the source-work finalization remains pending locally, compatible runners claim the gate before unrelated implementation work, and finalization replays after the gate passes.
+
 Runner setup and local-tool execution use bounded failure controls. During Git worktree preflight, `amistio run --watch` repairs safe stale Git registrations when the target worktree directory is missing and Git marks the registration prunable; dirty, present, or ambiguous worktrees are preserved. Other Git worktree preflight failures are retried by releasing the claim for another attempt, then fail the work item after `--max-preflight-attempts` attempts, defaulting to 3. Active local-tool runs renew the work lease, and `--tool-timeout-seconds` caps tool execution, defaulting to 1800 seconds.
 
 The environment doctor blocks work before local AI/tool execution when `git`, `node`, Corepack, the package manager, required package scripts, dependencies, setup allowlist, Docker, or the requested execution profile is not ready. Foreground, background, and startup-service runners accept `--execution-profile`; use `--setup-package-manager-install` with `hostWorktreeWithSetup` when the runner may run the fixed package-manager install step in the execution worktree. Work and Runner surfaces receive sanitized profile/readiness metadata only; raw host paths, command lines, environment values, and secrets are not uploaded. Watch mode also performs a Git PATH preflight before auto-sync or work claiming. If the runner reports that Git is not available to the runner PATH, install Git or restart the foreground, background, or startup-service runner from an environment where `git --version` works. On macOS, service and GUI-launched runner environments may not inherit the same PATH as an interactive shell, so restart or reinstall the service after changing PATH.
 
-Runner watch mode defaults to one claim lane. `--max-concurrent-work <count>` enables bounded parallel claim lanes for one paired runner, capped at 4. The server enforces one active lease per runner lane, honors the advertised capacity, and keeps equivalent implementation scopes serialized through Git worktree locks; use separate lanes for independent work, not multiple attempts at the same ADR scope.
+Runner watch mode defaults to bounded parallel claim lanes, capped at 4. `--max-concurrent-work <count>` lowers or explicitly sets the advertised lane count; use `--max-concurrent-work 1` only when you intentionally want serial execution. The server enforces one active lease per runner lane, honors the advertised capacity, and keeps equivalent implementation scopes serialized through Git worktree locks; use separate lanes for independent work, not multiple attempts at the same ADR scope.
 
 Watch mode prints a completed-work success once per work item, keeps fresh completion visible briefly, and returns old completed work to the ready state when no queued, running, blocked, failed, review, or runner-readiness action needs attention.
 
@@ -102,7 +111,7 @@ If watch mode reports that the runner was forgotten by the server, run `amistio
 
 App-evaluation and impact-preview result finalization rejections print safe validation paths and preserve the local finalization evidence without exposing raw source or secrets. If a structured app-evaluation or impact-preview result is rejected, update and restart the runner, confirm the web/API deployment is current, and retry before acting on cleanup, implementation, or risk recommendations. Accepted impact-preview results that cannot be stored safely are marked failed with a bounded reason instead of uploading raw source or secrets.
 
-When a newer manual or hourly app evaluation is queued for the same repository, Amistio marks older queued or running app-evaluation scans stale and closes their scan work without deleting historical scans, findings, or generated plans.
+When a newer manual or adaptive app evaluation is queued for the same repository, Amistio marks older queued or running app-evaluation scans stale and closes their scan work without deleting historical scans, findings, or generated plans. Runner-driven evaluation skips fresh clean evidence instead of spending another hourly scan when there is no active app-evaluation finding to act on.
 
 When brain generation or plan revision output is parsed but the Amistio API is temporarily unavailable during finalization, the runner keeps a safe pending result envelope in user-level Amistio config and replays it before claiming more work. The envelope uses a stable idempotency key and does not store raw tool stdout, provider sessions, credentials, or arbitrary local paths.
 

package/dist/index.js

@@ -157,7 +157,7 @@ var autopilotGuardCheckSchema = z.object({
 var implementationExpectedOutcomeSchema = z.enum(["sourceImplementation", "docsOnly", "analysisOnly", "verificationOnly"]);
 var implementationHandoffStatusSchema = z.enum(["notStarted", "noChanges", "prReady", "blocked", "failed", "noImplementationProduced"]);
 var implementationHandoffCleanupStatusSchema = z.enum(["notApplicable", "pending", "completed", "failed"]);
-var implementationHandoffRecoveryCategorySchema = z.enum(["noChangeCleaned", "rebaseConflict", "dirtyWorktree", "unresolvedConflicts", "providerBlocked", "cleanupRetryAvailable", "manualReview", "artifactBlocked", "nonGithubProvider"]);
+var implementationHandoffRecoveryCategorySchema = z.enum(["noChangeCleaned", "rebaseConflict", "dirtyWorktree", "unresolvedConflicts", "providerBlocked", "cleanupRetryAvailable", "manualReview", "artifactBlocked", "nonGithubProvider", "patchDrift"]);
 var implementationHandoffRecoveryActionSchema = z.enum(["retryHandoff", "requeueFreshAttempt", "keepForManualRepair", "cleanNoChangeWorktree", "markSupersededNoChanges", "exportHandoffDetails", "retryCleanup"]);
 var implementationHandoffRebaseAbortStatusSchema = z.enum(["notAttempted", "succeeded", "failed", "notApplicable"]);
 var safeRepoPathSchema = z.string().trim().min(1).max(300).refine((value) => {
@@ -3538,6 +3538,47 @@ var durableResultFinalizationEntrySchema = z4.object({
   updatedAt: z4.string().min(1),
   lastError: z4.string().optional()
 }).and(durableResultMutationSchema);
+var implementationFinalizationTelemetrySchema = z4.object({
+  message: z4.string().trim().min(1).max(1e3).optional(),
+  tool: z4.string().trim().min(1).max(120).optional(),
+  durationMs: z4.number().int().nonnegative().optional(),
+  sessionPolicy: sessionPolicySchema.optional(),
+  sessionGroupKey: z4.string().trim().min(1).max(200).optional(),
+  toolSessionId: z4.string().trim().min(1).max(200).optional(),
+  sessionDecision: sessionDecisionSchema.optional(),
+  sessionDecisionReason: z4.string().trim().min(1).max(600).optional(),
+  claimLaneId: z4.string().trim().min(1).max(80).optional(),
+  claimLeaseId: z4.string().trim().min(1).max(200).optional(),
+  controllingAdrId: z4.string().trim().min(1).max(200).optional(),
+  implementationScopeId: z4.string().trim().min(1).max(200).optional(),
+  executionBranch: z4.string().trim().min(1).max(200).optional(),
+  executionWorktreeKey: z4.string().trim().min(1).max(200).optional(),
+  isolationMode: z4.enum(["none", "gitWorktree"]).optional(),
+  machineId: z4.string().trim().min(1).max(200).optional(),
+  repositoryLockId: z4.string().trim().min(1).max(200).optional(),
+  blockerReason: z4.string().trim().min(1).max(1e3).optional(),
+  error: z4.string().trim().min(1).max(1200).optional(),
+  implementationHandoff: implementationHandoffSchema.optional()
+}).strict();
+var implementationFinalizationEntrySchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("implementationFinalization"),
+  status: z4.enum(["pending", "terminal"]),
+  accountId: z4.string().min(1),
+  projectId: z4.string().min(1),
+  repositoryLinkId: z4.string().min(1),
+  runnerId: z4.string().min(1),
+  workItemId: z4.string().min(1),
+  workKind: z4.enum(["implementation", "promptBatch"]),
+  attempt: z4.number().int().nonnegative(),
+  idempotencyKey: z4.string().min(1),
+  finalStatus: workStatusSchema,
+  telemetry: implementationFinalizationTelemetrySchema,
+  retryCount: z4.number().int().nonnegative(),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  lastError: z4.string().optional()
+});
 function defaultResultFinalizationOutboxDir() {
   return path5.join(os2.homedir(), ".config", "amistio", "result-finalizations");
 }
@@ -3580,6 +3621,26 @@ function createDurableResultFinalizationEntry(input, now = (/* @__PURE__ */ new
     updatedAt: now
   });
 }
+function createImplementationFinalizationEntry(input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return implementationFinalizationEntrySchema.parse({
+    schemaVersion: 1,
+    kind: "implementationFinalization",
+    status: "pending",
+    accountId: input.accountId,
+    projectId: input.projectId,
+    repositoryLinkId: input.repositoryLinkId,
+    runnerId: input.runnerId,
+    workItemId: input.workItemId,
+    workKind: input.workKind,
+    attempt: input.attempt,
+    idempotencyKey: input.idempotencyKey,
+    finalStatus: input.finalStatus,
+    telemetry: input.telemetry,
+    retryCount: 0,
+    createdAt: now,
+    updatedAt: now
+  });
+}
 async function upsertBrainGenerationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
   await mkdir5(outboxDir, { recursive: true });
   const filePath = brainGenerationFinalizationEntryPath(entry, outboxDir);
@@ -3620,6 +3681,14 @@ async function upsertDurableResultFinalizationEntry(entry, outboxDir = defaultRe
 `, "utf8");
   await rename(tempPath, filePath);
 }
+async function upsertImplementationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await mkdir5(outboxDir, { recursive: true });
+  const filePath = implementationFinalizationEntryPath(entry, outboxDir);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile4(tempPath, `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+  await rename(tempPath, filePath);
+}
 async function listPendingDurableResultFinalizations(scope, outboxDir = defaultResultFinalizationOutboxDir()) {
   const entries = await readdir2(outboxDir, { withFileTypes: true }).catch((error) => {
     if (error.code === "ENOENT") return [];
@@ -3644,6 +3713,30 @@ async function listPendingDurableResultFinalizations(scope, outboxDir = defaultR
   }
   return pending.sort((first, second) => Date.parse(first.createdAt) - Date.parse(second.createdAt));
 }
+async function listPendingImplementationFinalizations(scope, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const entries = await readdir2(outboxDir, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  const pending = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = path5.join(outboxDir, entry.name);
+    let raw;
+    try {
+      raw = JSON.parse(await readFile3(filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    const parsed = implementationFinalizationEntrySchema.safeParse(raw);
+    if (!parsed.success) continue;
+    const value = parsed.data;
+    if (value.status !== "pending") continue;
+    if (value.accountId !== scope.accountId || value.projectId !== scope.projectId || value.repositoryLinkId !== scope.repositoryLinkId || value.runnerId !== scope.runnerId) continue;
+    pending.push(value);
+  }
+  return pending.sort((first, second) => Date.parse(first.createdAt) - Date.parse(second.createdAt));
+}
 async function markBrainGenerationFinalizationRetry(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
   const updated = brainGenerationFinalizationEntrySchema.parse({
     ...entry,
@@ -3689,9 +3782,33 @@ async function markDurableResultFinalizationTerminal(entry, error, outboxDir = d
   await upsertDurableResultFinalizationEntry(updated, outboxDir);
   return updated;
 }
+async function markImplementationFinalizationRetry(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = implementationFinalizationEntrySchema.parse({
+    ...entry,
+    status: "pending",
+    retryCount: entry.retryCount + 1,
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertImplementationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function markImplementationFinalizationTerminal(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = implementationFinalizationEntrySchema.parse({
+    ...entry,
+    status: "terminal",
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertImplementationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
 async function deleteDurableResultFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
   await rm(durableResultFinalizationEntryPath(entry, outboxDir), { force: true });
 }
+async function deleteImplementationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await rm(implementationFinalizationEntryPath(entry, outboxDir), { force: true });
+}
 function brainGenerationFinalizationEntryPath(entry, outboxDir) {
   return path5.join(outboxDir, `${brainGenerationFinalizationEntryKey(entry)}.json`);
 }
@@ -3706,6 +3823,13 @@ function durableResultFinalizationEntryKey(entry) {
   const hash = createHash2("sha256").update([entry.accountId, entry.projectId, entry.repositoryLinkId, entry.runnerId, entry.workItemId, String(entry.attempt), entry.idempotencyKey, entry.resultKind].join("\0")).digest("hex").slice(0, 32);
   return `runner-result-${hash}`;
 }
+function implementationFinalizationEntryPath(entry, outboxDir) {
+  return path5.join(outboxDir, `${implementationFinalizationEntryKey(entry)}.json`);
+}
+function implementationFinalizationEntryKey(entry) {
+  const hash = createHash2("sha256").update([entry.accountId, entry.projectId, entry.repositoryLinkId, entry.runnerId, entry.workItemId, String(entry.attempt), entry.idempotencyKey].join("\0")).digest("hex").slice(0, 32);
+  return `implementation-finalization-${hash}`;
+}
 function truncateLocalError(error) {
   const trimmed = error.trim();
   return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
@@ -5099,11 +5223,20 @@ async function detectRunnerProviderCatalog(adapter) {
   return mergeProviderCatalogs(adapter.providerCatalog, localOpencodeConfigCatalog);
 }
 function localOpencodeProviderConfigPaths() {
-  return [
+  const configPaths = [
     path7.join(os3.homedir(), ".config", "opencode", "opencode.json"),
-    path7.join(os3.homedir(), ".config", "opencode", "config.json"),
-    path7.join(process.cwd(), "opencode.json")
+    path7.join(os3.homedir(), ".config", "opencode", "config.json")
   ];
+  const cwd = safeProcessCwd();
+  if (cwd) configPaths.push(path7.join(cwd, "opencode.json"));
+  return configPaths;
+}
+function safeProcessCwd() {
+  try {
+    return process.cwd();
+  } catch {
+    return void 0;
+  }
 }
 async function loadLocalOpencodeProviderConfigCatalog(configPaths = localOpencodeProviderConfigPaths()) {
   for (const configPath of configPaths) {
@@ -6112,6 +6245,30 @@ async function checkRunnerWatchGitPreflight(options) {
   return { status: "blocked", exitCode: 1, message, readiness: readiness2 };
 }
 
+// src/runner-patch-drift.ts
+var patchDriftPatterns = [
+  { signature: "applyPatchVerificationFailed", pattern: /apply_patch\s+verification\s+failed/i },
+  { signature: "expectedLinesMissing", pattern: /failed\s+to\s+find\s+expected\s+lines/i },
+  { signature: "patchContextMismatch", pattern: /patch\s+context\s+(?:mismatch|drift)|stale\s+patch\s+context/i }
+];
+function classifyPatchDriftToolResult(result) {
+  if (result.exitCode === 0) return void 0;
+  return classifyPatchDriftText(`${result.stderr}
+${result.stdout}`);
+}
+function classifyPatchDriftText(output) {
+  for (const candidate of patchDriftPatterns) {
+    if (candidate.pattern.test(output)) {
+      return {
+        signature: candidate.signature,
+        message: "Patch context drift was detected; refresh context or queue a fresh linked attempt before retrying this implementation.",
+        summary: `Local patch application failed with ${candidate.signature}. The runner preserved bounded recovery metadata instead of storing raw patch output.`
+      };
+    }
+  }
+  return void 0;
+}
+
 // src/runner-watch-errors.ts
 var forgottenRunnerWatchMessage = "This runner was forgotten by the server. Start or pair a new runner from the Runner panel; this runner ID cannot heartbeat or claim work anymore.";
 async function handleRunnerWatchError(options) {
@@ -7904,6 +8061,7 @@ function createAppEvaluationScanPrompt(workItem, context) {
     "- When lifecycle metadata disagrees across indexes, frontmatter, feature specs, ADRs, and implementation evidence, cite the conflict and propose a metadata correction or verification step instead of archival/removal.",
     "- Check missing memory or workflow updates when repeated lessons or operational rules are visible.",
     "- Check release readiness, UX, accessibility, performance, reliability, and security-posture follow-through at a summary level.",
+    "- For security posture, do not treat implemented controls, documentation, remediation notes, or the presence of the Security workflow as proof that current live posture is fresh. Require a recent completed securityPostureScan/security snapshot or explicit runner-backed scan evidence; if it is missing, report a securityPosture finding that recommends refreshing posture evidence rather than source implementation.",
     "- For release, deploy, or publish readiness, do not treat the mere presence of a workflow, script, or documented verification gate as proof. If fresh successful root verification evidence is missing for the current release candidate, report releaseReadiness and recommend refreshing the gate before release actions.",
     "- Prefer repository-documented verification commands over ad hoc package-script inference.",
     "- For this Amistio monorepo, if plain Corepack pnpm fails before scripts with spawnSync pnpm ENOENT, retry the documented command corepack pnpm --config.verify-deps-before-run=false verify before declaring whole-app verification blocked.",
@@ -9501,6 +9659,7 @@ var exactLocalEnvironmentFiles = /* @__PURE__ */ new Set([".env", ".env.local",
 var localEnvironmentFilePattern = /^\.env\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*\.local$/;
 function needsGitWorktreeIsolation(workItem) {
   const workKind = workItem.workKind ?? "implementation";
+  if (workItem.implementationExpectedOutcome === "analysisOnly" || workItem.implementationExpectedOutcome === "verificationOnly") return false;
   return workKind === "implementation" || workKind === "promptBatch";
 }
 function resolveWorktreeIdentity(workItem) {
@@ -11281,7 +11440,7 @@ program.command("orchestrate").description("Update the Amistio control plane thr
     process.exitCode = result.exitCode;
   }
 });
-program.command("run").description("Claim and run approved Amistio work locally").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--runner-id <runnerId>", "Stable runner ID").option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--execution-profile <profile>", "Runner execution environment profile: hostWorktree, hostWorktreeWithSetup, or dockerWorkspace", parseRunnerExecutionEnvironmentProfile, defaultRunnerExecutionEnvironmentProfile).option("--setup-package-manager-install", "Allow hostWorktreeWithSetup to run the approved package-manager install command").option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--dry-run", "Claim work and print the generated execution prompt without running a tool").option("--watch", "Keep polling for approved work until stopped").option("--background", "Start a detached background runner that watches for approved work").option("--interval-seconds <seconds>", "Polling interval for --watch", parsePositiveInteger, 10).option("--max-iterations <count>", "Stop watch mode after this many polling attempts", parsePositiveInteger).option("--max-concurrent-work <count>", "Maximum approved work items to run in parallel in --watch mode", parsePositiveInteger, 1).option("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors while watching").action(async (options, command) => {
+program.command("run").description("Claim and run approved Amistio work locally").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--runner-id <runnerId>", "Stable runner ID").option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--execution-profile <profile>", "Runner execution environment profile: hostWorktree, hostWorktreeWithSetup, or dockerWorkspace", parseRunnerExecutionEnvironmentProfile, defaultRunnerExecutionEnvironmentProfile).option("--setup-package-manager-install", "Allow hostWorktreeWithSetup to run the approved package-manager install command").option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--dry-run", "Claim work and print the generated execution prompt without running a tool").option("--watch", "Keep polling for approved work until stopped").option("--background", "Start a detached background runner that watches for approved work").option("--interval-seconds <seconds>", "Polling interval for --watch", parsePositiveInteger, 10).option("--max-iterations <count>", "Stop watch mode after this many polling attempts", parsePositiveInteger).option("--max-concurrent-work <count>", "Maximum approved work items to run in parallel in --watch mode", parsePositiveInteger, MAX_CONCURRENT_RUNNER_WORK).option("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors while watching").action(async (options, command) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -11510,7 +11669,7 @@ runner.command("stop").description("Stop a background runner for the paired repo
   console.log(stopResult === "stopped" ? `Stopped background runner ${record.runnerId}.` : `Marked background runner ${record.runnerId} stopped; process was not running.`);
 });
 var runnerService = runner.command("service").description("Manage a user-level startup service for the paired runner");
-runnerService.command("install").description("Install a user-level startup service for this paired repository runner").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Stable runner ID").option("--tool <name>", "Local tool to use: auto, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--execution-profile <profile>", "Runner execution environment profile for the service runner", parseRunnerExecutionEnvironmentProfile, defaultRunnerExecutionEnvironmentProfile).option("--setup-package-manager-install", "Allow hostWorktreeWithSetup to run the approved package-manager install command").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--interval-seconds <seconds>", "Polling interval for the service runner", parsePositiveInteger, 10).option("--max-concurrent-work <count>", "Maximum approved work items to run in parallel in --watch mode", parsePositiveInteger, 1).option("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors").option("--dry-run", "Print the startup service descriptor without installing it").action(async (options) => {
+runnerService.command("install").description("Install a user-level startup service for this paired repository runner").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Stable runner ID").option("--tool <name>", "Local tool to use: auto, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--execution-profile <profile>", "Runner execution environment profile for the service runner", parseRunnerExecutionEnvironmentProfile, defaultRunnerExecutionEnvironmentProfile).option("--setup-package-manager-install", "Allow hostWorktreeWithSetup to run the approved package-manager install command").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--interval-seconds <seconds>", "Polling interval for the service runner", parsePositiveInteger, 10).option("--max-concurrent-work <count>", "Maximum approved work items to run in parallel in --watch mode", parsePositiveInteger, MAX_CONCURRENT_RUNNER_WORK).option("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors").option("--dry-run", "Print the startup service descriptor without installing it").action(async (options) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -11689,9 +11848,6 @@ async function runWatchIteration({ command, context, options, runnerId }) {
 function claimLaneIds(maxConcurrentWork) {
   return Array.from({ length: maxConcurrentWork }, (_, index) => index === 0 ? "default" : `lane_${index + 1}`);
 }
-function supportsConcurrentLocalToolExecution(toolConfig) {
-  return toolConfig.tool === "none" || toolConfig.effectiveInvocationChannel === "command" || toolConfig.effectiveTool === "custom";
-}
 function aggregateRunnerLaneResults(results) {
   const stopResult = results.find((result) => result.stopRunner);
   if (stopResult) return stopResult;
@@ -11802,7 +11958,7 @@ async function runNextWorkItem({
     ...explicitTool ? { explicitTool } : {},
     ...toolCommand ? { toolCommand } : {}
   });
-  const effectiveMaxConcurrentWork = supportsConcurrentLocalToolExecution(toolConfig) ? maxConcurrentWork : 1;
+  const effectiveMaxConcurrentWork = Math.min(Math.max(maxConcurrentWork, 1), MAX_CONCURRENT_RUNNER_WORK);
   const effectiveActiveClaimLaneIds = claimLaneIds(effectiveMaxConcurrentWork);
   const heartbeatConcurrency = { maxConcurrentWork: effectiveMaxConcurrentWork, activeClaimLaneIds: effectiveActiveClaimLaneIds };
   if (claimLaneId !== "default" && effectiveMaxConcurrentWork === 1) {
@@ -12271,6 +12427,25 @@ async function runNextWorkItem({
   let implementationHandoff;
   let finalMessage = `${preview.toolName} exited with code ${toolResult.exitCode}.`;
   let finalError = failureExcerpt ?? promptBatchFailureReason(promptBatchResult);
+  const patchDrift = finalStatus !== "completed" ? classifyPatchDriftToolResult(toolResult) : void 0;
+  if (patchDrift) {
+    finalStatus = "blocked";
+    finalMessage = patchDrift.message;
+    finalError = patchDrift.summary;
+    implementationHandoff = {
+      status: "blocked",
+      cleanupStatus: "pending",
+      message: patchDrift.message,
+      error: patchDrift.summary,
+      recovery: {
+        category: "patchDrift",
+        availableActions: ["requeueFreshAttempt", "exportHandoffDetails"],
+        conflictFiles: [],
+        summary: "The local patch did not match the current worktree context. Refresh context or queue a fresh linked attempt before retrying.",
+        ...isolationTelemetry.executionWorktreeKey ? { worktreeKey: isolationTelemetry.executionWorktreeKey } : {}
+      }
+    };
+  }
   if (promptBatchResult && finalStatus !== "completed" && toolResult.exitCode === 0) {
     finalMessage = "Prompt batch reported a failed or blocked child prompt.";
   }
@@ -12321,33 +12496,59 @@ async function runNextWorkItem({
     ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
   });
   let statusResult;
+  const finalizationIdempotencyKey = `run_${result.workItem.workItemId}_${randomUUID3()}`;
+  const finalizationTelemetry = {
+    tool: preview.toolName,
+    ...toolResult.model ? { model: toolResult.model } : {},
+    durationMs,
+    message: finalMessage,
+    ...isolationTelemetry,
+    ...finalStatus === "blocked" ? { blockerReason: finalMessage } : {},
+    sessionPolicy: sessionContext.policy,
+    sessionDecision: sessionContext.decision,
+    sessionDecisionReason: sessionContext.reason,
+    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
+    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {},
+    ...implementationHandoff ? { implementationHandoff } : {},
+    ...result.workItem.workKind === "promptBatch" ? { promptBatch: finalizePromptBatchMetadata(result.workItem, finalStatus, finalError, promptBatchResult) } : {},
+    ...finalError ? { error: finalError } : {}
+  };
   try {
-    statusResult = await apiClient.updateWorkStatus(
-      projectId,
-      result.workItem.workItemId,
+    const implementationFinalization = await submitStagedImplementationFinalization(apiClient, {
+      accountId: commandContext.accountId,
+      attempt: result.workItem.attempt,
       finalStatus,
-      `run_${result.workItem.workItemId}_${randomUUID3()}`,
+      idempotencyKey: finalizationIdempotencyKey,
+      projectId,
+      repositoryLinkId,
       runnerId,
-      {
-        tool: preview.toolName,
-        ...toolResult.model ? { model: toolResult.model } : {},
-        durationMs,
-        message: finalMessage,
-        ...isolationTelemetry,
-        ...finalStatus === "blocked" ? { blockerReason: finalMessage } : {},
-        sessionPolicy: sessionContext.policy,
-        sessionDecision: sessionContext.decision,
-        sessionDecisionReason: sessionContext.reason,
-        ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-        ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {},
-        ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-        ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-        ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {},
-        ...implementationHandoff ? { implementationHandoff } : {},
-        ...result.workItem.workKind === "promptBatch" ? { promptBatch: finalizePromptBatchMetadata(result.workItem, finalStatus, finalError, promptBatchResult) } : {},
-        ...finalError ? { error: finalError } : {}
+      telemetry: implementationFinalizationTelemetry(finalizationTelemetry),
+      workItemId: result.workItem.workItemId,
+      workKind: result.workItem.workKind === "promptBatch" ? "promptBatch" : "implementation"
+    });
+    if (implementationFinalization.status === "failed") {
+      if (implementationFinalization.retryable) {
+        await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency)).catch(() => void 0);
+        return { status: "blocked", exitCode: 0, message: implementationFinalization.message };
       }
-    );
+      throw new Error(implementationFinalization.message);
+    }
+    if (implementationFinalization.status === "deferred") {
+      const gateMessage = "Implementation test gate was queued and must pass before completion or PR handoff is finalized.";
+      await recordRunnerMilestone(apiClient, projectId, result.workItem, runnerId, repositoryLinkId, {
+        status: "queued",
+        summary: gateMessage,
+        idempotencyKey: `runner_milestone_test_gate_required_${result.workItem.workItemId}_${result.workItem.attempt}`,
+        metadata: { tool: preview.toolName, durationMs, executionWorktreeKey: isolationTelemetry.executionWorktreeKey ?? "", executionBranch: isolationTelemetry.executionBranch ?? "" }
+      });
+      await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency));
+      console.log(gateMessage);
+      return { status: "blocked", exitCode: 0, message: gateMessage };
+    }
+    statusResult = { workItem: implementationFinalization.workItem };
   } catch (error) {
     if (error instanceof AmistioApiError && error.status === 409 && error.detail.includes("implementation_test_gate_required")) {
       const gateMessage = "Implementation test gate was queued and must pass before completion or PR handoff is finalized.";
@@ -12394,6 +12595,7 @@ function artifactHandoffMetadata(artifacts) {
 }
 function isImplementationHandoffWork(workItem) {
   const workKind = workItem.workKind ?? "implementation";
+  if (workItem.implementationExpectedOutcome === "analysisOnly" || workItem.implementationExpectedOutcome === "verificationOnly") return false;
   return workKind === "implementation" || workKind === "promptBatch";
 }
 async function loadWorkItemRepositoryLink(apiClient, projectId, repositoryLinkId) {
@@ -12895,10 +13097,12 @@ async function replayPendingResultFinalizations({ accountId, apiClient, projectI
     return brainReplay;
   }
   const pendingEntries = await listPendingDurableResultFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
-  if (!pendingEntries.length) {
+  const pendingImplementationEntries = await listPendingImplementationFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
+  if (!pendingEntries.length && !pendingImplementationEntries.length) {
     return void 0;
   }
   let completedCount = 0;
+  let deferredCount = 0;
   for (const entry of pendingEntries) {
     const replay = await submitDurableResultFinalizationEntry(apiClient, entry, { recordReplayTelemetry: true });
     if (replay.status === "completed") {
@@ -12907,7 +13111,24 @@ async function replayPendingResultFinalizations({ accountId, apiClient, projectI
     }
     return { status: "failed", exitCode: 1, message: replay.message };
   }
-  const message = `Replayed ${completedCount} pending runner result finalization${completedCount === 1 ? "" : "s"}.`;
+  for (const entry of pendingImplementationEntries) {
+    const replay = await submitImplementationFinalizationEntry(apiClient, entry, { recordReplayTelemetry: true });
+    if (replay.status === "completed") {
+      completedCount += 1;
+      continue;
+    }
+    if (replay.status === "deferred") {
+      deferredCount += 1;
+      continue;
+    }
+    return { status: "failed", exitCode: 1, message: replay.message };
+  }
+  if (!completedCount && deferredCount) {
+    const message2 = `Deferred ${deferredCount} pending implementation finalization${deferredCount === 1 ? "" : "s"} until required implementation test gates pass.`;
+    console.log(message2);
+    return void 0;
+  }
+  const message = `Replayed ${completedCount} pending runner finalization${completedCount === 1 ? "" : "s"}.`;
   console.log(message);
   return { status: "completed", exitCode: 0, message };
 }
@@ -12980,6 +13201,59 @@ async function submitDurableResultFinalizationEntry(apiClient, entry, options =
   }
   return { status: "completed", workItem, response };
 }
+async function submitImplementationFinalizationEntry(apiClient, entry, options = {}) {
+  let response;
+  try {
+    response = await apiClient.updateWorkStatus(entry.projectId, entry.workItemId, entry.finalStatus, entry.idempotencyKey, entry.runnerId, entry.telemetry);
+  } catch (error) {
+    if (isImplementationTestGateRequiredError(error)) {
+      await markImplementationFinalizationRetry(entry, "implementation_test_gate_required");
+      const message2 = `Pending implementation finalization ${entry.workItemId} is waiting for the required implementation test gate to pass.`;
+      await apiClient.updateWorkStatus(entry.projectId, entry.workItemId, "blocked", `${entry.idempotencyKey}_gate_pending`, entry.runnerId, {
+        ...entry.telemetry,
+        message: message2,
+        blockerReason: message2,
+        releaseClaim: true
+      }).catch((releaseError) => {
+        console.error(`Could not release implementation work ${entry.workItemId} while waiting for its test gate: ${truncateLogExcerpt(errorMessage7(releaseError))}`);
+      });
+      console.log(message2);
+      return { status: "deferred", message: message2, retryable: true };
+    }
+    const detail = truncateLogExcerpt(errorMessage7(error));
+    if (isRetryableApiError(error)) {
+      const updated = await markImplementationFinalizationRetry(entry, detail);
+      const message2 = `Pending implementation finalization ${entry.workItemId} could not be replayed yet (${updated.retryCount} attempt${updated.retryCount === 1 ? "" : "s"}): ${detail}`;
+      console.error(message2);
+      return { status: "failed", message: message2, retryable: true };
+    }
+    await markImplementationFinalizationTerminal(entry, detail);
+    const message = `Pending implementation finalization ${entry.workItemId} reached a terminal API failure: ${detail}`;
+    console.error(message);
+    return { status: "failed", message, retryable: false };
+  }
+  await deleteImplementationFinalizationEntry(entry).catch((error) => {
+    console.error(`delete pending implementation finalization ${entry.workItemId} failed: ${errorMessage7(error)}`);
+  });
+  if (options.recordReplayTelemetry) {
+    await recordRunnerMilestone(apiClient, entry.projectId, response.workItem, entry.runnerId, entry.repositoryLinkId, {
+      status: runnerMilestoneStatusFromWorkStatus(entry.finalStatus),
+      summary: `Replayed pending implementation finalization as ${entry.finalStatus}.`,
+      idempotencyKey: `runner_milestone_implementation_replayed_${entry.workItemId}_${response.workItem.idempotencyKey}`,
+      metadata: { replayedFinalization: true, workKind: entry.workKind }
+    });
+    await apiClient.sendRunnerHeartbeat(entry.projectId, entry.runnerId, entry.repositoryLinkId, "online", {
+      ...runnerHeartbeatMetadata(),
+      preferenceMessage: "Pending implementation finalization replayed."
+    }).catch(() => void 0);
+  }
+  return { status: "completed", workItem: response.workItem };
+}
+function runnerMilestoneStatusFromWorkStatus(status) {
+  if (status === "completed" || status === "failed" || status === "running" || status === "blocked") return status;
+  if (status === "approved" || status === "drafted") return "queued";
+  return "info";
+}
 async function submitDurableResultMutation(apiClient, entry) {
   if (entry.resultKind === "assistantResult") {
     return apiClient.submitAssistantResult(entry.projectId, entry.workItemId, entry.result);
@@ -13033,6 +13307,39 @@ async function submitStagedDurableResultFinalization(apiClient, input) {
   await upsertDurableResultFinalizationEntry(entry);
   return submitDurableResultFinalizationEntry(apiClient, entry);
 }
+async function submitStagedImplementationFinalization(apiClient, input) {
+  const entry = createImplementationFinalizationEntry(input);
+  await upsertImplementationFinalizationEntry(entry);
+  return submitImplementationFinalizationEntry(apiClient, entry);
+}
+function implementationFinalizationTelemetry(telemetry) {
+  const isolationMode = telemetry.isolationMode === "none" || telemetry.isolationMode === "gitWorktree" ? telemetry.isolationMode : void 0;
+  return {
+    ...telemetry.message ? { message: telemetry.message } : {},
+    ...telemetry.tool ? { tool: telemetry.tool } : {},
+    ...telemetry.durationMs !== void 0 ? { durationMs: telemetry.durationMs } : {},
+    ...telemetry.sessionPolicy ? { sessionPolicy: telemetry.sessionPolicy } : {},
+    ...telemetry.sessionGroupKey ? { sessionGroupKey: telemetry.sessionGroupKey } : {},
+    ...telemetry.toolSessionId ? { toolSessionId: telemetry.toolSessionId } : {},
+    ...telemetry.sessionDecision ? { sessionDecision: telemetry.sessionDecision } : {},
+    ...telemetry.sessionDecisionReason ? { sessionDecisionReason: telemetry.sessionDecisionReason } : {},
+    ...telemetry.claimLaneId ? { claimLaneId: telemetry.claimLaneId } : {},
+    ...telemetry.claimLeaseId ? { claimLeaseId: telemetry.claimLeaseId } : {},
+    ...telemetry.controllingAdrId ? { controllingAdrId: telemetry.controllingAdrId } : {},
+    ...telemetry.implementationScopeId ? { implementationScopeId: telemetry.implementationScopeId } : {},
+    ...telemetry.executionBranch ? { executionBranch: telemetry.executionBranch } : {},
+    ...telemetry.executionWorktreeKey ? { executionWorktreeKey: telemetry.executionWorktreeKey } : {},
+    ...isolationMode ? { isolationMode } : {},
+    ...telemetry.machineId ? { machineId: telemetry.machineId } : {},
+    ...telemetry.repositoryLockId ? { repositoryLockId: telemetry.repositoryLockId } : {},
+    ...telemetry.blockerReason ? { blockerReason: telemetry.blockerReason } : {},
+    ...telemetry.error ? { error: telemetry.error } : {},
+    ...telemetry.implementationHandoff ? { implementationHandoff: telemetry.implementationHandoff } : {}
+  };
+}
+function isImplementationTestGateRequiredError(error) {
+  return error instanceof AmistioApiError && error.status === 409 && error.detail.includes("implementation_test_gate_required");
+}
 async function submitPrimaryRunnerResult(apiClient, input) {
   const replay = await submitStagedDurableResultFinalization(apiClient, input);
   if (replay.status === "failed") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amistio/cli",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "type": "module",
   "repository": {
     "type": "git",