chainlesschain 0.162.29 → 0.162.31

package/src/lib/personal-data-hub-wiring.js

@@ -263,11 +263,41 @@ async function initHub() {
     // Fall back to rule-only — registry still works
   }
 
+  // ADB one-click readiness for the social platforms (B站/微博/抖音/小红书/
+  // 头条/快手): each has a *AdbSync hub method that pulls from a rooted phone
+  // over USB. The probe runs one `adb devices` so readiness() can show
+  // "已连接手机，点一键采集" vs "请插上 root 手机" instead of the misleading
+  // snapshot guidance. Best-effort — never throws into the readiness probe.
+  const ADB_ONE_CLICK_NAMES = new Set([
+    "social-bilibili",
+    "social-weibo",
+    "social-douyin",
+    "social-xiaohongshu",
+    "social-toutiao",
+    "social-kuaishou",
+  ]);
+  const adbReadinessProbe = async () => {
+    try {
+      const { listDevices } = await import("./host-adb-bridge.js");
+      const serials = await listDevices();
+      return {
+        deviceConnected: Array.isArray(serials) && serials.length > 0,
+        serial: serials && serials[0],
+      };
+    } catch (_e) {
+      return { deviceConnected: false };
+    }
+  };
+
   const registry = new AdapterRegistry({
     vault,
     kgSink: kgSink ? kgSink.write.bind(kgSink) : null,
     ragSink: ragSink ? ragSink.write.bind(ragSink) : null,
     entityResolver,
+    adbReadiness: {
+      probe: adbReadinessProbe,
+      oneClickNames: ADB_ONE_CLICK_NAMES,
+    },
   });
 
   const engine = new AnalysisEngine({

package/src/lib/recent-session.js

@@ -0,0 +1,72 @@
+/**
+ * Resolve the most-recent session id across both stores (DB + JSONL).
+ *
+ * Shared by `cc agent --continue` and `cc session resume` (id-less form) so a
+ * user can pick up the last conversation with a one-liner — Claude-Code
+ * `claude --continue` parity.
+ */
+
+import { listSessions } from "./session-manager.js";
+import { listJsonlSessions } from "../harness/jsonl-session-store.js";
+import { feature } from "./feature-flags.js";
+
+/**
+ * Merge both stores into a single newest-first, id-deduped list.
+ *
+ * @param {object} ctx   bootstrap() context (may be null; db is optional)
+ * @param {object} [opts]
+ * @param {number} [opts.scan=20]  how many recent rows to merge per store
+ * @returns {Array<object>}  session rows (id, title, message_count, updated_at, _store)
+ */
+export function listRecentSessions(ctx, opts = {}) {
+  const scan = Math.max(1, opts.scan || 20);
+  const sessions = [];
+
+  if (ctx && ctx.db) {
+    try {
+      const db = ctx.db.getDatabase();
+      sessions.push(
+        ...listSessions(db, { limit: scan }).map((s) => ({
+          ...s,
+          _store: "db",
+        })),
+      );
+    } catch (err) {
+      /* db unavailable — fall through to JSONL */
+      void err;
+    }
+  }
+
+  if (feature("JSONL_SESSION")) {
+    try {
+      sessions.push(
+        ...listJsonlSessions({ limit: scan }).map((s) => ({
+          ...s,
+          _store: "jsonl",
+        })),
+      );
+    } catch (err) {
+      void err;
+    }
+  }
+
+  // Dedup by id (JSONL precedence via sort+seen), newest updated_at first.
+  const seen = new Set();
+  return sessions
+    .sort((a, b) => ((b.updated_at || "") > (a.updated_at || "") ? 1 : -1))
+    .filter((s) => {
+      if (!s || !s.id || seen.has(s.id)) return false;
+      seen.add(s.id);
+      return true;
+    });
+}
+
+/**
+ * @param {object} ctx   bootstrap() context (may be null; db is optional)
+ * @param {object} [opts] forwarded to {@link listRecentSessions}
+ * @returns {string|null}  the most-recently-updated session id, or null
+ */
+export function resolveMostRecentSessionId(ctx, opts = {}) {
+  const sessions = listRecentSessions(ctx, opts);
+  return sessions.length > 0 ? sessions[0].id : null;
+}

package/src/lib/session-picker.js

@@ -0,0 +1,68 @@
+/**
+ * Interactive "which session to resume?" picker — shared by `cc session resume`
+ * and `cc agent --resume/--continue` so both render the same list and apply the
+ * same fallbacks (Claude-Code `--resume` parity).
+ *
+ * Behaviour:
+ *  - 0 sessions            → { id: null }   (caller decides how to report)
+ *  - non-TTY / single / noPicker → most-recent, no prompt (claude --continue)
+ *  - TTY + >1 sessions     → inquirer `select`; Ctrl-C falls back to most-recent
+ *
+ * All non-determinism (the session list, TTY-ness, the prompt fn) is injectable
+ * via `deps` so the deterministic branches are unit-testable without a TTY.
+ */
+
+import chalk from "chalk";
+import { listRecentSessions } from "./recent-session.js";
+
+/** Render one session row for the picker list. */
+export function formatSessionChoice(s) {
+  const title = (s.title || "Untitled").slice(0, 50).padEnd(50);
+  const msgs = chalk.cyan(`${s.message_count ?? 0} msgs`);
+  const when = chalk.gray(s.updated_at || "");
+  const store = s._store === "jsonl" ? " " + chalk.yellow("[JSONL]") : "";
+  return {
+    name: `${title} ${msgs}  ${when}${store}`,
+    value: s.id,
+    short: String(s.id).slice(0, 12),
+  };
+}
+
+/**
+ * Resolve which recent session to resume.
+ *
+ * @param {object} ctx              bootstrap() context (db optional)
+ * @param {object} [opts]
+ * @param {string} [opts.message]   picker prompt
+ * @param {boolean} [opts.noPicker] force most-recent, skip the prompt
+ * @param {number} [opts.scan]      forwarded to listRecentSessions
+ * @param {object} [deps]           { listRecentSessions, isTTY, select }
+ * @returns {Promise<{id:string|null, sessions:Array, picked:boolean}>}
+ */
+export async function pickRecentSession(ctx, opts = {}, deps = {}) {
+  const list = deps.listRecentSessions || listRecentSessions;
+  const isTTY =
+    deps.isTTY !== undefined ? deps.isTTY : Boolean(process.stdin.isTTY);
+
+  const sessions = list(ctx, { scan: opts.scan });
+  if (!sessions || sessions.length === 0) {
+    return { id: null, sessions: [], picked: false };
+  }
+
+  // No interactive prompt possible/wanted → newest wins (claude --continue).
+  if (!isTTY || sessions.length === 1 || opts.noPicker) {
+    return { id: sessions[0].id, sessions, picked: false };
+  }
+
+  const select = deps.select || (await import("@inquirer/prompts")).select;
+  try {
+    const id = await select({
+      message: opts.message || "Resume which session?",
+      choices: sessions.map(formatSessionChoice),
+    });
+    return { id, sessions, picked: true };
+  } catch {
+    // Ctrl-C / non-interactive environment → fall back to most recent.
+    return { id: sessions[0].id, sessions, picked: false };
+  }
+}

package/src/repl/agent-repl.js

@@ -65,6 +65,9 @@ import {
   agentLoop as coreAgentLoop,
   formatToolArgs,
 } from "../runtime/agent-core.js";
+import { expandFileRefs } from "../runtime/file-ref-expander.js";
+import { composeSystemPrompt } from "../runtime/system-prompt.js";
+import { makeFallbackChatFn } from "../runtime/fallback-model.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -150,6 +153,26 @@ export async function startAgentRepl(options = {}) {
   let provider = options.provider || "ollama";
   const baseUrl = options.baseUrl || "http://localhost:11434";
   const apiKey = options.apiKey || null;
+  // Extra workspace roots (--add-dir): advertised in the system prompt and
+  // spanned by search_files.
+  const additionalDirectories = Array.isArray(options.additionalDirectories)
+    ? options.additionalDirectories
+    : [];
+
+  // --fallback-model: retry a turn's LLM call once on a backup model when the
+  // primary errors out (overload / network). Built once; passed into every
+  // agentLoop call via chatFn. Undefined when no fallback configured.
+  const _fallbackChatFn = options.fallbackModel
+    ? makeFallbackChatFn({
+        fallbackModel: options.fallbackModel,
+        onFallback: ({ from, to, error }) =>
+          logger.info(
+            chalk.yellow(
+              `[fallback] model "${from}" failed (${error}); retrying with "${to}"`,
+            ),
+          ),
+      })
+    : undefined;
 
   // Bootstrap runtime (best-effort, DB not required)
   let db = null;
@@ -299,7 +322,18 @@ export async function startAgentRepl(options = {}) {
   }
 
   const messages = [
-    { role: "system", content: buildSystemPrompt(process.cwd()) },
+    {
+      role: "system",
+      // --system-prompt replaces the built-in prompt; --append-system-prompt
+      // extends it (parity with the headless runners).
+      content: composeSystemPrompt(
+        buildSystemPrompt(process.cwd(), { additionalDirectories }),
+        {
+          systemPrompt: options.systemPrompt,
+          appendSystemPrompt: options.appendSystemPrompt,
+        },
+      ),
+    },
   ];
 
   // Deep Agents Deploy Phase 1 — load agent bundle if --bundle provided.
@@ -1418,8 +1452,28 @@ export async function startAgentRepl(options = {}) {
       logger.verbose(`[hook] prompt rewritten by UserPromptSubmit hook`);
     }
 
+    // Expand @path file references into context blocks (Claude-Code parity),
+    // so `review @src/x.js` injects the file contents. Typo'd paths are warned
+    // about and left as-is.
+    let userContent = effectivePrompt;
+    try {
+      const fileRefs = expandFileRefs(effectivePrompt, { cwd: process.cwd() });
+      userContent = fileRefs.prompt;
+      for (const w of fileRefs.warnings) {
+        logger.info(chalk.yellow(`[@ref] ${w}`));
+      }
+      if (fileRefs.refs.length > 0) {
+        const summary = fileRefs.refs
+          .map((r) => `${r.rel}${r.kind === "dir" ? "/" : ""}`)
+          .join(", ");
+        logger.verbose(`[@ref] injected: ${summary}`);
+      }
+    } catch (err) {
+      logger.verbose(`[@ref] expansion skipped: ${err.message}`);
+    }
+
     // Add user message
-    messages.push({ role: "user", content: effectivePrompt });
+    messages.push({ role: "user", content: userContent });
 
     // Slot-filling: detect intent and fill missing parameters interactively
     try {
@@ -1476,9 +1530,11 @@ export async function startAgentRepl(options = {}) {
         iterationBudget,
         sessionId,
         cwd: process.cwd(),
+        additionalDirectories,
         prepareCall: defaultPrepareCall,
         approvalGate: _approvalGate,
         mcpClient: _bundleMcpClient || undefined,
+        chatFn: _fallbackChatFn,
       });
 
       if (sessionId && usageEvents?.length) {

package/src/repl/chat-repl.js

@@ -12,6 +12,7 @@ import readline from "readline";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import {
   streamOllama,
   streamOpenAI,
@@ -153,8 +154,22 @@ export async function startChatRepl(options = {}) {
       }
     }
 
+    // Expand @path file references into context blocks (Claude-Code parity),
+    // so `summarize @notes.md` injects the file. The model sees the expanded
+    // content; the JSONL log keeps the original line for readability.
+    let userContent = trimmed;
+    try {
+      const fileRefs = expandFileRefs(trimmed, { cwd: process.cwd() });
+      userContent = fileRefs.prompt;
+      for (const w of fileRefs.warnings) {
+        logger.info(chalk.yellow(`[@ref] ${w}`));
+      }
+    } catch (err) {
+      logger.verbose?.(`[@ref] expansion skipped: ${err.message}`);
+    }
+
     // Add user message
-    messages.push({ role: "user", content: trimmed });
+    messages.push({ role: "user", content: userContent });
 
     // Stream the response
     process.stdout.write(chalk.blue("ai>  "));

package/src/runtime/agent-core.js

@@ -338,9 +338,12 @@ function _buildPersonaPrompt(persona, envLines, cwd) {
  *  4. Default hardcoded prompt → fallback when no persona
  *
  * @param {string} [cwd] - working directory
+ * @param {object} [opts]
+ * @param {string[]} [opts.additionalDirectories] - extra workspace roots
+ *   (absolute paths) the agent may read/search/edit beyond `cwd`.
  * @returns {string} complete system prompt
  */
-export function buildSystemPrompt(cwd) {
+export function buildSystemPrompt(cwd, opts = {}) {
   const dir = cwd || process.cwd();
 
   // Check for project persona
@@ -393,6 +396,19 @@ export function buildSystemPrompt(cwd) {
     // Non-critical
   }
 
+  // Advertise extra workspace roots (--add-dir) so the model knows it may
+  // reach beyond cwd and which absolute paths to use.
+  const extraDirs = Array.isArray(opts.additionalDirectories)
+    ? opts.additionalDirectories.filter(Boolean)
+    : [];
+  if (extraDirs.length > 0) {
+    prompt +=
+      `\n\n## Additional working directories\n` +
+      `Beyond the current working directory, you may read, search, and edit ` +
+      `files under these absolute roots. Pass absolute paths to access them:\n` +
+      extraDirs.map((d) => `- ${d}`).join("\n");
+  }
+
   return prompt;
 }
 
@@ -529,6 +545,7 @@ export async function executeTool(name, args, context = {}) {
       shellPolicyOverrides: context.shellPolicyOverrides || null,
       approvalGate: context.approvalGate || null,
       shellConfirm: context.shellConfirm || null,
+      additionalDirectories: context.additionalDirectories || null,
     });
   } catch (err) {
     if (hookDb) {
@@ -598,6 +615,7 @@ async function executeToolInner(
     shellPolicyOverrides,
     approvalGate,
     shellConfirm,
+    additionalDirectories,
   },
 ) {
   const localToolDescriptor =
@@ -962,41 +980,52 @@ async function executeToolInner(
     }
 
     case "search_files": {
-      const dir = args.directory ? path.resolve(cwd, args.directory) : cwd;
-      try {
-        if (args.content_search) {
-          const cmd =
-            process.platform === "win32"
-              ? `findstr /s /i /n "${args.pattern}" *`
-              : `grep -r -l -i "${args.pattern}" . --include="*" 2>/dev/null | head -20`;
-          const output = execSync(cmd, {
-            cwd: dir,
-            encoding: "utf8",
-            timeout: 10000,
-          });
-          return attachDescriptor({
-            matches: output.trim().split("\n").slice(0, 20),
-          });
-        } else {
-          const cmd =
-            process.platform === "win32"
-              ? `dir /s /b *${args.pattern}* 2>NUL`
-              : `find . -name "*${args.pattern}*" -type f 2>/dev/null | head -20`;
+      // An explicit directory scopes the search to one root; otherwise span
+      // cwd plus any --add-dir roots so cross-package searches find matches.
+      const extraRoots = Array.isArray(additionalDirectories)
+        ? additionalDirectories.filter(Boolean)
+        : [];
+      const roots = args.directory
+        ? [path.resolve(cwd, args.directory)]
+        : [cwd, ...extraRoots];
+      const isContent = Boolean(args.content_search);
+      const cmd = isContent
+        ? process.platform === "win32"
+          ? `findstr /s /i /n "${args.pattern}" *`
+          : `grep -r -l -i "${args.pattern}" . --include="*" 2>/dev/null | head -20`
+        : process.platform === "win32"
+          ? `dir /s /b *${args.pattern}* 2>NUL`
+          : `find . -name "*${args.pattern}*" -type f 2>/dev/null | head -20`;
+
+      const hits = [];
+      const seen = new Set();
+      for (const root of roots) {
+        if (hits.length >= 20) break;
+        try {
+          if (!fs.existsSync(root)) continue;
           const output = execSync(cmd, {
-            cwd: dir,
+            cwd: root,
             encoding: "utf8",
             timeout: 10000,
           });
-          return attachDescriptor({
-            files: output.trim().split("\n").filter(Boolean).slice(0, 20),
-          });
+          for (const line of output.trim().split("\n")) {
+            const v = line.trim();
+            if (!v || seen.has(v)) continue;
+            // Qualify with the root so multi-root results stay unambiguous.
+            const labeled = roots.length > 1 ? `${root}: ${v}` : v;
+            seen.add(v);
+            hits.push(labeled);
+            if (hits.length >= 20) break;
+          }
+        } catch {
+          // No matches in this root — continue to the next.
         }
-      } catch {
-        return attachDescriptor({
-          files: [],
-          message: "No matches found",
-        });
       }
+
+      if (hits.length === 0) {
+        return attachDescriptor({ files: [], message: "No matches found" });
+      }
+      return attachDescriptor(isContent ? { matches: hits } : { files: hits });
     }
 
     case "list_dir": {
@@ -1608,9 +1637,16 @@ export async function chatWithTools(rawMessages, options) {
   } = options;
 
   const persona = _loadProjectPersona(options.cwd);
+  // Merge the project-persona deny-list with any caller-supplied deny-list
+  // (e.g. headless `--disallowed-tools`). Without this merge the caller's
+  // deny-list is silently dropped and the tool stays callable.
+  const mergedDisabledTools = [
+    ...(Array.isArray(persona?.toolsDisabled) ? persona.toolsDisabled : []),
+    ...(Array.isArray(options.disabledTools) ? options.disabledTools : []),
+  ];
   const tools = getAgentToolDefinitions({
     names: options.enabledToolNames,
-    disabledTools: persona?.toolsDisabled,
+    disabledTools: mergedDisabledTools,
     extraTools: [
       ...(options.hostManagedToolPolicy?.toolDefinitions || []),
       ...(options.extraToolDefinitions || []),
@@ -1842,6 +1878,7 @@ export async function* agentLoop(messages, options) {
     shellPolicyOverrides: options.shellPolicyOverrides || null,
     approvalGate: options.approvalGate || null,
     shellConfirm: options.shellConfirm || null,
+    additionalDirectories: options.additionalDirectories || null,
   };
 
   throwIfAborted(signal);

package/src/runtime/fallback-model.js

@@ -0,0 +1,109 @@
+/**
+ * `--fallback-model` support — Claude-Code parity for unattended runs.
+ *
+ * Wraps the agent loop's LLM call so a single request that fails with a
+ * *retryable* error (overload / rate-limit / transient network) is transparently
+ * re-issued once with a backup model. Because it sits at the chatFn seam
+ * (`agentLoop` uses `options.chatFn || chatWithTools`), fallback needs no changes
+ * to the runners — the wrapped fn is passed in via `options.chatFn`.
+ *
+ * Same-provider only: the fallback swaps `options.model`, keeping the configured
+ * provider / baseUrl / apiKey. Cross-provider fallback is a larger feature.
+ */
+
+import { chatWithTools } from "./agent-core.js";
+
+// Heuristics for "try again on a different model" — overloaded backends,
+// rate limits, and transient connectivity. Deliberately conservative: a 4xx
+// that is not 429 (bad request / auth) is NOT retried.
+const RETRYABLE_PATTERNS = [
+  /overload/i,
+  /rate.?limit/i,
+  /too many requests/i,
+  /temporarily unavailable/i,
+  /\b429\b/,
+  /\b50[0234]\b/,
+  /\b529\b/,
+  /timeout/i,
+  /timed out/i,
+  /ETIMEDOUT/i,
+  /ECONNREFUSED/i,
+  /ECONNRESET/i,
+  /ENOTFOUND/i,
+  /EAI_AGAIN/i,
+  /socket hang up/i,
+  /fetch failed/i,
+  /network error/i,
+];
+
+/**
+ * Decide whether an error from an LLM call warrants a fallback retry.
+ * @param {any} err
+ * @returns {boolean}
+ */
+export function isRetryableModelError(err) {
+  if (!err) return false;
+  const status =
+    typeof err.status === "number"
+      ? err.status
+      : typeof err.statusCode === "number"
+        ? err.statusCode
+        : null;
+  if (status === 429) return true;
+  if (status !== null && status >= 500 && status <= 599) return true;
+
+  const parts = [
+    err.message,
+    typeof err.code === "string" ? err.code : "",
+    err.cause?.message,
+    err.cause?.code,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  return RETRYABLE_PATTERNS.some((re) => re.test(parts));
+}
+
+/**
+ * Build a chatFn that retries once on the fallback model.
+ *
+ * @param {object} opts
+ * @param {string} opts.fallbackModel              backup model name (required)
+ * @param {Function} [opts.baseChatFn=chatWithTools] underlying LLM call
+ * @param {Function} [opts.isRetryable]            error predicate (testing seam)
+ * @param {Function} [opts.onFallback]             notified ({from,to,error}) on retry
+ * @returns {Function} a (messages, options) => Promise<result> chatFn
+ */
+export function makeFallbackChatFn(opts = {}) {
+  const fallbackModel = opts.fallbackModel;
+  const baseChatFn = opts.baseChatFn || chatWithTools;
+  const isRetryable = opts.isRetryable || isRetryableModelError;
+  const onFallback = opts.onFallback;
+
+  return async function chatWithFallback(messages, options = {}) {
+    try {
+      return await baseChatFn(messages, options);
+    } catch (err) {
+      const primaryModel = options.model;
+      // Skip a no-op retry when the fallback is the same model as the primary.
+      if (
+        !fallbackModel ||
+        fallbackModel === primaryModel ||
+        !isRetryable(err)
+      ) {
+        throw err;
+      }
+      if (typeof onFallback === "function") {
+        try {
+          onFallback({
+            from: primaryModel,
+            to: fallbackModel,
+            error: err?.message || String(err),
+          });
+        } catch {
+          // Notification is best-effort — never mask the retry.
+        }
+      }
+      return await baseChatFn(messages, { ...options, model: fallbackModel });
+    }
+  };
+}