chainlesschain 0.162.93 → 0.162.95

package/src/lib/file-checkpoint.js

@@ -43,6 +43,33 @@ function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
+/**
+ * Write a file atomically: write to a unique temp sibling, then rename over the
+ * target. rename() is atomic within a filesystem, so a crash mid-write leaves
+ * the previous file (or nothing) intact — never a half-written manifest/blob.
+ * Without this, a checkpoint manifest truncated by a crash makes the whole
+ * checkpoint unrecoverable (getCheckpoint's JSON.parse fails → null) while its
+ * blobs are orphaned on disk. The temp lives in the SAME dir as the target so
+ * the rename stays on one filesystem; on failure the temp is best-effort
+ * removed. Temp names end in `.tmp` (never `.json`), so a leftover from a hard
+ * crash is ignored by listCheckpoints.
+ */
+function atomicWriteFileSync(filePath, data) {
+  const rand = Math.random().toString(36).slice(2, 8);
+  const tmp = `${filePath}.${process.pid}.${rand}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data);
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {
+      /* best-effort temp cleanup */
+    }
+    throw err;
+  }
+}
+
 function sha256(buf) {
   return createHash("sha256").update(buf).digest("hex");
 }
@@ -127,7 +154,7 @@ export function createCheckpoint(paths, opts = {}) {
     const buf = fs.readFileSync(abs);
     const hash = sha256(buf);
     const blobPath = path.join(blobDir, hash);
-    if (!fs.existsSync(blobPath)) fs.writeFileSync(blobPath, buf);
+    if (!fs.existsSync(blobPath)) atomicWriteFileSync(blobPath, buf);
     files.push({
       rel: path.relative(cwd, abs) || path.basename(abs),
       abs,
@@ -145,10 +172,9 @@ export function createCheckpoint(paths, opts = {}) {
     files,
   };
   ensureDir(root);
-  fs.writeFileSync(
+  atomicWriteFileSync(
     path.join(root, `${id}.json`),
     JSON.stringify(manifest, null, 2),
-    "utf-8",
   );
   return manifest;
 }
@@ -275,7 +301,7 @@ export function restoreCheckpoint(id, opts = {}) {
 
   for (const w of toWrite) {
     ensureDir(path.dirname(w.abs));
-    fs.writeFileSync(w.abs, w.blob);
+    atomicWriteFileSync(w.abs, w.blob);
     restored.push(w.rel);
   }
 

package/src/lib/pdh-bridge.js

@@ -0,0 +1,266 @@
+/**
+ * PDH bridge discovery (Phase 0) — find a first-party "device capability" MCP
+ * server that the Android app advertises via a lockfile, and turn it into an
+ * MCP server config the agent loop can connect to.
+ *
+ * This is the cc-side (CLI) half of the Personal-Data IDE / PDH Bridge
+ * (design: docs/design/modules/101_个人数据IDE桥接方案.md). It mirrors the IDE
+ * bridge (ide-bridge.js, design module 98): the app runs a localhost MCP server
+ * exposing collect / query / file / task tools, and writes
+ *     <appFiles>/.chainlesschain/pdh-bridge/<port>.json   (file 0600, dir 0700)
+ * The app ALSO injects CHAINLESSCHAIN_PDH_PORT (+ optional _TOKEN) into the env
+ * of the in-APK cc it spawns, so cc locks onto the exact instance without
+ * scanning ("path A"). External agents (e.g. desktop over a forwarded port)
+ * fall back to a lockfile scan ("path B").
+ *
+ * Unlike the IDE bridge there is no multi-root workspace concept: a device has
+ * a single PDH server, so discovery is env-port → else the newest live lock.
+ *
+ * Pure CLI, no Android dependency, fully unit-testable through `_deps`. The
+ * connect path reuses the existing MCP client (HTTP) via mcp-config.js
+ * `loadPdhMcp`. Reserved server name `pdh` → tools `mcp__pdh__*`.
+ *
+ * NOTE: the discovery mechanics (localhost / transport / stale filtering,
+ * env fast-path, bearer headers) duplicate ide-bridge.js by design — keeping
+ * the two bridges decoupled for Phase 0. A later refactor may extract a shared
+ * device-bridge core; until then this file is self-contained on purpose.
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+/** A lock whose pid is dead and whose file is older than this = stale. */
+const STALE_TTL_MS = 30_000;
+
+/** Transports the CLI's MCP client can actually talk (see mcp-client.js). */
+const SUPPORTED_TRANSPORTS = new Set(["http", "https", "sse"]);
+
+/** Lock `kind` we accept (absent is tolerated; the dir already scopes us). */
+const EXPECTED_KIND = "pdh-bridge";
+
+/** Liveness probe via signal 0 — cross-platform (works on Windows too). */
+function defaultProcessAlive(pid) {
+  if (!pid || typeof pid !== "number") return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM: the process exists but we may not signal it → still alive.
+    return !!(err && err.code === "EPERM");
+  }
+}
+
+export const _deps = {
+  readDir: (d) => fs.readdirSync(d),
+  readFile: (p) => fs.readFileSync(p, "utf-8"),
+  statMtimeMs: (p) => fs.statSync(p).mtimeMs,
+  homedir: () => os.homedir(),
+  now: () => Date.now(),
+  processAlive: defaultProcessAlive,
+};
+
+/** `~/.chainlesschain/pdh-bridge/`. */
+export function pdhLockDir(deps = _deps) {
+  return path.join(deps.homedir(), ".chainlesschain", "pdh-bridge");
+}
+
+function isLocalhostUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname === "127.0.0.1" || u.hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function inferTransportFromUrl(url) {
+  if (/\/sse(\b|\/|$)/i.test(url)) return "sse";
+  if (/^https:/i.test(url)) return "https";
+  if (/^http:/i.test(url)) return "http";
+  return null;
+}
+
+/** Parse + validate one lock JSON. Returns a normalized lock or null. */
+function parseLock(raw, filePath) {
+  let lock;
+  try {
+    lock = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!lock || typeof lock !== "object") return null;
+  // Reject a foreign lock kind if present; absent kind is tolerated (the
+  // pdh-bridge/ dir already scopes us, but a stray file gets rejected here).
+  if (lock.kind != null && String(lock.kind) !== EXPECTED_KIND) return null;
+  if (!lock.url || !isLocalhostUrl(lock.url)) return null;
+
+  const transport = String(
+    lock.transport || inferTransportFromUrl(lock.url) || "",
+  ).toLowerCase();
+  if (!SUPPORTED_TRANSPORTS.has(transport)) return null; // e.g. ws — not yet
+
+  return {
+    kind: EXPECTED_KIND,
+    device: typeof lock.device === "string" ? lock.device : "unknown",
+    appUid: typeof lock.appUid === "number" ? lock.appUid : null,
+    transport,
+    url: lock.url,
+    port: lock.port,
+    token: typeof lock.token === "string" ? lock.token : null,
+    pid: typeof lock.pid === "number" ? lock.pid : null,
+    startedAt: typeof lock.started_at === "number" ? lock.started_at : 0,
+    _file: filePath,
+  };
+}
+
+/** True when a lock is dead: pid gone AND file older than the TTL. */
+function isStale(lock, deps) {
+  if (lock.pid && deps.processAlive(lock.pid)) return false;
+  let mtime;
+  try {
+    mtime = deps.statMtimeMs(lock._file);
+  } catch {
+    return true;
+  }
+  return deps.now() - mtime > STALE_TTL_MS;
+}
+
+/**
+ * Scan the lock dir → normalized, live, localhost, supported-transport locks.
+ * Missing dir / unreadable files are silently skipped (best-effort).
+ */
+export function readPdhLocks(deps = _deps) {
+  const dir = pdhLockDir(deps);
+  let names;
+  try {
+    names = deps.readDir(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names || []) {
+    if (!String(name).endsWith(".json")) continue;
+    const fp = path.join(dir, name);
+    let raw;
+    try {
+      raw = deps.readFile(fp);
+    } catch {
+      continue;
+    }
+    const lock = parseLock(raw, fp);
+    if (!lock) continue;
+    if (isStale(lock, deps)) continue;
+    out.push(lock);
+  }
+  return out;
+}
+
+/** Is the env wired to a PDH bridge (app-spawned cc, or explicit opt-in)? */
+export function isInPdhTerminal(env = process.env) {
+  if (!env) return false;
+  if (env.CHAINLESSCHAIN_PDH_PORT) return true;
+  if (env.CHAINLESSCHAIN_PDH) return true;
+  return false;
+}
+
+/**
+ * Pick the PDH server to connect to, or null.
+ *
+ * Path A (deterministic): if `CHAINLESSCHAIN_PDH_PORT` is set and a live lock
+ *   has that port, use it (token may come from the lock or the env).
+ * Path B (scan): otherwise the newest live lock (a device has one PDH server;
+ *   no workspace concept to match on, unlike the IDE bridge).
+ *
+ * @param {object} opts { env?, force? }   (force kept for API symmetry)
+ * @param {object} [deps]
+ */
+export function discoverPdhServer(
+  { env = process.env, force = false } = {},
+  deps = _deps,
+) {
+  void force; // no workspace gating for PDH; param kept for call-site symmetry
+  const locks = readPdhLocks(deps);
+  if (!locks.length) return null;
+
+  // Path A — env fast-path.
+  const envPort = env && env.CHAINLESSCHAIN_PDH_PORT;
+  if (envPort) {
+    const hit = locks.find((l) => String(l.port) === String(envPort));
+    if (hit) {
+      if (!hit.token && env.CHAINLESSCHAIN_PDH_TOKEN) {
+        hit.token = env.CHAINLESSCHAIN_PDH_TOKEN;
+      }
+      return hit;
+    }
+    // env named a port with no live lock — fall through to newest.
+  }
+
+  // Path B — newest live lock.
+  return locks.slice().sort((a, b) => b.startedAt - a.startedAt)[0];
+}
+
+/**
+ * A discovered lock → an MCP server config row for `setupMcpFromConfig`.
+ * `longRunning` flags the server as exempt from the agent loop's per-call
+ * timeout: PDH collect tools can block on `assist_required` (the user does a
+ * step in the target app, then resumes) — the same blocking-tool contract as
+ * the IDE bridge's `openDiff`.
+ */
+export function pdhServerToMcpConfig(lock) {
+  if (!lock || !lock.url) return null;
+  const headers = {};
+  if (lock.token) headers.Authorization = `Bearer ${lock.token}`;
+  return {
+    url: lock.url,
+    transport: lock.transport,
+    headers,
+    longRunning: true,
+  };
+}
+
+/**
+ * Human-readable explanation of why discovery did/didn't find a server — backs
+ * `cc pdh doctor`. Returns { inPdhTerminal, lockDir, locks:[...], chosen, reason }.
+ */
+export function diagnosePdh(
+  { env = process.env, force = false } = {},
+  deps = _deps,
+) {
+  const inPdhTerminal = isInPdhTerminal(env);
+  const locks = readPdhLocks(deps);
+  const chosen = discoverPdhServer({ env, force }, deps);
+
+  let reason;
+  if (chosen) {
+    reason =
+      env &&
+      env.CHAINLESSCHAIN_PDH_PORT &&
+      String(chosen.port) === String(env.CHAINLESSCHAIN_PDH_PORT)
+        ? "matched CHAINLESSCHAIN_PDH_PORT (env fast-path)"
+        : "newest live lock";
+  } else if (!locks.length) {
+    reason =
+      "no live PDH lockfiles in " +
+      pdhLockDir(deps) +
+      " (is the app's PDH bridge server running? are locks stale?)";
+  } else {
+    reason = "lockfiles present but none usable";
+  }
+  return {
+    inPdhTerminal,
+    lockDir: pdhLockDir(deps),
+    locks: locks.map((l) => ({
+      device: l.device,
+      appUid: l.appUid,
+      port: l.port,
+      transport: l.transport,
+      url: l.url,
+      hasToken: !!l.token,
+      pid: l.pid,
+    })),
+    chosen: chosen
+      ? { device: chosen.device, port: chosen.port, url: chosen.url }
+      : null,
+    reason,
+  };
+}

package/src/lib/repl-completer.js

@@ -128,8 +128,12 @@ export function makeAtCompleter(opts = {}) {
       });
   };
 
+  // De-duplicate before sorting so a drifted/aliased entry in the hand-
+  // maintained command list never shows twice in the autocomplete (mirrors the
+  // @-path's `new Set` merge below; Claude-Code 2.1.183 fixed the same class of
+  // duplicate-in-slash-autocomplete bug).
   const slashCommands = Array.isArray(opts.slashCommands)
-    ? [...opts.slashCommands].sort()
+    ? [...new Set(opts.slashCommands)].sort()
     : [];
 
   const completer = (line) => {

package/src/lib/session-tail.js

@@ -89,6 +89,10 @@ export async function* followSession(sessionId, options = {}) {
       ? fromOffset
       : initialOffset(sessionId, { fromStart });
   let buffer = "";
+  // Streaming decoder persisted across polls: when the file grows by a partial
+  // multi-byte UTF-8 character between reads (the rest arrives next poll), the
+  // held bytes are reassembled instead of corrupted into U+FFFD.
+  let decoder = new TextDecoder("utf-8");
 
   // eslint-disable-next-line no-constant-condition
   while (true) {
@@ -100,6 +104,7 @@ export async function* followSession(sessionId, options = {}) {
         // File was truncated / rotated — restart from beginning
         offset = 0;
         buffer = "";
+        decoder = new TextDecoder("utf-8"); // drop any held partial-char bytes
       }
       if (stat.size > offset) {
         const fd = await fsp.open(filePath, "r");
@@ -108,7 +113,7 @@ export async function* followSession(sessionId, options = {}) {
           const buf = Buffer.alloc(length);
           await fd.read(buf, 0, length, offset);
           offset = stat.size;
-          buffer += buf.toString("utf-8");
+          buffer += decoder.decode(buf, { stream: true });
         } finally {
           await fd.close();
         }

package/src/lib/skill-mcp.js

@@ -118,10 +118,16 @@ export async function mountSkillMcpServers(mcpClient, skill, opts = {}) {
   for (const server of declared) {
     const normalized = validateMcpServerConfig(server);
     if (!normalized) {
-      skipped.push({
-        name: server?.name || "(invalid)",
-        error: "invalid config",
-      });
+      const name = server?.name || "(invalid)";
+      skipped.push({ name, error: "invalid config" });
+      // Surface invalid configs too — previously only connect FAILURES warned,
+      // so a malformed server config was dropped silently and the skill author
+      // never learned why their MCP server didn't mount.
+      if (typeof opts.onWarn === "function") {
+        opts.onWarn(
+          `[skill-mcp] Skipped "${name}" for skill "${skill?.id || skill?.name}": invalid config`,
+        );
+      }
       continue;
     }
     try {

package/src/repl/agent-repl.js

@@ -1946,6 +1946,11 @@ export async function startAgentRepl(options = {}) {
             messages.length = 1; // keep system prompt
             messages.push(...rebuilt.filter((m) => m.role !== "system"));
             sessionId = resumeId;
+            // The prior session's checkpoint marks (turn-index → checkpoint id)
+            // no longer map to this swapped-in history; keeping them would make
+            // a later /rewind restore files from the WRONG session's snapshot.
+            // Same reset /clear does on a context swap.
+            _checkpointMarks.length = 0;
             logger.info(
               `Resumed JSONL session ${sessionId} (${rebuilt.length} messages)`,
             );
@@ -1959,6 +1964,8 @@ export async function startAgentRepl(options = {}) {
               messages.length = 1; // keep system prompt
               messages.push(...parsed.filter((m) => m.role !== "system"));
               sessionId = existing.id;
+              // Drop the prior session's checkpoint marks (see JSONL branch).
+              _checkpointMarks.length = 0;
               logger.info(
                 `Resumed session ${sessionId} (${parsed.length} messages)`,
               );
@@ -2660,7 +2667,7 @@ export async function startAgentRepl(options = {}) {
 
     // `/sessions` — list recent RESUMABLE conversations (read-only; the ids
     // work with `cc agent --resume <id>`). `/session` shows the current one.
-    if (trimmed === "/sessions" || trimmed === "/sessions ") {
+    if (trimmed === "/sessions" || trimmed.startsWith("/sessions ")) {
       try {
         const { listRecentSessions } = await import("../lib/recent-session.js");
         const { renderRecentSessions } = await import("./recent-sessions.js");
@@ -2676,7 +2683,7 @@ export async function startAgentRepl(options = {}) {
     // `/memory` — project-memory files auto-loaded into the system prompt
     // (cc.md hierarchy + imports + path-scoped rules). Distinct from `#` (add
     // a note) and `cc memory recall` (scoped store).
-    if (trimmed === "/memory" || trimmed === "/memory ") {
+    if (trimmed === "/memory" || trimmed.startsWith("/memory ")) {
       try {
         const { loadProjectInstructions } =
           await import("../lib/project-instructions.js");
@@ -2695,7 +2702,7 @@ export async function startAgentRepl(options = {}) {
     }
 
     // `/mcp` — overview of connected MCP servers' resources + prompts.
-    if (trimmed === "/mcp" || trimmed === "/mcp ") {
+    if (trimmed === "/mcp" || trimmed.startsWith("/mcp ")) {
       const mcpClient = _adhocMcp?.mcpClient || _bundleMcpClient;
       logger.log(renderMcpSurface(mcpClient));
       prompt();
@@ -2753,7 +2760,7 @@ export async function startAgentRepl(options = {}) {
 
     // `/doctor` — consolidated session-health readout (Claude-Code parity):
     // provider/key/IDE/MCP/permissions/hooks in one pass-or-warn view.
-    if (trimmed === "/doctor" || trimmed === "/doctor ") {
+    if (trimmed === "/doctor" || trimmed.startsWith("/doctor ")) {
       let config = {};
       try {
         config = (await import("../lib/config-manager.js")).loadConfig() || {};
@@ -2860,7 +2867,7 @@ export async function startAgentRepl(options = {}) {
 
     // `/cost` — running token spend + estimated $ for this session (Claude-Code
     // parity). In-memory accumulation, so it works without session persistence.
-    if (trimmed === "/cost" || trimmed === "/cost ") {
+    if (trimmed === "/cost" || trimmed.startsWith("/cost ")) {
       let overrides;
       let visionModel;
       try {
@@ -2937,7 +2944,7 @@ export async function startAgentRepl(options = {}) {
 
     // `/ide` — IDE bridge connection status (Claude-Code parity): which editor
     // is connected, its tools, or why discovery came up empty.
-    if (trimmed === "/ide" || trimmed === "/ide ") {
+    if (trimmed === "/ide" || trimmed.startsWith("/ide ")) {
       let diag = null;
       try {
         const { diagnoseIde } = await import("../lib/ide-bridge.js");

package/src/runtime/agent-core.js

@@ -3838,6 +3838,11 @@ export async function* agentLoop(messages, options) {
   // True once a Stop hook has forced a continuation — passed to the next Stop
   // hook as `stop_hook_active` so a well-behaved hook won't block forever.
   let stopHookActive = false;
+  // True once we have already re-prompted a thinking-only turn (a turn that
+  // produced extended-thinking but no visible text and no tool calls). The
+  // one-shot guard means a model that keeps returning empty turns completes
+  // rather than looping forever (the iteration budget is the hard backstop).
+  let emptyThinkingReprompted = false;
 
   while (budget.hasRemaining()) {
     budget.consume();
@@ -4036,6 +4041,26 @@ export async function* agentLoop(messages, options) {
             .join("")
             .trim()
         : "";
+      // Claude Code 2.1.183 parity: a turn that produced ONLY extended-thinking
+      // (no visible text, no tool calls) would otherwise complete silently with
+      // an empty answer — the user sees nothing. Re-prompt the model ONCE to
+      // surface its actual response. Mirrors the Stop-hook continuation path
+      // below (push assistant turn + a user nudge, then continue). Scoped to the
+      // thinking-only case so a genuinely empty completion (no thinking) still
+      // ends instead of looping.
+      const _contentEmpty = !String(msg.content || "").trim();
+      if (_contentEmpty && _thinking && !emptyThinkingReprompted) {
+        emptyThinkingReprompted = true;
+        messages.push({ role: "assistant", content: "" });
+        messages.push({
+          role: "user",
+          content:
+            "You ended your turn with only internal reasoning and no visible " +
+            "response. Please provide your actual answer now.",
+        });
+        yield { type: "empty-thinking-reprompt", runId };
+        continue;
+      }
       yield {
         type: "response-complete",
         content: msg.content || "",

package/src/runtime/headless-runner.js

@@ -414,6 +414,40 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     writeErr("No previous session to continue; starting a new one.\n");
   }
 
+  // Machine-readable modes (`--output-format json` / `stream-json`) must ALWAYS
+  // end with a terminal result envelope — a consumer parsing stdout otherwise
+  // gets nothing and can't tell success from failure. Several setup-phase error
+  // paths below early-return BEFORE the main loop's try/catch envelope (and
+  // before `system/init`), so route them through this so stdout is never empty.
+  // No-op in text mode (those paths already writeErr a human message).
+  const emitHeadlessError = (resultMsg) => {
+    if (isStream) {
+      writeOut(
+        JSON.stringify({
+          type: "result",
+          subtype: "error",
+          is_error: true,
+          error: resultMsg,
+        }) + "\n",
+      );
+    } else if (isJson) {
+      writeOut(
+        JSON.stringify(
+          buildResultEnvelope({
+            subtype: "error",
+            isError: true,
+            result: resultMsg,
+            sessionId,
+            toolCalls: [],
+            usage: {},
+            numTurns: 0,
+            durationMs: 0,
+          }),
+        ) + "\n",
+      );
+    }
+  };
+
   // Load prior conversation when resuming an existing session. The fresh
   // system prompt always leads; we drop any persisted system turns so it is
   // never duplicated.
@@ -489,11 +523,9 @@ export async function runAgentHeadless(options = {}, deps = {}) {
         writeErr(
           `[hook] prompt blocked${ups.reason ? ": " + ups.reason : ""}\n`,
         );
-        return {
-          exitCode: 2,
-          result: ups.reason || "blocked by UserPromptSubmit hook",
-          isError: true,
-        };
+        const reason = ups.reason || "blocked by UserPromptSubmit hook";
+        emitHeadlessError(reason);
+        return { exitCode: 2, result: reason, isError: true };
       }
       if (ups.additionalContext) {
         userContent += `\n\n[hook context]\n${ups.additionalContext}`;
@@ -593,6 +625,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
       }
     } catch (err) {
       writeErr(`Error: ${err.message}\n`);
+      emitHeadlessError(err.message);
       return { exitCode: 1, result: err.message, isError: true };
     }
   }
@@ -635,6 +668,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     } catch (err) {
       writeErr(`Error: ${err.message}\n`);
       if (mcp?.mcpClient) await mcp.mcpClient.disconnectAll().catch(() => {});
+      emitHeadlessError(err.message);
       return { exitCode: 1, result: err.message, isError: true };
     }
     if (approvalGate && typeof approvalGate.setConfirmer === "function") {