@amistio/cli 0.1.23 → 0.1.25

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createHash as createHash7, randomUUID } from "node:crypto";
-import { writeFile as writeFile9 } from "node:fs/promises";
-import os7 from "node:os";
-import path15 from "node:path";
+import { createHash as createHash8, randomUUID } from "node:crypto";
+import { writeFile as writeFile10 } from "node:fs/promises";
+import os8 from "node:os";
+import path16 from "node:path";
 import { Command } from "commander";
 
 // ../shared/src/schemas.ts
@@ -24,6 +24,10 @@ var itemTypeSchema = z.enum([
   "securityScan",
   "securityFinding",
   "securityPostureSnapshot",
+  "testProfile",
+  "testQualityScan",
+  "testQualityFinding",
+  "implementationTestGate",
   "appEvaluationScan",
   "appEvaluationFinding",
   "implementationVerification",
@@ -79,9 +83,89 @@ var workStatusSchema = z.enum([
 ]);
 var sourceSchema = z.enum(["web", "repo", "generated", "runner"]);
 var executionModeSchema = z.enum(["localRunner", "cloudSandbox"]);
-var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification"]);
+var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate", "runnerCommand"]);
+var autopilotModeSchema = z.enum(["disabled", "enabled", "paused"]);
+var autopilotClassificationOutcomeSchema = z.enum(["safeAutopilotEligible", "requiresReview", "blocked", "unsafe"]);
+var autopilotCandidateTypeSchema = z.enum([
+  "generatedDraftApproval",
+  "projectBrainSync",
+  "issueDiagnosis",
+  "issueFixHandoff",
+  "securityPostureScan",
+  "securityRemediationHandoff",
+  "appEvaluationScan",
+  "appEvaluationPlanHandoff",
+  "appEvaluationCleanup",
+  "projectContextRefresh",
+  "impactPreview",
+  "implementationQueue",
+  "implementationVerification",
+  "testQualityScan",
+  "implementationTestGate",
+  "requeueWork",
+  "runnerCommand"
+]);
+var autopilotReasonCodeSchema = z.enum([
+  "allowedLowRisk",
+  "disabled",
+  "paused",
+  "runnerRequired",
+  "runnerIncompatible",
+  "repositoryRequired",
+  "staleRevision",
+  "duplicateInFlight",
+  "budgetExceeded",
+  "protectedSurface",
+  "destructiveAction",
+  "rawSourceUpload",
+  "secretRisk",
+  "primaryCheckoutMutation",
+  "policyBlocked",
+  "reviewRequired",
+  "cooldownActive",
+  "expired",
+  "failureBudgetExceeded",
+  "verificationFailed",
+  "redactionHit",
+  "candidateTypeNotAllowed",
+  "riskTierExceeded",
+  "unsafePath",
+  "schemaInvalid",
+  "notAdditive",
+  "scopeMismatch",
+  "sizeLimitExceeded",
+  "worktreeIsolationRequired",
+  "verificationRequired",
+  "organizationPolicyRequired",
+  "unsafe"
+]);
+var autopilotGuardCheckSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  status: z.enum(["passed", "failed", "warning"]),
+  summary: z.string().trim().min(1).max(600)
+});
 var implementationHandoffStatusSchema = z.enum(["notStarted", "noChanges", "prReady", "blocked", "failed"]);
 var implementationHandoffCleanupStatusSchema = z.enum(["notApplicable", "pending", "completed", "failed"]);
+var safeRepoPathSchema = z.string().trim().min(1).max(300).refine((value) => {
+  if (value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value)) {
+    return false;
+  }
+  return !value.split(/[\\/]+/).includes("..");
+}, "Path must be repository-relative without traversal");
+var implementationHandoffArtifactStatusSchema = z.enum(["included", "skipped", "blocked"]);
+var implementationHandoffArtifactSchema = z.object({
+  documentId: z.string().trim().min(1).max(200),
+  title: z.string().trim().min(1).max(200).optional(),
+  repoPath: safeRepoPathSchema,
+  contentFormat: documentContentFormatSchema,
+  status: implementationHandoffArtifactStatusSchema,
+  message: z.string().trim().min(1).max(600).optional()
+}).strict();
+var implementationHandoffArtifactsSchema = z.object({
+  included: z.array(implementationHandoffArtifactSchema).max(50).default([]),
+  skipped: z.array(implementationHandoffArtifactSchema).max(50).default([]),
+  blocked: z.array(implementationHandoffArtifactSchema).max(50).default([])
+}).strict();
 var implementationVerificationOutcomeSchema = z.enum(["verifiedImplemented", "partiallyImplemented", "notImplemented", "inconclusive", "verificationBlocked"]);
 var implementationVerificationStatusSchema = z.enum(["queued", "running", "completed", "failed", "blocked", "stale"]);
 var implementationProofStatusSchema = z.enum(["unverified", "verificationQueued", "verificationRunning", "verifiedImplemented", "partiallyImplemented", "notImplemented", "inconclusive", "verificationBlocked", "humanOverride"]);
@@ -96,12 +180,97 @@ var implementationHandoffSchema = z.object({
   prUrl: z.string().trim().url().max(500).optional(),
   cleanupStatus: implementationHandoffCleanupStatusSchema.optional(),
   cleanupMessage: z.string().trim().min(1).max(600).optional(),
+  artifacts: implementationHandoffArtifactsSchema.optional(),
   message: z.string().trim().min(1).max(600).optional(),
   error: z.string().trim().min(1).max(1200).optional()
 }).strict();
 var generatedDraftStatusSchema = z.enum(["queued", "generating", "reviewing", "approved", "rejected", "changesRequested", "failed"]);
 var assistantQuestionModeSchema = z.enum(["brainOnly", "sourceAware"]);
 var impactRiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
+var autopilotBudgetWindowSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  limit: z.number().int().nonnegative(),
+  used: z.number().int().nonnegative(),
+  remaining: z.number().int().nonnegative().optional(),
+  windowStartedAt: isoDateTimeSchema,
+  windowEndsAt: isoDateTimeSchema
+}).strict();
+var autopilotPolicySnapshotSchema = z.object({
+  policyVersion: z.string().trim().min(1).max(80),
+  mode: autopilotModeSchema,
+  enabledByUserId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  allowedWorkKinds: z.array(workKindSchema).max(20).default([]),
+  allowedCandidateTypes: z.array(autopilotCandidateTypeSchema).max(30).default([]),
+  maxRiskLevel: impactRiskLevelSchema.default("low"),
+  dailyWorkLimit: z.number().int().positive().max(100).optional(),
+  dailyPrLimit: z.number().int().nonnegative().max(100).optional(),
+  concurrentWorkLimit: z.number().int().positive().max(20).optional(),
+  runnerMinuteBudget: z.number().int().nonnegative().max(1440).optional(),
+  failureBudget: z.number().int().nonnegative().max(50).optional(),
+  expiresAt: isoDateTimeSchema.optional(),
+  reviewAfter: isoDateTimeSchema.optional(),
+  cooldownUntil: isoDateTimeSchema.optional(),
+  pausedReason: z.string().trim().min(1).max(600).optional(),
+  budgetWindows: z.array(autopilotBudgetWindowSchema).max(10).default([])
+}).strict();
+var autopilotCandidateLinksSchema = z.object({
+  workItemId: z.string().min(1).optional(),
+  documentId: z.string().min(1).optional(),
+  generatedDraftId: z.string().min(1).optional(),
+  issueId: z.string().min(1).optional(),
+  securityScanId: z.string().min(1).optional(),
+  securityFindingId: z.string().min(1).optional(),
+  appEvaluationScanId: z.string().min(1).optional(),
+  appEvaluationFindingId: z.string().min(1).optional(),
+  implementationVerificationId: z.string().min(1).optional(),
+  testQualityScanId: z.string().min(1).optional(),
+  testQualityFindingId: z.string().min(1).optional(),
+  implementationTestGateId: z.string().min(1).optional(),
+  projectContextRefreshId: z.string().min(1).optional(),
+  runnerCommandId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  branchName: z.string().trim().min(1).max(200).optional(),
+  worktreeKey: z.string().trim().min(1).max(300).optional(),
+  pullRequestUrl: z.string().trim().url().max(500).optional()
+}).strict();
+var autopilotCandidateActionSchema = z.object({
+  candidateId: z.string().trim().min(1).max(160),
+  candidateType: autopilotCandidateTypeSchema,
+  subjectId: z.string().trim().min(1).max(200),
+  workKind: workKindSchema.optional(),
+  riskLevel: impactRiskLevelSchema.default("low"),
+  summary: z.string().trim().min(1).max(600),
+  safeRepoPaths: z.array(safeRepoPathSchema).max(50).default([]),
+  evidenceSummaries: z.array(z.string().trim().min(1).max(300)).max(20).default([]),
+  links: autopilotCandidateLinksSchema.default({}),
+  policySnapshot: autopilotPolicySnapshotSchema.optional(),
+  outcome: autopilotClassificationOutcomeSchema.optional(),
+  reasonCodes: z.array(autopilotReasonCodeSchema).max(30).optional(),
+  guardChecks: z.array(autopilotGuardCheckSchema).max(30).optional()
+}).strict();
+var autopilotAuthorizationSchema = z.object({
+  authorizationId: z.string().trim().min(1).max(160),
+  policyVersion: z.string().trim().min(1).max(80),
+  mode: autopilotModeSchema,
+  outcome: autopilotClassificationOutcomeSchema,
+  candidateId: z.string().trim().min(1).max(160).optional(),
+  candidateType: autopilotCandidateTypeSchema.optional(),
+  subjectId: z.string().trim().min(1).max(200).optional(),
+  riskLevel: impactRiskLevelSchema,
+  reasonCodes: z.array(autopilotReasonCodeSchema).min(1),
+  guardChecks: z.array(autopilotGuardCheckSchema).default([]),
+  policySnapshot: autopilotPolicySnapshotSchema.optional(),
+  budgetWindows: z.array(autopilotBudgetWindowSchema).max(10).default([]),
+  linkedRecords: autopilotCandidateLinksSchema.optional(),
+  evidenceSummaries: z.array(z.string().trim().min(1).max(300)).max(20).default([]),
+  authorizedAt: isoDateTimeSchema.optional(),
+  authorizedBy: z.literal("autopilot").optional(),
+  reviewedByUserId: z.string().min(1).optional(),
+  summary: z.string().trim().min(1).max(600)
+}).strict();
 var impactReportStatusSchema = z.enum(["queued", "running", "completed", "failed", "stale"]);
 var issueCategorySchema = z.enum(["bug", "regression", "brokenWorkflow", "security", "operational", "other"]);
 var issueSeveritySchema = z.enum(["low", "medium", "high", "critical"]);
