chainlesschain 0.162.155 → 0.162.157

package/src/command-manifest.json

@@ -1,6 +1,6 @@
 {
   "_generated": "scripts/gen-command-manifest.mjs — do not edit by hand",
-  "commandCount": 170,
+  "commandCount": 173,
   "commands": [
     {
       "name": "a2a",
@@ -16,6 +16,13 @@
       "register": "registerActivityPubCommand",
       "summary": "ActivityPub C2S bridge — actors, outbox/inbox, Follow/Create/Like/Announce"
     },
+    {
+      "name": "agenda",
+      "aliases": [],
+      "module": "./commands/agenda.js",
+      "register": "registerAgendaCommand",
+      "summary": "Fire agent-scheduled wakeups / crons / monitors (persisted by the `schedule` tool)"
+    },
     {
       "name": "agent",
       "aliases": ["a"],
@@ -44,6 +51,13 @@
       "register": "registerAndroidCommand",
       "summary": "Android-native bridge: ContentResolver / SAF / Accessibility / Shizuku / root (Plan A A7)"
     },
+    {
+      "name": "artifacts",
+      "aliases": ["artifact"],
+      "module": "./commands/artifacts.js",
+      "register": "registerArtifactsCommand",
+      "summary": "Browse agent-published deliverables (reports/patches/screenshots; see the publish_artifact tool)"
+    },
     {
       "name": "ask",
       "aliases": [],
@@ -100,6 +114,13 @@
       "register": "registerAutomationCommand",
       "summary": "Workflow automation engine — 12 SaaS connectors + triggers (Phase 96)"
     },
+    {
+      "name": "batch",
+      "aliases": [],
+      "module": "./commands/batch.js",
+      "register": "registerBatchCommand",
+      "summary": "Split a large change into independent units, run each in its own git worktree in parallel, and aggregate results"
+    },
     {
       "name": "bi",
       "aliases": [],

package/src/commands/agenda.js

@@ -0,0 +1,228 @@
+/**
+ * `cc agenda` — consumer for the agent-scheduled Monitor / Cron / Wakeup
+ * entries (gap-analysis 第四阶段 #3). The `schedule` agent tool PERSISTS
+ * intent; this command is what actually FIRES it — run it periodically
+ * (`cc loop --every 1m -- cc agenda run`, a system cron, or by hand):
+ *
+ *   cc agenda list [--json]           show all scheduled entries
+ *   cc agenda run [--json] [--dry-run]  fire everything due right now
+ *   cc agenda cancel <id>             remove one entry
+ *
+ * `run` for each due entry:
+ *   - wakeup  → spawn `cc agent -p <prompt>`, mark fired
+ *   - cron    → spawn `cc agent -p <prompt>`, advance to next fire time
+ *   - monitor → run <command>; if output matches stop_when, send the
+ *               notification and stop; else re-arm for the next interval
+ */
+
+import { spawn, execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { AgentScheduleStore } from "../lib/agent-schedule-store.js";
+import { sendAgentNotification } from "../lib/agent-notify.js";
+
+const BIN_PATH = fileURLToPath(
+  new URL("../../bin/chainlesschain.js", import.meta.url),
+);
+
+export function registerAgendaCommand(program) {
+  const cmd = program
+    .command("agenda")
+    .description(
+      "Fire agent-scheduled wakeups / crons / monitors (persisted by the `schedule` tool)",
+    );
+
+  cmd
+    .command("list", { isDefault: true })
+    .description("List all scheduled entries")
+    .option("--kind <kind>", "Filter by kind (wakeup|cron|monitor)")
+    .option("--json", "Machine-readable JSON output")
+    .action((options) => {
+      process.exitCode = runAgendaList(options);
+    });
+
+  cmd
+    .command("run")
+    .description("Fire every entry that is due now")
+    .option("--dry-run", "Show what would fire without running anything")
+    .option("--json", "Machine-readable JSON output")
+    .action(async (options) => {
+      process.exitCode = await runAgendaRun(options);
+    });
+
+  cmd
+    .command("cancel <id>")
+    .description("Remove a scheduled entry by id")
+    .option("--json", "Machine-readable JSON output")
+    .action((id, options) => {
+      process.exitCode = runAgendaCancel(id, options);
+    });
+}
+
+export function runAgendaList(options = {}, _deps = {}) {
+  const log = _deps.log || ((m) => console.log(m));
+  const store = _deps.store || new AgentScheduleStore();
+  const entries = store.list(options.kind || null);
+  if (options.json) {
+    log(JSON.stringify({ entries }, null, 2));
+    return 0;
+  }
+  if (entries.length === 0) {
+    log(chalk.gray("\n  No scheduled entries.\n"));
+    return 0;
+  }
+  log("");
+  log(chalk.bold("  Agenda:\n"));
+  for (const e of entries) {
+    const when =
+      e.kind === "wakeup"
+        ? new Date(e.dueAt).toISOString()
+        : e.kind === "cron"
+          ? `${e.cron} (next ${new Date(e.nextAt).toISOString()})`
+          : `every ${Math.round(e.intervalMs / 1000)}s (next ${new Date(e.nextAt).toISOString()})`;
+    log(
+      `  ${chalk.cyan(e.kind.padEnd(8))} ${chalk.dim(e.id.slice(0, 8))} ` +
+        `${statusBadge(e.status)}  ${e.label || truncate(e.prompt || e.command, 40)}`,
+    );
+    log(`           ${chalk.dim(when)}`);
+  }
+  log("");
+  return 0;
+}
+
+export function runAgendaCancel(id, options = {}, _deps = {}) {
+  const log = _deps.log || ((m) => console.log(m));
+  const store = _deps.store || new AgentScheduleStore();
+  const removed = store.cancel(id);
+  if (options.json) {
+    log(JSON.stringify({ cancelled: removed ? removed.id : null }, null, 2));
+    return removed ? 0 : 2;
+  }
+  if (removed) {
+    log(chalk.green(`\n  ✓ Cancelled ${removed.kind} ${removed.id}\n`));
+    return 0;
+  }
+  log(chalk.red(`\n  ✖ No entry with id ${id}\n`));
+  return 2;
+}
+
+/**
+ * Fire due entries. Returns 0 unless a monitor command / agent spawn failed in
+ * a way worth signalling; JSON summary lists every action taken.
+ */
+export async function runAgendaRun(options = {}, _deps = {}) {
+  const log = _deps.log || ((m) => console.log(m));
+  const store = _deps.store || new AgentScheduleStore();
+  const spawnAgent = _deps.spawnAgent || defaultSpawnAgent;
+  const runCommand = _deps.runCommand || defaultRunCommand;
+  const notify = _deps.notify || sendAgentNotification;
+  const due = store.due(null, _deps.now ? _deps.now() : null);
+  const actions = [];
+
+  for (const entry of due) {
+    if (options.dryRun) {
+      actions.push({ id: entry.id, kind: entry.kind, action: "would-fire" });
+      continue;
+    }
+    try {
+      if (entry.kind === "wakeup") {
+        await spawnAgent(entry.prompt);
+        store.markWakeupFired(entry.id);
+        actions.push({ id: entry.id, kind: "wakeup", action: "fired" });
+      } else if (entry.kind === "cron") {
+        await spawnAgent(entry.prompt);
+        store.advanceCron(entry.id);
+        actions.push({ id: entry.id, kind: "cron", action: "fired" });
+      } else if (entry.kind === "monitor") {
+        const output = await runCommand(entry.command);
+        const matched = entry.stopWhen
+          ? new RegExp(entry.stopWhen).test(output)
+          : false;
+        if (matched) {
+          await notify({
+            title: entry.notify?.title || `Monitor matched: ${entry.command}`,
+            body: truncate(output, 500),
+            level: "success",
+          });
+        }
+        const updated = store.recordMonitorCheck(entry.id, { matched });
+        actions.push({
+          id: entry.id,
+          kind: "monitor",
+          action: matched ? "matched" : "checked",
+          status: updated?.status,
+        });
+      }
+    } catch (err) {
+      actions.push({
+        id: entry.id,
+        kind: entry.kind,
+        action: "error",
+        error: err.message,
+      });
+    }
+  }
+
+  if (options.json) {
+    log(JSON.stringify({ due: due.length, actions }, null, 2));
+  } else if (actions.length === 0) {
+    log(chalk.gray("  Nothing due.\n"));
+  } else {
+    for (const a of actions) {
+      const colour = a.action === "error" ? chalk.red : chalk.green;
+      log(colour(`  ${a.kind} ${a.id.slice(0, 8)}: ${a.action}`));
+    }
+  }
+  return actions.some((a) => a.action === "error") ? 1 : 0;
+}
+
+// ─── default effectful deps (overridable in tests) ─────────────────────────
+
+function defaultSpawnAgent(prompt) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [BIN_PATH, "agent", "-p", prompt], {
+      stdio: "ignore",
+      detached: false,
+      env: process.env,
+    });
+    child.on("error", reject);
+    child.on("close", (code) =>
+      code === 0 || code == null
+        ? resolve(code)
+        : reject(new Error(`cc agent exited with code ${code}`)),
+    );
+  });
+}
+
+function defaultRunCommand(command) {
+  try {
+    return execSync(command, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 60000,
+    });
+  } catch (err) {
+    // A non-zero exit still yields output we want to match against.
+    return (err.stdout || "") + (err.stderr || "");
+  }
+}
+
+function statusBadge(status) {
+  switch (status) {
+    case "pending":
+    case "active":
+      return chalk.green(status);
+    case "fired":
+    case "matched":
+      return chalk.cyan(status);
+    case "exhausted":
+      return chalk.yellow(status);
+    default:
+      return status;
+  }
+}
+
+function truncate(text, n) {
+  const s = String(text || "");
+  return s.length > n ? s.slice(0, n) + "…" : s;
+}

