@amistio/cli 0.1.30 → 0.1.32

package/README.md

@@ -15,9 +15,11 @@ Runner lifecycle controls in the web app, such as update, restart, and remove, a
 
 Runner Update installs the official `@amistio/cli` package and then refreshes the runner runtime. Background runners attempt a replacement restart so the next heartbeat reports the new CLI version. If replacement restart metadata is missing or restart fails after a successful install, the old runner still stops and reports manual restart guidance instead of continuing to heartbeat the stale runtime. Foreground `amistio run --watch` sessions stop after a successful install with restart guidance; start the command again to load the updated package.
 
-Current runners advertise the work kinds they can claim. Older runners that do not send this capability can continue legacy brain generation, implementation, and plan revision work, but they will skip source-aware assistant, impact-preview, project-context refresh, issue-diagnosis, app-evaluation, security-posture, Test-quality, implementation-Test-gate, and implementation-verification work until updated.
+Current runners advertise the work kinds they can claim. Older runners that do not send this capability can continue legacy brain generation, implementation, and plan revision work, but they will skip source-aware assistant, impact-preview, semantic brain consolidation, project-context refresh, issue-diagnosis, app-evaluation, security-posture, Test-quality, implementation-Test-gate, and implementation-verification work until updated.
 
-Repository brain auto-sync is disabled until the repository link option is enabled in the app. After pairing, run `amistio sync watch` from the paired checkout to push recognized external brain Markdown/MDX files and HTML companions under `docs/html/<area>/`, including local ADRs, plans, prompts, workflows, memory, context, architecture, and feature docs, to the app for review. `amistio run --watch` also runs the same cycle between work polls when the option is enabled. The CLI skips templates, unsupported paths, oversized files, unchanged managed docs, and conflicts instead of silently overwriting web state.
+Tool session reuse is bounded. One-shot tool sessions close after successful completion, failed runs are blocked, active sessions are treated as already in use, and reusable sessions idle for more than six hours are closed before the next claim selects context. This keeps follow-up work from inheriting stale local AI context while preserving recent reusable sessions for related work.
+
+Repository brain auto-sync is disabled until the repository link option is enabled in the app. After pairing, run `amistio sync watch` from the paired checkout to push recognized external brain Markdown/MDX files and explicit HTML artifacts under `docs/html/<area>/`, including local ADRs, plans, prompts, workflows, memory, context, architecture, and feature docs, to the app for review. Markdown is the default generation format; HTML appears only when a runner or user explicitly generated an HTML artifact. `amistio run --watch` also runs the same cycle between work polls when the option is enabled. The CLI skips templates, unsupported paths, oversized files, unchanged managed docs, and conflicts instead of silently overwriting web state.
 
 Repository autopilot is disabled until the repository link option is enabled in the app. When enabled, Amistio can attach an audited low-risk autopilot authorization to eligible runner work, including generated brain approval, impact preview, issue diagnosis, security posture scan, app evaluation cleanup, low-risk implementation handoff, requeue, and implementation verification. The Runner panel shows and updates safe work scopes, allowed candidate types, max risk, optional runner binding, daily/concurrent/failure budgets, expiry/review/cooldown windows, and pause state. The CLI shows authorization id, candidate id/type, outcome, policy version, and work kind in `amistio work list`, claim logs, runner prompts, and milestone activity. Autopilot does not widen local runner permissions: pairing, supported work kinds, runner identity, Git worktree isolation, redaction, local-tool permission controls, and unsafe/review-required/blocked/paused/budget stops still apply.
 

package/dist/index.js

