@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/cc-orchestrator/external-agent-changes.js

@@ -0,0 +1,214 @@
+import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { encodeCwd } from "./session-discovery.js";
+/**
+ * #6 — attribute file changes made by a background external agent (DriveAgent
+ * running `claude` / `codex`). Those Edit/Write calls land in the external CLI's
+ * own transcript, invisible to the host's in-session file-change aggregator.
+ * Given the external session id + cwd, locate that transcript and extract the
+ * set of changed files, so the UI can show "N files edited" for the run.
+ *
+ * Read-only; tolerant — a malformed line is skipped, a missing transcript
+ * returns []. Never throws for the caller.
+ */
+const CLAUDE_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+const CODEX_WRITE_TOOLS = new Set(["apply_patch", "ApplyPatch", "write_file", "edit_file"]);
+/** Pull the changed-file path out of a claude tool_use input block. */
+function claudeInputPath(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const o = input;
+    const p = o.file_path ?? o.notebook_path;
+    return typeof p === "string" && p.length > 0 ? p : undefined;
+}
+/**
+ * Parse claude transcript JSONL text → deduped list of changed file paths.
+ * Each line is `{ message: { content: [{ type:"tool_use", name, input }] } }`.
+ * Exported for direct unit testing without a transcript file on disk.
+ */
+export function extractChangedFilesFromClaudeLines(text) {
+    const seen = new Set();
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const content = d?.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block &&
+                typeof block === "object" &&
+                block.type === "tool_use" &&
+                CLAUDE_WRITE_TOOLS.has(block.name ?? "")) {
+                const p = claudeInputPath(block.input);
+                if (p)
+                    seen.add(p);
+            }
+        }
+    }
+    return [...seen];
+}
+/** Locate `<claudeHome>/projects/<encodeCwd(cwd)>/<sid>.jsonl` and extract changes. */
+export function readClaudeChangedFiles(cwd, sessionId, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return [];
+    let text;
+    try {
+        text = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return extractChangedFilesFromClaudeLines(text);
+}
+/**
+ * Parse codex rollout JSONL text → changed file paths. Codex tool calls are
+ * `{type:"response_item", payload:{type:"function_call", name, arguments}}` or
+ * `{...custom_tool_call, input}`. apply_patch carries the patch text; write/edit
+ * carry a file path in arguments. Exported for unit testing.
+ */
+export function extractChangedFilesFromCodexLines(text) {
+    const seen = new Set();
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d?.type !== "response_item" || !d.payload)
+            continue;
+        const p = d.payload;
+        const name = typeof p.name === "string" ? p.name : "";
+        if (!CODEX_WRITE_TOOLS.has(name))
+            continue;
+        // function_call.arguments is a JSON string; custom_tool_call.input a string.
+        const rawArgs = typeof p.arguments === "string" ? p.arguments : typeof p.input === "string" ? p.input : "";
+        for (const f of filesFromCodexArgs(name, rawArgs))
+            seen.add(f);
+    }
+    return [...seen];
+}
+/** Pull file paths out of a codex tool's arguments string. */
+function filesFromCodexArgs(name, raw) {
+    if (!raw)
+        return [];
+    if (name === "apply_patch" || name === "ApplyPatch") {
+        // apply_patch payload wraps a patch; headers look like `*** Update File: <p>`
+        // or `*** Add File: <p>`. Match those directly off the raw text.
+        const out = [];
+        const re = /\*\*\*\s+(?:Update|Add|Delete) File:\s+(.+)/g;
+        let m;
+        while ((m = re.exec(raw)) !== null) {
+            const f = m[1]?.trim();
+            if (f)
+                out.push(f);
+        }
+        return out;
+    }
+    try {
+        const a = JSON.parse(raw);
+        const p = a.file_path ?? a.path;
+        return typeof p === "string" && p ? [p] : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Locate a codex rollout by threadId+cwd under `<codexHome>/sessions` and extract changes. */
+export function readCodexChangedFiles(cwd, threadId, codexHome = join(homedir(), ".codex")) {
+    const file = findRolloutFile(codexHome, cwd, threadId);
+    if (!file)
+        return [];
+    let text;
+    try {
+        text = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return extractChangedFilesFromCodexLines(text);
+}
+/** Dispatch by CLI. Unknown cli → []. Never throws. */
+export function readExternalChangedFiles(cli, cwd, sessionId) {
+    try {
+        if (cli === "codex")
+            return readCodexChangedFiles(cwd, sessionId);
+        return readClaudeChangedFiles(cwd, sessionId);
+    }
+    catch {
+        return [];
+    }
+}
+// ── codex rollout location (mirrors codex-session-history.ts) ──────────────
+function findRolloutFile(codexHome, cwd, threadId) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return undefined;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id === threadId && meta.cwd === cwd)
+            return file;
+    }
+    return undefined;
+}
+function* walkRollouts(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const full = join(root, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory())
+            yield* walkRollouts(full);
+        else if (name.startsWith("rollout-") && name.endsWith(".jsonl"))
+            yield full;
+    }
+}
+function readSessionMeta(file, maxBytes = 1 << 16) {
+    const fd = openSync(file, "r");
+    let text;
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        text = buf.toString("utf-8", 0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+    const nl = text.indexOf("\n");
+    const first = (nl === -1 ? text : text.slice(0, nl)).trim();
+    if (!first)
+        return undefined;
+    const d = JSON.parse(first);
+    if (d.type !== "session_meta" || !d.payload)
+        return undefined;
+    return { id: d.payload.id, cwd: d.payload.cwd };
+}

package/dist/cc-orchestrator/external-agent-driver.d.ts

@@ -0,0 +1,18 @@
+import type { AgentAdapter, BuildArgsOpts, PermissionMode } from "./agent-adapter.js";
+export interface AgentRunResult {
+    sessionId: string;
+    finalText: string;
+    isError: boolean;
+    exitCode: number | null;
+    lines: string[];
+}
+/** Pure: reduce collected output lines + exit code to a result. Unit-testable. */
+export declare function runWithLines(adapter: AgentAdapter, lines: string[], exitCode: number | null): AgentRunResult;
+export interface DriverRunOpts extends Omit<BuildArgsOpts, "permissionMode"> {
+    permissionMode?: PermissionMode;
+}
+/** Spawn ONE headless agent run, collect stream-json to exit, return result.
+ *  No time concept — a single turn. Honors AbortSignal (kills the child). */
+export declare function runAgentOnce(adapter: AgentAdapter, opts: DriverRunOpts & {
+    command: string;
+}, signal?: AbortSignal): Promise<AgentRunResult>;

package/dist/cc-orchestrator/external-agent-driver.js

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { pathWithCommonBins } from "./cc-capability.js";
+/** Pure: reduce collected output lines + exit code to a result. Unit-testable. */
+export function runWithLines(adapter, lines, exitCode) {
+    const parsed = adapter.parseResult(lines);
+    return { ...parsed, exitCode, lines };
+}
+/** Spawn ONE headless agent run, collect stream-json to exit, return result.
+ *  No time concept — a single turn. Honors AbortSignal (kills the child). */
+export function runAgentOnce(adapter, opts, signal) {
+    return new Promise((resolve, reject) => {
+        const args = adapter.buildArgs({
+            prompt: opts.prompt,
+            resumeSessionId: opts.resumeSessionId,
+            permissionMode: opts.permissionMode ?? "default",
+            cwd: opts.cwd,
+        });
+        // claude takes the prompt in argv (`-p <prompt>`) and wants stdin closed
+        // (verified: avoids a 3s wait). codex `exec` reads the prompt from stdin
+        // (argv ends with `-`), so adapters that set promptViaStdin get a piped
+        // stdin we write the prompt to.
+        const viaStdin = adapter.promptViaStdin === true;
+        const child = spawn(opts.command, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, PATH: pathWithCommonBins() },
+            // NOT detached: this child is owned by the (long-lived) worker that reads
+            // its stdout. Detaching orphaned it across a worker/app restart — the
+            // reader promise then never resolved and the completion notification never
+            // fired (the "后台任务没返回" bug). Bound to the worker, it lives or dies
+            // with the process that's actually listening for its result.
+            detached: false,
+            stdio: [viaStdin ? "pipe" : "ignore", "pipe", "pipe"],
+        });
+        if (viaStdin && child.stdin) {
+            child.stdin.end(opts.prompt);
+        }
+        const lines = [];
+        if (child.stdout) {
+            const rl = createInterface({ input: child.stdout });
+            rl.on("line", (line) => lines.push(line));
+        }
+        // Not detached → no own process group, so kill the child directly (a
+        // negative-pid group kill would target the worker's group). claude has no
+        // long-lived child tree of its own here, so a direct SIGTERM is sufficient.
+        const onAbort = () => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { /* already gone */ }
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child.on("error", (err) => {
+            signal?.removeEventListener("abort", onAbort);
+            // A missing binary is the most common failure (user hasn't installed the
+            // CLI, or GUI-launched Electron's PATH misses it). Turn the cryptic
+            // "spawn codex ENOENT" into something actionable that names the command.
+            if (err.code === "ENOENT") {
+                reject(new Error(`未找到命令 "${opts.command}"。请先安装该 CLI 并确保它在 PATH 中（${adapter.kind === "codex" ? "Codex CLI" : "Claude Code CLI"}）。`));
+                return;
+            }
+            reject(err);
+        });
+        child.on("exit", (code) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(runWithLines(adapter, lines, code));
+        });
+    });
+}

