@amistio/cli 0.1.52 → 0.1.53

package/README.md

@@ -95,6 +95,8 @@ Approved implementation work uses Git as the handoff boundary. During worktree p
 
 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.

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) {
@@ -12270,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.";
   }
@@ -12320,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.";
@@ -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.52",
+  "version": "0.1.53",
   "type": "module",
   "repository": {
     "type": "git",