chainlesschain 0.166.77 → 0.166.78

package/src/commands/orchestrate.js

@@ -16,13 +16,42 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../lib/logger.js";
 
+function agentOptions(options) {
+  if (options.cliTool && options.backends)
+    throw new Error("Choose --cli-tool or --backends, not both");
+  if (options.cliTool && !["claude", "codex"].includes(options.cliTool))
+    throw new Error("--cli-tool must be claude or codex");
+  const selected = options.backends || options.cliTool;
+  const config = { strategy: options.strategy || "round-robin" };
+  if (selected) {
+    const types = selected.split(",").map((s) => s.trim());
+    if (
+      types.some(
+        (type) =>
+          ![
+            "claude",
+            "codex",
+            "gemini",
+            "openai",
+            "anthropic",
+            "ollama",
+          ].includes(type),
+      )
+    ) {
+      throw new Error("Unknown orchestrate backend; see orchestrate --help");
+    }
+    config.backends = types.map((type) => ({ type, weight: 1 }));
+  }
+  return config;
+}
+
 export function registerOrchestrateCommand(program, dependencies = {}) {
   const evolutionCompositionFactory =
     dependencies.evolutionCompositionFactory ?? null;
   const cmd = program
     .command("orchestrate [task]")
     .description(
-      "Orchestrate AI coding tasks: ChainlessChain → Claude Code/Codex agents → CI/CD → Notify",
+      "Orchestrate AI coding tasks (experimental): API text generation only; external Claude/Codex execution is blocked pending governance admission. Use cc agent for tool execution.",
     )
     .option("-a, --agents <n>", "Max parallel agents", "3")
     .option(
@@ -41,10 +70,13 @@ export function registerOrchestrateCommand(program, dependencies = {}) {
     .option("--cwd <path>", "Project root directory (default: current dir)")
     .option("--provider <name>", "LLM provider for decomposition")
     .option("--model <name>", "Model for decomposition LLM calls")
-    .option("--cli-tool <name>", "Execution CLI: claude|codex (auto-detected)")
+    .option(
+      "--cli-tool <name>",
+      "Select claude|codex (currently blocked by governance preflight)",
+    )
     .option(
       "--backends <list>",
-      "Agent backends: claude,codex,gemini,openai,ollama (comma-separated)",
+      "Backends: claude,codex (blocked), gemini,openai,anthropic,ollama (text only)",
     )
     .option(
       "--strategy <name>",
@@ -89,26 +121,45 @@ export function registerOrchestrateCommand(program, dependencies = {}) {
         await import("../lib/claude-code-bridge.js");
       const claude = detectClaudeCode();
       const codex = detectCodex();
+      const { AgentRouter } = await import("../lib/agent-router.js");
+      const backends = new AgentRouter({
+        backends: [
+          { type: "claude", installed: claude.found },
+          { type: "codex", installed: codex.found },
+        ],
+      }).summary();
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { cliTools: { claude, codex }, backends, alternative: "cc agent" },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
       console.log(chalk.bold("\n\uD83D\uDD0D AI CLI Detection\n"));
       console.log(
         claude.found
-          ? chalk.green(`  \u2713 claude  ${claude.version}`)
+          ? chalk.yellow(
+              `  claude  ${claude.version} — installed, execution blocked`,
+            )
           : chalk.red(
               "  \u2717 claude  not found (install: npm i -g @anthropic-ai/claude-code)",
             ),
       );
       console.log(
         codex.found
-          ? chalk.green(`  \u2713 codex   ${codex.version}`)
+          ? chalk.yellow(
+              `  codex   ${codex.version} — installed, execution blocked`,
+            )
           : chalk.gray("  \u2717 codex   not found"),
       );
-      if (!claude.found && !codex.found) {
-        console.log(
-          chalk.yellow(
-            "\n  \u26A0 No AI CLI found. Install Claude Code:\n    npm install -g @anthropic-ai/claude-code\n",
-          ),
-        );
-      }
+      console.log(
+        chalk.yellow(
+          "\n  External CLI model requests cannot be attested; installing a CLI does not enable execution. Use cc agent for tool execution.\n",
+        ),
+      );
       return;
     }
 
@@ -156,16 +207,7 @@ export function registerOrchestrateCommand(program, dependencies = {}) {
     }
 
     // Build agent backends from --backends option
-    let agentsConfig;
-    if (options.backends) {
-      const backendNames = options.backends.split(",").map((s) => s.trim());
-      agentsConfig = {
-        backends: backendNames.map((type) => ({ type, weight: 1 })),
-        strategy: options.strategy || "round-robin",
-      };
-    } else if (options.strategy && options.strategy !== "round-robin") {
-      agentsConfig = { strategy: options.strategy };
-    }
+    const agentsConfig = agentOptions(options);
 
     // Build orchestrator
     const orch = new Orchestrator({
@@ -471,11 +513,21 @@ async function _showStatus(cwd, options) {
       claude: claude.found ? claude.version : "not found",
       codex: codex.found ? codex.version : "not found",
     },
-    activeCliTool: claude.found ? "claude" : codex.found ? "codex" : "none",
+    activeCliTool: "none",
+    alternative: "cc agent",
   };
 
   const { AgentRouter } = await import("../lib/agent-router.js");
-  const router = AgentRouter.autoDetect();
+  const config = agentOptions(options);
+  const router = config.backends
+    ? new AgentRouter({
+        ...config,
+        backends: config.backends.map((b) => ({
+          ...b,
+          installed: { claude, codex }[b.type]?.found ?? null,
+        })),
+      })
+    : AgentRouter.autoDetect({ ...config, cliDetections: { claude, codex } });
   const backends = router.summary();
 
   if (options.json) {
@@ -498,10 +550,16 @@ async function _showStatus(cwd, options) {
   for (const b of backends) {
     const icon = b.kind === "cli" ? "🖥" : "🌐";
     console.log(
-      `    ${icon} ${chalk.cyan(b.type.padEnd(12))} ${chalk.gray(b.kind)}  weight:${b.weight}`,
+      `    ${icon} ${chalk.cyan(b.type.padEnd(12))} ${b.executionMode} — ${b.blockedReason}`,
     );
   }
 
+  console.log(
+    chalk.yellow(
+      "  Installed/configured does not mean runnable. Use cc agent for tool execution.",
+    ),
+  );
+
   console.log();
   console.log(chalk.bold("  Notification Channels"));
   const { NotificationManager } = await import("../lib/notifiers/index.js");
@@ -534,6 +592,7 @@ async function _webhookMode(cwd, options, evolutionCompositionFactory = null) {
 
   const orch = new Orchestrator({
     cwd,
+    agents: agentOptions(options),
     verbose: options.verbose,
     evolutionCompositionFactory,
   });
@@ -751,6 +810,7 @@ async function _watchMode(cwd, options, evolutionCompositionFactory = null) {
 
   const orch = new Orchestrator({
     cwd,
+    agents: agentOptions(options),
     verbose: options.verbose,
     evolutionCompositionFactory,
   });

package/src/commands/session-location.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { TextDecoder } from "node:util";
+import { formatExecutionLocationFailureSite } from "../lib/execution-location-failure-site.js";
 import {
   buildExecutionLocationCatalog,
   buildExecutionLocationHandoffPreview,
@@ -1124,6 +1125,8 @@ function runAction(action, options = {}) {
     writeProjection(projection, options);
     return projection.allowed === false ? 2 : 0;
   } catch (error) {
+    if (options.json)
+      process.stderr.write(formatExecutionLocationFailureSite(error));
     process.stderr.write(`Execution location failed: ${error.message}\n`);
     return 1;
   }
@@ -1145,6 +1148,8 @@ async function runAsyncAction(action, options = {}) {
     writeProjection(projection, options);
     return projection.allowed === false ? 2 : 0;
   } catch (error) {
+    if (options.json)
+      process.stderr.write(formatExecutionLocationFailureSite(error));
     process.stderr.write(`Execution location failed: ${error.message}\n`);
     return 1;
   }

package/src/commands/session-show.js

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import { numericOption } from "../lib/cli-numeric.js";
 import { logger } from "../lib/logger.js";
 import { getPrLinks } from "../lib/pr-link-store.js";
+import { readSessionTranscriptPage } from "../lib/session-transcript-page.js";
+import { readSessionInputReceipt } from "../lib/session-input-receipt.js";
 import {
   getJsonlSessionMetadata,
   rebuildMessages,
@@ -15,9 +17,30 @@ export function registerSessionShowSubcommand(session, program) {
     .argument("<id>", "Session ID (or prefix)")
     .option("-n, --limit <n>", "Max messages to show")
     .option("--json", "Output as JSON")
+    .option(
+      "--history",
+      "Page verified display history across canonical compaction (requires --json)",
+    )
+    .option(
+      "--input-receipt <client-message-id>",
+      "Read verified input acceptance without replay (requires --json)",
+    )
+    .option(
+      "--page-size <n>",
+      "Verified context/history page size (1–100; requires --json)",
+    )
+    .option(
+      "--before <cursor>",
+      "Load the previous page in the selected view (requires --json)",
+    )
+    .option(
+      "--after <cursor>",
+      "Read new display messages after a history sync cursor (requires --json --history)",
+    )
     .action(async (id, options) => {
       let ctx = null;
       let shutdown = null;
+      let changesSessionId = id;
       try {
         let sess = null;
 
@@ -26,7 +49,15 @@ export function registerSessionShowSubcommand(session, program) {
         // if JSONL_SESSION is later disabled.
         const authority = resolveSessionAuthority(id);
         const jsonlId = authority?.readable ? authority.id : null;
+        changesSessionId = authority?.id || id;
         if (authority && !authority.readable) {
+          if (options.after !== undefined && options.json)
+            throw Object.assign(
+              new Error("Canonical transcript is unavailable"),
+              {
+                code: "SESSION_TRANSCRIPT_UNAVAILABLE",
+              },
+            );
           logger.error(
             `Session ${authority.id} has canonical persistence evidence but no readable transcript (${authority.presence}).`,
           );
@@ -34,6 +65,61 @@ export function registerSessionShowSubcommand(session, program) {
           return;
         }
         if (jsonlId) {
+          if (
+            options.after !== undefined &&
+            (!options.json || !options.history || options.before)
+          )
+            throw new Error(
+              "History changes require --json --history without --before",
+            );
+          if (options.inputReceipt !== undefined) {
+            if (
+              !options.json ||
+              options.pageSize ||
+              options.before ||
+              options.after !== undefined ||
+              options.history ||
+              options.limit
+            )
+              throw new Error(
+                "Input receipt requires --json without pagination or --limit",
+              );
+            console.log(
+              JSON.stringify(
+                readSessionInputReceipt(jsonlId, options.inputReceipt),
+              ),
+            );
+            return;
+          }
+          if (
+            options.pageSize ||
+            options.before ||
+            options.history ||
+            options.after !== undefined
+          ) {
+            if (!options.json)
+              throw new Error("Transcript pagination requires --json");
+            if (options.limit)
+              throw new Error(
+                "Transcript pagination cannot be combined with --limit",
+              );
+            const readPage = options.history
+              ? (await import("../lib/session-transcript-history.js"))
+                  .readSessionTranscriptHistory
+              : readSessionTranscriptPage;
+            const page = readPage(jsonlId, {
+              limit: numericOption(options.pageSize || "50", {
+                name: "--page-size",
+                integer: true,
+                min: 1,
+                max: 100,
+              }),
+              cursor: options.before || null,
+              ...(options.after !== undefined ? { after: options.after } : {}),
+            });
+            console.log(JSON.stringify(page));
+            return;
+          }
           const metadata = getJsonlSessionMetadata(jsonlId);
           const messages = rebuildMessages(jsonlId);
           sess = {
@@ -50,6 +136,16 @@ export function registerSessionShowSubcommand(session, program) {
         // Keep SQLite and the application bootstrap outside the canonical
         // JSONL read path. Legacy sessions still retain the original fallback.
         if (!sess) {
+          if (
+            options.pageSize ||
+            options.before ||
+            options.after !== undefined ||
+            options.history ||
+            options.inputReceipt !== undefined
+          )
+            throw new Error(
+              "Verified transcript pages and input receipts require a canonical JSONL session",
+            );
           const runtime = await import("../runtime/bootstrap.js");
           const sessionManager = await import("../lib/session-manager.js");
           shutdown = runtime.shutdown;
@@ -113,7 +209,19 @@ export function registerSessionShowSubcommand(session, program) {
           logger.log("");
         }
       } catch (error) {
-        logger.error(`Failed: ${error.message}`);
+        if (options.after !== undefined && options.json) {
+          console.log(
+            JSON.stringify({
+              schema: "chainlesschain.session-transcript-changes-error/v1",
+              sessionId: changesSessionId,
+              code:
+                typeof error.code === "string" && error.code.length <= 128
+                  ? error.code
+                  : "SESSION_TRANSCRIPT_CHANGES_FAILED",
+              error: String(error.message).slice(0, 1000),
+            }),
+          );
+        } else logger.error(`Failed: ${error.message}`);
         process.exitCode = 1;
       } finally {
         if (ctx && shutdown) await shutdown();

package/src/commands/session.js

@@ -220,7 +220,7 @@ export function rankSessions(sessions, limit) {
     .slice(0, limit);
 }
 
-export function registerSessionCommand(program) {
+export function registerSessionCommand(program, dependencies = {}) {
   const session = program
     .command("session")
     .description("Conversation session management");
@@ -737,13 +737,37 @@ export function registerSessionCommand(program) {
 
         // Import and start chat REPL with restored messages
         const { startChatRepl } = await import("../repl/chat-repl.js");
-        await startChatRepl({
+        const {
+          resolveChatCommandEvolutionComposition,
+          assertChatSessionUsageAdmission,
+        } = await import("./chat.js");
+        const { readEvolutionCompositionFactory } =
+          await import("../lib/evolution/governed-model-turn.js");
+        const { loadEvolutionDeploymentCommandDependencies } =
+          await import("../lib/evolution/evolution-deployment-loader.js");
+        const { waitForAgentEvolutionSession } =
+          await import("../lib/evolution/agent-evolution-session-lifecycle.js");
+        assertChatSessionUsageAdmission(sess.id);
+        // Resume is a chat entrypoint. Use the target's authenticated chat
+        // deployment, loaded only here so read-only session commands need none.
+        const factory =
+          readEvolutionCompositionFactory(dependencies) ??
+          readEvolutionCompositionFactory(
+            (await loadEvolutionDeploymentCommandDependencies("chat")) || {},
+          );
+        const composition =
+          await resolveChatCommandEvolutionComposition(factory);
+        const ingress = composition.evolutionIngress;
+        await ingress.start();
+        const lifecycle = await startChatRepl({
           model: options.model || sess.model || "qwen2:7b",
           provider: options.provider || sess.provider || "ollama",
           baseUrl: options.baseUrl || "http://localhost:11434",
           resumeMessages: sess.messages,
           sessionId: sess.id,
+          evolutionIngress: ingress,
         });
+        await waitForAgentEvolutionSession(lifecycle, ingress);
       } catch (err) {
         logger.error(`Failed: ${err.message}`);
         process.exitCode = 1;

package/src/commands/tokens.js

@@ -49,6 +49,11 @@ import {
   clearExpired,
 } from "../lib/response-cache.js";
 
+function displayCost(value, unpriced = 0) {
+  if (value == null) return "unpriced";
+  return `$${Number(value).toFixed(4)}${unpriced ? ` (partial; ${unpriced} unpriced calls)` : ""}`;
+}
+
 export function registerTokensCommand(program) {
   const tokens = program
     .command("tokens")
@@ -99,7 +104,7 @@ export function registerTokensCommand(program) {
             `  Total tokens:     ${chalk.cyan(stats.total_tokens.toLocaleString())}`,
           );
           logger.log(
-            `  Total cost:       ${chalk.yellow("$" + stats.total_cost_usd.toFixed(4))}`,
+            `  Total cost:       ${chalk.yellow(displayCost(stats.total_cost_usd, stats.unpriced_calls))}`,
           );
           logger.log(
             `  Avg response:     ${chalk.gray(Math.round(stats.avg_response_time_ms) + "ms")}`,
@@ -108,7 +113,7 @@ export function registerTokensCommand(program) {
           if (options.period !== "today") {
             logger.log(chalk.bold("\n  Today:"));
             logger.log(
-              `    Calls: ${chalk.cyan(todayStats.total_calls)}  Tokens: ${chalk.cyan(todayStats.total_tokens.toLocaleString())}  Cost: ${chalk.yellow("$" + todayStats.total_cost_usd.toFixed(4))}`,
+              `    Calls: ${chalk.cyan(todayStats.total_calls)}  Tokens: ${chalk.cyan(todayStats.total_tokens.toLocaleString())}  Cost: ${chalk.yellow(displayCost(todayStats.total_cost_usd, todayStats.unpriced_calls))}`,
             );
           }
         }
@@ -146,7 +151,7 @@ export function registerTokensCommand(program) {
               `  ${chalk.cyan(row.provider)}/${chalk.white(row.model)}`,
             );
             logger.log(
-              `    Calls: ${row.calls}  Tokens: ${row.total_tokens.toLocaleString()}  Cost: ${chalk.yellow("$" + row.cost_usd.toFixed(4))}`,
+              `    Calls: ${row.calls}  Tokens: ${row.total_tokens.toLocaleString()}  Cost: ${chalk.yellow(displayCost(row.cost_usd, row.unpriced_calls))}`,
             );
           }
         }
@@ -185,7 +190,7 @@ export function registerTokensCommand(program) {
           logger.log(chalk.bold("Recent LLM Calls:\n"));
           for (const e of entries) {
             logger.log(
-              `  ${chalk.gray(e.created_at)}  ${chalk.cyan(e.provider)}/${chalk.white(e.model)}  ${e.total_tokens} tokens  ${chalk.yellow("$" + e.cost_usd.toFixed(4))}  ${chalk.gray(e.response_time_ms + "ms")}`,
+              `  ${chalk.gray(e.created_at)}  ${chalk.cyan(e.provider)}/${chalk.white(e.model)}  ${e.total_tokens} tokens  ${chalk.yellow(displayCost(e.cost_usd))}  ${chalk.gray(e.response_time_ms + "ms")}`,
             );
           }
         }

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.78",
+      "cliVersions": ["0.166.78"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.78: CLI and IDE recovery candidate",
+          "body": "- Add verified session history paging and recovery across CLI, VS Code, and\n  JetBrains, including bounded input and draft handling.\n- Improve process lifecycle and IDE host recovery; keep approval and sandbox\n  boundaries with the CLI host.\n- Repair cross-platform CI fixtures and release validation for the exact source\n  commit. Publish child npm packages before the CLI, then the IDE extensions."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.77",

package/src/generated/cc-agent-protocol.schema.json

@@ -2828,6 +2828,37 @@
         }
       }
     },
+    "AgentTranscriptReferences": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema",
+        "sessionId",
+        "assistantEventId"
+      ],
+      "properties": {
+        "schema": {
+          "const": "chainlesschain.session-transcript-references/v1"
+        },
+        "sessionId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 256
+        },
+        "assistantEventId": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "userEventId": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "clientMessageId": {
+          "type": "string",
+          "pattern": "^[a-zA-Z0-9_-]{1,80}$"
+        }
+      }
+    },
     "AgentResultStreamEvent": {
       "type": "object",
       "required": [
@@ -2868,6 +2899,9 @@
           "type": "integer",
           "minimum": 0
         },
+        "transcript_refs": {
+          "$ref": "#/$defs/AgentTranscriptReferences"
+        },
         "duration_ms": {
           "type": "integer",
           "minimum": 0
@@ -3194,6 +3228,43 @@
           "type": "string",
           "maxLength": 64
         },
+        "permission_mode_state": {
+          "type": "object",
+          "required": [
+            "correlation_id",
+            "requested",
+            "effective",
+            "policy_revision"
+          ],
+          "properties": {
+            "correlation_id": {
+              "type": "string",
+              "pattern": "^[a-zA-Z0-9-]{1,80}$"
+            },
+            "requested": {
+              "enum": [
+                "default",
+                "acceptEdits",
+                "bypassPermissions"
+              ]
+            },
+            "effective": {
+              "enum": [
+                "default",
+                "acceptEdits",
+                "auto",
+                "bypassPermissions",
+                "dontAsk",
+                "plan"
+              ]
+            },
+            "policy_revision": {
+              "type": "string",
+              "pattern": "^[a-f0-9]{16,64}$"
+            }
+          },
+          "additionalProperties": true
+        },
         "tools": {
           "type": "array",
           "items": {