@amistio/cli 0.1.24 → 0.1.26

package/dist/index.js

@@ -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,
@@ -2526,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,
@@ -2691,6 +3127,115 @@ var brainGenerationFinalizationEntrySchema = z4.object({
   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");
 }
@@ -2713,6 +3258,26 @@ function createBrainGenerationFinalizationEntry(input, now = (/* @__PURE__ */ ne
     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);
@@ -2745,6 +3310,38 @@ async function listPendingBrainGenerationFinalizations(scope, outboxDir = defaul
   }
   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,
@@ -2769,6 +3366,30 @@ async function markBrainGenerationFinalizationTerminal(entry, error, outboxDir =
 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`);
 }
@@ -2776,6 +3397,13 @@ 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;
@@ -4725,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;
@@ -4732,6 +5364,156 @@ 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 canonicalTestCommandKinds = /* @__PURE__ */ new Map([
+  ["verify", "verify"],
+  ["verification", "verify"],
+  ["wholeapp", "verify"],
+  ["wholeappverification", "verify"],
+  ["full", "verify"],
+  ["fullcheck", "verify"],
+  ["fullchecks", "verify"],
+  ["allcheck", "verify"],
+  ["allchecks", "verify"],
+  ["ci", "verify"],
+  ["continuousintegration", "verify"],
+  ["test", "test"],
+  ["tests", "test"],
+  ["testing", "test"],
+  ["unittest", "test"],
+  ["unittests", "test"],
+  ["integrationtest", "test"],
+  ["integrationtests", "test"],
+  ["e2etest", "test"],
+  ["e2etests", "test"],
+  ["endtoend", "test"],
+  ["endtoendtest", "test"],
+  ["spec", "test"],
+  ["specs", "test"],
+  ["suite", "test"],
+  ["testsuite", "test"],
+  ["jest", "test"],
+  ["vitest", "test"],
+  ["coverage", "coverage"],
+  ["coveragereport", "coverage"],
+  ["lint", "lint"],
+  ["linting", "lint"],
+  ["eslint", "lint"],
+  ["format", "lint"],
+  ["formatting", "lint"],
+  ["style", "lint"],
+  ["quality", "lint"],
+  ["qualitycheck", "lint"],
+  ["staticanalysis", "lint"],
+  ["typecheck", "typecheck"],
+  ["typechecks", "typecheck"],
+  ["typechecking", "typecheck"],
+  ["typecheck", "typecheck"],
+  ["tsc", "typecheck"],
+  ["typescript", "typecheck"],
+  ["build", "build"],
+  ["compile", "build"],
+  ["focused", "focused"],
+  ["focus", "focused"],
+  ["targeted", "focused"],
+  ["scoped", "focused"],
+  ["package", "focused"],
+  ["packaged", "focused"],
+  ["affected", "focused"],
+  ["affectedtests", "focused"],
+  ["touched", "focused"],
+  ["touchedtests", "focused"],
+  ["changed", "focused"],
+  ["changedtests", "focused"],
+  ["other", "focused"]
+]);
 var canonicalProjectContextCitationSources = /* @__PURE__ */ new Map([
   ["projectbrain", "projectBrain"],
   ["approvedbrain", "projectBrain"],
@@ -4756,6 +5538,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",
     "",
@@ -4789,22 +5572,114 @@ 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);
-  }
+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: verify, test, coverage, lint, typecheck, build, focused.",
+    "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);
   }
@@ -4817,6 +5692,12 @@ function createWorkExecutionPrompt(workItem, context) {
   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",
     "",
@@ -4831,6 +5712,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",
     "",
@@ -4845,6 +5727,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}`,
@@ -5016,6 +5919,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.",
     "",
@@ -5028,6 +5933,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"]}',
@@ -5358,7 +6267,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);
@@ -5381,6 +6291,68 @@ 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(normalizeTestQualityScanResultCommandKinds(parsed));
+}
+function normalizeTestQualityScanResultCommandKinds(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (isObjectRecord(normalized.profile) && Array.isArray(normalized.profile.commands)) {
+    normalized.profile = {
+      ...normalized.profile,
+      commands: normalized.profile.commands.map(normalizeTestCommandKindObject)
+    };
+  }
+  if (Array.isArray(normalized.commandSummaries)) {
+    normalized.commandSummaries = normalized.commandSummaries.map(normalizeTestCommandKindObject);
+  }
+  return normalized;
+}
+function normalizeTestCommandKindObject(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  return { ...value, kind: normalizeTestCommandKind(value.kind) };
+}
+function normalizeTestCommandKind(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return value;
+  }
+  const direct = canonicalTestCommandKinds.get(normalizeEnumKey(trimmed));
+  if (direct) {
+    return direct;
+  }
+  for (const segment of trimmed.split(/[\/,|]+/)) {
+    const segmentKind = canonicalTestCommandKinds.get(normalizeEnumKey(segment));
+    if (segmentKind) {
+      return segmentKind;
+    }
+  }
+  return "focused";
+}
+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;
@@ -5482,6 +6454,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";
@@ -6188,6 +7229,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) {
@@ -6271,10 +7313,12 @@ function truncateProcessOutput(value) {
 
 // src/git-worktree.ts
 import { execFile as execFile5 } from "node:child_process";
-import { mkdir as mkdir10, stat as stat5 } from "node:fs/promises";
+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";
 }
@@ -6299,7 +7343,8 @@ 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 mkdir10(path14.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
@@ -6307,7 +7352,8 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
   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 = path14.basename(repoRoot);
@@ -6334,6 +7380,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();
@@ -6356,6 +7451,12 @@ 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";
@@ -6375,9 +7476,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) {
@@ -6385,6 +7494,7 @@ async function completeImplementationHandoff(input) {
         ...common,
         status: "noChanges",
         cleanupStatus: "notApplicable",
+        artifacts: artifactResult,
         message: "Local execution completed with no repository changes to hand off."
       };
     }
@@ -6396,14 +7506,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",
@@ -6416,12 +7528,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);
@@ -6458,6 +7628,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();
@@ -6513,9 +7687,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();
 }