package/dist/cc-orchestrator/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./cc-capability.js";
+export * from "./agent-adapter.js";
+export * from "./external-agent-driver.js";
+export * from "./session-discovery.js";
+export * from "./codex-session-discovery.js";
+export * from "./relevance-judge.js";
+export * from "./session-history.js";
+export * from "./codex-session-history.js";

package/dist/cc-orchestrator/index.js

@@ -0,0 +1,8 @@
+export * from "./cc-capability.js";
+export * from "./agent-adapter.js";
+export * from "./external-agent-driver.js";
+export * from "./session-discovery.js";
+export * from "./codex-session-discovery.js";
+export * from "./relevance-judge.js";
+export * from "./session-history.js";
+export * from "./codex-session-history.js";

package/dist/cc-orchestrator/relevance-judge.d.ts

@@ -0,0 +1,15 @@
+export interface JudgeDecision {
+    action: "continue-same" | "continue-fresh" | "stop";
+    handoffSummary?: string;
+    reason: string;
+}
+export interface JudgeInput {
+    goal?: string;
+    lastResult: string;
+    nextPrompt: string;
+}
+/** Injected aux-model call: takes a prompt, returns raw text. */
+export type AuxLlm = (prompt: string) => Promise<string>;
+export declare function buildJudgePrompt(input: JudgeInput): string;
+export declare function parseJudgeResponse(raw: string): JudgeDecision;
+export declare function judgeContinuation(input: JudgeInput, llm: AuxLlm): Promise<JudgeDecision>;

