@steerable/agent-shell 0.6.15

package/dist/preload.js

@@ -0,0 +1,411 @@
+import { contextBridge, ipcRenderer } from 'electron';
+// ---------------------------------------------------------------------------
+// Demo bypass: pre-seed the renderer's localStorage with a long-lived JWT so
+// the bundled web UI can talk to deeppath-api without going through the login
+// flow. This is intentionally limited to the agent shell and only activates
+// when AGENT_DEMO_TOKEN is set in the launch environment. Remove the env var
+// (or leave it unset) for a normal authenticated experience.
+// ---------------------------------------------------------------------------
+const DEMO_TOKEN_KEY = 'deeppath_access_token';
+const DEMO_USER_KEY = 'deeppath_user';
+const demoToken = process.env.AGENT_DEMO_TOKEN;
+const demoUserJson = process.env.AGENT_DEMO_USER;
+function seedDemoCredentials() {
+    if (!demoToken)
+        return;
+    try {
+        if (window.localStorage.getItem(DEMO_TOKEN_KEY) !== demoToken) {
+            window.localStorage.setItem(DEMO_TOKEN_KEY, demoToken);
+        }
+        if (demoUserJson && !window.localStorage.getItem(DEMO_USER_KEY)) {
+            window.localStorage.setItem(DEMO_USER_KEY, demoUserJson);
+        }
+        const expires = new Date(Date.now() + 30 * 864e5).toUTCString();
+        document.cookie = `${DEMO_TOKEN_KEY}=${encodeURIComponent(demoToken)}; expires=${expires}; path=/; SameSite=Lax`;
+    }
+    catch (err) {
+        console.error('[agent-shell] failed to seed demo token', err);
+    }
+}
+try {
+    seedDemoCredentials();
+}
+catch {
+    // window/document may not be ready yet; retry on DOMContentLoaded.
+}
+window.addEventListener('DOMContentLoaded', seedDemoCredentials);
+/**
+ * 构建并暴露 window.electron API（2.3 pack-preload 组合）。
+ *
+ * 包贡献经参数合并进顶层命名空间（如某包给出 `{ <pack>, <pack>Mock }`
+ * 这样的 invoke 型命名空间）；shell 本体不含任何
+ * 包符号。由产品 preload 入口（products/<id>/preload.ts）或 dev 入口
+ * （devtools/dev-preload.ts）调用。
+ */
+export function buildPreloadApi(packContributions = {}) {
+    const electronAPI = {
+        runtime: 'local',
+        platform: process.platform,
+        onThemeChanged: (callback) => {
+            ipcRenderer.on('theme-changed', (_event, isDark) => callback(isDark));
+        },
+        offThemeChanged: () => {
+            ipcRenderer.removeAllListeners('theme-changed');
+        },
+        retryConnection: () => {
+            ipcRenderer.send('retry-connection');
+        },
+        checkNetworkStatus: async () => {
+            return await ipcRenderer.invoke('check-network-status');
+        },
+        onNetworkStatusChanged: (callback) => {
+            ipcRenderer.on('network-status-changed', callback);
+        },
+        offNetworkStatusChanged: () => {
+            ipcRenderer.removeAllListeners('network-status-changed');
+        },
+        showNotification: (payload) => {
+            ipcRenderer.send('show-notification', payload);
+        },
+        onNotificationClicked: (callback) => {
+            ipcRenderer.on('notification-clicked', (_event, data) => callback(data));
+        },
+        offNotificationClicked: () => {
+            ipcRenderer.removeAllListeners('notification-clicked');
+        },
+        onMenuNewChat: (callback) => {
+            ipcRenderer.on('menu:new-chat', () => callback());
+        },
+        offMenuNewChat: () => {
+            ipcRenderer.removeAllListeners('menu:new-chat');
+        },
+        onMenuOpenTerminal: (callback) => {
+            ipcRenderer.on('menu:open-terminal', () => callback());
+        },
+        offMenuOpenTerminal: () => {
+            ipcRenderer.removeAllListeners('menu:open-terminal');
+        },
+        /**
+         * AI 标题异步就绪。Backend 在每条 chat 的首条助手回复完成后 fire-and-forget
+         * 跑 LLM 生成标题；完成后通过这个通道把 `{chatId, title}` 广播到所有 renderer。
+         *
+         * 返回 unsubscribe 函数——和 onMenuNewChat 不一样，这个通道有可能多处订阅
+         * （主窗 + 未来的设置窗），所以用 add/remove 配对而不是 removeAllListeners。
+         */
+        onChatTitleUpdated: (callback) => {
+            const handler = (_event, payload) => {
+                if (typeof payload?.chatId === 'string' && typeof payload?.title === 'string') {
+                    callback({ chatId: payload.chatId, title: payload.title });
+                }
+            };
+            ipcRenderer.on('chat-title-updated', handler);
+            return () => {
+                ipcRenderer.removeListener('chat-title-updated', handler);
+            };
+        },
+        /**
+         * 会话补建通知：Backend 在向本地不存在的 chatId 首次发送时按 URL 里的 id
+         * 现场补建会话，并广播 `chat-created`（{chatId, agentId}）。返回 unsubscribe
+         * （多处订阅用 add/remove 配对）。
+         */
+        onChatCreated: (callback) => {
+            const handler = (_event, payload) => {
+                if (typeof payload?.chatId === 'string' && payload.chatId) {
+                    callback({
+                        chatId: payload.chatId,
+                        agentId: typeof payload.agentId === 'string' ? payload.agentId : null,
+                    });
+                }
+            };
+            ipcRenderer.on('chat-created', handler);
+            return () => {
+                ipcRenderer.removeListener('chat-created', handler);
+            };
+        },
+        /**
+         * 场景包广播事件订阅（3.1 通用化）：按通道名订阅主进程广播，载荷
+         * 原样透传（收窄校验在订阅方——包——一侧）。通道名约定带包前缀
+         * （如 `<pack>:updated`）。返回解除订阅函数。
+         */
+        onPackEvent: (channel, callback) => {
+            const handler = (_event, payload) => {
+                callback(payload);
+            };
+            ipcRenderer.on(channel, handler);
+            return () => {
+                ipcRenderer.removeListener(channel, handler);
+            };
+        },
+        /**
+         * 4.6a 后台任务状态推送：任务到达终态（completed/failed）或 worktree
+         * 合并/丢弃完成时，主进程广播 `task-updated`。载荷只带 chatId/taskId/
+         * status——renderer 收到后重新拉任务列表（GET /chats/:id/tasks），
+         * 不把整条任务记录塞进 IPC（避免与 SQLite 双写漂移）。
+         */
+        onTaskUpdated: (callback) => {
+            const handler = (_event, payload) => {
+                if (typeof payload?.chatId === 'string' &&
+                    typeof payload?.taskId === 'string' &&
+                    typeof payload?.status === 'string') {
+                    callback({ chatId: payload.chatId, taskId: payload.taskId, status: payload.status });
+                }
+            };
+            ipcRenderer.on('task-updated', handler);
+            return () => {
+                ipcRenderer.removeListener('task-updated', handler);
+            };
+        },
+        onTaskProcess: (callback) => {
+            const handler = (_event, payload) => {
+                if (typeof payload?.chatId !== 'string' || typeof payload?.taskId !== 'string')
+                    return;
+                callback({
+                    chatId: payload.chatId,
+                    taskId: payload.taskId,
+                    timeline: payload.timeline,
+                    live: payload.live === true,
+                });
+            };
+            ipcRenderer.on('task-process', handler);
+            return () => {
+                ipcRenderer.removeListener('task-process', handler);
+            };
+        },
+        /**
+         * W4-1 审批代数：sidecar 的 ApprovalExecutor 经反向通道请示，主进程把
+         * 请求广播到 renderer（approval:request），审批弹窗应答后走
+         * approval:decide 回到主进程。订阅返回 unsubscribe；同一时刻只有一个
+         * 弹窗监听者（AgentPage 挂载的 ApprovalModalHost）。
+         */
+        approval: {
+            onRequest: (callback) => {
+                const handler = (_event, payload) => {
+                    const p = payload;
+                    if (typeof p?.requestId === 'string' && typeof p?.toolName === 'string') {
+                        callback(payload);
+                    }
+                };
+                ipcRenderer.on('approval:request', handler);
+                return () => {
+                    ipcRenderer.removeListener('approval:request', handler);
+                };
+            },
+            decide: async (decision) => {
+                await ipcRenderer.invoke('approval:decide', decision);
+            },
+        },
+        /**
+         * W8 结构化提问：sidecar 的 ask_user 工具经反向通道请示，主进程把
+         * 请求广播到 renderer（ask-user:request），问题卡片应答后走
+         * ask-user:answer 回到主进程。订阅返回 unsubscribe；同一时刻只有一个
+         * 卡片监听者（AgentLayout 挂载的 AskUserModalHost）。
+         */
+        askUser: {
+            onRequest: (callback) => {
+                const handler = (_event, payload) => {
+                    const p = payload;
+                    if (typeof p?.requestId === 'string' && Array.isArray(p?.questions)) {
+                        callback(payload);
+                    }
+                };
+                ipcRenderer.on('ask-user:request', handler);
+                return () => {
+                    ipcRenderer.removeListener('ask-user:request', handler);
+                };
+            },
+            answer: async (reply) => {
+                await ipcRenderer.invoke('ask-user:answer', reply);
+            },
+        },
+        local: {
+            selectDirectory: async (options) => {
+                return await ipcRenderer.invoke('local:select-directory', options);
+            },
+            saveTextFile: async (options) => {
+                return await ipcRenderer.invoke('local:save-text-file', options);
+            },
+            captureScreenshot: async (rect) => {
+                return await ipcRenderer.invoke('local:capture-screenshot', rect ? { rect } : {});
+            },
+            execShell: async (request) => {
+                return await ipcRenderer.invoke('local:exec-shell', request);
+            },
+            readFile: async (request) => {
+                return await ipcRenderer.invoke('local:read-file', request);
+            },
+            writeFile: async (request) => {
+                return await ipcRenderer.invoke('local:write-file', request);
+            },
+            openPath: async (request) => {
+                return await ipcRenderer.invoke('local:open-path', request);
+            },
+            listScripts: async () => {
+                return await ipcRenderer.invoke('local:list-scripts');
+            },
+            addScript: async (input) => {
+                return await ipcRenderer.invoke('local:add-script', input);
+            },
+            updateScript: async (id, updates) => {
+                return await ipcRenderer.invoke('local:update-script', { id, updates });
+            },
+            deleteScript: async (id) => {
+                return await ipcRenderer.invoke('local:delete-script', id);
+            },
+            runScript: async (id) => {
+                return await ipcRenderer.invoke('local:run-script', id);
+            },
+            getPlatformInfo: () => ({ platform: process.platform }),
+            updateSafetyConfig: async (config) => {
+                return await ipcRenderer.invoke('local:update-safety-config', config);
+            },
+        },
+        /** 会话附件：把源文件路径 / base64 字节拷贝进会话空间（`attachments:save`）。 */
+        attachments: {
+            save: async (input) => {
+                return await ipcRenderer.invoke('attachments:save', input);
+            },
+        },
+        localBackend: {
+            request: async (input) => {
+                const result = await ipcRenderer.invoke('local-backend:request', input);
+                if (!result.ok) {
+                    const err = new Error(result.error || 'Local backend request failed');
+                    err.status = result.status;
+                    throw err;
+                }
+                return result.data;
+            },
+            /**
+             * 启动一条本地后端流。
+             * 注意：Electron contextBridge 不支持把 ReadableStream 跨上下文传给 renderer
+             * （structured clone 会把它剥成空对象，导致 web UI 拿到的 Response.body 永远不出数据）。
+             * 这里只暴露 `startStream(input, onEvent)` 原语，由 web UI 端在 renderer 上下文
+             * 内自己构造 ReadableStream 并喂入 onEvent 回调（callback 跨上下文是 proxied 的）。
+             *
+             * 返回 streamId 用于后续 cancelStream(id)。
+             */
+            startStream: async (input, onEvent) => {
+                const result = (await ipcRenderer.invoke('local-backend:stream', input));
+                if (!result.ok || !result.streamId) {
+                    try {
+                        onEvent({ type: 'error', error: result.error || `start stream failed (${result.status ?? 500})` });
+                    }
+                    catch {
+                        // best-effort: callback 抛错不应影响 IPC 路径
+                    }
+                    return null;
+                }
+                const channel = `local-backend:stream:${result.streamId}`;
+                const handler = (_event, payload) => {
+                    try {
+                        onEvent(payload);
+                    }
+                    catch (err) {
+                        console.error('[preload] stream event callback threw', err);
+                    }
+                    if (payload.type === 'end' || payload.type === 'error') {
+                        ipcRenderer.removeListener(channel, handler);
+                    }
+                };
+                ipcRenderer.on(channel, handler);
+                return result.streamId;
+            },
+            cancelStream: (streamId) => {
+                ipcRenderer.send(`local-backend:stream:${streamId}:cancel`);
+            },
+            /**
+             * 轮中转向：把一条用户消息注入该 chat 正在运行的 CoreLoop 回合。
+             * 返回 true 表示已被接受（UI 立即上屏）；false 表示当前没有可转向的
+             * 回合（TS 循环路径或回合刚结束）——调用方应保留草稿。
+             */
+            steerChat: async (chatId, content) => {
+                const result = (await ipcRenderer.invoke('local-backend:steer', {
+                    chatId,
+                    content,
+                }));
+                return result?.ok === true;
+            },
+            traces: {
+                list: async (chatId, limit = 50) => {
+                    const path = `/api/v2/local/traces?chatId=${encodeURIComponent(chatId)}&limit=${limit}`;
+                    return await electronAPI.localBackend.request({ method: 'GET', path });
+                },
+                get: async (traceId) => {
+                    const path = `/api/v2/local/traces/${encodeURIComponent(traceId)}`;
+                    return await electronAPI.localBackend.request({ method: 'GET', path });
+                },
+            },
+        },
+        agent: {
+            hasToken: async () => {
+                return true;
+            },
+            provision: async (_userJWT) => {
+                return { success: true };
+            },
+            start: async () => {
+                return { success: true };
+            },
+            getStatus: async () => {
+                return { status: 'registered', agentId: 'local-agent' };
+            },
+            getInfo: async () => {
+                return {
+                    id: 'local-agent',
+                    machineId: 'local',
+                    name: 'Local Agent',
+                    platform: process.platform,
+                    hostname: 'localhost',
+                    shell: process.platform === 'darwin' ? 'zsh' : 'bash',
+                    isOnline: true,
+                };
+            },
+            onNeedProvision: (_callback) => undefined,
+            offNeedProvision: () => undefined,
+        },
+        terminal: {
+            list: async () => {
+                return await ipcRenderer.invoke('terminal:list');
+            },
+            spawn: async (options = {}) => {
+                return await ipcRenderer.invoke('terminal:spawn', options);
+            },
+            ensure: async (options = {}) => {
+                return await ipcRenderer.invoke('terminal:ensure', options);
+            },
+            write: async (id, data) => {
+                return await ipcRenderer.invoke('terminal:write', { id, data });
+            },
+            resize: async (id, cols, rows) => {
+                return await ipcRenderer.invoke('terminal:resize', { id, cols, rows });
+            },
+            kill: async (id) => {
+                return await ipcRenderer.invoke('terminal:kill', id);
+            },
+            exec: async (payload) => {
+                return await ipcRenderer.invoke('terminal:exec', payload);
+            },
+            onData: (callback) => {
+                const fn = (_event, payload) => callback(payload);
+                ipcRenderer.on('terminal:data', fn);
+                return () => ipcRenderer.removeListener('terminal:data', fn);
+            },
+            onExit: (callback) => {
+                const fn = (_event, payload) => callback(payload);
+                ipcRenderer.on('terminal:exit', fn);
+                return () => ipcRenderer.removeListener('terminal:exit', fn);
+            },
+            onSpawned: (callback) => {
+                const fn = (_event, session) => callback(session);
+                ipcRenderer.on('terminal:spawned', fn);
+                return () => ipcRenderer.removeListener('terminal:spawned', fn);
+            },
+            onReveal: (callback) => {
+                const fn = (_event, payload) => callback(payload);
+                ipcRenderer.on('terminal:reveal', fn);
+                return () => ipcRenderer.removeListener('terminal:reveal', fn);
+            },
+        },
+    };
+    contextBridge.exposeInMainWorld('electron', { ...electronAPI, ...packContributions });
+}

