@co0ontty/wand 4.81.0 → 4.82.0

package/dist/pi-model-discovery.js

@@ -0,0 +1,281 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/;
+const SUPPORTED_APIS = new Set([
+    "anthropic-messages",
+    "google-generative-ai",
+    "openai-completions",
+    "openai-responses",
+]);
+const MAX_PAGES_PER_ENDPOINT = 40;
+const MAX_MODELS_PER_ENDPOINT = 2000;
+const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+const REQUEST_TIMEOUT_MS = 10_000;
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveConfigValue(value, env) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("!"))
+        return null;
+    const dollarEscape = "\u0000";
+    const bangEscape = "\u0001";
+    let missingReference = false;
+    const expanded = trimmed
+        .replace(/\$\$/g, dollarEscape)
+        .replace(/\$!/g, bangEscape)
+        .replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, braced, bare) => {
+        const resolved = env[braced ?? bare ?? ""];
+        if (resolved === undefined) {
+            missingReference = true;
+            return "";
+        }
+        return resolved;
+    })
+        .replaceAll(dollarEscape, "$")
+        .replaceAll(bangEscape, "!");
+    return missingReference || !expanded.trim() ? null : expanded;
+}
+function configuredHeaders(value, env) {
+    if (!isRecord(value))
+        return {};
+    const headers = {};
+    for (const [name, rawValue] of Object.entries(value)) {
+        if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,128}$/.test(name))
+            continue;
+        const headerValue = resolveConfigValue(rawValue, env);
+        if (!headerValue || headerValue.length > 16_384 || /[\r\n]/.test(headerValue))
+            continue;
+        headers[name] = headerValue;
+    }
+    return headers;
+}
+function endpointUrl(baseUrl, api) {
+    try {
+        const url = new URL(baseUrl);
+        if ((url.protocol !== "http:" && url.protocol !== "https:") || url.username || url.password)
+            return null;
+        const basePath = url.pathname.replace(/\/+$/, "");
+        let suffix;
+        if (api === "anthropic-messages") {
+            suffix = /\/v\d+(?:beta)?$/i.test(basePath) ? "models" : "v1/models";
+        }
+        else if (api === "google-generative-ai") {
+            suffix = /\/v\d+(?:beta)?$/i.test(basePath) ? "models" : "v1beta/models";
+        }
+        else {
+            suffix = "models";
+        }
+        url.pathname = `${basePath}/${suffix}`.replace(/\/{2,}/g, "/");
+        url.hash = "";
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+function providerEndpoints(providersValue, env) {
+    if (!isRecord(providersValue))
+        return [];
+    const endpoints = [];
+    for (const [provider, rawProvider] of Object.entries(providersValue)) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(provider) || !isRecord(rawProvider))
+            continue;
+        const providerApi = typeof rawProvider.api === "string" ? rawProvider.api.trim() : "";
+        const providerBaseUrl = typeof rawProvider.baseUrl === "string" ? rawProvider.baseUrl.trim() : "";
+        const providerApiKey = resolveConfigValue(rawProvider.apiKey, env) ?? "";
+        const providerKeyConfigured = typeof rawProvider.apiKey === "string" && !!rawProvider.apiKey.trim();
+        const providerHeaders = configuredHeaders(rawProvider.headers, env);
+        const models = Array.isArray(rawProvider.models) ? rawProvider.models : [];
+        const endpointConfigs = [{
+                api: providerApi,
+                baseUrl: providerBaseUrl,
+                apiKey: providerApiKey,
+                apiKeyUnavailable: providerKeyConfigured && !providerApiKey,
+                headers: providerHeaders,
+            }];
+        for (const model of models) {
+            if (!isRecord(model))
+                continue;
+            const api = typeof model.api === "string" && model.api.trim() ? model.api.trim() : providerApi;
+            const baseUrl = typeof model.baseUrl === "string" && model.baseUrl.trim()
+                ? model.baseUrl.trim()
+                : providerBaseUrl;
+            const rawModelApiKey = model.apiKey;
+            const modelApiKey = resolveConfigValue(rawModelApiKey, env);
+            const apiKey = modelApiKey ?? providerApiKey;
+            const apiKeyUnavailable = typeof rawModelApiKey === "string" && !!rawModelApiKey.trim()
+                ? !modelApiKey
+                : providerKeyConfigured && !providerApiKey;
+            const headers = { ...providerHeaders, ...configuredHeaders(model.headers, env) };
+            if (api !== providerApi || baseUrl !== providerBaseUrl || apiKey !== providerApiKey
+                || JSON.stringify(headers) !== JSON.stringify(providerHeaders)) {
+                endpointConfigs.push({ api, baseUrl, apiKey, apiKeyUnavailable, headers });
+            }
+        }
+        const seen = new Set();
+        for (const config of endpointConfigs) {
+            if (!SUPPORTED_APIS.has(config.api) || !config.baseUrl || config.apiKeyUnavailable)
+                continue;
+            const url = endpointUrl(config.baseUrl, config.api);
+            if (!url)
+                continue;
+            // Keep this key in memory only; never log or persist endpoint credentials.
+            const signature = `${config.api}\n${url.href}\n${config.apiKey}\n${JSON.stringify(config.headers)}`;
+            if (seen.has(signature))
+                continue;
+            seen.add(signature);
+            endpoints.push({ provider, ...config });
+        }
+    }
+    return endpoints;
+}
+function asModelId(value, api) {
+    if (typeof value !== "string")
+        return "";
+    const trimmed = value.trim();
+    if (api === "google-generative-ai")
+        return trimmed.replace(/^models\//, "");
+    return trimmed;
+}
+function parseEndpointPage(api, body, provider) {
+    if (!isRecord(body))
+        return { models: [], nextCursor: "" };
+    const rows = Array.isArray(body.data)
+        ? body.data
+        : Array.isArray(body.models) ? body.models : [];
+    const models = [];
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        const id = asModelId(api === "google-generative-ai" ? row.name : row.id, api);
+        const qualifiedId = `${provider}/${id}`;
+        if (!id || id.length > 128 || !MODEL_ID_PATTERN.test(id) || !MODEL_ID_PATTERN.test(qualifiedId))
+            continue;
+        const displayName = typeof row.display_name === "string" ? row.display_name.trim()
+            : typeof row.displayName === "string" ? row.displayName.trim()
+                : typeof row.name === "string" && api !== "google-generative-ai" ? row.name.trim() : "";
+        models.push({
+            id: qualifiedId,
+            label: displayName && displayName !== id ? `${displayName} · ${qualifiedId}` : qualifiedId,
+        });
+    }
+    let nextCursor = "";
+    if (api === "google-generative-ai") {
+        nextCursor = typeof body.nextPageToken === "string" ? body.nextPageToken : "";
+    }
+    else if (body.has_more === true) {
+        const lastRow = rows.at(-1);
+        const lastRowId = isRecord(lastRow) && typeof lastRow.id === "string" ? lastRow.id : "";
+        nextCursor = typeof body.last_id === "string" ? body.last_id : lastRowId;
+    }
+    return { models, nextCursor };
+}
+function pageUrl(endpoint, cursor) {
+    const url = endpointUrl(endpoint.baseUrl, endpoint.api);
+    if (!url)
+        return null;
+    if (cursor) {
+        const key = endpoint.api === "google-generative-ai" ? "pageToken"
+            : endpoint.api === "anthropic-messages" ? "after_id" : "after";
+        url.searchParams.set(key, cursor);
+    }
+    return url;
+}
+async function fetchJson(fetchImpl, url, headers) {
+    try {
+        const response = await fetchImpl(url, {
+            method: "GET",
+            headers: { accept: "application/json", ...headers },
+            redirect: "error",
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const text = await response.text();
+        if (Buffer.byteLength(text, "utf8") > MAX_RESPONSE_BYTES)
+            return null;
+        return JSON.parse(text);
+    }
+    catch {
+        // Provider errors can echo private endpoint URLs or request credentials. Discovery is
+        // best-effort, so keep failures private and leave the Pi CLI catalog available.
+        return null;
+    }
+}
+async function fetchEndpointModels(endpoint, fetchImpl) {
+    const result = [];
+    const seen = new Set();
+    let cursor = "";
+    for (let page = 0; page < MAX_PAGES_PER_ENDPOINT && result.length < MAX_MODELS_PER_ENDPOINT; page++) {
+        const url = pageUrl(endpoint, cursor);
+        if (!url)
+            break;
+        const headers = { ...endpoint.headers };
+        if (endpoint.apiKey) {
+            if (endpoint.api === "google-generative-ai")
+                headers["x-goog-api-key"] = endpoint.apiKey;
+            else if (endpoint.api === "anthropic-messages") {
+                headers["x-api-key"] = endpoint.apiKey;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+            else
+                headers.authorization = `Bearer ${endpoint.apiKey}`;
+        }
+        const body = await fetchJson(fetchImpl, url, headers);
+        if (!body)
+            break;
+        const parsed = parseEndpointPage(endpoint.api, body, endpoint.provider);
+        for (const model of parsed.models) {
+            if (seen.has(model.id))
+                continue;
+            seen.add(model.id);
+            result.push(model);
+            if (result.length >= MAX_MODELS_PER_ENDPOINT)
+                break;
+        }
+        if (!parsed.nextCursor || parsed.nextCursor === cursor)
+            break;
+        cursor = parsed.nextCursor;
+    }
+    return result;
+}
+/**
+ * Discovers additional chat model IDs exposed by the API endpoints configured in Pi's models.json.
+ * The endpoint's key stays in memory and is never returned, logged, or persisted in the model catalog.
+ */
+export async function discoverPiEndpointModels(options = {}) {
+    const env = options.env ?? process.env;
+    const agentDir = options.agentDir?.trim()
+        || env.PI_CODING_AGENT_DIR?.trim()
+        || path.join(env.HOME?.trim() || homedir(), ".pi", "agent");
+    let config;
+    try {
+        const contents = await readFile(path.join(path.resolve(agentDir), "models.json"), "utf8");
+        config = JSON.parse(contents);
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(config))
+        return [];
+    const endpoints = providerEndpoints(config.providers, env);
+    if (!endpoints.length)
+        return [];
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    const lists = await Promise.all(endpoints.map((endpoint) => fetchEndpointModels(endpoint, fetchImpl)));
+    const result = [];
+    const seen = new Set();
+    for (const models of lists) {
+        for (const model of models) {
+            if (seen.has(model.id))
+                continue;
+            seen.add(model.id);
+            result.push(model);
+        }
+    }
+    return result;
+}

package/dist/process-manager.d.ts

@@ -20,12 +20,24 @@ export declare class PtyInputDeliveryError extends Error {
     readonly sessionId: string;
     constructor(sessionId: string, cause: unknown);
 }
+/**
+ * Quiet window for the non-Claude PTY turn tracker: a submitted turn stays busy
+ * until the CLI has produced no output for this long (see pty-turn-activity.ts).
+ * Matches the bridge's own idle-probe delay so both paths make the same call.
+ */
+export declare const PTY_TURN_IDLE_MS = 3000;
+export interface ProcessManagerOptions {
+    /** Overrides the non-Claude PTY turn quiet window (tests use a short one). */
+    ptyTurnIdleMs?: number;
+}
 export declare class ProcessManager extends EventEmitter {
     private readonly config;
     private readonly storage;
     private readonly sessions;
     private readonly logger;
     private readonly providerHistory;
+    /** Quiet window for the non-Claude PTY turn tracker. */
+    private readonly ptyTurnIdleMs;
     /** 24h archive scan timer */
     private archiveTimer;
     /** Per-session debounce timers for throttled persist calls */
@@ -40,10 +52,20 @@ export declare class ProcessManager extends EventEmitter {
     private readonly nativeTitles;
     private disposed;
     private readonly terminalHost;
-    constructor(config: WandConfig, storage: WandStorage, configDir?: string, terminalHost?: TerminalHost);
+    constructor(config: WandConfig, storage: WandStorage, configDir?: string, terminalHost?: TerminalHost, options?: ProcessManagerOptions);
     private makeRestoredRecord;
     private bindRestoredTerminal;
     private initializeClaudeBridge;
+    /**
+     * Open a non-Claude PTY turn and start its quiet-window timer. Claude's bridge
+     * owns ptyBusy, so bridged sessions are left untouched.
+     */
+    private openPtyTurn;
+    /** Extend the quiet window because the CLI is still producing output. */
+    private refreshPtyTurn;
+    /** The quiet window elapsed: the CLI is back at its prompt, so the turn is done. */
+    private closePtyTurn;
+    private clearPtyTurn;
     private bindTerminalProcess;
     private handleTerminalResync;
     private handleTerminalExit;

package/dist/process-manager.js

@@ -23,6 +23,7 @@ import { resolveSessionProvider, resolveSystemAiContext } from "./session-ai-con
 import { resolveSessionCwd } from "./session-cwd.js";
 import { inferProviderFromCommand } from "./session-provider.js";
 import { PtyTerminalState } from "./pty-terminal-state.js";
+import { isPtySubmitInput } from "./pty-turn-activity.js";
 import { buildPtyShellLaunchPlan, PtyCliExitMarker } from "./pty-shell-launch.js";
 import { InProcessTerminalHost, } from "./terminal-host.js";
 import { ProviderHistoryScanner, } from "./provider-history-scanner.js";
@@ -481,6 +482,12 @@ function restoreTerminalState(state) {
 const MAX_SESSIONS = 200;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 const CONFIRM_WINDOW_SIZE = 800;
+/**
+ * Quiet window for the non-Claude PTY turn tracker: a submitted turn stays busy
+ * until the CLI has produced no output for this long (see pty-turn-activity.ts).
+ * Matches the bridge's own idle-probe delay so both paths make the same call.
+ */
+export const PTY_TURN_IDLE_MS = 3000;
 const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function getClaudeProjectDir(cwd) {
     // Claude Code encodes the project dir by replacing every non-alphanumeric
@@ -537,6 +544,8 @@ export class ProcessManager extends EventEmitter {
     sessions = new Map();
     logger;
     providerHistory = new ProviderHistoryScanner();
+    /** Quiet window for the non-Claude PTY turn tracker. */
+    ptyTurnIdleMs;
     /** 24h archive scan timer */
     archiveTimer = null;
     /** Per-session debounce timers for throttled persist calls */
@@ -551,10 +560,11 @@ export class ProcessManager extends EventEmitter {
     nativeTitles = new SessionNativeTitleTracker();
     disposed = false;
     terminalHost;
-    constructor(config, storage, configDir, terminalHost) {
+    constructor(config, storage, configDir, terminalHost, options = {}) {
         super();
         this.config = config;
         this.storage = storage;
+        this.ptyTurnIdleMs = options.ptyTurnIdleMs ?? PTY_TURN_IDLE_MS;
         this.terminalHost = terminalHost ?? new InProcessTerminalHost();
         this.logger = new SessionLogger(configDir || path.join(process.env.HOME || process.cwd(), ".wand"), config.shortcutLogMaxBytes);
         let startupCodexHistory = null;
@@ -746,6 +756,48 @@ export class ProcessManager extends EventEmitter {
             this.handleBridgeEvent(record, event);
         });
     }
+    /**
+     * Open a non-Claude PTY turn and start its quiet-window timer. Claude's bridge
+     * owns ptyBusy, so bridged sessions are left untouched.
+     */
+    openPtyTurn(record) {
+        if (record.ptyBridge || !record.providerCliActive || record.status !== "running")
+            return;
+        if (record.ptyBusy !== true) {
+            record.ptyBusy = true;
+            this.emitEvent({ type: "status", sessionId: record.id, data: { ptyBusy: true } });
+        }
+        this.refreshPtyTurn(record);
+    }
+    /** Extend the quiet window because the CLI is still producing output. */
+    refreshPtyTurn(record) {
+        if (record.ptyBridge || !record.providerCliActive)
+            return;
+        if (record.ptyTurnTimer)
+            clearTimeout(record.ptyTurnTimer);
+        const timer = setTimeout(() => {
+            record.ptyTurnTimer = null;
+            if (this.sessions.get(record.id) !== record)
+                return;
+            this.closePtyTurn(record);
+        }, this.ptyTurnIdleMs);
+        timer.unref?.();
+        record.ptyTurnTimer = timer;
+    }
+    /** The quiet window elapsed: the CLI is back at its prompt, so the turn is done. */
+    closePtyTurn(record) {
+        this.clearPtyTurn(record);
+        if (record.ptyBusy !== true)
+            return;
+        record.ptyBusy = false;
+        this.emitEvent({ type: "status", sessionId: record.id, data: { ptyBusy: false } });
+    }
+    clearPtyTurn(record) {
+        if (record.ptyTurnTimer) {
+            clearTimeout(record.ptyTurnTimer);
+            record.ptyTurnTimer = null;
+        }
+    }
     bindTerminalProcess(record, child, onVisibleChunk) {
         child.onResync?.((state) => this.handleTerminalResync(record, child, state));
         child.onData((event) => this.handleTerminalData(record, child, event, onVisibleChunk));
@@ -817,6 +869,7 @@ export class ProcessManager extends EventEmitter {
             current.providerCliActive = false;
             current.providerCliExitCode = exitCode;
         }
+        this.clearPtyTurn(current);
         current.ptyBusy = false;
         current.pendingEscalation = null;
         current.ptyPermissionBlocked = false;
@@ -884,6 +937,10 @@ export class ProcessManager extends EventEmitter {
         if (chunk && current.providerCliActive && current.autoApprovePermissions && !current.ptyBridge && current.provider === "claude") {
             this.autoConfirmWithRecord(current, chunk, child);
         }
+        // Non-Claude CLIs have no parsed turn boundary; any output while a turn is
+        // open keeps it open (see pty-turn-activity.ts).
+        if (chunk && current.ptyBusy === true)
+            this.refreshPtyTurn(current);
         if (chunk)
             onVisibleChunk?.(chunk);
         if (boundary.exitCode !== null)
@@ -1213,6 +1270,8 @@ export class ProcessManager extends EventEmitter {
             }
             child.write(initialInputText);
             child.write("\r");
+            if (!current.ptyBridge)
+                this.openPtyTurn(current);
         };
         this.bindTerminalProcess(record, child, (chunk) => {
             if (initialInputText && !initialInputSent && (chunk.includes("❯") || chunk.includes("›")))
@@ -1598,6 +1657,11 @@ export class ProcessManager extends EventEmitter {
         if (record.ptyBridge && trackUserInput) {
             record.ptyBridge.onUserInput(input);
         }
+        // Non-Claude CLIs report no parsed boundary, so a line submit opens a turn
+        // that a quiet window later closes.
+        if (trackUserInput && !record.ptyBridge && isPtySubmitInput(input)) {
+            this.openPtyTurn(record);
+        }
     }
     resize(id, cols, rows) {
         const record = this.mustGet(id);
@@ -1651,6 +1715,7 @@ export class ProcessManager extends EventEmitter {
         record.providerCliExitCode = exitCode;
         record.providerShellMarker = null;
         record.ptyLaunchMarkerToken = null;
+        this.clearPtyTurn(record);
         record.ptyBusy = false;
         if (record.claudeTaskDiscoveryTimer) {
             clearTimeout(record.claudeTaskDiscoveryTimer);
@@ -1718,6 +1783,7 @@ export class ProcessManager extends EventEmitter {
         record.providerCliActive = false;
         record.providerShellMarker = null;
         record.ptyLaunchMarkerToken = null;
+        this.clearPtyTurn(record);
         record.ptyBusy = false;
         // Kill any running child process (from JSON chat turns)
         if (record.childProcess) {
@@ -1754,6 +1820,7 @@ export class ProcessManager extends EventEmitter {
         return this.snapshot(record);
     }
     cleanupRecord(record, terminateTerminal = true) {
+        this.clearPtyTurn(record);
         if (record.claudeTaskDiscoveryTimer) {
             clearTimeout(record.claudeTaskDiscoveryTimer);
             record.claudeTaskDiscoveryTimer = null;

package/dist/prompt-optimizer.js

@@ -31,9 +31,17 @@ export async function optimizePrompt(rawText, language, cwd, ai = {}) {
         throw new PromptOptimizeError(`输入过长（${text.length} 字符），请缩短到 ${MAX_INPUT_LENGTH} 以内。`, "INPUT_TOO_LONG");
     }
     const request = buildOptimizePrompt(text, language);
-    let raw;
     try {
-        raw = await callConfiguredAiText(request, cwd ?? process.cwd(), language, ai);
+        return await callConfiguredAiText(request, cwd ?? process.cwd(), language, ai, (raw) => {
+            const cleaned = raw
+                .replace(/^```[a-zA-Z]*\n?/, "")
+                .replace(/\n?```$/, "")
+                .replace(/^["'`]+|["'`]+$/g, "")
+                .trim();
+            if (!cleaned)
+                throw new PromptOptimizeError("AI 返回了空结果。", "EMPTY_RESULT");
+            return cleaned;
+        });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -42,13 +50,4 @@ export async function optimizePrompt(rawText, language, cwd, ai = {}) {
             : "AI_OPTIMIZE_FAILED";
         throw new PromptOptimizeError(message, code);
     }
-    const cleaned = raw
-        .replace(/^```[a-zA-Z]*\n?/, "")
-        .replace(/\n?```$/, "")
-        .replace(/^["'`]+|["'`]+$/g, "")
-        .trim();
-    if (!cleaned) {
-        throw new PromptOptimizeError("AI 返回了空结果。", "EMPTY_RESULT");
-    }
-    return cleaned;
 }

package/dist/pty-turn-activity.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PTY turn-activity heuristics for provider CLIs other than Claude.
+ *
+ * Claude has `ClaudePtyBridge`, which parses the TUI and reports an exact
+ * per-turn phase. Every other provider CLI writes an opaque TUI to the PTY, so
+ * the server cannot parse a turn boundary out of the bytes. What is left is
+ * output activity: a working CLI keeps redrawing (streamed tokens, spinner,
+ * elapsed counters), while a finished turn returns to a static prompt and the
+ * bytes stop. So a turn is opened on submit and closed once the session has been
+ * silent for a quiet window, refreshed on every chunk.
+ *
+ * The principled alternative is to ask the OS whether the terminal's foreground
+ * process group is blocked on a tty read (that is the real meaning of "waiting
+ * for input"). It works for any provider and is immune to spinners, but it needs
+ * the PTY-owning daemon (Render) to expose foreground-pgrp state, so it is left
+ * as a follow-up. This module is the deliberate fallback.
+ */
+/**
+ * Whether a PTY input chunk is a line submit rather than body text.
+ *
+ * The input contract sends the prompt text and the terminating Enter as two
+ * separate chunks (`getTerminalSubmitChunks`), so a submit is a chunk made
+ * purely of line terminators (plus whitespace). Pasted text that happens to end
+ * in a newline carries body and is intentionally not treated as a submit: a TUI
+ * may still be editing it, and a missed turn start only under-reports activity.
+ */
+export declare function isPtySubmitInput(input: string): boolean;

package/dist/pty-turn-activity.js

@@ -0,0 +1,31 @@
+/**
+ * PTY turn-activity heuristics for provider CLIs other than Claude.
+ *
+ * Claude has `ClaudePtyBridge`, which parses the TUI and reports an exact
+ * per-turn phase. Every other provider CLI writes an opaque TUI to the PTY, so
+ * the server cannot parse a turn boundary out of the bytes. What is left is
+ * output activity: a working CLI keeps redrawing (streamed tokens, spinner,
+ * elapsed counters), while a finished turn returns to a static prompt and the
+ * bytes stop. So a turn is opened on submit and closed once the session has been
+ * silent for a quiet window, refreshed on every chunk.
+ *
+ * The principled alternative is to ask the OS whether the terminal's foreground
+ * process group is blocked on a tty read (that is the real meaning of "waiting
+ * for input"). It works for any provider and is immune to spinners, but it needs
+ * the PTY-owning daemon (Render) to expose foreground-pgrp state, so it is left
+ * as a follow-up. This module is the deliberate fallback.
+ */
+/**
+ * Whether a PTY input chunk is a line submit rather than body text.
+ *
+ * The input contract sends the prompt text and the terminating Enter as two
+ * separate chunks (`getTerminalSubmitChunks`), so a submit is a chunk made
+ * purely of line terminators (plus whitespace). Pasted text that happens to end
+ * in a newline carries body and is intentionally not treated as a submit: a TUI
+ * may still be editing it, and a missed turn start only under-reports activity.
+ */
+export function isPtySubmitInput(input) {
+    if (!input || !/[\r\n]/.test(input))
+        return false;
+    return input.replace(/[\r\n]/g, "").trim().length === 0;
+}

package/dist/server-employee-routes.js

@@ -1,12 +1,12 @@
 import { randomUUID } from "node:crypto";
-import { AI_TEAM_MAX_CANDIDATES, SILICON_EMPLOYEE_AVATAR_MAX_CHARS, agentKey, } from "./ai-team-types.js";
+import { AI_TEAM_MAX_CANDIDATES, SILICON_EMPLOYEE_AVATAR_MAX_CHARS, agentKey, isBuiltinSiliconEmployee, } from "./ai-team-types.js";
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute } from "./express-async.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
 import { parseTaskAgent } from "./server-task-routes.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { generateSiliconEmployeeDraft } from "./silicon-employee-draft.js";
-import { isSystemSiliconEmployee } from "./system-employee.js";
+import { EMPLOYEE_KNOWLEDGE_MAX_ENTRIES } from "./employee-knowledge-types.js";
 /** 员工起草没有会话上下文，按「默认 provider」解析，与任务标题 / 提示词优化一致。 */
 function employeeDraftAiOptions(storage, config) {
     if (!config)
@@ -28,9 +28,9 @@ function sendEmployeeError(res, error) {
 }
 /** 内置员工是 Wand 自己的执行者，不能被归档或删除。 */
 function rejectSystemEmployeeMutation(existing, action) {
-    if (!isSystemSiliconEmployee(existing))
+    if (!isBuiltinSiliconEmployee(existing))
         return;
-    throw new Error(`「${existing.name}」是 Wand 内置的系统运维员工，不能${action}。`);
+    throw new Error(`「${existing.name}」是 Wand 内置员工，不能${action}。`);
 }
 function boundedText(value, label, min, max) {
     const result = text(value);
@@ -72,7 +72,7 @@ export function parseSystemEmployeeAgents(value, existing) {
         const current = existing[field.key];
         const isSame = typeof incoming === "string" && incoming === current;
         if (!isSame) {
-            throw new Error(`系统运维员工是内置的，${field.label}不可修改。`);
+            throw new Error(`该员工是内置的，${field.label}不可修改。`);
         }
     }
     if (!Array.isArray(body.agents))
@@ -214,13 +214,59 @@ export function registerSiliconEmployeeRoutes(app, deps) {
             sendEmployeeError(res, error);
         }
     });
+    app.get("/api/silicon-employees/:id/knowledge", (req, res) => {
+        try {
+            res.setHeader("Cache-Control", "no-store");
+            const employeeId = req.params.id;
+            const query = typeof req.query.q === "string" ? req.query.q : "";
+            res.json({ employeeId, entries: storage.listEmployeeKnowledge(employeeId, query),
+                total: storage.countEmployeeKnowledge(employeeId), maxEntries: EMPLOYEE_KNOWLEDGE_MAX_ENTRIES });
+        }
+        catch (error) {
+            sendEmployeeError(res, error);
+        }
+    });
+    app.post("/api/silicon-employees/:id/knowledge", (req, res) => {
+        try {
+            const body = bodyObject(req.body);
+            if (typeof body.content !== "string")
+                throw new Error("content 必须是知识文字。");
+            const entry = storage.rememberEmployeeKnowledge(req.params.id, body.content);
+            res.status(201).json(entry);
+        }
+        catch (error) {
+            sendEmployeeError(res, error);
+        }
+    });
+    app.delete("/api/silicon-employees/:id/knowledge/:entryId", (req, res) => {
+        try {
+            const deleted = storage.forgetEmployeeKnowledge(req.params.id, req.params.entryId);
+            if (!deleted) {
+                res.status(404).json({ error: "该知识不属于当前员工或已删除。" });
+                return;
+            }
+            res.json({ deleted: true });
+        }
+        catch (error) {
+            sendEmployeeError(res, error);
+        }
+    });
+    app.delete("/api/silicon-employees/:id/knowledge", (req, res) => {
+        try {
+            storage.clearEmployeeKnowledge(req.params.id);
+            res.json({ employeeId: req.params.id, entries: [], total: 0, maxEntries: EMPLOYEE_KNOWLEDGE_MAX_ENTRIES });
+        }
+        catch (error) {
+            sendEmployeeError(res, error);
+        }
+    });
     app.put("/api/silicon-employees/:id", (req, res) => {
         try {
             const existing = storage.getSiliconEmployee(req.params.id);
             if (!existing)
                 throw new Error(`硅基员工「${req.params.id}」不存在。`);
             const now = new Date().toISOString();
-            const employee = isSystemSiliconEmployee(existing)
+            const employee = isBuiltinSiliconEmployee(existing)
                 ? { ...existing, agents: parseSystemEmployeeAgents(req.body, existing), updatedAt: now }
                 : parseSiliconEmployeeInput(req.body, existing, now);
             storage.saveSiliconEmployee(employee);