@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/session-3C6AAC4Y.js

@@ -0,0 +1,707 @@
+(() => {
+  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 {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput,
+  humanWarn
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/session.ts
+import { ExitCode } from "@cleocode/contracts";
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Start a new session" },
+  args: {
+    scope: {
+      type: "string",
+      description: "Session scope (epic:T### or global)",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Session name",
+      required: true
+    },
+    "auto-start": {
+      type: "boolean",
+      description: "Auto-start on first available task"
+    },
+    "auto-focus": {
+      type: "boolean",
+      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"
+    },
+    agent: {
+      type: "string",
+      description: "Agent identifier"
+    },
+    grade: {
+      type: "boolean",
+      description: "Enable full query+mutation audit logging for behavioral grading"
+    },
+    "owner-auth": {
+      type: "boolean",
+      description: "Prompt for a password and store a session HMAC token for owner-override authentication (T1118 L4a)"
+    }
+  },
+  async run({ args }) {
+    let ownerAuthToken;
+    if (args["owner-auth"]) {
+      ownerAuthToken = await promptOwnerAuthPassword(args.name ?? "session");
+      if (!ownerAuthToken) {
+        cliError(
+          "--owner-auth: password prompt cancelled.",
+          ExitCode.GENERAL_ERROR,
+          { name: "E_PROMPT_CANCELLED" },
+          { operation: "session.start" }
+        );
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+    }
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "start",
+      {
+        scope: args.scope,
+        name: args.name,
+        autoStart: args["auto-start"] || args["auto-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,
+        // T9975: per-agent handle for multi-agent isolation
+        agentHandle: args.agent
+      },
+      { command: "session", operation: "session.start" }
+    );
+  }
+});
+async function promptOwnerAuthPassword(sessionName) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    cliError(
+      "--owner-auth requires an interactive TTY. stdin.isTTY or stderr.isTTY is false.",
+      ExitCode.GENERAL_ERROR,
+      { name: "E_TTY_REQUIRED" },
+      { operation: "session.start" }
+    );
+    return null;
+  }
+  const { createInterface } = await import("node:readline");
+  const { deriveOwnerAuthToken } = await import("@cleocode/core/internal");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: true
+  });
+  process.stderr.write(`[cleo] Enter owner-auth password for session "${sessionName}": `);
+  const password = await new Promise((resolve) => {
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(
+        true
+      );
+    }
+    let pw = "";
+    process.stdin.on("data", function onData(char) {
+      const ch = char.toString("utf8");
+      if (ch === "\n" || ch === "\r") {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        if (process.stdin.setRawMode) {
+          process.stdin.setRawMode(
+            false
+          );
+        }
+        process.stderr.write("\n");
+        resolve(pw);
+      } else if (ch === "") {
+        process.stderr.write("\n[cleo] Cancelled.\n");
+        resolve("");
+      } else if (ch === "\x7F" || ch === "\b") {
+        pw = pw.slice(0, -1);
+      } else {
+        pw += ch;
+      }
+    });
+    process.stdin.resume();
+  });
+  rl.close();
+  if (!password) return null;
+  const token = deriveOwnerAuthToken(sessionName, password);
+  return token;
+}
+var endCommand = defineCommand({
+  meta: { name: "end", description: "End the current session" },
+  args: {
+    session: {
+      type: "string",
+      description: "Specific session ID to stop"
+    },
+    note: {
+      type: "string",
+      description: "Stop note"
+    },
+    "next-action": {
+      type: "string",
+      description: "Suggested next action"
+    },
+    "emit-markdown": {
+      type: "string",
+      description: "Optional path to write a derived markdown VIEW of the handoff (one-way; never read back by CLEO). Source of truth remains tasks.db + brain.db. Use `cleo briefing` to resume context. (T1593)"
+    }
+  },
+  async run({ args }) {
+    const emitMarkdownPath = args["emit-markdown"];
+    if (emitMarkdownPath) {
+      const response = await dispatchRaw("mutate", "session", "end", {
+        note: args.note,
+        nextAction: args["next-action"],
+        // T12500: an unbound terminal names its target explicitly.
+        ...args.session ? { sessionId: args.session } : {}
+      });
+      if (!response.success) {
+        handleRawError(response, { command: "session end", operation: "session.end" });
+      }
+      try {
+        const handoffResp = await dispatchRaw("query", "session", "handoff.show", {});
+        const handoffData = handoffResp.success ? handoffResp.data : null;
+        if (handoffData?.handoff) {
+          const { emitHandoffMarkdown } = await import("@cleocode/core/internal");
+          await emitHandoffMarkdown(
+            emitMarkdownPath,
+            handoffData.handoff,
+            { sessionId: handoffData.sessionId }
+          );
+        }
+      } catch (err) {
+        humanWarn(`[cleo] session end --emit-markdown failed: ${err.message}`);
+      }
+      cliOutput(response.data ?? {}, { command: "session", operation: "session.end" });
+      return;
+    }
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "end",
+      {
+        note: args.note,
+        nextAction: args["next-action"],
+        // T12500: an unbound terminal names its target explicitly.
+        ...args.session ? { sessionId: args.session } : {}
+      },
+      { command: "session", operation: "session.end" }
+    );
+  }
+});
+var handoffCommand = defineCommand({
+  meta: { name: "handoff", description: "Show handoff data from the most recent ended session" },
+  args: {
+    scope: {
+      type: "string",
+      description: "Filter by scope (epic:T### or global)"
+    }
+  },
+  async run({ args }) {
+    const scope = args.scope;
+    const response = await dispatchRaw("query", "session", "handoff.show", {
+      scope
+    });
+    if (!response.success) {
+      handleRawError(response, { command: "session handoff", operation: "session.handoff.show" });
+    }
+    const data = response.data;
+    if (!data?.handoff) {
+      cliOutput(
+        { handoff: null },
+        {
+          command: "session handoff",
+          message: "No handoff data available",
+          operation: "session.handoff.show"
+        }
+      );
+      process.exit(ExitCode.NO_DATA);
+      return;
+    }
+    const { sessionId, handoff } = data;
+    const formattedHandoff = {
+      sessionId,
+      lastTask: handoff.lastTask ?? "None",
+      tasksCompleted: handoff.tasksCompleted ?? [],
+      tasksCreated: handoff.tasksCreated ?? [],
+      decisionsRecorded: handoff.decisionsRecorded ?? 0,
+      nextSuggested: handoff.nextSuggested ?? [],
+      openBlockers: handoff.openBlockers ?? [],
+      openBugs: handoff.openBugs ?? [],
+      // GH #1277 — mirrors computeHandoff: `null` is a recorded answer, an
+      // absent key is not. Kept in step with packages/core/src/sessions/handoff.ts.
+      note: handoff.note ?? null,
+      noteChars: handoff.noteChars ?? (typeof handoff.note === "string" ? handoff.note.length : 0),
+      nextAction: handoff.nextAction ?? null,
+      nextActionChars: handoff.nextActionChars ?? (typeof handoff.nextAction === "string" ? handoff.nextAction.length : 0)
+    };
+    cliOutput(
+      { handoff: formattedHandoff },
+      { command: "session handoff", operation: "session.handoff.show" }
+    );
+  }
+});
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show current session status" },
+  async run() {
+    const response = await dispatchRaw("query", "session", "status");
+    if (!response.success) {
+      handleRawError(response, { command: "session", operation: "session.status" });
+    }
+    const data = response.data;
+    if (!data || data["session"] === null || data["session"] === void 0 && !data["id"]) {
+      cliOutput(
+        { session: null },
+        { command: "session", message: "No active session", operation: "session.status" }
+      );
+      process.exit(ExitCode.NO_DATA);
+      return;
+    }
+    cliOutput({ session: data }, { command: "session", operation: "session.status" });
+  }
+});
+var resumeCommand = defineCommand({
+  meta: { name: "resume", description: "Resume an existing session" },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: "Session ID to resume",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "resume",
+      {
+        sessionId: args.sessionId
+      },
+      { command: "session", operation: "session.resume" }
+    );
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Find sessions (lightweight discovery \u2014 minimal fields, low context cost)"
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by status (active|ended|orphaned)"
+    },
+    scope: {
+      type: "string",
+      description: 'Filter by scope (e.g. "epic:T001" or "global")'
+    },
+    query: {
+      type: "string",
+      description: "Fuzzy match on session name or ID"
+    },
+    limit: {
+      type: "string",
+      description: "Max results"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "find",
+      {
+        status: args.status,
+        scope: args.scope,
+        query: args.query,
+        limit: args.limit ? Number.parseInt(args.limit, 10) : void 0
+      },
+      { command: "session", operation: "session.find" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List sessions" },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by status (active|ended|orphaned)"
+    },
+    limit: {
+      type: "string",
+      description: "Max results"
+    },
+    offset: {
+      type: "string",
+      description: "Skip first n results"
+    },
+    /**
+     * T9975: surface all per-agent columns (agent, scope, lastActivity).
+     * When set, the result includes agentHandle, scopeKind, scopeId, and
+     * lastActivity for each session — useful for multi-agent dashboards.
+     */
+    all: {
+      type: "boolean",
+      description: "Show all columns including per-agent fields (agent, scope, lastActivity) \u2014 T9975"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "list",
+      {
+        status: args.status,
+        limit: args.limit ? Number.parseInt(args.limit, 10) : void 0,
+        offset: args.offset ? Number.parseInt(args.offset, 10) : void 0,
+        all: args.all
+      },
+      { command: "session", operation: "session.list" }
+    );
+  }
+});
+var gcCommand = defineCommand({
+  meta: { name: "gc", description: "Garbage collect old sessions" },
+  args: {
+    "max-age": {
+      type: "string",
+      description: "Max age in days for active sessions"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "gc",
+      {
+        maxAgeDays: args["max-age"] ? Number.parseInt(args["max-age"], 10) : void 0
+      },
+      { command: "session", operation: "session.gc" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show full details for a session (absorbs debrief.show via --include debrief)"
+  },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: "Session ID to show",
+      required: true
+    },
+    include: {
+      type: "string",
+      description: "Include extra data (debrief)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "show",
+      {
+        sessionId: args.sessionId,
+        include: args.include
+      },
+      { command: "session", operation: "session.show" }
+    );
+  }
+});
+var driftCommand = defineCommand({
+  meta: {
+    name: "drift",
+    description: "Detect file-scope drift for the active session (project-agnostic)"
+  },
+  args: {
+    "audit-scope": { type: "string", description: "Audit log scope (global|local)" }
+  },
+  async run({ args }) {
+    const { detectSessionDrift, getProjectRoot } = await import("@cleocode/core");
+    const projectRoot = await getProjectRoot();
+    const scope = args["audit-scope"] === "local" ? "local" : "global";
+    const report = await detectSessionDrift({ projectRoot, auditScope: scope });
+    cliOutput(report, { command: "session drift", operation: "session.drift" });
+  }
+});
+var contextDriftCommand = defineCommand({
+  meta: {
+    name: "context-drift",
+    description: "Detect context drift in the current or specified session"
+  },
+  args: {
+    "session-id": {
+      type: "string",
+      description: "Session ID to check (defaults to active session)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "context.drift",
+      {
+        sessionId: args["session-id"]
+      },
+      { command: "session", operation: "session.context.drift" }
+    );
+  }
+});
+var suspendCommand = defineCommand({
+  meta: { name: "suspend", description: "Suspend an active session (pause without ending)" },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: "Session ID to suspend",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for suspension"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "suspend",
+      {
+        sessionId: args.sessionId,
+        reason: args.reason
+      },
+      { command: "session", operation: "session.suspend" }
+    );
+  }
+});
+var recordAssumptionCommand = defineCommand({
+  meta: {
+    name: "record-assumption",
+    description: "Record an assumption made during the current session"
+  },
+  args: {
+    assumption: {
+      type: "string",
+      description: "Assumption text",
+      required: true
+    },
+    confidence: {
+      type: "string",
+      description: "Confidence level (high|medium|low)",
+      required: true
+    },
+    "session-id": {
+      type: "string",
+      description: "Session ID (defaults to active session)"
+    },
+    "task-id": {
+      type: "string",
+      description: "Task ID the assumption relates to"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "record.assumption",
+      {
+        sessionId: args["session-id"],
+        taskId: args["task-id"],
+        assumption: args.assumption,
+        confidence: args.confidence
+      },
+      { command: "session", operation: "session.record.assumption" }
+    );
+  }
+});
+var recordDecisionCommand = defineCommand({
+  meta: {
+    name: "record-decision",
+    description: "Record a decision made during the current session"
+  },
+  args: {
+    "session-id": {
+      type: "string",
+      description: "Session ID (defaults to active session)"
+    },
+    "task-id": {
+      type: "string",
+      description: "Task ID the decision relates to",
+      required: true
+    },
+    decision: {
+      type: "string",
+      description: "Decision text",
+      required: true
+    },
+    rationale: {
+      type: "string",
+      description: "Rationale for the decision",
+      required: true
+    },
+    alternatives: {
+      type: "string",
+      description: "Alternatives considered"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "record.decision",
+      {
+        sessionId: args["session-id"],
+        taskId: args["task-id"],
+        decision: args.decision,
+        rationale: args.rationale,
+        alternatives: args.alternatives
+      },
+      { command: "session", operation: "session.record.decision" }
+    );
+  }
+});
+var decisionLogCommand = defineCommand({
+  meta: { name: "decision-log", description: "Show decisions recorded in a session" },
+  args: {
+    "session-id": {
+      type: "string",
+      description: "Session ID to filter by"
+    },
+    "task-id": {
+      type: "string",
+      description: "Task ID to filter by"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "decision.log",
+      {
+        sessionId: args["session-id"],
+        taskId: args["task-id"]
+      },
+      { command: "session", operation: "session.decision.log" }
+    );
+  }
+});
+var adoptCommand = defineCommand({
+  meta: {
+    name: "adopt",
+    description: "Rebind env to a specific session \u2014 prints export command to eval (T9975)"
+  },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: "Session ID to adopt",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const response = await dispatchRaw("mutate", "session", "adopt", {
+      sessionId: args.sessionId
+    });
+    if (!response.success) {
+      handleRawError(response, { command: "session adopt", operation: "session.adopt" });
+      return;
+    }
+    const data = response.data;
+    if (data?.exportCommand) {
+      process.stdout.write(`${data.exportCommand}
+`);
+    } else {
+      cliOutput(data ?? {}, { command: "session adopt", operation: "session.adopt" });
+    }
+  }
+});
+var lintCommand = defineCommand({
+  meta: {
+    name: "lint",
+    description: "Flag raw-md writes to canonical doc paths in a session transcript (T9797 \xB7 agent-accountability)"
+  },
+  args: {
+    transcript: {
+      type: "string",
+      description: "Absolute path to the *.jsonl transcript to scan",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "lint",
+      { transcript: args.transcript },
+      { command: "session", operation: "session.lint" }
+    );
+  }
+});
+var sessionCommand = defineCommand({
+  meta: { name: "session", description: "Manage work sessions" },
+  subCommands: {
+    start: startCommand,
+    end: endCommand,
+    stop: endCommand,
+    handoff: handoffCommand,
+    status: statusCommand,
+    resume: resumeCommand,
+    find: findCommand,
+    list: listCommand,
+    gc: gcCommand,
+    show: showCommand,
+    "context-drift": contextDriftCommand,
+    drift: driftCommand,
+    suspend: suspendCommand,
+    "record-assumption": recordAssumptionCommand,
+    "record-decision": recordDecisionCommand,
+    "decision-log": decisionLogCommand,
+    lint: lintCommand,
+    // T9975 — per-agent session isolation
+    adopt: adoptCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  sessionCommand
+};
+//# sourceMappingURL=session-3C6AAC4Y.js.map