package/dist/cc-orchestrator/relevance-judge.js

@@ -0,0 +1,29 @@
+const SYSTEM = `You decide how a scheduled task loop should continue after one run.
+Reply with ONLY a JSON object: {"action": "continue-same"|"continue-fresh"|"stop", "handoffSummary"?: string, "reason": string}.
+- "stop": the goal is met; no more runs needed.
+- "continue-same": next run should resume the SAME session (work is related, keep context).
+- "continue-fresh": next run should start a FRESH session because the next step is unrelated to what was just done; put a short context summary in handoffSummary.`;
+export function buildJudgePrompt(input) {
+    return [
+        SYSTEM,
+        input.goal ? `\nOverall goal: ${input.goal}` : "",
+        `\nWhat the last run produced:\n${input.lastResult.slice(0, 4000)}`,
+        `\nThe next scheduled prompt:\n${input.nextPrompt}`,
+        `\nDecision JSON:`,
+    ].join("\n");
+}
+export function parseJudgeResponse(raw) {
+    try {
+        const m = raw.match(/\{[\s\S]*\}/);
+        const d = JSON.parse(m ? m[0] : raw);
+        if (d.action === "stop" || d.action === "continue-fresh" || d.action === "continue-same") {
+            return { action: d.action, handoffSummary: typeof d.handoffSummary === "string" ? d.handoffSummary : undefined, reason: typeof d.reason === "string" ? d.reason : "" };
+        }
+    }
+    catch { /* fall through */ }
+    return { action: "continue-same", reason: "unparseable judge output; defaulting to continue-same" };
+}
+export async function judgeContinuation(input, llm) {
+    const raw = await llm(buildJudgePrompt(input));
+    return parseJudgeResponse(raw);
+}