package/src/commands/agent.js

@@ -168,6 +168,18 @@ export function registerAgentCommand(program) {
       "--safe-mode",
       "Run bare: disable project memory, settings hooks, memory recall, IDE context, status line and update notice (permission rules STAY active)",
     )
+    .option(
+      "--bare",
+      "Everything --safe-mode disables PLUS skills, plugins and MCP/IDE auto-connect — minimal fast surface for scripted calls (explicit --mcp-config still loads; permission rules STAY active)",
+    )
+    .option(
+      "--disable-slash-commands",
+      "Interactive REPL: don't dispatch '/' input as slash commands — it reaches the model verbatim (/exit and /quit stay live)",
+    )
+    .option(
+      "--ax-screen-reader",
+      "Screen-reader friendly output: no ANSI colors, no in-place status line repaints (also CC_SCREEN_READER=1)",
+    )
     .option(
       "--worktree",
       "Run this session in a fresh git worktree (isolated branch; auto-removed when the session changes nothing)",
@@ -371,17 +383,44 @@ export function registerAgentCommand(program) {
       }
       // --safe-mode flag OR CC_SAFE_MODE / CLAUDE_CODE_SAFE_MODE env (Claude-Code
       // 2.1.169 parity): flip every customization kill-switch BEFORE anything
-      // loads. Permission rules stay active.
+      // loads. Permission rules stay active. --bare (CC_BARE) is safe mode
+      // PLUS skills, plugins and MCP/IDE/PDH/JetBrains auto-connect off.
       {
-        const { applySafeMode, safeModeRequested } =
-          await import("../lib/safe-mode.js");
-        if (safeModeRequested(options)) {
+        const {
+          applySafeMode,
+          safeModeRequested,
+          applyBareMode,
+          bareModeRequested,
+        } = await import("../lib/safe-mode.js");
+        if (bareModeRequested(options)) {
+          const applied = applyBareMode();
+          // Ambient auto-connects off; an EXPLICIT --ide/--pdh/--jetbrains
+          // (or --mcp-config, handled downstream) still wins — bare kills
+          // defaults, not explicit input.
+          options.mcp = false;
+          if (options.ide === undefined) options.ide = false;
+          if (options.pdh === undefined) options.pdh = false;
+          if (options.jetbrains === undefined) options.jetbrains = false;
+          process.stderr.write(
+            `bare mode: hooks/skills/plugins/memory/MCP-auto-connect disabled (${applied.join(", ")}) — permission rules stay active.\n`,
+          );
+        } else if (safeModeRequested(options)) {
           const applied = applySafeMode();
           process.stderr.write(
             `safe mode: customizations disabled (${applied.join(", ")}) — permission rules stay active.\n`,
           );
         }
       }
+      // --ax-screen-reader flag OR CC_SCREEN_READER env: linear output for
+      // screen readers (mono theme + no repainting status line). Applied
+      // before anything renders.
+      {
+        const { screenReaderRequested, applyScreenReaderMode } =
+          await import("../lib/accessibility.js");
+        if (screenReaderRequested(options)) {
+          applyScreenReaderMode();
+        }
+      }
       // --project-mcp: opt IN to project-scoped `.mcp.json` discovery, which is
       // off by default (a checked-in .mcp.json can spawn commands). loadProjectMcp
       // reads CC_PROJECT_MCP; set it here so the opt-in reaches every run mode
@@ -1089,6 +1128,8 @@ export function registerAgentCommand(program) {
         pdh: options.pdh,
         // --jetbrains / --no-jetbrains: IDEA built-in MCP for the interactive session
         jetbrains: options.jetbrains,
+        // --disable-slash-commands: REPL sends "/" input to the model verbatim
+        disableSlashCommands: options.disableSlashCommands === true,
       });
       await runtime.startAgentSession();
       // Interactive session ended (REPL closed) — settle the worktree.

package/src/commands/artifacts.js

@@ -0,0 +1,161 @@
+/**
+ * `cc artifacts` — browse/manage the agent-published deliverable store
+ * (gap-analysis P1 #10). The `publish_artifact` agent tool copies finished
+ * deliverables (reports/patches/screenshots/logs) into
+ * `~/.chainlesschain/artifacts/`; this command is the user-facing surface:
+ *
+ *   cc artifacts list [--session <id>] [--kind <k>] [--json]
+ *   cc artifacts show <id> [--json]        metadata + stored path
+ *   cc artifacts open <id>                 print the stored path (pipe/open)
+ *   cc artifacts remove <id>
+ *   cc artifacts clean [--json]            drop expired artifacts (TTL)
+ */
+
+import chalk from "chalk";
+import { ArtifactStore } from "../lib/artifact-store.js";
+
+export function registerArtifactsCommand(program) {
+  const cmd = program
+    .command("artifacts")
+    .alias("artifact")
+    .description(
+      "Browse agent-published deliverables (reports/patches/screenshots; see the publish_artifact tool)",
+    );
+
+  cmd
+    .command("list", { isDefault: true })
+    .description("List published artifacts")
+    .option("--session <id>", "Only artifacts from one agent session")
+    .option(
+      "--kind <kind>",
+      "Filter by kind (report|patch|screenshot|log|data|other)",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .action((options) => {
+      process.exitCode = runArtifactsList(options);
+    });
+
+  cmd
+    .command("show <id>")
+    .description("Show one artifact's metadata + stored path")
+    .option("--json", "Machine-readable JSON output")
+    .action((id, options) => {
+      process.exitCode = runArtifactsShow(id, options);
+    });
+
+  cmd
+    .command("open <id>")
+    .description("Print the artifact's stored file path (for piping/opening)")
+    .action((id) => {
+      process.exitCode = runArtifactsOpen(id);
+    });
+
+  cmd
+    .command("remove <id>")
+    .alias("rm")
+    .description("Remove one artifact (stored copy + metadata)")
+    .option("--json", "Machine-readable JSON output")
+    .action((id, options) => {
+      process.exitCode = runArtifactsRemove(id, options);
+    });
+
+  cmd
+    .command("clean")
+    .description("Remove expired artifacts (past their TTL)")
+    .option("--json", "Machine-readable JSON output")
+    .action((options) => {
+      process.exitCode = runArtifactsClean(options);
+    });
+}
+
+export function runArtifactsList(options = {}, deps = {}) {
+  const store = deps.store || new ArtifactStore();
+  let entries = store.list({ sessionId: options.session });
+  if (options.kind) {
+    entries = entries.filter((e) => e.kind === String(options.kind));
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ artifacts: entries }, null, 2));
+    return 0;
+  }
+  if (entries.length === 0) {
+    console.log(
+      chalk.dim(
+        "No artifacts. Agents publish deliverables with the publish_artifact tool.",
+      ),
+    );
+    return 0;
+  }
+  for (const e of entries) {
+    console.log(
+      `${chalk.cyan(e.id)}  ${chalk.bold(e.title)}  ${chalk.dim(
+        `[${e.kind}] ${e.mime} ${e.size}B ${e.createdAt}${
+          e.sessionId ? ` session=${e.sessionId}` : ""
+        }`,
+      )}`,
+    );
+  }
+  console.log(
+    chalk.dim(`${entries.length} artifact(s). cc artifacts show <id>`),
+  );
+  return 0;
+}
+
+export function runArtifactsShow(id, options = {}, deps = {}) {
+  const store = deps.store || new ArtifactStore();
+  const entry = store.get(id);
+  if (!entry) {
+    console.error(chalk.red(`No artifact with id "${id}".`));
+    return 1;
+  }
+  const payload = { ...entry, storedPath: store.storedPath(entry) };
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return 0;
+  }
+  for (const [k, v] of Object.entries(payload)) {
+    console.log(`${chalk.dim(k.padEnd(11))} ${v == null ? "" : v}`);
+  }
+  return 0;
+}
+
+export function runArtifactsOpen(id, deps = {}) {
+  const store = deps.store || new ArtifactStore();
+  const entry = store.get(id);
+  if (!entry) {
+    console.error(chalk.red(`No artifact with id "${id}".`));
+    return 1;
+  }
+  console.log(store.storedPath(entry));
+  return 0;
+}
+
+export function runArtifactsRemove(id, options = {}, deps = {}) {
+  const store = deps.store || new ArtifactStore();
+  const found = store.remove(id);
+  if (options.json) {
+    console.log(JSON.stringify({ removed: found ? id : null, found }));
+    return found ? 0 : 1;
+  }
+  if (!found) {
+    console.error(chalk.red(`No artifact with id "${id}".`));
+    return 1;
+  }
+  console.log(chalk.green(`Removed ${id}.`));
+  return 0;
+}
+
+export function runArtifactsClean(options = {}, deps = {}) {
+  const store = deps.store || new ArtifactStore();
+  const { removed } = store.cleanupExpired();
+  if (options.json) {
+    console.log(JSON.stringify({ removed }));
+    return 0;
+  }
+  console.log(
+    removed > 0
+      ? chalk.green(`Removed ${removed} expired artifact(s).`)
+      : chalk.dim("Nothing expired."),
+  );
+  return 0;
+}