package/dist/product-config.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 产品注入配置（3.1）：shell 不硬编码任何产品特有的端点/链接/目录名，
+ * 由产品组装根（products/<id>/active.ts）在模块求值早期注入。
+ *
+ * 与 brand.ts 的分工：brand 是「产品身份」（显示名/自称/默认智能体），
+ * 本模块是「产品资源」（遥测端点、帮助链接、数据目录）。两者都由产品
+ * 组装根注入；缺省时 shell 表现为中性框架（无遥测、无帮助链接、
+ * 数据目录 .agent-shell）。
+ *
+ * 本模块只允许依赖 node 内置模块（与 brand.ts 同约束）。
+ */
+export interface ProductLinks {
+    /** 帮助菜单「打开发布页」URL（通常是产品的下载/更新通道页）。 */
+    releasePage?: string;
+    /** 帮助菜单「访问官网」URL。 */
+    website?: string;
+}
+export interface ProductConfig {
+    /**
+     * 云端遥测端点（insights flush 的 API base）。空 = 不上报（中性默认）；
+     * 用户设置里的 apiBase 与环境变量仍可覆盖。
+     */
+    insightsApiBase?: string;
+    /** 帮助菜单链接；缺省的项不渲染。 */
+    links?: ProductLinks;
+    /**
+     * BS 模式的 userData 目录名（~/ 下）。CS 模式由 Electron 按
+     * productName 分目录，不经此字段。
+     */
+    dataDirName?: string;
+    /**
+     * 主 SQLite 文件名（userData 目录下）。产品必须显式声明以保住存量
+     * 数据；中性 shell 缺省 'agent-shell.db'。
+     */
+    dbFileName?: string;
+}
+/**
+ * 注入产品配置（产品组装根在第一个 import 时调用）。重复注入抛错
+ * （组装期笔误，fail fast——与 setProductBrand 同语义）。
+ */
+export declare function setProductConfig(config: ProductConfig): void;
+/** 读取已注入的产品配置；未注入返回空对象（中性框架行为）。 */
+export declare function getProductConfig(): ProductConfig;