package/dist/cc-orchestrator/session-discovery.d.ts

@@ -0,0 +1,46 @@
+/** Encode a cwd to claude's project dir name: every non-[A-Za-z0-9] char → '-'.
+ *  Mirrors `~/.claude/projects/<encoded>` (verified against real layout). */
+export declare function encodeCwd(cwd: string): string;
+export interface DiscoveredSession {
+    sessionId: string;
+    firstMessage: string;
+    lastModified: number;
+    messageCount: number;
+}
+/**
+ * Bound how many sessions a discovery scan deep-reads + returns. Without this,
+ * `discoverSessions` read EVERY `.jsonl` file fully (title + message count) on
+ * every list open — O(all history) work that makes the CC/Codex room list slow
+ * and unwieldy once a project accumulates sessions. The default surfaces only
+ * the recent, useful slice; the UI fetches older ones on demand by passing a
+ * larger `limit` (or `sinceMs: 0`).
+ */
+export interface DiscoverOptions {
+    /** Max sessions to return (after the recency filter), newest first.
+     *  undefined or <= 0 = no cap. */
+    limit?: number;
+    /** Only include sessions modified within this many ms of `now`.
+     *  undefined or <= 0 = no window. */
+    sinceMs?: number;
+    /** Injectable clock for tests. Defaults to Date.now(). */
+    now?: number;
+}
+/** Default room-list window: last 2 weeks AND at most 20 — the intersection. */
+export declare const DEFAULT_DISCOVER_LIMIT = 20;
+export declare const DEFAULT_DISCOVER_SINCE_MS: number;
+/**
+ * Apply the recency window + limit to mtime-sorted stats, returning the slice to
+ * deep-read. Shared by the claude + codex discovery paths so they bound work
+ * identically. `total` (caller-side) lets the UI show a "load more" affordance.
+ */
+export declare function selectRecentStats<T extends {
+    mtimeMs: number;
+}>(stats: T[], opts?: DiscoverOptions): T[];
+/** List claude sessions for `cwd`. `claudeHome` defaults to ~/.claude (override
+ *  for tests). Read-only, on-demand scan; no index. Stats every file cheaply,
+ *  then deep-reads (title + count) ONLY the recent slice (opts) so an old,
+ *  large history doesn't get fully read on every list open. */
+export declare function discoverSessions(cwd: string, claudeHome?: string, opts?: DiscoverOptions): DiscoveredSession[];
+/** Count of all session files for `cwd`, cheaply (stat only). Lets the UI know
+ *  whether a bounded `discoverSessions` left older sessions unshown. */
+export declare function countSessions(cwd: string, claudeHome?: string): number;

package/dist/cc-orchestrator/session-discovery.js

