@cleocode/cleo 2026.4.148 → 2026.4.150

package/dist/cli/index.js

@@ -9296,7 +9296,7 @@ async function lifecycleStatus(epicId, projectRoot) {
     return engineError("E_INVALID_INPUT", "epicId is required");
   }
   try {
-    const data = await getLifecycleStatus(epicId, projectRoot);
+    const data = await getLifecycleStatus(projectRoot, { epicId });
     return engineSuccess(data);
   } catch (err) {
     if (err instanceof Error) {
@@ -9307,7 +9307,7 @@ async function lifecycleStatus(epicId, projectRoot) {
 }
 async function lifecycleHistory(taskId, projectRoot) {
   try {
-    const data = await getLifecycleHistory(taskId, projectRoot);
+    const data = await getLifecycleHistory(projectRoot ?? process.cwd(), { taskId });
     return engineSuccess(data);
   } catch (err) {
     if (err instanceof Error) {
@@ -9318,7 +9318,7 @@ async function lifecycleHistory(taskId, projectRoot) {
 }
 async function lifecycleGates(taskId, projectRoot) {
   try {
-    const data = await getLifecycleGates(taskId, projectRoot);
+    const data = await getLifecycleGates(projectRoot ?? process.cwd(), { taskId });
     return engineSuccess(data);
   } catch (err) {
     if (err instanceof Error) {
@@ -9346,7 +9346,10 @@ async function lifecycleCheck(epicId, targetStage, projectRoot) {
     return engineError("E_INVALID_INPUT", "epicId and targetStage are required");
   }
   try {
-    const data = await checkStagePrerequisites(epicId, targetStage, projectRoot);
+    const data = await checkStagePrerequisites(projectRoot ?? process.cwd(), {
+      epicId,
+      targetStage
+    });
     return engineSuccess(data);
   } catch (err) {
     if (err instanceof Error) {
@@ -9365,7 +9368,7 @@ async function lifecycleProgress(taskId, stage, status, notes, projectRoot) {
   try {
     if (status === "in_progress" || status === "completed") {
       const { getLifecycleStatus: getLifecycleStatus4 } = await import("@cleocode/core/internal");
-      const current = await getLifecycleStatus4(taskId, projectRoot);
+      const current = await getLifecycleStatus4(projectRoot ?? process.cwd(), { taskId });
       if (current.currentStage) {
         const { isPipelineTransitionForward, getPipelineStageOrder } = await import("@cleocode/core/internal");
         if (!isPipelineTransitionForward(current.currentStage, stage)) {
@@ -9382,7 +9385,12 @@ async function lifecycleProgress(taskId, stage, status, notes, projectRoot) {
         return engineError("E_LIFECYCLE_GATE_FAILED", gateResult.message);
       }
     }
-    const data = await recordStageProgress(taskId, stage, status, notes, projectRoot);
+    const data = await recordStageProgress(projectRoot ?? process.cwd(), {
+      taskId,
+      stage,
+      status,
+      notes
+    });
     return engineSuccess({ ...data, recorded: true });
   } catch (err) {
     if (err instanceof Error) {
@@ -9398,7 +9406,11 @@ async function lifecycleSkip(taskId, stage, reason, projectRoot) {
   const scopeDenied = await enforceScopeForLifecycleMutation(taskId, projectRoot);
   if (scopeDenied) return scopeDenied;
   try {
-    const data = await skipStageWithReason(taskId, stage, reason, projectRoot);
+    const data = await skipStageWithReason(projectRoot ?? process.cwd(), {
+      taskId,
+      stage,
+      reason
+    });
     return engineSuccess({ ...data, skipped: true });
   } catch (err) {
     if (err instanceof Error) {
@@ -9414,7 +9426,11 @@ async function lifecycleReset(taskId, stage, reason, projectRoot) {
   const scopeDenied = await enforceScopeForLifecycleMutation(taskId, projectRoot);
   if (scopeDenied) return scopeDenied;
   try {
-    const data = await resetStage(taskId, stage, reason, projectRoot);
+    const data = await resetStage(projectRoot ?? process.cwd(), {
+      taskId,
+      stage,
+      reason
+    });
     return engineSuccess({ ...data, reset: "pending" });
   } catch (err) {
     if (err instanceof Error) {
@@ -9428,7 +9444,12 @@ async function lifecycleGatePass(taskId, gateName, agent, notes, projectRoot) {
     return engineError("E_INVALID_INPUT", "taskId and gateName are required");
   }
   try {
-    const data = await passGate(taskId, gateName, agent, notes, projectRoot);
+    const data = await passGate(projectRoot ?? process.cwd(), {
+      taskId,
+      gateName,
+      agent: agent ?? "system",
+      notes
+    });
     return engineSuccess({ ...data, status: "passed" });
   } catch (err) {
     if (err instanceof Error) {
@@ -9442,7 +9463,11 @@ async function lifecycleGateFail(taskId, gateName, reason, projectRoot) {
     return engineError("E_INVALID_INPUT", "taskId and gateName are required");
   }
   try {
-    const data = await failGate(taskId, gateName, reason, projectRoot);
+    const data = await failGate(projectRoot ?? process.cwd(), {
+      taskId,
+      gateName,
+      reason: reason ?? ""
+    });
     return engineSuccess({ ...data, status: "failed" });
   } catch (err) {
     if (err instanceof Error) {
@@ -9610,8 +9635,7 @@ async function sessionList(projectRoot, params) {
 }
 async function sessionFind(projectRoot, params) {
   try {
-    const accessor = await getAccessor(projectRoot);
-    const result = await findSessions(accessor, params);
+    const result = await findSessions(projectRoot, params);
     return { success: true, data: result };
   } catch {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
@@ -9619,7 +9643,7 @@ async function sessionFind(projectRoot, params) {
 }
 async function sessionShow(projectRoot, sessionId) {
   try {
-    const result = await showSession(projectRoot, sessionId);
+    const result = await showSession(projectRoot, { sessionId });
     return { success: true, data: result };
   } catch (err) {
     return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "Session not initialized");
@@ -10014,7 +10038,7 @@ async function sessionGc(projectRoot, maxAgeDays = 1) {
 }
 async function sessionSuspend(projectRoot, sessionId, reason) {
   try {
-    const result = await suspendSession(projectRoot, sessionId, reason);
+    const result = await suspendSession(projectRoot, { sessionId, reason });
     return { success: true, data: result };
   } catch (err) {
     return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "Failed to end session");
@@ -10055,7 +10079,7 @@ async function sessionRecordDecision(projectRoot, params) {
 }
 async function sessionDecisionLog(projectRoot, params) {
   try {
-    const result = await getDecisionLog(projectRoot, params);
+    const result = await getDecisionLog(projectRoot, params ?? {});
     return { success: true, data: result };
   } catch {
     return { success: true, data: [] };
@@ -10063,7 +10087,7 @@ async function sessionDecisionLog(projectRoot, params) {
 }
 async function sessionContextDrift(projectRoot, params) {
   try {
-    const result = await getContextDrift(projectRoot, params);
+    const result = await getContextDrift(projectRoot, params ?? {});
     return { success: true, data: result };
   } catch (err) {
     return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "Failed to read decision log");
@@ -10890,11 +10914,11 @@ async function orchestrateStartup(epicId, projectRoot) {
     const children = tasks.filter((t) => t.parentId === epicId);
     const readyTasks = await getReadyTasks(epicId, root, accessor);
     const ready = readyTasks.filter((t) => t.ready);
-    const lifecycleStatus2 = await getLifecycleStatus2(epicId, root);
+    const lifecycleStatus2 = await getLifecycleStatus2(root, { epicId });
     let autoInitialized = false;
     let currentStage;
     if (!lifecycleStatus2.initialized) {
-      await recordStageProgress2(epicId, "research", "in_progress", void 0, root);
+      await recordStageProgress2(root, { taskId: epicId, stage: "research", status: "in_progress" });
       autoInitialized = true;
       currentStage = "research";
     } else {
@@ -12748,9 +12772,9 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join23 } = await import("node:path");
+    const { join: join22 } = await import("node:path");
     const { existsSync: existsSync12 } = await import("node:fs");
-    const dbPath = join23(projectRoot, CLEO_DIR_NAME, TASKS_DB_FILENAME);
+    const dbPath = join22(projectRoot, CLEO_DIR_NAME, TASKS_DB_FILENAME);
     if (!existsSync12(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
@@ -13727,7 +13751,7 @@ async function taskShowWithHistory(projectRoot, taskId, includeHistory) {
     }
     let history = [];
     try {
-      const status = await getLifecycleStatus3(taskId, projectRoot);
+      const status = await getLifecycleStatus3(projectRoot ?? process.cwd(), { taskId });
       history = status.stages.map(
         (s) => ({
           stage: s.stage,
@@ -13984,12 +14008,12 @@ async function taskCompleteStrict(projectRoot, taskId, notes) {
       const accessor = await getAccessor6(projectRoot);
       const task = await accessor.loadSingleTask(taskId);
       if (task?.verification?.evidence) {
-        const { revalidateEvidence: revalidateEvidence2 } = await import("@cleocode/core/internal");
+        const { revalidateEvidence } = await import("@cleocode/core/internal");
         const evidenceEntries = Object.entries(task.verification.evidence);
         const staleGates = [];
         for (const [gate, ev] of evidenceEntries) {
           if (!ev) continue;
-          const check = await revalidateEvidence2(ev, projectRoot);
+          const check = await revalidateEvidence(ev, projectRoot);
           if (!check.stillValid) {
             staleGates.push({
               gate,
@@ -16176,20 +16200,11 @@ var init_admin = __esm({
       "adr.find": async (params) => {
         const projectRoot = getProjectRoot2();
         if (params.query) {
-          const result2 = await findAdrs(projectRoot, params.query, {
-            topics: params.topics,
-            keywords: params.keywords,
-            status: params.status
-          });
+          const result2 = await findAdrs(projectRoot, params);
           return lafsSuccess(result2, "adr.find");
         }
         const { limit, offset } = getListParams({ limit: params.limit, offset: params.offset });
-        const result = await listAdrs(projectRoot, {
-          status: params.status,
-          since: params.since,
-          limit,
-          offset
-        });
+        const result = await listAdrs(projectRoot, { ...params, limit, offset });
         return lafsSuccess(
           {
             ...result,
@@ -16200,7 +16215,7 @@ var init_admin = __esm({
       },
       "adr.show": async (params) => {
         const projectRoot = getProjectRoot2();
-        const adr = await showAdr(projectRoot, params.adrId);
+        const adr = await showAdr(projectRoot, params);
         if (!adr) {
           return lafsError("E_NOT_FOUND", `ADR not found: ${params.adrId}`, "adr.show");
         }
@@ -16214,7 +16229,7 @@ var init_admin = __esm({
           if (!tokenId) {
             return lafsError("E_INVALID_INPUT", "tokenId is required", "token");
           }
-          const result2 = await showTokenUsage(tokenId, projectRoot);
+          const result2 = await showTokenUsage(projectRoot, { id: tokenId });
           if (!result2) {
             return lafsError("E_NOT_FOUND", `Token usage record not found: ${tokenId}`, "token");
           }
@@ -16222,36 +16237,7 @@ var init_admin = __esm({
         }
         if (action === "list") {
           const { limit, offset } = getListParams({ limit: params.limit, offset: params.offset });
-          const result2 = await listTokenUsage(
-            {
-              provider: params.provider,
-              transport: params.transport,
-              gateway: params.gateway,
-              domain: params.domain,
-              operation: params.operationName,
-              sessionId: params.sessionId,
-              taskId: params.taskId,
-              method: params.method,
-              confidence: params.confidence,
-              requestId: params.requestId,
-              since: params.since,
-              until: params.until,
-              limit,
-              offset
-            },
-            projectRoot
-          );
-          return lafsSuccess(
-            {
-              records: result2.records,
-              total: result2.total,
-              filtered: result2.filtered
-            },
-            "token"
-          );
-        }
-        const result = await summarizeTokenUsage(
-          {
+          const result2 = await listTokenUsage(projectRoot, {
             provider: params.provider,
             transport: params.transport,
             gateway: params.gateway,
@@ -16263,10 +16249,33 @@ var init_admin = __esm({
             confidence: params.confidence,
             requestId: params.requestId,
             since: params.since,
-            until: params.until
-          },
-          projectRoot
-        );
+            until: params.until,
+            limit,
+            offset
+          });
+          return lafsSuccess(
+            {
+              records: result2.records,
+              total: result2.total,
+              filtered: result2.filtered
+            },
+            "token"
+          );
+        }
+        const result = await summarizeTokenUsage(projectRoot, {
+          provider: params.provider,
+          transport: params.transport,
+          gateway: params.gateway,
+          domain: params.domain,
+          operation: params.operationName,
+          sessionId: params.sessionId,
+          taskId: params.taskId,
+          method: params.method,
+          confidence: params.confidence,
+          requestId: params.requestId,
+          since: params.since,
+          until: params.until
+        });
         return lafsSuccess(result, "token");
       },
       backup: async (_params) => {
@@ -16299,25 +16308,10 @@ var init_admin = __esm({
           );
         }
         if (params.scope === "tasks") {
-          const result2 = await exportTasksPackage({
-            taskIds: params.taskIds,
-            output: params.output,
-            subtree: params.subtree,
-            filter: params.filter,
-            includeDeps: params.includeDeps,
-            dryRun: params.dryRun,
-            cwd: projectRoot
-          });
+          const result2 = await exportTasksPackage(projectRoot, params);
           return lafsSuccess(result2, "export");
         }
-        const result = await exportTasks({
-          format: params.format,
-          output: params.output,
-          status: params.status,
-          parent: params.parent,
-          phase: params.phase,
-          cwd: projectRoot
-        });
+        const result = await exportTasks(projectRoot, params);
         return lafsSuccess(result, "export");
       },
       map: async (params) => {
@@ -16640,30 +16634,10 @@ var init_admin = __esm({
           );
         }
         if (params.scope === "tasks") {
-          const result2 = await importTasksPackage({
-            file,
-            dryRun: params.dryRun,
-            parent: params.parent,
-            phase: params.phase,
-            addLabel: params.addLabel,
-            provenance: params.provenance,
-            resetStatus: params.resetStatus,
-            onConflict: params.onConflict,
-            onMissingDep: params.onMissingDep,
-            force: params.force,
-            cwd: projectRoot
-          });
+          const result2 = await importTasksPackage(projectRoot, params);
           return lafsSuccess(result2, "import");
         }
-        const result = await importTasks({
-          file,
-          parent: params.parent,
-          phase: params.phase,
-          onDuplicate: params.onDuplicate,
-          addLabel: params.addLabel,
-          dryRun: params.dryRun,
-          cwd: projectRoot
-        });
+        const result = await importTasks(projectRoot, params);
         return lafsSuccess(result, "import");
       },
       detect: async (_params) => {
@@ -16681,30 +16655,27 @@ var init_admin = __esm({
           if (!tokenId) {
             return lafsError("E_INVALID_INPUT", "tokenId is required", "token.mutate");
           }
-          const result2 = await deleteTokenUsage(tokenId, projectRoot);
+          const result2 = await deleteTokenUsage(projectRoot, { id: tokenId });
           return lafsSuccess(result2, "token.mutate");
         }
         if (action === "clear") {
-          const result2 = await clearTokenUsage(
-            {
-              provider: params.provider,
-              transport: params.transport,
-              gateway: params.gateway,
-              domain: params.domain,
-              operation: params.operationName,
-              sessionId: params.sessionId,
-              taskId: params.taskId,
-              method: params.method,
-              confidence: params.confidence,
-              requestId: params.requestId,
-              since: params.since,
-              until: params.until
-            },
-            projectRoot
-          );
+          const result2 = await clearTokenUsage(projectRoot, {
+            provider: params.provider,
+            transport: params.transport,
+            gateway: params.gateway,
+            domain: params.domain,
+            operation: params.operationName,
+            sessionId: params.sessionId,
+            taskId: params.taskId,
+            method: params.method,
+            confidence: params.confidence,
+            requestId: params.requestId,
+            since: params.since,
+            until: params.until
+          });
           return lafsSuccess(result2, "token.mutate");
         }
-        const result = await recordTokenExchange({
+        const result = await recordTokenExchange(projectRoot, {
           provider: params.provider,
           model: params.model,
           transport: params.transport,
@@ -16716,8 +16687,7 @@ var init_admin = __esm({
           requestId: params.requestId,
           requestPayload: params.requestPayload,
           responsePayload: params.responsePayload,
-          metadata: params.metadata,
-          cwd: projectRoot
+          metadata: params.metadata
         });
         return lafsSuccess(result, "token.mutate");
       },
@@ -17079,12 +17049,26 @@ var init_canon = __esm({
 
 // packages/cleo/src/dispatch/domains/check.ts
 import {
+  checkArchiveStats,
+  checkCoherence,
+  checkComplianceRecord,
+  checkComplianceSummary,
+  checkComplianceSync,
+  checkGradeSession,
+  checkReadGrades,
+  checkRevalidateEvidence,
+  checkTestCoverage,
+  checkTestRun,
+  checkTestStatus,
+  checkValidateChain,
+  checkValidateManifest,
+  checkValidateOutput,
+  checkValidateProtocol,
+  checkValidateSchema,
+  checkValidateTask,
+  checkWorkflowCompliance,
   getLogger as getLogger6,
-  getProjectRoot as getProjectRoot3,
-  getWorkflowComplianceReport,
-  paginate as paginate3,
-  revalidateEvidence,
-  validateChain
+  getProjectRoot as getProjectRoot3
 } from "@cleocode/core/internal";
 var _checkTypedHandler, CheckHandler;
 var init_check = __esm({
@@ -17103,135 +17087,105 @@ var init_check = __esm({
         if (!params.type) {
           return lafsError("E_INVALID_INPUT", "type is required", "schema");
         }
-        const result = await validateSchemaOp(params.type, params.data, projectRoot);
-        if (!result.success) {
-          return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
-            "schema"
-          );
+        try {
+          const result = await checkValidateSchema(projectRoot, params);
+          return lafsSuccess(result, "schema");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const code = message.includes("not found") ? "E_NOT_FOUND" : message.includes("Unknown schema") ? "E_INVALID_TYPE" : message.includes("required") ? "E_INVALID_INPUT" : "E_VALIDATION_ERROR";
+          return lafsError(code, message, "schema");
         }
-        return lafsSuccess(result.data ?? { valid: false, violations: [] }, "schema");
       },
       task: async (params) => {
         const projectRoot = getProjectRoot3();
         if (!params.taskId) {
           return lafsError("E_INVALID_INPUT", "taskId is required", "task");
         }
-        const result = await validateTask(params.taskId, projectRoot);
-        if (!result.success) {
-          return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
-            "task"
-          );
+        try {
+          const result = await checkValidateTask(projectRoot, params);
+          return lafsSuccess(result, "task");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+          return lafsError(code, message, "task");
         }
-        return lafsSuccess(
-          result.data ?? { taskId: params.taskId, valid: false, violations: [], checks: {} },
-          "task"
-        );
       },
-      manifest: async (_params) => {
+      manifest: async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = validateManifest(projectRoot);
-        if (!result.success) {
+        try {
+          const result = checkValidateManifest(projectRoot, params);
+          return lafsSuccess(result, "manifest");
+        } catch (err) {
           return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
+            "E_FILE_ERROR",
+            err instanceof Error ? err.message : String(err),
             "manifest"
           );
         }
-        return lafsSuccess(result.data ?? { valid: false, entry: {}, violations: [] }, "manifest");
       },
       output: async (params) => {
         const projectRoot = getProjectRoot3();
         if (!params.filePath) {
           return lafsError("E_INVALID_INPUT", "filePath is required", "output");
         }
-        const result = validateOutput(params.filePath, params.taskId, projectRoot);
-        if (!result.success) {
-          return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
-            "output"
-          );
+        try {
+          const result = checkValidateOutput(projectRoot, params);
+          return lafsSuccess(result, "output");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+          return lafsError(code, message, "output");
         }
-        return lafsSuccess(
-          result.data ?? { taskId: "", filePath: "", valid: false, checks: {}, violations: [] },
-          "output"
-        );
       },
       "compliance.summary": async (params) => {
         const projectRoot = getProjectRoot3();
-        if (params?.detail) {
-          const result2 = validateComplianceViolations(params.limit, projectRoot);
-          if (!result2.success) {
-            return lafsError(
-              String(result2.error?.code ?? "E_INTERNAL"),
-              result2.error?.message ?? "Unknown error",
-              "compliance.summary"
-            );
-          }
-          return lafsSuccess(result2.data ?? { violations: [], total: 0 }, "compliance.summary");
-        }
-        const result = validateComplianceSummary(projectRoot);
-        if (!result.success) {
+        try {
+          const summary = checkComplianceSummary(projectRoot, params);
+          const enrichedData = {
+            ...summary,
+            view: params.type ?? "summary",
+            ...params.taskId ? { taskId: params.taskId } : {},
+            ...params.days ? { days: params.days } : {},
+            ...params.global ? { global: params.global } : {}
+          };
+          return lafsSuccess(enrichedData, "compliance.summary");
+        } catch (err) {
           return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
+            "E_FILE_ERROR",
+            err instanceof Error ? err.message : String(err),
             "compliance.summary"
           );
         }
-        const data = result.data ?? {};
-        const enrichedData = {
-          ...data,
-          view: params.type ?? "summary",
-          ...params.taskId ? { taskId: params.taskId } : {},
-          ...params.days ? { days: params.days } : {},
-          ...params.global ? { global: params.global } : {}
-        };
-        return lafsSuccess(enrichedData, "compliance.summary");
       },
       test: async (params) => {
         const projectRoot = getProjectRoot3();
         if (params?.format === "coverage") {
-          const result2 = validateTestCoverage(projectRoot);
-          if (!result2.success) {
-            return lafsError(
-              String(result2.error?.code ?? "E_INTERNAL"),
-              result2.error?.message ?? "Unknown error",
-              "test"
-            );
+          try {
+            const result = checkTestCoverage(projectRoot, {});
+            return lafsSuccess(result, "test");
+          } catch (err) {
+            return lafsError("E_FILE_ERROR", err instanceof Error ? err.message : String(err), "test");
           }
-          return lafsSuccess(
-            result2.data ?? { lineCoverage: 0, branchCoverage: 0, functionCoverage: 0, threshold: 0 },
-            "test"
-          );
         }
-        const result = validateTestStatus(projectRoot);
-        if (!result.success) {
-          return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
-            "test"
-          );
+        try {
+          const result = checkTestStatus(projectRoot, params);
+          return lafsSuccess(result, "test");
+        } catch (err) {
+          return lafsError("E_GENERAL", err instanceof Error ? err.message : String(err), "test");
         }
-        return lafsSuccess(
-          result.data ?? { total: 0, passed: 0, failed: 0, skipped: 0, passRate: 0 },
-          "test"
-        );
       },
-      coherence: async (_params) => {
+      coherence: async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = await validateCoherenceCheck(projectRoot);
-        if (!result.success) {
+        try {
+          const result = await checkCoherence(projectRoot, params);
+          return lafsSuccess(result, "coherence");
+        } catch (err) {
           return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
+            "E_NOT_INITIALIZED",
+            err instanceof Error ? err.message : String(err),
             "coherence"
           );
         }
-        return lafsSuccess(result.data ?? { passed: false, issues: [], warnings: [] }, "coherence");
       },
       protocol: async (params) => {
         const projectRoot = getProjectRoot3();
@@ -17462,15 +17416,14 @@ var init_check = __esm({
                 "protocol"
               );
             }
-            const result = await validateProtocol(params.taskId, protocolType, projectRoot);
-            if (!result.success) {
-              return lafsError(
-                String(result.error?.code ?? "E_INTERNAL"),
-                result.error?.message ?? "Unknown error",
-                "protocol"
-              );
+            try {
+              const result = await checkValidateProtocol(projectRoot, params);
+              return lafsSuccess(result, "protocol");
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+              return lafsError(code, message, "protocol");
             }
-            return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
           }
         }
       },
@@ -17549,15 +17502,14 @@ var init_check = __esm({
           let stillValid = true;
           let failedAtoms = [];
           try {
-            const reval = await revalidateEvidence(
-              {
+            const reval = await checkRevalidateEvidence(projectRoot, {
+              evidence: {
                 atoms: normalised.atoms,
                 capturedAt: normalised.capturedAt,
                 capturedBy: normalised.capturedBy,
                 override: normalised.override
-              },
-              projectRoot
-            );
+              }
+            });
             stillValid = reval.stillValid;
             failedAtoms = reval.failedAtoms.map((f) => ({
               kind: f.atom.kind,
@@ -17639,51 +17591,48 @@ var init_check = __esm({
       },
       "archive.stats": async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = await systemArchiveStats(projectRoot, {
-          period: params?.period,
-          report: params?.report,
-          since: params?.since,
-          until: params?.until
-        });
-        if (!result.success) {
+        try {
+          const result = await checkArchiveStats(projectRoot, params);
+          return lafsSuccess(result, "archive.stats");
+        } catch (err) {
           return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
+            "E_NOT_INITIALIZED",
+            err instanceof Error ? err.message : String(err),
             "archive.stats"
           );
         }
-        return lafsSuccess(result.data ?? {}, "archive.stats");
       },
       "chain.validate": async (params) => {
         if (!params.chain) {
           return lafsError("E_INVALID_INPUT", "chain is required", "chain.validate");
         }
-        const chainResult = validateChain(params.chain);
+        const chainResult = checkValidateChain("", params);
         return lafsSuccess(chainResult, "chain.validate");
       },
       grade: async (params) => {
         const projectRoot = getProjectRoot3();
-        const { gradeSession } = await import("@cleocode/core/internal");
         if (!params.sessionId) {
           return lafsError("E_INVALID_INPUT", "sessionId required", "grade");
         }
-        const gradeResult = await gradeSession(params.sessionId, projectRoot);
-        return lafsSuccess(gradeResult, "grade");
+        try {
+          const gradeResult = await checkGradeSession(projectRoot, params);
+          return lafsSuccess(gradeResult, "grade");
+        } catch (err) {
+          return lafsError("E_NOT_FOUND", err instanceof Error ? err.message : String(err), "grade");
+        }
       },
       "grade.list": async (params) => {
         const projectRoot = getProjectRoot3();
-        const { readGrades } = await import("@cleocode/core/internal");
-        const allGrades = await readGrades(void 0, projectRoot);
-        const filteredGrades = params.sessionId ? allGrades.filter((g) => g.sessionId === params.sessionId) : allGrades;
-        const page = paginate3(filteredGrades, params.limit, params.offset);
-        return lafsSuccess(
-          {
-            grades: page.items,
-            total: allGrades.length,
-            filtered: filteredGrades.length
-          },
-          "grade.list"
-        );
+        try {
+          const result = await checkReadGrades(projectRoot, params);
+          return lafsSuccess(result, "grade.list");
+        } catch (err) {
+          return lafsError(
+            "E_NOT_FOUND",
+            err instanceof Error ? err.message : String(err),
+            "grade.list"
+          );
+        }
       },
       canon: async (_params) => {
         const projectRoot = getProjectRoot3();
@@ -17693,11 +17642,16 @@ var init_check = __esm({
       },
       "workflow.compliance": async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = await getWorkflowComplianceReport({
-          since: params.since,
-          cwd: projectRoot
-        });
-        return lafsSuccess(result, "workflow.compliance");
+        try {
+          const result = await checkWorkflowCompliance(projectRoot, params);
+          return lafsSuccess(result, "workflow.compliance");
+        } catch (err) {
+          return lafsError(
+            "E_GENERAL",
+            err instanceof Error ? err.message : String(err),
+            "workflow.compliance"
+          );
+        }
       },
       // -----------------------------------------------------------------------
       // Mutate ops
@@ -17707,66 +17661,51 @@ var init_check = __esm({
         if (!params.taskId || !params.result) {
           return lafsError("E_INVALID_INPUT", "taskId and result are required", "compliance.record");
         }
-        const engineResult = validateComplianceRecord(
-          params.taskId,
-          params.result,
-          params.protocol,
-          params.violations,
-          projectRoot
-        );
-        if (!engineResult.success) {
+        try {
+          const result = checkComplianceRecord(projectRoot, params);
+          return lafsSuccess(result, "compliance.record");
+        } catch (err) {
           return lafsError(
-            String(engineResult.error?.code ?? "E_INTERNAL"),
-            engineResult.error?.message ?? "Unknown error",
+            "E_INVALID_INPUT",
+            err instanceof Error ? err.message : String(err),
             "compliance.record"
           );
         }
-        return lafsSuccess(
-          engineResult.data ?? { taskId: params.taskId, recorded: "" },
-          "compliance.record"
-        );
       },
       "test.run": async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = validateTestRun(
-          { scope: params.scope, pattern: params.pattern, parallel: params.parallel },
-          projectRoot
-        );
-        if (!result.success) {
-          return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
-            "test.run"
-          );
+        try {
+          const result = checkTestRun(projectRoot, params);
+          return lafsSuccess(result, "test.run");
+        } catch (err) {
+          return lafsError("E_GENERAL", err instanceof Error ? err.message : String(err), "test.run");
         }
-        return lafsSuccess(
-          result.data ?? { status: { total: 0, passed: 0, failed: 0, skipped: 0, passRate: 0 } },
-          "test.run"
-        );
       },
-      "test.coverage": async (_params) => {
+      "test.coverage": async (params) => {
         const projectRoot = getProjectRoot3();
-        const result = validateTestCoverage(projectRoot);
-        if (!result.success) {
+        try {
+          const result = checkTestCoverage(projectRoot, params ?? {});
+          return lafsSuccess(result, "test.coverage");
+        } catch (err) {
           return lafsError(
-            String(result.error?.code ?? "E_INTERNAL"),
-            result.error?.message ?? "Unknown error",
+            "E_FILE_ERROR",
+            err instanceof Error ? err.message : String(err),
             "test.coverage"
           );
         }
-        return lafsSuccess(
-          result.data ?? { lineCoverage: 0, branchCoverage: 0, functionCoverage: 0, threshold: 0 },
-          "test.coverage"
-        );
       },
       "compliance.sync": async (params) => {
         const projectRoot = getProjectRoot3();
-        const { syncComplianceMetrics } = await import("@cleocode/core/internal");
-        const result = await syncComplianceMetrics({
-          force: params.force,
-          cwd: projectRoot
-        });
-        return lafsSuccess(result, "compliance.sync");
+        try {
+          const result = await checkComplianceSync(projectRoot, params);
+          return lafsSuccess(result, "compliance.sync");
+        } catch (err) {
+          return lafsError(
+            "E_GENERAL",
+            err instanceof Error ? err.message : String(err),
+            "compliance.sync"
+          );
+        }
       },
       "gate.set": async (params) => {
         const projectRoot = getProjectRoot3();
@@ -21087,7 +21026,7 @@ import {
   nexusSyncAll,
   nexusUnregister,
   orphanDetection,
-  paginate as paginate4,
+  paginate as paginate3,
   previewTransfer,
   nexusReadRegistry as readRegistry,
   readSnapshot as readSnapshot2,
@@ -21117,8 +21056,8 @@ async function nexusStatus() {
 }
 async function nexusListProjects(limit, offset) {
   try {
-    const projects = await nexusList();
-    const page = paginate4(projects, limit, offset);
+    const projects = await nexusList("", {});
+    const page = paginate3(projects, limit, offset);
     return {
       success: true,
       data: {
@@ -21136,7 +21075,7 @@ async function nexusListProjects(limit, offset) {
 }
 async function nexusShowProject(name) {
   try {
-    const project = await nexusGetProject(name);
+    const project = await nexusGetProject("", { name });
     if (!project) {
       return engineError("E_NOT_FOUND", `Project not found: ${name}`);
     }
@@ -21153,7 +21092,7 @@ async function nexusResolve(query, currentProject) {
         `Invalid query syntax: ${query}. Expected: T001, project:T001, .:T001, or *:T001`
       );
     }
-    const result = await resolveTask(query, currentProject);
+    const result = await resolveTask("", { query, currentProject });
     return engineSuccess(result);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21161,7 +21100,7 @@ async function nexusResolve(query, currentProject) {
 }
 async function nexusDepsQuery(query, direction = "forward") {
   try {
-    const result = await nexusDeps(query, direction);
+    const result = await nexusDeps("", { query, direction });
     return engineSuccess(result);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21169,7 +21108,7 @@ async function nexusDepsQuery(query, direction = "forward") {
 }
 async function nexusGraph() {
   try {
-    const graph = await buildGlobalGraph();
+    const graph = await buildGlobalGraph("", {});
     return engineSuccess(graph);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21177,7 +21116,7 @@ async function nexusGraph() {
 }
 async function nexusCriticalPath() {
   try {
-    const path5 = await criticalPath();
+    const path5 = await criticalPath("", {});
     return engineSuccess(path5);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21406,7 +21345,7 @@ async function nexusTopEntries(params) {
 }
 async function nexusBlockers(query) {
   try {
-    const analysis = await blockingAnalysis(query);
+    const analysis = await blockingAnalysis("", { query });
     return engineSuccess(analysis);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21414,8 +21353,8 @@ async function nexusBlockers(query) {
 }
 async function nexusOrphans(limit, offset) {
   try {
-    const orphans = await orphanDetection();
-    const page = paginate4(orphans, limit, offset);
+    const orphans = await orphanDetection("", {});
+    const page = paginate3(orphans, limit, offset);
     return {
       success: true,
       data: {
@@ -21433,7 +21372,7 @@ async function nexusOrphans(limit, offset) {
 }
 async function nexusDiscover(taskQuery, method = "auto", limit = 10) {
   try {
-    const result = await discoverRelated(taskQuery, method, limit);
+    const result = await discoverRelated("", { query: taskQuery, method, limit });
     if ("error" in result) {
       return engineError(result.error.code, result.error.message);
     }
@@ -21444,7 +21383,7 @@ async function nexusDiscover(taskQuery, method = "auto", limit = 10) {
 }
 async function nexusSearch(pattern, projectFilter, limit = 20) {
   try {
-    const result = await searchAcrossProjects(pattern, projectFilter, limit);
+    const result = await searchAcrossProjects("", { pattern, project: projectFilter, limit });
     if ("error" in result) {
       return engineError(
         result.error.code,
@@ -21458,7 +21397,7 @@ async function nexusSearch(pattern, projectFilter, limit = 20) {
 }
 async function nexusInitialize() {
   try {
-    await nexusInit();
+    await nexusInit("", {});
     return engineSuccess({ message: "NEXUS initialized successfully" });
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21466,7 +21405,7 @@ async function nexusInitialize() {
 }
 async function nexusRegisterProject(path5, name, permission = "read") {
   try {
-    const hash = await nexusRegister(path5, name, permission);
+    const hash = await nexusRegister("", { path: path5, name, permission });
     return engineSuccess({ hash, message: `Project registered with hash: ${hash}` });
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21474,7 +21413,7 @@ async function nexusRegisterProject(path5, name, permission = "read") {
 }
 async function nexusUnregisterProject(name) {
   try {
-    await nexusUnregister(name);
+    await nexusUnregister("", { name });
     return engineSuccess({ message: `Project unregistered: ${name}` });
   } catch (error) {
     return cleoErrorToEngineError(error, "E_INTERNAL", `Failed to unregister project: ${name}`);
@@ -21483,7 +21422,7 @@ async function nexusUnregisterProject(name) {
 async function nexusSyncProject(name) {
   try {
     if (name) {
-      await nexusSync(name);
+      await nexusSync("", { name });
       return engineSuccess({ message: `Project synced: ${name}` });
     }
     const result = await nexusSyncAll();
@@ -21494,7 +21433,7 @@ async function nexusSyncProject(name) {
 }
 async function nexusSetPermission(name, level) {
   try {
-    await setPermission(name, level);
+    await setPermission("", { name, level });
     return engineSuccess({ message: `Permission for '${name}' set to '${level}'` });
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21502,7 +21441,7 @@ async function nexusSetPermission(name, level) {
 }
 async function nexusReconcileProject(projectRoot) {
   try {
-    const result = await nexusReconcile(projectRoot);
+    const result = await nexusReconcile(projectRoot, {});
     return engineSuccess(result);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -21510,7 +21449,7 @@ async function nexusReconcileProject(projectRoot) {
 }
 async function nexusShareStatus(projectRoot) {
   try {
-    const result = await getSharingStatus(projectRoot);
+    const result = await getSharingStatus(projectRoot, {});
     return engineSuccess(result);
   } catch (error) {
     return engineError("E_INTERNAL", error instanceof Error ? error.message : String(error));
@@ -27918,8 +27857,8 @@ async function acquireDb() {
 async function buildDefaultDispatcher() {
   if (__playbookRuntimeOverrides.dispatcher) return __playbookRuntimeOverrides.dispatcher;
   const { orchestrateSpawnExecute: orchestrateSpawnExecute2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
-  const { getProjectRoot: getProjectRoot32 } = await import("@cleocode/core/internal");
-  const projectRoot = getProjectRoot32();
+  const { getProjectRoot: getProjectRoot33 } = await import("@cleocode/core/internal");
+  const projectRoot = getProjectRoot33();
   return {
     async dispatch(input) {
       try {
@@ -28272,14 +28211,14 @@ var init_playbook = __esm({
         const dispatcher = await buildDefaultDispatcher();
         let result;
         try {
-          const { getProjectRoot: getProjectRoot32 } = await import("@cleocode/core/internal");
+          const { getProjectRoot: getProjectRoot33 } = await import("@cleocode/core/internal");
           const opts = {
             db,
             playbook: parsed.definition,
             playbookHash: parsed.sourceHash,
             initialContext,
             dispatcher,
-            projectRoot: getProjectRoot32()
+            projectRoot: getProjectRoot33()
           };
           if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
             opts.approvalSecret = __playbookRuntimeOverrides.approvalSecret;
@@ -28436,14 +28375,14 @@ import {
   getProjectRoot as getProjectRoot9,
   instantiateTessera,
   listTesseraTemplates,
-  paginate as paginate5,
+  paginate as paginate4,
   showTessera
 } from "@cleocode/core/internal";
 async function orchestrateClassify(request, context, projectRoot) {
   try {
     const { getCleoCantWorkflowsDir: getCleoCantWorkflowsDir2 } = await import("@cleocode/core/internal");
     const { readFileSync: readFileSync16, readdirSync: readdirSync4, existsSync: existsSync12 } = await import("node:fs");
-    const { join: join23 } = await import("node:path");
+    const { join: join22 } = await import("node:path");
     const workflowsDir = getCleoCantWorkflowsDir2();
     const combined = `${request} ${context ?? ""}`.toLowerCase();
     const matches = [];
@@ -28451,7 +28390,7 @@ async function orchestrateClassify(request, context, projectRoot) {
       const files = readdirSync4(workflowsDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync16(join23(workflowsDir, file), "utf-8");
+          const src = readFileSync16(join22(workflowsDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -28466,12 +28405,12 @@ async function orchestrateClassify(request, context, projectRoot) {
         }
       }
     }
-    const localCantDir = join23(projectRoot, CLEO_DIR_NAME, WORKFLOWS_SUBDIR);
+    const localCantDir = join22(projectRoot, CLEO_DIR_NAME, WORKFLOWS_SUBDIR);
     if (existsSync12(localCantDir)) {
       const files = readdirSync4(localCantDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync16(join23(localCantDir, file), "utf-8");
+          const src = readFileSync16(join22(localCantDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -29102,7 +29041,7 @@ var init_orchestrate2 = __esm({
               }
               const templates2 = listTesseraTemplates();
               const { limit, offset } = getListParams(params);
-              const page = paginate5(templates2, limit, offset);
+              const page = paginate4(templates2, limit, offset);
               return {
                 meta: dispatchMeta("query", "orchestrate", "tessera.list", startTime),
                 success: true,
@@ -29494,7 +29433,7 @@ import {
   getProjectRoot as getProjectRoot10,
   isValidStage,
   listChains,
-  paginate as paginate6,
+  paginate as paginate5,
   resolveChannelFromBranch as resolveChannelFromBranch2,
   showChain
 } from "@cleocode/core/internal";
@@ -30110,7 +30049,7 @@ var init_pipeline2 = __esm({
             const phases = listData.phases ?? [];
             const total = listData.summary?.total ?? phases.length;
             const { limit, offset } = getListParams(params);
-            const page = paginate6(phases, limit, offset);
+            const page = paginate5(phases, limit, offset);
             return {
               meta: dispatchMeta("query", "pipeline", "phase.list", startTime),
               success: true,
@@ -30310,7 +30249,7 @@ var init_pipeline2 = __esm({
           case "list": {
             const chains = await listChains(this.projectRoot);
             const { limit, offset } = getListParams(params);
-            const page = paginate6(chains, limit, offset);
+            const page = paginate5(chains, limit, offset);
             return wrapResult(
               {
                 success: true,
@@ -30616,8 +30555,19 @@ var init_release2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/sentient.ts
-import { join as join6 } from "node:path";
 import { getProjectRoot as getProjectRoot12 } from "@cleocode/core";
+import {
+  sentientAllowlistAdd,
+  sentientAllowlistList,
+  sentientAllowlistRemove,
+  sentientProposeAccept,
+  sentientProposeDiff,
+  sentientProposeDisable,
+  sentientProposeEnable,
+  sentientProposeList,
+  sentientProposeReject,
+  sentientProposeRun
+} from "@cleocode/core/sentient";
 function envelopeToEngineResult3(envelope) {
   if (envelope.success) {
     return { success: true, data: envelope.data };
@@ -30630,324 +30580,122 @@ function envelopeToEngineResult3(envelope) {
     }
   };
 }
-async function listProposals(projectRoot, params) {
-  const { getDb: getDb3 } = await import("@cleocode/core/internal");
-  const { tasks } = await import("@cleocode/core/store/tasks-schema");
-  const { and, eq: eq2, like } = await import("drizzle-orm");
-  const db = await getDb3(projectRoot);
-  const limit = params.limit && params.limit > 0 ? params.limit : 50;
-  const rows = await db.select().from(tasks).where(and(eq2(tasks.status, "proposed"), like(tasks.labelsJson, `%${TIER2_LABEL}%`))).limit(limit).all();
-  const proposals = rows.map((row) => ({
-    id: row.id,
-    title: row.title,
-    description: row.description,
-    status: row.status,
-    priority: row.priority,
-    labels: safeParseJsonArray(row.labelsJson),
-    createdAt: row.createdAt,
-    meta: safeParseProposalMeta(row.notesJson)
-  }));
-  proposals.sort((a, b) => {
-    const wa = typeof a.meta?.weight === "number" ? a.meta.weight : 0;
-    const wb = typeof b.meta?.weight === "number" ? b.meta.weight : 0;
-    return wb - wa;
-  });
-  return { success: true, data: { proposals, total: proposals.length } };
-}
-async function acceptProposal(projectRoot, id) {
-  const { getDb: getDb3 } = await import("@cleocode/core/internal");
-  const { tasks } = await import("@cleocode/core/store/tasks-schema");
-  const { and, eq: eq2, like } = await import("drizzle-orm");
-  const db = await getDb3(projectRoot);
-  const existing = await db.select().from(tasks).where(
-    and(
-      eq2(tasks.id, id),
-      eq2(tasks.status, "proposed"),
-      like(tasks.labelsJson, `%${TIER2_LABEL}%`)
-    )
-  ).get();
-  if (!existing) {
-    return {
-      success: false,
-      error: {
-        code: "E_NOT_FOUND",
-        message: `Task ${id} is not a pending proposal (status must be 'proposed' with label '${TIER2_LABEL}')`
-      }
-    };
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(tasks).set({ status: "pending", updatedAt: now }).where(eq2(tasks.id, id)).run();
-  await incrementTier2Stat(projectRoot, "proposalsAccepted");
-  return { success: true, data: { id, status: "pending", acceptedAt: now } };
-}
-async function rejectProposal(projectRoot, id, reason) {
-  const { getDb: getDb3 } = await import("@cleocode/core/internal");
-  const { tasks } = await import("@cleocode/core/store/tasks-schema");
-  const { and, eq: eq2, like } = await import("drizzle-orm");
-  const db = await getDb3(projectRoot);
-  const existing = await db.select().from(tasks).where(
-    and(
-      eq2(tasks.id, id),
-      eq2(tasks.status, "proposed"),
-      like(tasks.labelsJson, `%${TIER2_LABEL}%`)
-    )
-  ).get();
-  if (!existing) {
-    return {
-      success: false,
-      error: {
-        code: "E_NOT_FOUND",
-        message: `Task ${id} is not a pending proposal (status must be 'proposed' with label '${TIER2_LABEL}')`
-      }
-    };
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(tasks).set({
-    status: "cancelled",
-    cancellationReason: reason,
-    cancelledAt: now,
-    updatedAt: now
-  }).where(eq2(tasks.id, id)).run();
-  await incrementTier2Stat(projectRoot, "proposalsRejected");
-  return { success: true, data: { id, status: "cancelled", rejectedAt: now, reason } };
-}
-async function runProposeTick(projectRoot) {
-  const { safeRunProposeTick: safeRunProposeTick2 } = await import("@cleocode/core/sentient/propose-tick.js");
-  const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-  const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
-  const outcome = await safeRunProposeTick2({ projectRoot, statePath });
-  return { success: true, data: { outcome } };
-}
-async function listAllowlist(projectRoot) {
-  const { getOwnerPubkeys } = await import("@cleocode/core/sentient/allowlist.js");
-  const pubkeys = await getOwnerPubkeys(projectRoot, { noCache: true });
-  const b64List = pubkeys.map((k) => Buffer.from(k).toString("base64"));
-  return { success: true, data: { ownerPubkeys: b64List, count: b64List.length } };
-}
-async function addAllowlistKey(projectRoot, pubkeyBase64) {
-  try {
-    const { addOwnerPubkey } = await import("@cleocode/core/sentient/allowlist.js");
-    await addOwnerPubkey(projectRoot, pubkeyBase64);
-    return { success: true, data: { added: pubkeyBase64 } };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { success: false, error: { code: "E_ALLOWLIST_ADD", message } };
-  }
-}
-async function removeAllowlistKey(projectRoot, pubkeyBase64) {
-  try {
-    const { removeOwnerPubkey } = await import("@cleocode/core/sentient/allowlist.js");
-    await removeOwnerPubkey(projectRoot, pubkeyBase64);
-    return { success: true, data: { removed: pubkeyBase64 } };
-  } catch (err) {
-    const code = err.code === "E_ALLOWLIST_KEY_NOT_FOUND" ? "E_ALLOWLIST_KEY_NOT_FOUND" : "E_ALLOWLIST_REMOVE";
-    const message = err instanceof Error ? err.message : String(err);
-    return { success: false, error: { code, message } };
-  }
-}
-async function setTier2Enabled(projectRoot, enabled) {
-  if (enabled) {
-    try {
-      const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
-      const doctorResult = await scanBrainNoise(projectRoot);
-      if (!doctorResult.isClean) {
-        return {
-          success: false,
-          error: {
-            code: "E_M7_GATE_FAILED",
-            message: `M7 gate blocked: brain corpus has ${doctorResult.findings.length} noise pattern(s) across ${doctorResult.totalScanned} entries. Run \`cleo memory doctor\` for details, then \`cleo memory sweep --approve\` to clean before enabling Sentient v1.`,
-            details: { findings: doctorResult.findings, totalScanned: doctorResult.totalScanned }
-          }
-        };
-      }
-    } catch {
-    }
-  }
-  const { patchSentientState: patchSentientState2 } = await import("@cleocode/core/sentient/state.js");
-  const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-  const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
-  const updated = await patchSentientState2(statePath, { tier2Enabled: enabled });
-  return {
-    success: true,
-    data: {
-      tier2Enabled: updated.tier2Enabled,
-      message: enabled ? "Tier-2 proposals enabled" : "Tier-2 proposals disabled"
-    }
-  };
-}
-function safeParseJsonArray(json2) {
-  if (!json2) return [];
-  try {
-    const parsed = JSON.parse(json2);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function safeParseProposalMeta(notesJson) {
-  if (!notesJson) return null;
-  try {
-    const notes = JSON.parse(notesJson);
-    if (!Array.isArray(notes) || notes.length === 0) return null;
-    const first = notes[0];
-    if (typeof first !== "string") return null;
-    const meta = JSON.parse(first);
-    if (meta.kind === "proposal-meta") return meta;
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function incrementTier2Stat(projectRoot, field) {
-  try {
-    const { patchSentientState: patchSentientState2, readSentientState: readSentientState2 } = await import("@cleocode/core/sentient/state.js");
-    const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-    const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
-    const state = await readSentientState2(statePath);
-    await patchSentientState2(statePath, {
-      tier2Stats: {
-        ...state.tier2Stats,
-        [field]: state.tier2Stats[field] + 1
-      }
-    });
-  } catch {
-  }
-}
-var TIER2_LABEL, _sentientTypedHandler, QUERY_OPS4, MUTATE_OPS4, SentientHandler;
+var _sentientTypedHandler, QUERY_OPS4, MUTATE_OPS4, SentientHandler;
 var init_sentient2 = __esm({
   "packages/cleo/src/dispatch/domains/sentient.ts"() {
     "use strict";
     init_typed();
     init_base();
-    TIER2_LABEL = "sentient-tier2";
     _sentientTypedHandler = defineTypedHandler("sentient", {
       // -------------------------------------------------------------------------
       // Query ops
       // -------------------------------------------------------------------------
       "propose.list": async (params) => {
         const projectRoot = getProjectRoot12();
-        const result = await listProposals(projectRoot, params);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.list"
-          );
+        try {
+          const data = await sentientProposeList(projectRoot, params);
+          return lafsSuccess(data, "propose.list");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_INTERNAL", message, "propose.list");
         }
-        return lafsSuccess(result.data ?? { proposals: [], total: 0 }, "propose.list");
       },
       "propose.diff": async (params) => {
-        return lafsSuccess(
-          {
-            id: params.id,
-            diff: null,
-            message: "Content diff is a Tier-3 feature (blocked on T992+T993+T995). This proposal is a task-creation suggestion; no diff is available."
-          },
-          "propose.diff"
-        );
+        const projectRoot = getProjectRoot12();
+        try {
+          const data = await sentientProposeDiff(projectRoot, params);
+          return lafsSuccess(data, "propose.diff");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_INTERNAL", message, "propose.diff");
+        }
       },
       "allowlist.list": async (_params) => {
         const projectRoot = getProjectRoot12();
-        const result = await listAllowlist(projectRoot);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "allowlist.list"
-          );
+        try {
+          const data = await sentientAllowlistList(projectRoot, _params);
+          return lafsSuccess(data, "allowlist.list");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_INTERNAL", message, "allowlist.list");
         }
-        return lafsSuccess(result.data ?? { ownerPubkeys: [], count: 0 }, "allowlist.list");
       },
       // -------------------------------------------------------------------------
       // Mutate ops
       // -------------------------------------------------------------------------
       "propose.accept": async (params) => {
         const projectRoot = getProjectRoot12();
-        const result = await acceptProposal(projectRoot, params.id);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.accept"
-          );
+        try {
+          const data = await sentientProposeAccept(projectRoot, params);
+          return lafsSuccess(data, "propose.accept");
+        } catch (err) {
+          const code = err.code ?? "E_INTERNAL";
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError(code, message, "propose.accept");
         }
-        return lafsSuccess(result.data ?? { id: "", status: "", acceptedAt: "" }, "propose.accept");
       },
       "propose.reject": async (params) => {
         const projectRoot = getProjectRoot12();
-        const reason = params.reason ?? "rejected by owner";
-        const result = await rejectProposal(projectRoot, params.id, reason);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.reject"
-          );
+        try {
+          const data = await sentientProposeReject(projectRoot, params);
+          return lafsSuccess(data, "propose.reject");
+        } catch (err) {
+          const code = err.code ?? "E_INTERNAL";
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError(code, message, "propose.reject");
         }
-        return lafsSuccess(
-          result.data ?? { id: "", status: "", rejectedAt: "", reason: "" },
-          "propose.reject"
-        );
       },
       "propose.run": async (_params) => {
         const projectRoot = getProjectRoot12();
-        const result = await runProposeTick(projectRoot);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.run"
-          );
+        try {
+          const data = await sentientProposeRun(projectRoot, _params);
+          return lafsSuccess(data, "propose.run");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_INTERNAL", message, "propose.run");
         }
-        return lafsSuccess(result.data ?? { outcome: null }, "propose.run");
       },
       "propose.enable": async (_params) => {
         const projectRoot = getProjectRoot12();
-        const result = await setTier2Enabled(projectRoot, true);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.enable"
-          );
+        try {
+          const data = await sentientProposeEnable(projectRoot, _params);
+          return lafsSuccess(data, "propose.enable");
+        } catch (err) {
+          const code = err.code ?? "E_INTERNAL";
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError(code, message, "propose.enable");
         }
-        return lafsSuccess(result.data ?? { tier2Enabled: false, message: "" }, "propose.enable");
       },
       "propose.disable": async (_params) => {
         const projectRoot = getProjectRoot12();
-        const result = await setTier2Enabled(projectRoot, false);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "propose.disable"
-          );
+        try {
+          const data = await sentientProposeDisable(projectRoot, _params);
+          return lafsSuccess(data, "propose.disable");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_INTERNAL", message, "propose.disable");
         }
-        return lafsSuccess(result.data ?? { tier2Enabled: true, message: "" }, "propose.disable");
       },
       "allowlist.add": async (params) => {
         const projectRoot = getProjectRoot12();
-        const result = await addAllowlistKey(projectRoot, params.pubkey);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "allowlist.add"
-          );
+        try {
+          const data = await sentientAllowlistAdd(projectRoot, params);
+          return lafsSuccess(data, "allowlist.add");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError("E_ALLOWLIST_ADD", message, "allowlist.add");
         }
-        return lafsSuccess(result.data ?? { added: "" }, "allowlist.add");
       },
       "allowlist.remove": async (params) => {
         const projectRoot = getProjectRoot12();
-        const result = await removeAllowlistKey(projectRoot, params.pubkey);
-        if (!result.success) {
-          return lafsError(
-            result.error?.code ?? "E_INTERNAL",
-            result.error?.message ?? "Unknown error",
-            "allowlist.remove"
-          );
+        try {
+          const data = await sentientAllowlistRemove(projectRoot, params);
+          return lafsSuccess(data, "allowlist.remove");
+        } catch (err) {
+          const code = err.code === "E_ALLOWLIST_KEY_NOT_FOUND" ? "E_ALLOWLIST_KEY_NOT_FOUND" : "E_ALLOWLIST_REMOVE";
+          const message = err instanceof Error ? err.message : String(err);
+          return lafsError(code, message, "allowlist.remove");
         }
-        return lafsSuccess(result.data ?? { removed: "" }, "allowlist.remove");
       }
     });
     QUERY_OPS4 = /* @__PURE__ */ new Set(["propose.list", "propose.diff", "allowlist.list"]);
@@ -30961,9 +30709,6 @@ var init_sentient2 = __esm({
       "allowlist.remove"
     ]);
     SentientHandler = class {
-      // -----------------------------------------------------------------------
-      // Supported operations
-      // -----------------------------------------------------------------------
       /** Declared operations for introspection and validation. */
       getSupportedOperations() {
         return {
@@ -30979,9 +30724,6 @@ var init_sentient2 = __esm({
           ]
         };
       }
-      // -----------------------------------------------------------------------
-      // Query
-      // -----------------------------------------------------------------------
       /**
        * Execute a read-only sentient query operation.
        *
@@ -31010,9 +30752,6 @@ var init_sentient2 = __esm({
           return handleErrorResult("query", "sentient", operation, error, startTime);
         }
       }
-      // -----------------------------------------------------------------------
-      // Mutate
-      // -----------------------------------------------------------------------
       /**
        * Execute a state-modifying sentient mutation operation.
        *
@@ -31274,7 +31013,7 @@ var init_session3 = __esm({
           scope: params.scope,
           name: params.name,
           autoStart: params.autoStart,
-          startTask: params.startTask ?? params.focus,
+          startTask: params.startTask,
           grade: params.grade
         });
         if (!result.success) {
@@ -31678,7 +31417,7 @@ var init_sticky_engine = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/sticky.ts
-import { getLogger as getLogger15, getProjectRoot as getProjectRoot14, paginate as paginate7 } from "@cleocode/core";
+import { getLogger as getLogger15, getProjectRoot as getProjectRoot14, paginate as paginate6 } from "@cleocode/core";
 var StickyHandler;
 var init_sticky = __esm({
   "packages/cleo/src/dispatch/domains/sticky.ts"() {
@@ -31715,7 +31454,7 @@ var init_sticky = __esm({
               }
               const limit = params?.limit;
               const offset = params?.offset;
-              const page = paginate7(filteredStickies, limit, offset);
+              const page = paginate6(filteredStickies, limit, offset);
               return {
                 meta: dispatchMeta("query", "sticky", operation, startTime),
                 success: true,
@@ -32227,7 +31966,7 @@ var init_tasks3 = __esm({
         const result = await taskCreate(projectRoot, {
           title: params.title,
           description: typeof params.description === "string" ? params.description : void 0,
-          parent: params.parent ?? params.parentId,
+          parent: params.parent,
           depends: params.depends,
           priority: params.priority,
           labels: params.labels,
@@ -32239,8 +31978,8 @@ var init_tasks3 = __esm({
           files: params.files,
           dryRun: params.dryRun,
           parentSearch: params.parentSearch,
-          // T944: orthogonal axes — role accepts 'kind' alias for CLI compat
-          role: params.role ?? params.kind,
+          // T944: orthogonal axes — role is the canonical wire field (ADR-057 D2)
+          role: params.role,
           scope: params.scope,
           severity: params.severity
         });
@@ -32260,7 +31999,7 @@ var init_tasks3 = __esm({
           description: params.description,
           status: params.status,
           priority: params.priority,
-          notes: params.notes ?? params.note,
+          notes: params.notes,
           labels: params.labels,
           addLabels: params.addLabels,
           removeLabels: params.removeLabels,
@@ -32268,7 +32007,8 @@ var init_tasks3 = __esm({
           addDepends: params.addDepends,
           removeDepends: params.removeDepends,
           acceptance: params.acceptance,
-          parent: params.parent ?? params.parentId,
+          // ADR-057 D2: canonical wire field — no alias fallback
+          parent: params.parent,
           type: params.type,
           size: params.size,
           // T1014: wire --files through dispatch to engine (parity with add).
@@ -32674,7 +32414,7 @@ var init_tasks3 = __esm({
 });
 
 // packages/cleo/src/dispatch/engines/code-engine.ts
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 import { getProjectRoot as getProjectRoot16 } from "@cleocode/core";
 async function codeOutline(params) {
   const { smartOutline } = await import("@cleocode/core/internal");
@@ -32685,7 +32425,7 @@ async function codeOutline(params) {
       error: { code: "E_INVALID_INPUT", message: "file parameter required" }
     };
   const root = getProjectRoot16();
-  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
   return { success: true, data: smartOutline(absPath, root) };
 }
 async function codeSearch(params) {
@@ -32717,7 +32457,7 @@ async function codeUnfold(params) {
       error: { code: "E_INVALID_INPUT", message: "file and symbol parameters required" }
     };
   const root = getProjectRoot16();
-  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
   return { success: true, data: smartUnfold(absPath, symbol, root) };
 }
 async function codeParse(params) {
@@ -32729,7 +32469,7 @@ async function codeParse(params) {
       error: { code: "E_INVALID_INPUT", message: "file parameter required" }
     };
   const root = getProjectRoot16();
-  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
   return { success: true, data: parseFile(absPath, root) };
 }
 var init_code_engine = __esm({
@@ -32755,7 +32495,7 @@ import {
   installSkill,
   removeSkill
 } from "@cleocode/caamp";
-import { AdapterManager, collectDiagnostics, paginate as paginate8 } from "@cleocode/core/internal";
+import { AdapterManager, collectDiagnostics, paginate as paginate7 } from "@cleocode/core/internal";
 function toolsIssueDiagnostics() {
   try {
     const diag = collectDiagnostics();
@@ -32767,7 +32507,7 @@ function toolsIssueDiagnostics() {
 async function toolsSkillList(limit, offset) {
   try {
     const skills = await discoverSkills(getCanonicalSkillsDir());
-    const page = paginate8(skills, limit, offset);
+    const page = paginate7(skills, limit, offset);
     return {
       success: true,
       data: {
@@ -32888,7 +32628,7 @@ function toolsSkillCatalogProtocols(limit, offset) {
       name,
       path: catalog.getProtocolPath(name) ?? null
     }));
-    const page = paginate8(details, limit, offset);
+    const page = paginate7(details, limit, offset);
     return {
       success: true,
       data: {
@@ -32917,7 +32657,7 @@ function toolsSkillCatalogProfiles(limit, offset) {
         skills: profile?.skills ?? []
       };
     });
-    const page = paginate8(profiles, limit, offset);
+    const page = paginate7(profiles, limit, offset);
     return {
       success: true,
       data: {
@@ -32940,7 +32680,7 @@ function toolsSkillCatalogResources(limit, offset) {
       name,
       path: catalog.getSharedResourcePath(name) ?? null
     }));
-    const page = paginate8(details, limit, offset);
+    const page = paginate7(details, limit, offset);
     return {
       success: true,
       data: {
@@ -33091,7 +32831,7 @@ async function toolsSkillRefresh(projectRoot) {
 function toolsProviderList(limit, offset) {
   try {
     const providers = getAllProviders();
-    const page = paginate8(providers, limit, offset);
+    const page = paginate7(providers, limit, offset);
     return {
       success: true,
       data: {
@@ -33901,7 +33641,7 @@ var init_defaults = __esm({
 
 // packages/cleo/src/dispatch/lib/config-loader.ts
 import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 function loadFromEnv(key) {
   const envKey = `${ENV_PREFIX}${key.toUpperCase()}`;
   return process.env[envKey];
@@ -33922,7 +33662,7 @@ function parseEnvValue(key, value) {
 }
 function loadFromFile(projectRoot) {
   const root = projectRoot || process.cwd();
-  const configPath = join8(root, CLEO_DIR_NAME, CONFIG_JSON);
+  const configPath = join7(root, CLEO_DIR_NAME, CONFIG_JSON);
   if (!existsSync4(configPath)) {
     return {};
   }
@@ -34270,11 +34010,11 @@ var init_security = __esm({
 });
 
 // packages/cleo/src/dispatch/middleware/sanitizer.ts
-function createSanitizer(getProjectRoot32) {
+function createSanitizer(getProjectRoot33) {
   return async (req, next) => {
     if (req.params) {
       try {
-        const root = getProjectRoot32 ? getProjectRoot32() : void 0;
+        const root = getProjectRoot33 ? getProjectRoot33() : void 0;
         req.params = sanitizeParams(req.params, root, {
           domain: req.domain,
           operation: req.operation
@@ -34396,7 +34136,7 @@ __export(cli_exports, {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { catalog as catalog2, registerSkillLibraryFromPath } from "@cleocode/caamp";
 import { autoRecordDispatchTokenUsage, getProjectRoot as getProjectRoot18, hooks } from "@cleocode/core/internal";
@@ -34408,16 +34148,16 @@ function ensureCaampLibrary() {
       const req = createRequire2(import.meta.url);
       const skillsPkgJson = req.resolve("@cleocode/skills/package.json");
       const candidate = dirname4(skillsPkgJson);
-      if (existsSync5(join9(candidate, "skills.json"))) {
+      if (existsSync5(join8(candidate, "skills.json"))) {
         skillsRoot = candidate;
       }
     } catch {
     }
     if (!skillsRoot) {
       const thisFile = fileURLToPath2(import.meta.url);
-      const packageRoot = join9(dirname4(thisFile), "..", "..", "..", "..", "..");
-      const candidate = join9(packageRoot, "packages", "skills");
-      if (existsSync5(join9(candidate, "skills.json"))) {
+      const packageRoot = join8(dirname4(thisFile), "..", "..", "..", "..", "..");
+      const candidate = join8(packageRoot, "packages", "skills");
+      if (existsSync5(join8(candidate, "skills.json"))) {
         skillsRoot = candidate;
       }
     }
@@ -34637,7 +34377,7 @@ var init_cli = __esm({
 
 // packages/cleo/src/cli/index.ts
 import { readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname10, join as join22 } from "node:path";
+import { dirname as dirname10, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
   detectAndRemoveLegacyGlobalFiles,
@@ -34646,7 +34386,7 @@ import {
   ensureGlobalSignaldockDb as ensureGlobalSignaldockDb2,
   getGlobalSalt,
   getLogger as getLogger19,
-  getProjectRoot as getProjectRoot31,
+  getProjectRoot as getProjectRoot32,
   migrateSignaldockToConduit,
   needsSignaldockToConduitMigration,
   validateGlobalSalt
@@ -35656,7 +35396,8 @@ var addCommand = defineCommand({
     if (args["dry-run"] !== void 0) params["dryRun"] = args["dry-run"];
     if (args["parent-search"] !== void 0) params["parentSearch"] = args["parent-search"];
     if (args.role !== void 0) params["role"] = args.role;
-    if (args.kind !== void 0) params["kind"] = args.kind;
+    if (args.kind !== void 0)
+      params["role"] = params["role"] ?? args.kind;
     if (args.scope !== void 0) params["scope"] = args.scope;
     if (args.severity !== void 0) params["severity"] = args.severity;
     if (!params["parent"] && params["type"] !== "epic") {
@@ -36373,9 +36114,9 @@ var registerCommand = defineCommand({
         isActive: true
       });
       const { existsSync: existsSync12, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("node:fs");
-      const { join: join23 } = await import("node:path");
-      const cantDir = join23(CLEO_DIR_NAME, AGENTS_SUBDIR);
-      const cantPath = join23(cantDir, `${agentId}.cant`);
+      const { join: join22 } = await import("node:path");
+      const cantDir = join22(CLEO_DIR_NAME, AGENTS_SUBDIR);
+      const cantPath = join22(cantDir, `${agentId}.cant`);
       let cantScaffolded = false;
       if (!existsSync12(cantPath)) {
         mkdirSync5(cantDir, { recursive: true });
@@ -36557,7 +36298,7 @@ var startCommand = defineCommand({
       const { AgentRegistryAccessor, getDb: getDb3 } = await import("@cleocode/core/internal");
       const { createRuntime } = await import("@cleocode/runtime");
       const { existsSync: existsSync12, readFileSync: readFileSync16 } = await import("node:fs");
-      const { join: join23 } = await import("node:path");
+      const { join: join22 } = await import("node:path");
       await getDb3();
       const registry = new AgentRegistryAccessor(process.cwd());
       const credential = await registry.get(args.agentId);
@@ -36577,7 +36318,7 @@ var startCommand = defineCommand({
       }
       let profile = null;
       let cantValidation = null;
-      const cantPath = args.cant ?? join23(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
+      const cantPath = args.cant ?? join22(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
       if (existsSync12(cantPath)) {
         profile = readFileSync16(cantPath, "utf-8");
         try {
@@ -37103,7 +36844,7 @@ var workCommand = defineCommand({
       const { AgentRegistryAccessor, getDb: getDb3 } = await import("@cleocode/core/internal");
       const { createRuntime } = await import("@cleocode/runtime");
       const { existsSync: existsSync12 } = await import("node:fs");
-      const { join: join23 } = await import("node:path");
+      const { join: join22 } = await import("node:path");
       const { execFile: execFile2 } = await import("node:child_process");
       const { promisify: promisify2 } = await import("node:util");
       const execFileAsync = promisify2(execFile2);
@@ -37123,7 +36864,7 @@ var workCommand = defineCommand({
       }
       await registry.update(args.agentId, { isActive: true });
       await registry.markUsed(args.agentId);
-      const cantPath = join23(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
+      const cantPath = join22(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
       const hasProfile = existsSync12(cantPath);
       const runtime = await createRuntime(registry, {
         agentId: args.agentId,
@@ -37975,7 +37716,7 @@ var installCommand = defineCommand({
     let tempDir = null;
     try {
       const { existsSync: existsSync12, mkdirSync: mkdirSync5, statSync, readdirSync: readdirSync4, copyFileSync } = await import("node:fs");
-      const { join: join23, basename: basename2, resolve: resolve5, extname } = await import("node:path");
+      const { join: join22, basename: basename2, resolve: resolve5, extname } = await import("node:path");
       const { tmpdir } = await import("node:os");
       const resolvedPath = resolve5(args.path);
       if (!existsSync12(resolvedPath)) {
@@ -37999,7 +37740,7 @@ var installCommand = defineCommand({
         cantPath = resolvedPath;
       } else if (stat2.isFile() && ext === ".cantz") {
         const { execFileSync: execFileSync7 } = await import("node:child_process");
-        tempDir = join23(tmpdir(), `cleo-agent-install-${Date.now()}`);
+        tempDir = join22(tmpdir(), `cleo-agent-install-${Date.now()}`);
         mkdirSync5(tempDir, { recursive: true });
         try {
           execFileSync7("unzip", ["-o", "-q", resolvedPath, "-d", tempDir], {
@@ -38021,7 +37762,7 @@ var installCommand = defineCommand({
           return;
         }
         const topLevel = readdirSync4(tempDir).filter(
-          (entry) => statSync(join23(tempDir, entry)).isDirectory()
+          (entry) => statSync(join22(tempDir, entry)).isDirectory()
         );
         if (topLevel.length !== 1) {
           cliOutput(
@@ -38038,7 +37779,7 @@ var installCommand = defineCommand({
           return;
         }
         const agentName = topLevel[0];
-        const personaPath = join23(tempDir, agentName, "persona.cant");
+        const personaPath = join22(tempDir, agentName, "persona.cant");
         if (!existsSync12(personaPath)) {
           cliOutput(
             {
@@ -38053,11 +37794,11 @@ var installCommand = defineCommand({
           process.exitCode = 6;
           return;
         }
-        cantPath = join23(tempDir, `${agentName}.cant`);
+        cantPath = join22(tempDir, `${agentName}.cant`);
         copyFileSync(personaPath, cantPath);
       } else if (stat2.isDirectory()) {
         const agentName = basename2(resolvedPath);
-        const personaPath = join23(resolvedPath, "persona.cant");
+        const personaPath = join22(resolvedPath, "persona.cant");
         if (!existsSync12(personaPath)) {
           cliOutput(
             {
@@ -38072,9 +37813,9 @@ var installCommand = defineCommand({
           process.exitCode = 6;
           return;
         }
-        tempDir = join23(tmpdir(), `cleo-agent-install-${Date.now()}`);
+        tempDir = join22(tmpdir(), `cleo-agent-install-${Date.now()}`);
         mkdirSync5(tempDir, { recursive: true });
-        cantPath = join23(tempDir, `${agentName}.cant`);
+        cantPath = join22(tempDir, `${agentName}.cant`);
         copyFileSync(personaPath, cantPath);
       } else {
         cliOutput(
@@ -38219,8 +37960,8 @@ var packCommand = defineCommand({
         process.exitCode = 4;
         return;
       }
-      const { join: join23 } = await import("node:path");
-      const personaPath = join23(resolvedDir, "persona.cant");
+      const { join: join22 } = await import("node:path");
+      const personaPath = join22(resolvedDir, "persona.cant");
       if (!existsSync12(personaPath)) {
         cliOutput(
           {
@@ -38268,7 +38009,7 @@ var packCommand = defineCommand({
           if (entry.isFile()) {
             fileCount++;
           } else if (entry.isDirectory()) {
-            countFiles(join23(dirPath, entry.name));
+            countFiles(join22(dirPath, entry.name));
           }
         }
       };
@@ -38338,7 +38079,7 @@ var createCommand = defineCommand({
   async run({ args }) {
     try {
       const { existsSync: existsSync12, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("node:fs");
-      const { join: join23 } = await import("node:path");
+      const { join: join22 } = await import("node:path");
       const { homedir: homedir6 } = await import("node:os");
       const name = args.name;
       const role = args.role;
@@ -38398,12 +38139,12 @@ var createCommand = defineCommand({
       let targetRoot;
       if (isGlobal) {
         const home = homedir6();
-        const xdgData = process.env["XDG_DATA_HOME"] ?? join23(home, ".local", "share");
-        targetRoot = join23(xdgData, "cleo", "cant", "agents");
+        const xdgData = process.env["XDG_DATA_HOME"] ?? join22(home, ".local", "share");
+        targetRoot = join22(xdgData, "cleo", "cant", "agents");
       } else {
-        targetRoot = join23(process.cwd(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
+        targetRoot = join22(process.cwd(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
       }
-      const agentDir = join23(targetRoot, name);
+      const agentDir = join22(targetRoot, name);
       if (existsSync12(agentDir)) {
         cliOutput(
           {
@@ -38428,29 +38169,29 @@ var createCommand = defineCommand({
         domain,
         parent
       });
-      writeFileSync5(join23(agentDir, "persona.cant"), personaContent, "utf-8");
+      writeFileSync5(join22(agentDir, "persona.cant"), personaContent, "utf-8");
       const manifest = generateManifest({ name, role, tier, domain });
       writeFileSync5(
-        join23(agentDir, "manifest.json"),
+        join22(agentDir, "manifest.json"),
         `${JSON.stringify(manifest, null, 2)}
 `,
         "utf-8"
       );
       const createdFiles = [
-        join23(agentDir, "persona.cant"),
-        join23(agentDir, "manifest.json")
+        join22(agentDir, "persona.cant"),
+        join22(agentDir, "manifest.json")
       ];
       if (team) {
         const teamConfigContent = generateTeamConfig(name, role, team);
-        writeFileSync5(join23(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
-        createdFiles.push(join23(agentDir, "team-config.cant"));
+        writeFileSync5(join22(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
+        createdFiles.push(join22(agentDir, "team-config.cant"));
       }
       if (seedBrain) {
-        const expertiseDir = join23(agentDir, "expertise");
+        const expertiseDir = join22(agentDir, "expertise");
         mkdirSync5(expertiseDir, { recursive: true });
         const seedContent = generateMentalModelSeed(name, role, domain);
-        writeFileSync5(join23(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
-        createdFiles.push(join23(expertiseDir, "mental-model-seed.md"));
+        writeFileSync5(join22(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
+        createdFiles.push(join22(expertiseDir, "mental-model-seed.md"));
         try {
           const { execFile: execFile2 } = await import("node:child_process");
           const { promisify: promisify2 } = await import("node:util");
@@ -38549,7 +38290,7 @@ var mintCommand = defineCommand({
   async run({ args }) {
     try {
       const { existsSync: existsSync12, readFileSync: readFileSync16, mkdirSync: mkdirSync5 } = await import("node:fs");
-      const { resolve: resolve5, join: join23 } = await import("node:path");
+      const { resolve: resolve5, join: join22 } = await import("node:path");
       const specPath = resolve5(args.spec);
       if (!existsSync12(specPath)) {
         const errEnv = {
@@ -38568,7 +38309,7 @@ var mintCommand = defineCommand({
       }
       const specContent = readFileSync16(specPath, "utf-8");
       const projectRoot = process.cwd();
-      const outputDir = args["output-dir"] ? resolve5(args["output-dir"]) : join23(projectRoot, ".cleo", "cant", "agents");
+      const outputDir = args["output-dir"] ? resolve5(args["output-dir"]) : join22(projectRoot, ".cleo", "cant", "agents");
       mkdirSync5(outputDir, { recursive: true });
       if (args["dry-run"]) {
         const preview = {
@@ -39867,9 +39608,9 @@ var exportCommand = defineCommand({
   },
   async run({ args }) {
     const scope = args.scope;
-    const { packBundle, getProjectRoot: getProjectRoot32 } = await import("@cleocode/core/internal");
+    const { packBundle, getProjectRoot: getProjectRoot33 } = await import("@cleocode/core/internal");
     const includesProject = scope === "project" || scope === "all";
-    const projectRoot = includesProject ? getProjectRoot32() : void 0;
+    const projectRoot = includesProject ? getProjectRoot33() : void 0;
     let passphrase;
     if (args.encrypt === true) {
       passphrase = process.env["CLEO_BACKUP_PASSPHRASE"];
@@ -40681,7 +40422,7 @@ var briefingCommand = defineCommand({
 // packages/cleo/src/cli/commands/bug.ts
 import { existsSync as existsSync7 } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 import { getCleoDirAbsolute as getCleoDirAbsolute2, getCleoIdentity, getConfigPath, signAuditLine } from "@cleocode/core";
 init_cli();
 var SEVERITY_MAP = {
@@ -40734,7 +40475,7 @@ async function appendSignedBugSeverity(record) {
   const sig = await signAuditLine(id, canonical);
   const line = `${JSON.stringify({ ...full, _sig: sig })}
 `;
-  const auditPath = join10(getCleoDirAbsolute2(), "audit", "bug-severity.jsonl");
+  const auditPath = join9(getCleoDirAbsolute2(), "audit", "bug-severity.jsonl");
   await mkdir2(dirname5(auditPath), { recursive: true });
   await appendFile2(auditPath, line, { encoding: "utf-8" });
 }
@@ -40848,7 +40589,7 @@ var cancelCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/cant.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname6, isAbsolute, join as join11, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, isAbsolute, join as join10, resolve as resolve3 } from "node:path";
 init_renderers();
 function resolveFilePath(file) {
   return isAbsolute(file) ? file : resolve3(process.cwd(), file);
@@ -41008,7 +40749,7 @@ var cantMigrateCommand = defineCommand({
         const projectRoot = process.cwd();
         let written = 0;
         for (const outputFile of result.outputFiles) {
-          const outputPath = isAbsolute(outputFile.path) ? outputFile.path : join11(projectRoot, outputFile.path);
+          const outputPath = isAbsolute(outputFile.path) ? outputFile.path : join10(projectRoot, outputFile.path);
           mkdirSync2(dirname6(outputPath), { recursive: true });
           writeFileSync2(outputPath, outputFile.content, "utf-8");
           written++;
@@ -41607,9 +41348,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartOutline } = await import("@cleocode/core/internal");
-        const { join: join23 } = await import("node:path");
+        const { join: join22 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join23(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join22(root, args.file);
         const result = smartOutline(absPath, root);
         if (result.errors.length > 0 && result.symbols.length === 0) {
           console.error(`Error: ${result.errors.join(", ")}`);
@@ -41700,9 +41441,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartUnfold } = await import("@cleocode/core/internal");
-        const { join: join23 } = await import("node:path");
+        const { join: join22 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join23(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join22(root, args.file);
         const result = smartUnfold(absPath, args.symbol, root);
         if (!result.found) {
           console.error(`Symbol "${args.symbol}" not found in ${args.file}`);
@@ -42745,7 +42486,7 @@ var currentCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/daemon.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 import { getGCDaemonStatus, spawnGCDaemon, stopGCDaemon } from "@cleocode/core/gc/daemon.js";
 async function showDaemonStatus(cleoDir, json2) {
   try {
@@ -42798,7 +42539,7 @@ var startCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
     const jsonMode = args.json ?? false;
     try {
       const status = await getGCDaemonStatus(cleoDir);
@@ -42829,7 +42570,7 @@ var startCommand3 = defineCommand({
       } else {
         process.stdout.write(`GC daemon started (PID ${pid})
 `);
-        process.stdout.write(`Logs: ${join12(cleoDir, "logs", "gc.log")}
+        process.stdout.write(`Logs: ${join11(cleoDir, "logs", "gc.log")}
 `);
       }
     } catch (err) {
@@ -42858,7 +42599,7 @@ var stopCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
     const jsonMode = args.json ?? false;
     try {
       const stopResult = await stopGCDaemon(cleoDir);
@@ -42904,7 +42645,7 @@ var statusCommand4 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
     await showDaemonStatus(cleoDir, args.json ?? false);
   }
 });
@@ -42930,7 +42671,7 @@ var daemonCommand = defineCommand({
   },
   async run({ args, cmd, rawArgs }) {
     if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
-    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
     await showDaemonStatus(cleoDir, args.json ?? false);
   }
 });
@@ -43282,13 +43023,13 @@ var detectCommand2 = defineCommand({
 // packages/cleo/src/cli/commands/detect-drift.ts
 init_src();
 import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { dirname as dirname7, join as join12 } from "node:path";
 init_paths();
 init_renderers();
 function findProjectRoot() {
   let currentDir = process.cwd();
   while (currentDir !== "/") {
-    if (existsSync9(join13(currentDir, "package.json"))) {
+    if (existsSync9(join12(currentDir, "package.json"))) {
       return currentDir;
     }
     const parent = dirname7(currentDir);
@@ -43304,8 +43045,8 @@ var detectDriftCommand = defineCommand({
   },
   async run() {
     const projectRoot = findProjectRoot();
-    const isCleoRepo = existsSync9(join13(projectRoot, "packages", "cleo", "src"));
-    const cleoSrcRoot = isCleoRepo ? join13(projectRoot, "packages", "cleo", "src") : join13(projectRoot, "src");
+    const isCleoRepo = existsSync9(join12(projectRoot, "packages", "cleo", "src"));
+    const cleoSrcRoot = isCleoRepo ? join12(projectRoot, "packages", "cleo", "src") : join12(projectRoot, "src");
     const safeRead = (filePath) => {
       try {
         return readFileSync11(filePath, "utf-8");
@@ -43319,7 +43060,7 @@ var detectDriftCommand = defineCommand({
         checks: [],
         recommendations: []
       };
-      const injPath = join13(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      const injPath = join12(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
       if (existsSync9(injPath)) {
         const content = safeRead(injPath);
         userResult.checks.push({
@@ -43371,9 +43112,9 @@ var detectDriftCommand = defineCommand({
       }
     };
     try {
-      const specPath = join13(projectRoot, "docs", "specs", "CLEO-OPERATION-CONSTITUTION.md");
-      const registryPath = join13(cleoSrcRoot, "dispatch", "registry.ts");
-      const dispatchDomainsDir = join13(cleoSrcRoot, "dispatch", "domains");
+      const specPath = join12(projectRoot, "docs", "specs", "CLEO-OPERATION-CONSTITUTION.md");
+      const registryPath = join12(cleoSrcRoot, "dispatch", "registry.ts");
+      const dispatchDomainsDir = join12(cleoSrcRoot, "dispatch", "domains");
       if (!existsSync9(specPath)) {
         addCheck("Gateway-to-spec sync", "fail", "CLEO-OPERATION-CONSTITUTION.md missing", [
           {
@@ -43442,8 +43183,8 @@ var detectDriftCommand = defineCommand({
       ]);
     }
     try {
-      const cliDir = join13(cleoSrcRoot, "cli", "commands");
-      const coreDir = isCleoRepo ? join13(projectRoot, "packages", "core", "src") : join13(projectRoot, "src", "core");
+      const cliDir = join12(cleoSrcRoot, "cli", "commands");
+      const coreDir = isCleoRepo ? join12(projectRoot, "packages", "core", "src") : join12(projectRoot, "src", "core");
       if (!existsSync9(cliDir)) {
         addCheck("CLI-to-core sync", "fail", "CLI commands directory missing", [
           {
@@ -43470,7 +43211,7 @@ var detectDriftCommand = defineCommand({
       addCheck("CLI-to-core sync", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const domainsDir = join13(cleoSrcRoot, "dispatch", "domains");
+      const domainsDir = join12(cleoSrcRoot, "dispatch", "domains");
       if (!existsSync9(domainsDir)) {
         addCheck("Domain handler coverage", "fail", "Dispatch domains directory missing", [
           {
@@ -43488,7 +43229,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Domain handler coverage", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const matrixPath = join13(cleoSrcRoot, "dispatch", "lib", "capability-matrix.ts");
+      const matrixPath = join12(cleoSrcRoot, "dispatch", "lib", "capability-matrix.ts");
       if (!existsSync9(matrixPath)) {
         addCheck("Capability matrix", "fail", "Capability matrix missing", [
           {
@@ -43505,7 +43246,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Capability matrix", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const schemaPath = join13(projectRoot, "src", "store", "schema.ts");
+      const schemaPath = join12(projectRoot, "src", "store", "schema.ts");
       if (!existsSync9(schemaPath)) {
         addCheck("Schema validation", "fail", "Schema definition missing", [
           {
@@ -43540,8 +43281,8 @@ var detectDriftCommand = defineCommand({
       addCheck("Schema validation", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const visionPath = join13(projectRoot, "docs", "concepts", "CLEO-VISION.md");
-      const specPath = join13(projectRoot, "docs", "specs", "CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md");
+      const visionPath = join12(projectRoot, "docs", "concepts", "CLEO-VISION.md");
+      const specPath = join12(projectRoot, "docs", "specs", "CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md");
       const issues = [];
       if (!existsSync9(visionPath)) {
         issues.push({
@@ -43596,7 +43337,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Canonical identity", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const injectionPath = join13(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      const injectionPath = join12(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
       if (!existsSync9(injectionPath)) {
         addCheck("Agent injection", "fail", "Agent injection template missing", [
           {
@@ -43626,7 +43367,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Agent injection", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const exitCodesPath = join13(cleoSrcRoot, "dispatch", "lib", "exit-codes.ts");
+      const exitCodesPath = join12(cleoSrcRoot, "dispatch", "lib", "exit-codes.ts");
       if (!existsSync9(exitCodesPath)) {
         addCheck("Exit codes", "fail", "Exit codes definition missing", [
           {
@@ -43759,7 +43500,7 @@ var diagnosticsCommand = defineCommand({
 // packages/cleo/src/cli/commands/docs.ts
 init_src();
 import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile } from "node:fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute2, join as join14, resolve as resolve4 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join13, resolve as resolve4 } from "node:path";
 import {
   buildDocsGraph,
   CleoError as CleoError3,
@@ -43777,7 +43518,7 @@ import {
 init_cli();
 init_renderers();
 async function getScriptNames(projectRoot) {
-  const scriptsDir = join14(projectRoot, "scripts");
+  const scriptsDir = join13(projectRoot, "scripts");
   try {
     const files = await readdir(scriptsDir);
     return files.filter((f) => f.endsWith(".sh")).map((f) => f.replace(".sh", "")).sort();
@@ -43786,7 +43527,7 @@ async function getScriptNames(projectRoot) {
   }
 }
 async function getIndexedCommands(projectRoot) {
-  const indexPath = join14(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
+  const indexPath = join13(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
   const index = await readJson(indexPath);
   if (!index) return [];
   return index.commands.map((c) => c.name).sort();
@@ -43819,7 +43560,7 @@ async function runGapCheck(_projectRoot, filterId) {
     const reviewFiles = files.filter((f) => f.endsWith(".md"));
     for (const file of reviewFiles) {
       if (filterId && !file.includes(filterId)) continue;
-      const filePath = join14(reviewDir, file);
+      const filePath = join13(reviewDir, file);
       const content = await readFile3(filePath, "utf-8");
       const taskMatch = file.match(/^(T\d+)/);
       const taskId = taskMatch ? taskMatch[1] : "UNKNOWN";
@@ -45177,7 +44918,7 @@ var findCommand2 = defineCommand({
 
 // packages/cleo/src/cli/commands/gc.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 import { runGC } from "@cleocode/core/gc/runner.js";
 import { readGCState } from "@cleocode/core/gc/state.js";
 function formatBytes(bytes) {
@@ -45209,7 +44950,7 @@ var runCommand2 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join15(homedir3(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join14(homedir3(), ".cleo");
     const dryRun = args["dry-run"];
     try {
       const gcResult = await runGC({ cleoDir, dryRun });
@@ -45264,8 +45005,8 @@ var statusCommand6 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join15(homedir3(), ".cleo");
-    const statePath = join15(cleoDir, "gc-state.json");
+    const cleoDir = args["cleo-dir"] ?? join14(homedir3(), ".cleo");
+    const statePath = join14(cleoDir, "gc-state.json");
     try {
       const state = await readGCState(statePath);
       const result = { success: true, data: state };
@@ -45325,7 +45066,7 @@ var gcCommand = defineCommand({
 init_src();
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname9, join as join16 } from "node:path";
+import { dirname as dirname9, join as join15 } from "node:path";
 import { CleoError as CleoError4, formatError as formatError6, getConfigPath as getConfigPath2, getProjectRoot as getProjectRoot24 } from "@cleocode/core";
 init_renderers();
 function getChangelogSource(cwd) {
@@ -45484,7 +45225,7 @@ var generateChangelogCommand = defineCommand({
       const targetPlatform = args.platform;
       const dryRun = args["dry-run"] === true;
       const sourceFile = getChangelogSource();
-      const sourcePath = join16(getProjectRoot24(), sourceFile);
+      const sourcePath = join15(getProjectRoot24(), sourceFile);
       if (!existsSync10(sourcePath)) {
         throw new CleoError4(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
@@ -45497,7 +45238,7 @@ var generateChangelogCommand = defineCommand({
         const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
-          const fullPath = join16(getProjectRoot24(), outputPath);
+          const fullPath = join15(getProjectRoot24(), outputPath);
           mkdirSync3(dirname9(fullPath), { recursive: true });
           writeFileSync3(fullPath, content, "utf-8");
         }
@@ -45518,7 +45259,7 @@ var generateChangelogCommand = defineCommand({
             limit
           );
           if (!dryRun) {
-            const fullPath = join16(getProjectRoot24(), platformConfig.path);
+            const fullPath = join15(getProjectRoot24(), platformConfig.path);
             mkdirSync3(dirname9(fullPath), { recursive: true });
             writeFileSync3(fullPath, content, "utf-8");
           }
@@ -46930,7 +46671,7 @@ var mapCommand = defineCommand({
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join16 } from "node:path";
 import {
   getBrainDb as getBrainDb2,
   getBrainNativeDb as getBrainNativeDb4,
@@ -48228,11 +47969,11 @@ var importCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const sourceDir = args.from ?? join17(homedir4(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
+    const sourceDir = args.from ?? join16(homedir4(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
     const isDryRun = !!args["dry-run"];
     const isJson = !!args.json;
     const projectRoot = getProjectRoot25();
-    const stateFile = join17(projectRoot, CLEO_DIR_NAME, MIGRATE_MEMORY_HASHES_JSON);
+    const stateFile = join16(projectRoot, CLEO_DIR_NAME, MIGRATE_MEMORY_HASHES_JSON);
     if (!existsSync11(sourceDir)) {
       const msg = `Source directory not found: ${sourceDir}`;
       if (isJson) {
@@ -48242,7 +47983,7 @@ var importCommand3 = defineCommand({
       }
       process.exit(1);
     }
-    const files = readdirSync3(sourceDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => join17(sourceDir, f));
+    const files = readdirSync3(sourceDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => join16(sourceDir, f));
     const importedHashes = isDryRun ? /* @__PURE__ */ new Set() : loadImportHashes(stateFile);
     const stats = { total: files.length, imported: 0, skipped: 0, errors: 0 };
     const importedEntries = [];
@@ -51150,7 +50891,7 @@ var analyzeCommand3 = defineCommand({
       );
     }
     try {
-      const [{ getNexusDb: getNexusDb2, nexusSchema }, { runPipeline }, { getProjectRoot: getProjectRoot32 }, { eq: eq2 }] = await Promise.all([
+      const [{ getNexusDb: getNexusDb2, nexusSchema }, { runPipeline }, { getProjectRoot: getProjectRoot33 }, { eq: eq2 }] = await Promise.all([
         import("@cleocode/core/store/nexus-sqlite"),
         import("@cleocode/nexus/pipeline"),
         import("@cleocode/core/internal"),
@@ -51256,7 +50997,7 @@ var analyzeCommand3 = defineCommand({
 `
         );
       }
-      void getProjectRoot32;
+      void getProjectRoot33;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (jsonOutput) {
@@ -57681,7 +57422,7 @@ var schemaCommand = defineCommand({
 init_src();
 import { execFile } from "node:child_process";
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join17 } from "node:path";
 import * as readline2 from "node:readline";
 import { promisify } from "node:util";
 import {
@@ -57700,7 +57441,7 @@ var GITHUB_REPO = BUILD_CONFIG2.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome2();
   try {
-    const content = await readFile4(join18(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile4(join17(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -57754,7 +57495,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
   ];
   await import("node:fs/promises").then(
     ({ writeFile: writeFile3, mkdir: mkdir5 }) => mkdir5(cleoHome, { recursive: true }).then(
-      () => writeFile3(join18(cleoHome, "VERSION"), `${lines.join("\n")}
+      () => writeFile3(join17(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8")
     )
   );
@@ -58155,7 +57896,7 @@ async function runPostUpdateDiagnostics(opts) {
 }
 
 // packages/cleo/src/cli/commands/sentient.ts
-import { join as join19 } from "node:path";
+import { join as join18 } from "node:path";
 import { cwd as processCwd } from "node:process";
 import {
   getSentientDaemonStatus,
@@ -58226,7 +57967,7 @@ var startSub = defineCommand({
         return;
       }
       if (dryRun) {
-        const statePath2 = join19(projectRoot, SENTIENT_STATE_FILE);
+        const statePath2 = join18(projectRoot, SENTIENT_STATE_FILE);
         const outcome = await safeRunTick({ projectRoot, statePath: statePath2, dryRun: true });
         emitSuccess(
           { dryRun: true, outcome },
@@ -58360,7 +58101,7 @@ var tickSub = defineCommand({
     const jsonMode = args.json === true;
     const dryRun = args["dry-run"] === true;
     try {
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const outcome = await safeRunTick({ projectRoot, statePath, dryRun });
       emitSuccess(
         { outcome, dryRun },
@@ -58429,7 +58170,7 @@ var proposeAcceptSub = defineCommand({
         return;
       }
       await db.update(tasks).set({ status: "pending", updatedAt: now }).where(eq2(tasks.id, id)).run();
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       await patchSentientState(statePath, {
         tier2Stats: {
@@ -58481,7 +58222,7 @@ var proposeRejectSub = defineCommand({
         return;
       }
       await db.update(tasks).set({ status: "cancelled", cancellationReason: reason, cancelledAt: now, updatedAt: now }).where(eq2(tasks.id, id)).run();
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       await patchSentientState(statePath, {
         tier2Stats: {
@@ -58526,7 +58267,7 @@ var proposeRunSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const outcome = await safeRunProposeTick({ projectRoot, statePath });
       emitSuccess(
         { outcome },
@@ -58546,7 +58287,7 @@ var proposeEnableSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const updated = await patchSentientState(statePath, { tier2Enabled: true });
       emitSuccess({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals enabled");
     } catch (err) {
@@ -58565,7 +58306,7 @@ var proposeDisableSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const updated = await patchSentientState(statePath, { tier2Enabled: false });
       emitSuccess({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals disabled");
     } catch (err) {
@@ -58596,7 +58337,7 @@ var proposeSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       emitSuccess(
         {
@@ -58893,6 +58634,10 @@ var startCommand7 = defineCommand({
       description: "Auto-focus on first available task (alias for --auto-start)"
     },
     focus: {
+      type: "string",
+      description: "Set initial task to work on (alias for --start-task)"
+    },
+    "start-task": {
       type: "string",
       description: "Set initial task to work on"
     },
@@ -58926,7 +58671,8 @@ var startCommand7 = defineCommand({
         scope: args.scope,
         name: args.name,
         autoStart: args["auto-start"] || args["auto-focus"],
-        focus: args.focus,
+        // CLI-level alias normalization: --focus and --start-task both map to startTask (ADR-057 D2)
+        startTask: args["start-task"] ?? args.focus,
         grade: args.grade,
         ownerAuthToken
       },
@@ -60483,7 +60229,7 @@ var testingCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/token.ts
 import { readFileSync as readFileSync14 } from "node:fs";
-import { measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot30, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
 init_cli();
 init_renderers();
 function readPayload(args, textKey, fileKey) {
@@ -60642,7 +60388,7 @@ var estimateCommand = defineCommand({
       domain: args.domain,
       operation: args.operation
     };
-    const result = args.record ? await recordTokenExchange2(input) : await measureTokenExchange(input);
+    const result = args.record ? await recordTokenExchange2(getProjectRoot30(), input) : await measureTokenExchange(input);
     cliOutput(result, {
       command: "token",
       operation: args.record ? "admin.token.record" : "token.estimate"
@@ -60671,8 +60417,8 @@ var tokenCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/transcript.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join20 } from "node:path";
-import { getProjectRoot as getProjectRoot30 } from "@cleocode/core";
+import { join as join19 } from "node:path";
+import { getProjectRoot as getProjectRoot31 } from "@cleocode/core";
 import {
   parseDurationMs,
   pruneTranscripts,
@@ -60700,7 +60446,7 @@ var scanCommand = defineCommand({
   async run({ args }) {
     if (args.pending) {
       try {
-        const projectRoot = getProjectRoot30();
+        const projectRoot = getProjectRoot31();
         const { scanPendingTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
         const pending = await scanPendingTranscripts(projectRoot);
         const envelope = { success: true, data: { count: pending.length, pending } };
@@ -60729,7 +60475,7 @@ var scanCommand = defineCommand({
       }
       return;
     }
-    const projectsDir = args["projects-dir"] ?? join20(homedir5(), ".claude", "projects");
+    const projectsDir = args["projects-dir"] ?? join19(homedir5(), ".claude", "projects");
     try {
       const result = await scanTranscripts(projectsDir);
       const envelope = {
@@ -60833,7 +60579,7 @@ var extractCommand = defineCommand({
   async run({ args }) {
     const tier = args.tier ?? "warm";
     const dryRun = args["dry-run"] ?? false;
-    const projectRoot = getProjectRoot30();
+    const projectRoot = getProjectRoot31();
     try {
       const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
       const { findSessionTranscriptPath, listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -60964,7 +60710,7 @@ var migrateCommand2 = defineCommand({
     const dryRun = args["dry-run"] ?? false;
     const olderThanHours = args["older-than-hours"] ? Number.parseInt(args["older-than-hours"], 10) : 24;
     const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
-    const projectRoot = getProjectRoot30();
+    const projectRoot = getProjectRoot31();
     try {
       const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
       const { listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -61114,7 +60860,7 @@ var pruneCommand = defineCommand({
       process.exit(2);
       return;
     }
-    const projectsDir = args["projects-dir"] ?? join20(homedir5(), ".claude", "projects");
+    const projectsDir = args["projects-dir"] ?? join19(homedir5(), ".claude", "projects");
     try {
       const pruneResult = await pruneTranscripts({
         olderThanMs,
@@ -61540,7 +61286,7 @@ var verifyCommand2 = defineCommand({
 init_src();
 import { execFileSync as execFileSync6, spawn } from "node:child_process";
 import { mkdir as mkdir4, open, readFile as readFile5, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { join as join20 } from "node:path";
 import { CleoError as CleoError12, formatError as formatError14, getCleoHome as getCleoHome3 } from "@cleocode/core";
 init_renderers();
 var DEFAULT_PORT = 3456;
@@ -61548,10 +61294,10 @@ var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome3();
   return {
-    pidFile: join21(cleoHome, "web-server.pid"),
-    configFile: join21(cleoHome, "web-server.json"),
-    logDir: join21(cleoHome, "logs"),
-    logFile: join21(cleoHome, "logs", "web-server.log")
+    pidFile: join20(cleoHome, "web-server.pid"),
+    configFile: join20(cleoHome, "web-server.json"),
+    logDir: join20(cleoHome, "logs"),
+    logFile: join20(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -61590,7 +61336,7 @@ async function startWebServer(port, host) {
     throw new CleoError12(1 /* GENERAL_ERROR */, `Server already running (PID: ${status.pid})`);
   }
   const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-  const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join21(projectRoot, "packages", "studio", "build");
+  const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join20(projectRoot, "packages", "studio", "build");
   await mkdir4(logDir, { recursive: true });
   await writeFile2(
     configFile,
@@ -61600,7 +61346,7 @@ async function startWebServer(port, host) {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     })
   );
-  const webIndexPath = join21(studioDir, "index.js");
+  const webIndexPath = join20(studioDir, "index.js");
   try {
     await stat(webIndexPath);
   } catch {
@@ -61879,7 +61625,7 @@ Or via NodeSource: https://github.com/nodesource/distributions
   }
 }
 function getPackageVersion() {
-  const pkgPath = join22(dirname10(fileURLToPath3(import.meta.url)), "../../package.json");
+  const pkgPath = join21(dirname10(fileURLToPath3(import.meta.url)), "../../package.json");
   const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
   return pkg.version;
 }
@@ -62034,12 +61780,12 @@ subCommands["pipeline"] = phaseCommand;
   } catch {
   }
   try {
-    detectAndRemoveStrayProjectNexus(getProjectRoot31());
+    detectAndRemoveStrayProjectNexus(getProjectRoot32());
   } catch {
   }
   const _startupLog = getLogger19("cli-startup");
   try {
-    const _projectRootForMigration = getProjectRoot31();
+    const _projectRootForMigration = getProjectRoot32();
     if (needsSignaldockToConduitMigration(_projectRootForMigration)) {
       const migrationResult = migrateSignaldockToConduit(_projectRootForMigration);
       if (migrationResult.status === "failed") {
@@ -62059,7 +61805,7 @@ subCommands["pipeline"] = phaseCommand;
     }
   }
   try {
-    ensureConduitDb(getProjectRoot31());
+    ensureConduitDb(getProjectRoot32());
   } catch {
   }
   try {