@cleocode/core 2026.3.39 → 2026.3.41

package/dist/index.js

@@ -1774,7 +1774,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join105(chunks, separator) {
+      function join103(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -1782,7 +1782,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join105;
+      _sql.join = join103;
       function identifier(value) {
         return new Name(value);
       }
@@ -6469,7 +6469,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join105) => join105.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join103) => join103.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -7754,7 +7754,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_, v]) => v);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k, join105]) => {
+          return sql.join(withEntries.map(([k, join103]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One3);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -7765,7 +7765,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join105,
+              queryConfig: join103,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -7779,7 +7779,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join105 !== true && !!join105.where
+              isOptional: (relation.optional ?? false) || join103 !== true && !!join103.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s) => {
               return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb2}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -8178,7 +8178,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join105) => join105.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join103) => join103.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -8884,6 +8884,7 @@ __export(tasks_schema_exports, {
   adrTaskLinks: () => adrTaskLinks,
   architectureDecisions: () => architectureDecisions,
   auditLog: () => auditLog,
+  externalTaskLinks: () => externalTaskLinks,
   isValidStatus: () => isValidStatus,
   lifecycleEvidence: () => lifecycleEvidence,
   lifecycleGateResults: () => lifecycleGateResults,
@@ -8905,7 +8906,7 @@ __export(tasks_schema_exports, {
   warpChains: () => warpChains
 });
 import { sql as sql3 } from "drizzle-orm";
-var TASK_PRIORITIES, TASK_TYPES, TASK_SIZES, LIFECYCLE_STAGE_NAMES, LIFECYCLE_GATE_RESULTS, LIFECYCLE_EVIDENCE_TYPES, TOKEN_USAGE_METHODS, TOKEN_USAGE_CONFIDENCE, TOKEN_USAGE_TRANSPORTS, tasks, taskDependencies, taskRelations, sessions, taskWorkHistory, lifecyclePipelines, lifecycleStages, lifecycleGateResults, lifecycleEvidence, lifecycleTransitions, manifestEntries, pipelineManifest, releaseManifests, schemaMeta, auditLog, tokenUsage, architectureDecisions, adrTaskLinks, adrRelations, statusRegistryTable;
+var TASK_PRIORITIES, TASK_TYPES, TASK_SIZES, LIFECYCLE_STAGE_NAMES, LIFECYCLE_GATE_RESULTS, LIFECYCLE_EVIDENCE_TYPES, TOKEN_USAGE_METHODS, TOKEN_USAGE_CONFIDENCE, TOKEN_USAGE_TRANSPORTS, tasks, taskDependencies, taskRelations, sessions, taskWorkHistory, lifecyclePipelines, lifecycleStages, lifecycleGateResults, lifecycleEvidence, lifecycleTransitions, manifestEntries, pipelineManifest, releaseManifests, schemaMeta, auditLog, tokenUsage, architectureDecisions, adrTaskLinks, adrRelations, externalTaskLinks, statusRegistryTable;
 var init_tasks_schema = __esm({
   "packages/core/src/store/tasks-schema.ts"() {
     "use strict";
@@ -9360,6 +9361,40 @@ var init_tasks_schema = __esm({
       },
       (table) => [primaryKey({ columns: [table.fromAdrId, table.toAdrId, table.relationType] })]
     );
+    externalTaskLinks = sqliteTable(
+      "external_task_links",
+      {
+        id: text("id").primaryKey(),
+        taskId: text("task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
+        /** Provider identifier (e.g. 'linear', 'jira', 'github', 'gitlab'). */
+        providerId: text("provider_id").notNull(),
+        /** Provider-assigned identifier for the external task (opaque to CLEO). */
+        externalId: text("external_id").notNull(),
+        /** Optional URL to the external task (for human navigation). */
+        externalUrl: text("external_url"),
+        /** Title of the external task at the time of last sync. */
+        externalTitle: text("external_title"),
+        /** How this link was established. */
+        linkType: text("link_type", {
+          enum: ["created", "matched", "manual"]
+        }).notNull(),
+        /** Direction of the sync that created this link. */
+        syncDirection: text("sync_direction", {
+          enum: ["inbound", "outbound", "bidirectional"]
+        }).notNull().default("inbound"),
+        /** Arbitrary provider-specific metadata (JSON). */
+        metadataJson: text("metadata_json").default("{}"),
+        /** When the link was first established. */
+        linkedAt: text("linked_at").notNull().default(sql3`(datetime('now'))`),
+        /** When the external task was last synchronized. */
+        lastSyncAt: text("last_sync_at")
+      },
+      (table) => [
+        index("idx_ext_links_task_id").on(table.taskId),
+        index("idx_ext_links_provider_external").on(table.providerId, table.externalId),
+        index("idx_ext_links_provider_id").on(table.providerId)
+      ]
+    );
     statusRegistryTable = sqliteTable(
       "status_registry",
       {
@@ -12860,9 +12895,9 @@ async function readSequenceFromDb(cwd, accessor) {
     return isValidSequenceState(value) ? value : null;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
-  const rows = await db.select().from(schemaMeta).where(eq7(schemaMeta.key, SEQUENCE_META_KEY)).all();
+  const rows = await db.select().from(schemaMeta).where(eq8(schemaMeta.key, SEQUENCE_META_KEY)).all();
   const raw = rows[0]?.value;
   if (!raw) return null;
   try {
@@ -14298,8 +14333,8 @@ function analyzeArchitecture(projectRoot, _projectContext) {
       for (const entry of entries) {
         const entryPath = join22(srcPath, entry);
         try {
-          const stat3 = statSync2(entryPath);
-          if (stat3.isDirectory()) {
+          const stat2 = statSync2(entryPath);
+          if (stat2.isDirectory()) {
             const purpose = LAYER_PURPOSE[entry.toLowerCase()] ?? `${entry} layer`;
             layers.push({ name: entry, path: `src/${entry}`, purpose });
           } else if (ENTRY_POINT_NAMES.has(entry)) {
@@ -14420,8 +14455,8 @@ function analyzeStructure(projectRoot) {
     if (EXCLUDED_DIRS.has(entry) || entry.startsWith(".")) continue;
     const entryPath = join23(projectRoot, entry);
     try {
-      const stat3 = statSync3(entryPath);
-      if (stat3.isDirectory()) {
+      const stat2 = statSync3(entryPath);
+      if (stat2.isDirectory()) {
         const fileCount = countFiles(entryPath);
         totalFiles += fileCount;
         const purpose = DIR_PURPOSE[entry.toLowerCase()] ?? "Project directory";
@@ -14464,8 +14499,8 @@ function countFiles(dir, depth = 0) {
     if (EXCLUDED_DIRS.has(entry) || entry.startsWith(".")) continue;
     const entryPath = join23(dir, entry);
     try {
-      const stat3 = statSync3(entryPath);
-      if (stat3.isDirectory()) {
+      const stat2 = statSync3(entryPath);
+      if (stat2.isDirectory()) {
         count2 += countFiles(entryPath, depth + 1);
       } else {
         count2++;
@@ -14905,8 +14940,8 @@ function walkSourceFiles(dir, projectRoot, callback, depth = 0) {
       if (EXCLUDED_DIRS2.has(entry) || entry.startsWith(".")) continue;
       const fullPath = join27(dir, entry);
       try {
-        const stat3 = statSync5(fullPath);
-        if (stat3.isDirectory()) {
+        const stat2 = statSync5(fullPath);
+        if (stat2.isDirectory()) {
           walkSourceFiles(fullPath, projectRoot, callback, depth + 1);
         } else {
           const ext = entry.slice(entry.lastIndexOf("."));
@@ -17148,19 +17183,19 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and5, eq: eq7, gte: gte3, or: or4 } = await import("drizzle-orm");
+    const { and: and6, eq: eq8, gte: gte3, or: or4 } = await import("drizzle-orm");
     const db = await getDb3(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq7(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq7(auditLog2.domain, options.domain));
+    if (options?.sessionId) conditions.push(eq8(auditLog2.sessionId, options.sessionId));
+    if (options?.domain) conditions.push(eq8(auditLog2.domain, options.domain));
     if (options?.operation)
       conditions.push(
-        or4(eq7(auditLog2.operation, options.operation), eq7(auditLog2.action, options.operation))
+        or4(eq8(auditLog2.operation, options.operation), eq8(auditLog2.action, options.operation))
       );
-    if (options?.taskId) conditions.push(eq7(auditLog2.taskId, options.taskId));
+    if (options?.taskId) conditions.push(eq8(auditLog2.taskId, options.taskId));
     if (options?.since) conditions.push(gte3(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -17966,8 +18001,8 @@ async function cleanProjectSchemas(projectRoot) {
     return { cleaned: false };
   }
   try {
-    const stat3 = statSync7(projectSchemasDir);
-    if (!stat3.isDirectory()) {
+    const stat2 = statSync7(projectSchemasDir);
+    if (!stat2.isDirectory()) {
       return { cleaned: false };
     }
   } catch {
@@ -19013,8 +19048,8 @@ function checkSqliteDb(projectRoot) {
       fix: "cleo init"
     };
   }
-  const stat3 = statSync8(dbPath);
-  if (stat3.size === 0) {
+  const stat2 = statSync8(dbPath);
+  if (stat2.size === 0) {
     return {
       id: "sqlite_db",
       category: "scaffold",
@@ -19028,8 +19063,8 @@ function checkSqliteDb(projectRoot) {
     id: "sqlite_db",
     category: "scaffold",
     status: "passed",
-    message: `tasks.db exists (${stat3.size} bytes)`,
-    details: { path: dbPath, exists: true, size: stat3.size },
+    message: `tasks.db exists (${stat2.size} bytes)`,
+    details: { path: dbPath, exists: true, size: stat2.size },
     fix: null
   };
 }
@@ -19081,8 +19116,8 @@ function checkBrainDb(projectRoot) {
       fix: "cleo init"
     };
   }
-  const stat3 = statSync8(dbPath);
-  if (stat3.size === 0) {
+  const stat2 = statSync8(dbPath);
+  if (stat2.size === 0) {
     return {
       id: "brain_db",
       category: "scaffold",
@@ -19096,8 +19131,8 @@ function checkBrainDb(projectRoot) {
     id: "brain_db",
     category: "scaffold",
     status: "passed",
-    message: `brain.db exists (${stat3.size} bytes)`,
-    details: { path: dbPath, exists: true, size: stat3.size },
+    message: `brain.db exists (${stat2.size} bytes)`,
+    details: { path: dbPath, exists: true, size: stat2.size },
     fix: null
   };
 }
@@ -19348,8 +19383,8 @@ function detectEnvMode() {
     const devKv = {};
     const devLines = devContent.trim().split("\n");
     for (let i = 1; i < devLines.length; i++) {
-      const eq7 = devLines[i].indexOf("=");
-      if (eq7 > 0) devKv[devLines[i].slice(0, eq7).trim()] = devLines[i].slice(eq7 + 1).trim();
+      const eq8 = devLines[i].indexOf("=");
+      if (eq8 > 0) devKv[devLines[i].slice(0, eq8).trim()] = devLines[i].slice(eq8 + 1).trim();
     }
     if (devKv["mode"] === "dev-ts" && devKv["source"]) {
       const devSource = devKv["source"].replace(/\\/g, "/");
@@ -20588,9 +20623,9 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
   const projectHash = generateProjectHash(projectPath);
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  const existingRows = await db.select().from(projectRegistry).where(eq7(projectRegistry.projectHash, projectHash));
+  const existingRows = await db.select().from(projectRegistry).where(eq8(projectRegistry.projectHash, projectHash));
   const existing = existingRows[0];
   if (existing?.permissions) {
     throw new CleoError(
@@ -20599,7 +20634,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
     );
   }
   if (!existing) {
-    const nameConflictRows = await db.select().from(projectRegistry).where(eq7(projectRegistry.name, projectName));
+    const nameConflictRows = await db.select().from(projectRegistry).where(eq8(projectRegistry.name, projectName));
     if (nameConflictRows.length > 0) {
       throw new CleoError(
         6 /* VALIDATION_ERROR */,
@@ -20617,7 +20652,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
       taskCount: meta.taskCount,
       labelsJson: JSON.stringify(meta.labels),
       lastSeen: now
-    }).where(eq7(projectRegistry.projectHash, projectHash));
+    }).where(eq8(projectRegistry.projectHash, projectHash));
   } else {
     if (!projectId) {
       projectId = randomUUID3();
@@ -20655,9 +20690,9 @@ async function nexusUnregister(nameOrHash) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.delete(projectRegistry).where(eq7(projectRegistry.projectHash, project.hash));
+  await db.delete(projectRegistry).where(eq8(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "unregister",
     projectHash: project.hash,
@@ -20679,9 +20714,9 @@ async function nexusList() {
 async function nexusGetProject(nameOrHash) {
   try {
     const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-    const { eq: eq7, or: or4 } = await import("drizzle-orm");
+    const { eq: eq8, or: or4 } = await import("drizzle-orm");
     const db = await getNexusDb2();
-    const rows = await db.select().from(projectRegistry).where(or4(eq7(projectRegistry.projectHash, nameOrHash), eq7(projectRegistry.name, nameOrHash)));
+    const rows = await db.select().from(projectRegistry).where(or4(eq8(projectRegistry.projectHash, nameOrHash), eq8(projectRegistry.name, nameOrHash)));
     const row = rows[0];
     if (!row) return null;
     return rowToProject(row);
@@ -20704,14 +20739,14 @@ async function nexusSync(nameOrHash) {
   const meta = await readProjectMeta(project.path);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   await db.update(projectRegistry).set({
     taskCount: meta.taskCount,
     labelsJson: JSON.stringify(meta.labels),
     lastSync: now,
     lastSeen: now
-  }).where(eq7(projectRegistry.projectHash, project.hash));
+  }).where(eq8(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "sync",
     projectHash: project.hash,
@@ -20725,7 +20760,7 @@ async function nexusSyncAll() {
   let synced = 0;
   let failed = 0;
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   for (const project of projects) {
     try {
@@ -20736,7 +20771,7 @@ async function nexusSyncAll() {
         labelsJson: JSON.stringify(meta.labels),
         lastSync: now,
         lastSeen: now
-      }).where(eq7(projectRegistry.projectHash, project.hash));
+      }).where(eq8(projectRegistry.projectHash, project.hash));
       synced++;
     } catch {
       failed++;
@@ -20756,9 +20791,9 @@ async function nexusSetPermission(nameOrHash, permission) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.update(projectRegistry).set({ permissions: permission }).where(eq7(projectRegistry.projectHash, project.hash));
+  await db.update(projectRegistry).set({ permissions: permission }).where(eq8(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "set-permission",
     projectHash: project.hash,
@@ -20774,12 +20809,12 @@ async function nexusReconcile(projectRoot) {
   }
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   const projectId = await readProjectId(projectRoot);
   const currentHash = generateProjectHash(projectRoot);
   if (projectId) {
-    const hashRows2 = await db.select().from(projectRegistry).where(eq7(projectRegistry.projectHash, currentHash));
+    const hashRows2 = await db.select().from(projectRegistry).where(eq8(projectRegistry.projectHash, currentHash));
     const hashMatch2 = hashRows2[0];
     if (hashMatch2 && hashMatch2.projectId !== projectId) {
       await writeNexusAudit({
@@ -20798,12 +20833,12 @@ async function nexusReconcile(projectRoot) {
     }
   }
   if (projectId) {
-    const idRows = await db.select().from(projectRegistry).where(eq7(projectRegistry.projectId, projectId));
+    const idRows = await db.select().from(projectRegistry).where(eq8(projectRegistry.projectId, projectId));
     const existing = idRows[0];
     if (existing) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       if (existing.projectPath === projectRoot) {
-        await db.update(projectRegistry).set({ lastSeen: now }).where(eq7(projectRegistry.projectId, projectId));
+        await db.update(projectRegistry).set({ lastSeen: now }).where(eq8(projectRegistry.projectId, projectId));
         await writeNexusAudit({
           action: "reconcile",
           projectHash: currentHash,
@@ -20819,7 +20854,7 @@ async function nexusReconcile(projectRoot) {
         projectPath: projectRoot,
         projectHash: currentHash,
         lastSeen: now
-      }).where(eq7(projectRegistry.projectId, projectId));
+      }).where(eq8(projectRegistry.projectId, projectId));
       await writeNexusAudit({
         action: "reconcile",
         projectHash: currentHash,
@@ -20831,11 +20866,11 @@ async function nexusReconcile(projectRoot) {
       return { status: "path_updated", oldPath, newPath: projectRoot };
     }
   }
-  const hashRows = await db.select().from(projectRegistry).where(eq7(projectRegistry.projectHash, currentHash));
+  const hashRows = await db.select().from(projectRegistry).where(eq8(projectRegistry.projectHash, currentHash));
   const hashMatch = hashRows[0];
   if (hashMatch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    await db.update(projectRegistry).set({ lastSeen: now }).where(eq7(projectRegistry.projectHash, currentHash));
+    await db.update(projectRegistry).set({ lastSeen: now }).where(eq8(projectRegistry.projectHash, currentHash));
     await writeNexusAudit({
       action: "reconcile",
       projectHash: currentHash,
@@ -21437,7 +21472,7 @@ var init_update2 = __esm({
 // packages/core/src/sessions/assumptions.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import { appendFileSync as appendFileSync7, existsSync as existsSync63, mkdirSync as mkdirSync13 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join67 } from "node:path";
 async function recordAssumption(projectRoot, params) {
   if (!params?.assumption) {
     throw new CleoError(2 /* INVALID_INPUT */, "assumption is required");
@@ -21459,11 +21494,11 @@ async function recordAssumption(projectRoot, params) {
     validatedAt: null,
     timestamp: now
   };
-  const auditDir = join68(projectRoot, ".cleo", "audit");
+  const auditDir = join67(projectRoot, ".cleo", "audit");
   if (!existsSync63(auditDir)) {
     mkdirSync13(auditDir, { recursive: true });
   }
-  const assumptionsPath = join68(auditDir, "assumptions.jsonl");
+  const assumptionsPath = join67(auditDir, "assumptions.jsonl");
   appendFileSync7(assumptionsPath, JSON.stringify(record) + "\n", "utf-8");
   return {
     id,
@@ -22915,11 +22950,11 @@ var init_sessions = __esm({
 
 // packages/core/src/hooks.ts
 import { existsSync as existsSync83 } from "node:fs";
-import { chmod, copyFile as copyFile2, mkdir as mkdir15, readFile as readFile14 } from "node:fs/promises";
-import { join as join87 } from "node:path";
+import { chmod, copyFile as copyFile2, mkdir as mkdir14, readFile as readFile14 } from "node:fs/promises";
+import { join as join86 } from "node:path";
 async function ensureGitHooks(projectRoot, opts) {
-  const gitDir = join87(projectRoot, ".git");
-  const gitHooksDir = join87(gitDir, "hooks");
+  const gitDir = join86(projectRoot, ".git");
+  const gitHooksDir = join86(gitDir, "hooks");
   if (!existsSync83(gitDir)) {
     return {
       action: "skipped",
@@ -22928,7 +22963,7 @@ async function ensureGitHooks(projectRoot, opts) {
     };
   }
   const packageRoot = getPackageRoot();
-  const sourceDir = join87(packageRoot, "templates", "git-hooks");
+  const sourceDir = join86(packageRoot, "templates", "git-hooks");
   if (!existsSync83(sourceDir)) {
     return {
       action: "skipped",
@@ -22936,13 +22971,13 @@ async function ensureGitHooks(projectRoot, opts) {
       details: "templates/git-hooks/ not found in package root, skipping git hook installation"
     };
   }
-  await mkdir15(gitHooksDir, { recursive: true });
+  await mkdir14(gitHooksDir, { recursive: true });
   const force = opts?.force ?? false;
   let installedCount = 0;
   const errors = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join87(sourceDir, hook);
-    const destPath = join87(gitHooksDir, hook);
+    const sourcePath = join86(sourceDir, hook);
+    const destPath = join86(gitHooksDir, hook);
     if (!existsSync83(sourcePath)) {
       continue;
     }
@@ -22980,13 +23015,13 @@ async function ensureGitHooks(projectRoot, opts) {
   };
 }
 async function checkGitHooks(projectRoot) {
-  const gitHooksDir = join87(projectRoot, ".git", "hooks");
+  const gitHooksDir = join86(projectRoot, ".git", "hooks");
   const packageRoot = getPackageRoot();
-  const sourceDir = join87(packageRoot, "templates", "git-hooks");
+  const sourceDir = join86(packageRoot, "templates", "git-hooks");
   const results = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join87(sourceDir, hook);
-    const installedPath = join87(gitHooksDir, hook);
+    const sourcePath = join86(sourceDir, hook);
+    const installedPath = join86(gitHooksDir, hook);
     const result = {
       hook,
       installed: false,
@@ -23069,14 +23104,6 @@ function taskToMarkdown(task) {
   const priority = task.priority === "critical" ? "!!!" : task.priority === "high" ? "!!" : "";
   return `- [${status}] **${task.id}** ${priority} ${task.title}`;
 }
-function taskToTodoWrite(task) {
-  return {
-    id: task.id,
-    content: task.title,
-    status: task.status === "done" ? "completed" : task.status === "active" ? "in_progress" : "pending",
-    priority: task.priority === "critical" ? "high" : task.priority
-  };
-}
 async function exportTasks(params) {
   const accessor = await getAccessor(params.cwd);
   const queryResult = await accessor.queryTasks({});
@@ -23140,13 +23167,8 @@ async function exportTasks(params) {
       content = lines.join("\n");
       break;
     }
-    case "todowrite": {
-      const items = tasks2.map(taskToTodoWrite);
-      content = JSON.stringify(items, null, 2);
-      break;
-    }
     default:
-      throw new Error(`Unknown format: ${format}. Valid: json, csv, tsv, markdown, todowrite`);
+      throw new Error(`Unknown format: ${format}. Valid: json, csv, tsv, markdown`);
   }
   if (params.output) {
     await writeFile2(params.output, content);
@@ -23969,7 +23991,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     return result;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and5, eq: eq7 } = await import("drizzle-orm");
+  const { and: and6, eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(projectRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const filePath of matchingFiles) {
@@ -23979,7 +24001,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
       const fm = record.frontmatter;
       const content = readFileSync5(filePath, "utf-8");
       const relativePath = `.cleo/adrs/${filename}`;
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq7(architectureDecisions.id, record.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq8(architectureDecisions.id, record.id)).all();
       const rowBase = {
         id: record.id,
         title: record.title,
@@ -23999,19 +24021,19 @@ async function linkPipelineAdr(projectRoot, taskId) {
         updatedAt: now
       };
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq7(architectureDecisions.id, record.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq8(architectureDecisions.id, record.id));
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
       }
       result.synced++;
-      await db.delete(adrTaskLinks).where(and5(eq7(adrTaskLinks.adrId, record.id), eq7(adrTaskLinks.taskId, taskId)));
+      await db.delete(adrTaskLinks).where(and6(eq8(adrTaskLinks.adrId, record.id), eq8(adrTaskLinks.taskId, taskId)));
       await db.insert(adrTaskLinks).values({ adrId: record.id, taskId, linkType: "implements" });
       result.linked.push({ adrId: record.id, taskId });
       if (fm["Related ADRs"]) {
         const relatedIds = fm["Related ADRs"].split(",").map((r) => r.trim()).filter((r) => /^ADR-\d+$/.test(r));
         for (const toId of relatedIds) {
           try {
-            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq7(architectureDecisions.id, toId)).all();
+            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq8(architectureDecisions.id, toId)).all();
             if (targetExists.length > 0) {
               await db.insert(adrRelations).values({ fromAdrId: record.id, toAdrId: toId, relationType: "related" }).onConflictDoNothing();
             }
@@ -24149,7 +24171,7 @@ async function syncAdrsToDb(projectRoot) {
     return result;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(projectRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const allFiles = collectAdrFiles(adrsDir);
@@ -24183,15 +24205,15 @@ async function syncAdrsToDb(projectRoot) {
         topics: fm.Topics ?? null,
         updatedAt: now
       };
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq7(architectureDecisions.id, record.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq8(architectureDecisions.id, record.id)).all();
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq7(architectureDecisions.id, record.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq8(architectureDecisions.id, record.id));
         result.updated++;
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
         result.inserted++;
       }
-      await db.delete(adrTaskLinks).where(eq7(adrTaskLinks.adrId, record.id));
+      await db.delete(adrTaskLinks).where(eq8(adrTaskLinks.adrId, record.id));
       if (fm["Related Tasks"]) {
         for (const taskId of parseTaskIds2(fm["Related Tasks"])) {
           await db.insert(adrTaskLinks).values({ adrId: record.id, taskId, linkType: "related" });
@@ -25124,7 +25146,7 @@ function selectTasksForInjection(data, opts) {
   });
   return tasks2.slice(0, maxTasks);
 }
-function formatForTodoWrite(tasks2) {
+function formatForInjection(tasks2) {
   return tasks2.map((t) => {
     let prefix = `[${t.id}]`;
     if (t.priority === "critical" || t.priority === "high") prefix += " [!]";
@@ -25143,7 +25165,7 @@ async function injectTasks(opts, accessor) {
     focus: focusMeta
   };
   const selectedTasks = selectTasksForInjection(data, opts);
-  const formatted = formatForTodoWrite(selectedTasks);
+  const formatted = formatForInjection(selectedTasks);
   const phase = opts.phase ?? projectMeta?.currentPhase ?? null;
   return {
     tasks: formatted,
@@ -26289,12 +26311,12 @@ async function getEnforcementMode(cwd) {
 }
 async function getLifecycleStatus(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineResult = await db.select({
     pipeline: lifecyclePipelines,
     task: tasks
-  }).from(lifecyclePipelines).innerJoin(tasks, eq7(lifecyclePipelines.taskId, tasks.id)).where(eq7(lifecyclePipelines.taskId, epicId)).limit(1);
+  }).from(lifecyclePipelines).innerJoin(tasks, eq8(lifecyclePipelines.taskId, tasks.id)).where(eq8(lifecyclePipelines.taskId, epicId)).limit(1);
   if (pipelineResult.length === 0) {
     return {
       epicId,
@@ -26307,7 +26329,7 @@ async function getLifecycleStatus(epicId, cwd) {
   }
   const task = pipelineResult[0].task;
   const pipelineId = `pipeline-${epicId}`;
-  const stageRows = await db.select().from(lifecycleStages).where(eq7(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
+  const stageRows = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
   const stageDataMap = /* @__PURE__ */ new Map();
   for (const row of stageRows) {
     let parsedChain;
@@ -26376,10 +26398,10 @@ async function getLifecycleStatus(epicId, cwd) {
 }
 async function getLifecycleHistory(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq7(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return { epicId, history: [] };
   }
@@ -26409,7 +26431,7 @@ async function getLifecycleHistory(epicId, cwd) {
   }
   const stageIds = stages.map((s) => s.id);
   if (stageIds.length > 0) {
-    const gateResults = await db.select().from(lifecycleGateResults).where(eq7(lifecycleGateResults.stageId, stageIds[0]));
+    const gateResults = await db.select().from(lifecycleGateResults).where(eq8(lifecycleGateResults.stageId, stageIds[0]));
     for (const gate of gateResults) {
       const stageName = stageIdToName.get(gate.stageId);
       if (stageName) {
@@ -26422,7 +26444,7 @@ async function getLifecycleHistory(epicId, cwd) {
       }
     }
     for (let i = 1; i < stageIds.length; i++) {
-      const additionalGates = await db.select().from(lifecycleGateResults).where(eq7(lifecycleGateResults.stageId, stageIds[i]));
+      const additionalGates = await db.select().from(lifecycleGateResults).where(eq8(lifecycleGateResults.stageId, stageIds[i]));
       for (const gate of additionalGates) {
         const stageName = stageIdToName.get(gate.stageId);
         if (stageName) {
@@ -26441,16 +26463,16 @@ async function getLifecycleHistory(epicId, cwd) {
 }
 async function getLifecycleGates(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq7(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return {};
   }
   const gates = {};
   for (const stage of stages) {
-    const gateRows = await db.select().from(lifecycleGateResults).where(eq7(lifecycleGateResults.stageId, stage.id));
+    const gateRows = await db.select().from(lifecycleGateResults).where(eq8(lifecycleGateResults.stageId, stage.id));
     if (gateRows.length > 0) {
       gates[stage.stageName] = {};
       for (const gateRow of gateRows) {
@@ -26514,7 +26536,7 @@ async function checkStagePrerequisites(epicId, targetStage, cwd) {
 }
 async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
   const stageId = `stage-${epicId}-${stageName}`;
@@ -26522,7 +26544,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   getNativeDb2().prepare(
     `INSERT OR IGNORE INTO tasks (id, title, status, priority, created_at) VALUES (?, ?, 'pending', 'medium', datetime('now'))`
   ).run(epicId, `Task ${epicId}`);
-  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq7(lifecyclePipelines.id, pipelineId)).limit(1).all();
+  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.id, pipelineId)).limit(1).all();
   if (existingPipeline.length === 0) {
     await db.insert(lifecyclePipelines).values({
       id: pipelineId,
@@ -26532,7 +26554,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
       startedAt: options.now
     }).run();
   }
-  const existingStage = await db.select().from(lifecycleStages).where(eq7(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.id, stageId)).limit(1).all();
   if (existingStage.length === 0) {
     const sequence = isValidStage(stageName) ? STAGE_ORDER[stageName] : 0;
     await db.insert(lifecycleStages).values({
@@ -26545,7 +26567,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
     }).run();
   }
   if (options.updateCurrentStage) {
-    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq7(lifecyclePipelines.id, pipelineId)).run();
+    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq8(lifecyclePipelines.id, pipelineId)).run();
   }
   return { db, pipelineId, stageId };
 }
@@ -26560,7 +26582,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       `Invalid status: ${status}. Valid: ${validStatuses.join(", ")}`
     );
   }
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = stage;
   const { db, stageId, pipelineId } = await ensureLifecycleContext(epicId, stage, cwd, {
@@ -26576,7 +26598,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     status,
     related: artifact.related
   };
-  const existingStage = await db.select().from(lifecycleStages).where(eq7(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.id, stageId)).limit(1).all();
   const sequence = STAGE_ORDER[stage];
   const stageValues = {
     status,
@@ -26603,7 +26625,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       provenanceChainJson: JSON.stringify(provenanceChain)
     }).run();
   } else {
-    await db.update(lifecycleStages).set(stageValues).where(eq7(lifecycleStages.id, stageId)).run();
+    await db.update(lifecycleStages).set(stageValues).where(eq8(lifecycleStages.id, stageId)).run();
   }
   if (status === "completed") {
     await linkProvenance(epicId, stageName, artifact.absolutePath, cwd);
@@ -26623,7 +26645,7 @@ async function resetStage(epicId, stage, reason, cwd) {
   if (!PIPELINE_STAGES.includes(stage)) {
     throw new CleoError(2 /* INVALID_INPUT */, `Invalid stage: ${stage}`);
   }
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const { db, stageId } = await ensureLifecycleContext(epicId, stage, cwd, {
     now,
@@ -26636,11 +26658,11 @@ async function resetStage(epicId, stage, reason, cwd) {
     skippedAt: null,
     skipReason: null,
     notesJson: JSON.stringify([`Reset: ${reason}`])
-  }).where(eq7(lifecycleStages.id, stageId)).run();
+  }).where(eq8(lifecycleStages.id, stageId)).run();
   return { epicId, stage, reason };
 }
 async function passGate(epicId, gateName, agent, notes, cwd) {
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -26649,7 +26671,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq7(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq8(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -26661,14 +26683,14 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     reason: null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq7(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq8(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
   return { epicId, gateName, timestamp: now };
 }
 async function failGate(epicId, gateName, reason, cwd) {
-  const { eq: eq7 } = await import("drizzle-orm");
+  const { eq: eq8 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -26677,7 +26699,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq7(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq8(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -26689,7 +26711,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     reason: reason ?? null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq7(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq8(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -27879,8 +27901,8 @@ function parseTokenMetrics(inputFile, cwd) {
     const raw = JSON.parse(readFileSync28(file, "utf-8"));
     if (raw.resourceMetrics) {
       const points = [];
-      for (const rm4 of raw.resourceMetrics ?? []) {
-        for (const sm of rm4.scopeMetrics ?? []) {
+      for (const rm2 of raw.resourceMetrics ?? []) {
+        for (const sm of rm2.scopeMetrics ?? []) {
           for (const metric of sm.metrics ?? []) {
             if (metric.name !== "claude_code.token.usage") continue;
             for (const dp of metric.sum?.dataPoints ?? []) {
@@ -31064,8 +31086,8 @@ function collectCleoFiles(cleoDir) {
       const fullPath = join59(dir, entry);
       const relPath = relative5(cleoDir, fullPath);
       try {
-        const stat3 = statSync15(fullPath);
-        if (stat3.isDirectory()) {
+        const stat2 = statSync15(fullPath);
+        if (stat2.isDirectory()) {
           walk(fullPath);
         } else {
           files.push(relPath.replaceAll("\\", "/"));
@@ -31301,17 +31323,17 @@ function scanLogDir(dir, includeMigration) {
     const isMigration = MIGRATION_LOG_PATTERN.test(name2);
     if (!cleoMatch && (!isMigration || !includeMigration)) continue;
     const filePath = join60(dir, name2);
-    let stat3;
+    let stat2;
     try {
-      stat3 = statSync16(filePath);
+      stat2 = statSync16(filePath);
     } catch {
       continue;
     }
     files.push({
       path: filePath,
       name: name2,
-      size: stat3.size,
-      mtime: stat3.mtime.toISOString(),
+      size: stat2.size,
+      mtime: stat2.mtime.toISOString(),
       date: cleoMatch ? cleoMatch[1] : null,
       isActive: false
       // set below
@@ -32501,53 +32523,109 @@ async function showPhase2(projectRoot, phaseId, accessor) {
 // packages/core/src/reconciliation/index.ts
 var reconciliation_exports = {};
 __export(reconciliation_exports, {
-  clearSyncState: () => clearSyncState,
-  readSyncState: () => readSyncState,
+  createLink: () => createLink,
+  getLinkByExternalId: () => getLinkByExternalId,
+  getLinksByProvider: () => getLinksByProvider,
+  getLinksByTaskId: () => getLinksByTaskId,
   reconcile: () => reconcile,
-  writeSyncState: () => writeSyncState
+  removeLinksByProvider: () => removeLinksByProvider,
+  touchLink: () => touchLink
 });
 
-// packages/core/src/reconciliation/reconciliation-engine.ts
-init_data_accessor();
-init_add();
-init_complete();
-init_update2();
-
-// packages/core/src/reconciliation/sync-state.ts
-init_paths();
-init_atomic();
-init_json2();
-import { mkdir as mkdir13, rm as rm2 } from "node:fs/promises";
-import { join as join62 } from "node:path";
-function getSyncDir(cwd) {
-  return join62(getCleoDir(cwd), "sync");
+// packages/core/src/reconciliation/link-store.ts
+init_sqlite2();
+init_tasks_schema();
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { and as and4, eq as eq6 } from "drizzle-orm";
+async function getLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq6(externalTaskLinks.providerId, providerId));
+  return rows.map(rowToLink);
 }
-function getStateFilePath(providerId, cwd) {
-  return join62(getSyncDir(cwd), `${providerId}-session.json`);
+async function getLinkByExternalId(providerId, externalId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(
+    and4(
+      eq6(externalTaskLinks.providerId, providerId),
+      eq6(externalTaskLinks.externalId, externalId)
+    )
+  );
+  return rows.length > 0 ? rowToLink(rows[0]) : null;
 }
-async function readSyncState(providerId, cwd) {
-  const filePath = getStateFilePath(providerId, cwd);
-  try {
-    return await readJson(filePath);
-  } catch {
-    return null;
+async function getLinksByTaskId(taskId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq6(externalTaskLinks.taskId, taskId));
+  return rows.map(rowToLink);
+}
+async function createLink(params, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = randomUUID4();
+  await db.insert(externalTaskLinks).values({
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadataJson: params.metadata ? JSON.stringify(params.metadata) : "{}",
+    linkedAt: now,
+    lastSyncAt: now
+  });
+  return {
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadata: params.metadata,
+    linkedAt: now,
+    lastSyncAt: now
+  };
+}
+async function touchLink(linkId, updates, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const values = { lastSyncAt: now };
+  if (updates?.externalTitle !== void 0) {
+    values.externalTitle = updates.externalTitle;
+  }
+  if (updates?.metadata !== void 0) {
+    values.metadataJson = JSON.stringify(updates.metadata);
   }
+  await db.update(externalTaskLinks).set(values).where(eq6(externalTaskLinks.id, linkId));
 }
-async function writeSyncState(providerId, state, cwd) {
-  const syncDir = getSyncDir(cwd);
-  await mkdir13(syncDir, { recursive: true });
-  const filePath = getStateFilePath(providerId, cwd);
-  await atomicWriteJson(filePath, state);
+async function removeLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const result = await db.delete(externalTaskLinks).where(eq6(externalTaskLinks.providerId, providerId));
+  return Number(result.changes);
 }
-async function clearSyncState(providerId, cwd) {
-  const filePath = getStateFilePath(providerId, cwd);
-  try {
-    await rm2(filePath);
-  } catch {
-  }
+function rowToLink(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    providerId: row.providerId,
+    externalId: row.externalId,
+    externalUrl: row.externalUrl,
+    externalTitle: row.externalTitle,
+    linkType: row.linkType,
+    syncDirection: row.syncDirection,
+    metadata: row.metadataJson ? JSON.parse(row.metadataJson) : void 0,
+    linkedAt: row.linkedAt,
+    lastSyncAt: row.lastSyncAt
+  };
 }
 
 // packages/core/src/reconciliation/reconciliation-engine.ts
+init_data_accessor();
+init_add();
+init_complete();
+init_update2();
 function buildTaskMap(tasks2) {
   const map = /* @__PURE__ */ new Map();
   for (const t of tasks2) {
@@ -32555,19 +32633,25 @@ function buildTaskMap(tasks2) {
   }
   return map;
 }
-function computeActions(externalTasks, taskMap, injectedIds) {
+function buildLinkMap(links) {
+  const map = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    map.set(link.externalId, link);
+  }
+  return map;
+}
+function computeActions(externalTasks, taskMap, linkMap) {
   const actions = [];
-  const seenCleoIds = /* @__PURE__ */ new Set();
   for (const ext of externalTasks) {
-    if (ext.cleoTaskId) {
-      seenCleoIds.add(ext.cleoTaskId);
-      const cleoTask = taskMap.get(ext.cleoTaskId);
+    const existingLink = linkMap.get(ext.externalId);
+    if (existingLink) {
+      const cleoTask = taskMap.get(existingLink.taskId);
       if (!cleoTask) {
         actions.push({
           type: "skip",
-          cleoTaskId: ext.cleoTaskId,
+          cleoTaskId: existingLink.taskId,
           externalId: ext.externalId,
-          summary: `CLEO task ${ext.cleoTaskId} not found \u2014 skipping`,
+          summary: `Linked CLEO task ${existingLink.taskId} no longer exists \u2014 skipping`,
           applied: false
         });
         continue;
@@ -32575,9 +32659,9 @@ function computeActions(externalTasks, taskMap, injectedIds) {
       if (cleoTask.status === "done" || cleoTask.status === "cancelled") {
         actions.push({
           type: "skip",
-          cleoTaskId: ext.cleoTaskId,
+          cleoTaskId: cleoTask.id,
           externalId: ext.externalId,
-          summary: `CLEO task ${ext.cleoTaskId} already ${cleoTask.status}`,
+          summary: `CLEO task ${cleoTask.id} already ${cleoTask.status}`,
           applied: false
         });
         continue;
@@ -32585,61 +32669,54 @@ function computeActions(externalTasks, taskMap, injectedIds) {
       if (ext.status === "completed") {
         actions.push({
           type: "complete",
-          cleoTaskId: ext.cleoTaskId,
+          cleoTaskId: cleoTask.id,
           externalId: ext.externalId,
-          summary: `Complete ${ext.cleoTaskId} (${cleoTask.title})`,
-          applied: false
+          summary: `Complete ${cleoTask.id} (${cleoTask.title})`,
+          applied: false,
+          linkId: existingLink.id
         });
         continue;
       }
       if (ext.status === "active" && (cleoTask.status === "pending" || cleoTask.status === "blocked")) {
         actions.push({
           type: "activate",
-          cleoTaskId: ext.cleoTaskId,
+          cleoTaskId: cleoTask.id,
           externalId: ext.externalId,
-          summary: `Activate ${ext.cleoTaskId} (${cleoTask.title})`,
-          applied: false
+          summary: `Activate ${cleoTask.id} (${cleoTask.title})`,
+          applied: false,
+          linkId: existingLink.id
         });
         continue;
       }
-      if (ext.status === "removed") {
+      if (ext.title !== cleoTask.title) {
         actions.push({
-          type: "remove",
-          cleoTaskId: ext.cleoTaskId,
+          type: "update",
+          cleoTaskId: cleoTask.id,
           externalId: ext.externalId,
-          summary: `Task ${ext.cleoTaskId} removed from provider`,
-          applied: false
+          summary: `Update ${cleoTask.id} title: "${cleoTask.title}" \u2192 "${ext.title}"`,
+          applied: false,
+          linkId: existingLink.id
         });
         continue;
       }
       actions.push({
         type: "skip",
-        cleoTaskId: ext.cleoTaskId,
+        cleoTaskId: cleoTask.id,
         externalId: ext.externalId,
-        summary: `No change needed for ${ext.cleoTaskId}`,
-        applied: false
-      });
-      continue;
-    }
-    if (ext.status !== "removed") {
-      actions.push({
-        type: "create",
-        cleoTaskId: null,
-        externalId: ext.externalId,
-        summary: `Create new task: ${ext.title}`,
-        applied: false
-      });
-    }
-  }
-  for (const injectedId of injectedIds) {
-    if (!seenCleoIds.has(injectedId)) {
-      actions.push({
-        type: "remove",
-        cleoTaskId: injectedId,
-        externalId: `injected:${injectedId}`,
-        summary: `Injected task ${injectedId} no longer in provider`,
-        applied: false
+        summary: `No change needed for ${cleoTask.id}`,
+        applied: false,
+        linkId: existingLink.id
       });
+    } else {
+      if (ext.status !== "removed") {
+        actions.push({
+          type: "create",
+          cleoTaskId: null,
+          externalId: ext.externalId,
+          summary: `Create new task: ${ext.title}`,
+          applied: false
+        });
+      }
     }
   }
   return actions;
@@ -32649,32 +32726,33 @@ async function reconcile(externalTasks, options, accessor) {
   const acc = accessor ?? await getAccessor(cwd);
   const { tasks: allTasks } = await acc.queryTasks({});
   const taskMap = buildTaskMap(allTasks);
-  const syncState = await readSyncState(providerId, cwd);
-  const injectedIds = new Set(syncState?.injectedTaskIds ?? []);
-  const actions = computeActions(externalTasks, taskMap, injectedIds);
+  const existingLinks = await getLinksByProvider(providerId, cwd);
+  const linkMap = buildLinkMap(existingLinks);
+  const actions = computeActions(externalTasks, taskMap, linkMap);
   const summary = {
+    created: 0,
+    updated: 0,
     completed: 0,
     activated: 0,
-    created: 0,
-    removed: 0,
     skipped: 0,
     conflicts: 0,
+    total: actions.length,
     applied: 0
   };
   for (const action of actions) {
     switch (action.type) {
+      case "create":
+        summary.created++;
+        break;
+      case "update":
+        summary.updated++;
+        break;
       case "complete":
         summary.completed++;
         break;
       case "activate":
         summary.activated++;
         break;
-      case "create":
-        summary.created++;
-        break;
-      case "remove":
-        summary.removed++;
-        break;
       case "skip":
         summary.skipped++;
         break;
@@ -32683,9 +32761,14 @@ async function reconcile(externalTasks, options, accessor) {
         break;
     }
   }
+  let linksAffected = 0;
   if (!dryRun) {
     for (const action of actions) {
       if (action.type === "skip" || action.type === "conflict") {
+        if (action.linkId) {
+          const ext = externalTasks.find((e) => e.externalId === action.externalId);
+          await touchLink(action.linkId, { externalTitle: ext?.title }, cwd);
+        }
         continue;
       }
       try {
@@ -32694,11 +32777,15 @@ async function reconcile(externalTasks, options, accessor) {
             await completeTask(
               {
                 taskId: action.cleoTaskId,
-                notes: `Completed via ${providerId} task sync`
+                notes: `Completed via ${providerId} sync`
               },
               cwd,
               acc
             );
+            if (action.linkId) {
+              await touchLink(action.linkId, void 0, cwd);
+              linksAffected++;
+            }
             action.applied = true;
             summary.applied++;
             break;
@@ -32708,33 +32795,73 @@ async function reconcile(externalTasks, options, accessor) {
               {
                 taskId: action.cleoTaskId,
                 status: "active",
-                notes: `Activated during ${providerId} task sync`
+                notes: `Activated via ${providerId} sync`
               },
               cwd,
               acc
             );
+            if (action.linkId) {
+              await touchLink(action.linkId, void 0, cwd);
+              linksAffected++;
+            }
             action.applied = true;
             summary.applied++;
             break;
           }
-          case "create": {
+          case "update": {
             const ext = externalTasks.find((e) => e.externalId === action.externalId);
             if (!ext) break;
-            await addTask(
+            await updateTask(
               {
+                taskId: action.cleoTaskId,
                 title: ext.title,
-                description: ext.description ?? `Created during ${providerId} task sync`,
-                labels: [...defaultLabels ?? [], ...ext.labels ?? [], "sync-created"],
-                ...defaultPhase ? { phase: defaultPhase, addPhase: true } : {}
+                notes: `Updated via ${providerId} sync`
               },
               cwd,
               acc
             );
+            if (action.linkId) {
+              await touchLink(action.linkId, { externalTitle: ext.title }, cwd);
+              linksAffected++;
+            }
             action.applied = true;
             summary.applied++;
             break;
           }
-          case "remove": {
+          case "create": {
+            const ext = externalTasks.find((e) => e.externalId === action.externalId);
+            if (!ext) break;
+            const result = await addTask(
+              {
+                title: ext.title,
+                description: ext.description ?? `Synced from ${providerId}`,
+                priority: ext.priority,
+                type: ext.type,
+                labels: [...defaultLabels ?? [], ...ext.labels ?? [], `sync:${providerId}`],
+                ...defaultPhase ? { phase: defaultPhase, addPhase: true } : {}
+              },
+              cwd,
+              acc
+            );
+            const newTaskId = result.task.id;
+            if (newTaskId) {
+              const link = await createLink(
+                {
+                  taskId: newTaskId,
+                  providerId,
+                  externalId: ext.externalId,
+                  externalUrl: ext.url,
+                  externalTitle: ext.title,
+                  linkType: "created",
+                  syncDirection: "inbound",
+                  metadata: ext.providerMeta
+                },
+                cwd
+              );
+              action.cleoTaskId = newTaskId;
+              action.linkId = link.id;
+              linksAffected++;
+            }
             action.applied = true;
             summary.applied++;
             break;
@@ -32744,14 +32871,13 @@ async function reconcile(externalTasks, options, accessor) {
         action.error = err instanceof Error ? err.message : String(err);
       }
     }
-    await clearSyncState(providerId, cwd);
   }
   return {
     dryRun,
     providerId,
     actions,
     summary,
-    sessionCleared: !dryRun
+    linksAffected
   };
 }
 
@@ -33358,15 +33484,15 @@ function describeChannel(channel) {
 
 // packages/core/src/release/ci.ts
 import { existsSync as existsSync59, mkdirSync as mkdirSync12, readFileSync as readFileSync42, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname13, join as join64 } from "node:path";
+import { dirname as dirname13, join as join63 } from "node:path";
 
 // packages/core/src/release/release-config.ts
 init_paths();
 import { existsSync as existsSync58, readFileSync as readFileSync41 } from "node:fs";
-import { join as join63 } from "node:path";
+import { join as join62 } from "node:path";
 function readConfigValueSync(path2, defaultValue, cwd) {
   try {
-    const configPath = join63(getCleoDir(cwd), "config.json");
+    const configPath = join62(getCleoDir(cwd), "config.json");
     if (!existsSync58(configPath)) return defaultValue;
     const config = JSON.parse(readFileSync41(configPath, "utf-8"));
     const keys = path2.split(".");
@@ -33530,9 +33656,9 @@ function getPlatformPath(platform3) {
 }
 function detectCIPlatform(projectDir) {
   const dir = projectDir ?? process.cwd();
-  if (existsSync59(join64(dir, ".github"))) return "github-actions";
-  if (existsSync59(join64(dir, ".gitlab-ci.yml"))) return "gitlab-ci";
-  if (existsSync59(join64(dir, ".circleci"))) return "circleci";
+  if (existsSync59(join63(dir, ".github"))) return "github-actions";
+  if (existsSync59(join63(dir, ".gitlab-ci.yml"))) return "gitlab-ci";
+  if (existsSync59(join63(dir, ".circleci"))) return "circleci";
   return null;
 }
 function generateGitHubActions(config) {
@@ -33634,7 +33760,7 @@ function generateCIConfig(platform3, cwd) {
 }
 function writeCIConfig(platform3, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
-  const outputPath = join64(projectDir, getPlatformPath(platform3));
+  const outputPath = join63(projectDir, getPlatformPath(platform3));
   const content = generateCIConfig(platform3, projectDir);
   if (options.dryRun) {
     return { action: "would_write", path: outputPath, content };
@@ -33645,7 +33771,7 @@ function writeCIConfig(platform3, options = {}) {
 }
 function validateCIConfig(platform3, projectDir) {
   const dir = projectDir ?? process.cwd();
-  const configPath = join64(dir, getPlatformPath(platform3));
+  const configPath = join63(dir, getPlatformPath(platform3));
   if (!existsSync59(configPath)) {
     return { valid: false, exists: false, errors: ["Config file not found"] };
   }
@@ -33903,8 +34029,8 @@ function checkDoubleListing(releaseTaskIds, existingReleases) {
 import { execFileSync as execFileSync7 } from "node:child_process";
 import { existsSync as existsSync61, renameSync as renameSync5 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
-import { join as join66 } from "node:path";
-import { and as and4, count, desc as desc3, eq as eq6 } from "drizzle-orm";
+import { join as join65 } from "node:path";
+import { and as and5, count, desc as desc3, eq as eq7 } from "drizzle-orm";
 init_paths();
 init_tasks_schema();
 
@@ -33913,10 +34039,10 @@ init_src();
 init_errors3();
 init_paths();
 import { existsSync as existsSync60, readFileSync as readFileSync43, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join65 } from "node:path";
+import { join as join64 } from "node:path";
 function readConfigValueSync2(path2, defaultValue, cwd) {
   try {
-    const configPath = join65(getCleoDir(cwd), "config.json");
+    const configPath = join64(getCleoDir(cwd), "config.json");
     if (!existsSync60(configPath)) return defaultValue;
     const config = JSON.parse(readFileSync43(configPath, "utf-8"));
     const keys = path2.split(".");
@@ -34013,7 +34139,7 @@ function isVersionBumpConfigured(cwd) {
   return getVersionBumpConfig(cwd).length > 0;
 }
 function bumpFile(target, newVersion, projectRoot) {
-  const filePath = join65(projectRoot, target.file);
+  const filePath = join64(projectRoot, target.file);
   if (!existsSync60(filePath)) {
     return {
       file: target.file,
@@ -34152,6 +34278,36 @@ function effectivePageLimit(limit, offset) {
 function isValidVersion(version) {
   return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
 }
+function validateCalVerWindow(version, now = /* @__PURE__ */ new Date()) {
+  const normalized = version.startsWith("v") ? version.slice(1) : version;
+  const base = normalized.split("-")[0] ?? normalized;
+  const parts = base.split(".");
+  if (parts.length !== 3) {
+    return { valid: false, message: `Invalid CalVer format: ${version}` };
+  }
+  const tagYear = Number.parseInt(parts[0] ?? "", 10);
+  const tagMonth = Number.parseInt(parts[1] ?? "", 10);
+  if (!Number.isInteger(tagYear) || !Number.isInteger(tagMonth)) {
+    return { valid: false, message: `Invalid CalVer date components: ${version}` };
+  }
+  const currentYear = now.getUTCFullYear();
+  const currentMonth = now.getUTCMonth() + 1;
+  const nextMonth = currentMonth === 12 ? 1 : currentMonth + 1;
+  const nextYear = currentMonth === 12 ? currentYear + 1 : currentYear;
+  const isPreRelease = normalized.includes("-");
+  if (isPreRelease) {
+    const valid2 = (tagYear === currentYear || tagYear === nextYear) && (tagMonth === currentMonth || tagMonth === nextMonth);
+    return {
+      valid: valid2,
+      message: valid2 ? `CalVer OK (pre-release): ${version}` : `Pre-release ${version} outside allowed CalVer range ${currentYear}.${currentMonth} or ${nextYear}.${nextMonth}`
+    };
+  }
+  const valid = tagYear === currentYear && tagMonth === currentMonth;
+  return {
+    valid,
+    message: valid ? `CalVer OK (stable): ${version}` : `${version} does not match current CalVer ${currentYear}.${currentMonth}`
+  };
+}
 function normalizeVersion(version) {
   return version.startsWith("v") ? version : `v${version}`;
 }
@@ -34174,7 +34330,7 @@ function rowToManifest(row) {
 }
 async function findLatestPushedVersion(cwd) {
   const db = await getDb2(cwd);
-  const rows = await db.select({ version: releaseManifests.version }).from(releaseManifests).where(eq6(releaseManifests.status, "pushed")).orderBy(desc3(releaseManifests.pushedAt)).limit(1).all();
+  const rows = await db.select({ version: releaseManifests.version }).from(releaseManifests).where(eq7(releaseManifests.status, "pushed")).orderBy(desc3(releaseManifests.pushedAt)).limit(1).all();
   return rows[0]?.version;
 }
 async function prepareRelease(version, tasks2, notes, loadTasksFn, cwd) {
@@ -34186,7 +34342,7 @@ async function prepareRelease(version, tasks2, notes, loadTasksFn, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const existing = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const existing = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (existing.length > 0) {
     throw new Error(`Release ${normalizedVersion} already exists (status: ${existing[0].status})`);
   }
@@ -34226,7 +34382,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -34363,8 +34519,8 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
     sections.push("");
   }
   const changelog = sections.join("\n");
-  await db.update(releaseManifests).set({ changelog }).where(eq6(releaseManifests.version, normalizedVersion)).run();
-  const changelogPath = join66(cwd ?? process.cwd(), "CHANGELOG.md");
+  await db.update(releaseManifests).set({ changelog }).where(eq7(releaseManifests.version, normalizedVersion)).run();
+  const changelogPath = join65(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile12(changelogPath, "utf8");
@@ -34401,8 +34557,8 @@ async function listManifestReleases(optionsOrCwd, cwd) {
   const db = await getDb2(effectiveCwd);
   const totalRow = await db.select({ count: count() }).from(releaseManifests).get();
   const total = totalRow?.count ?? 0;
-  const conditions = options.status ? [eq6(releaseManifests.status, options.status)] : [];
-  const whereClause = conditions.length > 0 ? and4(...conditions) : void 0;
+  const conditions = options.status ? [eq7(releaseManifests.status, options.status)] : [];
+  const whereClause = conditions.length > 0 ? and5(...conditions) : void 0;
   const filteredRow = await db.select({ count: count() }).from(releaseManifests).where(whereClause).get();
   const filtered = filteredRow?.count ?? 0;
   let query = db.select().from(releaseManifests).where(whereClause).orderBy(desc3(releaseManifests.createdAt));
@@ -34433,7 +34589,7 @@ async function showManifestRelease(version, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -34445,7 +34601,7 @@ async function commitRelease(version, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -34455,7 +34611,7 @@ async function commitRelease(version, cwd) {
     );
   }
   const committedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(releaseManifests).set({ status: "committed", committedAt }).where(eq6(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "committed", committedAt }).where(eq7(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "committed", committedAt };
 }
 async function tagRelease(version, cwd) {
@@ -34464,12 +34620,12 @@ async function tagRelease(version, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   const taggedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq6(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq7(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "tagged", taggedAt };
 }
 async function runReleaseGates(version, loadTasksFn, cwd, opts) {
@@ -34478,7 +34634,7 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -34490,6 +34646,15 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
     status: isValidVersion(normalizedVersion) ? "passed" : "failed",
     message: isValidVersion(normalizedVersion) ? "Version format is valid" : "Invalid version format"
   });
+  const releaseConfig = loadReleaseConfig(cwd);
+  if (releaseConfig.versioningScheme === "calver") {
+    const calver = validateCalVerWindow(normalizedVersion);
+    gates.push({
+      name: "calver_window",
+      status: calver.valid ? "passed" : "failed",
+      message: calver.message
+    });
+  }
   gates.push({
     name: "has_tasks",
     status: releaseTasks.length > 0 ? "passed" : "failed",
@@ -34511,10 +34676,10 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
     message: incompleteTasks.length === 0 ? "All tasks completed" : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(", ")}`
   });
   const projectRoot = cwd ?? getProjectRoot();
-  const monorepoDist = join66(projectRoot, "packages", "cleo", "dist", "cli", "index.js");
-  const rootDist = join66(projectRoot, "dist", "cli", "index.js");
+  const monorepoDist = join65(projectRoot, "packages", "cleo", "dist", "cli", "index.js");
+  const rootDist = join65(projectRoot, "dist", "cli", "index.js");
   const distExists = existsSync61(monorepoDist) || existsSync61(rootDist);
-  const isNodeProject = existsSync61(join66(projectRoot, "package.json"));
+  const isNodeProject = existsSync61(join65(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
@@ -34560,7 +34725,6 @@ async function runReleaseGates(version, loadTasksFn, cwd, opts) {
     }).trim();
   } catch {
   }
-  const releaseConfig = loadReleaseConfig(cwd);
   const gitFlowCfg = getGitFlowConfig(releaseConfig);
   const channelCfg = getChannelConfig(releaseConfig);
   const expectedBranch = isPreRelease ? gitFlowCfg.branches.develop : gitFlowCfg.branches.main;
@@ -34618,7 +34782,7 @@ async function cancelRelease(version, projectRoot) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(projectRoot);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     return {
       success: false,
@@ -34635,7 +34799,7 @@ async function cancelRelease(version, projectRoot) {
       version: normalizedVersion
     };
   }
-  await db.delete(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).run();
+  await db.delete(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).run();
   return {
     success: true,
     message: `Release ${normalizedVersion} cancelled and removed`,
@@ -34648,12 +34812,12 @@ async function rollbackRelease(version, reason, cwd) {
   }
   const normalizedVersion = normalizeVersion(version);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq6(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq7(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   const previousStatus = rows[0].status;
-  await db.update(releaseManifests).set({ status: "rolled_back" }).where(eq6(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "rolled_back" }).where(eq7(releaseManifests.version, normalizedVersion)).run();
   return {
     version: normalizedVersion,
     previousStatus,
@@ -34662,7 +34826,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join66(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join65(getCleoDirAbsolute(cwd), "config.json");
   let config;
   try {
     const raw = await readFile12(configPath, "utf-8");
@@ -34763,10 +34927,10 @@ async function markReleasePushed(version, pushedAt, cwd, provenance) {
     pushedAt,
     ...provenance?.commitSha != null ? { commitSha: provenance.commitSha } : {},
     ...provenance?.gitTag != null ? { gitTag: provenance.gitTag } : {}
-  }).where(eq6(releaseManifests.version, normalizedVersion)).run();
+  }).where(eq7(releaseManifests.version, normalizedVersion)).run();
 }
 async function migrateReleasesJsonToSqlite(projectRoot) {
-  const releasesPath = join66(getCleoDirAbsolute(projectRoot), "releases.json");
+  const releasesPath = join65(getCleoDirAbsolute(projectRoot), "releases.json");
   if (!existsSync61(releasesPath)) {
     return { migrated: 0 };
   }
@@ -34783,7 +34947,7 @@ async function migrateReleasesJsonToSqlite(projectRoot) {
   const db = await getDb2(projectRoot);
   let migrated = 0;
   for (const r of raw.releases) {
-    const existing = await db.select({ id: releaseManifests.id }).from(releaseManifests).where(eq6(releaseManifests.version, r.version)).limit(1).all();
+    const existing = await db.select({ id: releaseManifests.id }).from(releaseManifests).where(eq7(releaseManifests.version, r.version)).limit(1).all();
     if (existing.length > 0) continue;
     const id = `rel-${r.version.replace(/[^a-z0-9]/gi, "-")}`;
     await db.insert(releaseManifests).values({
@@ -35089,11 +35253,11 @@ __export(roadmap_exports, {
 });
 init_data_accessor();
 import { existsSync as existsSync62, readFileSync as readFileSync44 } from "node:fs";
-import { join as join67 } from "node:path";
+import { join as join66 } from "node:path";
 async function getRoadmap(opts, accessor) {
   const acc = accessor ?? await getAccessor(opts.cwd);
   const { tasks: tasks2 } = await acc.queryTasks({});
-  const versionPath = join67(opts.cwd ?? process.cwd(), "VERSION");
+  const versionPath = join66(opts.cwd ?? process.cwd(), "VERSION");
   const currentVersion = existsSync62(versionPath) ? readFileSync44(versionPath, "utf-8").trim() : "unknown";
   const childParentIds = new Set(tasks2.filter((t) => t.parentId).map((t) => t.parentId));
   const epics = tasks2.filter((t) => childParentIds.has(t.id));
@@ -35101,7 +35265,7 @@ async function getRoadmap(opts, accessor) {
   const completed = epics.filter((e) => e.status === "done");
   const releaseHistory = [];
   if (opts.includeHistory) {
-    const changelogPath = join67(opts.cwd ?? process.cwd(), "CHANGELOG.md");
+    const changelogPath = join66(opts.cwd ?? process.cwd(), "CHANGELOG.md");
     if (existsSync62(changelogPath)) {
       const content = readFileSync44(changelogPath, "utf-8");
       const versionRegex = /^##\s+\[?v?(\d+\.\d+\.\d+[^\]]*)\]?\s*[-(]?\s*(\d{4}-\d{2}-\d{2})?/gm;
@@ -35176,6 +35340,10 @@ var CAPABILITY_MATRIX = [
   { domain: "tasks", operation: "relates.add", gateway: "mutate", mode: "native" },
   { domain: "tasks", operation: "start", gateway: "mutate", mode: "native" },
   { domain: "tasks", operation: "stop", gateway: "mutate", mode: "native" },
+  // Sync sub-domain (provider-agnostic task reconciliation)
+  { domain: "tasks", operation: "sync.reconcile", gateway: "mutate", mode: "native" },
+  { domain: "tasks", operation: "sync.links", gateway: "query", mode: "native" },
+  { domain: "tasks", operation: "sync.links.remove", gateway: "mutate", mode: "native" },
   // === Session Domain ===
   // Query operations
   { domain: "session", operation: "status", gateway: "query", mode: "native" },
@@ -35346,10 +35514,6 @@ var CAPABILITY_MATRIX = [
   { domain: "tools", operation: "provider.supports", gateway: "query", mode: "native" },
   { domain: "tools", operation: "provider.hooks", gateway: "query", mode: "native" },
   { domain: "tools", operation: "provider.inject", gateway: "mutate", mode: "native" },
-  // TodoWrite operations
-  { domain: "tools", operation: "todowrite.status", gateway: "query", mode: "native" },
-  { domain: "tools", operation: "todowrite.sync", gateway: "mutate", mode: "native" },
-  { domain: "tools", operation: "todowrite.clear", gateway: "mutate", mode: "native" },
   // === Nexus Domain ===
   // Query operations
   { domain: "nexus", operation: "status", gateway: "query", mode: "native" },
@@ -36051,12 +36215,12 @@ import { catalog as catalog2 } from "@cleocode/caamp";
 // packages/core/src/skills/agents/config.ts
 init_paths();
 import { existsSync as existsSync65, readFileSync as readFileSync46 } from "node:fs";
-import { basename as basename11, join as join70 } from "node:path";
+import { basename as basename11, join as join69 } from "node:path";
 
 // packages/core/src/skills/discovery.ts
 init_paths();
 import { existsSync as existsSync64, readdirSync as readdirSync24, readFileSync as readFileSync45, statSync as statSync17 } from "node:fs";
-import { basename as basename10, join as join69 } from "node:path";
+import { basename as basename10, join as join68 } from "node:path";
 import {
   discoverSkill as caampDiscoverSkill,
   discoverSkills as caampDiscoverSkills,
@@ -36146,12 +36310,12 @@ var SKILL_NAME_MAP = {
 function getSkillSearchPaths(cwd) {
   const projectRoot = getProjectRoot(cwd);
   const cleoHome = getCleoHome();
-  const projectAgentsSkills = join69(getProjectAgentsDir(projectRoot), "skills");
+  const projectAgentsSkills = join68(getProjectAgentsDir(projectRoot), "skills");
   const paths = [
     { scope: "agent-skills", path: getCanonicalSkillsDir(), priority: 1 },
     { scope: "project-custom", path: projectAgentsSkills, priority: 2 }
   ];
-  const mpCacheDir = process.env["CLEO_SKILLS_MP_CACHE"] ?? join69(cleoHome, ".skills-cache");
+  const mpCacheDir = process.env["CLEO_SKILLS_MP_CACHE"] ?? join68(cleoHome, ".skills-cache");
   if (existsSync64(mpCacheDir)) {
     paths.push({ scope: "marketplace", path: mpCacheDir, priority: 4 });
   }
@@ -36162,7 +36326,7 @@ function getSkillsDir(cwd) {
   return getCanonicalSkillsDir();
 }
 function getSharedDir(cwd) {
-  return join69(getSkillsDir(cwd), "_shared");
+  return join68(getSkillsDir(cwd), "_shared");
 }
 function mapSkillName(input) {
   if (SKILL_NAME_MAP[input]) {
@@ -36245,7 +36409,7 @@ function parseFrontmatter3(content) {
   };
 }
 function discoverSkill(skillDir) {
-  const skillMdPath = join69(skillDir, "SKILL.md");
+  const skillMdPath = join68(skillDir, "SKILL.md");
   if (!existsSync64(skillMdPath)) {
     return null;
   }
@@ -36270,7 +36434,7 @@ function discoverSkillsInDir(dir) {
     const entries = readdirSync24(dir);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry.startsWith("_")) continue;
-      const entryPath = join69(dir, entry);
+      const entryPath = join68(dir, entry);
       try {
         if (statSync17(entryPath).isDirectory()) {
           const skill = discoverSkill(entryPath);
@@ -36304,14 +36468,14 @@ function findSkill(name2, cwd) {
   const { canonical } = mapSkillName(name2);
   const searchPaths = getSkillSearchPaths(cwd);
   for (const sp of searchPaths) {
-    const skillDir = join69(sp.path, canonical);
+    const skillDir = join68(sp.path, canonical);
     const skill = discoverSkill(skillDir);
     if (skill) return skill;
   }
   if (canonical.startsWith("ct-")) {
     const legacy = canonical.slice(3);
     for (const sp of searchPaths) {
-      const skillDir = join69(sp.path, legacy);
+      const skillDir = join68(sp.path, legacy);
       const skill = discoverSkill(skillDir);
       if (skill) return skill;
     }
@@ -36350,10 +36514,10 @@ function resolveTemplatePath(name2, cwd) {
 
 // packages/core/src/skills/agents/config.ts
 function getAgentsDir(cwd) {
-  return join70(getProjectRoot(cwd), "agents");
+  return join69(getProjectRoot(cwd), "agents");
 }
 function parseAgentConfig(agentDir) {
-  const agentMdPath = join70(agentDir, "AGENT.md");
+  const agentMdPath = join69(agentDir, "AGENT.md");
   if (!existsSync65(agentMdPath)) {
     return null;
   }
@@ -36369,7 +36533,7 @@ function parseAgentConfig(agentDir) {
 }
 function loadAgentConfig(agentName, cwd) {
   const agentsDir = getAgentsDir(cwd);
-  const agentDir = join70(agentsDir, agentName);
+  const agentDir = join69(agentsDir, agentName);
   return parseAgentConfig(agentDir);
 }
 function getSubagentConfig(cwd) {
@@ -36377,7 +36541,7 @@ function getSubagentConfig(cwd) {
 }
 function agentExists(agentName, cwd) {
   const agentsDir = getAgentsDir(cwd);
-  const agentMdPath = join70(agentsDir, agentName, "AGENT.md");
+  const agentMdPath = join69(agentsDir, agentName, "AGENT.md");
   return existsSync65(agentMdPath);
 }
 function extractBody(content) {
@@ -36400,14 +36564,14 @@ function extractBody(content) {
 // packages/core/src/skills/agents/install.ts
 init_paths();
 import { existsSync as existsSync66, mkdirSync as mkdirSync14, readdirSync as readdirSync25, readlinkSync, symlinkSync, unlinkSync as unlinkSync4 } from "node:fs";
-import { basename as basename12, join as join71 } from "node:path";
+import { basename as basename12, join as join70 } from "node:path";
 function getAgentInstallDir() {
   return getClaudeAgentsDir();
 }
 function installAgent(agentDir) {
   const targetDir = getAgentInstallDir();
   const agentName = basename12(agentDir);
-  const targetPath = join71(targetDir, agentName);
+  const targetPath = join70(targetDir, agentName);
   if (!existsSync66(targetDir)) {
     mkdirSync14(targetDir, { recursive: true });
   }
@@ -36445,8 +36609,8 @@ function installAllAgents(cwd) {
   const entries = readdirSync25(agentsDir);
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const agentDir = join71(agentsDir, entry);
-    const agentMdPath = join71(agentDir, "AGENT.md");
+    const agentDir = join70(agentsDir, entry);
+    const agentMdPath = join70(agentDir, "AGENT.md");
     if (!existsSync66(agentMdPath)) continue;
     const result = installAgent(agentDir);
     results.push({
@@ -36459,7 +36623,7 @@ function installAllAgents(cwd) {
 }
 function uninstallAgent(agentName) {
   const targetDir = getAgentInstallDir();
-  const targetPath = join71(targetDir, agentName);
+  const targetPath = join70(targetDir, agentName);
   if (!existsSync66(targetPath)) {
     return false;
   }
@@ -36474,9 +36638,9 @@ function uninstallAgent(agentName) {
 // packages/core/src/skills/agents/registry.ts
 init_paths();
 import { existsSync as existsSync67, mkdirSync as mkdirSync15, readdirSync as readdirSync26, readFileSync as readFileSync47, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname14, join as join72 } from "node:path";
+import { dirname as dirname14, join as join71 } from "node:path";
 function getRegistryPath2() {
-  return join72(getCleoHome(), "agent-registry.json");
+  return join71(getCleoHome(), "agent-registry.json");
 }
 function readRegistry2() {
   const registryPath = getRegistryPath2();
@@ -36545,7 +36709,7 @@ function syncRegistry(cwd) {
   const entries = readdirSync26(agentsDir);
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const agentDir = join72(agentsDir, entry);
+    const agentDir = join71(agentsDir, entry);
     try {
       const config = parseAgentConfig(agentDir);
       if (config) {
@@ -36559,7 +36723,7 @@ function syncRegistry(cwd) {
     if (existingNames.has(name2)) {
       result.unchanged.push(name2);
     } else {
-      registerAgent(name2, join72(agentsDir, name2), config);
+      registerAgent(name2, join71(agentsDir, name2), config);
       result.added.push(name2);
     }
   }
@@ -36579,7 +36743,7 @@ import { catalog } from "@cleocode/caamp";
 // packages/core/src/skills/injection/token.ts
 init_paths();
 import { existsSync as existsSync68, readFileSync as readFileSync48 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join72 } from "node:path";
 var REQUIRED_TOKENS = ["TASK_ID", "DATE", "TOPIC_SLUG"];
 var TOKEN_PATTERNS = {
   TASK_ID: /^T\d+$/,
@@ -36615,7 +36779,7 @@ var CLEO_DEFAULTS = {
 };
 function loadPlaceholders(cwd) {
   const projectRoot = getProjectRoot(cwd);
-  const path2 = join73(projectRoot, "skills", "_shared", "placeholders.json");
+  const path2 = join72(projectRoot, "skills", "_shared", "placeholders.json");
   if (!existsSync68(path2)) return null;
   try {
     return JSON.parse(readFileSync48(path2, "utf-8"));
@@ -36999,9 +37163,9 @@ init_src();
 init_errors3();
 init_paths();
 import { existsSync as existsSync69, readFileSync as readFileSync49 } from "node:fs";
-import { join as join74 } from "node:path";
+import { join as join73 } from "node:path";
 function getProtocolBasePath(cwd) {
-  return join74(getProjectRoot(cwd), "skills", "_shared", "subagent-protocol-base.md");
+  return join73(getProjectRoot(cwd), "skills", "_shared", "subagent-protocol-base.md");
 }
 function loadProtocolBase(cwd) {
   const path2 = getProtocolBasePath(cwd);
@@ -37295,12 +37459,12 @@ init_src();
 init_errors3();
 init_paths();
 import { appendFileSync as appendFileSync8, existsSync as existsSync71, mkdirSync as mkdirSync16, readFileSync as readFileSync51, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join75 } from "node:path";
+import { join as join74 } from "node:path";
 function ensureOutputs(cwd) {
   const outputDir = getAgentOutputsDir(cwd);
   const absOutputDir = getAgentOutputsAbsolute(cwd);
   const manifestPath = getManifestPath(cwd);
-  const archiveDir = join75(absOutputDir, "archive");
+  const archiveDir = join74(absOutputDir, "archive");
   const created = [];
   if (!existsSync71(absOutputDir)) {
     mkdirSync16(absOutputDir, { recursive: true });
@@ -37429,13 +37593,13 @@ function rotateManifest(maxEntries = 100, cwd) {
   if (entries.length <= maxEntries) return 0;
   const manifestPath = getManifestPath(cwd);
   const absOutputDir = getAgentOutputsAbsolute(cwd);
-  const archiveDir = join75(absOutputDir, "archive");
+  const archiveDir = join74(absOutputDir, "archive");
   const toKeep = entries.slice(-maxEntries);
   const toArchive = entries.slice(0, entries.length - maxEntries);
   if (!existsSync71(archiveDir)) {
     mkdirSync16(archiveDir, { recursive: true });
   }
-  const archivePath = join75(archiveDir, `MANIFEST-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.jsonl`);
+  const archivePath = join74(archiveDir, `MANIFEST-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.jsonl`);
   const archiveContent = toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n";
   appendFileSync8(archivePath, archiveContent, "utf-8");
   const keepContent = toKeep.map((e) => JSON.stringify(e)).join("\n") + "\n";
@@ -37498,13 +37662,13 @@ function validateEntry(entry) {
 // packages/core/src/skills/manifests/resolver.ts
 init_paths();
 import { existsSync as existsSync72, mkdirSync as mkdirSync17, readFileSync as readFileSync52, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join76 } from "node:path";
+import { join as join75 } from "node:path";
 var DEFAULT_CACHE_TTL = 300;
 function getCacheDir() {
-  return process.env["CLEO_MANIFEST_CACHE_DIR"] ?? join76(getCleoHome(), "cache");
+  return process.env["CLEO_MANIFEST_CACHE_DIR"] ?? join75(getCleoHome(), "cache");
 }
 function getCachedManifestPath() {
-  return join76(getCacheDir(), "skills-manifest.json");
+  return join75(getCacheDir(), "skills-manifest.json");
 }
 function isCacheFresh(cachePath) {
   const path2 = cachePath ?? getCachedManifestPath();
@@ -37578,11 +37742,11 @@ function regenerateCache(cwd) {
 // packages/core/src/skills/marketplace.ts
 init_paths();
 import { existsSync as existsSync73, readFileSync as readFileSync53 } from "node:fs";
-import { join as join77 } from "node:path";
+import { join as join76 } from "node:path";
 import { searchSkills as caampSearchSkills, MarketplaceClient } from "@cleocode/caamp";
 function loadConfig2(cwd) {
   const projectRoot = getProjectRoot(cwd);
-  const configFile = join77(projectRoot, ".cleo", "skillsmp.json");
+  const configFile = join76(projectRoot, ".cleo", "skillsmp.json");
   if (!existsSync73(configFile)) return null;
   try {
     const data = JSON.parse(readFileSync53(configFile, "utf-8"));
@@ -37770,7 +37934,7 @@ function spawnBatch(taskIds, templateName, cwd, tier) {
 // packages/core/src/skills/orchestrator/startup.ts
 init_paths();
 import { existsSync as existsSync75, readFileSync as readFileSync55 } from "node:fs";
-import { join as join78 } from "node:path";
+import { join as join77 } from "node:path";
 var DEFAULT_THRESHOLDS = { warning: 70, critical: 80 };
 function getThresholds(config) {
   const orc = config?.orchestrator?.contextThresholds;
@@ -37792,13 +37956,13 @@ function getContextState(sessionId, cwd) {
   };
   let stateFile = "";
   if (sessionId) {
-    stateFile = join78(cleoDirAbs, "sessions", sessionId, ".context-state.json");
+    stateFile = join77(cleoDirAbs, "sessions", sessionId, ".context-state.json");
     if (!existsSync75(stateFile)) {
-      stateFile = join78(cleoDirAbs, `.context-state-${sessionId}.json`);
+      stateFile = join77(cleoDirAbs, `.context-state-${sessionId}.json`);
     }
   }
   if (!stateFile || !existsSync75(stateFile)) {
-    stateFile = join78(cleoDirAbs, ".context-state.json");
+    stateFile = join77(cleoDirAbs, ".context-state.json");
   }
   if (!existsSync75(stateFile)) {
     return defaultState;
@@ -37827,7 +37991,7 @@ function getContextState(sessionId, cwd) {
 async function sessionInit(_epicId, cwd) {
   const sessionsPath = getSessionsPath(cwd);
   const cleoDirAbs = getCleoDirAbsolute(cwd);
-  const focusPath = join78(cleoDirAbs, "focus.json");
+  const focusPath = join77(cleoDirAbs, "focus.json");
   let activeSessions = 0;
   let activeSessionId = null;
   let activeScope = null;
@@ -38020,13 +38184,13 @@ async function generateHitlSummary(epicId, stopReason = "context-limit", cwd) {
   const taskPath = getTaskPath(cwd);
   const cleoDirAbs = getCleoDirAbsolute(cwd);
   let sessionId = null;
-  const currentSessionFile = join78(cleoDirAbs, ".current-session");
+  const currentSessionFile = join77(cleoDirAbs, ".current-session");
   if (existsSync75(currentSessionFile)) {
     sessionId = readFileSync55(currentSessionFile, "utf-8").trim() || null;
   }
   let focusedTask = null;
   let progressNote = null;
-  const focusPath = join78(cleoDirAbs, "focus.json");
+  const focusPath = join77(cleoDirAbs, "focus.json");
   if (existsSync75(focusPath)) {
     try {
       const focus = JSON.parse(readFileSync55(focusPath, "utf-8"));
@@ -38109,7 +38273,7 @@ function priorityRank(priority) {
 init_src();
 init_paths();
 import { existsSync as existsSync76, readFileSync as readFileSync56 } from "node:fs";
-import { join as join79 } from "node:path";
+import { join as join78 } from "node:path";
 var KEY_FINDINGS_MIN = 3;
 var KEY_FINDINGS_MAX = 7;
 var MANIFEST_REQUIRED_FIELDS = [
@@ -38190,7 +38354,7 @@ function validateSubagentOutput(researchId, cwd) {
   }
   if (entry.file) {
     const absOutputDir = getAgentOutputsAbsolute(cwd);
-    const filePath = join79(absOutputDir, entry.file);
+    const filePath = join78(absOutputDir, entry.file);
     if (!existsSync76(filePath)) {
       issues.push(`FILE_NOT_FOUND: Expected file at ${filePath}`);
     }
@@ -38233,7 +38397,7 @@ function validateManifestIntegrity(cwd) {
     seenIds.add(entry.id);
     if (entry.file) {
       const absOutputDir = getAgentOutputsAbsolute(cwd);
-      const filePath = join79(absOutputDir, entry.file);
+      const filePath = join78(absOutputDir, entry.file);
       if (!existsSync76(filePath)) {
         issues.push(`LINE_${lineNum}_FILE_MISSING: ${entry.file} does not exist`);
       }
@@ -38349,13 +38513,13 @@ function validateOrchestratorCompliance(epicId, cwd) {
 // packages/core/src/skills/skill-paths.ts
 init_paths();
 import { existsSync as existsSync77, lstatSync, readlinkSync as readlinkSync2, realpathSync as realpathSync2 } from "node:fs";
-import { delimiter, join as join80, resolve as resolve9 } from "node:path";
+import { delimiter, join as join79, resolve as resolve9 } from "node:path";
 function getCaampCanonical() {
-  return join80(getAgentsHome(), "skills");
+  return join79(getAgentsHome(), "skills");
 }
 function getProjectEmbedded(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  return join80(root, "skills");
+  return join79(root, "skills");
 }
 function getProjectRoot3(cwd) {
   return cwd ?? process.cwd();
@@ -38405,8 +38569,8 @@ function getSkillSearchPaths2(projectRoot) {
 function resolveSkillPath(skillName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join80(searchPath, skillName);
-    if (existsSync77(join80(candidate, "SKILL.md"))) {
+    const candidate = join79(searchPath, skillName);
+    if (existsSync77(join79(candidate, "SKILL.md"))) {
       return safeRealpath(candidate);
     }
   }
@@ -38415,13 +38579,13 @@ function resolveSkillPath(skillName, projectRoot) {
 function resolveProtocolPath(protocolName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join80(searchPath, "_ct-skills-protocols", `${protocolName}.md`);
+    const candidate = join79(searchPath, "_ct-skills-protocols", `${protocolName}.md`);
     if (existsSync77(candidate)) {
       return safeRealpath(candidate);
     }
   }
   const root = getProjectRoot3(projectRoot);
-  const legacy = join80(root, "src", "protocols", `${protocolName}.md`);
+  const legacy = join79(root, "src", "protocols", `${protocolName}.md`);
   if (existsSync77(legacy)) {
     return safeRealpath(legacy);
   }
@@ -38430,11 +38594,11 @@ function resolveProtocolPath(protocolName, projectRoot) {
 function resolveSharedPath(resourceName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join80(searchPath, "_ct-skills-shared", `${resourceName}.md`);
+    const candidate = join79(searchPath, "_ct-skills-shared", `${resourceName}.md`);
     if (existsSync77(candidate)) {
       return safeRealpath(candidate);
     }
-    const legacy = join80(searchPath, "_shared", `${resourceName}.md`);
+    const legacy = join79(searchPath, "_shared", `${resourceName}.md`);
     if (existsSync77(legacy)) {
       return safeRealpath(legacy);
     }
@@ -38460,7 +38624,7 @@ function getSkillSourceType(skillDir, projectRoot) {
     }
   } catch {
   }
-  if (normalizedDir.startsWith(resolve9(embeddedDir)) || normalizedDir.startsWith(join80(root, "skills"))) {
+  if (normalizedDir.startsWith(resolve9(embeddedDir)) || normalizedDir.startsWith(join79(root, "skills"))) {
     return "embedded";
   }
   if (normalizedDir.startsWith(caampDir)) {
@@ -38492,7 +38656,7 @@ function formatDateYMD(date2) {
 
 // packages/core/src/skills/validation.ts
 import { existsSync as existsSync78, readFileSync as readFileSync57 } from "node:fs";
-import { basename as basename13, join as join81 } from "node:path";
+import { basename as basename13, join as join80 } from "node:path";
 var VALID_PROTOCOLS = /* @__PURE__ */ new Set([
   "research",
   "consensus",
@@ -38515,7 +38679,7 @@ function validateSkill(skillDir) {
     });
     return buildResult(dirName, skillDir, issues);
   }
-  const skillMdPath = join81(skillDir, "SKILL.md");
+  const skillMdPath = join80(skillDir, "SKILL.md");
   if (!existsSync78(skillMdPath)) {
     issues.push({
       severity: "error",
@@ -38537,7 +38701,7 @@ function validateSkill(skillDir) {
   }
   const optionalFiles = ["README.md", "references"];
   for (const file of optionalFiles) {
-    const filePath = join81(skillDir, file);
+    const filePath = join80(skillDir, file);
     if (!existsSync78(filePath)) {
       issues.push({
         severity: "info",
@@ -38686,8 +38850,8 @@ init_paths();
 init_data_accessor();
 import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync79 } from "node:fs";
-import { mkdir as mkdir14, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname15, join as join82 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname15, join as join81 } from "node:path";
 var SNAPSHOT_FORMAT_VERSION = "1.0.0";
 function toSnapshotTask(task) {
   return {
@@ -38746,7 +38910,7 @@ async function exportSnapshot(cwd) {
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname15(outputPath);
   if (!existsSync79(dir)) {
-    await mkdir14(dir, { recursive: true });
+    await mkdir13(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
 }
@@ -38763,7 +38927,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join82(cleoDir, "snapshots", `snapshot-${timestamp2}.json`);
+  return join81(cleoDir, "snapshots", `snapshot-${timestamp2}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -38991,8 +39155,8 @@ async function initializeSpawnAdapters(manifests) {
     if (!manifest.capabilities?.supportsSpawn) continue;
     if (spawnRegistry.hasAdapterForProvider(manifest.provider)) continue;
     try {
-      const { join: join105 } = await import("node:path");
-      const modulePath = join105(manifest.packagePath, manifest.entryPoint);
+      const { join: join103 } = await import("node:path");
+      const modulePath = join103(manifest.packagePath, manifest.entryPoint);
       const adapterModule = await import(modulePath);
       let SpawnProviderClass;
       for (const [exportName, exportValue] of Object.entries(adapterModule)) {
@@ -39943,13 +40107,13 @@ async function getArchiveStats(opts, accessor) {
 // packages/core/src/system/audit.ts
 init_data_accessor();
 import { existsSync as existsSync80, readFileSync as readFileSync58 } from "node:fs";
-import { join as join83 } from "node:path";
+import { join as join82 } from "node:path";
 async function auditData(projectRoot, opts) {
-  const cleoDir = join83(projectRoot, ".cleo");
+  const cleoDir = join82(projectRoot, ".cleo");
   const scope = opts?.scope ?? "all";
   const issues = [];
   if (scope === "all" || scope === "tasks") {
-    const tasksDbPath = join83(cleoDir, "tasks.db");
+    const tasksDbPath = join82(cleoDir, "tasks.db");
     if (existsSync80(tasksDbPath)) {
       try {
         const accessor = await getAccessor(projectRoot);
@@ -40012,7 +40176,7 @@ async function auditData(projectRoot, opts) {
     }
   }
   if (scope === "all" || scope === "sessions") {
-    const sessPath = join83(cleoDir, "sessions.json");
+    const sessPath = join82(cleoDir, "sessions.json");
     if (existsSync80(sessPath)) {
       try {
         const data = JSON.parse(readFileSync58(sessPath, "utf-8"));
@@ -40047,7 +40211,7 @@ async function auditData(projectRoot, opts) {
     }
   }
   if (scope === "all") {
-    const seqPath = join83(cleoDir, ".sequence.json");
+    const seqPath = join82(cleoDir, ".sequence.json");
     if (existsSync80(seqPath)) {
       try {
         const seq = JSON.parse(readFileSync58(seqPath, "utf-8"));
@@ -40082,22 +40246,22 @@ async function auditData(projectRoot, opts) {
 init_src();
 init_errors3();
 import { existsSync as existsSync81, mkdirSync as mkdirSync18, readFileSync as readFileSync59, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join84 } from "node:path";
+import { join as join83 } from "node:path";
 function createBackup2(projectRoot, opts) {
-  const cleoDir = join84(projectRoot, ".cleo");
+  const cleoDir = join83(projectRoot, ".cleo");
   const btype = opts?.type || "snapshot";
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   const backupId = `${btype}-${timestamp2.replace(/[:.]/g, "-")}`;
-  const backupDir = join84(cleoDir, "backups", btype);
+  const backupDir = join83(cleoDir, "backups", btype);
   if (!existsSync81(backupDir)) {
     mkdirSync18(backupDir, { recursive: true });
   }
   const filesToBackup = ["tasks.db", "brain.db", "config.json", "project-info.json"];
   const backedUp = [];
   for (const file of filesToBackup) {
-    const src = join84(cleoDir, file);
+    const src = join83(cleoDir, file);
     if (existsSync81(src)) {
-      const dest = join84(backupDir, `${file}.${backupId}`);
+      const dest = join83(backupDir, `${file}.${backupId}`);
       try {
         const content = readFileSync59(src);
         writeFileSync11(dest, content);
@@ -40106,7 +40270,7 @@ function createBackup2(projectRoot, opts) {
       }
     }
   }
-  const metaPath = join84(backupDir, `${backupId}.meta.json`);
+  const metaPath = join83(backupDir, `${backupId}.meta.json`);
   try {
     writeFileSync11(
       metaPath,
@@ -40131,15 +40295,15 @@ function restoreBackup(projectRoot, params) {
   if (!params.backupId) {
     throw new CleoError(2 /* INVALID_INPUT */, "backupId is required");
   }
-  const cleoDir = join84(projectRoot, ".cleo");
+  const cleoDir = join83(projectRoot, ".cleo");
   const backupTypes = ["snapshot", "safety", "migration"];
   let metaPath = null;
   let backupDir = null;
   for (const btype of backupTypes) {
-    const candidateMeta = join84(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
+    const candidateMeta = join83(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
     if (existsSync81(candidateMeta)) {
       metaPath = candidateMeta;
-      backupDir = join84(cleoDir, "backups", btype);
+      backupDir = join83(cleoDir, "backups", btype);
       break;
     }
   }
@@ -40154,11 +40318,11 @@ function restoreBackup(projectRoot, params) {
   }
   const restored = [];
   for (const file of meta.files ?? []) {
-    const backupFile = join84(backupDir, `${file}.${params.backupId}`);
+    const backupFile = join83(backupDir, `${file}.${params.backupId}`);
     if (existsSync81(backupFile)) {
       try {
         const content = readFileSync59(backupFile);
-        writeFileSync11(join84(cleoDir, file), content);
+        writeFileSync11(join83(cleoDir, file), content);
         restored.push(file);
       } catch {
       }
@@ -40175,12 +40339,12 @@ function restoreBackup(projectRoot, params) {
 // packages/core/src/system/cleanup.ts
 init_src();
 import { existsSync as existsSync82, readdirSync as readdirSync27, readFileSync as readFileSync60, unlinkSync as unlinkSync5, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join86 } from "node:path";
+import { join as join85 } from "node:path";
 
 // packages/core/src/audit-prune.ts
 init_logger();
 import { createWriteStream, mkdirSync as mkdirSync19 } from "node:fs";
-import { join as join85 } from "node:path";
+import { join as join84 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
@@ -40192,7 +40356,7 @@ async function pruneAuditLog(cleoDir, config) {
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     const cutoff = new Date(Date.now() - config.auditRetentionDays * 864e5).toISOString();
-    const projectRoot = join85(cleoDir, "..");
+    const projectRoot = join84(cleoDir, "..");
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
     const { lt: lt2 } = await import("drizzle-orm");
@@ -40206,10 +40370,10 @@ async function pruneAuditLog(cleoDir, config) {
     let rowsArchived = 0;
     if (config.archiveBeforePrune) {
       try {
-        const archiveDir = join85(cleoDir, "backups", "logs");
+        const archiveDir = join84(cleoDir, "backups", "logs");
         mkdirSync19(archiveDir, { recursive: true });
         const dateStamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-        archivePath = join85(archiveDir, `audit-${dateStamp}.jsonl.gz`);
+        archivePath = join84(archiveDir, `audit-${dateStamp}.jsonl.gz`);
         const lines = oldRows.map((row) => JSON.stringify(row));
         const jsonlContent = lines.join("\n") + "\n";
         const gzip = createGzip();
@@ -40252,7 +40416,7 @@ async function cleanupSystem(projectRoot, params) {
       "target is required (sessions|backups|logs|archive)"
     );
   }
-  const cleoDir = join86(projectRoot, ".cleo");
+  const cleoDir = join85(projectRoot, ".cleo");
   const dryRun = params.dryRun ?? false;
   const items = [];
   let prunedRows;
@@ -40260,7 +40424,7 @@ async function cleanupSystem(projectRoot, params) {
   let archivePath;
   switch (params.target) {
     case "sessions": {
-      const sessPath = join86(cleoDir, "sessions.json");
+      const sessPath = join85(cleoDir, "sessions.json");
       if (existsSync82(sessPath)) {
         try {
           const data = JSON.parse(readFileSync60(sessPath, "utf-8"));
@@ -40289,14 +40453,14 @@ async function cleanupSystem(projectRoot, params) {
       break;
     }
     case "backups": {
-      const backupBaseDir = join86(cleoDir, "backups");
+      const backupBaseDir = join85(cleoDir, "backups");
       if (existsSync82(backupBaseDir)) {
         for (const typeDir of readdirSync27(backupBaseDir)) {
-          const fullDir = join86(backupBaseDir, typeDir);
+          const fullDir = join85(backupBaseDir, typeDir);
           try {
             for (const file of readdirSync27(fullDir)) {
               if (file.endsWith(".meta.json")) {
-                const metaFilePath = join86(fullDir, file);
+                const metaFilePath = join85(fullDir, file);
                 try {
                   const meta = JSON.parse(readFileSync60(metaFilePath, "utf-8"));
                   if (params.olderThan && meta.timestamp < params.olderThan) {
@@ -40306,7 +40470,7 @@ async function cleanupSystem(projectRoot, params) {
                       for (const bf of readdirSync27(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync5(join86(fullDir, bf));
+                            unlinkSync5(join85(fullDir, bf));
                           } catch {
                           }
                         }
@@ -40338,7 +40502,7 @@ async function cleanupSystem(projectRoot, params) {
             items.push(file);
             if (!dryRun) {
               try {
-                unlinkSync5(join86(cleoDir, file));
+                unlinkSync5(join85(cleoDir, file));
               } catch {
               }
             }
@@ -40368,7 +40532,7 @@ init_paths();
 import { execFile as execFile6, execFileSync as execFileSync10 } from "node:child_process";
 import { existsSync as existsSync86, readFileSync as readFileSync63, statSync as statSync19 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { join as join90 } from "node:path";
+import { join as join89 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 
 // packages/core/src/platform.ts
@@ -40395,25 +40559,25 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename14, dirname as dirname16, join as join88 } from "node:path";
+import { basename as basename14, dirname as dirname16, join as join87 } from "node:path";
 import * as lockfile2 from "proper-lockfile";
 var MAX_BACKUPS = 10;
 function rotateBackup(filePath) {
   const dir = dirname16(filePath);
   const name2 = basename14(filePath);
-  const backupDir = join88(dir, ".backups");
+  const backupDir = join87(dir, ".backups");
   if (!existsSync84(backupDir)) {
     mkdirSync20(backupDir, { recursive: true });
   }
   for (let i = MAX_BACKUPS; i >= 1; i--) {
-    const current = join88(backupDir, `${name2}.${i}`);
+    const current = join87(backupDir, `${name2}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
         unlinkSync6(current);
       } catch {
       }
     } else {
-      const next = join88(backupDir, `${name2}.${i + 1}`);
+      const next = join87(backupDir, `${name2}.${i + 1}`);
       try {
         if (existsSync84(current)) renameSync6(current, next);
       } catch {
@@ -40422,13 +40586,13 @@ function rotateBackup(filePath) {
   }
   try {
     const content = readFileSync61(filePath, "utf-8");
-    writeFileSync13(join88(backupDir, `${name2}.1`), content, "utf-8");
+    writeFileSync13(join87(backupDir, `${name2}.1`), content, "utf-8");
   } catch {
   }
 }
 function writeJsonFileAtomic(filePath, data, indent = 2) {
   const dir = dirname16(filePath);
-  const tempPath = join88(dir, `.${basename14(filePath)}.${randomBytes8(6).toString("hex")}.tmp`);
+  const tempPath = join87(dir, `.${basename14(filePath)}.${randomBytes8(6).toString("hex")}.tmp`);
   const content = JSON.stringify(data, null, indent) + "\n";
   writeFileSync13(tempPath, content, "utf-8");
   try {
@@ -40445,7 +40609,7 @@ function writeJsonFileAtomic(filePath, data, indent = 2) {
   }
 }
 function getDataPath(projectRoot, filename) {
-  return join88(projectRoot, ".cleo", filename);
+  return join87(projectRoot, ".cleo", filename);
 }
 
 // packages/core/src/platform.ts
@@ -40569,7 +40733,7 @@ init_data_accessor();
 import { execFileSync as execFileSync9 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync85, readFileSync as readFileSync62, statSync as statSync18 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join89 } from "node:path";
+import { join as join88 } from "node:path";
 
 // packages/core/src/constants.ts
 var CORE_PROTECTED_FILES = [
@@ -40596,7 +40760,7 @@ function checkCliInstallation(cleoHome = getCleoHome()) {
 }
 var VERSION_REGEX = /^\d+\.\d+\.\d+$/;
 function checkCliVersion(cleoHome = getCleoHome()) {
-  const versionFile = join89(cleoHome, "VERSION");
+  const versionFile = join88(cleoHome, "VERSION");
   if (!existsSync85(versionFile)) {
     return {
       id: "cli_version",
@@ -40619,7 +40783,7 @@ function checkCliVersion(cleoHome = getCleoHome()) {
   };
 }
 function checkDocsAccessibility(cleoHome = getCleoHome()) {
-  const docsFile = join89(cleoHome, "templates", "CLEO-INJECTION.md");
+  const docsFile = join88(cleoHome, "templates", "CLEO-INJECTION.md");
   if (!existsSync85(docsFile)) {
     return {
       id: "docs_accessibility",
@@ -40653,7 +40817,7 @@ function checkDocsAccessibility(cleoHome = getCleoHome()) {
   };
 }
 function checkAtReferenceResolution(cleoHome = getCleoHome()) {
-  const docsFile = join89(cleoHome, "templates", "CLEO-INJECTION.md");
+  const docsFile = join88(cleoHome, "templates", "CLEO-INJECTION.md");
   const reference = "@~/.cleo/templates/CLEO-INJECTION.md";
   if (!existsSync85(docsFile)) {
     return {
@@ -40701,7 +40865,7 @@ function checkAtReferenceResolution(cleoHome = getCleoHome()) {
 }
 function checkAgentsMdHub(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const agentsMdPath = join89(root, "AGENTS.md");
+  const agentsMdPath = join88(root, "AGENTS.md");
   if (!existsSync85(agentsMdPath)) {
     return {
       id: "agents_md_hub",
@@ -40746,7 +40910,7 @@ function checkAgentsMdHub(projectRoot) {
 }
 function checkRootGitignore(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitignorePath = join89(root, ".gitignore");
+  const gitignorePath = join88(root, ".gitignore");
   if (!existsSync85(gitignorePath)) {
     return {
       id: "root_gitignore",
@@ -40797,7 +40961,7 @@ function checkRootGitignore(projectRoot) {
 }
 function checkCleoGitignore(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitignorePath = join89(root, ".cleo", ".gitignore");
+  const gitignorePath = join88(root, ".cleo", ".gitignore");
   if (!existsSync85(gitignorePath)) {
     return {
       id: "cleo_gitignore",
@@ -40827,8 +40991,8 @@ function checkCleoGitignore(projectRoot) {
   } catch {
     try {
       const templatePaths = [
-        join89(root, "templates", "cleo-gitignore"),
-        join89(getCleoHome(), "templates", "cleo-gitignore")
+        join88(root, "templates", "cleo-gitignore"),
+        join88(getCleoHome(), "templates", "cleo-gitignore")
       ];
       for (const tp of templatePaths) {
         if (existsSync85(tp)) {
@@ -40869,7 +41033,7 @@ function detectStorageEngine(_projectRoot) {
 }
 function checkVitalFilesTracked(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join89(root, ".git");
+  const gitDir = join88(root, ".git");
   if (!existsSync85(gitDir)) {
     return {
       id: "vital_files_tracked",
@@ -40884,7 +41048,7 @@ function checkVitalFilesTracked(projectRoot) {
   const vitalFiles = CORE_PROTECTED_FILES.map((f) => `.cleo/${f}`);
   const untracked = [];
   for (const file of vitalFiles) {
-    const fullPath = join89(root, file);
+    const fullPath = join88(root, file);
     if (!existsSync85(fullPath)) continue;
     try {
       execFileSync9("git", ["ls-files", "--error-unmatch", file], {
@@ -40916,7 +41080,7 @@ function checkVitalFilesTracked(projectRoot) {
 }
 function checkCoreFilesNotIgnored(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join89(root, ".git");
+  const gitDir = join88(root, ".git");
   if (!existsSync85(gitDir)) {
     return {
       id: "core_files_not_ignored",
@@ -40930,7 +41094,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
   const ignoredFiles = [];
   for (const file of CORE_PROTECTED_FILES) {
     const relPath = `.cleo/${file}`;
-    const fullPath = join89(root, relPath);
+    const fullPath = join88(root, relPath);
     if (!existsSync85(fullPath)) continue;
     try {
       execFileSync9("git", ["check-ignore", "-q", relPath], {
@@ -40962,7 +41126,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
 }
 function checkSqliteNotTracked(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join89(root, ".git");
+  const gitDir = join88(root, ".git");
   if (!existsSync85(gitDir)) {
     return {
       id: "sqlite_not_tracked",
@@ -40974,7 +41138,7 @@ function checkSqliteNotTracked(projectRoot) {
     };
   }
   const sqliteFile = ".cleo/tasks.db";
-  const fullPath = join89(root, sqliteFile);
+  const fullPath = join88(root, sqliteFile);
   if (!existsSync85(fullPath)) {
     return {
       id: "sqlite_not_tracked",
@@ -41011,7 +41175,7 @@ function checkSqliteNotTracked(projectRoot) {
 }
 function checkLegacyAgentOutputs(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const cleoDir = join89(root, ".cleo");
+  const cleoDir = join88(root, ".cleo");
   const detection = detectLegacyAgentOutputs(root, cleoDir);
   if (detection.hasLegacy) {
     return {
@@ -41037,7 +41201,7 @@ function checkCaampMarkerIntegrity(projectRoot) {
   const files = ["CLAUDE.md", "AGENTS.md"];
   const issues = [];
   for (const file of files) {
-    const filePath = join89(root, file);
+    const filePath = join88(root, file);
     if (!existsSync85(filePath)) continue;
     let content;
     try {
@@ -41075,7 +41239,7 @@ function checkCaampMarkerIntegrity(projectRoot) {
 }
 function checkAtReferenceTargetExists(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const agentsPath = join89(root, "AGENTS.md");
+  const agentsPath = join88(root, "AGENTS.md");
   if (!existsSync85(agentsPath)) {
     return {
       id: "at_reference_targets",
@@ -41115,7 +41279,7 @@ function checkAtReferenceTargetExists(projectRoot) {
   const missing = [];
   for (const ref of refs) {
     const rawPath = ref.slice(1).trim();
-    const resolvedPath = rawPath.startsWith("~/") ? join89(homedir4(), rawPath.slice(2)) : join89(root, rawPath);
+    const resolvedPath = rawPath.startsWith("~/") ? join88(homedir4(), rawPath.slice(2)) : join88(root, rawPath);
     if (!existsSync85(resolvedPath)) {
       missing.push(rawPath);
     }
@@ -41142,8 +41306,8 @@ function checkAtReferenceTargetExists(projectRoot) {
 function checkTemplateFreshness(projectRoot, cleoHome) {
   const root = projectRoot ?? process.cwd();
   const home = cleoHome ?? getCleoHome();
-  const sourcePath = join89(root, "templates", "CLEO-INJECTION.md");
-  const deployedPath = join89(home, "templates", "CLEO-INJECTION.md");
+  const sourcePath = join88(root, "templates", "CLEO-INJECTION.md");
+  const deployedPath = join88(home, "templates", "CLEO-INJECTION.md");
   if (!existsSync85(sourcePath)) {
     return {
       id: "template_freshness",
@@ -41187,7 +41351,7 @@ function checkTemplateFreshness(projectRoot, cleoHome) {
 }
 function checkTierMarkersPresent(cleoHome) {
   const home = cleoHome ?? getCleoHome();
-  const templatePath = join89(home, "templates", "CLEO-INJECTION.md");
+  const templatePath = join88(home, "templates", "CLEO-INJECTION.md");
   if (!existsSync85(templatePath)) {
     return {
       id: "tier_markers_present",
@@ -41309,7 +41473,7 @@ function checkGlobalSchemaHealth(_projectRoot) {
 }
 function checkNoLocalSchemas(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const localSchemasDir = join89(root, ".cleo", "schemas");
+  const localSchemasDir = join88(root, ".cleo", "schemas");
   if (!existsSync85(localSchemasDir)) {
     return {
       id: "no_local_schemas",
@@ -41374,13 +41538,13 @@ var databaseSyncCtor = (() => {
 })();
 var STALE_JSON_FILES = ["todo.json", "sessions.json", "todo-archive.json"];
 function resolveStructuredLogPath(cleoDir) {
-  const defaultPath = join90(cleoDir, "logs", "cleo.log");
-  const configPath = join90(cleoDir, "config.json");
+  const defaultPath = join89(cleoDir, "logs", "cleo.log");
+  const configPath = join89(cleoDir, "config.json");
   if (!existsSync86(configPath)) return defaultPath;
   try {
     const config = JSON.parse(readFileSync63(configPath, "utf-8"));
     if (!config.logging?.filePath) return defaultPath;
-    return join90(cleoDir, config.logging.filePath);
+    return join89(cleoDir, config.logging.filePath);
   } catch {
     return defaultPath;
   }
@@ -41422,14 +41586,14 @@ function checkAuditLogAvailability(dbPath) {
   }
 }
 function getSystemHealth(projectRoot, opts) {
-  const cleoDir = join90(projectRoot, ".cleo");
+  const cleoDir = join89(projectRoot, ".cleo");
   const checks = [];
   if (existsSync86(cleoDir)) {
     checks.push({ name: "cleo_dir", status: "pass", message: ".cleo directory exists" });
   } else {
     checks.push({ name: "cleo_dir", status: "fail", message: ".cleo directory not found" });
   }
-  const dbPath = join90(cleoDir, "tasks.db");
+  const dbPath = join89(cleoDir, "tasks.db");
   if (existsSync86(dbPath)) {
     try {
       const dbSize = statSync19(dbPath).size;
@@ -41451,7 +41615,7 @@ function getSystemHealth(projectRoot, opts) {
   if (existsSync86(dbPath)) {
     checks.push(checkAuditLogAvailability(dbPath));
   }
-  const configPath = join90(cleoDir, "config.json");
+  const configPath = join89(cleoDir, "config.json");
   if (existsSync86(configPath)) {
     try {
       JSON.parse(readFileSync63(configPath, "utf-8"));
@@ -41467,7 +41631,7 @@ function getSystemHealth(projectRoot, opts) {
     checks.push({ name: "config_json", status: "warn", message: "config.json not found" });
   }
   if (existsSync86(dbPath)) {
-    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync86(join90(cleoDir, f)));
+    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync86(join89(cleoDir, f)));
     if (staleFiles.length > 0) {
       checks.push({
         name: "stale_json",
@@ -41491,7 +41655,7 @@ function getSystemHealth(projectRoot, opts) {
         message: `structured log not found: ${logPath}`
       });
     }
-    const backupDir = join90(cleoDir, ".backups");
+    const backupDir = join89(cleoDir, ".backups");
     if (existsSync86(backupDir)) {
       checks.push({ name: "backups_dir", status: "pass", message: ".backups directory exists" });
     } else {
@@ -41504,7 +41668,7 @@ function getSystemHealth(projectRoot, opts) {
   }
   let version = "unknown";
   try {
-    const pkgPath = join90(projectRoot, "package.json");
+    const pkgPath = join89(projectRoot, "package.json");
     if (existsSync86(pkgPath)) {
       const pkg = JSON.parse(readFileSync63(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
@@ -41540,8 +41704,8 @@ async function getSystemDiagnostics(projectRoot, opts) {
       details: preflight.summary
     });
   }
-  const cleoDir = join90(projectRoot, ".cleo");
-  const dbPath = join90(cleoDir, "tasks.db");
+  const cleoDir = join89(projectRoot, ".cleo");
+  const dbPath = join89(cleoDir, "tasks.db");
   if (existsSync86(dbPath)) {
     try {
       const accessor = await getAccessor(projectRoot);
@@ -41681,7 +41845,7 @@ function mapSchemaCheckResult(sr) {
   };
 }
 function checkContributorChannel(projectRoot) {
-  const configPath = join90(projectRoot, ".cleo", "config.json");
+  const configPath = join89(projectRoot, ".cleo", "config.json");
   if (!existsSync86(configPath)) {
     return { check: "contributor_channel", status: "ok", message: "Not a contributor project" };
   }
@@ -41698,7 +41862,7 @@ function checkContributorChannel(projectRoot) {
     return { check: "contributor_channel", status: "ok", message: "Not a contributor project" };
   }
   const pathDirs = (process.env["PATH"] ?? "").split(":").filter(Boolean);
-  const devCliOnPath = pathDirs.some((dir) => existsSync86(join90(dir, devCli)));
+  const devCliOnPath = pathDirs.some((dir) => existsSync86(join89(dir, devCli)));
   if (!devCliOnPath) {
     return {
       check: "contributor_channel",
@@ -41731,14 +41895,14 @@ async function coreDoctorReport(projectRoot) {
     status: gitPath ? "ok" : "warning",
     message: gitPath ? `git found: ${gitPath}` : "git not found (optional, needed for version control features)"
   });
-  const cleoDir = join90(projectRoot, ".cleo");
+  const cleoDir = join89(projectRoot, ".cleo");
   const dirExists = existsSync86(cleoDir);
   checks.push({
     check: "project_dir",
     status: dirExists ? "ok" : "error",
     message: dirExists ? `Project dir: ${cleoDir}` : `Project dir not found: ${cleoDir}. Run: cleo init`
   });
-  const dbPath = join90(cleoDir, "tasks.db");
+  const dbPath = join89(cleoDir, "tasks.db");
   const dbExists2 = existsSync86(dbPath);
   const dbSize = await fileSize(dbPath);
   checks.push({
@@ -41788,14 +41952,14 @@ async function coreDoctorReport(projectRoot) {
     } catch {
     }
   }
-  const configPath = join90(cleoDir, "config.json");
+  const configPath = join89(cleoDir, "config.json");
   const configExists = existsSync86(configPath);
   checks.push({
     check: "config_file",
     status: configExists ? "ok" : "warning",
     message: configExists ? "config.json present" : "config.json not found (using defaults)"
   });
-  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync86(join90(cleoDir, f)));
+  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync86(join89(cleoDir, f)));
   if (dbExists2 && staleJsonFiles.length > 0) {
     checks.push({
       check: "stale_json",
@@ -41811,7 +41975,7 @@ async function coreDoctorReport(projectRoot) {
     status: logExists ? "ok" : "warning",
     message: logExists ? `structured log present: ${logPath}` : `structured log not found: ${logPath}`
   });
-  const rootGitignorePath = join90(projectRoot, ".gitignore");
+  const rootGitignorePath = join89(projectRoot, ".gitignore");
   if (existsSync86(rootGitignorePath)) {
     try {
       const gitignoreContent = readFileSync63(rootGitignorePath, "utf-8");
@@ -41833,7 +41997,7 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkVitalFilesTracked(projectRoot)));
   checks.push(mapCheckResult(checkCoreFilesNotIgnored(projectRoot)));
   checks.push(mapCheckResult(checkLegacyAgentOutputs(projectRoot)));
-  const cleoGitHeadExists = existsSync86(join90(cleoDir, ".git", "HEAD"));
+  const cleoGitHeadExists = existsSync86(join89(cleoDir, ".git", "HEAD"));
   checks.push({
     check: "cleo_git_repo",
     status: cleoGitHeadExists ? "ok" : "warning",
@@ -41849,15 +42013,15 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkProjectContext(projectRoot)));
   checks.push(mapCheckResult(checkInjection2(projectRoot)));
   checks.push(checkContributorChannel(projectRoot));
-  const agentDefPath = join90(getAgentsHome(), "agents", "cleo-subagent");
+  const agentDefPath = join89(getAgentsHome(), "agents", "cleo-subagent");
   checks.push({
     check: "agent_definition",
     status: existsSync86(agentDefPath) ? "ok" : "warning",
     message: existsSync86(agentDefPath) ? "cleo-subagent agent definition installed" : "cleo-subagent not found \u2014 run: cleo init",
     ...existsSync86(agentDefPath) ? {} : { fix: "cleo init" }
   });
-  const gitDir = join90(projectRoot, ".git");
-  const gitHubTemplatesDir = join90(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const gitDir = join89(projectRoot, ".git");
+  const gitHubTemplatesDir = join89(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (existsSync86(gitDir)) {
     checks.push({
       check: "github_templates",
@@ -41893,11 +42057,11 @@ async function coreDoctorReport(projectRoot) {
 init_paths();
 init_data_accessor();
 import { existsSync as existsSync87, readFileSync as readFileSync64 } from "node:fs";
-import { join as join91 } from "node:path";
+import { join as join90 } from "node:path";
 async function generateInjection(projectRoot, accessor) {
   let version = "unknown";
   try {
-    const pkgPath = join91(projectRoot, "package.json");
+    const pkgPath = join90(projectRoot, "package.json");
     if (existsSync87(pkgPath)) {
       const pkg = JSON.parse(readFileSync64(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
@@ -42031,9 +42195,9 @@ async function getLabels(cwd, accessor) {
 
 // packages/core/src/system/metrics.ts
 import { existsSync as existsSync88, readFileSync as readFileSync65 } from "node:fs";
-import { join as join92 } from "node:path";
+import { join as join91 } from "node:path";
 async function getSystemMetrics(projectRoot, opts, accessor) {
-  const cleoDir = join92(projectRoot, ".cleo");
+  const cleoDir = join91(projectRoot, ".cleo");
   let complianceEntries = readComplianceJsonl(projectRoot);
   if (opts?.since) {
     complianceEntries = complianceEntries.filter((e) => e.timestamp >= opts.since);
@@ -42060,7 +42224,7 @@ async function getSystemMetrics(projectRoot, opts, accessor) {
       sessionsActive = sessions2.filter((s) => s.status === "active").length;
       sessionsCompleted = sessions2.filter((s) => s.status === "ended").length;
     } else {
-      const sessionsPath = join92(cleoDir, "sessions.json");
+      const sessionsPath = join91(cleoDir, "sessions.json");
       if (existsSync88(sessionsPath)) {
         const sessionsData = JSON.parse(readFileSync65(sessionsPath, "utf-8"));
         const sessions2 = sessionsData.sessions ?? [];
@@ -42085,9 +42249,9 @@ init_src();
 init_errors3();
 init_data_accessor();
 import { existsSync as existsSync89 } from "node:fs";
-import { join as join93 } from "node:path";
+import { join as join92 } from "node:path";
 async function getMigrationStatus2(projectRoot, opts) {
-  const taskPath = join93(projectRoot, ".cleo", "tasks.db");
+  const taskPath = join92(projectRoot, ".cleo", "tasks.db");
   let currentVersion = "unknown";
   if (existsSync89(taskPath)) {
     try {
@@ -42119,7 +42283,7 @@ init_paths();
 import { execFile as execFile7 } from "node:child_process";
 import { existsSync as existsSync90 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
-import { basename as basename15, join as join94 } from "node:path";
+import { basename as basename15, join as join93 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 function normalizeChannel(value) {
   if (!value) return null;
@@ -42152,7 +42316,7 @@ function getExpectedNaming(channel) {
   }
 }
 async function parseVersionFile(dataRoot) {
-  const versionPath = join94(dataRoot, "VERSION");
+  const versionPath = join93(dataRoot, "VERSION");
   if (!existsSync90(versionPath)) return null;
   let content;
   try {
@@ -42182,9 +42346,9 @@ async function parseVersionFile(dataRoot) {
 async function getPackageInfo(sourceDir) {
   const candidates = [];
   if (sourceDir && sourceDir !== "unknown" && sourceDir !== "npm") {
-    candidates.push(join94(sourceDir, "package.json"));
+    candidates.push(join93(sourceDir, "package.json"));
   }
-  candidates.push(join94(process.cwd(), "package.json"));
+  candidates.push(join93(process.cwd(), "package.json"));
   for (const candidate of candidates) {
     try {
       const raw = await readFile15(candidate, "utf-8");
@@ -42264,13 +42428,13 @@ init_src();
 init_errors3();
 init_data_accessor();
 import { existsSync as existsSync91, readFileSync as readFileSync66, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join95 } from "node:path";
+import { join as join94 } from "node:path";
 function safestop(projectRoot, opts) {
   const dryRun = opts?.dryRun ?? false;
   const reason = opts?.reason ?? "Manual safestop";
   let sessionEnded = false;
   if (!dryRun && !opts?.noSessionEnd) {
-    const sessPath = join95(projectRoot, ".cleo", "sessions.json");
+    const sessPath = join94(projectRoot, ".cleo", "sessions.json");
     if (existsSync91(sessPath)) {
       try {
         const data = JSON.parse(readFileSync66(sessPath, "utf-8"));
@@ -42298,7 +42462,7 @@ async function uncancelTask(projectRoot, params) {
   if (!params.taskId) {
     throw new CleoError(2 /* INVALID_INPUT */, "taskId is required");
   }
-  const taskDbPath = join95(projectRoot, ".cleo", "tasks.db");
+  const taskDbPath = join94(projectRoot, ".cleo", "tasks.db");
   if (!existsSync91(taskDbPath)) {
     throw new CleoError(8 /* CONFIG_ERROR */, "No tasks.db found");
   }
@@ -42355,11 +42519,9 @@ async function uncancelTask(projectRoot, params) {
 // packages/core/src/task-work/index.ts
 var task_work_exports = {};
 __export(task_work_exports, {
-  analyzeTodoWriteChanges: () => analyzeChanges,
   currentTask: () => currentTask,
   getTaskHistory: () => getTaskHistory,
   getWorkHistory: () => getWorkHistory,
-  mergeTodoWriteState: () => mergeTodoWriteState,
   startTask: () => startTask,
   stopTask: () => stopTask
 });
@@ -42380,153 +42542,6 @@ function getUnresolvedDeps(taskId, tasks2) {
 
 // packages/core/src/task-work/index.ts
 init_handlers();
-
-// packages/core/src/task-work/todowrite-merge.ts
-init_src();
-init_errors3();
-init_paths();
-init_data_accessor();
-init_json2();
-init_add();
-init_complete();
-init_update2();
-import { readFile as readFile16, rm as rm3, stat as stat2 } from "node:fs/promises";
-import { join as join96 } from "node:path";
-function parseTaskId(content) {
-  const match = content.match(/^\[T(\d+)\]/);
-  return match ? `T${match[1]}` : null;
-}
-function stripPrefixes(content) {
-  return content.replace(/^\[T\d+\]\s*/, "").replace(/^\[!\]\s*/, "").replace(/^\[BLOCKED\]\s*/, "");
-}
-function analyzeChanges(todowriteState, injectedIds) {
-  const foundIds = [];
-  const completed = [];
-  const progressed = [];
-  const newTasks = [];
-  for (const item of todowriteState.todos) {
-    const taskId = parseTaskId(item.content);
-    if (taskId) {
-      foundIds.push(taskId);
-      if (item.status === "completed") {
-        completed.push(taskId);
-      } else if (item.status === "in_progress") {
-        progressed.push(taskId);
-      }
-    } else {
-      const cleanTitle = stripPrefixes(item.content);
-      if (cleanTitle.trim()) {
-        newTasks.push(cleanTitle);
-      }
-    }
-  }
-  const foundSet = new Set(foundIds);
-  const removed = injectedIds.filter((id) => !foundSet.has(id));
-  return { completed, progressed, newTasks, removed };
-}
-async function mergeTodoWriteState(options) {
-  const { file, dryRun = false, defaultPhase, cwd } = options;
-  const acc = options.accessor ?? await getAccessor(cwd);
-  try {
-    await stat2(file);
-  } catch {
-    throw new CleoError(4 /* NOT_FOUND */, `File not found: ${file}`);
-  }
-  const content = await readFile16(file, "utf-8");
-  let todowriteState;
-  try {
-    todowriteState = JSON.parse(content);
-  } catch {
-    throw new CleoError(2 /* INVALID_INPUT */, `Invalid JSON in ${file}`);
-  }
-  if (!todowriteState.todos || !Array.isArray(todowriteState.todos)) {
-    throw new CleoError(2 /* INVALID_INPUT */, 'File must contain a "todos" array');
-  }
-  const cleoDir = getCleoDir(cwd);
-  const stateFile = join96(cleoDir, "sync", "todowrite-session.json");
-  let sessionState = null;
-  try {
-    sessionState = await readJson(stateFile);
-  } catch {
-  }
-  const injectedIds = sessionState?.injected_tasks ?? [];
-  const changes = analyzeChanges(todowriteState, injectedIds);
-  const totalChanges = changes.completed.length + changes.progressed.length + changes.newTasks.length;
-  if (totalChanges === 0) {
-    return {
-      dryRun,
-      changes: {
-        completed: 0,
-        progressed: 0,
-        new: 0,
-        removed: changes.removed.length,
-        applied: 0
-      },
-      sessionCleared: false
-    };
-  }
-  let appliedCount = 0;
-  if (!dryRun) {
-    const { tasks: allTasks } = await acc.queryTasks({});
-    for (const taskId of changes.completed) {
-      const task = allTasks.find((t) => t.id === taskId);
-      if (!task) continue;
-      if (task.status === "done") continue;
-      try {
-        await completeTask({ taskId, notes: "Completed via TodoWrite session sync" }, cwd, acc);
-        appliedCount++;
-      } catch {
-      }
-    }
-    for (const taskId of changes.progressed) {
-      const task = allTasks.find((t) => t.id === taskId);
-      if (!task) continue;
-      if (task.status !== "pending" && task.status !== "blocked") continue;
-      try {
-        await updateTask(
-          { taskId, status: "active", notes: "Progressed during TodoWrite session" },
-          cwd,
-          acc
-        );
-        appliedCount++;
-      } catch {
-      }
-    }
-    for (const title of changes.newTasks) {
-      try {
-        await addTask(
-          {
-            title,
-            description: "Created during TodoWrite session",
-            labels: ["session-created"],
-            ...defaultPhase ? { phase: defaultPhase, addPhase: true } : {}
-          },
-          cwd,
-          acc
-        );
-        appliedCount++;
-      } catch {
-      }
-    }
-    try {
-      await rm3(stateFile);
-    } catch {
-    }
-  }
-  return {
-    dryRun,
-    changes: {
-      completed: changes.completed.length,
-      progressed: changes.progressed.length,
-      new: changes.newTasks.length,
-      removed: changes.removed.length,
-      applied: dryRun ? 0 : appliedCount
-    },
-    sessionCleared: !dryRun
-  };
-}
-
-// packages/core/src/task-work/index.ts
 async function currentTask(cwd, accessor) {
   const acc = accessor ?? await getAccessor(cwd);
   const focus = await acc.getMetaValue("focus_state");
@@ -43088,7 +43103,7 @@ __export(templates_exports, {
 
 // packages/core/src/templates/parser.ts
 import { existsSync as existsSync92, readdirSync as readdirSync29, readFileSync as readFileSync67 } from "fs";
-import { join as join97 } from "path";
+import { join as join95 } from "path";
 import { parse as parseYaml } from "yaml";
 var SUFFIX_PATTERNS = ["_report", "_request", "_question"];
 function deriveSubcommand(filename) {
@@ -43103,7 +43118,7 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile2(templateDir, filename) {
-  const filePath = join97(templateDir, filename);
+  const filePath = join95(templateDir, filename);
   const raw = readFileSync67(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name2 = typeof parsed.name === "string" ? parsed.name : filename;
@@ -43153,7 +43168,7 @@ function parseTemplateFile2(templateDir, filename) {
   };
 }
 function parseIssueTemplates2(projectRoot) {
-  const templateDir = join97(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const templateDir = join95(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (!existsSync92(templateDir)) {
     return {
       success: false,
@@ -43305,7 +43320,7 @@ __export(ui_exports, {
 // packages/core/src/ui/aliases.ts
 import { existsSync as existsSync93, readFileSync as readFileSync68, writeFileSync as writeFileSync15 } from "node:fs";
 import { homedir as homedir5, platform as platform2 } from "node:os";
-import { join as join98 } from "node:path";
+import { join as join96 } from "node:path";
 var MARKER_START = "# CLEO-CLAUDE-ALIASES:START";
 var MARKER_END = "# CLEO-CLAUDE-ALIASES:END";
 var ALIASES_VERSION = "1.0.0";
@@ -43327,16 +43342,16 @@ function getRcFilePath(shell) {
   const sh = shell ?? getCurrentShell();
   switch (sh) {
     case "bash":
-      return join98(home, ".bashrc");
+      return join96(home, ".bashrc");
     case "zsh":
-      return join98(home, ".zshrc");
+      return join96(home, ".zshrc");
     case "powershell":
-      return join98(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+      return join96(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
     case "cmd":
       return "";
     // CMD doesn't have a standard RC
     default:
-      return join98(home, ".bashrc");
+      return join96(home, ".bashrc");
   }
 }
 function detectAvailableShells() {
@@ -43576,7 +43591,7 @@ ${markdown}`);
 
 // packages/core/src/ui/command-registry.ts
 import { existsSync as existsSync95, readdirSync as readdirSync30, readFileSync as readFileSync70 } from "node:fs";
-import { basename as basename16, join as join99 } from "node:path";
+import { basename as basename16, join as join97 } from "node:path";
 var CLEO_HEADER_START = "###CLEO";
 var CLEO_HEADER_END = "###END";
 function parseCommandHeader(scriptPath) {
@@ -43662,7 +43677,7 @@ function scanAllCommands(scriptsDir) {
   if (!existsSync95(scriptsDir)) return registry;
   for (const file of readdirSync30(scriptsDir)) {
     if (!file.endsWith(".sh") && !file.endsWith(".ts")) continue;
-    const meta = parseCommandHeader(join99(scriptsDir, file));
+    const meta = parseCommandHeader(join97(scriptsDir, file));
     if (meta) {
       registry.set(meta.command, meta);
     }
@@ -44006,7 +44021,7 @@ function calculateOrchestrationOverhead(orchestratorTokens, totalSubagentTokens,
 
 // packages/core/src/validation/docs-sync.ts
 import { existsSync as existsSync96, readdirSync as readdirSync31, readFileSync as readFileSync71 } from "node:fs";
-import { join as join100 } from "node:path";
+import { join as join98 } from "node:path";
 function getScriptCommands(scriptsDir) {
   if (!existsSync96(scriptsDir)) return [];
   try {
@@ -44099,13 +44114,13 @@ var CRITICAL_COMMANDS = [
 ];
 function detectDrift(mode = "full", projectRoot = ".") {
   const issues = [];
-  const scriptsDir = join100(projectRoot, "scripts");
-  const indexPath = join100(projectRoot, "docs/commands/COMMANDS-INDEX.json");
+  const scriptsDir = join98(projectRoot, "scripts");
+  const indexPath = join98(projectRoot, "docs/commands/COMMANDS-INDEX.json");
   issues.push(...checkCommandsSync(scriptsDir, indexPath));
-  const wrapperPath = join100(projectRoot, "installer/lib/link.sh");
+  const wrapperPath = join98(projectRoot, "installer/lib/link.sh");
   issues.push(...checkWrapperSync(wrapperPath, indexPath));
   if (mode === "full") {
-    const readmePath = join100(projectRoot, "README.md");
+    const readmePath = join98(projectRoot, "README.md");
     if (existsSync96(readmePath)) {
       try {
         const readme = readFileSync71(readmePath, "utf-8");
@@ -44143,13 +44158,13 @@ function shouldRunDriftDetection(enabled = true, autoCheck = false, command, cri
 init_paths();
 import { createHash as createHash10 } from "node:crypto";
 import { existsSync as existsSync97, mkdirSync as mkdirSync21, readFileSync as readFileSync72, unlinkSync as unlinkSync7, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname17, join as join101 } from "node:path";
+import { dirname as dirname17, join as join99 } from "node:path";
 var CACHE_VERSION = "1.0.0";
 var CACHE_TTL_SECONDS = 300;
 var CACHE_FILE2 = "doctor-project-cache.json";
 function getCacheFilePath(cleoHome) {
   const home = cleoHome ?? getCleoHome();
-  return join101(home, CACHE_FILE2);
+  return join99(home, CACHE_FILE2);
 }
 function initCacheFile(cacheFile) {
   const cache = {
@@ -44193,8 +44208,8 @@ function getCachedValidation(projectHash, projectPath, cacheFile) {
   const now = Date.now();
   const age = (now - lastValidated) / 1e3;
   if (age > (entry.ttl || CACHE_TTL_SECONDS)) return null;
-  const currentTasksDbHash = getFileHash(join101(projectPath, ".cleo", "tasks.db"));
-  const currentConfigHash = getFileHash(join101(projectPath, ".cleo", "config.json"));
+  const currentTasksDbHash = getFileHash(join99(projectPath, ".cleo", "tasks.db"));
+  const currentConfigHash = getFileHash(join99(projectPath, ".cleo", "config.json"));
   if (currentTasksDbHash !== (entry.fileHashes["tasks.db"] ?? "")) return null;
   if (currentConfigHash !== (entry.fileHashes["config.json"] ?? "")) return null;
   return entry;
@@ -44205,8 +44220,8 @@ function cacheValidationResult(projectHash, projectPath, validationStatus, issue
   if (!cache) {
     cache = initCacheFile(cachePath);
   }
-  const tasksDbHash = getFileHash(join101(projectPath, ".cleo", "tasks.db"));
-  const configHash = getFileHash(join101(projectPath, ".cleo", "config.json"));
+  const tasksDbHash = getFileHash(join99(projectPath, ".cleo", "tasks.db"));
+  const configHash = getFileHash(join99(projectPath, ".cleo", "config.json"));
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   cache.projects[projectHash] = {
     path: projectPath,
@@ -45204,7 +45219,7 @@ function formatGapReport(report) {
 // packages/core/src/validation/manifest.ts
 init_paths();
 import { existsSync as existsSync98 } from "node:fs";
-import { appendFile as appendFile3, mkdir as mkdir16, readFile as readFile17 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir15, readFile as readFile16 } from "node:fs/promises";
 import { dirname as dirname18 } from "node:path";
 var DEFAULT_MANIFEST_PATH = ".cleo/agent-outputs/MANIFEST.jsonl";
 var DEFAULT_COMPLIANCE_PATH = ".cleo/metrics/COMPLIANCE.jsonl";
@@ -45217,7 +45232,7 @@ async function findManifestEntry(taskId, manifestPath) {
     }
   }
   if (!existsSync98(manifestPath)) return null;
-  const content = await readFile17(manifestPath, "utf-8");
+  const content = await readFile16(manifestPath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   for (let i = lines.length - 1; i >= 0; i--) {
     const line2 = lines[i];
@@ -45329,7 +45344,7 @@ async function validateManifestEntry(taskId, manifestEntry, manifestPath = DEFAU
 }
 async function logRealCompliance(taskId, validationResult, agentType = "unknown", compliancePath = DEFAULT_COMPLIANCE_PATH) {
   const metricsDir = dirname18(compliancePath);
-  await mkdir16(metricsDir, { recursive: true });
+  await mkdir15(metricsDir, { recursive: true });
   const { score, pass, violations } = validationResult;
   const violationCount = violations.length;
   let severity = "none";
@@ -46124,25 +46139,25 @@ init_hooks();
 init_injection();
 init_memory_bridge();
 import { existsSync as existsSync100, readdirSync as readdirSync33, readFileSync as readFileSync74 } from "node:fs";
-import { copyFile as copyFile3, lstat, mkdir as mkdir17, readFile as readFile18, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
-import { basename as basename17, dirname as dirname19, join as join102 } from "node:path";
+import { copyFile as copyFile3, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
+import { basename as basename17, dirname as dirname19, join as join100 } from "node:path";
 init_paths();
 init_scaffold();
 init_schema_management();
 init_json2();
 async function initAgentDefinition(created, warnings) {
   const packageRoot = getPackageRoot();
-  const agentSourceDir = join102(packageRoot, "agents", "cleo-subagent");
+  const agentSourceDir = join100(packageRoot, "agents", "cleo-subagent");
   if (!existsSync100(agentSourceDir)) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join102(getAgentsHome(), "agents", "cleo-subagent");
-  await mkdir17(dirname19(globalAgentsDir), { recursive: true });
+  const globalAgentsDir = join100(getAgentsHome(), "agents", "cleo-subagent");
+  await mkdir16(dirname19(globalAgentsDir), { recursive: true });
   try {
     try {
-      const stat3 = await lstat(globalAgentsDir);
-      if (stat3.isSymbolicLink() || stat3.isDirectory()) {
+      const stat2 = await lstat(globalAgentsDir);
+      if (stat2.isSymbolicLink() || stat2.isDirectory()) {
         return;
       }
     } catch {
@@ -46151,10 +46166,10 @@ async function initAgentDefinition(created, warnings) {
     created.push("agent: cleo-subagent (symlinked)");
   } catch (_err) {
     try {
-      await mkdir17(globalAgentsDir, { recursive: true });
+      await mkdir16(globalAgentsDir, { recursive: true });
       const files = readdirSync33(agentSourceDir);
       for (const file of files) {
-        await copyFile3(join102(agentSourceDir, file), join102(globalAgentsDir, file));
+        await copyFile3(join100(agentSourceDir, file), join100(globalAgentsDir, file));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -46174,12 +46189,12 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const bundledPath = join102(packageRoot, "packages", "skills");
-      if (existsSync100(join102(bundledPath, "skills.json"))) {
+      const bundledPath = join100(packageRoot, "packages", "skills");
+      if (existsSync100(join100(bundledPath, "skills.json"))) {
         ctSkillsRoot = bundledPath;
       } else {
-        const ctSkillsPath = join102(packageRoot, "node_modules", "@cleocode", "skills");
-        if (existsSync100(join102(ctSkillsPath, "skills.json"))) {
+        const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
+        if (existsSync100(join100(ctSkillsPath, "skills.json"))) {
           ctSkillsRoot = ctSkillsPath;
         }
       }
@@ -46194,13 +46209,13 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join102(ctSkillsRoot, "skills.json");
+    const catalogPath = join100(ctSkillsRoot, "skills.json");
     const catalog3 = JSON.parse(readFileSync74(catalogPath, "utf-8"));
     const skills = catalog3.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname19(join102(ctSkillsRoot, skill.path));
+      const skillSourceDir = dirname19(join100(ctSkillsRoot, skill.path));
       if (!existsSync100(skillSourceDir)) {
         continue;
       }
@@ -46244,33 +46259,33 @@ async function initNexusRegistration(projectRoot, created, warnings) {
   }
 }
 async function installGitHubTemplates(projectRoot, created, skipped) {
-  if (!existsSync100(join102(projectRoot, ".git"))) {
+  if (!existsSync100(join100(projectRoot, ".git"))) {
     return;
   }
-  const githubDir = join102(projectRoot, ".github");
-  const issueTemplateDir = join102(githubDir, "ISSUE_TEMPLATE");
+  const githubDir = join100(projectRoot, ".github");
+  const issueTemplateDir = join100(githubDir, "ISSUE_TEMPLATE");
   const packageRoot = getPackageRoot();
-  const templateSrcDir = join102(packageRoot, "templates", "github");
+  const templateSrcDir = join100(packageRoot, "templates", "github");
   if (!existsSync100(templateSrcDir)) {
     return;
   }
-  await mkdir17(issueTemplateDir, { recursive: true });
-  const issueSrcDir = join102(templateSrcDir, "ISSUE_TEMPLATE");
+  await mkdir16(issueTemplateDir, { recursive: true });
+  const issueSrcDir = join100(templateSrcDir, "ISSUE_TEMPLATE");
   if (existsSync100(issueSrcDir)) {
     const issueFiles = readdirSync33(issueSrcDir);
     for (const file of issueFiles) {
-      const dest = join102(issueTemplateDir, file);
+      const dest = join100(issueTemplateDir, file);
       if (existsSync100(dest)) {
         skipped.push(`.github/ISSUE_TEMPLATE/${file}`);
         continue;
       }
-      const content = readFileSync74(join102(issueSrcDir, file), "utf-8");
+      const content = readFileSync74(join100(issueSrcDir, file), "utf-8");
       await writeFile11(dest, content, "utf-8");
       created.push(`.github/ISSUE_TEMPLATE/${file}`);
     }
   }
-  const prTemplateSrc = join102(templateSrcDir, "pull_request_template.md");
-  const prTemplateDest = join102(githubDir, "pull_request_template.md");
+  const prTemplateSrc = join100(templateSrcDir, "pull_request_template.md");
+  const prTemplateDest = join100(githubDir, "pull_request_template.md");
   if (existsSync100(prTemplateSrc)) {
     if (existsSync100(prTemplateDest)) {
       skipped.push(".github/pull_request_template.md");
@@ -46309,7 +46324,7 @@ async function initProject(opts = {}) {
   }
   const cleoDir = getCleoDirAbsolute();
   const projRoot = getProjectRoot();
-  const alreadyInitialized = existsSync100(cleoDir) && (existsSync100(join102(cleoDir, "tasks.db")) || existsSync100(join102(cleoDir, "config.json")));
+  const alreadyInitialized = existsSync100(cleoDir) && (existsSync100(join100(cleoDir, "tasks.db")) || existsSync100(join100(cleoDir, "config.json")));
   if (alreadyInitialized && !opts.force) {
     throw new CleoError(
       1 /* GENERAL_ERROR */,
@@ -46333,7 +46348,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-    await getDb3(join102(cleoDir, ".."));
+    await getDb3(join100(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -46354,7 +46369,7 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join102(cleoDir, ".gitignore");
+    const gitignorePath = join100(cleoDir, ".gitignore");
     if (existsSync100(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
@@ -46366,12 +46381,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join102(cleoDir, ".sequence");
+  const legacySequencePath = join100(cleoDir, ".sequence");
   try {
     await unlink4(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join102(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join100(cleoDir, ".sequence.json");
   try {
     await unlink4(legacySequenceJsonPath);
   } catch {
@@ -46533,8 +46548,8 @@ function isAutoInitEnabled() {
 }
 async function ensureInitialized(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const cleoDir = join102(root, ".cleo");
-  const isInit = existsSync100(cleoDir) && (existsSync100(join102(cleoDir, "tasks.db")) || existsSync100(join102(cleoDir, "config.json")));
+  const cleoDir = join100(root, ".cleo");
+  const isInit = existsSync100(cleoDir) && (existsSync100(join100(cleoDir, "tasks.db")) || existsSync100(join100(cleoDir, "config.json")));
   if (isInit) {
     return { initialized: true };
   }
@@ -46546,10 +46561,10 @@ async function ensureInitialized(projectRoot) {
 }
 async function getVersion2(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const versionPaths = [join102(root, "VERSION"), join102(root, "..", "VERSION")];
+  const versionPaths = [join100(root, "VERSION"), join100(root, "..", "VERSION")];
   for (const versionPath of versionPaths) {
     try {
-      const content = await readFile18(versionPath, "utf-8");
+      const content = await readFile17(versionPath, "utf-8");
       const version = content.trim();
       if (version) {
         return { version };
@@ -46557,7 +46572,7 @@ async function getVersion2(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join102(root, "package.json"));
+  const pkg = await readJson(join100(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
@@ -46570,15 +46585,15 @@ init_logger();
 
 // packages/core/src/output.ts
 init_errors3();
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // packages/core/src/sessions/context-alert.ts
 init_paths();
 import { existsSync as existsSync101, readFileSync as readFileSync75, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join103 } from "node:path";
+import { join as join101 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join103(getCleoDir(cwd), ".current-session");
+  const sessionFile = join101(getCleoDir(cwd), ".current-session");
   if (existsSync101(sessionFile)) {
     return readFileSync75(sessionFile, "utf-8").trim() || null;
   }
@@ -46603,7 +46618,7 @@ function createCliMeta(operation, mvi = "standard") {
     schemaVersion: "2026.2.1",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     operation,
-    requestId: randomUUID4(),
+    requestId: randomUUID5(),
     transport: "cli",
     strict: true,
     mvi,
@@ -46656,13 +46671,13 @@ init_paths();
 // packages/core/src/project-info.ts
 init_paths();
 import { existsSync as existsSync102, readFileSync as readFileSync76 } from "node:fs";
-import { readFile as readFile19 } from "node:fs/promises";
-import { join as join104 } from "node:path";
+import { readFile as readFile18 } from "node:fs/promises";
+import { join as join102 } from "node:path";
 async function getProjectInfo(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join104(cleoDir, "project-info.json");
-  const raw = await readFile19(infoPath, "utf-8");
+  const infoPath = join102(cleoDir, "project-info.json");
+  const raw = await readFile18(infoPath, "utf-8");
   const data = JSON.parse(raw);
   if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
     throw new Error(`project-info.json missing required field: projectHash`);
@@ -46679,7 +46694,7 @@ async function getProjectInfo(cwd) {
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join104(cleoDir, "project-info.json");
+  const infoPath = join102(cleoDir, "project-info.json");
   if (!existsSync102(infoPath)) return null;
   try {
     const raw = readFileSync76(infoPath, "utf-8");
@@ -46940,9 +46955,9 @@ var Cleo = class _Cleo {
         },
         store
       ),
-      readState: (providerId) => readSyncState(providerId, root),
-      writeState: (providerId, state) => writeSyncState(providerId, state, root),
-      clearState: (providerId) => clearSyncState(providerId, root)
+      getLinks: (providerId) => getLinksByProvider(providerId, root),
+      getTaskLinks: (taskId) => getLinksByTaskId(taskId, root),
+      removeProviderLinks: (providerId) => removeLinksByProvider(providerId, root)
     };
   }
 };