@@ -0,0 +1,125 @@
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/** Encode a cwd to claude's project dir name: every non-[A-Za-z0-9] char → '-'.
+ *  Mirrors `~/.claude/projects/<encoded>` (verified against real layout). */
+export function encodeCwd(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+/** Default room-list window: last 2 weeks AND at most 20 — the intersection. */
+export const DEFAULT_DISCOVER_LIMIT = 20;
+export const DEFAULT_DISCOVER_SINCE_MS = 14 * 24 * 60 * 60 * 1000;
+function claudeProjectsDir(claudeHome) {
+    return join(claudeHome, "projects");
+}
+/** Extract first *real* user message text, skipping caveat/command noise. */
+function firstUserMessage(lines) {
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type !== "user")
+            continue;
+        const c = d.message?.content;
+        const text = typeof c === "string"
+            ? c
+            : Array.isArray(c)
+                ? c.map((p) => (typeof p?.text === "string" ? p.text : "")).join("")
+                : "";
+        const t = text.trim();
+        if (!t)
+            continue;
+        if (t.startsWith("<local-command-caveat>") || t.startsWith("<command-name>"))
+            continue;
+        return t.slice(0, 200);
+    }
+    return "";
+}
+function countUserMessages(lines) {
+    let n = 0;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            if (JSON.parse(line).type === "user")
+                n++;
+        }
+        catch { /* skip */ }
+    }
+    return n;
+}
+/** Cheap (sessionId, mtime) pairs for every session file — stat only, no read. */
+function listSessionStats(dir) {
+    const stats = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".jsonl"))
+            continue;
+        const file = join(dir, name);
+        let st;
+        try {
+            st = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        stats.push({ sessionId: name.replace(/\.jsonl$/, ""), file, mtimeMs: st.mtimeMs });
+    }
+    return stats;
+}
+/**
+ * Apply the recency window + limit to mtime-sorted stats, returning the slice to
+ * deep-read. Shared by the claude + codex discovery paths so they bound work
+ * identically. `total` (caller-side) lets the UI show a "load more" affordance.
+ */
+export function selectRecentStats(stats, opts = {}) {
+    const now = opts.now ?? Date.now();
+    let sel = stats.slice().sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (opts.sinceMs && opts.sinceMs > 0) {
+        const cutoff = now - opts.sinceMs;
+        sel = sel.filter((s) => s.mtimeMs >= cutoff);
+    }
+    if (opts.limit && opts.limit > 0)
+        sel = sel.slice(0, opts.limit);
+    return sel;
+}
+/** List claude sessions for `cwd`. `claudeHome` defaults to ~/.claude (override
+ *  for tests). Read-only, on-demand scan; no index. Stats every file cheaply,
+ *  then deep-reads (title + count) ONLY the recent slice (opts) so an old,
+ *  large history doesn't get fully read on every list open. */
+export function discoverSessions(cwd, claudeHome = join(homedir(), ".claude"), opts = {}) {
+    const dir = join(claudeProjectsDir(claudeHome), encodeCwd(cwd));
+    if (!existsSync(dir))
+        return [];
+    const selected = selectRecentStats(listSessionStats(dir), opts);
+    const out = [];
+    for (const s of selected) {
+        let lines;
+        try {
+            lines = readFileSync(s.file, "utf-8").split("\n");
+        }
+        catch {
+            continue;
+        }
+        out.push({
+            sessionId: s.sessionId,
+            firstMessage: firstUserMessage(lines),
+            lastModified: s.mtimeMs,
+            messageCount: countUserMessages(lines),
+        });
+    }
+    return out;
+}
+/** Count of all session files for `cwd`, cheaply (stat only). Lets the UI know
+ *  whether a bounded `discoverSessions` left older sessions unshown. */
+export function countSessions(cwd, claudeHome = join(homedir(), ".claude")) {
+    const dir = join(claudeProjectsDir(claudeHome), encodeCwd(cwd));
+    if (!existsSync(dir))
+        return 0;
+    return listSessionStats(dir).length;
+}

package/dist/cc-orchestrator/session-history.d.ts