@@ -226,6 +226,7 @@ var autopilotCandidateLinksSchema = z.object({
   securityFindingId: z.string().min(1).optional(),
   appEvaluationScanId: z.string().min(1).optional(),
   appEvaluationFindingId: z.string().min(1).optional(),
+  brainConsolidationScanId: z.string().min(1).optional(),
   implementationVerificationId: z.string().min(1).optional(),
   testQualityScanId: z.string().min(1).optional(),
   testQualityFindingId: z.string().min(1).optional(),
@@ -313,6 +314,9 @@ var brainConsolidationScanSourceSchema = z.enum(["manual", "system", "runner"]);
 var brainConsolidationProposalStatusSchema = z.enum(["open", "approved", "changesRequested", "dismissed", "acceptedRisk", "resolved", "failed"]);
 var brainConsolidationProposalActionSchema = z.enum(["archiveDuplicates", "supersedeDuplicates", "keepCanonical", "manualReview"]);
 var brainConsolidationRiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
+var brainConsolidationRecommendationCoverageSchema = z.enum(["full", "partial", "notCovered", "ambiguous"]);
+var brainConsolidationRecommendationConfidenceSchema = z.enum(["low", "medium", "high"]);
+var brainConsolidationRecommendationActionSchema = z.enum(["archiveDuplicate", "proposeArchive", "manualReview", "skip"]);
 var activityEventTypeSchema = z.enum([
   "autopilotAuthorized",
   "autopilotReviewRequired",
@@ -633,6 +637,9 @@ var brainConsolidationScanItemSchema = baseItemSchema.extend({
   brainConsolidationScanId: z.string().min(1),
   source: brainConsolidationScanSourceSchema,
   status: brainConsolidationScanStatusSchema,
+  workItemId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
   activeReviewCount: z.number().int().nonnegative(),
   exactDuplicateGroupCount: z.number().int().nonnegative(),
   autoArchivedCount: z.number().int().nonnegative(),
@@ -659,6 +666,22 @@ var brainConsolidationProposalItemSchema = baseItemSchema.extend({
   reviewedByUserId: z.string().min(1).optional(),
   reviewedAt: isoDateTimeSchema.optional()
 });
+var brainConsolidationRecommendationSchema = z.object({
+  recommendationId: z.string().trim().min(1).max(160).optional(),
+  canonicalDocumentId: z.string().min(1),
+  candidateDocumentIds: z.array(z.string().min(1)).min(1).max(25),
+  coverage: brainConsolidationRecommendationCoverageSchema,
+  confidence: brainConsolidationRecommendationConfidenceSchema.default("medium"),
+  recommendedAction: brainConsolidationRecommendationActionSchema,
+  riskLevel: brainConsolidationRiskLevelSchema.default("medium"),
+  evidence: z.array(z.string().trim().min(1).max(300)).min(1).max(10),
+  reason: z.string().trim().min(1).max(800)
+});
+var brainConsolidationScanResultSchema = z.object({
+  summary: z.string().trim().min(1).max(2e3),
+  recommendations: z.array(brainConsolidationRecommendationSchema).max(100).default([]),
+  warnings: z.array(z.string().trim().min(1).max(600)).default([])
+});
 var generatedDraftItemSchema = baseItemSchema.extend({
   type: z.literal("generatedDraft"),
   projectId: z.string().min(1),
@@ -709,6 +732,7 @@ var workItemSchema = baseItemSchema.extend({
   securityFindingId: z.string().min(1).optional(),
   appEvaluationScanId: z.string().min(1).optional(),
   appEvaluationFindingId: z.string().min(1).optional(),
+  brainConsolidationScanId: z.string().min(1).optional(),
   implementationVerificationId: z.string().min(1).optional(),
   testQualityScanId: z.string().min(1).optional(),
   testQualityFindingId: z.string().min(1).optional(),
@@ -2975,6 +2999,16 @@ var ApiClient = class {
       }
     );
   }
+  async submitBrainConsolidationScanResult(projectId, workItemId, result) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/brain-consolidation-result`,
+      z3.object({ scan: brainConsolidationScanItemSchema, proposals: z3.array(brainConsolidationProposalItemSchema), autoArchivedDocuments: z3.array(brainDocumentItemSchema), workItem: workItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify(result)
+      }
+    );
+  }
   async submitProjectContextRefreshResult(projectId, workItemId, result) {
     return this.request(
       `/projects/${projectId}/work-items/${workItemId}/project-context-result`,
@@ -3233,6 +3267,13 @@ var appEvaluationScanResultMutationSchema = z4.discriminatedUnion("status", [
   }),
   resultFinalizationFailureSchema
 ]);
+var brainConsolidationScanResultMutationSchema = z4.discriminatedUnion("status", [
+  resultFinalizationTelemetrySchema.extend({
+    status: z4.literal("completed"),
+    result: brainConsolidationScanResultSchema
+  }),
+  resultFinalizationFailureSchema
+]);
 var projectContextRefreshResultMutationSchema = z4.discriminatedUnion("status", [
   resultFinalizationTelemetrySchema.extend({
     status: z4.literal("completed"),
@@ -3267,6 +3308,7 @@ var durableResultMutationSchema = z4.discriminatedUnion("resultKind", [
   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("brainConsolidationScanResult"), result: brainConsolidationScanResultMutationSchema }),
   z4.object({ resultKind: z4.literal("projectContextRefreshResult"), result: projectContextRefreshResultMutationSchema }),
   z4.object({ resultKind: z4.literal("implementationVerificationResult"), result: implementationVerificationResultMutationSchema }),
   z4.object({ resultKind: z4.literal("testQualityScanResult"), result: testQualityScanResultMutationSchema }),
@@ -3281,7 +3323,7 @@ var durableResultFinalizationEntrySchema = z4.object({
   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"]),
+  workKind: z4.enum(["assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "brainConsolidationScan", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate"]),
   attempt: z4.number().int().nonnegative(),
   idempotencyKey: z4.string().min(1),
   retryCount: z4.number().int().nonnegative(),
@@ -4698,8 +4740,32 @@ function runProcess(command, args, timeoutMs) {
   });
 }
 
+// src/tool-session-lifecycle.ts
+var TOOL_SESSION_MAX_IDLE_MS = 6 * 60 * 60 * 1e3;
+function completedToolSessionStatus(session) {
+  return session.resumabilityScope === "none" ? "closed" : "open";
+}
+function completedToolSessionClosedReason(session) {
+  if (session.resumabilityScope !== "none") {
+    return void 0;
+  }
+  return "Completed one-shot tool run; this session is not reusable.";
+}
+function staleToolSessionClosedReason(session, now = /* @__PURE__ */ new Date()) {
+  if (session.status !== "open") {
+    return void 0;
+  }
+  const lastActivityMs = Date.parse(session.lastActivityAt);
+  if (!Number.isFinite(lastActivityMs)) {
+    return "Session has an invalid last activity timestamp; closing to prevent stale context reuse.";
+  }
+  if (lastActivityMs + TOOL_SESSION_MAX_IDLE_MS >= now.getTime()) {
+    return void 0;
+  }
+  return "Session idle window expired; closing to prevent stale context reuse.";
+}
+
 // src/session-policy.ts
-var maxIdleMs = 24 * 60 * 60 * 1e3;
 var maxTotalMs = 7 * 24 * 60 * 60 * 1e3;
 var maxMessageCount = 80;
 var maxEstimatedTokens = 12e4;
@@ -4783,10 +4849,10 @@ function sessionIneligibleReason(session, input, now) {
   if (input.workItem.executionWorktreeKey && session.executionWorktreeKey !== input.workItem.executionWorktreeKey) {
     return "worktree scope mismatch";
   }
-  if (session.status === "closed" || session.status === "archived" || session.status === "blocked" || session.status === "unavailable") {
+  if (session.status === "closed" || session.status === "archived" || session.status === "blocked" || session.status === "unavailable" || session.status === "active") {
     return `session is ${session.status}`;
   }
-  if (Date.parse(session.lastActivityAt) + maxIdleMs < now.getTime()) {
+  if (Date.parse(session.lastActivityAt) + TOOL_SESSION_MAX_IDLE_MS < now.getTime()) {
     return "session is idle past the reuse window";
   }
   if (Date.parse(session.createdAt) + maxTotalMs < now.getTime()) {
@@ -5404,6 +5470,8 @@ var securityPostureStart = "AMISTIO_SECURITY_POSTURE_START";
 var securityPostureEnd = "AMISTIO_SECURITY_POSTURE_END";
 var appEvaluationStart = "AMISTIO_APP_EVALUATION_START";
 var appEvaluationEnd = "AMISTIO_APP_EVALUATION_END";
+var brainConsolidationStart = "AMISTIO_BRAIN_CONSOLIDATION_START";
+var brainConsolidationEnd = "AMISTIO_BRAIN_CONSOLIDATION_END";
 var projectContextRefreshStart = "AMISTIO_PROJECT_CONTEXT_REFRESH_START";
 var projectContextRefreshEnd = "AMISTIO_PROJECT_CONTEXT_REFRESH_END";
 var implementationVerificationStart = "AMISTIO_IMPLEMENTATION_VERIFICATION_START";
@@ -5752,6 +5820,9 @@ function createWorkExecutionPrompt(workItem, context) {
   if (workItem.workKind === "appEvaluationScan") {
     return createAppEvaluationScanPrompt(workItem, context?.appEvaluationScan);
   }
+  if (workItem.workKind === "brainConsolidationScan") {
+    return createBrainConsolidationScanPrompt(workItem, context?.brainConsolidationScan);
+  }
   if (workItem.workKind === "projectContextRefresh") {
     return createProjectContextRefreshPrompt(workItem, context?.projectContextRefresh);
   }
@@ -5984,8 +6055,11 @@ 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.",
+    "- Check old plans and prompts for lifecycle reconciliation, but only propose cleanup actions such as markCompleted, markSuperseded, or archive when direct controlling evidence shows they are completed, superseded, or obsolete.",
+    "- Treat active proposed, approved, ready, or in-progress plans/prompts with accepted controlling ADRs, features, or work artifacts as active backlog. Do not classify them as cleanup material solely because they are older, unexecuted, or not yet fully implemented; use keepActive when they still describe valid pending or approved work.",
+    "- Treat intentionally in-progress feature tracks as still-active work when their controlling plan/feature has unchecked requirements or explicit follow-up gaps. For example, a completed first implementation prompt does not make the broader feature stale if PLAN/FEAT evidence says remaining lifecycle work is still open; return proposedLifecycleAction keepActive with evidence instead of cleanup.",
+    "- Treat prompt frontmatter status Ready as an active execution backlog state by default, not as stale review debt. Only flag a Ready prompt for metadata correction when its controlling plan, feature, prompt index, or verification evidence unambiguously proves the prompt has already completed or been superseded.",
+    "- Treat implemented umbrella plans that explicitly label unchecked checklist items as deferred follow-ups, future candidates, roadmap backlog, or split-out hardening phases as valid deferred backlog. Do not mark the umbrella incomplete or stale solely because those deferred items remain unchecked; use keepActive or no cleanup, and recommend a fresh focused plan only when a concrete deferred slice has current evidence and approval.",
     "- 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.",
@@ -6014,6 +6088,91 @@ function createAppEvaluationScanPrompt(workItem, context) {
     "Do not put Markdown fences around the markers. Do not implement improvements or cleanup."
   ].join("\n");
 }
+function createBrainConsolidationScanPrompt(workItem, context) {
+  const documents = context?.documents ?? [];
+  const activeReviewDocuments = documents.filter(isActiveReviewPromptDocument).slice(0, 160);
+  const canonicalDocuments = documents.filter(isCanonicalPromptDocument).slice(0, 120);
+  const activeReviewContext = activeReviewDocuments.map((document) => formatBrainConsolidationDocument(document)).join("\n\n");
+  const canonicalContext = canonicalDocuments.map((document) => formatBrainConsolidationDocument(document)).join("\n\n");
+  return [
+    "# Amistio Semantic Brain Consolidation Scan",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Run a read-only semantic duplicate and coverage scan for Project Brain review documents.",
+    "Do not modify files, create branches, commit, push, archive documents, approve documents, or run implementation prompts.",
+    "Return bounded recommendations only; the Amistio server decides what is safe to auto-archive.",
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    `Brain consolidation scan ID: ${workItem.brainConsolidationScanId ?? "unknown"}`,
+    "",
+    "## Scan Request",
+    "",
+    workItem.sourceWish ?? "Compare active generated review documents against approved or synced Project Brain documents and recommend safe consolidation actions.",
+    "",
+    "## Active Review Documents",
+    "",
+    activeReviewContext || "No active review documents were provided in the scan context.",
+    "",
+    "## Approved Or Synced Canonical Documents",
+    "",
+    canonicalContext || "No approved or synced canonical documents were provided in the scan context.",
+    "",
+    "## Requirements",
+    "",
+    "- Compare active review documents to approved or synced canonical documents by documentId, title, repoPath, documentType, source, syncState, frontmatter lineage, and content excerpt.",
+    "- Recommend archiveDuplicate only when a generated draft is fully covered by a canonical approved/synced document and adds no distinct requirement, decision, plan step, or memory entry.",
+    "- Use proposeArchive for partial, ambiguous, user-owned, repo-sourced, dirty, or medium-risk matches that need human review.",
+    "- Use manualReview when the candidate appears related but may contain unique requirements or unresolved conflicts.",
+    "- Use skip for documents that are not duplicates or cannot be evaluated safely from the available context.",
+    "- Keep each recommendation focused on one canonical document and one or more candidate document IDs.",
+    "",
+    "## Data Safety",
+    "",
+    "- Persist only document IDs, short evidence, bounded summaries, and recommendations.",
+    "- Do not include raw source dumps, secrets, env vars, process lists, absolute local paths, credential values, tokens, provider sessions, or destructive shell output.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below. The CLI will submit only this structured consolidation result back to Amistio.",
+    "Accepted coverage values: full, partial, notCovered, ambiguous.",
+    "Accepted confidence values: low, medium, high.",
+    "Accepted recommendedAction values: archiveDuplicate, proposeArchive, manualReview, skip.",
+    "Accepted riskLevel values: low, medium, high, critical.",
+    "",
+    brainConsolidationStart,
+    '{"summary":"Compared active generated review documents against approved canonical documents.","recommendations":[{"canonicalDocumentId":"doc_approved","candidateDocumentIds":["doc_review_duplicate"],"coverage":"full","confidence":"high","recommendedAction":"archiveDuplicate","riskLevel":"low","evidence":["The candidate repeats the accepted decision without adding requirements."],"reason":"The generated review draft is fully covered by the approved canonical document."}],"warnings":[]}',
+    brainConsolidationEnd,
+    "",
+    "Do not put Markdown fences around the markers. Do not archive, approve, or edit documents."
+  ].join("\n");
+}
+function formatBrainConsolidationDocument(document) {
+  return [
+    `### ${document.title}`,
+    `documentId: ${document.documentId}`,
+    `documentType: ${document.documentType}`,
+    `repoPath: ${document.repoPath}`,
+    `contentFormat: ${document.contentFormat ?? "markdown"}`,
+    `source: ${document.source}`,
+    `status: ${document.status}`,
+    `syncState: ${document.syncState}`,
+    `revision: ${document.revision}`,
+    `approvedRevision: ${document.approvedRevision ?? "none"}`,
+    `contentHash: ${document.contentHash}`,
+    `frontmatter: ${JSON.stringify(document.frontmatter)}`,
+    document.content.slice(0, 1600)
+  ].join("\n");
+}
+function isActiveReviewPromptDocument(document) {
+  return document.syncState === "draft" && ["draft", "drafted", "reviewing", "changesRequested"].includes(document.status);
+}
+function isCanonicalPromptDocument(document) {
+  return document.syncState === "approved" || document.syncState === "synced" || document.status === "approved";
+}
 function createIssueDiagnosisPrompt(workItem, context) {
   const issue = context?.issue;
   const approvedContext = (context?.documents ?? []).filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced").slice(0, 16).map((document) => [
@@ -6339,6 +6498,16 @@ function parseAppEvaluationScanResult(output) {
   const normalized = normalizeAppEvaluationScanResultPaths(normalizeAppEvaluationScanResultEnums(parsed));
   return appEvaluationScanResultSchema.parse(normalized);
 }
+function parseBrainConsolidationScanResult(output) {
+  const start = output.indexOf(brainConsolidationStart);
+  const end = output.indexOf(brainConsolidationEnd, start + brainConsolidationStart.length);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Local AI scan did not return an Amistio brain consolidation block.");
+  }
+  const payload = output.slice(start + brainConsolidationStart.length, end).trim();
+  const parsed = JSON.parse(stripJsonFence(payload));
+  return brainConsolidationScanResultSchema.parse(parsed);
+}
 function parseProjectContextRefreshResult(output, options = {}) {
   const start = output.indexOf(projectContextRefreshStart);
   const end = output.indexOf(projectContextRefreshEnd, start + projectContextRefreshStart.length);
@@ -6491,7 +6660,7 @@ function createBrainGenerationPrompt(workItem) {
     "- plan -> docs/plans/",
     "- prompt -> docs/prompts/",
     "- workflow -> docs/workflows/",
-    "- HTML companions -> docs/html/<same-folder>/ using .html, for example docs/html/plans/PLAN-example.html",
+    "- HTML artifacts -> docs/html/<same-folder>/ using .html, for example docs/html/plans/PLAN-example.html",
     "",
     artifactFormatPreferenceInstructions(artifactFormatPreference),
     "",
@@ -6768,10 +6937,10 @@ function artifactFormatPreferenceInstructions(preference) {
     return "The user chose HTML. Generate .html artifacts under docs/html/<folder>/ and set contentFormat to html.";
   }
   if (preference === "both") {
-    return "The user chose both formats. Generate Markdown artifacts under docs/<folder>/ and matching HTML companions under docs/html/<folder>/ with contentFormat values markdown and html.";
+    return "The user chose both formats. Choose one format per artifact purpose; do not generate matching Markdown and HTML companion copies of the same document.";
   }
   if (preference === "auto") {
-    return "Choose Markdown or HTML based on the artifact content. Use Markdown for text-first docs and HTML for visual or layout-sensitive artifacts.";
+    return "Choose Markdown or HTML based on the artifact content. Use Markdown for text-first docs and HTML only for visual or layout-sensitive artifacts.";
   }
   return "The user chose Markdown. Generate Markdown artifacts under docs/<folder>/ and set contentFormat to markdown or omit it.";
 }
@@ -7836,7 +8005,7 @@ var DEFAULT_TOOL_TIMEOUT_SECONDS = 30 * 60;
 var RUNNER_WORK_LEASE_SECONDS = 300;
 var RUNNER_WORK_LEASE_RENEWAL_MS = 12e4;
 var MAX_CONCURRENT_RUNNER_WORK = 4;
-var runnerSupportedWorkKinds = ["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate"];
+var runnerSupportedWorkKinds = ["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis", "securityPostureScan", "appEvaluationScan", "brainConsolidationScan", "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);
@@ -8917,6 +9086,24 @@ 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 === "brainConsolidationScan") {
+    try {
+      return await finalizeBrainConsolidationScanWork({
+        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 === "projectContextRefresh") {
     try {
       return await finalizeProjectContextRefreshWork({
@@ -9519,6 +9706,9 @@ async function submitDurableResultMutation(apiClient, entry) {
   if (entry.resultKind === "appEvaluationScanResult") {
     return apiClient.submitAppEvaluationScanResult(entry.projectId, entry.workItemId, entry.result);
   }
+  if (entry.resultKind === "brainConsolidationScanResult") {
+    return apiClient.submitBrainConsolidationScanResult(entry.projectId, entry.workItemId, entry.result);
+  }
   if (entry.resultKind === "projectContextRefreshResult") {
     return apiClient.submitProjectContextRefreshResult(entry.projectId, entry.workItemId, entry.result);
   }
@@ -9538,6 +9728,7 @@ function durableResultResponseWorkItem(response) {
 }
 function runnerResultFinalizationLabel(entry) {
   if (entry.workKind === "appEvaluationScan") return "app evaluation scan";
+  if (entry.workKind === "brainConsolidationScan") return "brain consolidation scan";
   if (entry.workKind === "securityPostureScan") return "security posture scan";
   if (entry.workKind === "projectContextRefresh") return "project context refresh";
   if (entry.workKind === "implementationVerification") return "implementation verification";
@@ -10203,6 +10394,101 @@ ${toolResult.stderr}`);
   console.error(scanError ?? "Local runner app evaluation scan failed.");
   return { status: "failed", exitCode: toolResult.exitCode || 1 };
 }
+async function finalizeBrainConsolidationScanWork({
+  apiClient,
+  durationMs,
+  projectId,
+  repositoryLinkId,
+  runnerId,
+  sessionContext,
+  toolConfig,
+  toolName,
+  toolResult,
+  workItem
+}) {
+  let scanResult = void 0;
+  let scanError;
+  if (toolResult.exitCode === 0) {
+    try {
+      scanResult = parseBrainConsolidationScanResult(`${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: `brain_consolidation_${workItem.workItemId}_${randomUUID()}`,
+      result: scanResult,
+      tool: toolName,
+      durationMs,
+      ...sessionTelemetry,
+      message: `${toolName} returned a semantic brain consolidation scan.`
+    };
+    const result = await submitPrimaryRunnerResult(apiClient, {
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: "brainConsolidationScan",
+      resultKind: "brainConsolidationScanResult",
+      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 semantic brain consolidation scan.`,
+      idempotencyKey: `runner_milestone_brain_consolidation_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, recommendationCount: scanResult.recommendations.length, autoArchivedCount: result.autoArchivedDocuments.length, proposalCount: result.proposals.length, verificationSummary: scanResult.summary }
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    console.log(`Brain consolidation scan returned: archived ${result.autoArchivedDocuments.length}, opened ${result.proposals.length} proposal${result.proposals.length === 1 ? "" : "s"}.`);
+    return { status: "completed", exitCode: 0 };
+  }
+  const failedMutation = {
+    status: "failed",
+    runnerId,
+    idempotencyKey: `brain_consolidation_${workItem.workItemId}_${randomUUID()}`,
+    tool: toolName,
+    durationMs,
+    ...sessionTelemetry,
+    message: `${toolName} did not produce a valid semantic brain consolidation scan.`,
+    ...scanError ? { error: scanError } : {}
+  };
+  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+    accountId: workItem.accountId,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    workItemId: workItem.workItemId,
+    workKind: "brainConsolidationScan",
+    resultKind: "brainConsolidationScanResult",
+    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 semantic brain consolidation scan.`,
+    idempotencyKey: `runner_milestone_brain_consolidation_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    metadata: { tool: toolName, durationMs, verificationSummary: "Brain consolidation output did not include valid structured JSON." }
+  });
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  console.error(scanError ?? "Local runner brain consolidation scan failed.");
+  return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
 async function finalizeProjectContextRefreshWork({
   apiClient,
   durationMs,
@@ -10652,6 +10938,12 @@ async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
       appEvaluationScan: { documents: documents2 }
     });
   }
+  if (workItem.workKind === "brainConsolidationScan") {
+    const { documents: documents2 } = await apiClient.listBrainDocuments(projectId);
+    return createWorkExecutionPrompt(workItem, {
+      brainConsolidationScan: { documents: documents2 }
+    });
+  }
   if (workItem.workKind === "testQualityScan") {
     const { documents: documents2 } = await apiClient.listBrainDocuments(projectId);
     return createWorkExecutionPrompt(workItem, {
@@ -10759,6 +11051,8 @@ async function prepareToolSession({
   workItem
 }) {
   const { toolSessions } = await apiClient.listToolSessions(projectId);
+  const now = /* @__PURE__ */ new Date();
+  await closeStaleToolSessionsBestEffort(apiClient, projectId, toolSessions, now);
   const selection = selectToolSession({
     policy: sessionPolicy,
     workItem,
@@ -10767,7 +11061,8 @@ async function prepareToolSession({
     runnerId,
     repositoryLinkId,
     machineId,
-    supportsSessionReuse
+    supportsSessionReuse,
+    now
   });
   if (selection.decision === "skipped") {
     return selection;
@@ -10809,6 +11104,18 @@ async function prepareToolSession({
   });
   return { ...selection, toolSession };
 }
+async function closeStaleToolSessionsBestEffort(apiClient, projectId, toolSessions, now) {
+  const staleSessions = toolSessions.map((session) => ({ session, reason: staleToolSessionClosedReason(session, now) })).filter((item) => Boolean(item.reason));
+  if (!staleSessions.length) {
+    return;
+  }
+  const settlements = await Promise.allSettled(staleSessions.map(({ session, reason }) => apiClient.updateToolSession(projectId, session.toolSessionId, {
+    status: "closed",
+    closedReason: reason,
+    summary: session.summary ?? reason
+  })));
+  logRejectedSettlements("close stale tool sessions", settlements);
+}
 async function finalizeToolSession({
   apiClient,
   costUsd,
@@ -10826,8 +11133,10 @@ async function finalizeToolSession({
     return void 0;
   }
   const summary = summarizeToolOutput(stdout) ?? session.summary;
+  const nextStatus = status === "completed" ? completedToolSessionStatus(session) : "blocked";
+  const closedReason = status === "completed" ? completedToolSessionClosedReason(session) : "Last run failed or returned a non-zero exit code.";
   const { toolSession } = await apiClient.updateToolSession(projectId, session.toolSessionId, {
-    status: status === "completed" ? "open" : "blocked",
+    status: nextStatus,
     runnerId,
     lastWorkItemId: workItemId,
     messageCount: (session.messageCount ?? 0) + (messageCount ?? 1),
@@ -10835,7 +11144,7 @@ async function finalizeToolSession({
     ...tokensIn !== void 0 ? { estimatedInputTokens: (session.estimatedInputTokens ?? 0) + tokensIn } : {},
     ...tokensOut !== void 0 ? { estimatedOutputTokens: (session.estimatedOutputTokens ?? 0) + tokensOut } : {},
     ...costUsd !== void 0 ? { costUsd: (session.costUsd ?? 0) + costUsd } : {},
-    ...status === "failed" ? { closedReason: "Last run failed or returned a non-zero exit code." } : {}
+    ...closedReason ? { closedReason } : {}
   });
   return toolSession;
 }