chainlesschain 0.162.30 → 0.162.32

package/src/lib/llm-pricing.js

@@ -0,0 +1,227 @@
+/**
+ * llm-pricing — turn token counts into estimated $ cost.
+ *
+ * Layers a price table on top of the token roll-ups produced by
+ * `session-usage.js`, so `cc cost` can show spend per provider/model.
+ *
+ * IMPORTANT: these rates are ESTIMATES of public list prices (USD per 1M
+ * tokens) and drift over time. Local providers (ollama / local) are free.
+ * An unmatched model is reported as `matched:false` with zero cost rather
+ * than guessed — the caller surfaces it as "unpriced" so the number is never
+ * silently wrong. Override or extend PRICE_TABLE below as prices change.
+ *
+ * Rate shape: { in: <USD per 1M input tokens>, out: <USD per 1M output> }.
+ * Matching is provider-scoped, longest-pattern-first, case-insensitive
+ * substring against the model id.
+ */
+
+/** Providers whose models run locally and cost nothing to call. */
+export const FREE_PROVIDERS = Object.freeze([
+  "ollama",
+  "local",
+  "llamacpp",
+  "mediapipe",
+]);
+
+/**
+ * Per-provider model price patterns. Each entry: { match, in, out }.
+ * Order within a provider matters — more specific patterns first so
+ * "gpt-4o-mini" is not shadowed by "gpt-4o".
+ */
+export const PRICE_TABLE = Object.freeze({
+  anthropic: [
+    { match: "opus", in: 15, out: 75 },
+    { match: "sonnet", in: 3, out: 15 },
+    { match: "haiku", in: 1, out: 5 },
+  ],
+  openai: [
+    { match: "gpt-4o-mini", in: 0.15, out: 0.6 },
+    { match: "gpt-4o", in: 2.5, out: 10 },
+    { match: "gpt-4-turbo", in: 10, out: 30 },
+    { match: "gpt-4", in: 30, out: 60 },
+    { match: "gpt-3.5", in: 0.5, out: 1.5 },
+    { match: "o1-mini", in: 1.1, out: 4.4 },
+    { match: "o1", in: 15, out: 60 },
+  ],
+  deepseek: [
+    { match: "reasoner", in: 0.55, out: 2.19 },
+    { match: "chat", in: 0.27, out: 1.1 },
+  ],
+  // Volcengine Doubao — rough USD conversion of public RMB list pricing.
+  volcengine: [
+    { match: "seed-1-6", in: 0.11, out: 0.28 },
+    { match: "seed", in: 0.11, out: 0.28 },
+    { match: "pro", in: 0.11, out: 0.28 },
+    { match: "lite", in: 0.04, out: 0.08 },
+    { match: "doubao", in: 0.11, out: 0.28 },
+  ],
+});
+
+const round = (n, dp = 6) => {
+  const f = Math.pow(10, dp);
+  return Math.round((Number(n) + Number.EPSILON) * f) / f;
+};
+
+/**
+ * Merge user-supplied price overrides (typically `config.llm.pricing`) onto the
+ * built-in table. Override shape mirrors PRICE_TABLE:
+ *   { "<provider>": [ { match: "<substr>", in: <num>, out: <num> }, ... ] }
+ *
+ * Per provider, a user entry whose `match` equals a built-in pattern REPLACES
+ * it; brand-new patterns are prepended so they win ties; unknown providers are
+ * added. Malformed entries (missing match / non-numeric rate) are skipped so a
+ * bad config line can't crash cost reporting. Returns a new table; never
+ * mutates PRICE_TABLE or the input.
+ *
+ * @param {object} [overrides]
+ * @param {object} [base=PRICE_TABLE]
+ * @returns {object} merged price table
+ */
+export function mergePricing(overrides, base = PRICE_TABLE) {
+  const merged = {};
+  for (const [p, entries] of Object.entries(base)) {
+    merged[p] = entries.map((e) => ({ ...e }));
+  }
+  if (!overrides || typeof overrides !== "object") return merged;
+
+  for (const [provider, rawEntries] of Object.entries(overrides)) {
+    if (!Array.isArray(rawEntries)) continue;
+    const valid = rawEntries
+      .filter(
+        (e) =>
+          e &&
+          typeof e.match === "string" &&
+          e.match.trim() &&
+          Number.isFinite(Number(e.in)) &&
+          Number.isFinite(Number(e.out)),
+      )
+      .map((e) => ({
+        match: e.match.toLowerCase(),
+        in: Number(e.in),
+        out: Number(e.out),
+      }));
+    if (valid.length === 0) continue;
+    const overridden = new Set(valid.map((v) => v.match));
+    const kept = (merged[provider] || []).filter(
+      (e) => !overridden.has(e.match.toLowerCase()),
+    );
+    merged[provider] = [...valid, ...kept];
+  }
+  return merged;
+}
+
+/**
+ * Look up the rate for a provider/model, or null if unpriced.
+ * @param {string} provider
+ * @param {string} model
+ * @param {object} [table=PRICE_TABLE] merged table from mergePricing()
+ * @returns {{ in:number, out:number, pattern:string }|null}
+ */
+export function lookupRate(provider, model, table = PRICE_TABLE) {
+  const p = String(provider || "").toLowerCase();
+  const m = String(model || "").toLowerCase();
+  if (FREE_PROVIDERS.includes(p)) {
+    return { in: 0, out: 0, pattern: "free" };
+  }
+  const entries = (table || PRICE_TABLE)[p];
+  if (!entries) return null;
+  // Longest pattern first so specific beats generic regardless of table order.
+  const sorted = [...entries].sort((a, b) => b.match.length - a.match.length);
+  for (const e of sorted) {
+    if (m.includes(e.match)) {
+      return { in: e.in, out: e.out, pattern: e.match };
+    }
+  }
+  return null;
+}
+
+/**
+ * Estimate cost for a single usage record.
+ * @returns {{ inputCost:number, outputCost:number, totalCost:number,
+ *             currency:string, matched:boolean, free:boolean, rate:object|null }}
+ */
+export function estimateCost({
+  provider,
+  model,
+  inputTokens = 0,
+  outputTokens = 0,
+  table,
+} = {}) {
+  const rate = lookupRate(provider, model, table);
+  if (!rate) {
+    return {
+      inputCost: 0,
+      outputCost: 0,
+      totalCost: 0,
+      currency: "USD",
+      matched: false,
+      free: false,
+      rate: null,
+    };
+  }
+  const inputCost = round((Number(inputTokens) / 1e6) * rate.in);
+  const outputCost = round((Number(outputTokens) / 1e6) * rate.out);
+  return {
+    inputCost,
+    outputCost,
+    totalCost: round(inputCost + outputCost),
+    currency: "USD",
+    matched: true,
+    free: rate.pattern === "free",
+    rate: { in: rate.in, out: rate.out, pattern: rate.pattern },
+  };
+}
+
+/**
+ * Augment a session-usage aggregate ({ total, byModel:[...] }) with cost.
+ * Returns a new object — does not mutate the input.
+ *
+ * Each byModel row gains: cost, currency, matched. The returned `cost`
+ * top-level sums priced rows; `unpriced` lists provider/model rows that had
+ * usage but no matching rate (their tokens are excluded from `cost.totalCost`).
+ */
+export function priceRollup(aggregate, { table } = {}) {
+  const byModel = (aggregate?.byModel || []).map((row) => {
+    const est = estimateCost({
+      provider: row.provider,
+      model: row.model,
+      inputTokens: row.inputTokens,
+      outputTokens: row.outputTokens,
+      table,
+    });
+    return {
+      ...row,
+      cost: est.totalCost,
+      inputCost: est.inputCost,
+      outputCost: est.outputCost,
+      currency: est.currency,
+      matched: est.matched,
+      free: est.free,
+    };
+  });
+
+  let totalCost = 0;
+  const unpriced = [];
+  for (const row of byModel) {
+    if (row.matched) {
+      totalCost = round(totalCost + row.cost);
+    } else if (row.totalTokens > 0) {
+      unpriced.push({
+        provider: row.provider,
+        model: row.model,
+        totalTokens: row.totalTokens,
+      });
+    }
+  }
+
+  return {
+    ...aggregate,
+    byModel,
+    cost: {
+      totalCost,
+      currency: "USD",
+      unpricedCount: unpriced.length,
+    },
+    unpriced,
+  };
+}

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)
@@ -89,8 +92,18 @@ async function executeTool(name, args) {
  */
 async function agentLoop(messages, options) {
   const usageEvents = [];
-  for await (const event of coreAgentLoop(messages, options)) {
-    if (event.type === "tool-executing") {
+  // The REPL runs its own auto-compaction (after each turn, with metrics +
+  // persisted compact events), so opt out of the agent loop's in-loop
+  // compaction to avoid compacting the same history twice.
+  for await (const event of coreAgentLoop(messages, {
+    autoCompact: false,
+    ...options,
+  })) {
+    if (event.type === "checkpoint") {
+      process.stdout.write(
+        chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
+      );
+    } else if (event.type === "tool-executing") {
       process.stdout.write(
         chalk.gray(
           `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
@@ -150,6 +163,29 @@ 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
+    : [];
+  // Snapshot the work tree before each mutating tool (git engine) so the user
+  // can `cc checkpoint restore` to just before any tool call.
+  const autoCheckpoint = options.autoCheckpoint === true;
+
+  // --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 +335,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.
@@ -684,8 +731,10 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/compact") {
       if (_compressor && messages.length > 3) {
-        const { messages: compacted, stats } =
-          await _compressor.compress(messages);
+        const { messages: compacted, stats } = await _compressor.compress(
+          messages,
+          { preserveToolPairs: true },
+        );
         messages.length = 0;
         messages.push(...compacted);
         recordCompressionMetric(stats, {
@@ -1418,8 +1467,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 {
@@ -1467,6 +1536,23 @@ export async function startAgentRepl(options = {}) {
     try {
       process.stdout.write("\n");
       const iterationBudget = new IterationBudget({ owner: sessionId });
+      // Bind a cross-session goal (cc goal) into this run, if one resolves.
+      // Composes WITH defaultPrepareCall — never replaces it. Best-effort.
+      let prepareCall = defaultPrepareCall;
+      try {
+        const { resolveActiveGoal } = await import("../lib/goal-store.js");
+        const boundGoal = resolveActiveGoal({ sessionId });
+        if (boundGoal) {
+          const { goalPrepareCall, composePrepareCall } =
+            await import("../lib/goal-context.js");
+          prepareCall = composePrepareCall([
+            defaultPrepareCall,
+            goalPrepareCall(boundGoal),
+          ]);
+        }
+      } catch (_e) {
+        /* goal binding is best-effort — fall back to defaultPrepareCall */
+      }
       const { content: response, usageEvents } = await agentLoop(messages, {
         provider,
         model: activeModel,
@@ -1476,9 +1562,13 @@ export async function startAgentRepl(options = {}) {
         iterationBudget,
         sessionId,
         cwd: process.cwd(),
-        prepareCall: defaultPrepareCall,
+        additionalDirectories,
+        autoCheckpoint,
+        checkpointSession: sessionId,
+        prepareCall,
         approvalGate: _approvalGate,
         mcpClient: _bundleMcpClient || undefined,
+        chatFn: _fallbackChatFn,
       });
 
       if (sessionId && usageEvents?.length) {
@@ -1557,8 +1647,10 @@ export async function startAgentRepl(options = {}) {
         _compressor.shouldAutoCompact(messages)
       ) {
         try {
-          const { messages: compacted, stats } =
-            await _compressor.compress(messages);
+          const { messages: compacted, stats } = await _compressor.compress(
+            messages,
+            { preserveToolPairs: true },
+          );
           messages.length = 0;
           messages.push(...compacted);
           recordCompressionMetric(stats, {

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>  "));