@@ -0,0 +1,19 @@
+export interface HistoryMessage {
+    role: "user" | "assistant";
+    text: string;
+    /** `summary` is a lossy one-field preview; `args` is the full tool_use input
+     *  (e.g. a sub-agent's `prompt`) so a replayed tool card can show the real
+     *  parameters, not just the whitelisted field. */
+    tools?: {
+        name: string;
+        summary: string;
+        args?: Record<string, unknown>;
+    }[];
+    ts?: number;
+}
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export declare function readRecentHistory(cwd: string, sessionId: string, limit: number, claudeHome?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};

package/dist/cc-orchestrator/session-history.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { encodeCwd } from "./session-discovery.js";
+const NOISE = ["<local-command-caveat>", "<command-name>"];
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content))
+        return content.map((p) => (typeof p?.text === "string" ? p.text : "")).join("");
+    return "";
+}
+function toolsOf(content) {
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const p of content) {
+        if (p?.type === "tool_use") {
+            const inp = p.input ?? {};
+            const summary = inp.command ?? inp.file_path ?? inp.path ?? inp.url ?? inp.pattern ?? inp.query ?? "";
+            const args = inp && typeof inp === "object" && Object.keys(inp).length > 0 ? inp : undefined;
+            out.push({ name: typeof p.name === "string" ? p.name : "tool", summary: String(summary).slice(0, 120), args });
+        }
+    }
+    return out;
+}
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return { messages: [], hasMore: false, totalCount: 0 };
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return { messages: [], hasMore: false, totalCount: 0 };
+    }
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type === "user") {
+            const t = textOf(d.message?.content).trim();
+            if (!t || NOISE.some((n) => t.startsWith(n)))
+                continue;
+            all.push({ role: "user", text: t.slice(0, 4000) });
+        }
+        else if (d.type === "assistant") {
+            const t = textOf(d.message?.content).trim();
+            const tools = toolsOf(d.message?.content);
+            if (!t && tools.length === 0)
+                continue;
+            all.push({ role: "assistant", text: t.slice(0, 4000), tools: tools.length ? tools : undefined });
+        }
+    }
+    const lim = limit > 0 ? limit : 20;
+    const start = Math.max(0, all.length - lim);
+    return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
+}

package/dist/cli/agent-server-stdio.d.ts

@@ -29,4 +29,29 @@
  * transport is stdio NDJSON and the protocol surface is unchanged, this
  * bootstrap is invisible to them.
  */
-export {};
+import type { EngineConfigSlice } from "../protocol/chat-session-manager.js";
+import { type ValidatedSettings } from "../settings/schema.js";
+/**
+ * Resolve per-session agent config: protocol slice overrides win, else fall
+ * back to disk settings.agent.*. Fixes the bug where settings.agent.* never
+ * reached session engines (slice arrived with only permissionMode+cwd).
+ */
+export declare function resolveSessionAgentConfig(slice: EngineConfigSlice, settings: ValidatedSettings): {
+    preset: string;
+    customSystemPrompt: string | undefined;
+    appendSystemPrompt: string | undefined;
+};
+/**
+ * Resolve a session's effective cwd. A protocol slice with an explicit cwd
+ * points the session at that project; a slice WITHOUT a cwd is a no-repo
+ * "纯聊天" session (the renderer omits cwd when no project is selected) and must
+ * land in the no-repo sandbox (~/.code-shell/no-repo) — NOT the worker's boot
+ * cwd.
+ *
+ * Why not the boot cwd: this stdio worker is long-lived and reused across
+ * sessions/projects, so its boot cwd is whatever project first spawned it.
+ * Inheriting it for a no-repo chat would (a) silently run the chat against a
+ * stale, unrelated project's files and (b) defeat the no-repo skill/plugin
+ * whitelist inversion (which only fires when cwd === noRepoDir).
+ */
+export declare function resolveSessionCwd(slice: EngineConfigSlice): string;