@@ -6556,7 +7744,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);
@@ -6839,7 +8028,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) => {
@@ -6905,7 +8094,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.");
@@ -6923,6 +8112,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.");
@@ -7077,7 +8271,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.");
@@ -7100,6 +8294,11 @@ 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,
@@ -7178,7 +8377,7 @@ async function runWatchIteration({ command, context, options, runnerId }) {
       });
     }
     if (!options.dryRun) {
-      const replayResult = await replayPendingBrainGenerationFinalizations({
+      const replayResult = await replayPendingResultFinalizations({
         accountId: context.metadata.amistioAccountId,
         apiClient: context.client,
         projectId: context.metadata.amistioProjectId,
@@ -7189,7 +8388,8 @@ async function runWatchIteration({ command, context, options, runnerId }) {
         return replayResult;
       }
     }
-    return await runNextWorkItem({
+    const activeClaimLaneIds = claimLaneIds(options.maxConcurrentWork);
+    const runLane = (claimLaneId, laneIndex) => runNextWorkItem({
       apiClient: context.client,
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
@@ -7218,8 +8418,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;
@@ -7247,6 +8455,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;
@@ -7326,7 +8551,11 @@ async function runNextWorkItem({
   commandContext,
   suppressIdleOutput,
   toolTimeoutMs,
-  verbose
+  verbose,
+  claimLaneId,
+  maxConcurrentWork,
+  activeClaimLaneIds,
+  skipRunnerCommands
 }) {
   const toolConfig = await resolveRunnerToolConfig({
     apiClient,
@@ -7340,19 +8569,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);
@@ -7370,17 +8607,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 } : {},
@@ -7403,6 +8640,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.`,
@@ -7413,7 +8654,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,
@@ -7439,7 +8680,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,
@@ -7622,6 +8863,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);
@@ -7636,14 +8913,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;
@@ -7661,31 +8951,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,
@@ -7699,19 +9006,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" };
   }
@@ -7726,9 +9041,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) {
@@ -7749,14 +9064,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;
@@ -7767,7 +9082,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 } : {},
@@ -7783,6 +9098,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()
@@ -7822,6 +9138,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,
@@ -7846,6 +9163,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 } : {},
@@ -7857,17 +9175,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") {
@@ -7954,6 +9315,28 @@ async function replayPendingBrainGenerationFinalizations({ accountId, apiClient,
   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 {
@@ -7988,6 +9371,127 @@ async function submitBrainGenerationFinalizationEntry(apiClient, entry, options
   }
   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,
@@ -8145,28 +9649,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()}`,
@@ -8177,7 +9662,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.`,
@@ -8188,7 +9687,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()}`,
@@ -8197,7 +9696,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.`,
@@ -8234,29 +9747,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()}`,
@@ -8268,7 +9762,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.`,
@@ -8279,7 +9787,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()}`,
@@ -8288,7 +9796,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.`,
@@ -8324,28 +9846,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()}`,
@@ -8354,7 +9857,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.`,
@@ -8365,7 +9882,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()}`,
@@ -8374,7 +9891,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.`,
@@ -8410,28 +9941,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()}`,
@@ -8440,7 +9952,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.`,
@@ -8451,7 +9977,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()}`,
@@ -8460,7 +9986,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.`,
@@ -8496,28 +10036,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()}`,
@@ -8526,7 +10047,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.`,
@@ -8537,7 +10072,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()}`,
@@ -8546,7 +10081,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.`,
@@ -8583,28 +10132,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()}`,
@@ -8613,7 +10143,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, {
@@ -8636,7 +10180,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()}`,
@@ -8645,7 +10189,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.`,
@@ -8681,28 +10239,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()}`,
@@ -8711,7 +10250,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,
@@ -8722,7 +10275,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()}`,
@@ -8731,7 +10284,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.`,
@@ -8742,6 +10309,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: [] };
@@ -8798,6 +10555,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([
@@ -9285,15 +11051,17 @@ 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 {
@@ -9301,6 +11069,8 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
     mode,
     hostname: os8.hostname(),
     ...runnerIsolationCapabilityMetadata(),
+    maxConcurrentWork: concurrencyMetadata.maxConcurrentWork,
+    activeClaimLaneIds: concurrencyMetadata.activeClaimLaneIds,
     resourceUsage: sampleCurrentRunnerResourceUsage(),
     ...toolConfig?.capabilities ? { capabilities: toolConfig.capabilities } : {},
     ...toolConfig?.requestedTool ? { requestedTool: toolConfig.requestedTool } : {},