@cleocode/cleo 2026.10.4 → 2026.10.5-rc.ci.672

package/dist/cli/session-N5ISU56W.js

@@ -0,0 +1,568 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  bindSession,
+  unbindSession
+} from "./chunk-D7BAQNV2.js";
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch,
+  wrapCoreResult
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  envelopeToEngineResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/session.ts
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { eq } from "drizzle-orm";
+var sessionAdopt = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionAdopt
+);
+var sessionBriefing = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionBriefing
+);
+var sessionComputeDebrief = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionComputeDebrief
+);
+var sessionComputeHandoff = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionComputeHandoff
+);
+var sessionContextDrift = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionContextDrift
+);
+var sessionDebriefShow = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionDebriefShow
+);
+var sessionDecisionLog = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionDecisionLog
+);
+var sessionEnd = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionEnd
+);
+var sessionFind = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionFind
+);
+var sessionGc = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionGc
+);
+var sessionHandoff = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionHandoff
+);
+var sessionList = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionList
+);
+var sessionRecordAssumption = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionRecordAssumption
+);
+var sessionRecordDecision = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionRecordDecision
+);
+var sessionResume = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionResume
+);
+var sessionShow = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionShow
+);
+var sessionStart = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionStart
+);
+var sessionStatus = lazyOperation(
+  async () => (await import("@cleocode/core/session/status-op")).sessionStatus
+);
+var sessionSuspend = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionSuspend
+);
+async function sessionStatusOp() {
+  return sessionStatus(getProjectRoot());
+}
+async function sessionListOp(params) {
+  return sessionList(getProjectRoot(), params);
+}
+async function sessionShowOp(params) {
+  if (params.include === "debrief") {
+    return sessionDebriefShow(getProjectRoot(), params.sessionId);
+  }
+  return sessionShow(getProjectRoot(), params.sessionId);
+}
+async function sessionFindOp(params) {
+  return sessionFind(getProjectRoot(), params);
+}
+async function sessionDecisionLogOp(params) {
+  return sessionDecisionLog(getProjectRoot(), params);
+}
+async function sessionContextDriftOp(params) {
+  return sessionContextDrift(getProjectRoot(), params);
+}
+async function sessionHandoffShowOp(params) {
+  let scopeFilter;
+  if (params.scope) {
+    if (params.scope === "global") {
+      scopeFilter = { type: "global" };
+    } else if (params.scope.startsWith("epic:")) {
+      scopeFilter = { type: "epic", epicId: params.scope.replace("epic:", "") };
+    }
+  }
+  return sessionHandoff(getProjectRoot(), scopeFilter);
+}
+async function sessionBriefingShowOp(params) {
+  return sessionBriefing(getProjectRoot(), params);
+}
+async function sessionStartOp(params) {
+  return sessionStart(getProjectRoot(), params);
+}
+async function sessionEndOp(params) {
+  return sessionEnd(getProjectRoot(), params.note, {
+    sessionSummary: params.sessionSummary,
+    ...params.sessionId ? { sessionId: params.sessionId } : {}
+  });
+}
+async function sessionResumeOp(params) {
+  return sessionResume(getProjectRoot(), params.sessionId);
+}
+async function sessionSuspendOp(params) {
+  return sessionSuspend(getProjectRoot(), params.sessionId, params.reason);
+}
+async function sessionGcOp(params) {
+  return sessionGc(getProjectRoot(), params.maxAgeDays);
+}
+async function sessionRecordDecisionOp(params) {
+  return sessionRecordDecision(getProjectRoot(), params);
+}
+async function sessionRecordAssumptionOp(params) {
+  return sessionRecordAssumption(getProjectRoot(), params);
+}
+async function sessionAdoptOp(params) {
+  return sessionAdopt(getProjectRoot(), params.sessionId);
+}
+async function sessionLintOp(params) {
+  if (!params.transcript) {
+    return {
+      success: false,
+      error: { code: "E_INVALID_INPUT", message: "transcript is required" }
+    };
+  }
+  try {
+    const { lintSessionForCanonViolations } = await import("@cleocode/core/session/canon-lint");
+    const result = lintSessionForCanonViolations({
+      transcriptPath: params.transcript,
+      projectRoot: getProjectRoot()
+    });
+    const wireResult = {
+      transcriptPath: result.transcriptPath,
+      sessionId: result.sessionId,
+      passed: result.passed,
+      scanned: result.scanned,
+      // Clone to drop readonly modifiers for the wire shape.
+      violations: result.violations.map((v) => ({
+        sessionId: v.sessionId,
+        toolUseId: v.toolUseId,
+        tool: v.tool,
+        path: v.path,
+        docKind: v.docKind,
+        matchedPath: v.matchedPath,
+        kind: v.kind,
+        evidence: v.evidence,
+        fix: v.fix
+      })),
+      warnings: [...result.warnings],
+      mode: result.mode
+    };
+    return { success: true, data: wireResult };
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        code: "E_CANON_INVALID",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+var coreOps = {
+  status: sessionStatusOp,
+  list: sessionListOp,
+  show: sessionShowOp,
+  find: sessionFindOp,
+  "decision.log": sessionDecisionLogOp,
+  "context.drift": sessionContextDriftOp,
+  "handoff.show": sessionHandoffShowOp,
+  "briefing.show": sessionBriefingShowOp,
+  start: sessionStartOp,
+  end: sessionEndOp,
+  resume: sessionResumeOp,
+  suspend: sessionSuspendOp,
+  gc: sessionGcOp,
+  "record.decision": sessionRecordDecisionOp,
+  "record.assumption": sessionRecordAssumptionOp,
+  lint: sessionLintOp,
+  // T9975 — per-agent session isolation
+  adopt: sessionAdoptOp
+};
+var _sessionTypedHandler = defineTypedHandler("session", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  // Engine guarantees data on success; fallback mirrors empty-state shape.
+  // overrideCount included per T1501 / P0-5.
+  status: async (_params) => wrapCoreResult(await coreOps.status(), "status", {
+    hasActiveSession: false,
+    session: null,
+    taskWork: null,
+    overrideCount: 0
+  }),
+  list: async (params) => wrapCoreResult(await coreOps.list(params), "list"),
+  // session.show absorbs debrief.show via include param (T5615)
+  show: async (params) => {
+    if (!params.sessionId) {
+      return lafsError("E_INVALID_INPUT", "sessionId is required", "show");
+    }
+    const result = await coreOps.show(params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "show"
+      );
+    }
+    if (params.include !== "debrief" && !result.data) {
+      return lafsError("E_NOT_FOUND", `Session ${params.sessionId} not found`, "show");
+    }
+    return lafsSuccess(result.data, "show");
+  },
+  find: async (params) => {
+    const result = await coreOps.find(params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "find"
+      );
+    }
+    return lafsSuccess({ sessions: result.data ?? [] }, "find");
+  },
+  "decision.log": async (params) => wrapCoreResult(await coreOps["decision.log"](params), "decision.log", []),
+  "context.drift": async (params) => {
+    const result = await coreOps["context.drift"](params);
+    if (result.success && !result.data) {
+      return lafsError("E_INTERNAL", "context.drift returned no data", "context.drift");
+    }
+    return wrapCoreResult(result, "context.drift");
+  },
+  "handoff.show": async (params) => wrapCoreResult(await coreOps["handoff.show"](params), "handoff.show", null),
+  "briefing.show": async (params) => wrapCoreResult(await coreOps["briefing.show"](params), "briefing.show"),
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  // SSoT-EXEMPT: storeOwnerAuthToken (DB side-effect requiring post-create sessionId),
+  // bindSession (process-scoped context, requires scope-string parsing) — ADR-058
+  start: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.scope) {
+      return lafsError("E_INVALID_INPUT", "scope is required", "start");
+    }
+    const result = await coreOps.start(params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "start"
+      );
+    }
+    if (!result.data) {
+      return lafsError("E_INTERNAL", "sessionStart returned no data", "start");
+    }
+    const sessionData = result.data;
+    const sessionId = sessionData.id;
+    if (params.ownerAuthToken) {
+      try {
+        await storeSessionOwnerAuthToken(projectRoot, sessionId, params.ownerAuthToken);
+      } catch (err) {
+        getLogger("domain:session").warn(
+          { sessionId, err },
+          "Failed to store owner_auth_token \u2014 override auth will not be available"
+        );
+      }
+    }
+    Object.assign(sessionData, { sessionId });
+    try {
+      const scopeParts = params.scope.split(":");
+      bindSession({
+        sessionId,
+        scope: {
+          type: scopeParts[0] ?? "global",
+          epicId: scopeParts[1]
+        },
+        gradeMode: params.grade ?? false
+      });
+    } catch {
+      getLogger("domain:session").warn(
+        { sessionId },
+        "Session context already bound, skipping bindSession"
+      );
+    }
+    return lafsSuccess(sessionData, "start");
+  },
+  // SSoT-EXEMPT: orchestrated post-op pipeline — sessionComputeDebrief, persistSessionMemory,
+  // unbindSession (process-context teardown), refreshMemoryBridge — ADR-058
+  end: async (params) => {
+    const projectRoot = getProjectRoot();
+    const endResult = await coreOps.end(params);
+    if (!endResult.success) {
+      return lafsError(
+        String(endResult.error?.code ?? "E_INTERNAL"),
+        endResult.error?.message ?? "Unknown error",
+        "end"
+      );
+    }
+    if (endResult.data) {
+      const sessionId = endResult.data.sessionId;
+      if (sessionId) {
+        let debriefResult = null;
+        try {
+          debriefResult = await sessionComputeDebrief(projectRoot, sessionId, {
+            note: params.note,
+            nextAction: params.nextAction
+          });
+        } catch {
+          try {
+            await sessionComputeHandoff(projectRoot, sessionId, {
+              note: params.note,
+              nextAction: params.nextAction
+            });
+          } catch {
+          }
+        }
+        if (debriefResult?.success && debriefResult.data) {
+          try {
+            const { persistSessionMemory } = await import("@cleocode/core/internal");
+            await persistSessionMemory(projectRoot, sessionId, debriefResult.data);
+          } catch {
+          }
+        }
+      }
+      unbindSession();
+    }
+    try {
+      const { refreshMemoryBridge } = await import("@cleocode/core/internal");
+      await refreshMemoryBridge(projectRoot);
+    } catch {
+    }
+    if (!endResult.data) {
+      return lafsError("E_INTERNAL", "session.end returned no data", "end");
+    }
+    return lafsSuccess(endResult.data, "end");
+  },
+  resume: async (params) => {
+    if (!params.sessionId) {
+      return lafsError("E_INVALID_INPUT", "sessionId is required", "resume");
+    }
+    const result = await coreOps.resume(params);
+    if (result.success && !result.data) {
+      return lafsError("E_NOT_FOUND", `Session ${params.sessionId} not found`, "resume");
+    }
+    return wrapCoreResult(result, "resume");
+  },
+  suspend: async (params) => {
+    if (!params.sessionId) {
+      return lafsError("E_INVALID_INPUT", "sessionId is required", "suspend");
+    }
+    const result = await coreOps.suspend(params);
+    if (result.success && !result.data) {
+      return lafsError("E_NOT_FOUND", `Session ${params.sessionId} not found`, "suspend");
+    }
+    return wrapCoreResult(result, "suspend");
+  },
+  // Engine guarantees data on success; fallback for safety.
+  gc: async (params) => wrapCoreResult(await coreOps.gc(params), "gc", { orphaned: [], removed: [] }),
+  "record.decision": async (params) => {
+    const result = await coreOps["record.decision"](params);
+    if (result.success && !result.data) {
+      return lafsError("E_INTERNAL", "record.decision returned no data", "record.decision");
+    }
+    return wrapCoreResult(result, "record.decision");
+  },
+  "record.assumption": async (params) => {
+    const result = await coreOps["record.assumption"](params);
+    if (result.success && !result.data) {
+      return lafsError("E_INTERNAL", "record.assumption returned no data", "record.assumption");
+    }
+    return wrapCoreResult(result, "record.assumption");
+  },
+  // T9797 — agent-accountability harness. Returns a LAFS envelope whose
+  // `data` is a SessionLintResult; `error` is set on E_INVALID_INPUT
+  // (missing transcript) or E_CANON_INVALID (malformed canon.yml).
+  lint: async (params) => {
+    const result = await coreOps.lint(params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "lint"
+      );
+    }
+    if (!result.data) {
+      return lafsError("E_INTERNAL", "session.lint returned no data", "lint");
+    }
+    return lafsSuccess(result.data, "lint");
+  },
+  // T9975 — per-agent session isolation: adopt rebinds env to a specific session.
+  adopt: async (params) => {
+    if (!params.sessionId) {
+      return lafsError("E_INVALID_INPUT", "sessionId is required", "adopt");
+    }
+    const result = await coreOps.adopt(params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "adopt"
+      );
+    }
+    if (!result.data) {
+      return lafsError("E_INTERNAL", "session.adopt returned no data", "adopt");
+    }
+    return lafsSuccess(result.data, "adopt");
+  }
+});
+var QUERY_OPS = /* @__PURE__ */ new Set([
+  "status",
+  "list",
+  "show",
+  "find",
+  "decision.log",
+  "context.drift",
+  "handoff.show",
+  "briefing.show",
+  "lint"
+]);
+var MUTATE_OPS = /* @__PURE__ */ new Set([
+  "start",
+  "end",
+  "resume",
+  "suspend",
+  "gc",
+  "record.decision",
+  "record.assumption",
+  // T9975 — per-agent session isolation
+  "adopt"
+]);
+var SessionHandler = class {
+  // -----------------------------------------------------------------------
+  // Query
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a read-only session query operation.
+   *
+   * @param operation - The session query op name (e.g. 'status', 'list').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "session", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _sessionTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "query", "session", operation, startTime);
+    } catch (error) {
+      getLogger("domain:session").error(
+        { gateway: "query", domain: "session", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "session", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Mutate
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a state-modifying session mutation operation.
+   *
+   * @param operation - The session mutate op name (e.g. 'start', 'end').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "session", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _sessionTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(
+        envelopeToEngineResult(envelope),
+        "mutate",
+        "session",
+        operation,
+        startTime
+      );
+    } catch (error) {
+      getLogger("domain:session").error(
+        { gateway: "mutate", domain: "session", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "session", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Supported operations
+  // -----------------------------------------------------------------------
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: [
+        "status",
+        "list",
+        "show",
+        "find",
+        "decision.log",
+        "context.drift",
+        "handoff.show",
+        "briefing.show"
+      ],
+      mutate: ["start", "end", "resume", "suspend", "gc", "record.decision", "record.assumption"]
+    };
+  }
+};
+async function storeSessionOwnerAuthToken(projectRoot, sessionId, token) {
+  const [{ getDb }, { sessions }] = await Promise.all([
+    import("@cleocode/core/store/sqlite"),
+    import("@cleocode/core/store/tasks-schema")
+  ]);
+  const db = await getDb(projectRoot);
+  db.update(sessions).set({ ownerAuthToken: token }).where(eq(sessions.id, sessionId)).run();
+}
+export {
+  SessionHandler
+};
+//# sourceMappingURL=session-N5ISU56W.js.map

package/dist/cli/{setup-BTUBW5PU.js → setup-L3YYV53D.js}

@@ -15,12 +15,12 @@
 })();
 import {
   makeOAuthAcquirer
-} from "./chunk-J3ZFM3UQ.js";
+} from "./chunk-UWCZY52R.js";
 import {
   ReadlineWizardIO,
   StdinClosedError
 } from "./chunk-GZFVDR44.js";