@@ -114,6 +283,22 @@ var securityFindingSeveritySchema = z.enum(["info", "low", "medium", "high", "cr
 var securityFindingConfidenceSchema = z.enum(["low", "medium", "high"]);
 var securityFindingStatusSchema = z.enum(["open", "planReady", "approved", "changesRequested", "dismissed", "acceptedRisk", "remediationQueued", "resolved", "failed"]);
 var securityApprovalStateSchema = z.enum(["proposed", "approved", "changesRequested", "dismissed", "acceptedRisk", "implemented", "blocked"]);
+var testProfileStatusSchema = z.enum(["detected", "reviewReady", "approved", "disabled", "stale"]);
+var testPackageManagerSchema = z.enum(["pnpm", "npm", "yarn", "bun", "dotnet", "maven", "gradle", "mixed", "unknown"]);
+var testCommandKindSchema = z.enum(["verify", "test", "coverage", "lint", "typecheck", "build", "focused"]);
+var testCommandSourceSchema = z.enum(["detected", "approved", "manual"]);
+var testCoverageMetricStatusSchema = z.enum(["met", "belowThreshold", "missing", "blocked", "unknown"]);
+var testCommandStatusSchema = z.enum(["passed", "failed", "blocked", "skipped", "missing"]);
+var testRedactionStatusSchema = z.enum(["clean", "redacted", "blocked"]);
+var testQualityScanStatusSchema = z.enum(["queued", "running", "completed", "failed", "stale", "skipped"]);
+var testQualityFindingCategorySchema = z.enum(["missingTests", "missingCoverage", "missingCommand", "lowCoverage", "failingTests", "failingQuality", "failingQualityCheck", "staleScan", "blockedEnvironment", "weakTests", "flakyTests", "unverifiedImplementation", "testGap", "other"]);
+var testQualityFindingSeveritySchema = z.enum(["info", "low", "medium", "high", "critical"]);
+var testQualityFindingConfidenceSchema = z.enum(["low", "medium", "high"]);
+var testQualityFindingStatusSchema = z.enum(["open", "planReady", "approved", "changesRequested", "dismissed", "acceptedRisk", "implementationQueued", "resolved", "failed"]);
+var testQualityApprovalStateSchema = z.enum(["proposed", "approved", "changesRequested", "dismissed", "acceptedRisk", "implemented", "blocked"]);
+var implementationTestGateStatusSchema = z.enum(["queued", "running", "passed", "failed", "blocked", "overridden", "stale"]);
+var implementationTestGateOutcomeSchema = z.enum(["passed", "failed", "blocked", "missingTests", "belowThreshold", "overridden"]);
+var implementationTestGateSourceSchema = z.enum(["manual", "runner", "completion", "prHandoff", "push", "system"]);
 var appEvaluationScanStatusSchema = z.enum(["queued", "running", "completed", "failed", "stale", "skipped"]);
 var appEvaluationFindingCategorySchema = z.enum(["verification", "productDrift", "planCleanup", "promptRot", "missingMemory", "releaseReadiness", "ux", "accessibility", "performance", "reliability", "securityPosture", "other"]);
 var appEvaluationFindingSeveritySchema = z.enum(["info", "low", "medium", "high", "critical"]);
@@ -122,6 +307,10 @@ var appEvaluationFindingStatusSchema = z.enum(["open", "planReady", "approved",
 var appEvaluationApprovalStateSchema = z.enum(["proposed", "approved", "changesRequested", "dismissed", "acceptedRisk", "implemented", "blocked"]);
 var appEvaluationPlanLifecycleActionSchema = z.enum(["createPlan", "updatePlan", "markCompleted", "markImplemented", "markSuperseded", "markBlocked", "archive", "keepActive", "none"]);
 var activityEventTypeSchema = z.enum([
+  "autopilotAuthorized",
+  "autopilotReviewRequired",
+  "autopilotBlocked",
+  "autopilotPaused",
   "commandSubmitted",
   "generationQueued",
   "generationCompleted",
@@ -161,6 +350,22 @@ var activityEventTypeSchema = z.enum([
   "appEvaluationFindingReviewed",
   "appEvaluationPlanCreated",
   "appEvaluationImplementationQueued",
+  "testProfileDetected",
+  "testProfileUpdated",
+  "testQualityScanQueued",
+  "testQualityScanStarted",
+  "testQualityScanCompleted",
+  "testQualityScanFailed",
+  "testQualityFindingOpened",
+  "testQualityFindingReviewed",
+  "testQualityPlanCreated",
+  "implementationTestGateQueued",
+  "implementationTestGateStarted",
+  "implementationTestGatePassed",
+  "implementationTestGateFailed",
+  "implementationTestGateBlocked",
+  "implementationTestGateOverride",
+  "ciWorkflowRetired",
   "workRequeueRequested",
   "workRequeueQueued",
   "workRequeueBlocked",
@@ -288,6 +493,7 @@ var runnerResourceUsageSchema = z.object({
   systemLoadAverage5m: z.number().nonnegative().optional(),
   systemLoadAverage15m: z.number().nonnegative().optional()
 });
+var runnerClaimLaneIdSchema = z.string().trim().min(1).max(80);
 var workIsolationModeSchema = z.enum(["none", "primaryCheckout", "branch", "gitWorktree"]);
 var repositoryLinkSourceSchema = z.enum(["web", "cli"]);
 var repositoryCloneStatusSchema = z.enum(["notCloned", "cloned", "validated", "failed"]);
@@ -370,6 +576,25 @@ var repositoryLinkItemSchema = baseItemSchema.extend({
   cloneStatus: repositoryCloneStatusSchema.optional(),
   autoSyncEnabled: z.boolean().optional(),
   appEvaluationEnabled: z.boolean().optional(),
+  testQualityEnabled: z.boolean().optional(),
+  autopilotMode: autopilotModeSchema.optional(),
+  autopilotPolicyVersion: z.string().trim().min(1).max(80).optional(),
+  autopilotSafeWorkKinds: z.array(workKindSchema).optional(),
+  autopilotAllowedCandidateTypes: z.array(autopilotCandidateTypeSchema).optional(),
+  autopilotMaxRiskLevel: impactRiskLevelSchema.optional(),
+  autopilotRunnerId: z.string().min(1).optional(),
+  autopilotPausedReason: z.string().trim().min(1).max(600).optional(),
+  autopilotDailyWorkLimit: z.number().int().positive().max(100).optional(),
+  autopilotDailyPrLimit: z.number().int().nonnegative().max(100).optional(),
+  autopilotConcurrentWorkLimit: z.number().int().positive().max(20).optional(),
+  autopilotRunnerMinuteBudget: z.number().int().nonnegative().max(1440).optional(),
+  autopilotFailureBudget: z.number().int().nonnegative().max(50).optional(),
+  autopilotExpiresAt: isoDateTimeSchema.optional(),
+  autopilotReviewAfter: isoDateTimeSchema.optional(),
+  autopilotCooldownUntil: isoDateTimeSchema.optional(),
+  autopilotBudgetWindows: z.array(autopilotBudgetWindowSchema).max(10).optional(),
+  autopilotUpdatedByUserId: z.string().min(1).optional(),
+  autopilotUpdatedAt: isoDateTimeSchema.optional(),
   lastValidatedAt: isoDateTimeSchema.optional(),
   status: z.enum(["active", "revoked"]).default("active")
 });
@@ -441,6 +666,9 @@ var workItemSchema = baseItemSchema.extend({
   appEvaluationScanId: z.string().min(1).optional(),
   appEvaluationFindingId: z.string().min(1).optional(),
   implementationVerificationId: z.string().min(1).optional(),
+  testQualityScanId: z.string().min(1).optional(),
+  testQualityFindingId: z.string().min(1).optional(),
+  implementationTestGateId: z.string().min(1).optional(),
   projectContextRefreshId: z.string().min(1).optional(),
   contextMissId: z.string().min(1).optional(),
   sourceWorkItemId: z.string().min(1).optional(),
@@ -468,6 +696,7 @@ var workItemSchema = baseItemSchema.extend({
   claimedByRunnerId: z.string().optional(),
   pairedByUserId: z.string().min(1).optional(),
   machineId: z.string().min(1).optional(),
+  claimLaneId: runnerClaimLaneIdSchema.optional(),
   claimLeaseId: z.string().min(1).optional(),
   claimAttempt: z.number().int().nonnegative().optional(),
   leaseExpiresAt: isoDateTimeSchema.optional(),
@@ -488,6 +717,12 @@ var workItemSchema = baseItemSchema.extend({
   sessionDecision: sessionDecisionSchema.optional(),
   sessionDecisionReason: z.string().min(1).optional(),
   implementationHandoff: implementationHandoffSchema.optional(),
+  autopilotAuthorization: autopilotAuthorizationSchema.optional(),
+  autopilotAuthorizationId: z.string().min(1).optional(),
+  autopilotCandidateId: z.string().min(1).optional(),
+  autopilotCandidateType: autopilotCandidateTypeSchema.optional(),
+  autopilotClassificationOutcome: autopilotClassificationOutcomeSchema.optional(),
+  autopilotPolicyVersion: z.string().trim().min(1).max(80).optional(),
   lastStatusMessage: z.string().optional(),
   lastStatusAt: isoDateTimeSchema
 });
@@ -507,6 +742,8 @@ var runnerHeartbeatItemSchema = baseItemSchema.extend({
   supportedWorkKinds: z.array(workKindSchema).optional(),
   supportsBranchIsolation: z.boolean().optional(),
   supportsGitWorktreeIsolation: z.boolean().optional(),
+  maxConcurrentWork: z.number().int().min(1).max(4).optional(),
+  activeClaimLaneIds: z.array(runnerClaimLaneIdSchema).max(4).optional(),
   currentWorkItemId: z.string().min(1).optional(),
   currentImplementationScopeId: z.string().min(1).optional(),
   currentWorktreeKey: z.string().min(1).optional(),
@@ -565,6 +802,7 @@ var runnerExecutionLogItemSchema = baseItemSchema.extend({
   executionWorktreeKey: z.string().min(1).optional(),
   isolationMode: workIsolationModeSchema.optional(),
   repositoryLockId: z.string().min(1).optional(),
+  claimLaneId: runnerClaimLaneIdSchema.optional(),
   claimLeaseId: z.string().min(1).optional(),
   status: z.enum(["claimed", "running", "completed", "failed", "blocked", "idle"]),
   executionMode: executionModeSchema.optional(),
@@ -796,12 +1034,7 @@ var projectContextFreshnessSchema = z.enum(["fresh", "stale", "partial", "missin
 var projectContextMapStatusSchema = z.enum(["draft", "proposed", "approved", "stale", "archived"]);
 var projectContextRefreshStatusSchema = z.enum(["queued", "running", "completed", "failed", "skipped"]);
 var contextMissStatusSchema = z.enum(["open", "resolved", "dismissed"]);
-var projectContextRepoPathSchema = z.string().trim().min(1).max(300).refine((value) => {
-  if (value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value)) {
-    return false;
-  }
-  return !value.split(/[\\/]+/).includes("..");
-}, "Path must be repository-relative without traversal");
+var projectContextRepoPathSchema = safeRepoPathSchema;
 var projectContextCitationSchema = assistantCitationSchema.extend({
   repoPath: projectContextRepoPathSchema.optional()
 });
@@ -1269,6 +1502,179 @@ var securityPostureSnapshotItemSchema = baseItemSchema.extend({
   nextScheduledAt: isoDateTimeSchema.optional(),
   summary: z.string().trim().min(1).max(2e3).optional()
 });
+var testCoverageThresholdsSchema = z.object({
+  lines: z.number().min(0).max(100).optional(),
+  statements: z.number().min(0).max(100).optional(),
+  branches: z.number().min(0).max(100).optional(),
+  functions: z.number().min(0).max(100).optional()
+}).strict();
+var testProfileCommandSchema = z.object({
+  commandId: z.string().trim().min(1).max(160),
+  kind: testCommandKindSchema,
+  label: z.string().trim().min(1).max(200),
+  source: testCommandSourceSchema.default("detected"),
+  packageName: z.string().trim().min(1).max(200).optional(),
+  scriptName: z.string().trim().min(1).max(120).optional(),
+  tool: z.string().trim().min(1).max(120).optional(),
+  workingDirectory: projectContextRepoPathSchema.optional(),
+  required: z.boolean().default(false),
+  estimatedDurationSeconds: z.number().int().positive().max(7200).optional()
+}).strict();
+var testProfileItemSchema = baseItemSchema.extend({
+  type: z.literal("testProfile"),
+  projectId: z.string().min(1),
+  testProfileId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  status: testProfileStatusSchema,
+  enabled: z.boolean().default(true),
+  detectedPackageManager: testPackageManagerSchema.default("unknown"),
+  packageManagers: z.array(testPackageManagerSchema).default([]),
+  commands: z.array(testProfileCommandSchema).max(40).default([]),
+  coverageThresholds: testCoverageThresholdsSchema.default({}),
+  defaultWholeAppCommandId: z.string().trim().min(1).max(160).optional(),
+  focusedCommandIds: z.array(z.string().trim().min(1).max(160)).max(20).default([]),
+  lastDetectedAt: isoDateTimeSchema.optional(),
+  lastReviewedRevision: z.string().trim().min(1).max(160).optional(),
+  reviewedByUserId: z.string().min(1).optional(),
+  reviewedAt: isoDateTimeSchema.optional()
+});
+var testCommandSummarySchema = z.object({
+  commandId: z.string().trim().min(1).max(160).optional(),
+  kind: testCommandKindSchema,
+  label: z.string().trim().min(1).max(200),
+  status: testCommandStatusSchema,
+  durationMs: z.number().int().nonnegative().optional(),
+  exitCode: z.number().int().min(0).max(255).optional(),
+  summary: z.string().trim().min(1).max(1200),
+  outputExcerpt: z.string().trim().min(1).max(1200).optional(),
+  safePaths: z.array(projectContextRepoPathSchema).max(30).default([])
+}).strict();
+var testCoverageSummarySchema = z.object({
+  status: testCoverageMetricStatusSchema,
+  lines: z.number().min(0).max(100).optional(),
+  statements: z.number().min(0).max(100).optional(),
+  branches: z.number().min(0).max(100).optional(),
+  functions: z.number().min(0).max(100).optional(),
+  thresholds: testCoverageThresholdsSchema.default({}),
+  reportPath: projectContextRepoPathSchema.optional(),
+  summary: z.string().trim().min(1).max(1200).optional()
+}).strict();
+var testRedactionStateSchema = z.object({
+  status: testRedactionStatusSchema.default("clean"),
+  redactedFields: z.array(z.string().trim().min(1).max(120)).max(40).default([]),
+  summary: z.string().trim().min(1).max(600).optional()
+}).strict();
+var testQualityFindingResultSchema = z.object({
+  title: z.string().trim().min(1).max(200),
+  category: testQualityFindingCategorySchema,
+  severity: testQualityFindingSeveritySchema,
+  confidence: testQualityFindingConfidenceSchema.default("medium"),
+  summary: z.string().trim().min(1).max(2e3),
+  affectedSurfaces: z.array(z.string().trim().min(1).max(300)).default([]),
+  evidence: z.array(z.string().trim().min(1).max(600)).default([]),
+  safePaths: z.array(projectContextRepoPathSchema).max(30).default([]),
+  suggestedAction: z.string().trim().min(1).max(4e3),
+  verificationPlan: z.array(z.string().trim().min(1).max(300)).min(1),
+  proposedPlanTitle: z.string().trim().min(1).max(200).optional(),
+  proposedPlanRepoPath: projectContextRepoPathSchema.optional(),
+  proposedPlanContent: z.string().trim().min(1).max(3e4).optional(),
+  dedupeKey: z.string().trim().min(1).max(240).optional(),
+  status: testQualityFindingStatusSchema.default("open")
+}).strict();
+var testQualityScanResultSchema = z.object({
+  summary: z.string().trim().min(1).max(2e3),
+  profile: testProfileItemSchema.omit({ id: true, type: true, schemaVersion: true, accountId: true, projectId: true, createdAt: true, updatedAt: true }).optional(),
+  commandSummaries: z.array(testCommandSummarySchema).max(40).default([]),
+  coverage: testCoverageSummarySchema.optional(),
+  findings: z.array(testQualityFindingResultSchema).max(50).default([]),
+  blockedReasons: z.array(z.string().trim().min(1).max(600)).max(20).default([]),
+  redactionState: testRedactionStateSchema.default({ status: "clean", redactedFields: [] }),
+  verificationPlan: z.array(z.string().trim().min(1).max(300)).min(1),
+  warnings: z.array(z.string().trim().min(1).max(600)).default([])
+}).strict();
+var testQualityScanItemSchema = baseItemSchema.extend({
+  type: z.literal("testQualityScan"),
+  projectId: z.string().min(1),
+  testQualityScanId: z.string().min(1),
+  scheduledDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  source: z.enum(["runner", "manual"]),
+  status: testQualityScanStatusSchema,
+  repositoryLinkId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  workItemId: z.string().min(1).optional(),
+  testProfileId: z.string().min(1).optional(),
+  findingIds: z.array(z.string().min(1)).default([]),
+  summary: z.string().trim().min(1).max(2e3).optional(),
+  result: testQualityScanResultSchema.optional(),
+  startedAt: isoDateTimeSchema.optional(),
+  completedAt: isoDateTimeSchema.optional(),
+  failedAt: isoDateTimeSchema.optional(),
+  error: z.string().max(1e3).optional()
+});
+var testQualityFindingItemSchema = baseItemSchema.extend({
+  type: z.literal("testQualityFinding"),
+  projectId: z.string().min(1),
+  testQualityFindingId: z.string().min(1),
+  testQualityScanId: z.string().min(1).optional(),
+  implementationTestGateId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  title: z.string().trim().min(1).max(200),
+  category: testQualityFindingCategorySchema,
+  severity: testQualityFindingSeveritySchema,
+  confidence: testQualityFindingConfidenceSchema.default("medium"),
+  status: testQualityFindingStatusSchema,
+  approvalState: testQualityApprovalStateSchema.default("proposed"),
+  summary: z.string().trim().min(1).max(2e3),
+  affectedSurfaces: z.array(z.string().trim().min(1).max(300)).default([]),
+  evidence: z.array(z.string().trim().min(1).max(600)).default([]),
+  safePaths: z.array(projectContextRepoPathSchema).max(30).default([]),
+  suggestedAction: z.string().trim().min(1).max(4e3),
+  verificationPlan: z.array(z.string().trim().min(1).max(300)).min(1),
+  dedupeKey: z.string().trim().min(1).max(240).optional(),
+  proposedPlanDocumentId: z.string().min(1).optional(),
+  implementationWorkItemId: z.string().min(1).optional(),
+  reviewNotes: z.string().trim().min(1).optional(),
+  reviewedByUserId: z.string().min(1).optional(),
+  reviewedAt: isoDateTimeSchema.optional(),
+  resolvedAt: isoDateTimeSchema.optional(),
+  lastReviewAction: z.enum(["approve", "requestChanges", "dismiss", "acceptRisk", "reopen"]).optional()
+});
+var implementationTestGateResultSchema = z.object({
+  outcome: implementationTestGateOutcomeSchema,
+  summary: z.string().trim().min(1).max(2e3),
+  commandSummaries: z.array(testCommandSummarySchema).max(40).default([]),
+  coverage: testCoverageSummarySchema.optional(),
+  findings: z.array(testQualityFindingResultSchema).max(50).default([]),
+  testGapJustification: z.string().trim().min(1).max(1200).optional(),
+  blockedReasons: z.array(z.string().trim().min(1).max(600)).max(20).default([]),
+  redactionState: testRedactionStateSchema.default({ status: "clean", redactedFields: [] }),
+  verificationPlan: z.array(z.string().trim().min(1).max(300)).default([]),
+  warnings: z.array(z.string().trim().min(1).max(600)).default([])
+}).strict();
+var implementationTestGateItemSchema = baseItemSchema.extend({
+  type: z.literal("implementationTestGate"),
+  projectId: z.string().min(1),
+  implementationTestGateId: z.string().min(1),
+  status: implementationTestGateStatusSchema,
+  source: implementationTestGateSourceSchema.default("system"),
+  sourceWorkItemId: z.string().min(1),
+  gateWorkItemId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  planDocumentId: z.string().min(1).optional(),
+  planDocumentRevision: z.number().int().nonnegative().optional(),
+  testProfileId: z.string().min(1).optional(),
+  outcome: implementationTestGateOutcomeSchema.optional(),
+  result: implementationTestGateResultSchema.optional(),
+  summary: z.string().trim().min(1).max(2e3).optional(),
+  startedAt: isoDateTimeSchema.optional(),
+  completedAt: isoDateTimeSchema.optional(),
+  failedAt: isoDateTimeSchema.optional(),
+  overriddenByUserId: z.string().min(1).optional(),
+  overrideReason: z.string().trim().min(1).max(1e3).optional(),
+  overriddenAt: isoDateTimeSchema.optional(),
+  error: z.string().max(1e3).optional()
+});
 var appEvaluationFindingResultSchema = z.object({
   title: z.string().trim().min(1).max(200),
   category: appEvaluationFindingCategorySchema,
@@ -1358,13 +1764,19 @@ var activityEventItemSchema = baseItemSchema.extend({
   relatedAppEvaluationScanId: z.string().min(1).optional(),
   relatedAppEvaluationFindingId: z.string().min(1).optional(),
   relatedImplementationVerificationId: z.string().min(1).optional(),
+  relatedTestQualityScanId: z.string().min(1).optional(),
+  relatedTestQualityFindingId: z.string().min(1).optional(),
+  relatedImplementationTestGateId: z.string().min(1).optional(),
   relatedProjectContextRefreshId: z.string().min(1).optional(),
   relatedProjectSystemDiagramId: z.string().min(1).optional(),
   relatedContextMissId: z.string().min(1).optional(),
+  relatedAutopilotAuthorizationId: z.string().min(1).optional(),
+  relatedAutopilotCandidateId: z.string().min(1).optional(),
   generatedDraftId: z.string().min(1).optional(),
   runnerId: z.string().min(1).optional(),
   repositoryLinkId: z.string().min(1).optional(),
   runnerLogId: z.string().min(1).optional(),
+  claimLaneId: runnerClaimLaneIdSchema.optional(),
   commandId: z.string().min(1).optional()
 });
 var activityHandoffExportSchema = z.object({
@@ -1421,6 +1833,10 @@ var projectItemUnionSchema = z.discriminatedUnion("type", [
   securityScanItemSchema,
   securityFindingItemSchema,
   securityPostureSnapshotItemSchema,
+  testProfileItemSchema,
+  testQualityScanItemSchema,
+  testQualityFindingItemSchema,
+  implementationTestGateItemSchema,
   appEvaluationScanItemSchema,
   appEvaluationFindingItemSchema,
   implementationVerificationItemSchema,
@@ -2178,6 +2594,24 @@ async function readGitTopLevel(rootDir) {
 
 // src/api-client.ts
 import { z as z3 } from "zod";
+var AmistioApiError = class extends Error {
+  constructor(status, statusText, detail) {
+    super(`Amistio API request failed: ${status} ${statusText}${detail ? ` - ${detail}` : ""}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.detail = detail;
+    this.name = "AmistioApiError";
+  }
+  status;
+  statusText;
+  detail;
+};
+function isRetryableApiError(error) {
+  if (error instanceof AmistioApiError) {
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+  }
+  return error instanceof TypeError;
+}
 var ApiClient = class {
   constructor(options) {
     this.options = options;
@@ -2508,6 +2942,26 @@ var ApiClient = class {
       }
     );
   }
+  async submitTestQualityScanResult(projectId, workItemId, result) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/test-quality-result`,
+      z3.object({ scan: testQualityScanItemSchema, findings: z3.array(testQualityFindingItemSchema), workItem: workItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify(result)
+      }
+    );
+  }
+  async submitImplementationTestGateResult(projectId, workItemId, result) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/implementation-test-gate-result`,
+      z3.object({ gate: implementationTestGateItemSchema, findings: z3.array(testQualityFindingItemSchema), workItem: workItemSchema, sourceWorkItem: workItemSchema.optional() }),
+      {
+        method: "POST",
+        body: JSON.stringify(result)
+      }
+    );
+  }
   async request(urlPath, schema, init) {
     const response = await fetch(resolveApiUrl(this.options.apiUrl, urlPath), {
       ...init,
@@ -2519,7 +2973,7 @@ var ApiClient = class {
     });
     if (!response.ok) {
       const detail = await response.text().catch(() => "");
-      throw new Error(`Amistio API request failed: ${response.status} ${response.statusText}${detail ? ` - ${detail}` : ""}`);
+      throw new AmistioApiError(response.status, response.statusText, detail);
     }
     return schema.parse(await response.json());
   }
@@ -2554,8 +3008,8 @@ var toolSessionMutationSchema = z3.object({
 });
 function resolveApiUrl(apiUrl, urlPath) {
   const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
-  const path16 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
-  return new URL(`${base}${path16}`);
+  const path17 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path17}`);
 }
 
 // src/orchestrator.ts
@@ -2619,11 +3073,347 @@ async function writePromptFile(filePath, prompt) {
   return filePath;
 }
 
-// src/local-tool-runner.ts
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile as readFile3, rm, writeFile as writeFile4 } from "node:fs/promises";
+// src/result-finalization-outbox.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile3, rename, rm, writeFile as writeFile4 } from "node:fs/promises";
 import os2 from "node:os";
 import path5 from "node:path";
+import { z as z4 } from "zod";
+var brainGenerationResultMutationSchema = z4.discriminatedUnion("status", [
+  z4.object({
+    status: z4.literal("completed"),
+    runnerId: z4.string().min(1),
+    idempotencyKey: z4.string().min(1),
+    artifacts: z4.array(generatedBrainArtifactSchema).min(1),
+    tool: z4.string().min(1).optional(),
+    durationMs: z4.number().int().nonnegative().optional(),
+    sessionPolicy: sessionPolicySchema.optional(),
+    sessionGroupKey: z4.string().min(1).optional(),
+    toolSessionId: z4.string().min(1).optional(),
+    sessionDecision: sessionDecisionSchema.optional(),
+    sessionDecisionReason: z4.string().min(1).optional(),
+    message: z4.string().optional()
+  }),
+  z4.object({
+    status: z4.literal("failed"),
+    runnerId: z4.string().min(1),
+    idempotencyKey: z4.string().min(1),
+    tool: z4.string().min(1).optional(),
+    durationMs: z4.number().int().nonnegative().optional(),
+    sessionPolicy: sessionPolicySchema.optional(),
+    sessionGroupKey: z4.string().min(1).optional(),
+    toolSessionId: z4.string().min(1).optional(),
+    sessionDecision: sessionDecisionSchema.optional(),
+    sessionDecisionReason: z4.string().min(1).optional(),
+    message: z4.string().optional(),
+    error: z4.string().optional()
+  })
+]);
+var brainGenerationFinalizationEntrySchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("brainGenerationResult"),
+  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(["brainGeneration", "planRevision"]),
+  attempt: z4.number().int().nonnegative(),
+  idempotencyKey: z4.string().min(1),
+  result: brainGenerationResultMutationSchema,
+  retryCount: z4.number().int().nonnegative(),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  lastError: z4.string().optional()
+});
+var resultFinalizationTelemetrySchema = z4.object({
+  runnerId: z4.string().min(1),
+  idempotencyKey: z4.string().min(1),
+  tool: z4.string().min(1).optional(),
+  durationMs: z4.number().int().nonnegative().optional(),
+  sessionPolicy: sessionPolicySchema.optional(),
+  sessionGroupKey: z4.string().min(1).optional(),
+  toolSessionId: z4.string().min(1).optional(),
+  sessionDecision: sessionDecisionSchema.optional(),
+  sessionDecisionReason: z4.string().min(1).optional(),
+  message: z4.string().optional()
+});
+var resultFinalizationFailureSchema = resultFinalizationTelemetrySchema.extend({
+  status: z4.literal("failed"),
+  error: z4.string().optional()
+});
+var assistantResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    answer: assistantAnswerResultSchema.shape.answer,
+    sourceBoundary: assistantAnswerResultSchema.shape.sourceBoundary.optional(),
+    citations: assistantAnswerResultSchema.shape.citations.optional()
+  }),
+  resultFinalizationFailureSchema
+]);
+var impactPreviewResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    report: impactPreviewResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var issueDiagnosisResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    diagnosis: issueDiagnosisResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var securityPostureScanResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: securityPostureScanResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var appEvaluationScanResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: appEvaluationScanResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var projectContextRefreshResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: projectContextRefreshResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var implementationVerificationResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: implementationVerificationResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var testQualityScanResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: testQualityScanResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var implementationTestGateResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: implementationTestGateResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
+var durableResultMutationSchema = z4.discriminatedUnion("resultKind", [
+  z4.object({ resultKind: z4.literal("assistantResult"), result: assistantResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("impactPreviewResult"), result: impactPreviewResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("issueDiagnosisResult"), result: issueDiagnosisResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("securityPostureScanResult"), result: securityPostureScanResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("appEvaluationScanResult"), result: appEvaluationScanResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("projectContextRefreshResult"), result: projectContextRefreshResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("implementationVerificationResult"), result: implementationVerificationResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("testQualityScanResult"), result: testQualityScanResultMutationSchema }),
+  z4.object({ resultKind: z4.literal("implementationTestGateResult"), result: implementationTestGateResultMutationSchema })
+]);
+var durableResultFinalizationEntrySchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("runnerResult"),
+  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(["assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate"]),
+  attempt: z4.number().int().nonnegative(),
+  idempotencyKey: z4.string().min(1),
+  retryCount: z4.number().int().nonnegative(),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  lastError: z4.string().optional()
+}).and(durableResultMutationSchema);
+function defaultResultFinalizationOutboxDir() {
+  return path5.join(os2.homedir(), ".config", "amistio", "result-finalizations");
+}
+function createBrainGenerationFinalizationEntry(input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return brainGenerationFinalizationEntrySchema.parse({
+    schemaVersion: 1,
+    kind: "brainGenerationResult",
+    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,
+    result: input.result,
+    retryCount: 0,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+function createDurableResultFinalizationEntry(input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return durableResultFinalizationEntrySchema.parse({
+    schemaVersion: 1,
+    kind: "runnerResult",
+    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,
+    resultKind: input.resultKind,
+    result: input.result,
+    retryCount: 0,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+async function upsertBrainGenerationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await mkdir5(outboxDir, { recursive: true });
+  const filePath = brainGenerationFinalizationEntryPath(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 listPendingBrainGenerationFinalizations(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 = brainGenerationFinalizationEntrySchema.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 upsertDurableResultFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await mkdir5(outboxDir, { recursive: true });
+  const filePath = durableResultFinalizationEntryPath(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 [];
+    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 = durableResultFinalizationEntrySchema.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,
+    status: "pending",
+    retryCount: entry.retryCount + 1,
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertBrainGenerationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function markBrainGenerationFinalizationTerminal(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = brainGenerationFinalizationEntrySchema.parse({
+    ...entry,
+    status: "terminal",
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertBrainGenerationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function deleteBrainGenerationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await rm(brainGenerationFinalizationEntryPath(entry, outboxDir), { force: true });
+}
+async function markDurableResultFinalizationRetry(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = durableResultFinalizationEntrySchema.parse({
+    ...entry,
+    status: "pending",
+    retryCount: entry.retryCount + 1,
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertDurableResultFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function markDurableResultFinalizationTerminal(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = durableResultFinalizationEntrySchema.parse({
+    ...entry,
+    status: "terminal",
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertDurableResultFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function deleteDurableResultFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await rm(durableResultFinalizationEntryPath(entry, outboxDir), { force: true });
+}
+function brainGenerationFinalizationEntryPath(entry, outboxDir) {
+  return path5.join(outboxDir, `${brainGenerationFinalizationEntryKey(entry)}.json`);
+}
+function brainGenerationFinalizationEntryKey(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 `brain-generation-${hash}`;
+}
+function durableResultFinalizationEntryPath(entry, outboxDir) {
+  return path5.join(outboxDir, `${durableResultFinalizationEntryKey(entry)}.json`);
+}
+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 truncateLocalError(error) {
+  const trimmed = error.trim();
+  return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
+}
+
+// src/local-tool-runner.ts
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import os3 from "node:os";
+import path6 from "node:path";
 var localToolNames = runnerToolNames;
 var allReasoningEfforts = ["auto", "low", "medium", "high", "xhigh"];
 var highReasoningEfforts = ["auto", "high", "xhigh"];
@@ -2830,9 +3620,9 @@ async function detectLocalTools() {
   );
 }
 async function runLocalTool(options) {
-  const promptTempDir = await mkdtemp(path5.join(os2.tmpdir(), "amistio-prompt-"));
-  const promptFilePath = path5.join(promptTempDir, "prompt.md");
-  await writeFile4(promptFilePath, options.prompt, "utf8");
+  const promptTempDir = await mkdtemp(path6.join(os3.tmpdir(), "amistio-prompt-"));
+  const promptFilePath = path6.join(promptTempDir, "prompt.md");
+  await writeFile5(promptFilePath, options.prompt, "utf8");
   const modelConfig = normalizeModelOptions(options);
   try {
     const runnerOptions = {
@@ -2864,11 +3654,11 @@ async function runLocalTool(options) {
       ...result
     };
   } finally {
-    await rm(promptTempDir, { recursive: true, force: true });
+    await rm2(promptTempDir, { recursive: true, force: true });
   }
 }
 async function createToolRunPreview(options) {
-  const promptFilePath = path5.join(os2.tmpdir(), "amistio-generated-prompt.md");
+  const promptFilePath = path6.join(os3.tmpdir(), "amistio-generated-prompt.md");
   const modelConfig = normalizeModelOptions(options);
   const runnerOptions = {
     rootDir: options.rootDir,
@@ -3061,13 +3851,13 @@ async function detectProviderCatalog(adapter) {
 }
 async function loadOpencodeProviderCatalog() {
   const configPaths = [
-    path5.join(os2.homedir(), ".config", "opencode", "opencode.json"),
-    path5.join(os2.homedir(), ".config", "opencode", "config.json"),
-    path5.join(process.cwd(), "opencode.json")
+    path6.join(os3.homedir(), ".config", "opencode", "opencode.json"),
+    path6.join(os3.homedir(), ".config", "opencode", "config.json"),
+    path6.join(process.cwd(), "opencode.json")
   ];
   for (const configPath of configPaths) {
     try {
-      const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+      const parsed = JSON.parse(await readFile4(configPath, "utf8"));
       const providerValue = isRecord(parsed) ? parsed.provider : void 0;
       const catalog = sanitizeProviderCatalog(providerValue);
       if (catalog) return catalog;
@@ -3439,16 +4229,16 @@ function shellQuote(value) {
 
 // src/runner-daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { openSync } from "node:fs";
-import { mkdir as mkdir5, readdir as readdir2, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
-import os3 from "node:os";
-import path6 from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile5, writeFile as writeFile6 } from "node:fs/promises";
+import os4 from "node:os";
+import path7 from "node:path";
 function currentRunnerMode() {
   return process.env.AMISTIO_RUNNER_MODE === "background" ? "background" : "foreground";
 }
 function defaultRunnerMetadataDir() {
-  return path6.join(os3.homedir(), ".config", "amistio", "runners");
+  return path7.join(os4.homedir(), ".config", "amistio", "runners");
 }
 function updatedCliRunnerLaunchOptions() {
   return { executablePath: "amistio", directExecutable: true };
@@ -3465,8 +4255,8 @@ async function startRunnerDaemon(input) {
   if (existing?.status === "running" && isProcessRunning(existing.pid)) {
     throw new Error(`Background runner ${existing.runnerId} is already running with PID ${existing.pid}.`);
   }
-  await mkdir5(metadataDir, { recursive: true });
-  const logPath = path6.join(metadataDir, `${runnerDaemonKey(input)}.log`);
+  await mkdir6(metadataDir, { recursive: true });
+  const logPath = path7.join(metadataDir, `${runnerDaemonKey(input)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args: input.args,
@@ -3493,13 +4283,13 @@ async function startRunnerDaemon(input) {
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path6.resolve(input.rootDir),
+    rootDir: path7.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     pid: child.pid,
     status: "running",
     startedAt: now,
     updatedAt: now,
-    hostname: os3.hostname(),
+    hostname: os4.hostname(),
     logPath
   };
   await writeRunnerDaemonMetadata(metadata, metadataDir);
@@ -3507,8 +4297,8 @@ async function startRunnerDaemon(input) {
 }
 async function restartRunnerDaemonProcess(metadata, args, input = {}) {
   const metadataDir = input.metadataDir ?? defaultRunnerMetadataDir();
-  await mkdir5(metadataDir, { recursive: true });
-  const logPath = metadata.logPath ?? path6.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
+  await mkdir6(metadataDir, { recursive: true });
+  const logPath = metadata.logPath ?? path7.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args,
@@ -3536,7 +4326,7 @@ async function restartRunnerDaemonProcess(metadata, args, input = {}) {
     status: "running",
     startedAt: now,
     updatedAt: now,
-    hostname: os3.hostname(),
+    hostname: os4.hostname(),
     logPath
   };
   await writeRunnerDaemonMetadata(replacement, metadataDir);
@@ -3545,12 +4335,12 @@ async function restartRunnerDaemonProcess(metadata, args, input = {}) {
 async function listRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   let entries;
   try {
-    entries = await readdir2(metadataDir);
+    entries = await readdir3(metadataDir);
   } catch {
     return [];
   }
   const records = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path6.join(metadataDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path7.join(metadataDir, entry)))
   );
   return records.filter((record) => Boolean(record)).filter((record) => record.accountId === input.accountId && record.projectId === input.projectId && record.repositoryLinkId === input.repositoryLinkId).filter((record) => !input.runnerId || record.runnerId === input.runnerId).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
 }
@@ -3558,8 +4348,8 @@ async function readRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetada
   return readRunnerDaemonMetadataFile(runnerDaemonMetadataPath(input, metadataDir));
 }
 async function writeRunnerDaemonMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir5(metadataDir, { recursive: true });
-  await writeFile5(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir6(metadataDir, { recursive: true });
+  await writeFile6(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function markRunnerDaemonStopped(metadata, metadataDir = defaultRunnerMetadataDir()) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3621,14 +4411,14 @@ function runnerDaemonUptime(metadata, now = Date.now()) {
   return `${seconds}s`;
 }
 function runnerDaemonMetadataPath(input, metadataDir) {
-  return path6.join(metadataDir, `${runnerDaemonKey(input)}.json`);
+  return path7.join(metadataDir, `${runnerDaemonKey(input)}.json`);
 }
 function runnerDaemonKey(input) {
-  return createHash2("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
+  return createHash3("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
 }
 async function readRunnerDaemonMetadataFile(filePath) {
   try {
-    const parsed = JSON.parse(await readFile4(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile5(filePath, "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.runnerId || !parsed.projectId || !parsed.repositoryLinkId) {
       return void 0;
     }
@@ -3640,10 +4430,10 @@ async function readRunnerDaemonMetadataFile(filePath) {
 
 // src/runner-service.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile5, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
-import os4 from "node:os";
-import path7 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir7, readFile as readFile6, rm as rm3, writeFile as writeFile7 } from "node:fs/promises";
+import os5 from "node:os";
+import path8 from "node:path";
 function detectRunnerServicePlatform(platform = process.platform) {
   if (platform === "darwin") return "launchd";
   if (platform === "linux") return "systemd";
@@ -3654,19 +4444,19 @@ function createRunnerServiceDescriptor(input) {
   if (platform === "unsupported") {
     throw new Error("Startup services are supported for user-level launchd on macOS and systemd user services on Linux.");
   }
-  const homeDir = input.homeDir ?? os4.homedir();
+  const homeDir = input.homeDir ?? os5.homedir();
   const serviceName = runnerServiceName(input);
   const serviceFilePath = runnerServiceFilePath(platform, serviceName, homeDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const command = [input.executablePath ?? process.execPath, input.scriptPath ?? process.argv[1], ...input.args];
-  const logPath = path7.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
+  const logPath = path8.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
   const metadata = {
     schemaVersion: 1,
     accountId: input.accountId,
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path7.resolve(input.rootDir),
+    rootDir: path8.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     serviceName,
     serviceFilePath,
@@ -3683,9 +4473,9 @@ function createRunnerServiceDescriptor(input) {
 }
 async function installRunnerService(input, options = {}) {
   const descriptor = createRunnerServiceDescriptor(input);
-  await mkdir6(path7.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
-  await mkdir6(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
-  await writeFile6(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
+  await mkdir7(path8.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
+  await mkdir7(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
+  await writeFile7(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
   await writeRunnerServiceMetadata(descriptor.metadata, input.metadataDir);
   if (options.activate !== false) {
     const activation = await activateRunnerService(descriptor.metadata);
@@ -3701,13 +4491,13 @@ async function removeRunnerService(input) {
     return void 0;
   }
   await deactivateRunnerService(metadata).catch(() => void 0);
-  await rm2(metadata.serviceFilePath, { force: true });
-  await rm2(runnerServiceMetadataPath(input, input.metadataDir ?? defaultRunnerMetadataDir()), { force: true });
+  await rm3(metadata.serviceFilePath, { force: true });
+  await rm3(runnerServiceMetadataPath(input, input.metadataDir ?? defaultRunnerMetadataDir()), { force: true });
   return { ...metadata, status: "removed", updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   try {
-    const parsed = JSON.parse(await readFile5(runnerServiceMetadataPath(input, metadataDir), "utf8"));
+    const parsed = JSON.parse(await readFile6(runnerServiceMetadataPath(input, metadataDir), "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.serviceName || !parsed.serviceFilePath) {
       return void 0;
     }
@@ -3717,8 +4507,8 @@ async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetad
   }
 }
 async function writeRunnerServiceMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir6(metadataDir, { recursive: true });
-  await writeFile6(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir7(metadataDir, { recursive: true });
+  await writeFile7(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function runnerServiceRuntimeStatus(metadata) {
   if (metadata.platform === "launchd") {
@@ -3801,18 +4591,18 @@ WantedBy=default.target
 }
 function runnerServiceFilePath(platform, serviceName, homeDir) {
   if (platform === "launchd") {
-    return path7.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
+    return path8.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
   }
-  return path7.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
+  return path8.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
 }
 function runnerServiceMetadataPath(input, metadataDir) {
-  return path7.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
+  return path8.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
 }
 function runnerServiceName(input) {
   return `com.amistio.runner.${runnerServiceKey(input).slice(0, 20)}`;
 }
 function runnerServiceKey(input) {
-  return createHash3("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
+  return createHash4("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
 }
 function launchdDomain() {
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
@@ -3988,9 +4778,9 @@ function tokens(value) {
 
 // src/sync.ts
 import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir7, readdir as readdir3, readFile as readFile6, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
-import path8 from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir as mkdir8, readdir as readdir4, readFile as readFile7, stat as stat3, writeFile as writeFile8 } from "node:fs/promises";
+import path9 from "node:path";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync3 = promisify3(execFile3);
 var legacySyncRoots = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
@@ -4086,7 +4876,7 @@ async function readLocalSyncedDocuments(rootDir) {
   const documentFiles = await findBrainDocumentFiles(rootDir);
   const documents = [];
   for (const fullPath of documentFiles) {
-    const raw = await readFile6(fullPath, "utf8");
+    const raw = await readFile7(fullPath, "utf8");
     const repoPath = toRepoPath(rootDir, fullPath);
     const parsed = parseSyncedDocument(raw, repoPath);
     if (!parsed) {
@@ -4136,8 +4926,8 @@ async function materializeBrainDocuments(rootDir, documents, options = {}) {
       result.skipped.push(document.repoPath);
       continue;
     }
-    await mkdir7(path8.dirname(fullPath), { recursive: true });
-    await writeFile7(fullPath, createSyncedDocumentContent(document), "utf8");
+    await mkdir8(path9.dirname(fullPath), { recursive: true });
+    await writeFile8(fullPath, createSyncedDocumentContent(document), "utf8");
     result.written.push(document.repoPath);
   }
   return result;
@@ -4266,7 +5056,7 @@ function parseSyncedHtml(content) {
 }
 async function readExistingSyncedDocument(fullPath) {
   try {
-    const raw = await readFile6(fullPath, "utf8");
+    const raw = await readFile7(fullPath, "utf8");
     const parsed = parseSyncedDocument(raw, fullPath);
     if (!parsed) {
       return { exists: true };
@@ -4291,7 +5081,7 @@ async function readExistingSyncedDocument(fullPath) {
 async function findBrainDocumentFiles(rootDir) {
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot]) {
-    const fullRoot = path8.join(rootDir, syncRoot);
+    const fullRoot = path9.join(rootDir, syncRoot);
     if (!await exists2(fullRoot)) {
       continue;
     }
@@ -4300,8 +5090,8 @@ async function findBrainDocumentFiles(rootDir) {
   return files;
 }
 async function walkBrainDocumentFiles(directory, files) {
-  for (const entry of await readdir3(directory, { withFileTypes: true })) {
-    const fullPath = path8.join(directory, entry.name);
+  for (const entry of await readdir4(directory, { withFileTypes: true })) {
+    const fullPath = path9.join(directory, entry.name);
     if (entry.isDirectory()) {
       await walkBrainDocumentFiles(fullPath, files);
     } else if (entry.isFile() && /\.(md|mdx|html?)$/i.test(entry.name)) {
@@ -4310,23 +5100,23 @@ async function walkBrainDocumentFiles(directory, files) {
   }
 }
 function safeRepoPath(rootDir, repoPath) {
-  if (path8.isAbsolute(repoPath)) {
+  if (path9.isAbsolute(repoPath)) {
     throw new Error(`Refusing to use absolute repo path: ${repoPath}`);
   }
-  const normalized = path8.normalize(repoPath);
-  if (normalized === ".." || normalized.startsWith(`..${path8.sep}`)) {
+  const normalized = path9.normalize(repoPath);
+  if (normalized === ".." || normalized.startsWith(`..${path9.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
-  const root = path8.resolve(rootDir);
-  const fullPath = path8.resolve(root, normalized);
-  if (!fullPath.startsWith(`${root}${path8.sep}`)) {
+  const root = path9.resolve(rootDir);
+  const fullPath = path9.resolve(root, normalized);
+  if (!fullPath.startsWith(`${root}${path9.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
   return fullPath;
 }
 function isControlPlanePath(repoPath) {
-  const normalized = path8.normalize(repoPath);
-  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path8.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path8.sep}`);
+  const normalized = path9.normalize(repoPath);
+  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path9.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path9.sep}`);
 }
 function canonicalControlPlaneRepoPath(repoPath) {
   const normalized = repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -4337,16 +5127,16 @@ function canonicalControlPlaneRepoPath(repoPath) {
   return normalized;
 }
 function toRepoPath(rootDir, fullPath) {
-  return path8.relative(rootDir, fullPath).split(path8.sep).join("/");
+  return path9.relative(rootDir, fullPath).split(path9.sep).join("/");
 }
 function inferTitle(content, repoPath) {
   const heading = content.split("\n").find((line) => line.startsWith("# "))?.replace(/^#\s+/, "").trim();
   if (heading) return heading;
   const htmlHeading = content.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
-  return htmlHeading || path8.basename(repoPath, path8.extname(repoPath));
+  return htmlHeading || path9.basename(repoPath, path9.extname(repoPath));
 }
 async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingDocuments, options) {
-  const root = path8.resolve(rootDir);
+  const root = path9.resolve(rootDir);
   const maxBytes = (options.maxFileKb ?? defaultAutoSyncMaxFileKb) * 1024;
   const syncedAt = options.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const existingById = new Map(existingDocuments.map((document) => [document.documentId, document]));
@@ -4371,7 +5161,7 @@ async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingD
       skipped.push({ repoPath: normalizedRepoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile6(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile7(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
       continue;
@@ -4436,7 +5226,7 @@ async function listAutoSyncCandidatePaths(rootDir) {
   }
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot, ...legacySyncRoots]) {
-    const fullRoot = path8.join(rootDir, syncRoot);
+    const fullRoot = path9.join(rootDir, syncRoot);
     if (await exists2(fullRoot)) {
       await walkAutoSyncFiles(rootDir, fullRoot, files);
     }
@@ -4444,9 +5234,9 @@ async function listAutoSyncCandidatePaths(rootDir) {
   return uniqueSortedRepoPaths(files);
 }
 async function walkAutoSyncFiles(rootDir, directory, files) {
-  for (const entry of await readdir3(directory, { withFileTypes: true }).catch(() => [])) {
-    const fullPath = path8.join(directory, entry.name);
-    const repoPath = normalizeRepoPath3(path8.relative(rootDir, fullPath));
+  for (const entry of await readdir4(directory, { withFileTypes: true }).catch(() => [])) {
+    const fullPath = path9.join(directory, entry.name);
+    const repoPath = normalizeRepoPath3(path9.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!autoSyncExcludedDirectoryNames.has(entry.name)) {
         await walkAutoSyncFiles(rootDir, fullPath, files);
@@ -4480,7 +5270,7 @@ function legacyDocumentTypeForRepoPath(repoPath) {
   return root && root in documentTypeByRoot ? documentTypeByRoot[root] : void 0;
 }
 function stableExternalDocumentId(metadata, repoPath) {
-  return `doc_external_${createHash4("sha256").update(`${metadata.amistioAccountId}:${metadata.amistioProjectId}:${metadata.repositoryLinkId}:${repoPath}`).digest("hex").slice(0, 24)}`;
+  return `doc_external_${createHash5("sha256").update(`${metadata.amistioAccountId}:${metadata.amistioProjectId}:${metadata.repositoryLinkId}:${repoPath}`).digest("hex").slice(0, 24)}`;
 }
 function normalizeRepoPath3(repoPath) {
   return repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -4508,9 +5298,9 @@ async function exists2(filePath) {
 }
 
 // src/tool-session-store.ts
-import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
-import os5 from "node:os";
-import path9 from "node:path";
+import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
+import os6 from "node:os";
+import path10 from "node:path";
 var LocalToolSessionStore = class {
   constructor(filePath = defaultSessionStorePath()) {
     this.filePath = filePath;
@@ -4524,12 +5314,12 @@ var LocalToolSessionStore = class {
   async setProviderSessionId(toolSessionId, toolName, providerSessionId) {
     const data = await this.read();
     data[toolSessionId] = { toolName, providerSessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await mkdir8(path9.dirname(this.filePath), { recursive: true });
-    await writeFile8(this.filePath, JSON.stringify(data, null, 2), "utf8");
+    await mkdir9(path10.dirname(this.filePath), { recursive: true });
+    await writeFile9(this.filePath, JSON.stringify(data, null, 2), "utf8");
   }
   async read() {
     try {
-      return JSON.parse(await readFile7(this.filePath, "utf8"));
+      return JSON.parse(await readFile8(this.filePath, "utf8"));
     } catch {
       return {};
     }
@@ -4537,16 +5327,16 @@ var LocalToolSessionStore = class {
 };
 function defaultSessionStorePath() {
   if (process.platform === "darwin") {
-    return path9.join(os5.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
+    return path10.join(os6.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
   }
   if (process.platform === "win32") {
-    return path9.join(process.env.APPDATA ?? os5.homedir(), "Amistio", "tool-sessions.json");
+    return path10.join(process.env.APPDATA ?? os6.homedir(), "Amistio", "tool-sessions.json");
   }
-  return path9.join(process.env.XDG_STATE_HOME ?? path9.join(os5.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
+  return path10.join(process.env.XDG_STATE_HOME ?? path10.join(os6.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
 }
 
 // src/work-runner.ts
-import path10 from "node:path";
+import path11 from "node:path";
 var generationResultStart = "AMISTIO_BRAIN_GENERATION_RESULT_START";
 var generationResultEnd = "AMISTIO_BRAIN_GENERATION_RESULT_END";
 var assistantAnswerStart = "AMISTIO_ASSISTANT_ANSWER_START";
@@ -4563,6 +5353,10 @@ var projectContextRefreshStart = "AMISTIO_PROJECT_CONTEXT_REFRESH_START";
 var projectContextRefreshEnd = "AMISTIO_PROJECT_CONTEXT_REFRESH_END";
 var implementationVerificationStart = "AMISTIO_IMPLEMENTATION_VERIFICATION_START";
 var implementationVerificationEnd = "AMISTIO_IMPLEMENTATION_VERIFICATION_END";
+var testQualityStart = "AMISTIO_TEST_QUALITY_START";
+var testQualityEnd = "AMISTIO_TEST_QUALITY_END";
+var implementationTestGateStart = "AMISTIO_IMPLEMENTATION_TEST_GATE_START";
+var implementationTestGateEnd = "AMISTIO_IMPLEMENTATION_TEST_GATE_END";
 var projectContextMissingAreaMaxLength = 160;
 var projectContextCoverageWarningMaxLength = 300;
 var projectContextVerificationPlanMaxLength = 300;
@@ -4570,6 +5364,94 @@ var projectContextTopLevelWarningMaxLength = 600;
 var validProjectContextSliceKinds = /* @__PURE__ */ new Set(["overview", "architecture", "domain", "data", "api", "frontend", "backend", "cli", "workflow", "operations", "security", "testing", "unknown"]);
 var validProjectContextEntityTypes = /* @__PURE__ */ new Set(["project", "system", "component", "domain", "tool", "decision", "feature", "risk", "team", "workflow", "unknown"]);
 var validProjectContextRelationTypes = /* @__PURE__ */ new Set(["uses", "depends_on", "decides", "supersedes", "touches", "blocks", "implements", "mentions"]);
+var canonicalAppEvaluationCategories = /* @__PURE__ */ new Map([
+  ["verification", "verification"],
+  ["verify", "verification"],
+  ["test", "verification"],
+  ["tests", "verification"],
+  ["testing", "verification"],
+  ["check", "verification"],
+  ["checks", "verification"],
+  ["ci", "verification"],
+  ["continuousintegration", "verification"],
+  ["qa", "verification"],
+  ["qualityassurance", "verification"],
+  ["build", "verification"],
+  ["lint", "verification"],
+  ["linting", "verification"],
+  ["typecheck", "verification"],
+  ["typechecking", "verification"],
+  ["productdrift", "productDrift"],
+  ["drift", "productDrift"],
+  ["docs", "productDrift"],
+  ["doc", "productDrift"],
+  ["documentation", "productDrift"],
+  ["docsdrift", "productDrift"],
+  ["documentationdrift", "productDrift"],
+  ["contextdrift", "productDrift"],
+  ["productdocumentationdrift", "productDrift"],
+  ["plancleanup", "planCleanup"],
+  ["plan", "planCleanup"],
+  ["plans", "planCleanup"],
+  ["staleplan", "planCleanup"],
+  ["staleplans", "planCleanup"],
+  ["cleanup", "planCleanup"],
+  ["cleanupplan", "planCleanup"],
+  ["superseded", "planCleanup"],
+  ["obsolete", "planCleanup"],
+  ["promptrot", "promptRot"],
+  ["prompt", "promptRot"],
+  ["prompts", "promptRot"],
+  ["template", "promptRot"],
+  ["templates", "promptRot"],
+  ["instruction", "promptRot"],
+  ["instructions", "promptRot"],
+  ["runnerprompt", "promptRot"],
+  ["runnerprompttemplate", "promptRot"],
+  ["prompttemplate", "promptRot"],
+  ["missingmemory", "missingMemory"],
+  ["memory", "missingMemory"],
+  ["memories", "missingMemory"],
+  ["lesson", "missingMemory"],
+  ["lessons", "missingMemory"],
+  ["workflow", "missingMemory"],
+  ["workflowlesson", "missingMemory"],
+  ["workflows", "missingMemory"],
+  ["releasereadiness", "releaseReadiness"],
+  ["release", "releaseReadiness"],
+  ["deploy", "releaseReadiness"],
+  ["deployment", "releaseReadiness"],
+  ["readiness", "releaseReadiness"],
+  ["production", "releaseReadiness"],
+  ["productionreadiness", "releaseReadiness"],
+  ["ux", "ux"],
+  ["ui", "ux"],
+  ["userexperience", "ux"],
+  ["accessibility", "accessibility"],
+  ["a11y", "accessibility"],
+  ["accessible", "accessibility"],
+  ["performance", "performance"],
+  ["perf", "performance"],
+  ["reliability", "reliability"],
+  ["resilience", "reliability"],
+  ["resiliency", "reliability"],
+  ["stability", "reliability"],
+  ["uptime", "reliability"],
+  ["securityposture", "securityPosture"],
+  ["security", "securityPosture"],
+  ["posture", "securityPosture"],
+  ["vulnerability", "securityPosture"],
+  ["vulnerabilities", "securityPosture"],
+  ["vulnerabilityposture", "securityPosture"],
+  ["other", "other"],
+  ["technicaldebt", "other"],
+  ["debt", "other"],
+  ["maintainability", "other"],
+  ["codequality", "other"],
+  ["architecture", "other"],
+  ["operations", "other"],
+  ["ops", "other"]
+]);
 var canonicalProjectContextCitationSources = /* @__PURE__ */ new Map([
   ["projectbrain", "projectBrain"],
   ["approvedbrain", "projectBrain"],
@@ -4594,6 +5476,7 @@ function createImplementationVerificationPrompt(workItem) {
     `Project ID: ${workItem.projectId}`,
     `Implementation verification ID: ${workItem.implementationVerificationId ?? "unknown"}`,
     `Source work item ID: ${workItem.sourceWorkItemId ?? "unknown"}`,
+    ...autopilotPromptLines(workItem),
     "",
     "## Verification Request",
     "",
@@ -4627,34 +5510,132 @@ function createImplementationVerificationPrompt(workItem) {
     "Do not put Markdown fences around the markers. Do not implement or fix anything during this verification pass."
   ].join("\n");
 }
-function createWorkExecutionPrompt(workItem, context) {
-  if (workItem.workKind === "brainGeneration") {
-    return createBrainGenerationPrompt(workItem);
-  }
-  if (workItem.workKind === "planRevision") {
-    return createPlanRevisionPrompt(workItem, context?.planRevision);
-  }
-  if (workItem.workKind === "assistantQuestion") {
-    return createAssistantQuestionPrompt(workItem, context?.assistantQuestion);
-  }
-  if (workItem.workKind === "impactPreview") {
-    return createImpactPreviewPrompt(workItem, context?.impactPreview);
-  }
-  if (workItem.workKind === "issueDiagnosis") {
-    return createIssueDiagnosisPrompt(workItem, context?.issueDiagnosis);
-  }
-  if (workItem.workKind === "securityPostureScan") {
-    return createSecurityPostureScanPrompt(workItem, context?.securityPostureScan);
-  }
-  if (workItem.workKind === "appEvaluationScan") {
-    return createAppEvaluationScanPrompt(workItem, context?.appEvaluationScan);
-  }
-  if (workItem.workKind === "projectContextRefresh") {
-    return createProjectContextRefreshPrompt(workItem, context?.projectContextRefresh);
+function createTestQualityScanPrompt(workItem, context) {
+  const approvedContext = (context?.documents ?? []).filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced").slice(0, 20).map((document) => [
+    `### ${document.title}`,
+    `documentId: ${document.documentId}`,
+    `documentType: ${document.documentType}`,
+    `repoPath: ${document.repoPath}`,
+    `revision: ${document.revision}`,
+    document.content.slice(0, 3e3)
+  ].join("\n")).join("\n\n");
+  return [
+    "# Amistio Test Quality Scan",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Run a non-mutating daily test, coverage, and quality scan for this repository.",
+    "Do not modify files, create branches, commit, push, install packages, run implementation prompts, or make unaudited network calls.",
+    "Use safe local metadata to infer package managers and scripts, then run existing lint, typecheck, test, coverage, and build commands only when they already exist.",
+    "Return missing tests, missing coverage, low coverage, failing quality commands, and broken whole-app verification as reviewable findings that can become plans.",
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    `Test quality scan ID: ${workItem.testQualityScanId ?? "unknown"}`,
+    "",
+    "## Approved Project Brain Context",
+    "",
+    approvedContext || "No approved project-brain records were loaded. Inspect safe local metadata and summarize the context gap.",
+    "",
+    "## Requirements",
+    "",
+    "- Prefer the repository whole-app verification script when one exists, then focused package scripts.",
+    "- Detect package managers from lockfiles and package metadata without uploading raw source.",
+    "- Capture bounded summaries, exit codes, coverage metrics, and repository-relative safe paths only.",
+    "- If coverage cannot be measured, return a missingCoverage finding instead of guessing.",
+    "- If tests are missing or impossible to run, return a missingTests or testGap finding with a concrete plan and verification steps.",
+    "- Redact secrets, absolute paths, env vars, process lists, tokens, provider sessions, and command lines containing secret-looking values.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below. The CLI will submit only this structured test scan result back to Amistio.",
+    "Accepted command kind values: lint, typecheck, unitTest, integrationTest, e2eTest, coverage, build, verify, other.",
+    "Accepted command status values: passed, failed, skipped, missing, blocked.",
+    "Accepted finding categories: missingTests, missingCoverage, lowCoverage, failingTests, failingQuality, missingCommand, flakyTests, unverifiedImplementation, testGap, other.",
+    "",
+    testQualityStart,
+    '{"summary":"Whole-app verification exists, but coverage reporting is missing for one package.","profile":{"testProfileId":"test_profile_detected","repositoryLinkId":"repository_link_placeholder","status":"detected","enabled":true,"detectedPackageManager":"pnpm","packageManagers":["pnpm"],"commands":[{"commandId":"verify","kind":"verify","label":"Whole-app verification","source":"detected","scriptName":"verify","workingDirectory":".","required":true}],"coverageThresholds":{"lines":80},"defaultWholeAppCommandId":"verify","focusedCommandIds":[],"lastDetectedAt":"2026-01-01T00:00:00.000Z"},"commandSummaries":[{"commandId":"verify","kind":"verify","label":"Whole-app verification","status":"passed","exitCode":0,"summary":"The repository verification script completed successfully.","safePaths":["package.json"]}],"coverage":{"status":"missing","thresholds":{"lines":80},"summary":"No coverage report was found."},"findings":[{"title":"Coverage report is missing","category":"missingCoverage","severity":"medium","confidence":"high","summary":"The repository test profile does not produce a coverage summary.","affectedSurfaces":["Test verification"],"evidence":["The scan found a test command but no coverage output."],"safePaths":["package.json"],"suggestedAction":"Add or document a coverage command for the affected package and include it in whole-app verification.","verificationPlan":["Run the new coverage command locally","Confirm coverage appears in the Test panel"],"dedupeKey":"missing-coverage"}],"blockedReasons":[],"redactionState":{"status":"clean","redactedFields":[]},"verificationPlan":["Review generated Test findings","Run the whole-app verification command before implementation handoff"],"warnings":[]}',
+    testQualityEnd,
+    "",
+    "Do not put Markdown fences around the markers. Do not implement fixes during this scan."
+  ].join("\n");
+}
+function createImplementationTestGatePrompt(workItem) {
+  return [
+    "# Amistio Implementation Test Gate",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Run the required test gate before implementation completion, PR handoff, or runner-managed push.",
+    "Do not modify files, install packages unless an already-approved preflight policy permits it, commit, push, or upload raw source.",
+    "Run focused checks for the touched scope first when available, then the whole-app verification command when practical.",
+    "If tests are missing or impossible, return blocked with a test-gap justification and a finding instead of marking the gate passed.",
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    `Implementation test gate ID: ${workItem.implementationTestGateId ?? "unknown"}`,
+    `Source work item ID: ${workItem.sourceWorkItemId ?? "unknown"}`,
+    "",
+    "## Gate Request",
+    "",
+    workItem.sourceWish ?? "Run focused checks and whole-app verification before marking implementation complete.",
+    "",
+    "## Data Safety",
+    "",
+    "- Persist only bounded summaries, coverage metrics, exit codes, and repository-relative paths.",
+    "- Do not include raw source, secrets, env vars, process lists, absolute local paths, credential values, tokens, provider sessions, or destructive shell output.",
+    "- Use safePaths for repository-relative paths only; never include /absolute paths or ../ traversal.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below. The CLI will submit only this structured gate result back to Amistio.",
+    "Accepted outcome values: passed, failed, blocked, overridden.",
+    "",
+    implementationTestGateStart,
+    '{"outcome":"passed","summary":"Focused checks and whole-app verification passed.","commandSummaries":[{"commandId":"verify","kind":"verify","label":"Whole-app verification","status":"passed","exitCode":0,"summary":"The repository verification script completed successfully.","safePaths":["package.json"]}],"coverage":{"status":"unknown","thresholds":{},"summary":"No coverage threshold was configured for this gate."},"findings":[],"blockedReasons":[],"redactionState":{"status":"clean","redactedFields":[]},"verificationPlan":["Record this gate result before marking implementation complete"],"warnings":[]}',
+    implementationTestGateEnd,
+    "",
+    "Do not put Markdown fences around the markers."
+  ].join("\n");
+}
+function createWorkExecutionPrompt(workItem, context) {
+  if (workItem.workKind === "brainGeneration") {
+    return createBrainGenerationPrompt(workItem);
+  }
+  if (workItem.workKind === "planRevision") {
+    return createPlanRevisionPrompt(workItem, context?.planRevision);
+  }
+  if (workItem.workKind === "assistantQuestion") {
+    return createAssistantQuestionPrompt(workItem, context?.assistantQuestion);
+  }
+  if (workItem.workKind === "impactPreview") {
+    return createImpactPreviewPrompt(workItem, context?.impactPreview);
+  }
+  if (workItem.workKind === "issueDiagnosis") {
+    return createIssueDiagnosisPrompt(workItem, context?.issueDiagnosis);
+  }
+  if (workItem.workKind === "securityPostureScan") {
+    return createSecurityPostureScanPrompt(workItem, context?.securityPostureScan);
+  }
+  if (workItem.workKind === "appEvaluationScan") {
+    return createAppEvaluationScanPrompt(workItem, context?.appEvaluationScan);
+  }
+  if (workItem.workKind === "projectContextRefresh") {
+    return createProjectContextRefreshPrompt(workItem, context?.projectContextRefresh);
   }
   if (workItem.workKind === "implementationVerification") {
     return createImplementationVerificationPrompt(workItem);
   }
+  if (workItem.workKind === "testQualityScan") {
+    return createTestQualityScanPrompt(workItem, context?.testQualityScan);
+  }
+  if (workItem.workKind === "implementationTestGate") {
+    return createImplementationTestGatePrompt(workItem);
+  }
   return [
     "# Amistio Work Execution",
     "",
@@ -4669,6 +5650,7 @@ function createWorkExecutionPrompt(workItem, context) {
     `Implementation scope: ${workItem.implementationScopeId ?? workItem.controllingAdrId ?? "work-item"}`,
     `Execution branch: ${workItem.executionBranch ?? "managed by Amistio CLI"}`,
     `Execution worktree key: ${workItem.executionWorktreeKey ?? "managed by Amistio CLI"}`,
+    ...autopilotPromptLines(workItem),
     "",
     "## Rules",
     "",
@@ -4683,6 +5665,27 @@ function createWorkExecutionPrompt(workItem, context) {
     "- Run relevant verification commands when feasible and summarize results."
   ].join("\n");
 }
+function autopilotPromptLines(workItem) {
+  const autopilot = autopilotWorkMetadata(workItem);
+  if (!autopilot.autopilotAuthorizationId) {
+    return [];
+  }
+  const lines = [
+    `Autopilot authorization ID: ${autopilot.autopilotAuthorizationId}`,
+    ...autopilot.autopilotCandidateId ? [`Autopilot candidate ID: ${autopilot.autopilotCandidateId}`] : [],
+    ...autopilot.autopilotCandidateType ? [`Autopilot candidate type: ${autopilot.autopilotCandidateType}`] : [],
+    `Autopilot outcome: ${autopilot.autopilotClassificationOutcome ?? "unknown"}`,
+    `Autopilot policy: ${autopilot.autopilotPolicyVersion ?? "unknown"}`
+  ];
+  if (autopilot.autopilotAuthorization?.summary) {
+    lines.push(`Autopilot summary: ${autopilot.autopilotAuthorization.summary}`);
+  }
+  lines.push("Autopilot satisfies the app approval gate only for the audited low-risk work item; it does not loosen local repository, credential, or data-safety boundaries.");
+  return lines;
+}
+function autopilotWorkMetadata(workItem) {
+  return workItem;
+}
 function createProjectContextRefreshPrompt(workItem, context) {
   const approvedContext = (context?.documents ?? []).filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced").slice(0, 24).map((document) => [
     `### ${document.title}`,
@@ -4854,6 +5857,8 @@ function createAppEvaluationScanPrompt(workItem, context) {
     "- Check app verification health: lint, typecheck, test, build, CI references, flaky or missing gates.",
     "- Check product and docs drift between approved context, plans, prompts, and current implementation.",
     "- Check old plans and prompts for cleanup candidates, but only propose lifecycle actions such as markCompleted, markSuperseded, archive, keepActive, or none.",
+    "- Treat active proposed, approved, ready, or in-progress plans/prompts with accepted controlling ADRs, features, or work artifacts as active work. Do not classify them as cleanup material solely because they are older or not yet fully implemented; use keepActive when they still describe valid pending or approved work.",
+    "- 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.",
     "",
@@ -4866,6 +5871,10 @@ function createAppEvaluationScanPrompt(workItem, context) {
     "## Output Contract",
     "",
     "Print exactly one JSON object between the markers below. The CLI will submit only this structured scan result back to Amistio.",
+    "Accepted category values: verification, productDrift, planCleanup, promptRot, missingMemory, releaseReadiness, ux, accessibility, performance, reliability, securityPosture, other.",
+    "Accepted severity values: info, low, medium, high, critical.",
+    "Accepted confidence values: low, medium, high.",
+    "Accepted proposedLifecycleAction values: createPlan, updatePlan, markCompleted, markImplemented, markSuperseded, markBlocked, archive, keepActive, none.",
     "",
     appEvaluationStart,
     '{"summary":"The app is generally healthy, but one release-readiness plan needs cleanup and verification evidence should be refreshed.","baselineVersion":"amistio-app-evaluation-v1","findings":[{"title":"Stale release plan should be marked superseded","category":"planCleanup","severity":"low","confidence":"high","summary":"A release plan appears to describe a workflow that has since been replaced by a newer accepted plan.","affectedSurfaces":["docs/plans"],"evidence":["A newer plan references the same scope and status, while the older plan remains proposed."],"suggestedAction":"Prepare a cleanup update that marks the stale plan superseded and links to the newer plan.","verificationPlan":["Review both plan files","Confirm the newer plan is accepted before changing lifecycle state"],"safePaths":["docs/plans/PLAN-example.md"],"proposedLifecycleAction":"markSuperseded","relatedArtifactIds":[]}],"verificationPlan":["Review App Evaluation findings for approval","Run the canonical verify gate before implementing approved actions"]}',
@@ -5196,7 +6205,8 @@ function parseAppEvaluationScanResult(output) {
   }
   const payload = output.slice(start + appEvaluationStart.length, end).trim();
   const parsed = JSON.parse(stripJsonFence(payload));
-  return appEvaluationScanResultSchema.parse(parsed);
+  const normalized = normalizeAppEvaluationScanResultPaths(normalizeAppEvaluationScanResultEnums(parsed));
+  return appEvaluationScanResultSchema.parse(normalized);
 }
 function parseProjectContextRefreshResult(output, options = {}) {
   const start = output.indexOf(projectContextRefreshStart);
@@ -5219,6 +6229,26 @@ function parseImplementationVerificationResult(output) {
   const parsed = JSON.parse(stripJsonFence(payload));
   return implementationVerificationResultSchema.parse(parsed);
 }
+function parseTestQualityScanResult(output) {
+  const start = output.indexOf(testQualityStart);
+  const end = output.indexOf(testQualityEnd, start + testQualityStart.length);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Local AI scan did not return an Amistio test quality block.");
+  }
+  const payload = output.slice(start + testQualityStart.length, end).trim();
+  const parsed = JSON.parse(stripJsonFence(payload));
+  return testQualityScanResultSchema.parse(parsed);
+}
+function parseImplementationTestGateResult(output) {
+  const start = output.indexOf(implementationTestGateStart);
+  const end = output.indexOf(implementationTestGateEnd, start + implementationTestGateStart.length);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Local AI gate did not return an Amistio implementation test gate block.");
+  }
+  const payload = output.slice(start + implementationTestGateStart.length, end).trim();
+  const parsed = JSON.parse(stripJsonFence(payload));
+  return implementationTestGateResultSchema.parse(parsed);
+}
 function projectContextRefreshSubmissionFailureSummary(result) {
   if (result.refresh.status !== "failed" && result.workItem.status !== "failed") {
     return void 0;
@@ -5320,6 +6350,75 @@ function normalizeProjectContextRefreshEnums(value) {
   }
   return normalized;
 }
+function normalizeAppEvaluationScanResultEnums(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (Array.isArray(normalized.findings)) {
+    normalized.findings = normalized.findings.map((finding) => {
+      if (!isObjectRecord(finding)) {
+        return finding;
+      }
+      const normalizedFinding = { ...finding };
+      normalizedFinding.category = normalizeAppEvaluationFindingCategory(finding.category);
+      return normalizedFinding;
+    });
+  }
+  return normalized;
+}
+function normalizeAppEvaluationFindingCategory(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "other";
+  }
+  const direct = canonicalAppEvaluationCategories.get(normalizeEnumKey(trimmed));
+  if (direct) {
+    return direct;
+  }
+  for (const segment of trimmed.split(/[\/,|]+/)) {
+    const segmentCategory = canonicalAppEvaluationCategories.get(normalizeEnumKey(segment));
+    if (segmentCategory) {
+      return segmentCategory;
+    }
+  }
+  return "other";
+}
+function normalizeEnumKey(value) {
+  return value.trim().replace(/[^A-Za-z0-9]+/g, "").toLowerCase();
+}
+function normalizeAppEvaluationScanResultPaths(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (Array.isArray(normalized.findings)) {
+    normalized.findings = normalized.findings.map((finding) => {
+      if (!isObjectRecord(finding)) {
+        return finding;
+      }
+      const normalizedFinding = { ...finding };
+      if (Array.isArray(normalizedFinding.safePaths)) {
+        normalizedFinding.safePaths = normalizedFinding.safePaths.map((safePath) => typeof safePath === "string" ? normalizeAppEvaluationRepoPath(safePath) : safePath);
+      }
+      if (typeof normalizedFinding.proposedPlanRepoPath === "string") {
+        normalizedFinding.proposedPlanRepoPath = normalizeAppEvaluationRepoPath(normalizedFinding.proposedPlanRepoPath);
+      }
+      return normalizedFinding;
+    });
+  }
+  return normalized;
+}
+function normalizeAppEvaluationRepoPath(value) {
+  try {
+    return normalizeRelativeProjectContextPath(value);
+  } catch {
+    throw new Error("App evaluation scan contains an unsafe repository path.");
+  }
+}
 function normalizeProjectContextSliceKind(value) {
   if (typeof value !== "string") {
     return "unknown";
@@ -5430,15 +6529,15 @@ function normalizeProjectContextRepoPath(value, options) {
   if (!trimmed || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed) || /^file:/i.test(trimmed) || /^[A-Za-z]:($|[^\\/])/.test(trimmed)) {
     throwUnsafeProjectContextPath();
   }
-  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path10.isAbsolute(trimmed) || path10.win32.isAbsolute(trimmed);
+  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path11.isAbsolute(trimmed) || path11.win32.isAbsolute(trimmed);
   if (!absolute) {
     return normalizeRelativeProjectContextPath(trimmed);
   }
   if (!options.repositoryRoot) {
     throwUnsafeProjectContextPath();
   }
-  const useWindowsPathRules = path10.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
-  const relativePath = useWindowsPathRules ? path10.win32.relative(path10.win32.resolve(options.repositoryRoot), path10.win32.resolve(trimmed)) : path10.relative(path10.resolve(options.repositoryRoot), path10.resolve(trimmed));
+  const useWindowsPathRules = path11.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
+  const relativePath = useWindowsPathRules ? path11.win32.relative(path11.win32.resolve(options.repositoryRoot), path11.win32.resolve(trimmed)) : path11.relative(path11.resolve(options.repositoryRoot), path11.resolve(trimmed));
   return normalizeRelativeProjectContextPath(relativePath);
 }
 function normalizeRelativeProjectContextPath(value) {
@@ -5490,7 +6589,7 @@ function stripJsonFence(value) {
 }
 
 // src/runner-status.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var watchStateReminderMs = 60 * 1e3;
 function formatWatchStartupContext(input) {
   return [
@@ -5517,20 +6616,20 @@ function watchStateKey(action) {
   return [action.kind, action.message, action.workItemId, action.documentId, action.runnerId].filter(Boolean).join(":");
 }
 function stableRunnerId(input) {
-  const digest = createHash5("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
+  const digest = createHash6("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
   return `runner_${digest}`;
 }
 
 // src/runner-resources.ts
-import os6 from "node:os";
+import os7 from "node:os";
 var defaultRuntime = {
   nowMs: () => Date.now(),
   memoryUsage: () => process.memoryUsage(),
   uptime: () => process.uptime(),
   cpuUsage: () => process.cpuUsage(),
-  totalmem: () => os6.totalmem(),
-  freemem: () => os6.freemem(),
-  loadavg: () => os6.loadavg()
+  totalmem: () => os7.totalmem(),
+  freemem: () => os7.freemem(),
+  loadavg: () => os7.loadavg()
 };
 var previousRunnerResourceSample;
 function sampleCurrentRunnerResourceUsage() {
@@ -5642,9 +6741,9 @@ function roundNumber(value, digits) {
 
 // src/importer.ts
 import { execFile as execFile4 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import { readdir as readdir4, readFile as readFile8, stat as stat4 } from "node:fs/promises";
-import path11 from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { readdir as readdir5, readFile as readFile9, stat as stat4 } from "node:fs/promises";
+import path12 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 var defaultMaxFileKb = 256;
@@ -5665,12 +6764,12 @@ var documentFolderByType = {
   workflow: "docs/workflows"
 };
 async function inspectLocalRepository(rootDir, defaultBranch) {
-  const requestedRoot = path11.resolve(rootDir);
+  const requestedRoot = path12.resolve(rootDir);
   const root = await runGit2(["-C", requestedRoot, "rev-parse", "--show-toplevel"]).catch(() => requestedRoot);
   const detectedBranch = await runGit2(["-C", root, "symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => defaultBranch);
   const originUrl = await runGit2(["-C", root, "remote", "get-url", "origin"]).catch(() => void 0);
   const parsedCloneUrl = originUrl ? parseOptionalOriginCloneUrl(originUrl) : void 0;
-  const repoName = (parsedCloneUrl?.repoName ?? path11.basename(root)) || "repository";
+  const repoName = (parsedCloneUrl?.repoName ?? path12.basename(root)) || "repository";
   const fingerprintSeed = parsedCloneUrl ? `origin:${parsedCloneUrl.normalizedKey}` : `repo:${repoName}:${detectedBranch || defaultBranch}`;
   return {
     rootDir: root,
@@ -5682,7 +6781,7 @@ async function inspectLocalRepository(rootDir, defaultBranch) {
   };
 }
 async function scanLegacyDocuments(options) {
-  const rootDir = path11.resolve(options.rootDir);
+  const rootDir = path12.resolve(options.rootDir);
   const maxBytes = (options.maxFileKb ?? defaultMaxFileKb) * 1024;
   const skipped = [];
   const candidates = [];
@@ -5702,7 +6801,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "excluded" });
       continue;
     }
-    const fullPath = path11.join(rootDir, ...repoPath.split("/"));
+    const fullPath = path12.join(rootDir, ...repoPath.split("/"));
     const fileStat = await stat4(fullPath).catch(() => void 0);
     if (!fileStat?.isFile()) {
       skipped.push({ repoPath, reason: "unreadable" });
@@ -5712,7 +6811,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile8(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile9(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath, reason: "unreadable" });
       continue;
@@ -5802,10 +6901,10 @@ async function listRepositoryPaths(rootDir) {
   return files;
 }
 async function walkRepository(rootDir, directory, files) {
-  const entries = await readdir4(directory, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir5(directory, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path11.join(directory, entry.name);
-    const repoPath = normalizeRepoPath4(path11.relative(rootDir, fullPath));
+    const fullPath = path12.join(directory, entry.name);
+    const repoPath = normalizeRepoPath4(path12.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!excludedDirectoryNames.has(entry.name)) {
         await walkRepository(rootDir, fullPath, files);
@@ -5873,9 +6972,9 @@ function uniqueDestinationPath(basePath, sourcePath, usedPaths) {
     usedPaths.add(basePath);
     return basePath;
   }
-  const extension = path11.posix.extname(basePath) || ".md";
-  const directory = path11.posix.dirname(basePath);
-  const basename = path11.posix.basename(basePath, extension);
+  const extension = path12.posix.extname(basePath) || ".md";
+  const directory = path12.posix.dirname(basePath);
+  const basename = path12.posix.basename(basePath, extension);
   const uniquePath = `${directory}/${basename}-${hashText(sourcePath, 8)}${extension}`;
   usedPaths.add(uniquePath);
   return uniquePath;
@@ -5948,7 +7047,7 @@ function inferTitle2(content, repoPath) {
   if (heading) return heading;
   const htmlHeading = body.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
   if (htmlHeading) return htmlHeading;
-  const basename = path11.posix.basename(repoPath, path11.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
+  const basename = path12.posix.basename(repoPath, path12.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
   return titleCase(basename || "Imported Document");
 }
 function stripFrontmatter(content) {
@@ -5970,7 +7069,7 @@ function stableImportDocumentId(accountId, projectId, repositoryLinkId, sourcePa
   return `doc_import_${hashText(`${accountId}\0${projectId}\0${repositoryLinkId}\0${sourcePath}`, 24)}`;
 }
 function hashText(value, length) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, length);
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
 }
 function normalizeRepoPath4(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -5982,7 +7081,7 @@ async function runGit2(args) {
 
 // src/runner-actions.ts
 import { spawn as spawn4 } from "node:child_process";
-import path12 from "node:path";
+import path13 from "node:path";
 function buildBackgroundRunnerArgs(options) {
   const args = [
     "run",
@@ -5992,7 +7091,7 @@ function buildBackgroundRunnerArgs(options) {
     "--runner-id",
     options.runnerId,
     "--root",
-    path12.resolve(options.root),
+    path13.resolve(options.root),
     "--session",
     options.session,
     "--interval-seconds",
@@ -6026,6 +7125,7 @@ function buildBackgroundRunnerArgs(options) {
   if (options.maxIterations !== void 0) {
     args.push("--max-iterations", String(options.maxIterations));
   }
+  args.push("--max-concurrent-work", String(options.maxConcurrentWork));
   args.push("--max-preflight-attempts", String(options.maxPreflightAttempts));
   args.push("--tool-timeout-seconds", String(options.toolTimeoutSeconds));
   if (!options.stream) {
@@ -6109,10 +7209,12 @@ function truncateProcessOutput(value) {
 
 // src/git-worktree.ts
 import { execFile as execFile5 } from "node:child_process";
-import { mkdir as mkdir9, stat as stat5 } from "node:fs/promises";
-import path13 from "node:path";
+import { copyFile, lstat, mkdir as mkdir10, readdir as readdir6, stat as stat5 } from "node:fs/promises";
+import path14 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile5);
+var exactLocalEnvironmentFiles = /* @__PURE__ */ new Set([".env", ".env.local", ".env.development", ".env.development.local", ".env.test", ".env.test.local", ".env.production", ".env.production.local"]);
+var localEnvironmentFilePattern = /^\.env\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*\.local$/;
 function needsGitWorktreeIsolation(workItem) {
   return (workItem.workKind ?? "implementation") === "implementation";
 }
@@ -6137,20 +7239,22 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
   const worktreePath = localWorktreePath(repoRoot, identity.worktreeKey);
   if (await pathExists(worktreePath)) {
     await assertExistingWorktree(worktreePath, identity.branch);
-    return { ...identity, baseRevision, worktreePath };
+    const preparedLocalEnvironmentFileCount2 = await prepareLocalWorktreeEnvironment(repoRoot, worktreePath);
+    return { ...identity, baseRevision, worktreePath, ...preparedLocalEnvironmentFileCount2 ? { preparedLocalEnvironmentFileCount: preparedLocalEnvironmentFileCount2 } : {} };
   }
-  await mkdir9(path13.dirname(worktreePath), { recursive: true });
+  await mkdir10(path14.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
   const worktreeArgs = branchExists ? ["worktree", "add", worktreePath, identity.branch] : ["worktree", "add", "-b", identity.branch, worktreePath, baseRevision];
   await gitOutput(repoRoot, worktreeArgs).catch((error) => {
     throw new Error(`Could not create Git worktree ${identity.worktreeKey} on ${identity.branch}: ${errorMessage2(error)}`);
   });
-  return { ...identity, baseRevision, worktreePath };
+  const preparedLocalEnvironmentFileCount = await prepareLocalWorktreeEnvironment(repoRoot, worktreePath);
+  return { ...identity, baseRevision, worktreePath, ...preparedLocalEnvironmentFileCount ? { preparedLocalEnvironmentFileCount } : {} };
 }
 function localWorktreePath(repoRoot, worktreeKey) {
-  const repoName = path13.basename(repoRoot);
+  const repoName = path14.basename(repoRoot);
   const worktreeSlug = worktreeKey.split("/").filter(Boolean).pop() ?? "work";
-  return path13.join(path13.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
+  return path14.join(path14.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
 }
 async function assertExistingWorktree(worktreePath, branch) {
   await gitOutput(worktreePath, ["rev-parse", "--is-inside-work-tree"]);
@@ -6172,6 +7276,55 @@ async function assertBaseRevision(repoRoot, baseRevision, currentHead) {
     throw new Error(`Work item base revision ${baseRevision} is not an ancestor of ${currentHead}; refresh the work item before implementation.`);
   }
 }
+async function prepareLocalWorktreeEnvironment(repoRoot, worktreePath) {
+  const candidates = await localEnvironmentFileCandidates(repoRoot);
+  let preparedCount = 0;
+  for (const candidate of candidates) {
+    const sourcePath = path14.join(repoRoot, candidate);
+    const targetPath = path14.join(worktreePath, candidate);
+    if (await pathExists(targetPath)) {
+      continue;
+    }
+    if (await gitCommandSucceeds(repoRoot, ["ls-files", "--error-unmatch", "--", candidate])) {
+      continue;
+    }
+    if (!await gitCommandSucceeds(worktreePath, ["check-ignore", "--quiet", "--", candidate])) {
+      continue;
+    }
+    try {
+      await copyFile(sourcePath, targetPath);
+      preparedCount += 1;
+    } catch (error) {
+      throw new Error(`Could not prepare local worktree environment files: ${safeFileError(error)}`);
+    }
+  }
+  return preparedCount;
+}
+async function localEnvironmentFileCandidates(repoRoot) {
+  const names = new Set(exactLocalEnvironmentFiles);
+  for (const entry of await readdir6(repoRoot)) {
+    if (isAllowedLocalEnvironmentFile(entry)) {
+      names.add(entry);
+    }
+  }
+  const candidates = [];
+  for (const name of [...names].sort()) {
+    if (!isRootFileName(name)) {
+      continue;
+    }
+    const source = await lstat(path14.join(repoRoot, name)).catch(() => void 0);
+    if (source?.isFile()) {
+      candidates.push(name);
+    }
+  }
+  return candidates;
+}
+function isAllowedLocalEnvironmentFile(name) {
+  return exactLocalEnvironmentFiles.has(name) || localEnvironmentFilePattern.test(name);
+}
+function isRootFileName(name) {
+  return name === path14.basename(name) && !name.includes("/") && !name.includes("\\");
+}
 async function gitOutput(cwd, args) {
   const { stdout } = await execFileAsync5("git", args, { cwd, maxBuffer: 1024 * 1024 });
   return stdout.trim();
@@ -6194,10 +7347,16 @@ function slugify(value) {
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function safeFileError(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return error instanceof Error ? error.name : "unknown file error";
+}
 
 // src/implementation-handoff.ts
 import { execFile as execFile6 } from "node:child_process";
-import path14 from "node:path";
+import path15 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync6 = promisify6(execFile6);
 async function completeImplementationHandoff(input) {
@@ -6213,9 +7372,17 @@ async function completeImplementationHandoff(input) {
     headBranch
   };
   try {
+    const artifactResult = await materializeApprovedArtifacts(input);
+    if (artifactResult.blocked.length) {
+      return blockedHandoff({
+        ...common,
+        artifacts: artifactResult,
+        message: `Implementation handoff is blocked because ${artifactResult.blocked.length} approved artifact${artifactResult.blocked.length === 1 ? "" : "s"} could not be materialized safely.`
+      });
+    }
     const unmergedFiles = await gitOutput2(run, input.worktreePath, ["diff", "--name-only", "--diff-filter=U"]);
     if (unmergedFiles.trim()) {
-      return blockedHandoff({ ...common, message: "Implementation handoff is blocked because the worktree has unresolved merge conflicts." });
+      return blockedHandoff({ ...common, artifacts: artifactResult, message: "Implementation handoff is blocked because the worktree has unresolved merge conflicts." });
     }
     const status = await gitOutput2(run, input.worktreePath, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
     if (!status) {
@@ -6223,6 +7390,7 @@ async function completeImplementationHandoff(input) {
         ...common,
         status: "noChanges",
         cleanupStatus: "notApplicable",
+        artifacts: artifactResult,
         message: "Local execution completed with no repository changes to hand off."
       };
     }
@@ -6234,14 +7402,16 @@ async function completeImplementationHandoff(input) {
         ...common,
         provider,
         remoteName,
+        artifacts: artifactResult,
         message: "Automated pull request handoff currently requires a GitHub remote. Commit and push manually, or link a GitHub repository."
       });
     }
     await gitOutput2(run, input.worktreePath, ["add", "-A"]);
     await gitOutput2(run, input.worktreePath, ["commit", "-m", commitSubject(input.workItem), "-m", commitBody(input)]);
+    await rebaseBranchFromRemoteBase(run, input.worktreePath, { baseBranch, remoteName });
     const commitSha = await gitOutput2(run, input.worktreePath, ["rev-parse", "HEAD"]);
     await gitOutput2(run, input.worktreePath, ["push", "--set-upstream", remoteName, headBranch]);
-    const pullRequest = await ensureGithubPullRequest(run, input.worktreePath, { baseBranch, headBranch, workItem: input.workItem, ...input.verificationSummary ? { verificationSummary: input.verificationSummary } : {} });
+    const pullRequest = await ensureGithubPullRequest(run, input.worktreePath, { artifacts: artifactResult, baseBranch, headBranch, workItem: input.workItem, ...input.verificationSummary ? { verificationSummary: input.verificationSummary } : {} });
     const cleanup = await cleanupWorktree(run, input);
     return {
       provider: "github",
@@ -6254,12 +7424,70 @@ async function completeImplementationHandoff(input) {
       prUrl: pullRequest.url,
       cleanupStatus: cleanup.status,
       ...cleanup.message ? { cleanupMessage: cleanup.message } : {},
+      artifacts: artifactResult,
       message: cleanup.status === "completed" ? "GitHub pull request is ready for review and the local worktree was cleaned up." : "GitHub pull request is ready for review; local worktree cleanup needs attention."
     };
   } catch (error) {
     return blockedHandoff({ ...common, message: "Implementation handoff is blocked and the local worktree was preserved for recovery.", error: safeErrorMessage(error) });
   }
 }
+async function materializeApprovedArtifacts(input) {
+  const { selected: artifacts, skipped } = selectApprovedWorkArtifacts(input.workItem, input.approvedArtifacts ?? []);
+  if (!artifacts.length) {
+    return { included: [], skipped, blocked: [] };
+  }
+  let materialized;
+  try {
+    materialized = await materializeBrainDocuments(input.worktreePath, artifacts);
+  } catch (error) {
+    return { included: [], skipped, blocked: artifacts.map((artifact) => artifactStatus(artifact, "blocked", safeErrorMessage(error))) };
+  }
+  return {
+    included: materialized.written.map((repoPath) => artifactStatus(findArtifactByPath(artifacts, repoPath), "included", "Approved artifact materialized into the implementation worktree.")),
+    skipped: [...skipped, ...materialized.skipped.map((repoPath) => artifactStatus(findArtifactByPath(artifacts, repoPath), "skipped", "Approved artifact was already current in the implementation worktree."))],
+    blocked: materialized.conflicts.map((conflict) => artifactStatus(findArtifactByPath(artifacts, conflictRepoPath(conflict)), "blocked", conflict))
+  };
+}
+function selectApprovedWorkArtifacts(workItem, documents) {
+  const draftId = workItem.generatedDraftId;
+  const explicitDocumentIds = new Set([workItem.reviewDocumentId, workItem.impactDocumentId].filter((value) => Boolean(value)));
+  const scopeIds = new Set([workItem.workItemId, workItem.controllingAdrId, workItem.implementationScopeId].filter((value) => Boolean(value)));
+  const skipped = [];
+  const selected = documents.filter((document) => {
+    const inScope = Boolean(draftId && document.frontmatter.generatedDraftId === draftId || explicitDocumentIds.has(document.documentId) || explicitDocumentIds.has(document.id) || [document.frontmatter.workItemId, document.frontmatter.generationWorkItemId, document.frontmatter.revisionWorkItemId, document.frontmatter.controllingAdrId, document.frontmatter.adrId, document.frontmatter.implementationScopeId].some((value) => typeof value === "string" && scopeIds.has(value)));
+    if (!inScope) return false;
+    if (document.status !== "approved" && document.syncState !== "approved" && document.syncState !== "synced") {
+      skipped.push(artifactStatus(document, "skipped", "Artifact is not approved for repository inclusion."));
+      return false;
+    }
+    if (!["markdown", "html", void 0].includes(document.contentFormat)) {
+      skipped.push(artifactStatus(document, "skipped", "Artifact format is not supported for implementation PR inclusion."));
+      return false;
+    }
+    return true;
+  });
+  const byDocumentId = /* @__PURE__ */ new Map();
+  for (const document of selected) {
+    byDocumentId.set(document.documentId, document);
+  }
+  return { selected: [...byDocumentId.values()], skipped };
+}
+function findArtifactByPath(artifacts, repoPath) {
+  return artifacts.find((artifact) => artifact.repoPath === repoPath) ?? artifacts[0];
+}
+function artifactStatus(artifact, status, message) {
+  return {
+    documentId: artifact.documentId,
+    title: truncate(artifact.title, 200),
+    repoPath: artifact.repoPath,
+    contentFormat: artifact.contentFormat ?? "markdown",
+    status,
+    message: truncate(message, 600)
+  };
+}
+function conflictRepoPath(conflict) {
+  return conflict.split(":")[0]?.trim() ?? conflict;
+}
 async function ensureGithubPullRequest(run, cwd, input) {
   const existing = await run("gh", ["pr", "list", "--head", input.headBranch, "--base", input.baseBranch, "--state", "open", "--json", "number,url", "--limit", "1"], { cwd });
   const parsed = parsePullRequestList(existing.stdout);
@@ -6283,7 +7511,7 @@ async function cleanupWorktree(run, input) {
     return { status: "failed", message: "Cleanup skipped because the worktree is not clean after PR handoff." };
   }
   try {
-    await gitOutput2(run, input.primaryRepoRoot || path14.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
+    await gitOutput2(run, input.primaryRepoRoot || path15.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
     return { status: "completed" };
   } catch (error) {
     return { status: "failed", message: `Cleanup failed: ${safeErrorMessage(error)}` };
@@ -6296,6 +7524,10 @@ async function resolveRemoteName(run, cwd) {
   }
   return remotes.includes("origin") ? "origin" : remotes[0];
 }
+async function rebaseBranchFromRemoteBase(run, cwd, input) {
+  await gitOutput2(run, cwd, ["fetch", input.remoteName, input.baseBranch]);
+  await gitOutput2(run, cwd, ["rebase", "FETCH_HEAD"]);
+}
 async function gitOutput2(run, cwd, args) {
   const result = await run("git", args, { cwd });
   return result.stdout.trim();
@@ -6351,9 +7583,23 @@ function pullRequestBody(input) {
     `Base branch: ${input.baseBranch}`,
     `Head branch: ${input.headBranch}`,
     "",
+    ...artifactSummaryLines(input.artifacts),
+    "",
     input.verificationSummary ?? "Verification summary was not reported by the local runner."
   ].join("\n");
 }
+function artifactSummaryLines(artifacts) {
+  if (!artifacts || !artifacts.included.length && !artifacts.skipped.length && !artifacts.blocked.length) {
+    return ["Approved artifacts: none materialized for this handoff."];
+  }
+  const lines = [
+    `Approved artifacts: ${artifacts.included.length} included, ${artifacts.skipped.length} already current, ${artifacts.blocked.length} blocked.`
+  ];
+  for (const artifact of artifacts.included.slice(0, 12)) {
+    lines.push(`- ${artifact.repoPath}${artifact.title ? ` (${artifact.title})` : ""}`);
+  }
+  return lines;
+}
 function truncate(value, maxLength) {
   return value.length <= maxLength ? value : value.slice(0, maxLength - 1).trimEnd();
 }
@@ -6394,7 +7640,8 @@ var DEFAULT_MAX_PREFLIGHT_ATTEMPTS = 3;
 var DEFAULT_TOOL_TIMEOUT_SECONDS = 30 * 60;
 var RUNNER_WORK_LEASE_SECONDS = 300;
 var RUNNER_WORK_LEASE_RENEWAL_MS = 12e4;
-var runnerSupportedWorkKinds = ["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification"];
+var MAX_CONCURRENT_RUNNER_WORK = 4;
+var runnerSupportedWorkKinds = ["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate"];
 program.name("amistio").description("Amistio project brain CLI").version(CLI_VERSION);
 program.command("init").description("Create Amistio control-plane folders for a new project").option("--root <path>", "Repository root", defaultRoot).action(async (options) => {
   const created = await initControlPlane(options.root);
@@ -6677,7 +7924,7 @@ work.command("list").description("List queued work without claiming it").option(
     return;
   }
   for (const item of workItems) {
-    console.log(`${item.workItemId} [${item.status}] ${item.title}`);
+    console.log(`${item.workItemId} [${item.status}] ${item.title}${formatAutopilotListSuffix(item)}`);
   }
 });
 work.command("prompt").description("Print or write an approved work prompt without claiming a runner lease").argument("[workItemId]", "Work item ID. Defaults to the newest approved work item.").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--out <path>", "Write the prompt to a file instead of stdout").action(async (workItemId, options) => {
@@ -6694,7 +7941,7 @@ work.command("prompt").description("Print or write an approved work prompt witho
   }
   const prompt = await createRunnerWorkPrompt(context.client, context.metadata.amistioProjectId, workItem);
   if (options.out) {
-    await writeFile9(options.out, prompt, "utf8");
+    await writeFile10(options.out, prompt, "utf8");
     console.log(`Wrote work prompt to ${options.out}.`);
   } else {
     console.log(prompt);
@@ -6743,7 +7990,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("--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-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("--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) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -6761,6 +8008,11 @@ program.command("run").description("Claim and run approved Amistio work locally"
     machineId: runnerMachineId()
   });
   const resolvedOptions = { ...options, runnerId };
+  if (resolvedOptions.maxConcurrentWork > MAX_CONCURRENT_RUNNER_WORK) {
+    console.log(`--max-concurrent-work is capped at ${MAX_CONCURRENT_RUNNER_WORK}.`);
+    process.exitCode = 1;
+    return;
+  }
   if (options.background) {
     if (options.dryRun) {
       console.log("Background runners cannot be started in dry-run mode.");
@@ -6772,7 +8024,7 @@ program.command("run").description("Claim and run approved Amistio work locally"
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
       runnerId,
-      rootDir: path15.resolve(options.root),
+      rootDir: path16.resolve(options.root),
       apiUrl: options.apiUrl,
       args: buildBackgroundRunnerArgs(resolvedOptions)
     });
@@ -6915,7 +8167,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("--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-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("--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) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -6938,13 +8190,18 @@ runnerService.command("install").description("Install a user-level startup servi
     repositoryLinkId: context.metadata.repositoryLinkId,
     machineId: runnerMachineId()
   });
+  if (options.maxConcurrentWork > MAX_CONCURRENT_RUNNER_WORK) {
+    console.log(`--max-concurrent-work is capped at ${MAX_CONCURRENT_RUNNER_WORK}.`);
+    process.exitCode = 1;
+    return;
+  }
   const args = buildBackgroundRunnerArgs({ ...options, runnerId, apiUrl: options.apiUrl, root: options.root });
   const serviceInput = {
     accountId: context.metadata.amistioAccountId,
     projectId: context.metadata.amistioProjectId,
     repositoryLinkId: context.metadata.repositoryLinkId,
     runnerId,
-    rootDir: path15.resolve(options.root),
+    rootDir: path16.resolve(options.root),
     apiUrl: options.apiUrl,
     args,
     platform
@@ -7015,7 +8272,20 @@ async function runWatchIteration({ command, context, options, runnerId }) {
         runnerId
       });
     }
-    return await runNextWorkItem({
+    if (!options.dryRun) {
+      const replayResult = await replayPendingResultFinalizations({
+        accountId: context.metadata.amistioAccountId,
+        apiClient: context.client,
+        projectId: context.metadata.amistioProjectId,
+        repositoryLinkId: context.metadata.repositoryLinkId,
+        runnerId
+      });
+      if (replayResult) {
+        return replayResult;
+      }
+    }
+    const activeClaimLaneIds = claimLaneIds(options.maxConcurrentWork);
+    const runLane = (claimLaneId, laneIndex) => runNextWorkItem({
       apiClient: context.client,
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
@@ -7044,8 +8314,16 @@ async function runWatchIteration({ command, context, options, runnerId }) {
       suppressIdleOutput: Boolean(options.watch),
       maxPreflightAttempts: options.maxPreflightAttempts,
       toolTimeoutMs: options.toolTimeoutSeconds * 1e3,
-      verbose: Boolean(options.verbose)
+      verbose: Boolean(options.verbose),
+      claimLaneId,
+      maxConcurrentWork: options.maxConcurrentWork,
+      activeClaimLaneIds,
+      skipRunnerCommands: laneIndex > 0
     });
+    if (options.watch && !options.dryRun && options.maxConcurrentWork > 1) {
+      return aggregateRunnerLaneResults(await Promise.all(activeClaimLaneIds.map((claimLaneId, laneIndex) => runLane(claimLaneId, laneIndex))));
+    }
+    return await runLane("default", 0);
   } catch (error) {
     if (!options.watch) {
       throw error;
@@ -7073,6 +8351,23 @@ ${detail}`);
     return { status: "failed", exitCode: 1, message };
   }
 }
+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;
+  const failedResult = results.find((result) => result.status === "failed");
+  if (failedResult) return failedResult;
+  const blockedResult = results.find((result) => result.status === "blocked");
+  if (blockedResult) return blockedResult;
+  const completedResult = results.find((result) => result.status === "completed" || result.status === "preview");
+  if (completedResult) return completedResult;
+  return results.find((result) => result.status === "idle") ?? { status: "idle", exitCode: 0 };
+}
 async function runAutoSyncCycle({ context, maxFileKb, quiet, quietDisabled, root, runnerId }) {
   const projectId = context.metadata.amistioProjectId;
   const repositoryLinkId = context.metadata.repositoryLinkId;
@@ -7152,7 +8447,11 @@ async function runNextWorkItem({
   commandContext,
   suppressIdleOutput,
   toolTimeoutMs,
-  verbose
+  verbose,
+  claimLaneId,
+  maxConcurrentWork,
+  activeClaimLaneIds,
+  skipRunnerCommands
 }) {
   const toolConfig = await resolveRunnerToolConfig({
     apiClient,
@@ -7166,19 +8465,27 @@ async function runNextWorkItem({
     ...explicitTool ? { explicitTool } : {},
     ...toolCommand ? { toolCommand } : {}
   });
-  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, toolConfig.ready ? "online" : "blocked", runnerHeartbeatMetadata(toolConfig));
-  const commandResult = await runPendingRunnerCommand(apiClient, commandContext, runnerHeartbeatMetadata(toolConfig));
-  if (commandResult.handled) {
-    if (commandResult.message) {
-      console.log(commandResult.message);
+  const effectiveMaxConcurrentWork = supportsConcurrentLocalToolExecution(toolConfig) ? maxConcurrentWork : 1;
+  const effectiveActiveClaimLaneIds = claimLaneIds(effectiveMaxConcurrentWork);
+  const heartbeatConcurrency = { maxConcurrentWork: effectiveMaxConcurrentWork, activeClaimLaneIds: effectiveActiveClaimLaneIds };
+  if (claimLaneId !== "default" && effectiveMaxConcurrentWork === 1) {
+    return { status: "idle", exitCode: 0 };
+  }
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, toolConfig.ready ? "online" : "blocked", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency));
+  if (!skipRunnerCommands) {
+    const commandResult = await runPendingRunnerCommand(apiClient, commandContext, runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency));
+    if (commandResult.handled) {
+      if (commandResult.message) {
+        console.log(commandResult.message);
+      }
+      return { status: commandResult.succeeded ? "completed" : "failed", exitCode: commandResult.succeeded ? 0 : 1, ...commandResult.stopRunner ? { stopRunner: true } : {} };
     }
-    return { status: commandResult.succeeded ? "completed" : "failed", exitCode: commandResult.succeeded ? 0 : 1, ...commandResult.stopRunner ? { stopRunner: true } : {} };
   }
   if (!toolConfig.ready) {
     console.log(toolConfig.message);
     return { status: "blocked", exitCode: 1 };
   }
-  const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId, RUNNER_WORK_LEASE_SECONDS, runnerIsolationCapabilityMetadata());
+  const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId, RUNNER_WORK_LEASE_SECONDS, runnerIsolationCapabilityMetadata({ claimLaneId, maxConcurrentWork: effectiveMaxConcurrentWork }));
   if (!result.workItem) {
     const nextAction = await loadProjectNextAction(apiClient, projectId, repositoryLinkId, root);
     const message = formatProjectNextAction(nextAction);
@@ -7196,17 +8503,17 @@ async function runNextWorkItem({
   });
   if (dryRun || toolConfig.tool === "none") {
     console.log(prompt);
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency));
     return { status: "preview", exitCode: 0 };
   }
-  const worktreeIsolation = await prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem: result.workItem });
+  const worktreeIsolation = await prepareWorktreeForClaimedItem({ apiClient, heartbeatConcurrency, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem: result.workItem });
   if (worktreeIsolation.status !== "ready") {
     return { status: worktreeIsolation.status === "failed" ? "failed" : "blocked", exitCode: 1, message: worktreeIsolation.message };
   }
   const executionRoot = worktreeIsolation.isolation?.worktreePath ?? root;
   const isolationTelemetry = workItemIsolationTelemetry(result.workItem, worktreeIsolation.isolation);
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "running", {
-    ...runnerHeartbeatMetadata(toolConfig),
+    ...runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency),
     currentWorkItemId: result.workItem.workItemId,
     ...isolationTelemetry.implementationScopeId ? { currentImplementationScopeId: isolationTelemetry.implementationScopeId } : {},
     ...isolationTelemetry.executionWorktreeKey ? { currentWorktreeKey: isolationTelemetry.executionWorktreeKey } : {},
@@ -7229,6 +8536,10 @@ async function runNextWorkItem({
     isolationTelemetry
   });
   console.log(`Claimed ${result.workItem.workItemId}. Running ${preview.toolName}: ${preview.displayCommand}`);
+  const autopilotClaimLine = formatAutopilotClaimLine(result.workItem);
+  if (autopilotClaimLine) {
+    console.log(autopilotClaimLine);
+  }
   await recordRunnerMilestone(apiClient, projectId, result.workItem, runnerId, repositoryLinkId, {
     status: "running",
     summary: `Local runner started ${preview.toolName} execution.`,
@@ -7239,7 +8550,7 @@ async function runNextWorkItem({
   const providerSessionStore = new LocalToolSessionStore();
   const providerSessionId = sessionContext.toolSession ? await providerSessionStore.getProviderSessionId(sessionContext.toolSession.toolSessionId, preview.toolName) : void 0;
   let toolResult;
-  const stopLeaseRenewal = startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem: result.workItem, telemetry: isolationTelemetry });
+  const stopLeaseRenewal = startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem: result.workItem, telemetry: isolationTelemetry, heartbeatConcurrency });
   try {
     toolResult = await runLocalTool({
       rootDir: executionRoot,
@@ -7265,7 +8576,7 @@ async function runNextWorkItem({
     const durationMs2 = Date.now() - startedAt;
     const message = `${preview.toolName} failed before returning a result.`;
     const settlements = await Promise.allSettled([
-      apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)),
+      apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency)),
       markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage3(error)),
       apiClient.updateWorkStatus(projectId, result.workItem.workItemId, "failed", `run_failed_${result.workItem.workItemId}_${result.workItem.attempt}_${runnerId}`, runnerId, {
         ...isolationTelemetry,
@@ -7448,6 +8759,42 @@ async function runNextWorkItem({
       return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
     }
   }
+  if (result.workItem.workKind === "testQualityScan") {
+    try {
+      return await finalizeTestQualityScanWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
+  }
+  if (result.workItem.workKind === "implementationTestGate") {
+    try {
+      return await finalizeImplementationTestGateWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
+  }
   let finalStatus = toolResult.exitCode === 0 ? "completed" : "failed";
   const durationMs = Date.now() - startedAt;
   const failureExcerpt = toolResult.exitCode === 0 ? void 0 : truncateLogExcerpt(toolResult.stderr || toolResult.stdout);
@@ -7462,14 +8809,27 @@ async function runNextWorkItem({
       metadata: { executionWorktreeKey: isolationTelemetry.executionWorktreeKey ?? "", executionBranch: isolationTelemetry.executionBranch ?? "" }
     });
     const repositoryLink = await loadWorkItemRepositoryLink(apiClient, projectId, result.workItem.repositoryLinkId ?? repositoryLinkId);
-    implementationHandoff = await completeImplementationHandoff({
-      primaryRepoRoot: root,
-      ...repositoryLink ? { repositoryLink } : {},
-      verificationSummary: "Local execution reported completion.",
-      workItem: result.workItem,
-      ...worktreeIsolation.isolation ? { worktreeIsolation: worktreeIsolation.isolation } : {},
-      worktreePath: executionRoot
+    const approvedArtifacts = await apiClient.listBrainDocuments(projectId).then((response) => response.documents).catch((error) => {
+      implementationHandoff = {
+        status: "blocked",
+        cleanupStatus: "pending",
+        artifacts: { included: [], skipped: [], blocked: [] },
+        message: "Implementation handoff is blocked because approved artifact metadata could not be loaded.",
+        error: truncateLogExcerpt(errorDetail(error))
+      };
+      return void 0;
     });
+    if (!implementationHandoff) {
+      implementationHandoff = await completeImplementationHandoff({
+        ...approvedArtifacts ? { approvedArtifacts } : {},
+        primaryRepoRoot: root,
+        ...repositoryLink ? { repositoryLink } : {},
+        verificationSummary: "Local execution reported completion.",
+        workItem: result.workItem,
+        ...worktreeIsolation.isolation ? { worktreeIsolation: worktreeIsolation.isolation } : {},
+        worktreePath: executionRoot
+      });
+    }
     finalStatus = implementationHandoff.status === "prReady" || implementationHandoff.status === "noChanges" ? "completed" : "blocked";
     finalMessage = implementationHandoff.message ?? "Implementation handoff finished.";
     finalError = implementationHandoff.error;
@@ -7487,31 +8847,48 @@ async function runNextWorkItem({
     ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
     ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
   });
-  const statusResult = await apiClient.updateWorkStatus(
-    projectId,
-    result.workItem.workItemId,
-    finalStatus,
-    `run_${result.workItem.workItemId}_${randomUUID()}`,
-    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 } : {},
-      ...finalError ? { error: finalError } : {}
+  let statusResult;
+  try {
+    statusResult = await apiClient.updateWorkStatus(
+      projectId,
+      result.workItem.workItemId,
+      finalStatus,
+      `run_${result.workItem.workItemId}_${randomUUID()}`,
+      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 } : {},
+        ...finalError ? { error: finalError } : {}
+      }
+    );
+  } 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.";
+      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 };
     }
-  );
+    throw error;
+  }
   await recordRunnerMilestone(apiClient, projectId, result.workItem, runnerId, repositoryLinkId, {
     status: finalStatus,
     summary: finalMessage,
@@ -7525,19 +8902,27 @@ async function runNextWorkItem({
       executionBranch: isolationTelemetry.executionBranch ?? "",
       ...implementationHandoff?.status ? { handoffStatus: implementationHandoff.status } : {},
       ...implementationHandoff?.prUrl ? { prUrl: implementationHandoff.prUrl } : {},
-      ...implementationHandoff?.cleanupStatus ? { cleanupStatus: implementationHandoff.cleanupStatus } : {}
+      ...implementationHandoff?.cleanupStatus ? { cleanupStatus: implementationHandoff.cleanupStatus } : {},
+      ...implementationHandoff?.artifacts ? artifactHandoffMetadata(implementationHandoff.artifacts) : {}
     }
   });
-  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency));
   const durationSeconds = Math.round(durationMs / 1e3);
   console.log(`Marked ${statusResult.workItem.workItemId} ${statusResult.workItem.status} after ${durationSeconds}s.`);
   return { status: finalStatus, exitCode: finalStatus === "completed" ? toolResult.exitCode : 1 };
 }
+function artifactHandoffMetadata(artifacts) {
+  return {
+    artifactIncludedCount: artifacts.included.length,
+    artifactSkippedCount: artifacts.skipped.length,
+    artifactBlockedCount: artifacts.blocked.length
+  };
+}
 async function loadWorkItemRepositoryLink(apiClient, projectId, repositoryLinkId) {
   const { repositoryLinks } = await apiClient.listRepositoryLinks(projectId);
   return repositoryLinks.find((link) => link.repositoryLinkId === repositoryLinkId && link.status !== "revoked");
 }
-async function prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem }) {
+async function prepareWorktreeForClaimedItem({ apiClient, heartbeatConcurrency, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem }) {
   if (!needsGitWorktreeIsolation(workItem)) {
     return { status: "ready" };
   }
@@ -7552,9 +8937,9 @@ async function prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts,
     const isolation = await prepareGitWorktreeIsolation(root, workItem);
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "running",
-      summary: `Prepared Git worktree ${isolation.worktreeKey} on ${isolation.branch}.`,
+      summary: isolation.preparedLocalEnvironmentFileCount ? `Prepared Git worktree ${isolation.worktreeKey} on ${isolation.branch} and local environment files.` : `Prepared Git worktree ${isolation.worktreeKey} on ${isolation.branch}.`,
       idempotencyKey: `runner_milestone_worktree_${workItem.workItemId}_${workItem.attempt}`,
-      metadata: { executionWorktreeKey: isolation.worktreeKey, executionBranch: isolation.branch, implementationScopeId: isolation.implementationScopeId }
+      metadata: { executionWorktreeKey: isolation.worktreeKey, executionBranch: isolation.branch, implementationScopeId: isolation.implementationScopeId, ...isolation.preparedLocalEnvironmentFileCount ? { preparedLocalEnvironmentFileCount: isolation.preparedLocalEnvironmentFileCount } : {} }
     });
     return { status: "ready", isolation };
   } catch (error) {
@@ -7575,14 +8960,14 @@ async function prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts,
       metadata: { executionWorktreeKey: telemetry.executionWorktreeKey ?? "", executionBranch: telemetry.executionBranch ?? "", implementationScopeId: telemetry.implementationScopeId ?? "", attempt: workItem.attempt, maxAttempts: maxPreflightAttempts, error: message }
     });
     await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", {
-      ...runnerHeartbeatMetadata(toolConfig),
+      ...runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency),
       preferenceMessage: statusMessage
     });
     console.error(statusMessage);
     return { status: finalAttempt ? "failed" : "retrying", message: statusMessage };
   }
 }
-function startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem, telemetry }) {
+function startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem, telemetry, heartbeatConcurrency }) {
   let stopped = false;
   const renew = async () => {
     if (stopped) return;
@@ -7593,7 +8978,7 @@ function startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerI
         leaseExpiresAt
       });
       await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "running", {
-        ...runnerHeartbeatMetadata(toolConfig),
+        ...runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency),
         currentWorkItemId: workItem.workItemId,
         ...telemetry.implementationScopeId ? { currentImplementationScopeId: telemetry.implementationScopeId } : {},
         ...telemetry.executionWorktreeKey ? { currentWorktreeKey: telemetry.executionWorktreeKey } : {},
@@ -7609,6 +8994,7 @@ function startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerI
         workItemId: workItem.workItemId,
         workTitle: workItem.title,
         ...workItem.workKind ? { workKind: workItem.workKind } : {},
+        ...workItem.claimLaneId ? { claimLaneId: workItem.claimLaneId } : {},
         message: "Runner could not renew the active work lease.",
         error: detail,
         machineId: runnerMachineId()
@@ -7648,6 +9034,7 @@ async function recordFinalizationFailure({ apiClient, durationMs, error, isolati
       workItemId: workItem.workItemId,
       workTitle: workItem.title,
       ...workItem.workKind ? { workKind: workItem.workKind } : {},
+      ...workItem.claimLaneId ? { claimLaneId: workItem.claimLaneId } : {},
       tool: toolName,
       durationMs,
       message,
@@ -7672,6 +9059,7 @@ function workItemIsolationTelemetry(workItem, isolation) {
   const repositoryLockId = isolation?.repositoryLockId ?? workItem.repositoryLockId;
   return {
     ...needsGitWorktreeIsolation(workItem) ? { isolationMode: "gitWorktree" } : workItem.isolationMode ? { isolationMode: workItem.isolationMode } : {},
+    ...workItem.claimLaneId ? { claimLaneId: workItem.claimLaneId } : {},
     ...workItem.claimLeaseId ? { claimLeaseId: workItem.claimLeaseId } : {},
     ...workItem.controllingAdrId ? { controllingAdrId: workItem.controllingAdrId } : {},
     ...implementationScopeId ? { implementationScopeId } : {},
@@ -7683,17 +9071,60 @@ function workItemIsolationTelemetry(workItem, isolation) {
   };
 }
 async function recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, input) {
+  const autopilot = autopilotWorkMetadata2(workItem);
+  const metadata = { ...autopilotRunnerMetadata(workItem), ...workItem.claimLaneId ? { claimLaneId: workItem.claimLaneId } : {}, ...input.metadata ?? {} };
   await apiClient.recordActivityEvent(projectId, {
     eventType: "runnerMilestone",
     runnerId,
     repositoryLinkId,
+    ...workItem.claimLaneId ? { claimLaneId: workItem.claimLaneId } : {},
     relatedWorkItemId: workItem.workItemId,
     ...workItem.reviewDocumentId ? { relatedDocumentId: workItem.reviewDocumentId } : workItem.impactDocumentId ? { relatedDocumentId: workItem.impactDocumentId } : {},
     ...workItem.issueId ? { relatedIssueId: workItem.issueId } : {},
+    ...autopilot.autopilotAuthorizationId ? { relatedAutopilotAuthorizationId: autopilot.autopilotAuthorizationId } : {},
+    ...autopilot.autopilotCandidateId ? { relatedAutopilotCandidateId: autopilot.autopilotCandidateId } : {},
     ...workItem.generatedDraftId ? { generatedDraftId: workItem.generatedDraftId } : {},
-    ...input
+    ...input,
+    ...Object.keys(metadata).length ? { metadata } : {}
   }).catch(() => void 0);
 }
+function formatAutopilotListSuffix(workItem) {
+  const autopilot = autopilotWorkMetadata2(workItem);
+  if (!autopilot.autopilotAuthorizationId) {
+    return "";
+  }
+  const details = [
+    autopilot.autopilotClassificationOutcome ?? "authorized",
+    workItem.workKind ?? "implementation",
+    autopilot.autopilotCandidateType,
+    autopilot.autopilotPolicyVersion ? `policy ${autopilot.autopilotPolicyVersion}` : void 0,
+    `auth ${autopilot.autopilotAuthorizationId}`,
+    autopilot.autopilotCandidateId ? `candidate ${autopilot.autopilotCandidateId}` : void 0
+  ].filter(Boolean).join(", ");
+  return ` (autopilot: ${details})`;
+}
+function formatAutopilotClaimLine(workItem) {
+  const autopilot = autopilotWorkMetadata2(workItem);
+  if (!autopilot.autopilotAuthorizationId) {
+    return void 0;
+  }
+  const candidate = autopilot.autopilotCandidateId ? `, candidate ${autopilot.autopilotCandidateId}` : "";
+  const candidateType = autopilot.autopilotCandidateType ? `, ${autopilot.autopilotCandidateType}` : "";
+  return `Autopilot authorization: ${autopilot.autopilotAuthorizationId} (${autopilot.autopilotClassificationOutcome ?? "authorized"}, ${workItem.workKind ?? "implementation"}${candidateType}, policy ${autopilot.autopilotPolicyVersion ?? "unknown"}${candidate}). Local runner safety rules still apply.`;
+}
+function autopilotRunnerMetadata(workItem) {
+  const autopilot = autopilotWorkMetadata2(workItem);
+  return {
+    ...autopilot.autopilotAuthorizationId ? { autopilotAuthorizationId: autopilot.autopilotAuthorizationId } : {},
+    ...autopilot.autopilotCandidateId ? { autopilotCandidateId: autopilot.autopilotCandidateId } : {},
+    ...autopilot.autopilotCandidateType ? { autopilotCandidateType: autopilot.autopilotCandidateType } : {},
+    ...autopilot.autopilotClassificationOutcome ? { autopilotOutcome: autopilot.autopilotClassificationOutcome } : {},
+    ...autopilot.autopilotPolicyVersion ? { autopilotPolicyVersion: autopilot.autopilotPolicyVersion } : {}
+  };
+}
+function autopilotWorkMetadata2(workItem) {
+  return workItem;
+}
 function logRejectedSettlements(action, settlements) {
   for (const settlement of settlements) {
     if (settlement.status === "rejected") {
@@ -7762,6 +9193,201 @@ function runnerCommandLabel(commandKind) {
   if (commandKind === "restart") return "restart";
   return "remove";
 }
+async function replayPendingBrainGenerationFinalizations({ accountId, apiClient, projectId, repositoryLinkId, runnerId }) {
+  const pendingEntries = await listPendingBrainGenerationFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
+  if (!pendingEntries.length) {
+    return void 0;
+  }
+  let completedCount = 0;
+  for (const entry of pendingEntries) {
+    const replay = await submitBrainGenerationFinalizationEntry(apiClient, entry, { recordReplayTelemetry: true });
+    if (replay.status === "completed") {
+      completedCount += 1;
+      continue;
+    }
+    return { status: "failed", exitCode: 1, message: replay.message };
+  }
+  const message = `Replayed ${completedCount} pending brain generation finalization${completedCount === 1 ? "" : "s"}.`;
+  console.log(message);
+  return { status: "completed", exitCode: 0, message };
+}
+async function replayPendingResultFinalizations({ accountId, apiClient, projectId, repositoryLinkId, runnerId }) {
+  const brainReplay = await replayPendingBrainGenerationFinalizations({ accountId, apiClient, projectId, repositoryLinkId, runnerId });
+  if (brainReplay) {
+    return brainReplay;
+  }
+  const pendingEntries = await listPendingDurableResultFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
+  if (!pendingEntries.length) {
+    return void 0;
+  }
+  let completedCount = 0;
+  for (const entry of pendingEntries) {
+    const replay = await submitDurableResultFinalizationEntry(apiClient, entry, { recordReplayTelemetry: true });
+    if (replay.status === "completed") {
+      completedCount += 1;
+      continue;
+    }
+    return { status: "failed", exitCode: 1, message: replay.message };
+  }
+  const message = `Replayed ${completedCount} pending runner result finalization${completedCount === 1 ? "" : "s"}.`;
+  console.log(message);
+  return { status: "completed", exitCode: 0, message };
+}
+async function submitBrainGenerationFinalizationEntry(apiClient, entry, options = {}) {
+  let result;
+  try {
+    result = await apiClient.submitBrainGenerationResult(entry.projectId, entry.workItemId, entry.result);
+  } catch (error) {
+    const detail = truncateLogExcerpt(errorMessage3(error));
+    if (isRetryableApiError(error)) {
+      const updated = await markBrainGenerationFinalizationRetry(entry, detail);
+      const message2 = `Pending brain generation 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 markBrainGenerationFinalizationTerminal(entry, detail);
+    const message = `Pending brain generation finalization ${entry.workItemId} reached a terminal API failure: ${detail}`;
+    console.error(message);
+    return { status: "failed", message, retryable: false };
+  }
+  await deleteBrainGenerationFinalizationEntry(entry).catch((error) => {
+    console.error(`delete pending brain generation finalization ${entry.workItemId} failed: ${errorMessage3(error)}`);
+  });
+  if (options.recordReplayTelemetry) {
+    await recordRunnerMilestone(apiClient, entry.projectId, result.workItem, entry.runnerId, entry.repositoryLinkId, {
+      status: entry.result.status,
+      summary: entry.result.status === "completed" ? "Replayed pending brain generation result finalization." : "Replayed pending brain generation failure finalization.",
+      idempotencyKey: `runner_milestone_generation_replayed_${entry.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { artifactCount: result.documents.length, replayedFinalization: true, workKind: entry.workKind }
+    });
+    await apiClient.sendRunnerHeartbeat(entry.projectId, entry.runnerId, entry.repositoryLinkId, "online", {
+      ...runnerHeartbeatMetadata(),
+      preferenceMessage: "Pending result finalization replayed."
+    }).catch(() => void 0);
+  }
+  return { status: "completed", workItem: result.workItem, documentCount: result.documents.length };
+}
+async function submitDurableResultFinalizationEntry(apiClient, entry, options = {}) {
+  let response;
+  try {
+    response = await submitDurableResultMutation(apiClient, entry);
+  } catch (error) {
+    const detail = truncateLogExcerpt(errorMessage3(error));
+    if (isRetryableApiError(error)) {
+      const updated = await markDurableResultFinalizationRetry(entry, detail);
+      const message2 = `Pending ${runnerResultFinalizationLabel(entry)} 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 markDurableResultFinalizationTerminal(entry, detail);
+    const message = `Pending ${runnerResultFinalizationLabel(entry)} finalization ${entry.workItemId} reached a terminal API failure: ${detail}`;
+    console.error(message);
+    return { status: "failed", message, retryable: false };
+  }
+  const workItem = durableResultResponseWorkItem(response);
+  await deleteDurableResultFinalizationEntry(entry).catch((error) => {
+    console.error(`delete pending ${runnerResultFinalizationLabel(entry)} finalization ${entry.workItemId} failed: ${errorMessage3(error)}`);
+  });
+  if (options.recordReplayTelemetry) {
+    await recordRunnerMilestone(apiClient, entry.projectId, workItem, entry.runnerId, entry.repositoryLinkId, {
+      status: entry.result.status,
+      summary: entry.result.status === "completed" ? `Replayed pending ${runnerResultFinalizationLabel(entry)} finalization.` : `Replayed pending ${runnerResultFinalizationLabel(entry)} failure finalization.`,
+      idempotencyKey: `runner_milestone_result_replayed_${entry.workItemId}_${workItem.idempotencyKey}`,
+      metadata: { replayedFinalization: true, resultKind: entry.resultKind, workKind: entry.workKind }
+    });
+    await apiClient.sendRunnerHeartbeat(entry.projectId, entry.runnerId, entry.repositoryLinkId, "online", {
+      ...runnerHeartbeatMetadata(),
+      preferenceMessage: "Pending result finalization replayed."
+    }).catch(() => void 0);
+  }
+  return { status: "completed", workItem, response };
+}
+async function submitDurableResultMutation(apiClient, entry) {
+  if (entry.resultKind === "assistantResult") {
+    return apiClient.submitAssistantResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "impactPreviewResult") {
+    return apiClient.submitImpactPreviewResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "issueDiagnosisResult") {
+    return apiClient.submitIssueDiagnosisResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "securityPostureScanResult") {
+    return apiClient.submitSecurityPostureScanResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "appEvaluationScanResult") {
+    return apiClient.submitAppEvaluationScanResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "projectContextRefreshResult") {
+    return apiClient.submitProjectContextRefreshResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "testQualityScanResult") {
+    return apiClient.submitTestQualityScanResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  if (entry.resultKind === "implementationTestGateResult") {
+    return apiClient.submitImplementationTestGateResult(entry.projectId, entry.workItemId, entry.result);
+  }
+  return apiClient.submitImplementationVerificationResult(entry.projectId, entry.workItemId, entry.result);
+}
+function durableResultResponseWorkItem(response) {
+  if (response && typeof response === "object" && "workItem" in response) {
+    return response.workItem;
+  }
+  throw new Error("Runner result finalization response did not include a work item.");
+}
+function runnerResultFinalizationLabel(entry) {
+  if (entry.workKind === "appEvaluationScan") return "app evaluation scan";
+  if (entry.workKind === "securityPostureScan") return "security posture scan";
+  if (entry.workKind === "projectContextRefresh") return "project context refresh";
+  if (entry.workKind === "implementationVerification") return "implementation verification";
+  if (entry.workKind === "testQualityScan") return "test quality scan";
+  if (entry.workKind === "implementationTestGate") return "implementation test gate";
+  if (entry.workKind === "issueDiagnosis") return "issue diagnosis";
+  if (entry.workKind === "impactPreview") return "impact preview";
+  return "assistant answer";
+}
+async function submitStagedDurableResultFinalization(apiClient, input) {
+  const entry = createDurableResultFinalizationEntry(input);
+  await upsertDurableResultFinalizationEntry(entry);
+  return submitDurableResultFinalizationEntry(apiClient, entry);
+}
+async function submitPrimaryRunnerResult(apiClient, input) {
+  const replay = await submitStagedDurableResultFinalization(apiClient, input);
+  if (replay.status === "failed") {
+    if (!replay.retryable) {
+      throw new Error(replay.message);
+    }
+    return void 0;
+  }
+  return replay.response;
+}
+function pendingSessionTelemetry(sessionContext) {
+  return {
+    sessionPolicy: sessionContext.policy,
+    sessionDecision: sessionContext.decision,
+    sessionDecisionReason: sessionContext.reason,
+    ...sessionContext.toolSession ? { toolSessionId: sessionContext.toolSession.toolSessionId } : {},
+    ...sessionContext.toolSession?.sessionGroupKey ? { sessionGroupKey: sessionContext.toolSession.sessionGroupKey } : {}
+  };
+}
+async function finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status, toolResult, workItemId }) {
+  const settlements = await Promise.allSettled([
+    finalizeToolSession({
+      apiClient,
+      projectId,
+      status,
+      runnerId,
+      workItemId,
+      stdout: toolResult.stdout,
+      ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+      ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+      ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+      ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+      ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+    })
+  ]);
+  logRejectedSettlements("finalize runner result tool session", settlements);
+}
 async function finalizeBrainGenerationWork({
   apiClient,
   durationMs,
@@ -7787,55 +9413,97 @@ ${toolResult.stderr}`);
     generationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = artifacts ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
   const sessionTelemetry = {
     sessionPolicy: sessionContext.policy,
     sessionDecision: sessionContext.decision,
     sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
+    ...sessionContext.toolSession ? { toolSessionId: sessionContext.toolSession.toolSessionId } : {},
+    ...sessionContext.toolSession?.sessionGroupKey ? { sessionGroupKey: sessionContext.toolSession.sessionGroupKey } : {}
   };
   if (artifacts) {
     const completionMessage = workItem.workKind === "planRevision" ? `${toolName} returned a revised plan for review.` : `${toolName} generated ${artifacts.length} brain artifact${artifacts.length === 1 ? "" : "s"}.`;
-    const result = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `generation_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`,
       artifacts,
       tool: toolName,
       durationMs,
       ...sessionTelemetry,
       message: completionMessage
+    };
+    const entry = createBrainGenerationFinalizationEntry({
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: brainGenerationFinalizationWorkKind(workItem.workKind),
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    await upsertBrainGenerationFinalizationEntry(entry);
+    const replay = await submitBrainGenerationFinalizationEntry(apiClient, entry);
+    if (replay.status === "failed") {
+      if (!replay.retryable) {
+        throw new Error(replay.message);
+      }
+      return { status: "failed", exitCode: 1 };
+    }
+    const toolSessionSettlement = await Promise.allSettled([
+      finalizeToolSession({
+        apiClient,
+        projectId,
+        status: finalStatus,
+        runnerId,
+        workItemId: workItem.workItemId,
+        stdout: toolResult.stdout,
+        ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+        ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+        ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+        ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+        ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+      })
+    ]);
+    logRejectedSettlements("finalize generation tool session", toolSessionSettlement);
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: completionMessage,
-      idempotencyKey: `runner_milestone_generation_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
-      metadata: { tool: toolName, durationMs, artifactCount: result.documents.length, verificationSummary: "Generated artifacts were accepted by the Amistio API for review." }
+      idempotencyKey: `runner_milestone_generation_completed_${workItem.workItemId}_${entry.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, artifactCount: replay.documentCount, verificationSummary: "Generated artifacts were accepted by the Amistio API for review." }
     });
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
-    console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `Generated ${result.documents.length} brain artifact${result.documents.length === 1 ? "" : "s"} for review.`);
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)).catch((error) => {
+      console.error(`send generation completion heartbeat failed: ${errorMessage3(error)}`);
+    });
+    console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `Generated ${replay.documentCount} brain artifact${replay.documentCount === 1 ? "" : "s"} for review.`);
     return { status: "completed", exitCode: 0 };
   }
+  const updatedToolSession = await finalizeToolSession({
+    apiClient,
+    projectId,
+    status: finalStatus,
+    runnerId,
+    workItemId: workItem.workItemId,
+    stdout: toolResult.stdout,
+    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+  });
+  const failedSessionTelemetry = {
+    ...sessionTelemetry,
+    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
+    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
+  };
   const failedResult = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
     status: "failed",
     runnerId,
     idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
     tool: toolName,
     durationMs,
-    ...sessionTelemetry,
+    ...failedSessionTelemetry,
     message: `${toolName} did not produce valid brain artifacts.`,
     ...generationError ? { error: generationError } : {}
   });
@@ -7849,6 +9517,9 @@ ${toolResult.stderr}`);
   console.error(generationError ?? "Local runner generation failed.");
   return { status: "failed", exitCode: toolResult.exitCode || 1 };
 }
+function brainGenerationFinalizationWorkKind(workKind) {
+  return workKind === "planRevision" ? "planRevision" : "brainGeneration";
+}
 async function finalizeAssistantQuestionWork({
   apiClient,
   durationMs,
@@ -7874,28 +9545,9 @@ ${toolResult.stderr}`);
     answerError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = answerResult ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (answerResult) {
-    const result = await apiClient.submitAssistantResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID()}`,
@@ -7906,7 +9558,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned a project knowledge answer.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "assistantQuestion",
+      resultKind: "assistantResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: `${toolName} returned a project knowledge answer.`,
@@ -7917,7 +9583,7 @@ ${toolResult.stderr}`);
     console.log("Project knowledge answer returned.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitAssistantResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID()}`,
@@ -7926,7 +9592,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid project knowledge answer.`,
     ...answerError ? { error: answerError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "assistantQuestion",
+    resultKind: "assistantResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: answerError ?? `${toolName} did not produce a valid project knowledge answer.`,
@@ -7963,29 +9643,10 @@ ${toolResult.stderr}`);
     previewError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = report ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (report) {
     const metadata = await readProjectLink(root).catch(() => void 0);
-    const result = await apiClient.submitImpactPreviewResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `impact_${workItem.workItemId}_${randomUUID()}`,
@@ -7997,7 +9658,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned an implementation impact preview.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "impactPreview",
+      resultKind: "impactPreviewResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: `${toolName} returned an implementation impact preview.`,
@@ -8008,7 +9683,7 @@ ${toolResult.stderr}`);
     console.log(result.implementationWorkItem ? "Impact preview returned; implementation work is now queued." : "Impact preview returned.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitImpactPreviewResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `impact_${workItem.workItemId}_${randomUUID()}`,
@@ -8017,7 +9692,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid impact preview.`,
     ...previewError ? { error: previewError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "impactPreview",
+    resultKind: "impactPreviewResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: previewError ?? `${toolName} did not produce a valid impact preview.`,
@@ -8053,28 +9742,9 @@ ${toolResult.stderr}`);
     diagnosisError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = diagnosis ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (diagnosis) {
-    const result = await apiClient.submitIssueDiagnosisResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
@@ -8083,7 +9753,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned an issue root-cause analysis.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "issueDiagnosis",
+      resultKind: "issueDiagnosisResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: `${toolName} returned an issue root-cause analysis.`,
@@ -8094,7 +9778,7 @@ ${toolResult.stderr}`);
     console.log("Issue diagnosis returned for approval.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitIssueDiagnosisResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
@@ -8103,7 +9787,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid issue diagnosis.`,
     ...diagnosisError ? { error: diagnosisError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "issueDiagnosis",
+    resultKind: "issueDiagnosisResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: diagnosisError ?? `${toolName} did not produce a valid issue diagnosis.`,
@@ -8139,28 +9837,9 @@ ${toolResult.stderr}`);
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = scanResult ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (scanResult) {
-    const result = await apiClient.submitSecurityPostureScanResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `security_${workItem.workItemId}_${randomUUID()}`,
@@ -8169,7 +9848,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned a security posture scan.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "securityPostureScan",
+      resultKind: "securityPostureScanResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: `${toolName} returned a security posture scan.`,
@@ -8180,7 +9873,7 @@ ${toolResult.stderr}`);
     console.log("Security posture scan returned for review.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitSecurityPostureScanResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `security_${workItem.workItemId}_${randomUUID()}`,
@@ -8189,7 +9882,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid security posture scan.`,
     ...scanError ? { error: scanError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "securityPostureScan",
+    resultKind: "securityPostureScanResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid security posture scan.`,
@@ -8225,28 +9932,9 @@ ${toolResult.stderr}`);
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = scanResult ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (scanResult) {
-    const result = await apiClient.submitAppEvaluationScanResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID()}`,
@@ -8255,7 +9943,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned an app evaluation scan.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "appEvaluationScan",
+      resultKind: "appEvaluationScanResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: `${toolName} returned an app evaluation scan.`,
@@ -8266,7 +9968,7 @@ ${toolResult.stderr}`);
     console.log("App evaluation scan returned for review.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitAppEvaluationScanResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID()}`,
@@ -8275,7 +9977,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid app evaluation scan.`,
     ...scanError ? { error: scanError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "appEvaluationScan",
+    resultKind: "appEvaluationScanResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid app evaluation scan.`,
@@ -8312,28 +10028,9 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     refreshError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = refreshResult ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (refreshResult) {
-    const result = await apiClient.submitProjectContextRefreshResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID()}`,
@@ -8342,7 +10039,21 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned a project context refresh.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "projectContextRefresh",
+      resultKind: "projectContextRefreshResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     const failureSummary = projectContextRefreshSubmissionFailureSummary(result);
     if (failureSummary) {
       await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
@@ -8365,7 +10076,7 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     console.log("Project context refresh returned for review.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitProjectContextRefreshResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID()}`,
@@ -8374,7 +10085,21 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid project context refresh.`,
     ...refreshError ? { error: refreshError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "projectContextRefresh",
+    resultKind: "projectContextRefreshResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: refreshError ?? `${toolName} did not produce a valid project context refresh.`,
@@ -8410,28 +10135,9 @@ ${toolResult.stderr}`);
     verificationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = verificationResult ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
-  const sessionTelemetry = {
-    sessionPolicy: sessionContext.policy,
-    sessionDecision: sessionContext.decision,
-    sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
-  };
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
   if (verificationResult) {
-    const result = await apiClient.submitImplementationVerificationResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
       idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID()}`,
@@ -8440,7 +10146,21 @@ ${toolResult.stderr}`);
       durationMs,
       ...sessionTelemetry,
       message: `${toolName} returned implementation verification proof.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "implementationVerification",
+      resultKind: "implementationVerificationResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: verificationResult.outcome === "verifiedImplemented" ? "completed" : verificationResult.outcome === "verificationBlocked" ? "blocked" : "warning",
       summary: verificationResult.summary,
@@ -8451,7 +10171,7 @@ ${toolResult.stderr}`);
     console.log("Implementation verification returned for review.");
     return { status: "completed", exitCode: 0 };
   }
-  const failedResult = await apiClient.submitImplementationVerificationResult(projectId, workItem.workItemId, {
+  const failedMutation = {
     status: "failed",
     runnerId,
     idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID()}`,
@@ -8460,7 +10180,21 @@ ${toolResult.stderr}`);
     ...sessionTelemetry,
     message: `${toolName} did not produce valid implementation verification proof.`,
     ...verificationError ? { error: verificationError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "implementationVerification",
+    resultKind: "implementationVerificationResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
   });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: verificationError ?? `${toolName} did not produce valid implementation verification proof.`,
@@ -8471,6 +10205,196 @@ ${toolResult.stderr}`);
   console.error(verificationError ?? "Local runner implementation verification failed.");
   return { status: "failed", exitCode: toolResult.exitCode || 1 };
 }
+async function finalizeTestQualityScanWork({
+  apiClient,
+  durationMs,
+  projectId,
+  repositoryLinkId,
+  runnerId,
+  sessionContext,
+  toolConfig,
+  toolName,
+  toolResult,
+  workItem
+}) {
+  let scanResult = void 0;
+  let scanError;
+  if (toolResult.exitCode === 0) {
+    try {
+      scanResult = parseTestQualityScanResult(`${toolResult.stdout}
+${toolResult.stderr}`);
+    } catch (error) {
+      scanError = errorMessage3(error);
+    }
+  } else {
+    scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
+  }
+  const finalStatus = scanResult ? "completed" : "failed";
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
+  if (scanResult) {
+    const resultMutation = {
+      status: "completed",
+      runnerId,
+      idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID()}`,
+      result: scanResult,
+      tool: toolName,
+      durationMs,
+      ...sessionTelemetry,
+      message: `${toolName} returned a test quality scan.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "testQualityScan",
+      resultKind: "testQualityScanResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
+    });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
+    await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+      status: scanResult.findings.some((finding) => finding.severity === "critical" || finding.severity === "high") ? "warning" : "completed",
+      summary: scanResult.summary,
+      idempotencyKey: `runner_milestone_test_quality_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, findingCount: scanResult.findings.length, commandCount: scanResult.commandSummaries.length, verificationSummary: scanResult.verificationPlan.join(" | ") }
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    console.log("Test quality scan returned for review.");
+    return { status: "completed", exitCode: 0 };
+  }
+  const failedMutation = {
+    status: "failed",
+    runnerId,
+    idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID()}`,
+    tool: toolName,
+    durationMs,
+    ...sessionTelemetry,
+    message: `${toolName} did not produce a valid test quality scan.`,
+    ...scanError ? { error: scanError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "testQualityScan",
+    resultKind: "testQualityScanResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
+  });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
+  await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+    status: "failed",
+    summary: scanError ?? `${toolName} did not produce a valid test quality scan.`,
+    idempotencyKey: `runner_milestone_test_quality_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    metadata: { tool: toolName, durationMs, verificationSummary: "Test quality output did not include valid structured JSON." }
+  });
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  console.error(scanError ?? "Local runner test quality scan failed.");
+  return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
+async function finalizeImplementationTestGateWork({
+  apiClient,
+  durationMs,
+  projectId,
+  repositoryLinkId,
+  runnerId,
+  sessionContext,
+  toolConfig,
+  toolName,
+  toolResult,
+  workItem
+}) {
+  let gateResult = void 0;
+  let gateError;
+  if (toolResult.exitCode === 0) {
+    try {
+      gateResult = parseImplementationTestGateResult(`${toolResult.stdout}
+${toolResult.stderr}`);
+    } catch (error) {
+      gateError = errorMessage3(error);
+    }
+  } else {
+    gateError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
+  }
+  const finalStatus = gateResult ? "completed" : "failed";
+  const sessionTelemetry = pendingSessionTelemetry(sessionContext);
+  if (gateResult) {
+    const resultMutation = {
+      status: "completed",
+      runnerId,
+      idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID()}`,
+      result: gateResult,
+      tool: toolName,
+      durationMs,
+      ...sessionTelemetry,
+      message: `${toolName} returned an implementation test gate result.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "implementationTestGate",
+      resultKind: "implementationTestGateResult",
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
+    });
+    if (!result) return { status: "failed", exitCode: 1 };
+    await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
+    await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+      status: gateResult.outcome === "passed" ? "completed" : gateResult.outcome === "blocked" ? "blocked" : "failed",
+      summary: gateResult.summary,
+      idempotencyKey: `runner_milestone_implementation_test_gate_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, outcome: gateResult.outcome, findingCount: gateResult.findings.length, commandCount: gateResult.commandSummaries.length, verificationSummary: gateResult.verificationPlan.join(" | ") }
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    console.log("Implementation test gate returned for review.");
+    return { status: gateResult.outcome === "passed" ? "completed" : "failed", exitCode: gateResult.outcome === "passed" ? 0 : 1 };
+  }
+  const failedMutation = {
+    status: "failed",
+    runnerId,
+    idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID()}`,
+    tool: toolName,
+    durationMs,
+    ...sessionTelemetry,
+    message: `${toolName} did not produce a valid implementation test gate result.`,
+    ...gateError ? { error: gateError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "implementationTestGate",
+    resultKind: "implementationTestGateResult",
+    attempt: workItem.attempt,
+    idempotencyKey: failedMutation.idempotencyKey,
+    result: failedMutation
+  });
+  if (!failedResult) return { status: "failed", exitCode: 1 };
+  await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
+  await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+    status: "failed",
+    summary: gateError ?? `${toolName} did not produce a valid implementation test gate result.`,
+    idempotencyKey: `runner_milestone_implementation_test_gate_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    metadata: { tool: toolName, durationMs, verificationSummary: "Implementation test gate output did not include valid structured JSON." }
+  });
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  console.error(gateError ?? "Local runner implementation test gate failed.");
+  return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
 async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
   if (workItem.workKind === "assistantQuestion") {
     const emptyProjectContext = { maps: [], refreshes: [], misses: [] };
@@ -8527,6 +10451,15 @@ async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
       appEvaluationScan: { documents: documents2 }
     });
   }
+  if (workItem.workKind === "testQualityScan") {
+    const { documents: documents2 } = await apiClient.listBrainDocuments(projectId);
+    return createWorkExecutionPrompt(workItem, {
+      testQualityScan: { documents: documents2 }
+    });
+  }
+  if (workItem.workKind === "implementationTestGate") {
+    return createWorkExecutionPrompt(workItem);
+  }
   if (workItem.workKind === "projectContextRefresh") {
     const emptyProjectContext = { maps: [], refreshes: [], misses: [] };
     const [{ documents: documents2 }, context] = await Promise.all([
@@ -8767,10 +10700,10 @@ function parseReasoningEffort(value) {
   throw new Error(`Expected reasoning effort auto, low, medium, high, or xhigh; received ${value}.`);
 }
 function inferRepoName(root) {
-  return path15.basename(path15.resolve(root)) || "repository";
+  return path16.basename(path16.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-  return createHash7("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+  return createHash8("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
 }
 function defaultApiUrl() {
   const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
@@ -9014,22 +10947,26 @@ function toRunnerToolCapabilities(tools) {
     supportsGitWorktreeIsolation: true
   }));
 }
-function runnerIsolationCapabilityMetadata() {
+function runnerIsolationCapabilityMetadata(laneMetadata = {}) {
   return {
     machineId: runnerMachineId(),
     supportedWorkKinds: runnerSupportedWorkKinds,
     supportsBranchIsolation: true,
-    supportsGitWorktreeIsolation: true
+    supportsGitWorktreeIsolation: true,
+    ...laneMetadata.claimLaneId ? { claimLaneId: laneMetadata.claimLaneId } : {},
+    ...laneMetadata.maxConcurrentWork !== void 0 ? { maxConcurrentWork: laneMetadata.maxConcurrentWork } : {}
   };
 }
-function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
+function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode(), concurrencyMetadata = { maxConcurrentWork: 1, activeClaimLaneIds: ["default"] }) {
   const modelConfig = toolConfig ? toolConfigModelOptions(toolConfig) : {};
   const effectiveModelConfig = toolConfig?.ready ? modelConfig : {};
   return {
     version: CLI_VERSION,
     mode,
-    hostname: os7.hostname(),
+    hostname: os8.hostname(),
     ...runnerIsolationCapabilityMetadata(),
+    maxConcurrentWork: concurrencyMetadata.maxConcurrentWork,
+    activeClaimLaneIds: concurrencyMetadata.activeClaimLaneIds,
     resourceUsage: sampleCurrentRunnerResourceUsage(),
     ...toolConfig?.capabilities ? { capabilities: toolConfig.capabilities } : {},
     ...toolConfig?.requestedTool ? { requestedTool: toolConfig.requestedTool } : {},
@@ -9051,7 +10988,7 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
   };
 }
 function runnerMachineId() {
-  return createHash7("sha256").update(`${os7.hostname()}:${os7.platform()}:${os7.arch()}`).digest("hex").slice(0, 20);
+  return createHash8("sha256").update(`${os8.hostname()}:${os8.platform()}:${os8.arch()}`).digest("hex").slice(0, 20);
 }
 async function delay(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));