@co0ontty/wand 4.105.1 → 4.106.0

package/dist/path-repair.js

@@ -303,6 +303,9 @@ function probeLoginShell(shell, timeoutMs) {
         `printf '\\n${ENV_BEGIN_MARKER}\\n'; command env; printf '${ENV_END_MARKER}\\n'`;
     return new Promise((resolve, reject) => {
         const child = spawn(shell, ["-lic", script], {
+            // Own a separate probe group: shell rc can spawn children which inherit
+            // our pipes, and an interactive shell may ignore SIGTERM.
+            detached: process.platform !== "win32",
             env: {
                 ...process.env,
                 // 防止 PROMPT_COMMAND / PS1 等钩子往 stdout 喷东西干扰解析
@@ -314,6 +317,25 @@ function probeLoginShell(shell, timeoutMs) {
         let stdout = "";
         let stderr = "";
         let settled = false;
+        let killTimer;
+        const terminateProbe = (signal) => {
+            if (process.platform !== "win32" && child.pid) {
+                try {
+                    process.kill(-child.pid, signal);
+                    return;
+                }
+                catch { /* group already gone, or spawn failed */ }
+            }
+            try {
+                child.kill(signal);
+            }
+            catch { /* probe already exited */ }
+        };
+        const clearTimers = () => {
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+        };
         const finalize = (fn) => {
             if (settled)
                 return;
@@ -321,20 +343,20 @@ function probeLoginShell(shell, timeoutMs) {
             fn();
         };
         const timer = setTimeout(() => {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch { /* noop */ }
+            terminateProbe("SIGTERM");
+            // Kill only this detached probe group, never a provider PTY/daemon or
+            // another session. Descendants can keep stdout open after the shell exits.
+            killTimer = setTimeout(() => terminateProbe("SIGKILL"), 250);
             finalize(() => reject(new Error(`login shell probe timed out after ${timeoutMs}ms`)));
         }, timeoutMs);
         child.stdout?.on("data", (b) => { stdout += b.toString(); });
         child.stderr?.on("data", (b) => { stderr += b.toString(); });
         child.on("error", (err) => {
-            clearTimeout(timer);
+            clearTimers();
             finalize(() => reject(err));
         });
         child.on("close", (code) => {
-            clearTimeout(timer);
+            clearTimers();
             finalize(() => {
                 if (!stdout && code !== 0) {
                     reject(new Error(`login shell exited ${code}: ${stderr.trim().slice(0, 200)}`));

package/dist/pi-resource-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { PiResourceCatalog, PiResourceSelection } from "./pi-session-settings.js";
+import { type PiResourceCatalog, type PiResourceSelection, type PiSessionSettings, type PiSessionSettingsPatch } from "./pi-session-settings.js";
 import type { WandConfig } from "./types.js";
 import type { Skill, McpExtensionOptions } from "@earendil-works/pi-coding-agent";
 type McpConfig = ReturnType<NonNullable<McpExtensionOptions["loadConfig"]>>;
@@ -15,4 +15,6 @@ export declare function resolvePiResourceSelection(inventory: PiResourceInventor
     skills: Skill[];
     servers: McpConfig["servers"];
 };
+/** Validate additions; an explicit unlock also releases that skill's unavailable selected reference. */
+export declare function resolvePiResourceSettingsPatch(inventory: PiResourceInventory, current: PiSessionSettings, patch: PiSessionSettingsPatch): PiSessionSettingsPatch;
 export {};

package/dist/pi-resource-catalog.js

@@ -3,6 +3,7 @@ import { realpath, stat } from "node:fs/promises";
 import { coreHarnessAgentDir } from "./harness-engine.js";
 import { importPiCliModule, resolvePiCliPackage } from "./pi-cli-runtime.js";
 import { cliPiResourceReader, installedPiUserResources } from "./pi-user-resources.js";
+import { patchPiSessionSettings } from "./pi-session-settings.js";
 function resourceId(kind, identity) {
     return `${kind}-${createHash("sha256").update(identity).digest("hex").slice(0, 24)}`;
 }
@@ -65,3 +66,27 @@ export function resolvePiResourceSelection(inventory, selection) {
     });
     return { skills, servers };
 }
+/** Validate additions; an explicit unlock also releases that skill's unavailable selected reference. */
+export function resolvePiResourceSettingsPatch(inventory, current, patch) {
+    const next = patchPiSessionSettings(current, patch);
+    let resolved = patch;
+    if (patch.lockedSkills !== undefined && next.resources) {
+        const released = new Set((current.lockedSkills ?? []).filter((id) => !next.lockedSkills.includes(id) && !inventory.skills.has(id)));
+        if (next.resources.skills.some((id) => released.has(id))) {
+            resolved = { ...patch, resources: { ...next.resources,
+                    skills: next.resources.skills.filter((id) => !released.has(id)) } };
+        }
+    }
+    // Keep other stale references until explicitly removed, so several unavailable items can be
+    // repaired one at a time. Execution still validates the complete selection and fails closed.
+    if (resolved.resources !== undefined)
+        resolvePiResourceSelection(inventory, {
+            skills: resolved.resources.skills.filter((id) => !current.resources?.skills.includes(id)),
+            mcpServers: resolved.resources.mcpServers.filter((id) => !current.resources?.mcpServers.includes(id)),
+        });
+    if (resolved.lockedSkills !== undefined)
+        resolvePiResourceSelection(inventory, {
+            skills: resolved.lockedSkills.filter((id) => !current.lockedSkills?.includes(id)), mcpServers: [],
+        });
+    return resolved;
+}

package/dist/pi-session-settings.d.ts

@@ -33,6 +33,8 @@ export type PiSkillMode = "off" | "on" | "locked";
 export declare function piSkillMode(settings: PiSessionSettings, id: string): PiSkillMode;
 /** A single manual gesture changes selection and lock atomically, never mutating its snapshot. */
 export declare function piSkillModePatch(settings: PiSessionSettings, id: string, mode: PiSkillMode): PiSessionSettingsPatch;
+/** The server may also deselect a newly unlocked Skill if it disappeared since the panel loaded. */
+export declare function piResourceSettingsConfirmed(current: PiSessionSettings, patch: PiSessionSettingsPatch, confirmed: PiSessionSettings | undefined): boolean;
 export interface PiResourceSelectionNotice {
     status: "selecting" | "selected" | "fallback" | "cancelled";
     label: string;

package/dist/pi-session-settings.js

@@ -18,6 +18,31 @@ export function piSkillModePatch(settings, id, mode) {
         lockedSkills: mode === "locked" ? [...new Set([...locks, id])] : locks.filter((value) => value !== id),
     };
 }
+/** The server may also deselect a newly unlocked Skill if it disappeared since the panel loaded. */
+export function piResourceSettingsConfirmed(current, patch, confirmed) {
+    if (!confirmed)
+        return false;
+    if (patch.lockedSkills !== undefined
+        && JSON.stringify(confirmed.lockedSkills) !== JSON.stringify(patch.lockedSkills))
+        return false;
+    if (patch.resources === undefined && patch.lockedSkills === undefined)
+        return true;
+    const expected = patch.resources ?? current.resources;
+    if (!confirmed.resources)
+        return !expected && !patch.lockedSkills?.length;
+    let resources;
+    try {
+        resources = patchPiResourceSelection(confirmed.resources);
+    }
+    catch {
+        return false;
+    }
+    const unlocked = new Set(patch.lockedSkills === undefined ? []
+        : (current.lockedSkills ?? []).filter((id) => !patch.lockedSkills.includes(id)));
+    const skills = (expected?.skills ?? []).filter((id) => !unlocked.has(id) || resources.skills.includes(id));
+    return JSON.stringify(resources.skills) === JSON.stringify(skills)
+        && JSON.stringify(resources.mcpServers) === JSON.stringify(expected?.mcpServers ?? []);
+}
 export function patchPiResourceSelection(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         throw new Error("请选择有效的 Skills / MCP 列表。");

package/dist/process-manager.d.ts

@@ -302,6 +302,8 @@ export declare class ProcessManager extends EventEmitter {
     private snapshotSlim;
     private isPermissionBlocked;
     setSessionWorkspace(id: string, membership: Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId">): void;
+    /** The source is committed by storage before the live checkpoint projection is refreshed. */
+    setSessionSource(id: string, sessionSource: SessionSource): void;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
     private setSessionTopicGenerating;
     /**

package/dist/process-manager.js

@@ -1,3 +1,4 @@
+import { knowledgeInstructions } from "./employee-knowledge.js";
 import { isOpenRouterFreeSelector } from "./openrouter-free-models.js";
 import { isAutoAssignSelector, defaultModelGroupSelector, resolveModelGroupModels } from "./model-groups.js";
 import { resolveAutoAssign } from "./model-auto-assign.js";
@@ -563,6 +564,7 @@ export class ProcessManager extends EventEmitter {
         // PTY emits its asynchronous exit event. Ignore that stale incarnation.
         if (current !== record || current.ptyProcess !== child)
             return;
+        this.storage.revokeSessionKnowledgeAccess(record.id);
         current.timers.clearAll();
         if (current.ptyBridge) {
             current.ptyBridge.onExit(exitCode);
@@ -844,10 +846,7 @@ export class ProcessManager extends EventEmitter {
         let processedCommand = this.processCommandForMode(command, effectiveMode, provider, preferredModels[0], initialThinkingEffort);
         // 会话级系统提示：provider 有系统提示开关就走开关（PTY 与结构化行为一致），没有就并进首条输入。
         const systemPrompt = (opts?.systemPrompt ?? inheritedRole?.systemPrompt)?.trim() || undefined;
-        const initialInputText = initialInput && systemPrompt && !systemPromptFlag(provider)
-            ? composeSystemFallback(systemPrompt, initialInput)
-            : initialInput;
-        processedCommand = commandWithSystemPrompt(processedCommand, provider, systemPrompt);
+        let initialInputText = initialInput;
         const isCodexProvider = provider === "codex";
         const isOpenCodeProvider = provider === "opencode";
         const existingProviderSessionId = provider
@@ -873,12 +872,6 @@ export class ProcessManager extends EventEmitter {
             : null;
         const initialClaudeSessionId = existingProviderSessionId ?? assignedProviderSessionId;
         const startedAt = new Date().toISOString();
-        const launchPlan = buildPtyShellLaunchPlan({
-            shell: this.config.shell,
-            command: processedCommand,
-            bareShell: opts?.interactiveShell === true,
-            providerCommand: provider !== undefined,
-        });
         const record = {
             id,
             sessionSource: opts?.sessionSource ?? inheritedSessionSource ?? "interactive",
@@ -912,7 +905,7 @@ export class ProcessManager extends EventEmitter {
             processId: null,
             ptyProcess: null,
             terminalState: new PtyTerminalState(opts?.cols !== undefined ? clampDimension(opts.cols, 20, 1000) : 120, opts?.rows !== undefined ? clampDimension(opts.rows, 5, 500) : 36),
-            providerShellMarker: launchPlan.cliExitMarker,
+            providerShellMarker: null,
             providerCliActive: provider !== undefined,
             providerCliExitCode: null,
             stopRequested: false,
@@ -939,7 +932,7 @@ export class ProcessManager extends EventEmitter {
             ptyCols: opts?.cols !== undefined ? clampDimension(opts.cols, 20, 1000) : 120,
             ptyRows: opts?.rows !== undefined ? clampDimension(opts.rows, 5, 500) : 36,
             ptyOutputSeq: 0,
-            ptyLaunchMarkerToken: launchPlan.cliExitMarker?.token ?? null,
+            ptyLaunchMarkerToken: null,
         };
         this.sessions.set(id, record);
         this.persist(record, { forceFullSave: true });
@@ -947,13 +940,31 @@ export class ProcessManager extends EventEmitter {
             this.providerHistory.invalidate(provider);
         }
         let child;
+        let launchPlan;
         try {
+            // Derive authority only after the real session/project binding has been persisted.
+            const access = provider ? this.storage.knowledgeSessionScope(id) : null;
+            const knowledgeToken = access ? this.storage.issueKnowledgeAccess(id) : undefined;
+            const runtimePrompt = access ? [knowledgeInstructions(access),
+                "本终端会话的知识工具只在有效执行期内可用；每次使用知识先 search/read，不把旧轮次快照当作当前状态。访问失效时新开一轮结构化执行或恢复会话，不绕过权限。"].join("\n\n") : undefined;
+            const launchPrompt = [systemPrompt, runtimePrompt].filter(Boolean).join("\n\n") || undefined;
+            initialInputText = initialInput && launchPrompt && !systemPromptFlag(provider)
+                ? composeSystemFallback(launchPrompt, initialInput) : initialInput;
+            processedCommand = commandWithSystemPrompt(processedCommand, provider, launchPrompt);
+            launchPlan = buildPtyShellLaunchPlan({ shell: this.config.shell, command: processedCommand,
+                bareShell: opts?.interactiveShell === true, providerCommand: provider !== undefined });
+            record.providerShellMarker = launchPlan.cliExitMarker;
+            record.ptyLaunchMarkerToken = launchPlan.cliExitMarker?.token ?? null;
+            this.persist(record, { forceFullSave: true });
             const attached = await this.terminalHost.createOrAttach({
                 sessionId: id,
                 file: this.config.shell,
                 args: launchPlan.shellArgs,
                 cwd: resolvedCwd,
                 env: buildChildEnv(this.config.inheritEnv !== false, {
+                    WAND_SESSION_ID: id,
+                    WAND_KNOWLEDGE_DB: knowledgeToken ? this.storage.databasePath() : undefined,
+                    WAND_KNOWLEDGE_TOKEN: knowledgeToken,
                     WAND_MODE: effectiveMode,
                     WAND_AUTO_CONFIRM: record.autoApprovePermissions ? "1" : "0",
                     WAND_AUTO_EDIT: effectiveMode === "auto-edit" ? "1" : "0",
@@ -1503,6 +1514,7 @@ export class ProcessManager extends EventEmitter {
     finishProviderCli(record, exitCode) {
         if (!record.providerCliActive)
             return;
+        this.storage.revokeSessionKnowledgeAccess(record.id);
         record.providerCliActive = false;
         record.providerCliExitCode = exitCode;
         record.providerShellMarker = null;
@@ -1539,6 +1551,7 @@ export class ProcessManager extends EventEmitter {
         if (this.unknownTerminalOwners.has(id))
             throw new Error("Terminal ownership is unknown; stop was not delivered. Retry after recovery.");
         const record = this.mustGet(id);
+        this.storage.revokeSessionKnowledgeAccess(id);
         const start = this.startingSessions.get(id);
         if (start)
             start.cancelled = true;
@@ -1591,6 +1604,8 @@ export class ProcessManager extends EventEmitter {
         return this.snapshot(record);
     }
     cleanupRecord(record, terminateTerminal = true) {
+        if (terminateTerminal && record.status === "running")
+            this.storage.revokeSessionKnowledgeAccess(record.id);
         this.clearPtyTurn(record);
         record.timers.clearAll();
         const pendingPersist = this.persistDebounceTimers.get(record.id);
@@ -1843,6 +1858,14 @@ export class ProcessManager extends EventEmitter {
         Object.assign(this.mustGet(id), membership);
         this.emitEvent({ type: "status", sessionId: id, data: membership });
     }
+    /** The source is committed by storage before the live checkpoint projection is refreshed. */
+    setSessionSource(id, sessionSource) {
+        const record = this.mustGet(id);
+        if (record.sessionSource === sessionSource)
+            return;
+        record.sessionSource = sessionSource;
+        this.emitEvent({ type: "status", sessionId: id, data: { sessionSource } });
+    }
     setSessionTopic(id, title, description) {
         const record = this.mustGet(id);
         record.title = title;

package/dist/quick-terminal-session.d.ts

@@ -0,0 +1,3 @@
+import type { SessionSnapshot } from "./types.js";
+/** A quick-terminal claim never takes ownership of an Agent or automation session. */
+export declare function canClaimQuickTerminal(session: SessionSnapshot): boolean;

package/dist/quick-terminal-session.js

@@ -0,0 +1,5 @@
+/** A quick-terminal claim never takes ownership of an Agent or automation session. */
+export function canClaimQuickTerminal(session) {
+    return (session.sessionKind ?? "pty") === "pty" && !session.provider && !session.automationId
+        && (!session.sessionSource || session.sessionSource === "interactive" || session.sessionSource === "quick-terminal");
+}

package/dist/retention-protection.d.ts

@@ -0,0 +1,15 @@
+import type { WandStorage } from "./storage.js";
+import type { WandTask } from "./task-types.js";
+import type { SessionSnapshot } from "./types.js";
+/** Read all ownership/execution facts before the first destructive action. Never loads transcripts or settings. */
+export declare function createRetentionProtection(storage: WandStorage, sessions: readonly SessionSnapshot[], archivedMs: number | null, now: number): {
+    tasks: WandTask[];
+    runs: import("./ai-team-types.js").AiTeamRun[];
+    teamSessionIds: Map<string, string[]>;
+    canArchiveTask: (task: WandTask) => boolean;
+    canPurgeTask: (id: string) => boolean;
+    canArchiveSession: (id: string) => boolean;
+    canPurgeSession: (id: string) => boolean;
+    canArchiveRun: (id: string) => boolean;
+    canPurgeRun: (id: string) => boolean;
+};

package/dist/retention-protection.js

@@ -0,0 +1,134 @@
+import { AI_TEAM_ACTIVE_RUN_STATUSES } from "./ai-team-types.js";
+import { isArchiveBlocked } from "./archive-policy.js";
+import { TASK_RETENTION_ARCHIVE_VERSION } from "./task-retention.js";
+import { parseTimestampMs } from "./time-utils.js";
+function acceptedTask(task) {
+    const acceptance = task.acceptance;
+    return (task.status === "done" || task.status === "archived")
+        && typeof acceptance?.acceptedAt === "string" && parseTimestampMs(acceptance.acceptedAt) !== null
+        && typeof acceptance.evidence === "string" && !!acceptance.evidence.trim()
+        && typeof acceptance.blocker === "string" && !acceptance.blocker.trim();
+}
+/** Iterative, order-independent propagation; shared histories and legacy cycles cannot evade a hold. */
+function spread(graph, seeds) {
+    const held = new Set(seeds), pending = [...held];
+    for (let index = 0; index < pending.length; index += 1) {
+        for (const next of graph.get(pending[index]) ?? []) {
+            if (held.has(next))
+                continue;
+            held.add(next);
+            pending.push(next);
+        }
+    }
+    return held;
+}
+/** Read all ownership/execution facts before the first destructive action. Never loads transcripts or settings. */
+export function createRetentionProtection(storage, sessions, archivedMs, now) {
+    const tasks = storage.listWandTasks(), runs = storage.listAiTeamRuns();
+    const versions = storage.taskRetentionArchiveVersions();
+    const byId = new Map(tasks.map(task => [task.id, task]));
+    const byContainer = new Map(tasks.flatMap(task => task.workspaceTaskId ? [[task.workspaceTaskId, task]] : []));
+    const graph = new Map(), ancestors = new Map();
+    const taskNode = (id) => `task:${id}`;
+    const sessionNode = (id) => `session:${id}`;
+    const runNode = (id) => `run:${id}`;
+    const busy = new Set(), unfinished = new Set(), notPurgeReady = new Set();
+    const link = (left, right) => {
+        if (!graph.has(left))
+            graph.set(left, new Set());
+        if (!graph.has(right))
+            graph.set(right, new Set());
+        graph.get(left).add(right);
+        graph.get(right).add(left);
+    };
+    for (const task of tasks) {
+        const node = taskNode(task.id);
+        if (!acceptedTask(task))
+            unfinished.add(node);
+        const archivedAt = parseTimestampMs(task.archivedAt), acceptedAt = parseTimestampMs(task.acceptance?.acceptedAt);
+        if (!acceptedTask(task) || task.status !== "archived" || archivedAt === null || acceptedAt === null
+            || versions.get(task.id) !== TASK_RETENTION_ARCHIVE_VERSION || archivedMs === null
+            || now - Math.max(archivedAt, acceptedAt) < archivedMs)
+            notPurgeReady.add(node);
+        if (task.parentTaskId) {
+            link(node, taskNode(task.parentTaskId));
+            ancestors.set(node, new Set([taskNode(task.parentTaskId)]));
+            if (!byId.has(task.parentTaskId))
+                busy.add(node); // Unknown ancestry is not permission to detach history.
+        }
+        // Container-less archives can still have historical membership. Live membership comes from snapshots below.
+        if (!task.workspaceTaskId) {
+            for (const id of storage.listWandTaskSessionIds(task.id))
+                link(node, sessionNode(id));
+        }
+    }
+    const checked = new Set();
+    for (const task of tasks) {
+        const path = new Set();
+        let cursor = task.id;
+        while (cursor && !checked.has(cursor)) {
+            if (path.has(cursor)) {
+                busy.add(taskNode(cursor));
+                break;
+            }
+            path.add(cursor);
+            cursor = byId.get(cursor)?.parentTaskId ?? null;
+        }
+        for (const id of path)
+            checked.add(id);
+    }
+    for (const session of sessions) {
+        const node = sessionNode(session.id);
+        if (isArchiveBlocked(session))
+            busy.add(node);
+        if (session.workspaceTaskId) {
+            const owner = byContainer.get(session.workspaceTaskId);
+            if (owner)
+                link(node, taskNode(owner.id));
+            else
+                busy.add(node);
+        }
+    }
+    for (const fact of storage.taskCommentRetentionFacts()) {
+        const node = taskNode(fact.taskId);
+        if (fact.sessionId)
+            link(node, sessionNode(fact.sessionId));
+        if (fact.state !== "accepted" && fact.state !== "failed")
+            busy.add(node);
+    }
+    const teamSessionIds = new Map();
+    for (const run of runs) {
+        const node = runNode(run.id), ids = new Set();
+        if (run.chatSessionId)
+            ids.add(run.chatSessionId);
+        for (const step of storage.listAiTeamSteps(run.id))
+            if (step.sessionId)
+                ids.add(step.sessionId);
+        teamSessionIds.set(run.id, [...ids]);
+        for (const id of ids)
+            link(node, sessionNode(id));
+        if (run.taskId) {
+            const owner = byId.get(run.taskId) ?? byContainer.get(run.taskId);
+            // A dangling historical id has no surviving task context to detach; active status is handled above.
+            if (owner)
+                link(node, taskNode(owner.id));
+        }
+        if (AI_TEAM_ACTIVE_RUN_STATUSES.includes(run.status))
+            busy.add(node);
+    }
+    const executionHeld = spread(graph, busy);
+    const archiveHeld = spread(graph, [...busy, ...unfinished]);
+    // A task-bound history must outlive the latest acceptance/archive grace window in its whole family.
+    const purgeHeld = spread(graph, [...busy, ...notPurgeReady]);
+    const unfinishedAncestors = spread(ancestors, unfinished);
+    return {
+        tasks, runs, teamSessionIds,
+        canArchiveTask: (task) => task.status === "done" && acceptedTask(task)
+            && !executionHeld.has(taskNode(task.id)) && !unfinishedAncestors.has(taskNode(task.id)),
+        canPurgeTask: (id) => !purgeHeld.has(taskNode(id)),
+        canArchiveSession: (id) => !archiveHeld.has(sessionNode(id)),
+        canPurgeSession: (id) => !purgeHeld.has(sessionNode(id)),
+        canArchiveRun: (id) => !archiveHeld.has(runNode(id)),
+        canPurgeRun: (id) => !purgeHeld.has(runNode(id)),
+    };
+}

package/dist/retention.d.ts

@@ -5,8 +5,9 @@ import type { SessionSnapshot } from "./types.js";
 export declare const RETENTION_IDLE_MS: number;
 export declare const RETENTION_ARCHIVED_MS: number;
 /**
- * 看板任务、会话和已结束的团队运行共用 `taskRetention`。
- * 没配过时默认空闲 7 天归档，再过 7 天清理。
+ * 看板任务、会话和已结束的团队运行共用 `taskRetention` 的开关与天数。
+ * 只有已验收、无未完成上下文且无执行/审批/排队事实的任务才能自动归档；
+ * 关联会话与团队历史跟随保护。升级前的任务归档不自动删除。
  * 结构化会话看运行状态；PTY 只有正在回复或等待确认才跳过，空闲壳不算在处理。
  */
 export interface RetentionDeps {