@titan-design/active-work 0.4.0 → 0.5.0

package/dist/cli.js

@@ -76,7 +76,7 @@ import {
   writeFrontmatter,
   writeNoteFile,
   writeYaml
-} from "./chunk-BK25ASXA.js";
+} from "./chunk-RLSQSE7I.js";
 
 // src/cli.ts
 import { Command, CommanderError } from "commander";
@@ -5039,7 +5039,7 @@ var edit_default = edit;
 
 // src/commands/mcp-serve.ts
 import { spawn as spawn3 } from "child_process";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 
 // src/server/mcp.ts
 import {
@@ -5055,9 +5055,8 @@ import {
   toolNameToCommandName as pkgToolNameToCommandName
 } from "@titan-design/registry";
 
-// src/server/health.ts
-var DAEMON_VERSION = "0.1.0";
-var startedAt = Date.now();
+// src/version.ts
+var BUILD_VERSION = "0.5.0";
 
 // src/server/mcp.ts
 var TOOL_NAME_PREFIX = "active__";
@@ -5068,7 +5067,7 @@ function mcpOptions() {
     formatError,
     toolPrefix: TOOL_NAME_PREFIX,
     name: "@hjewkes/active-work",
-    version: DAEMON_VERSION
+    version: BUILD_VERSION
   };
 }
 async function runMcpStdio() {
@@ -5402,6 +5401,7 @@ function taskResolver(root) {
 // src/workspace-index/refresh.ts
 import { promises as fs43 } from "fs";
 import matter4 from "gray-matter";
+import { z as z42 } from "zod";
 
 // src/workspace-index/refs.ts
 import path48 from "path";
@@ -6031,16 +6031,17 @@ function isUnchanged(row, file) {
   return row.lastOffset > 0 && row.fileSize === file.size && row.fileMtime === file.mtime;
 }
 var BATCH = 200;
+function describeFailure(err) {
+  if (err instanceof z42.ZodError) {
+    return err.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+  }
+  return err instanceof Error ? err.message : String(err);
+}
 async function readAttempt(file, watermarkId) {
   try {
     return { file, watermarkId, record: await readRecord(file), reason: null };
   } catch (err) {
-    return {
-      file,
-      watermarkId,
-      record: null,
-      reason: err instanceof Error ? err.message : String(err)
-    };
+    return { file, watermarkId, record: null, reason: describeFailure(err) };
   }
 }
 function applyBatch(graph, writer, batch) {
@@ -6287,7 +6288,7 @@ async function withRefreshLock(fn) {
   }
 }
 async function runRefresh(options = {}) {
-  const startedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const started = Date.now();
   const graph = options.graph ?? openGraph(options.dbPath ?? defaultGraphPath());
   const owned = options.graph === void 0;
@@ -6312,7 +6313,7 @@ async function runRefresh(options = {}) {
     });
     const preserved = replayPreserved(graph);
     return {
-      startedAt: startedAt2,
+      startedAt,
       durationMs: Date.now() - started,
       transcripts: discovered.length,
       scanned: visiting.length,
@@ -6498,7 +6499,7 @@ async function runDaemon(options = {}) {
     stateDir: getStateRoot(),
     port: resolvePort(options),
     watchRoot: getActiveRoot(),
-    version: DAEMON_VERSION,
+    version: BUILD_VERSION,
     logger: log,
     health: () => ({ index: toHealthIndexState(indexWatch?.status()) }),
     mountRoutes: (app) => {
@@ -6537,15 +6538,15 @@ async function runDaemon(options = {}) {
 }
 
 // src/commands/mcp-serve.ts
-var ArgsSchema38 = z42.object({
-  stdio: z42.boolean().optional(),
-  detach: z42.boolean().optional(),
-  port: z42.number().int().positive().optional()
+var ArgsSchema38 = z43.object({
+  stdio: z43.boolean().optional(),
+  detach: z43.boolean().optional(),
+  port: z43.number().int().positive().optional()
 });
-var ResultSchema34 = z42.object({
-  mode: z42.enum(["stdio", "http", "detached"]),
-  pid: z42.number().optional(),
-  port: z42.number().optional()
+var ResultSchema34 = z43.object({
+  mode: z43.enum(["stdio", "http", "detached"]),
+  pid: z43.number().optional(),
+  port: z43.number().optional()
 });
 function detachedSpawn(port) {
   const entry = process.argv[1];
@@ -6600,11 +6601,11 @@ var mcp_serve_default = defineCommand({
 });
 
 // src/commands/mcp-stop.ts
-import { z as z43 } from "zod";
-var ArgsSchema39 = z43.object({});
-var ResultSchema35 = z43.union([
-  z43.object({ stopped: z43.literal(true), pid: z43.number() }),
-  z43.object({ stopped: z43.literal(false), reason: z43.string() })
+import { z as z44 } from "zod";
+var ArgsSchema39 = z44.object({});
+var ResultSchema35 = z44.union([
+  z44.object({ stopped: z44.literal(true), pid: z44.number() }),
+  z44.object({ stopped: z44.literal(false), reason: z44.string() })
 ]);
 var SHUTDOWN_TIMEOUT_MS = 3e3;
 var POLL_INTERVAL_MS = 100;
@@ -6649,13 +6650,13 @@ var mcp_stop_default = defineCommand({
 
 // src/commands/mcp-restart.ts
 import { spawn as spawn4 } from "child_process";
-import { z as z44 } from "zod";
-var ArgsSchema40 = z44.object({
-  port: z44.number().int().positive().optional()
+import { z as z45 } from "zod";
+var ArgsSchema40 = z45.object({
+  port: z45.number().int().positive().optional()
 });
-var ResultSchema36 = z44.object({
-  pid: z44.number(),
-  port: z44.number()
+var ResultSchema36 = z45.object({
+  pid: z45.number(),
+  port: z45.number()
 });
 var SHUTDOWN_TIMEOUT_MS2 = 15e3;
 var KILL_TIMEOUT_MS = 3e3;
@@ -6743,17 +6744,17 @@ var mcp_restart_default = defineCommand({
 });
 
 // src/commands/mcp-status.ts
-import { z as z45 } from "zod";
-var ArgsSchema41 = z45.object({});
-var ResultSchema37 = z45.object({
-  running: z45.boolean(),
-  pid: z45.number().optional(),
-  port: z45.number().optional(),
-  version: z45.string().optional(),
-  uptime_ms: z45.number().optional(),
-  healthy: z45.boolean().optional(),
+import { z as z46 } from "zod";
+var ArgsSchema41 = z46.object({});
+var ResultSchema37 = z46.object({
+  running: z46.boolean(),
+  pid: z46.number().optional(),
+  port: z46.number().optional(),
+  version: z46.string().optional(),
+  uptime_ms: z46.number().optional(),
+  healthy: z46.boolean().optional(),
   /** Answering `/health` with no PID file naming it — see `removePidFile`. */
-  orphaned: z45.boolean().optional()
+  orphaned: z46.boolean().optional()
 });
 async function statusByPort(port) {
   const health = await probeHealth(port);
@@ -6806,12 +6807,12 @@ var mcp_status_default = defineCommand({
 // src/commands/mcp-logs.ts
 import { promises as fs45 } from "fs";
 import path57 from "path";
-import { z as z46 } from "zod";
-var ArgsSchema42 = z46.object({
-  lines: z46.number().int().positive().optional()
+import { z as z47 } from "zod";
+var ArgsSchema42 = z47.object({
+  lines: z47.number().int().positive().optional()
 });
-var ResultSchema38 = z46.object({
-  lines: z46.array(z46.string())
+var ResultSchema38 = z47.object({
+  lines: z47.array(z47.string())
 });
 var DEFAULT_LINES = 50;
 var mcp_logs_default = defineCommand({
@@ -6848,7 +6849,7 @@ var mcp_logs_default = defineCommand({
 });
 
 // src/commands/miner-drain-ingest.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 
 // src/drain/transcript-reader.ts
 import { nextOffset, prefixHash, readJsonLines, resumePoint } from "@titan-design/locator";
@@ -6862,29 +6863,29 @@ import { promises as fs46 } from "fs";
 import path58 from "path";
 
 // src/schemas/template.ts
-import { z as z47 } from "zod";
-var LocatorSchema = z47.tuple([
-  z47.number().int().nonnegative(),
-  z47.number().int().nonnegative(),
-  z47.number().int().positive()
+import { z as z48 } from "zod";
+var LocatorSchema = z48.tuple([
+  z48.number().int().nonnegative(),
+  z48.number().int().nonnegative(),
+  z48.number().int().positive()
 ]);
-var TemplateSchema = z47.object({
-  templateId: z47.string().min(1),
-  toolType: z47.string().min(1),
-  maskedSignature: z47.string().min(1),
-  createdAt: z47.string().min(1),
-  occurrenceCount: z47.number().int().nonnegative(),
+var TemplateSchema = z48.object({
+  templateId: z48.string().min(1),
+  toolType: z48.string().min(1),
+  maskedSignature: z48.string().min(1),
+  createdAt: z48.string().min(1),
+  occurrenceCount: z48.number().int().nonnegative(),
   exemplarLocator: LocatorSchema
 });
-var OccurrenceSchema = z47.object({
-  templateId: z47.string().min(1),
+var OccurrenceSchema = z48.object({
+  templateId: z48.string().min(1),
   locator: LocatorSchema,
-  sessionId: z47.string().min(1),
-  timestamp: z47.string().min(1),
-  extractedParams: z47.record(z47.string(), z47.string()).optional()
+  sessionId: z48.string().min(1),
+  timestamp: z48.string().min(1),
+  extractedParams: z48.record(z48.string(), z48.string()).optional()
 });
-var TemplatesFileSchema = z47.object({
-  templates: z47.array(TemplateSchema).default([])
+var TemplatesFileSchema = z48.object({
+  templates: z48.array(TemplateSchema).default([])
 });
 
 // src/drain/store.ts
@@ -6931,27 +6932,27 @@ async function appendOccurrences(occurrences, root = getMinerRoot()) {
 // src/drain/tree-store.ts
 import { promises as fs47 } from "fs";
 import path59 from "path";
-import { z as z48 } from "zod";
-var PartitionSchema = z48.object({
-  partition: z48.string().min(1),
-  nextClusterId: z48.number().int().positive(),
-  clusters: z48.array(
-    z48.object({
-      clusterId: z48.number().int().positive(),
-      tokens: z48.array(z48.string()),
-      size: z48.number().int().nonnegative()
+import { z as z49 } from "zod";
+var PartitionSchema = z49.object({
+  partition: z49.string().min(1),
+  nextClusterId: z49.number().int().positive(),
+  clusters: z49.array(
+    z49.object({
+      clusterId: z49.number().int().positive(),
+      tokens: z49.array(z49.string()),
+      size: z49.number().int().nonnegative()
     })
   ),
   /** `clusterId -> templateId`, as pairs so the file has a stable order. */
-  templateIds: z48.array(z48.tuple([z48.number().int().positive(), z48.string().min(1)]))
+  templateIds: z49.array(z49.tuple([z49.number().int().positive(), z49.string().min(1)]))
 });
-var TreeSnapshotFileSchema = z48.object({
-  version: z48.literal(1).default(1),
-  partitions: z48.array(PartitionSchema).default([])
+var TreeSnapshotFileSchema = z49.object({
+  version: z49.literal(1).default(1),
+  partitions: z49.array(PartitionSchema).default([])
 });
-var LegacySnapshotFileSchema = z48.object({
-  version: z48.literal(1),
-  trees: z48.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z48.string().min(1) }))
+var LegacySnapshotFileSchema = z49.object({
+  version: z49.literal(1),
+  trees: z49.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z49.string().min(1) }))
 });
 function snapshotPath(root) {
   return path59.join(root, "drain-trees.json");
@@ -7134,23 +7135,23 @@ function extractBlobs(line, toolNames) {
 // src/drain/reader-state.ts
 import { promises as fs48 } from "fs";
 import path60 from "path";
-import { z as z49 } from "zod";
-var TranscriptStateSchema = z49.object({
+import { z as z50 } from "zod";
+var TranscriptStateSchema = z50.object({
   /** `~`-relative path, matching `session-index/discover.ts`'s display form. */
-  path: z49.string().min(1),
-  lastByteOffset: z49.number().int().nonnegative().default(0),
+  path: z50.string().min(1),
+  lastByteOffset: z50.number().int().nonnegative().default(0),
   /** sha256 of bytes `[0, lastByteOffset)`; detects rewrite vs. append. */
-  prefixHash: z49.string().nullable().default(null),
+  prefixHash: z50.string().nullable().default(null),
   /**
    * `tool_use_id -> tool name` pairs seen but not yet consumed by a result.
    * Persisted because a chunk boundary routinely falls between an assistant's
    * `tool_use` and the user line carrying its result.
    */
-  pendingToolNames: z49.record(z49.string(), z49.string()).default({})
+  pendingToolNames: z50.record(z50.string(), z50.string()).default({})
 });
-var ReaderStateSchema = z49.object({
-  version: z49.literal(1).default(1),
-  transcripts: z49.array(TranscriptStateSchema).default([])
+var ReaderStateSchema = z50.object({
+  version: z50.literal(1).default(1),
+  transcripts: z50.array(TranscriptStateSchema).default([])
 });
 var MAX_PENDING_TOOL_NAMES = 256;
 function readerStatePath(root = getMinerRoot()) {
@@ -7261,7 +7262,7 @@ async function ingestLine(parsed, locator, toolNames, ingestor, counters, sample
   }
 }
 async function runDrainIngest(options = {}) {
-  const startedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const started = process.hrtime.bigint();
   const root = options.root ?? getMinerRoot();
   const corpusRoot = options.corpusRoot ?? transcriptsRoot3();
@@ -7308,7 +7309,7 @@ async function runDrainIngest(options = {}) {
   await ingestor.flush();
   await saveReaderState(state, root);
   return {
-    startedAt: startedAt2,
+    startedAt,
     durationMs: Number(process.hrtime.bigint() - started) / 1e6,
     transcripts: discovered.length,
     scanned,
@@ -7321,27 +7322,27 @@ async function runDrainIngest(options = {}) {
 }
 
 // src/commands/miner-drain-ingest.ts
-var ArgsSchema43 = z50.object({
-  full: z50.boolean().optional(),
-  limit: z50.coerce.number().int().positive().optional(),
-  verify_hashes: z50.boolean().optional()
-});
-var ResultSchema39 = z50.object({
-  startedAt: z50.string(),
-  durationMs: z50.number(),
-  transcripts: z50.number(),
-  scanned: z50.number(),
-  unchanged: z50.number(),
-  rewound: z50.number(),
-  linesRead: z50.number(),
-  malformedLines: z50.number(),
-  blobs: z50.number(),
-  ingested: z50.number(),
-  newTemplates: z50.number(),
-  templates: z50.number(),
-  evicting: z50.boolean(),
-  curve: z50.array(z50.object({ blobs: z50.number(), templates: z50.number(), evicting: z50.boolean() })),
-  errors: z50.array(z50.string())
+var ArgsSchema43 = z51.object({
+  full: z51.boolean().optional(),
+  limit: z51.coerce.number().int().positive().optional(),
+  verify_hashes: z51.boolean().optional()
+});
+var ResultSchema39 = z51.object({
+  startedAt: z51.string(),
+  durationMs: z51.number(),
+  transcripts: z51.number(),
+  scanned: z51.number(),
+  unchanged: z51.number(),
+  rewound: z51.number(),
+  linesRead: z51.number(),
+  malformedLines: z51.number(),
+  blobs: z51.number(),
+  ingested: z51.number(),
+  newTemplates: z51.number(),
+  templates: z51.number(),
+  evicting: z51.boolean(),
+  curve: z51.array(z51.object({ blobs: z51.number(), templates: z51.number(), evicting: z51.boolean() })),
+  errors: z51.array(z51.string())
 });
 var miner_drain_ingest_default = defineCommand({
   name: "miner.drain-ingest",
@@ -7374,46 +7375,46 @@ var miner_drain_ingest_default = defineCommand({
 });
 
 // src/commands/miner-refresh.ts
-import { z as z51 } from "zod";
-var ArgsSchema44 = z51.object({
-  full: z51.boolean().optional(),
-  limit: z51.coerce.number().int().positive().optional(),
-  verify_hashes: z51.boolean().optional()
-});
-var WorkspaceSchema = z51.object({
-  files: z51.number(),
-  indexed: z51.number(),
-  unchanged: z51.number(),
-  removed: z51.number(),
-  malformed: z51.array(z51.object({ path: z51.string(), reason: z51.string() })),
-  rows: z51.object({
-    initiative: z51.number(),
-    note: z51.number(),
-    task: z51.number(),
-    session: z51.number(),
-    source: z51.number()
+import { z as z52 } from "zod";
+var ArgsSchema44 = z52.object({
+  full: z52.boolean().optional(),
+  limit: z52.coerce.number().int().positive().optional(),
+  verify_hashes: z52.boolean().optional()
+});
+var WorkspaceSchema = z52.object({
+  files: z52.number(),
+  indexed: z52.number(),
+  unchanged: z52.number(),
+  removed: z52.number(),
+  malformed: z52.array(z52.object({ path: z52.string(), reason: z52.string() })),
+  rows: z52.object({
+    initiative: z52.number(),
+    note: z52.number(),
+    task: z52.number(),
+    session: z52.number(),
+    source: z52.number()
   }),
-  edges: z51.object({ holds: z51.number(), mentions: z51.number(), sharesTag: z51.number() }),
-  orphanRatio: z51.number()
-});
-var ResultSchema40 = z51.object({
-  startedAt: z51.string(),
-  durationMs: z51.number(),
-  transcripts: z51.number(),
-  scanned: z51.number(),
-  indexed: z51.number(),
-  rewound: z51.number(),
-  unchanged: z51.number(),
-  quarantined: z51.number(),
-  missing: z51.number(),
-  reconciledMissing: z51.number(),
-  factsAdded: z51.number(),
-  turnsRolledUp: z51.number(),
-  tasksRequested: z51.number(),
-  tasksApplied: z51.number(),
+  edges: z52.object({ holds: z52.number(), mentions: z52.number(), sharesTag: z52.number() }),
+  orphanRatio: z52.number()
+});
+var ResultSchema40 = z52.object({
+  startedAt: z52.string(),
+  durationMs: z52.number(),
+  transcripts: z52.number(),
+  scanned: z52.number(),
+  indexed: z52.number(),
+  rewound: z52.number(),
+  unchanged: z52.number(),
+  quarantined: z52.number(),
+  missing: z52.number(),
+  reconciledMissing: z52.number(),
+  factsAdded: z52.number(),
+  turnsRolledUp: z52.number(),
+  tasksRequested: z52.number(),
+  tasksApplied: z52.number(),
   workspace: WorkspaceSchema.nullable(),
-  preserved: z51.object({ restored: z51.number(), merged: z51.number(), skipped: z51.number() }),
-  errors: z51.array(z51.string())
+  preserved: z52.object({ restored: z52.number(), merged: z52.number(), skipped: z52.number() }),
+  errors: z52.array(z52.string())
 });
 var miner_refresh_default = defineCommand({
   name: "miner.refresh",
@@ -7445,7 +7446,7 @@ var miner_refresh_default = defineCommand({
 
 // src/commands/miner-liveness.ts
 import { existsSync as existsSync3 } from "fs";
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // src/session-index/liveness.ts
 import { existsSync as existsSync2 } from "fs";
@@ -7562,22 +7563,22 @@ function runLiveness(db) {
 }
 
 // src/commands/miner-liveness.ts
-var ArgsSchema45 = z52.object({});
-var ResultSchema41 = z52.object({
-  emptyColumns: z52.array(
-    z52.object({ table: z52.string(), column: z52.string(), rows: z52.number(), nonNull: z52.number() })
+var ArgsSchema45 = z53.object({});
+var ResultSchema41 = z53.object({
+  emptyColumns: z53.array(
+    z53.object({ table: z53.string(), column: z53.string(), rows: z53.number(), nonNull: z53.number() })
   ),
-  unusedRelations: z52.array(z52.string()),
-  undeclaredRelations: z52.array(z52.string()),
-  danglingNamespaces: z52.array(
-    z52.object({ namespace: z52.string(), edges: z52.number(), dangling: z52.number() })
+  unusedRelations: z53.array(z53.string()),
+  undeclaredRelations: z53.array(z53.string()),
+  danglingNamespaces: z53.array(
+    z53.object({ namespace: z53.string(), edges: z53.number(), dangling: z53.number() })
   ),
-  unmappedNamespaces: z52.array(z52.string()),
-  expectedEmptyColumns: z52.array(
-    z52.object({ table: z52.string(), column: z52.string(), reason: z52.string() })
+  unmappedNamespaces: z53.array(z53.string()),
+  expectedEmptyColumns: z53.array(
+    z53.object({ table: z53.string(), column: z53.string(), reason: z53.string() })
   ),
-  staleTranscripts: z52.number(),
-  transcripts: z52.number()
+  staleTranscripts: z53.number(),
+  transcripts: z53.number()
 });
 function report(result) {
   const lines = [color.bold("active-work miner liveness")];
@@ -7668,40 +7669,40 @@ var miner_liveness_default = defineCommand({
 
 // src/commands/miner-status.ts
 import { existsSync as existsSync4, statSync } from "fs";
-import { z as z53 } from "zod";
-var ArgsSchema46 = z53.object({});
-var ResultSchema42 = z53.object({
-  dbPath: z53.string(),
-  schemaVersion: z53.number(),
-  sizeBytes: z53.number(),
-  counts: z53.object({
-    transcripts: z53.number(),
-    sessions: z53.number(),
-    facts: z53.number(),
-    turns: z53.number(),
-    edges: z53.number(),
-    spans: z53.number()
+import { z as z54 } from "zod";
+var ArgsSchema46 = z54.object({});
+var ResultSchema42 = z54.object({
+  dbPath: z54.string(),
+  schemaVersion: z54.number(),
+  sizeBytes: z54.number(),
+  counts: z54.object({
+    transcripts: z54.number(),
+    sessions: z54.number(),
+    facts: z54.number(),
+    turns: z54.number(),
+    edges: z54.number(),
+    spans: z54.number()
   }),
-  transcripts: z53.object({
-    ok: z53.number(),
-    quarantined: z53.number(),
-    missing: z53.number()
+  transcripts: z54.object({
+    ok: z54.number(),
+    quarantined: z54.number(),
+    missing: z54.number()
   }),
-  watermark: z53.object({
-    lastIndexedAt: z53.string().nullable(),
-    behindBytes: z53.number()
+  watermark: z54.object({
+    lastIndexedAt: z54.string().nullable(),
+    behindBytes: z54.number()
   }),
-  fts: z53.object({
-    rows: z53.number(),
-    orphanRows: z53.number(),
-    needsFullRebuild: z53.boolean()
+  fts: z54.object({
+    rows: z54.number(),
+    orphanRows: z54.number(),
+    needsFullRebuild: z54.boolean()
   }),
-  daemon: z53.object({
-    indexing: z53.boolean(),
-    pending: z53.boolean(),
-    lastRunAt: z53.string().nullable(),
-    lastDurationMs: z53.number().nullable(),
-    consecutiveErrors: z53.number()
+  daemon: z54.object({
+    indexing: z54.boolean(),
+    pending: z54.boolean(),
+    lastRunAt: z54.string().nullable(),
+    lastDurationMs: z54.number().nullable(),
+    consecutiveErrors: z54.number()
   }).nullable()
 });
 var ORPHAN_WARN_RATIO = 0.2;
@@ -7785,7 +7786,7 @@ var miner_status_default = defineCommand({
 });
 
 // src/commands/hooks-agent-chat-spawn.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 
 // src/utils/read-stdin-json.ts
 async function readStdinJson(stream = process.stdin) {
@@ -7806,12 +7807,12 @@ async function readStdinJson(stream = process.stdin) {
 // src/utils/agent-chat-hook-state.ts
 import { promises as fs49 } from "fs";
 import path61 from "path";
-import { z as z54 } from "zod";
-var SpawnContextSchema = z54.object({
-  slug: z54.string().min(1),
-  sessionId: z54.string().min(1),
-  name: z54.string(),
-  started: z54.string(),
+import { z as z55 } from "zod";
+var SpawnContextSchema = z55.object({
+  slug: z55.string().min(1),
+  sessionId: z55.string().min(1),
+  name: z55.string(),
+  started: z55.string(),
   /**
    * The spawning session, already resolved from the payload's `parent`
    * agentId to a session id. Resolved at spawn time on purpose: `parent` names
@@ -7819,10 +7820,10 @@ var SpawnContextSchema = z54.object({
    * another live entry in this same directory — which is gone by the time
    * on_complete runs, because reading one deletes it.
    */
-  parentSessionId: z54.string().min(1).nullable().default(null),
+  parentSessionId: z55.string().min(1).nullable().default(null),
   /** agent-chat profile and briefing slug, for the recorded session's prose. */
-  profile: z54.string().nullable().default(null),
-  briefing: z54.string().nullable().default(null)
+  profile: z55.string().nullable().default(null),
+  briefing: z55.string().nullable().default(null)
 });
 function stateDir() {
   return path61.join(getStateRoot(), "agent-chat-hooks");
@@ -7854,10 +7855,10 @@ async function peekSpawnContext(agentId) {
 }
 
 // src/commands/hooks-agent-chat-spawn.ts
-var ArgsSchema47 = z55.object({});
-var ResultSchema43 = z55.object({
-  matched: z55.boolean(),
-  slug: z55.string().nullable()
+var ArgsSchema47 = z56.object({});
+var ResultSchema43 = z56.object({
+  matched: z56.boolean(),
+  slug: z56.string().nullable()
 });
 function str2(source, key) {
   const value = source?.[key];
@@ -7899,11 +7900,11 @@ var hooks_agent_chat_spawn_default = defineCommand({
 
 // src/commands/hooks-agent-chat-complete.ts
 import { spawn as spawn5 } from "child_process";
-import { z as z56 } from "zod";
-var ArgsSchema48 = z56.object({});
-var ResultSchema44 = z56.object({
-  recorded: z56.boolean(),
-  slug: z56.string().nullable()
+import { z as z57 } from "zod";
+var ArgsSchema48 = z57.object({});
+var ResultSchema44 = z57.object({
+  recorded: z57.boolean(),
+  slug: z57.string().nullable()
 });
 function str3(source, key) {
   const value = source?.[key];
@@ -7982,7 +7983,7 @@ var hooks_agent_chat_complete_default = defineCommand({
 });
 
 // src/commands/setup.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 
 // src/setup/steps.ts
 import { promises as fsp3, existsSync as existsSync5 } from "fs";
@@ -8133,7 +8134,7 @@ import path64 from "path";
 
 // src/migrations/v3-proposal.ts
 import { promises as fs51 } from "fs";
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 
 // src/migrations/data/v3-open-loops-proposal.ts
 var V3_OPEN_LOOPS_PROPOSAL = {
@@ -8929,36 +8930,36 @@ var KEBAB_SESSION_ID = SessionIdSchema.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, {
   message: "session_id must be kebab-case ([a-z0-9-], no leading/trailing dash)"
 });
 var ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
-var AbandonedSchema = z57.object({ note: z57.string().min(1) });
+var AbandonedSchema = z58.object({ note: z58.string().min(1) });
 var ProposalNextStepSchema = NextStepSchema.extend({
   abandoned: AbandonedSchema.optional()
 });
-var ProposalInitiativeSchema = z57.object({
-  slug: z57.string().min(1),
+var ProposalInitiativeSchema = z58.object({
+  slug: z58.string().min(1),
   /**
    * Real last-touch of the initiative, hand-supplied. Never `Date.now()` and
    * never file mtime — several initiatives have mtimes months adrift from
    * their true last-touch, and the whole point of back-dating is to preserve
    * the staleness signal.
    */
-  ended: z57.string().regex(ISO_INSTANT, {
+  ended: z58.string().regex(ISO_INSTANT, {
     message: "ended must be an ISO 8601 instant with timezone"
   }),
   session_id: KEBAB_SESSION_ID,
-  body: z57.string().min(1),
-  next_steps: z57.array(ProposalNextStepSchema).default([])
+  body: z58.string().min(1),
+  next_steps: z58.array(ProposalNextStepSchema).default([])
 });
-var ProposalSchema = z57.object({
+var ProposalSchema = z58.object({
   /**
    * When the abandonment decision was made. Hand-supplied rather than read
    * from the clock: the second session's filename derives from it, and the
    * migration keys idempotence on exact paths, so `Date.now()` would mint a
    * fresh path — and a duplicate abandonment session — on every re-run.
    */
-  abandoned_at: z57.string().regex(ISO_INSTANT, {
+  abandoned_at: z58.string().regex(ISO_INSTANT, {
     message: "abandoned_at must be an ISO 8601 instant with timezone"
   }).optional(),
-  initiatives: z57.array(ProposalInitiativeSchema)
+  initiatives: z58.array(ProposalInitiativeSchema)
 }).superRefine((value, ctx) => {
   const withAbandoned = value.initiatives.filter(
     (i) => i.next_steps.some((n) => n.abandoned !== void 0)
@@ -10888,20 +10889,20 @@ async function runUninstall(deps = {}) {
 }
 
 // src/commands/setup.ts
-var ArgsSchema49 = z58.object({
-  update: z58.boolean().optional(),
-  yes: z58.boolean().optional()
+var ArgsSchema49 = z59.object({
+  update: z59.boolean().optional(),
+  yes: z59.boolean().optional()
 });
-var StepSchema = z58.object({
-  name: z58.string(),
-  ok: z58.boolean(),
-  done: z58.boolean().optional(),
-  message: z58.string().optional(),
-  error: z58.string().optional()
+var StepSchema = z59.object({
+  name: z59.string(),
+  ok: z59.boolean(),
+  done: z59.boolean().optional(),
+  message: z59.string().optional(),
+  error: z59.string().optional()
 });
-var ResultSchema45 = z58.object({
-  banner: z58.string(),
-  steps: z58.array(StepSchema)
+var ResultSchema45 = z59.object({
+  banner: z59.string(),
+  steps: z59.array(StepSchema)
 });
 function printStep(step) {
   if (step.ok) {
@@ -10954,19 +10955,19 @@ var setup_default = defineCommand({
 });
 
 // src/commands/uninstall.ts
-import { z as z59 } from "zod";
-var ArgsSchema50 = z59.object({
-  yes: z59.boolean().optional()
+import { z as z60 } from "zod";
+var ArgsSchema50 = z60.object({
+  yes: z60.boolean().optional()
 });
-var StepSchema2 = z59.object({
-  name: z59.string(),
-  done: z59.boolean(),
-  message: z59.string().optional(),
-  error: z59.string().optional()
+var StepSchema2 = z60.object({
+  name: z60.string(),
+  done: z60.boolean(),
+  message: z60.string().optional(),
+  error: z60.string().optional()
 });
-var ResultSchema46 = z59.object({
-  steps: z59.array(StepSchema2),
-  activeRootPreservedAt: z59.string()
+var ResultSchema46 = z60.object({
+  steps: z60.array(StepSchema2),
+  activeRootPreservedAt: z60.string()
 });
 var uninstall_default = defineCommand({
   name: "uninstall",
@@ -11002,7 +11003,7 @@ var uninstall_default = defineCommand({
 });
 
 // src/commands/doctor.ts
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 
 // src/doctor.ts
 import { promises as fsp4 } from "fs";
@@ -11410,15 +11411,15 @@ async function runDoctor(deps = {}) {
 }
 
 // src/commands/doctor.ts
-var ArgsSchema51 = z60.object({});
-var CheckSchema = z60.object({
-  name: z60.string(),
-  status: z60.enum(["ok", "warn", "fail"]),
-  detail: z60.string()
+var ArgsSchema51 = z61.object({});
+var CheckSchema = z61.object({
+  name: z61.string(),
+  status: z61.enum(["ok", "warn", "fail"]),
+  detail: z61.string()
 });
-var ResultSchema47 = z60.object({
-  ok: z60.boolean(),
-  checks: z60.array(CheckSchema)
+var ResultSchema47 = z61.object({
+  ok: z61.boolean(),
+  checks: z61.array(CheckSchema)
 });
 function badge(status) {
   if (status === "ok") return color.green("OK  ");
@@ -11446,34 +11447,34 @@ var doctor_default = defineCommand({
 });
 
 // src/commands/migrate.ts
-import { z as z61 } from "zod";
-var ArgsSchema52 = z61.object({
-  dry_run: z61.boolean().optional(),
-  apply: z61.boolean().optional()
-});
-var SessionSchema = z61.object({
-  kind: z61.enum(["open", "abandon"]),
-  action: z61.enum(["write", "exists"]),
-  file: z61.string(),
-  ended: z61.string(),
-  loops: z61.number().int().nonnegative(),
-  resolves: z61.number().int().nonnegative()
-});
-var InitiativeSchema = z61.object({
-  slug: z61.string(),
-  sessions: z61.array(SessionSchema),
-  task_seq_backfill: z61.number().int().positive().nullable(),
-  brief_repairs: z61.array(z61.string()),
-  brief_blocked: z61.string().optional(),
-  handoff: z61.enum(["archive-and-remove", "archive-exists", "absent"]),
-  note: z61.string().optional()
-});
-var ResultSchema48 = z61.object({
-  applied: z61.boolean(),
-  proposal: z61.string(),
-  initiatives: z61.array(InitiativeSchema),
-  repairs: z61.array(z61.object({ action: z61.string(), file: z61.string(), detail: z61.string() })),
-  uncovered: z61.array(z61.string())
+import { z as z62 } from "zod";
+var ArgsSchema52 = z62.object({
+  dry_run: z62.boolean().optional(),
+  apply: z62.boolean().optional()
+});
+var SessionSchema = z62.object({
+  kind: z62.enum(["open", "abandon"]),
+  action: z62.enum(["write", "exists"]),
+  file: z62.string(),
+  ended: z62.string(),
+  loops: z62.number().int().nonnegative(),
+  resolves: z62.number().int().nonnegative()
+});
+var InitiativeSchema = z62.object({
+  slug: z62.string(),
+  sessions: z62.array(SessionSchema),
+  task_seq_backfill: z62.number().int().positive().nullable(),
+  brief_repairs: z62.array(z62.string()),
+  brief_blocked: z62.string().optional(),
+  handoff: z62.enum(["archive-and-remove", "archive-exists", "absent"]),
+  note: z62.string().optional()
+});
+var ResultSchema48 = z62.object({
+  applied: z62.boolean(),
+  proposal: z62.string(),
+  initiatives: z62.array(InitiativeSchema),
+  repairs: z62.array(z62.object({ action: z62.string(), file: z62.string(), detail: z62.string() })),
+  uncovered: z62.array(z62.string())
 });
 function describe2(plan, applied) {
   const initiatives = plan.initiatives.map((i) => ({
@@ -11585,18 +11586,18 @@ var migrate_default = defineCommand({
 
 // src/commands/sync.ts
 import os7 from "os";
-import { z as z62 } from "zod";
-var ArgsSchema53 = z62.object({
-  message: z62.string().min(1).optional(),
-  require_clean: z62.boolean().optional()
-});
-var ResultSchema49 = z62.object({
-  branch: z62.string(),
-  committed: z62.boolean(),
-  committed_files: z62.number().int(),
-  rebased: z62.boolean(),
-  pushed: z62.boolean(),
-  summary: z62.string()
+import { z as z63 } from "zod";
+var ArgsSchema53 = z63.object({
+  message: z63.string().min(1).optional(),
+  require_clean: z63.boolean().optional()
+});
+var ResultSchema49 = z63.object({
+  branch: z63.string(),
+  committed: z63.boolean(),
+  committed_files: z63.number().int(),
+  rebased: z63.boolean(),
+  pushed: z63.boolean(),
+  summary: z63.string()
 });
 async function git(root, args) {
   return getGitRunner()("git", ["-C", root, ...args]);
@@ -12012,7 +12013,7 @@ function attachCommand(root, cmd) {
 function buildProgram() {
   const program = new Command();
   program.exitOverride();
-  program.name("active-work").description("active-work CLI \u2014 durable workspace state for engineering work").version("0.1.0").option("--json", "emit machine-readable JSON envelope on stdout").addHelpText(
+  program.name("active-work").description("active-work CLI \u2014 durable workspace state for engineering work").version(BUILD_VERSION).option("--json", "emit machine-readable JSON envelope on stdout").addHelpText(
     "after",
     "\nRun `active-work <command> --help` for command-specific options.\nTip: `aw [slug]` launches Claude with the bootstrap prompt.\n"
   );