-import "./chunk-ULN4OKQQ.js";
+import "./chunk-GRU74UE4.js";
 import "./chunk-47JYZAMS.js";
 import "./chunk-C3B7C43W.js";
 import {
@@ -29,7 +29,7 @@ import {
 import {
   cliError,
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/commands/setup.ts
@@ -320,4 +320,4 @@ export {
   runSetup,
   setupCommand
 };
-//# sourceMappingURL=setup-BTUBW5PU.js.map
+//# sourceMappingURL=setup-L3YYV53D.js.map

package/dist/cli/{show-MXT2V7TF.js → show-364V3KY2.js}

@@ -16,22 +16,23 @@
 import {
   getOperationParams,
   paramsToCittyArgs
-} from "./chunk-W33Q3FBH.js";
-import {
-  defineCommand
-} from "./chunk-PKKZPOOP.js";
+} from "./chunk-RRKP7HLU.js";
 import {
   dispatchFromCli,
   dispatchRaw
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
 import {
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/show.ts
 var showCommand = defineCommand({
@@ -119,4 +120,4 @@ export {
   showCommand,
   unwrapShowRecord
 };
-//# sourceMappingURL=show-MXT2V7TF.js.map
+//# sourceMappingURL=show-364V3KY2.js.map

package/dist/cli/{skill-GFUZOU2C.js → skill-F2KR6HW5.js}

@@ -22,7 +22,7 @@ import {
 import {
   cliError,
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/commands/skill.ts
@@ -81,4 +81,4 @@ var skillCommand = defineCommand({
 export {
   skillCommand
 };
-//# sourceMappingURL=skill-GFUZOU2C.js.map
+//# sourceMappingURL=skill-F2KR6HW5.js.map