@co0ontty/wand 4.83.1 → 4.84.0

package/dist/path-repair.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { setLoginShellEnv } from "./env-utils.js";
 import { compareSemver } from "./version-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { providerCliCommand, SESSION_PROVIDERS } from "./session-provider.js";
@@ -177,6 +178,7 @@ export async function deepRepairRuntimePath(result, opts = {}) {
         result.deepProbe = "skipped";
         return result;
     }
+    result.shell = shell;
     let probe;
     try {
         probe = await probeLoginShell(shell, opts.timeoutMs ?? DEEP_PROBE_TIMEOUT_MS);
@@ -186,6 +188,13 @@ export async function deepRepairRuntimePath(result, opts = {}) {
         result.deepProbe = "failed";
         return result;
     }
+    if (process.env.WAND_SHELL_ENV_DISABLE === "1") {
+        result.warnings.push("跳过登录 shell 环境回收：WAND_SHELL_ENV_DISABLE=1");
+    }
+    else {
+        setLoginShellEnv(probe.env);
+        result.shellEnvVars = Object.keys(probe.env).filter((key) => !(key in process.env)).length;
+    }
     const delim = path.delimiter;
     const currentSegments = (process.env.PATH ?? "")
         .split(delim)
@@ -237,6 +246,32 @@ export async function deepRepairRuntimePath(result, opts = {}) {
     result.deepProbe = "success";
     return result;
 }
+/** 探测用的 shell 自身状态，不回填给会话（探测把 PS1 清空只为解析 stdout）。 */
+const PROBE_ONLY_ENV_KEYS = ["PS0", "PS1", "PS2", "PS3", "PS4", "PROMPT_COMMAND"];
+const ENV_LINE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const ENV_BEGIN_MARKER = "WAND_ENV_BEGIN_7c1f";
+const ENV_END_MARKER = "WAND_ENV_END_7c1f";
+/**
+ * 解析 env 输出。只接受形如 `NAME=value` 的行：交互式 rc 可能往 stdout 喷无关内容，
+ * 把噪声行当"上一个值的续行"会污染变量，宁可丢掉内嵌换行这种罕见值。
+ */
+function parseEnvDump(stdout) {
+    const begin = stdout.indexOf(`${ENV_BEGIN_MARKER}\n`);
+    const end = stdout.lastIndexOf(`\n${ENV_END_MARKER}`);
+    const env = {};
+    if (begin < 0 || end < begin)
+        return env;
+    for (const line of stdout.slice(begin + ENV_BEGIN_MARKER.length + 1, end).split("\n")) {
+        if (!ENV_LINE.test(line))
+            continue;
+        const idx = line.indexOf("=");
+        const key = line.slice(0, idx);
+        if (PROBE_ONLY_ENV_KEYS.includes(key))
+            continue;
+        env[key] = line.slice(idx + 1);
+    }
+    return env;
+}
 function pickProbeShell(configured) {
     const candidates = [
         configured,
@@ -254,8 +289,8 @@ function pickProbeShell(configured) {
     return null;
 }
 /**
- * 用与 PTY provider 相同的交互式 login shell 跑最小脚本，拿到实际的 PATH 和 CLI 路径。
- * 用 \x1f（ASCII Unit Separator）作字段分隔符避免和路径里的字符冲突。
+ * 用与 PTY provider 相同的交互式 login shell 跑最小脚本，拿到实际的 PATH、CLI 路径和
+ * rc 生效后的完整环境。用 \x1f（ASCII Unit Separator）作字段分隔符避免和路径里的字符冲突。
  */
 function probeLoginShell(shell, timeoutMs) {
     const script = `printf 'PATH\\x1f%s\\n' "$PATH"; ` +
@@ -263,7 +298,8 @@ function probeLoginShell(shell, timeoutMs) {
         `printf 'CODEX\\x1f%s\\n' "$(command -v codex 2>/dev/null)"; ` +
         `printf 'OPENCODE\\x1f%s\\n' "$(command -v opencode 2>/dev/null)"; ` +
         `printf 'GROK\\x1f%s\\n' "$(command -v grok 2>/dev/null)"; ` +
-        `printf 'QODERCLI\\x1f%s\\n' "$(command -v qodercli 2>/dev/null)"`;
+        `printf 'QODERCLI\\x1f%s\\n' "$(command -v qodercli 2>/dev/null)"; ` +
+        `printf '\\n${ENV_BEGIN_MARKER}\\n'; command env; printf '${ENV_END_MARKER}\\n'`;
     return new Promise((resolve, reject) => {
         const child = spawn(shell, ["-lic", script], {
             env: {
@@ -303,7 +339,15 @@ function probeLoginShell(shell, timeoutMs) {
                     reject(new Error(`login shell exited ${code}: ${stderr.trim().slice(0, 200)}`));
                     return;
                 }
-                const out = { path: "", claude: null, codex: null, opencode: null, grok: null, qodercli: null };
+                const out = {
+                    path: "",
+                    claude: null,
+                    codex: null,
+                    opencode: null,
+                    grok: null,
+                    qodercli: null,
+                    env: parseEnvDump(stdout),
+                };
                 for (const line of stdout.split("\n")) {
                     const idx = line.indexOf("\x1f");
                     if (idx < 0)
@@ -378,7 +422,8 @@ export function formatPathRepairSummary(result) {
         parts.push(`deep-probe: ${result.warnings[0]}`);
     }
     else if (result.deepProbe === "success") {
-        parts.push("deep-probe: ok");
+        const envSuffix = result.shellEnvVars ? `, +${result.shellEnvVars} env vars` : "";
+        parts.push(`deep-probe: ok${result.shell ? ` (${result.shell})` : ""}${envSuffix}`);
     }
     return parts.join("; ");
 }

package/dist/pi-auto-resources.d.ts

@@ -0,0 +1,12 @@
+import { type PiResourceInventory } from "./pi-resource-catalog.js";
+import { type PiResourceEvaluator } from "./pi-resource-recommendation.js";
+import type { StructuredRunnerAdapter } from "./structured-runner.js";
+import type { WandConfig } from "./types.js";
+interface AutoResourceOptions {
+    evaluate(): PiResourceEvaluator | undefined;
+    inventory?: (cwd: string) => Promise<PiResourceInventory>;
+    timeoutMs?: number;
+}
+/** Owned by the submitted runner, not by the composer. Manual settings are never overwritten. */
+export declare function withAutomaticPiResources(runner: StructuredRunnerAdapter, config: Pick<WandConfig, "harness">, options: AutoResourceOptions): StructuredRunnerAdapter;
+export {};

package/dist/pi-auto-resources.js

@@ -0,0 +1,151 @@
+import { DecisionError } from "./decision-types.js";
+import { discoverPiResources, resolvePiResourceSelection } from "./pi-resource-catalog.js";
+import { decidePiCodemode, parsePiRecommendationRequest, recommendPiResources } from "./pi-resource-recommendation.js";
+import { patchPiResourceSelection } from "./pi-session-settings.js";
+/** Owned by the submitted runner, not by the composer. Manual settings are never overwritten. */
+export function withAutomaticPiResources(runner, config, options) {
+    return { start(context, observer) {
+            if (context.session.provider !== "pi" || context.session.piSettings?.autoResources !== true) {
+                return runner.start(context, observer);
+            }
+            const abort = new AbortController();
+            let interrupted = false;
+            let execution = null;
+            let notice = { status: "selecting", label: "正在自动选择 Skills / MCP / CodeMode…", skills: [], mcpServers: [] };
+            const withNotice = (state) => ({ ...state, resourceSelection: notice });
+            const publish = () => {
+                if (observer.isActive() && !interrupted)
+                    observer.onUpdate(withNotice({ blocks: [], result: "", sessionId: context.session.claudeSessionId }));
+            };
+            // The manager receives ownership synchronously; all asynchronous work starts in the next microtask.
+            const spawnedAt = new Date().toISOString();
+            const completion = Promise.resolve().then(async () => {
+                const checkActive = () => {
+                    if (interrupted || !observer.isActive())
+                        throw new DecisionError("CANCELLED", "自动选择已取消，尚未启动 Pi。", 499);
+                };
+                checkActive();
+                publish();
+                const manual = context.session.piSettings?.resources ?? { skills: [], mcpServers: [] };
+                const locked = new Set(context.session.piSettings?.lockedSkills ?? []);
+                let selected = manual;
+                const manualCodemode = context.session.piSettings?.codemodeOverride;
+                let automaticCodemode;
+                let inventory;
+                let fallback = "";
+                let timer;
+                try {
+                    inventory = await (options.inventory?.(context.session.cwd) ?? discoverPiResources(config, context.session.cwd));
+                    checkActive();
+                    // A missing manual resource must fail as usual, never be silently replaced by an automatic pick.
+                    resolvePiResourceSelection(inventory, manual);
+                    const evaluate = context.session.piSettings?.localDecision === false ? undefined : options.evaluate();
+                    if (!evaluate)
+                        throw new DecisionError("UNAVAILABLE", "本地决策不可用");
+                    const candidates = {
+                        skills: inventory.catalog.skills.filter((item) => !locked.has(item.id)).map((item) => item.id),
+                        mcpServers: inventory.catalog.mcpServers.filter((item) => inventory.servers.get(item.id)?.config.enabled !== false)
+                            .map((item) => item.id),
+                    };
+                    const request = parsePiRecommendationRequest({ prompt: context.prompt, candidates });
+                    timer = setTimeout(() => abort.abort(), options.timeoutMs ?? 15_000);
+                    const boundedEvaluate = (value, caller, signal) => new Promise((resolve, reject) => {
+                        const cancelled = () => reject(new DecisionError("CANCELLED", "本地选择已取消"));
+                        if (signal?.aborted) {
+                            cancelled();
+                            return;
+                        }
+                        signal?.addEventListener("abort", cancelled, { once: true });
+                        Promise.resolve().then(() => { checkActive(); return evaluate(value, caller, signal); }).then(resolve, reject)
+                            .finally(() => signal?.removeEventListener("abort", cancelled));
+                    });
+                    if (!manualCodemode)
+                        automaticCodemode = await decidePiCodemode({
+                            prompt: request.prompt, evaluate: boundedEvaluate, caller: `pi-auto-resources:${context.session.id}`, signal: abort.signal,
+                        });
+                    const result = await recommendPiResources({ ...request, catalog: inventory.catalog, evaluate: boundedEvaluate,
+                        caller: `pi-auto-resources:${context.session.id}`, signal: abort.signal });
+                    checkActive();
+                    if (abort.signal.aborted)
+                        throw new DecisionError("TIMEOUT", "本地选择超时");
+                    selected = patchPiResourceSelection({
+                        skills: [...new Set([...manual.skills.filter((id) => locked.has(id)),
+                                ...result.selection.skills.filter((id) => !locked.has(id))])],
+                        mcpServers: [...new Set([...manual.mcpServers, ...result.selection.mcpServers])],
+                    });
+                    resolvePiResourceSelection(inventory, selected);
+                }
+                catch (error) {
+                    checkActive();
+                    selected = manual;
+                    automaticCodemode = undefined;
+                    // Explicit manual constraints remain authoritative even when inference failed.
+                    if (inventory)
+                        resolvePiResourceSelection(inventory, manual);
+                    fallback = error instanceof DecisionError ? error.code === "CANDIDATE_LIMIT" ? "候选过多"
+                        : error.code === "INVALID_REQUEST" ? "提示词超出本地选择范围"
+                            : error.code === "TIMEOUT" || abort.signal.aborted ? "本地选择超时" : "本地决策不可用"
+                        : "资源目录暂不可用";
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                }
+                checkActive();
+                const names = (kind) => selected[kind].map((id) => (inventory?.catalog[kind].find((item) => item.id === id)?.name ?? "已手选资源").slice(0, 80));
+                const skills = names("skills");
+                const mcpServers = names("mcpServers");
+                const codemode = {
+                    mode: manualCodemode ?? automaticCodemode?.override ?? "follow",
+                    source: manualCodemode ? "manual" : fallback ? "fallback" : automaticCodemode?.override ? "automatic" : "uncertain",
+                };
+                const codemodeLabel = codemode.mode === "on" ? "启用" : codemode.mode === "off" ? "关闭"
+                    : codemode.mode === "only" ? "仅 CodeMode" : "跟随 Pi";
+                const chosen = [skills.length ? `Skills：${skills.join("、")}` : "", mcpServers.length ? `MCP：${mcpServers.join("、")}` : "",
+                    `CodeMode：${codemodeLabel}${codemode.source === "manual" ? "（手动）" : codemode.source === "uncertain" ? "（判断不确定）" : ""}`].filter(Boolean).join("；");
+                notice = { status: fallback ? "fallback" : "selected", skills, mcpServers, codemode,
+                    label: fallback ? `自动选择：${fallback}，沿用手选（${chosen}）` : `本轮选择 · ${chosen}` };
+                if (notice.label.length > 1024)
+                    notice = { ...notice, label: `${notice.label.slice(0, 1023)}…` };
+                // This is a server-owned selection record, not a fabricated provider tool call.
+                observer.onEvent?.({ type: "wand_pi_resource_selection", ...notice });
+                publish();
+                const scoped = { ...context, session: { ...context.session,
+                        piSettings: { ...context.session.piSettings, resources: selected,
+                            ...(!manualCodemode && automaticCodemode?.override ? { codemodeOverride: automaticCodemode.override } : {}) } } };
+                const scopedObserver = { ...observer, onUpdate: (state) => {
+                        if (!interrupted && observer.isActive())
+                            observer.onUpdate(withNotice(state));
+                    } };
+                checkActive();
+                execution = runner.start(scoped, scopedObserver);
+                const result = await execution.completion;
+                // Selection notices are metadata, not model execution. A fallback tool starts with
+                // its own configuration; cancelled/failed preparation below is still never retried.
+                return { ...result, state: withNotice(result.state) };
+            }).catch((error) => {
+                if (notice.status === "selecting") {
+                    notice = interrupted || error instanceof DecisionError && error.code === "CANCELLED"
+                        ? { ...notice, status: "cancelled", label: "本轮自动选择已取消" }
+                        : { ...notice, status: "fallback", label: "自动配置准备失败，尚未启动 Pi" };
+                }
+                return {
+                    state: withNotice({ blocks: [], result: "", sessionId: context.session.claudeSessionId }),
+                    exitCode: 1, signal: null, stderr: "", primaryError: error instanceof Error ? error.message : "自动选择准备失败。",
+                    inputAccepted: false, retryForbidden: true,
+                };
+            });
+            return { get args() { return execution?.args ?? []; }, get pid() { return execution?.pid ?? null; },
+                spawnedAt, completion, interrupt: () => {
+                    if (interrupted)
+                        return;
+                    if (notice.status === "selecting") {
+                        notice = { ...notice, status: "cancelled", label: "本轮自动选择已取消" };
+                        publish();
+                    }
+                    interrupted = true;
+                    abort.abort();
+                    execution?.interrupt();
+                } };
+        } };
+}

package/dist/pi-execution-types.d.ts

@@ -0,0 +1,48 @@
+export type PiExecutionState = "pending" | "running" | "background" | "completed" | "failed" | "paused" | "stopped" | "detached" | "rejected" | "skipped" | "partial" | "unknown";
+export interface PiExecutionNode {
+    id: string;
+    parentId?: string;
+    label: string;
+    kind: string;
+    state: PiExecutionState;
+    phase?: string;
+    agent?: string;
+    model?: string;
+    runId?: string;
+    task?: string;
+    currentTool?: string;
+    durationMs?: number;
+    tokens?: number;
+    toolCount?: number;
+    error?: string;
+    output?: string;
+}
+export interface PiExecutionSnapshot {
+    version: 1;
+    source: "tool-progress" | "tool-result" | "status-file";
+    mode: string;
+    name?: string;
+    runId?: string;
+    state: PiExecutionState;
+    inventoryComplete: boolean;
+    updatedAt?: number;
+    nodes: PiExecutionNode[];
+    trace: Array<{
+        key: string;
+        operation: string;
+        state: string;
+        phase?: string;
+        durationMs?: number;
+        error?: string;
+    }>;
+    omittedNodes: number;
+    omittedTrace: number;
+}
+export interface PiExecutionResponse {
+    toolId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    script?: string;
+    snapshot: PiExecutionSnapshot | null;
+    notice?: string;
+}

package/dist/pi-execution-types.js

@@ -0,0 +1 @@
+export {};

package/dist/pi-execution.d.ts

@@ -0,0 +1,9 @@
+import type { ContentBlock, ConversationTurn } from "./types.js";
+import type { PiExecutionSnapshot, PiExecutionState, PiExecutionResponse } from "./pi-execution-types.js";
+export declare function isPiExecutionTool(name: string): boolean;
+/** Only execution fields cross the host boundary; never forward arbitrary extension details. */
+export declare function projectPiExecution(raw: unknown, source: PiExecutionSnapshot["source"], fallbackState: PiExecutionState): PiExecutionSnapshot | null;
+/** Partial updates update the invocation, never create a final tool_result or imply delivery. */
+export declare function capturePiExecutionEvent(blocks: ContentBlock[], event: Record<string, unknown>): void;
+/** Inspect only a run referenced by this session. Old receipts use the package's fixed temp roots. */
+export declare function inspectPiExecution(messages: ConversationTurn[], toolId: string): Promise<PiExecutionResponse | null>;

package/dist/pi-execution.js

@@ -0,0 +1,187 @@
+import { readdir, open } from "node:fs/promises";
+import { constants } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const MAX_NODES = 80;
+const MAX_TRACE = 128;
+const UUID = /^[0-9a-f]{8}-[0-9a-f-]{27,55}$/i;
+const record = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+const text = (v, max = 256) => typeof v === "string" && v.trim() ? v.slice(0, max) : undefined;
+const number = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : undefined;
+const array = (v) => Array.isArray(v) ? v : [];
+export function isPiExecutionTool(name) {
+    return ["subagent", "workflow"].includes(name.replace(/^Pi\//, ""));
+}
+function state(v) {
+    const aliases = { complete: "completed", done: "completed", error: "failed", queued: "pending", started: "running" };
+    const s = String(v ?? "");
+    return aliases[s] ?? (["pending", "running", "background", "completed", "failed", "paused", "stopped", "detached", "rejected", "skipped", "partial"].includes(s) ? s : "unknown");
+}
+/** Only execution fields cross the host boundary; never forward arbitrary extension details. */
+export function projectPiExecution(raw, source, fallbackState) {
+    const d = record(raw);
+    const children = record(d.workflowChildren);
+    if (!Object.keys(d).length || !(d.mode || d.workflowChildren || d.workflowGraph || Array.isArray(d.agents) || Array.isArray(d.progress)))
+        return null;
+    const workflow = record(d.workflow);
+    const steps = array(d.steps);
+    const trace = array(workflow.trace);
+    const rows = [];
+    function add(rawRow, id, parentId) {
+        const r = record(rawRow);
+        const activity = record(r.activity);
+        const node = {
+            id: text(id) ?? String(rows.length), label: text(r.label ?? r.sessionName ?? r.agent ?? r.childId ?? r.key) ?? id,
+            kind: text(r.kind) ?? "agent", state: state(r.state ?? r.status),
+        };
+        if (parentId)
+            node.parentId = parentId;
+        for (const [key, value] of Object.entries({ phase: r.phase, agent: r.agent, model: r.model, runId: r.runId,
+            task: r.task ?? r.description ?? r.prompt, currentTool: activity.currentTool ?? r.currentTool,
+            error: r.error, output: r.resultPreview ?? r.recentOutput })) {
+            const valueText = text(value, ["task", "error", "output"].includes(key) ? 2000 : 256);
+            if (valueText)
+                node[key] = valueText;
+        }
+        for (const key of ["durationMs", "tokens", "toolCount"]) {
+            const value = number(activity[key] ?? r[key]);
+            if (value !== undefined)
+                node[key] = value;
+        }
+        rows.push(node);
+    }
+    function graphNodes(nodes, parentId, depth = 0) {
+        if (depth > 8)
+            return;
+        for (const r of nodes.slice(0, 256)) {
+            const id = text(r?.id) ?? `node-${rows.length}`;
+            add(r, id, parentId);
+            graphNodes(array(r?.children), id, depth + 1);
+        }
+    }
+    if (array(d.workflowGraph?.nodes).length)
+        graphNodes(d.workflowGraph.nodes);
+    else if (Array.isArray(children.children)) {
+        for (const child of children.children.slice(0, 256)) {
+            const step = steps.find(s => s.workflowKey === child.childId) ?? {};
+            const entry = [...trace].reverse().find(t => t.operation === "run" && t.key === child.childId) ?? {};
+            add({ ...entry, ...step, ...child }, String(child.childId));
+        }
+    }
+    else {
+        const sourceRows = Array.isArray(d.agents) ? d.agents : steps.length ? steps : array(d.progress).length ? d.progress : array(d.results);
+        sourceRows.slice(0, 256).forEach((r, i) => add({ ...r,
+            state: r.state ?? r.status ?? (r.detached ? "detached" : r.interrupted ? "paused" : typeof r.exitCode === "number" ? (r.exitCode === 0 ? "completed" : "failed") : undefined),
+        }, String(r.workflowKey ?? r.id ?? `step-${i}`)));
+    }
+    const totalNodes = Math.max(rows.length, array(children.children).length, steps.length, array(d.agents).length);
+    return {
+        version: 1, source, mode: text(d.mode) ?? "workflow", name: text(d.name),
+        runId: text(d.runId ?? children.workflowRunId ?? d.asyncId),
+        state: state(children.workflowState ?? d.state ?? (d.asyncId ? "background" : fallbackState)),
+        inventoryComplete: typeof children.inventoryComplete === "boolean" ? children.inventoryComplete : source === "tool-result" && !d.asyncId,
+        updatedAt: number(d.lastUpdate ?? d.updatedAt), nodes: rows.slice(0, MAX_NODES),
+        trace: trace.slice(-MAX_TRACE).map(t => ({ key: text(t.key) ?? "", operation: text(t.operation) ?? "", state: text(t.state) ?? "unknown",
+            phase: text(t.phase), durationMs: number(t.durationMs), error: text(t.error, 1000) })),
+        omittedNodes: Math.max(0, totalNodes - MAX_NODES), omittedTrace: Math.max(0, trace.length - MAX_TRACE),
+    };
+}
+/** Partial updates update the invocation, never create a final tool_result or imply delivery. */
+export function capturePiExecutionEvent(blocks, event) {
+    if (event.type !== "tool_execution_update" && event.type !== "tool_execution_end")
+        return;
+    const use = blocks.find((b) => b.type === "tool_use" && b.id === event.toolCallId);
+    if (!use || !isPiExecutionTool(use.name) || use.input.action)
+        return;
+    const result = record(event.type === "tool_execution_update" ? event.partialResult : event.result);
+    const details = record(result.details);
+    const source = event.type === "tool_execution_update" ? "tool-progress" : "tool-result";
+    const snapshot = projectPiExecution(details, source, event.isError ? "failed" : source === "tool-progress" ? "running" : "completed");
+    if (snapshot)
+        use.execution = snapshot;
+    const runId = text(details.asyncId);
+    const directory = text(details.asyncDir, 4096);
+    if (runId && UUID.test(runId) && directory && path.isAbsolute(directory) && path.basename(directory) === runId) {
+        use.piExecutionRef = { runId, directory };
+    }
+}
+function resultText(result) {
+    return typeof result?.content === "string" ? result.content : array(result?.content).map(p => text(p?.text, 8000) ?? "").join("\n");
+}
+function legacyReceiptRunId(result) {
+    if (result?.is_error)
+        return;
+    const lines = resultText(result).trim().split("\n");
+    if (!/^Run fan-out:\s*\d+\/\d+ used\b/.test(lines[0] ?? ""))
+        return;
+    for (const line of lines.slice(1, 25)) {
+        if (!/^Async(?: workflow\b|:)/.test(line.trim()))
+            continue;
+        const id = [...line.matchAll(/\[([0-9a-f-]{36,64})\]/gi)].at(-1)?.[1];
+        if (id && UUID.test(id))
+            return id;
+    }
+}
+async function readStatus(directory, runId, toolId) {
+    // References come from this session's extension result, never an HTTP path parameter.
+    const handle = await open(path.join(directory, "status.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 2 * 1024 * 1024)
+            throw new Error("执行状态超出读取上限");
+        const raw = JSON.parse(await handle.readFile("utf8"));
+        if ((raw.runId ?? raw.id) !== runId || (raw.toolCallId && raw.toolCallId !== toolId))
+            throw new Error("执行身份不匹配");
+        return raw;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Inspect only a run referenced by this session. Old receipts use the package's fixed temp roots. */
+export async function inspectPiExecution(messages, toolId) {
+    let use;
+    let result;
+    let dispatchTurn;
+    for (const turn of messages)
+        for (const b of turn.content) {
+            if (b.type === "tool_use" && b.id === toolId) {
+                use = b;
+                dispatchTurn = turn;
+            }
+            if (b.type === "tool_result" && b.tool_use_id === toolId)
+                result = b;
+        }
+    if (!use || !isPiExecutionTool(use.name) || use.input.action)
+        return null;
+    let snapshot = use.execution ?? null;
+    let notice;
+    const runId = use.piExecutionRef?.runId ?? legacyReceiptRunId(result);
+    if (runId) {
+        let directories = use.piExecutionRef ? [use.piExecutionRef.directory] : [];
+        if (!directories.length) {
+            const entries = await readdir(os.tmpdir(), { withFileTypes: true }).catch(() => []);
+            directories = entries.filter(e => e.isDirectory() && /^pi-subagents-[\w-]+$/.test(e.name)).slice(0, 64)
+                .map(e => path.join(os.tmpdir(), e.name, "async-subagent-runs", runId));
+        }
+        let found = false;
+        for (const directory of directories) {
+            try {
+                const raw = await readStatus(directory, runId, toolId);
+                snapshot = projectPiExecution(raw, "status-file", "unknown");
+                found = !!snapshot;
+                if (found)
+                    break;
+            }
+            catch { /* Retention, old versions and temporary writes leave the captured snapshot available. */ }
+        }
+        if (!found)
+            notice = "后台状态文件不可读取或已清理；以下保留最后一次工具快照，不代表当前运行状态。";
+    }
+    if (!snapshot)
+        notice = "这次调用没有可读取的结构数据；保留派发参数，无法确认子任务或完成状态。";
+    const inlineScript = typeof use.input.script === "string" ? use.input.script : undefined;
+    const replyScript = use.input.workflow === true || use.input.workflow === "true"
+        ? dispatchTurn?.content.filter(b => b.type === "text").map(b => b.text).join("\n").match(/```(?:js|javascript) workflow\s*\n([\s\S]*?)\n```/)?.[1] : undefined;
+    return { toolId, toolName: use.name, input: use.input, script: (inlineScript ?? replyScript)?.slice(0, 64_000), snapshot, notice };
+}

package/dist/pi-extension-resources.d.ts

@@ -0,0 +1,13 @@
+import { loadPiCodingAgent } from "./harness-engine.js";
+import type { WandConfig } from "./types.js";
+import type { PiSessionSettings } from "./pi-session-settings.js";
+import type { ResourceLoader } from "@earendil-works/pi-coding-agent";
+type CodingAgent = Awaited<ReturnType<typeof loadPiCodingAgent>>;
+/** Resolve already-installed USER resources only. Never install, import code, or trust project packages. */
+export declare function installedPiExtensions(config: WandConfig, cwd: string): Promise<Array<{
+    path: string;
+    name: string;
+    goal: boolean;
+}>>;
+export declare function createPiExtensionResources(pi: CodingAgent, config: WandConfig, cwd: string, settings: PiSessionSettings, systemPrompt: string): Promise<ResourceLoader>;
+export {};

package/dist/pi-extension-resources.js

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { coreHarnessAgentDir, loadPiCodingAgent } from "./harness-engine.js";
+/** Resolve already-installed USER resources only. Never install, import code, or trust project packages. */
+export async function installedPiExtensions(config, cwd) {
+    const pi = await loadPiCodingAgent();
+    const agentDir = coreHarnessAgentDir(config.harness);
+    let raw = {};
+    try {
+        raw = JSON.parse(await readFile(path.join(agentDir, "settings.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const settings = pi.SettingsManager.inMemory({
+        packages: Array.isArray(raw.packages) ? raw.packages : [],
+        extensions: Array.isArray(raw.extensions) ? raw.extensions.filter((item) => typeof item === "string") : [],
+    }, { projectTrusted: false });
+    const manager = new pi.DefaultPackageManager({ cwd, agentDir, settingsManager: settings });
+    const resolved = await manager.resolve(async () => "skip");
+    return resolved.extensions.filter((item) => item.enabled && item.metadata.scope === "user").map((item) => {
+        const name = item.metadata.source === "local" || item.metadata.source === "auto"
+            ? path.basename(item.path) : item.metadata.source.replace(/^npm:/, "");
+        return { path: item.path, name, goal: /(?:^|[/:])pi-goal(?:[/@]|$)/.test(`${item.metadata.source}/${item.path}`) };
+    });
+}
+/**
+ * The pinned SDK's public ResourceLoader caches imported factories by cwd. Many user extensions
+ * (including pi-goal) keep module-level state; sharing those factories leaks across Wand sessions.
+ * Use its uncached file loader, at this one version-locked boundary, with explicit installed paths.
+ */
+async function nativeExtensionLoader() {
+    const url = new URL("./core/extensions/loader.js", import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const loaded = await import(url.href);
+    if (typeof loaded.loadExtensions !== "function" || typeof loaded.loadExtensionFromFactory !== "function") {
+        throw new Error("当前 Pi SDK 不支持隔离扩展加载；请检查锁定的 SDK 版本。");
+    }
+    return loaded;
+}
+export async function createPiExtensionResources(pi, config, cwd, settings, systemPrompt) {
+    const resources = settings.globalTools || settings.goalMode ? await installedPiExtensions(config, cwd) : [];
+    if (settings.goalMode && !resources.some((item) => item.goal)) {
+        throw new Error("目标模式不可用：请先在 Pi 中安装并启用 pi-goal。");
+    }
+    const paths = resources.filter((item) => item.goal ? settings.goalMode : settings.globalTools).map((item) => item.path);
+    const loader = await nativeExtensionLoader();
+    const runtime = pi.createExtensionRuntime();
+    const events = pi.createEventBus();
+    const result = await loader.loadExtensions(paths, cwd, events, runtime);
+    if (result.errors.length)
+        throw new Error(`Pi 扩展加载失败：${result.errors.map((item) => `${path.basename(item.path)}: ${item.error}`).join("；")}`);
+    if (settings.codemode !== "off") {
+        result.extensions.push(await loader.loadExtensionFromFactory(
+        // Only orchestration of enabled tools. No implicit classifier/image API access.
+        pi.createCodemodeExtension({ mode: settings.codemode, models: false }), cwd, events, runtime, "wand:codemode"));
+    }
+    return {
+        getExtensions: () => result,
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => systemPrompt,
+        getSystemPromptSource: () => undefined,
+        getAppendSystemPrompt: () => [],
+        getAppendSystemPromptSources: () => [],
+        extendResources: () => { },
+        reload: async () => { throw new Error("原生 Pi 扩展按回合加载；请在下一轮重载。"); },
+    };
+}

package/dist/pi-openrouter-free-bridge.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function wandOpenRouterFree(pi: ExtensionAPI): void;