package/dist/product-config.js

@@ -0,0 +1,26 @@
+/**
+ * 产品注入配置（3.1）：shell 不硬编码任何产品特有的端点/链接/目录名，
+ * 由产品组装根（products/<id>/active.ts）在模块求值早期注入。
+ *
+ * 与 brand.ts 的分工：brand 是「产品身份」（显示名/自称/默认智能体），
+ * 本模块是「产品资源」（遥测端点、帮助链接、数据目录）。两者都由产品
+ * 组装根注入；缺省时 shell 表现为中性框架（无遥测、无帮助链接、
+ * 数据目录 .agent-shell）。
+ *
+ * 本模块只允许依赖 node 内置模块（与 brand.ts 同约束）。
+ */
+let productConfig = null;
+/**
+ * 注入产品配置（产品组装根在第一个 import 时调用）。重复注入抛错
+ * （组装期笔误，fail fast——与 setProductBrand 同语义）。
+ */
+export function setProductConfig(config) {
+    if (productConfig) {
+        throw new Error('[product-config] product config already set');
+    }
+    productConfig = config;
+}
+/** 读取已注入的产品配置；未注入返回空对象（中性框架行为）。 */
+export function getProductConfig() {
+    return productConfig ?? {};
+}

package/dist/project-registry.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 项目注册表（项目模式）。
+ *
+ * 项目 = 名字 + 绑定的本地文件夹。chat 通过 `chat_sessions.project_id` 绑定
+ * 项目；绑定后该对话的文件读写与命令执行被硬限制在项目文件夹内（见
+ * tool-router.ts 的 ToolExecContext.projectRoot 与 local-executor.ts 的
+ * 路径围栏）。
+ *
+ * 持久化在 userData/agent-projects.json。存储通过 {@link ProjectKvStore}
+ * 接口注入：main.ts 用 electron-store 实现，单测用内存实现——本模块不
+ * import electron，保持纯 Node 可测（与 mcp-server-registry.ts 同一模式）。
+ */
+export interface ProjectRecord {
+    id: string;
+    /** 用户可见名称（侧边栏分组标题）。 */
+    name: string;
+    /** 绑定的项目文件夹（绝对路径）。 */
+    folderPath: string;
+    /**
+     * W6-5 项目信任门控：项目目录里的 `AGENTS.md` / `CLAUDE.md` 等规则文件
+     * 是「项目作者写给 agent 的指令」——打开一个恶意仓库时，一段精心构造的
+     * 规则文件就能劫持 agent。因此项目级规则只在 `trusted: true` 时才加载进
+     * 模型上下文；默认不信任（安全缺省），用户显式授权后才加载，且可随时撤销。
+     * 旧记录没有此字段，读取时按 `false` 处理（见 {@link ProjectRegistry.isTrusted}）。
+     */
+    trusted?: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateProjectInput {
+    name: string;
+    folderPath: string;
+}
+/** 最小 KV 存储接口，避免本模块直接依赖 electron-store。 */
+export interface ProjectKvStore {
+    get(key: 'projects'): ProjectRecord[] | undefined;
+    set(key: 'projects', value: ProjectRecord[]): void;
+}
+export declare class ProjectRegistry {
+    private readonly store;
+    constructor(store: ProjectKvStore);
+    list(): ProjectRecord[];
+    get(idOrName: string): ProjectRecord | null;
+    create(input: CreateProjectInput): ProjectRecord;
+    update(id: string, updates: Partial<CreateProjectInput>): ProjectRecord;
+    delete(id: string): boolean;
+    /**
+     * W6-5: read the trust flag, defaulting absent (legacy) records to
+     * `false` — fail-closed, so a project is never trusted unless the user
+     * explicitly said so.
+     */
+    isTrusted(id: string): boolean;
+    /** W6-5: grant or revoke trust. Returns the updated record. */
+    setTrusted(id: string, trusted: boolean): ProjectRecord;
+}

package/dist/project-registry.js

@@ -0,0 +1,106 @@
+/**
+ * 项目注册表（项目模式）。
+ *
+ * 项目 = 名字 + 绑定的本地文件夹。chat 通过 `chat_sessions.project_id` 绑定
+ * 项目；绑定后该对话的文件读写与命令执行被硬限制在项目文件夹内（见
+ * tool-router.ts 的 ToolExecContext.projectRoot 与 local-executor.ts 的
+ * 路径围栏）。
+ *
+ * 持久化在 userData/agent-projects.json。存储通过 {@link ProjectKvStore}
+ * 接口注入：main.ts 用 electron-store 实现，单测用内存实现——本模块不
+ * import electron，保持纯 Node 可测（与 mcp-server-registry.ts 同一模式）。
+ */
+import { randomUUID } from 'node:crypto';
+const STORE_KEY = 'projects';
+export class ProjectRegistry {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    list() {
+        // 按创建时间升序：侧边栏项目组顺序稳定，早建的在前。
+        return [...(this.store.get(STORE_KEY) ?? [])].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    get(idOrName) {
+        const needle = idOrName.trim().toLowerCase();
+        return (this.list().find((p) => p.id === idOrName || p.name.toLowerCase() === needle) ?? null);
+    }
+    create(input) {
+        const name = input.name.trim();
+        const folderPath = input.folderPath.trim();
+        if (!name)
+            throw new Error('项目名称不能为空');
+        if (!folderPath)
+            throw new Error('项目文件夹不能为空');
+        if (this.get(name))
+            throw new Error(`已存在同名项目「${name}」`);
+        const now = new Date().toISOString();
+        const entry = {
+            id: randomUUID(),
+            name,
+            folderPath,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.store.set(STORE_KEY, [...this.list(), entry]);
+        return entry;
+    }
+    update(id, updates) {
+        const projects = this.list();
+        const idx = projects.findIndex((p) => p.id === id);
+        if (idx === -1)
+            throw new Error('项目不存在');
+        const current = projects[idx];
+        const nextName = updates.name !== undefined ? updates.name.trim() : current.name;
+        if (!nextName)
+            throw new Error('项目名称不能为空');
+        const nameClash = projects.some((p) => p.id !== id && p.name.toLowerCase() === nextName.toLowerCase());
+        if (nameClash)
+            throw new Error(`已存在同名项目「${nextName}」`);
+        const nextFolder = updates.folderPath !== undefined
+            ? updates.folderPath.trim()
+            : current.folderPath;
+        if (!nextFolder)
+            throw new Error('项目文件夹不能为空');
+        const next = {
+            ...current,
+            name: nextName,
+            folderPath: nextFolder,
+            updatedAt: new Date().toISOString(),
+        };
+        projects[idx] = next;
+        this.store.set(STORE_KEY, projects);
+        return next;
+    }
+    delete(id) {
+        const projects = this.list();
+        const next = projects.filter((p) => p.id !== id);
+        if (next.length === projects.length)
+            return false;
+        this.store.set(STORE_KEY, next);
+        return true;
+    }
+    /**
+     * W6-5: read the trust flag, defaulting absent (legacy) records to
+     * `false` — fail-closed, so a project is never trusted unless the user
+     * explicitly said so.
+     */
+    isTrusted(id) {
+        return this.get(id)?.trusted === true;
+    }
+    /** W6-5: grant or revoke trust. Returns the updated record. */
+    setTrusted(id, trusted) {
+        const projects = this.list();
+        const idx = projects.findIndex((p) => p.id === id);
+        if (idx === -1)
+            throw new Error('项目不存在');
+        const next = {
+            ...projects[idx],
+            trusted,
+            updatedAt: new Date().toISOString(),
+        };
+        projects[idx] = next;
+        this.store.set(STORE_KEY, projects);
+        return next;
+    }
+}

package/dist/project-rules.d.ts

@@ -0,0 +1,15 @@
+export interface ProjectRules {
+    /** 实际发现的规则文件绝对路径，根→叶顺序（越靠后对当前项目越具体）。 */
+    files: string[];
+    /** 拼接好的注入文本（含每个文件的来源标注），已按上限截断。 */
+    content: string;
+    /** 是否有内容因上限被截断。 */
+    truncated: boolean;
+}
+/**
+ * 收集并拼接项目规则。`folderPath` 为绑定的项目根目录。
+ *
+ * 向上遍历在「用户 home 目录」处封顶（若项目不在 home 下则按 MAX_LEVELS
+ * 封顶）——不扫 `/`、`/etc` 这类与项目无关的祖先目录。
+ */
+export declare function loadProjectRuleFiles(folderPath: string): ProjectRules;