mocode-ai 1.2.7 → 1.2.9

package/dist/tools/builtins/memory-update.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const memoryUpdateTool: Tool;

package/dist/tools/builtins/project-skill-update.js

@@ -1,102 +0,0 @@
-import { readProjectSkill, writeProjectSkillWithCompression, appendProjectSkillWithCompression, } from '../../project-skill/index.js';
-/**
- * 项目专属 Skill 更新工具。
- * 支持三种操作:
- *   - read: 读取当前 skill 内容
- *   - write: 全量覆盖(适合重构整个 skill)
- *   - append: 追加到末尾(适合发现新坑点/约定时增量更新)
- *
- * 使用场景:
- *   - 开发过程中发现项目特有的架构模式、命名约定
- *   - 踩坑后记录避坑指南
- *   - 总结项目关键决策和设计理由
- *   - 随着项目开发，skill 越来越了解项目，开发效率越来越高
- */
-export const projectSkillUpdateTool = {
-    name: 'project_skill_update',
-    description: 'Update the project-specific skill file (.mocode/project-skill.md). ' +
-        'Use this to record architectural patterns, naming conventions, common pitfalls, ' +
-        'and key decisions specific to this project. The skill persists across sessions and ' +
-        'is injected into the system prompt when MOCODE_PROJECT_SKILL=true. ' +
-        'Actions: "read" (view current content), "write" (replace all), "append" (add to end). ' +
-        '\n\n' +
-        '## Skill 维护指南\n' +
-        'Skill 专注 Snapshot 无法自动提供的洞察知识（why/how/gotchas）。Snapshot 已提供文件结构和静态文件内容——Skill 不要重复这些信息。\n' +
-        '\n' +
-        '**Skill 该写什么（Snapshot 不能替代的）**：\n' +
-        '- 设计决策的 why（为什么这样设计、取舍是什么）\n' +
-        '- 模块行为和职责描述（怎么工作、数据流、调用链）\n' +
-        '- 常见坑点和解决方案（踩过的坑、非直觉行为、边界条件）\n' +
-        '- 项目约定（命名规范、代码风格、测试策略）\n' +
-        '- 开发流程（构建/测试/部署命令及注意事项）\n' +
-        '- 关键 API 的使用限制和特殊行为\n' +
-        '\n' +
-        '**Skill 不该写什么（交给 Snapshot）**：\n' +
-        '- 文件列表和目录结构（Snapshot 自动扫描 src 树）\n' +
-        '- 静态文件内容摘要（依赖、编译器选项等 → package.json / tsconfig.json）\n' +
-        '\n' +
-        '**何时更新**：发现新架构模式、踩坑后总结、学到新约定、完成重要重构、用户纠正理解时。\n' +
-        '\n' +
-        '**注意事项**：\n' +
-        '- 内容长度不设硬上限，按项目实际复杂度完整记录有价值的信息\n' +
-        '- 写可操作的内容，避免空泛描述\n' +
-        '- 用具体路径和例子（不要写"有多个模块"，要写"src/agent 负责 agent 循环"）\n' +
-        '- 定期整理，删除过时和重复信息\n' +
-        '- 更新前建议先 `read` 看一下现有内容，避免重复。',
-    risk: 'safe',
-    parameters: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['read', 'write', 'append'],
-                description: 'Action to perform: "read" to view current content, "write" to replace all, "append" to add to end',
-            },
-            content: {
-                type: 'string',
-                description: 'Content to write or append (required for "write" and "append" actions, ignored for "read")',
-            },
-        },
-        required: ['action'],
-    },
-    execute: async (args, ctx) => {
-        const action = String(args.action ?? '').trim();
-        const content = String(args.content ?? '');
-        const signal = ctx?.signal;
-        switch (action) {
-            case 'read': {
-                const current = readProjectSkill();
-                if (!current) {
-                    return 'Project skill is empty or does not exist yet.';
-                }
-                return `Current project skill:\n\n${current}`;
-            }
-            case 'write': {
-                if (!content.trim()) {
-                    return 'Error: "write" action requires non-empty content parameter.';
-                }
-                const result = await writeProjectSkillWithCompression(content, 3, signal);
-                if (!result.ok) {
-                    return `Error: ${result.error}`;
-                }
-                return result.compressed
-                    ? 'Project skill updated successfully (full replacement, auto-compressed to fit limit).'
-                    : 'Project skill updated successfully (full replacement).';
-            }
-            case 'append': {
-                if (!content.trim()) {
-                    return 'Error: "append" action requires non-empty content parameter.';
-                }
-                const result = await appendProjectSkillWithCompression(content, 3, signal);
-                if (!result.ok) {
-                    return `Error: ${result.error}`;
-                }
-                return result.compressed
-                    ? 'Project skill updated successfully (appended, auto-compressed to fit limit).'
-                    : 'Project skill updated successfully (appended).';
-            }
-            default:
-                return `Error: Unknown action "${action}". Use "read", "write", or "append".`;
-        }
-    },
-};

package/dist/tools/builtins/read-file.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const readFileTool: Tool;

package/dist/tools/builtins/run-command.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const runCommandTool: Tool;

package/dist/tools/builtins/switch-mode.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const switchModeTool: Tool;

package/dist/tools/builtins/switch-mode.js

@@ -1,44 +0,0 @@
-import { setAgentMode, getAgentMode } from '../../agent/mode.js';
-// ---------- switch_mode ----------
-export const switchModeTool = {
-    name: 'switch_mode',
-    description: [
-        'Switch agent mode between "plan" (read-only investigation) and "auto" (full tool execution).',
-        'Use to transition from planning to execution WITHIN THE SAME TURN: in plan, after presenting a plan, call switch_mode("auto") and continue — ONLY when the user asked for autonomous execution ("先 plan 再 auto" etc.).',
-        'If the user entered plan mode manually (/plan or Shift+Tab) for review, do NOT switch to auto — present the plan and STOP for approval.',
-    ].join(' '),
-    parameters: {
-        type: 'object',
-        properties: {
-            mode: {
-                type: 'string',
-                enum: ['auto', 'plan'],
-                description: 'Target mode: "plan" (read-only) or "auto" (full tools)',
-            },
-        },
-        required: ['mode'],
-    },
-    async execute(args) {
-        const target = String(args.mode);
-        if (target !== 'auto' && target !== 'plan') {
-            return `错误:mode 必须是 "auto" 或 "plan",收到 "${target}"`;
-        }
-        const prev = getAgentMode();
-        if (prev === target) {
-            return `已在 ${target} 模式,无需切换。`;
-        }
-        setAgentMode(target); // 触发 listener:repl 重写 history[0] 系统提示 + 刷状态行 modeTag
-        if (target === 'auto') {
-            return [
-                `已从 plan 切换到 auto 模式。`,
-                `写盘 / 命令 / 记忆写入工具(write_file / edit_file / run_command / memory_save / memory_update / memory_forget)现已恢复可用。`,
-                `请按你刚才产出的计划继续执行(同一轮内,无需重述计划)。`,
-            ].join('\n');
-        }
-        return [
-            `已从 auto 切换到 plan 模式(只读探查)。`,
-            `写盘 / 命令 / 记忆写入工具已禁用;只用 read_file / glob / grep / codegraph / web_search / web_fetch / use_skill / ask_human / memory_search / memory_list 探查。`,
-            `产出计划后 STOP 等用户审批,或(若用户要求自主执行)再调 switch_mode("auto") 续跑。`,
-        ].join('\n');
-    },
-};

package/dist/tools/builtins/task.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const taskTool: Tool;

package/dist/tools/builtins/todolist.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const todolistTool: Tool;

package/dist/tools/builtins/todolist.js

@@ -1,411 +0,0 @@
-// todolist 工具:LLM 的「工作记事本」——把隐式思考外化为持久 checklist,抗压缩、可视化。
-//
-// 落地:plan/store.ts(文件源)+ plan/active.ts(进程级活跃缓存)+ 本工具(写盘 + 通知 listener)。
-//
-// 契约对齐「调度器永不抛错、永远返回字符串」(tools/registry.ts executeTool)。
-// 单 plan/会话:create 前若有 in_progress 活跃 plan → 拒绝(避免误覆盖);finish/abandoned 后可再建。
-//
-// 工具返回:把当前 plan 紧凑渲染给 LLM(不只返操作结果——让 LLM 单次调用后看到完整状态,无需再 read)。
-import { newPlanId, readPlan, writePlan, updatePlan, listPlans, archivePlan, unarchivePlan, deletePlanAnywhere, renderPlanForLLM, localIsoTimestamp, } from '../../plan/store.js';
-import { getActivePlan, setActivePlan, hasActivePlan, clearActivePlan } from '../../plan/active.js';
-import { MAX_OUTPUT } from '../constants.js';
-const VALID_STATUS = new Set([
-    'pending', 'in_progress', 'done', 'skipped', 'failed',
-]);
-const VALID_PLAN_STATUS = new Set([
-    'in_progress', 'finished', 'abandoned',
-]);
-// ── 工具定义 ──
-export const todolistTool = {
-    name: 'todolist',
-    description: [
-        'Maintain a working "notepad" plan in .mocode/plans/<id>.md (file-based, survives context compression).',
-        '',
-        '## PREREQUISITES (before create)',
-        'Research first: explore codebase (read-only tools) → clarify with user (ask_human) → have concrete steps.',
-        'Do NOT create prematurely — if you haven\'t done research and confirmation, stop and do that first.',
-        '',
-        '## WHEN TO USE / NOT USE',
-        'ONLY for genuinely complex tasks: ≥3 file changes, ≥5 tool calls across phases, multi-phase features,',
-        'or user explicitly requests ("先计划再执行" / "plan then do").',
-        'Skip for: single-file edits, bug fixes, quick lookups, ≤3 focused tool calls. If in doubt, just execute.',
-        '',
-        '## STEP GRANULARITY (4-5 steps max)',
-        'Each step = one meaningful execution unit (a phase, not a single tool call).',
-        'GOOD: "调研现有架构 → 设计新接口 → 实现核心逻辑 → 编写测试 → 集成验证"',
-        'BAD: "打开文件A → 修改函数X → 保存文件A → 运行测试" (too fine-grained, just do it)',
-        '',
-        '## UPDATE WORKFLOW',
-        'Update in real-time after completing each step (one step = one update, or batch_update for 2-3 at once).',
-        'Do NOT batch all updates at the end — update as you go so the chip reflects real progress.',
-        'All steps done/skipped → plan auto-finishes, archives, and chip disappears.',
-        '',
-        '## LIFECYCLE',
-        'Single plan per session: create refuses if an in-progress plan already exists — finish or abandon it first.',
-        'finish(plan_status="finished") auto-archives to .mocode/plans/archive/; use plan_status="abandoned" to abandon.',
-        'To revisit: list with scope=archived, or unarchive to bring back to active. delete permanently removes.',
-    ].join('\n'),
-    parameters: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['create', 'read', 'update', 'batch_update', 'add_step', 'finish', 'list', 'delete', 'unarchive'],
-                description: 'create=新计划;read=读当前活跃;update=改步骤状态;batch_update=批量改多个步骤状态;add_step=追加步骤;finish=收尾(自动归档);list=列计划;delete=永久删除;unarchive=从归档还原到活跃',
-            },
-            title: { type: 'string', description: 'create 必填:计划标题' },
-            goal: { type: 'string', description: 'create 可选:目标描述(写进「目标」段)' },
-            steps: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'create 必填:步骤标题数组(从 1 起自动编号)',
-            },
-            step_id: {
-                type: 'number',
-                description: 'update 必填:步骤编号(1-based;create 后 read 返回的 id)',
-            },
-            status: {
-                type: 'string',
-                enum: ['pending', 'in_progress', 'done', 'skipped', 'failed'],
-                description: 'update 必填:目标状态',
-            },
-            updates: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        step_id: { type: 'number', description: '步骤编号' },
-                        status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'skipped', 'failed'], description: '目标状态' },
-                    },
-                    required: ['step_id', 'status'],
-                },
-                description: 'batch_update 必填:批量更新数组,每项含 step_id 和 status',
-            },
-            note: {
-                type: 'string',
-                description: 'update / batch_update / finish 可选:追加到进度日志的一行说明(可空)',
-            },
-            plan_status: {
-                type: 'string',
-                enum: ['finished', 'abandoned'],
-                description: 'finish 必填:finished=完成;abandoned=放弃(中途取消)。finished 触发自动归档。',
-            },
-            scope: {
-                type: 'string',
-                enum: ['active', 'archived', 'all'],
-                description: 'list 可选:范围(active=默认,仅进行中;archived=仅归档;all=全)。',
-            },
-            id: {
-                type: 'string',
-                description: 'delete / unarchive 必填:目标 plan id(list 可拿到)。',
-            },
-        },
-        required: ['action'],
-    },
-    async execute(args) {
-        const action = String(args.action ?? '');
-        try {
-            switch (action) {
-                case 'create': return doCreate(args);
-                case 'read': return doRead();
-                case 'update': return doUpdate(args);
-                case 'batch_update': return doBatchUpdate(args);
-                case 'add_step': return doAddStep(args);
-                case 'finish': return doFinish(args);
-                case 'list': return doList(args);
-                case 'delete': return doDelete(args);
-                case 'unarchive': return doUnarchive(args);
-                default:
-                    return `错误:未知 action「${action}」,合法值:create / read / update / batch_update / add_step / finish / list / delete / unarchive。`;
-            }
-        }
-        catch (e) {
-            // 兜底:工具内部不抛,但防御性 catch 一道(契约对齐「永不抛」)。
-            const why = e instanceof Error ? e.message : String(e);
-            return `错误:todolist 内部异常: ${why}`;
-        }
-    },
-};
-// ── actions ──
-function doCreate(args) {
-    const title = String(args.title ?? '').trim();
-    if (!title)
-        return '错误:create 必填 title。';
-    const goal = String(args.goal ?? '').trim();
-    const rawSteps = Array.isArray(args.steps) ? args.steps : null;
-    if (!rawSteps || rawSteps.length === 0)
-        return '错误:create 必填 steps(非空字符串数组)。';
-    const steps = rawSteps
-        .map((s) => String(s ?? '').trim())
-        .filter((s) => s.length > 0);
-    if (steps.length === 0)
-        return '错误:create 的 steps 全是空字符串。';
-    if (hasActivePlan()) {
-        const cur = getActivePlan();
-        return `错误:已存在进行中的 plan「${cur?.title ?? ''}」(id=${cur?.id ?? ''}),需先 finish 后再建。`;
-    }
-    // 旧 plan 残留(finished/abandoned)→ 允许新建,不删历史(用户可后续 read 历史 plan)
-    const now = localIsoTimestamp();
-    const plan = {
-        id: newPlanId(),
-        title,
-        status: 'in_progress',
-        created: now,
-        updated: now,
-        goal,
-        steps: steps.map((t, i) => ({ id: i + 1, title: t, status: 'pending' })),
-        log: [{ at: now, text: `创建计划: ${steps.length} 步` }],
-    };
-    if (!writePlan(plan))
-        return '错误:写 plan 文件失败(检查 .mocode/plans 目录权限)。';
-    setActivePlan(plan);
-    return renderSuccess('create', plan);
-}
-function doRead() {
-    const cur = getActivePlan();
-    if (!cur) {
-        // 兜底:state 缓存空但文件可能存在(sandboxRoot 切了 / 进程重启)→ 列 plans 找一个最新的 in_progress
-        const fallback = findInProgressFromDisk();
-        if (fallback) {
-            setActivePlan(fallback);
-            return renderSuccess('read', fallback);
-        }
-        return '错误:无活跃 plan。先用 action=create 开一个。';
-    }
-    // 重新读盘以保最新(其他路径可能改了文件)
-    const fresh = readPlan(cur.id);
-    if (fresh)
-        setActivePlan(fresh);
-    return renderSuccess('read', fresh ?? cur);
-}
-function doUpdate(args) {
-    const cur = getActivePlan();
-    if (!cur)
-        return '错误:无活跃 plan 可 update。先 create。';
-    const stepId = Number(args.step_id);
-    if (!Number.isFinite(stepId) || stepId < 1) {
-        return `错误:update 必填 step_id(>=1 的整数),收到「${args.step_id}」。`;
-    }
-    const status = String(args.status ?? '');
-    if (!VALID_STATUS.has(status)) {
-        return `错误:update 的 status 非法「${status}」,合法:pending / in_progress / done / skipped / failed。`;
-    }
-    const note = String(args.note ?? '').trim();
-    const updated = updatePlan(cur.id, (p) => {
-        const step = p.steps.find((s) => s.id === stepId);
-        if (!step)
-            return false; // 无改动,工具返错
-        step.status = status;
-        const at = new Date().toISOString();
-        const logText = note || `step ${stepId} → ${status}`;
-        p.log.push({ at, text: logText });
-        return p;
-    });
-    if (!updated) {
-        return `错误:update 失败(找不到 step_id=${stepId},可能 plan 已不存在或 step 编号越界)。`;
-    }
-    // step 不存在(updatePlan 内 mutator 返 false → updatePlan 返原对象,需二次校验)
-    if (!updated.steps.some((s) => s.id === stepId)) {
-        return `错误:找不到 step_id=${stepId}(plan 共 ${updated.steps.length} 步)。`;
-    }
-    // 自动完成:所有步骤都 done/skipped 时自动 finish + 归档 + 清 chip(LLM 常漏调 finish)
-    const allDone = updated.steps.length > 0
-        && updated.steps.every((s) => s.status === 'done' || s.status === 'skipped');
-    if (allDone && updated.status === 'in_progress') {
-        updated.status = 'finished';
-        updated.log.push({ at: localIsoTimestamp(), text: '自动完成:所有步骤已完成' });
-        if (!writePlan(updated)) {
-            setActivePlan(updated);
-            return renderSuccess('update', updated) + '\n⚠ 自动 finish 写盘失败';
-        }
-        const archived = archivePlan(updated.id);
-        clearActivePlan();
-        const archivedNote = archived
-            ? '(已自动归档到 plans/archive/)'
-            : '(⚠ 归档失败,plan 仍留在 plans/)';
-        return renderSuccess('update', updated) + `\n✓ 自动完成:所有步骤已完成 ${archivedNote}`;
-    }
-    setActivePlan(updated);
-    return renderSuccess('update', updated);
-}
-function doBatchUpdate(args) {
-    const cur = getActivePlan();
-    if (!cur)
-        return '错误:无活跃 plan 可 batch_update。先 create。';
-    const updates = args.updates;
-    if (!Array.isArray(updates) || updates.length === 0) {
-        return '错误:batch_update 必填 updates(非空数组,每项含 step_id 和 status)。';
-    }
-    // 验证所有更新项
-    for (const u of updates) {
-        const sid = Number(u.step_id);
-        const st = String(u.status ?? '');
-        if (!Number.isFinite(sid) || sid < 1) {
-            return `错误:updates 中某项 step_id 非法「${u.step_id}」,需 >=1 整数。`;
-        }
-        if (!VALID_STATUS.has(st)) {
-            return `错误:updates 中某项 status 非法「${st}」,合法:pending / in_progress / done / skipped / failed。`;
-        }
-    }
-    const note = String(args.note ?? '').trim();
-    const updated = updatePlan(cur.id, (p) => {
-        for (const u of updates) {
-            const sid = Number(u.step_id);
-            const st = String(u.status);
-            const step = p.steps.find((s) => s.id === sid);
-            if (step) {
-                step.status = st;
-                p.log.push({ at: new Date().toISOString(), text: `step ${sid} → ${st}` });
-            }
-        }
-        if (note)
-            p.log.push({ at: new Date().toISOString(), text: note });
-        return p;
-    });
-    if (!updated)
-        return '错误:batch_update 写盘失败。';
-    // 检查所有 step_id 是否存在
-    const missingIds = [];
-    for (const u of updates) {
-        const sid = Number(u.step_id);
-        if (!updated.steps.some((s) => s.id === sid))
-            missingIds.push(sid);
-    }
-    if (missingIds.length > 0) {
-        return `错误:batch_update 找不到 step_id=${missingIds.join(', ')}(plan 共 ${updated.steps.length} 步)。`;
-    }
-    // 自动完成:所有步骤都 done/skipped 时自动 finish + 归档 + 清 chip(LLM 常漏调 finish)
-    const allDone = updated.steps.length > 0
-        && updated.steps.every((s) => s.status === 'done' || s.status === 'skipped');
-    if (allDone && updated.status === 'in_progress') {
-        updated.status = 'finished';
-        updated.log.push({ at: localIsoTimestamp(), text: '自动完成:所有步骤已完成' });
-        if (!writePlan(updated)) {
-            setActivePlan(updated);
-            return renderSuccess('batch_update', updated) + '\n⚠ 自动 finish 写盘失败';
-        }
-        const archived = archivePlan(updated.id);
-        clearActivePlan();
-        const archivedNote = archived
-            ? '(已自动归档到 plans/archive/)'
-            : '(⚠ 归档失败,plan 仍留在 plans/)';
-        return renderSuccess('batch_update', updated) + `\n✓ 自动完成:所有步骤已完成 ${archivedNote}`;
-    }
-    setActivePlan(updated);
-    return renderSuccess('batch_update', updated);
-}
-function doAddStep(args) {
-    const cur = getActivePlan();
-    if (!cur)
-        return '错误:无活跃 plan 可 add_step。先 create。';
-    const text = String(args.title ?? args.note ?? '').trim();
-    if (!text)
-        return '错误:add_step 必填 title(单条步骤标题)。';
-    const updated = updatePlan(cur.id, (p) => {
-        const nextId = p.steps.length > 0 ? Math.max(...p.steps.map((s) => s.id)) + 1 : 1;
-        p.steps.push({ id: nextId, title: text, status: 'pending' });
-        p.log.push({ at: new Date().toISOString(), text: `add step: ${text}` });
-        return p;
-    });
-    if (!updated)
-        return '错误:add_step 写盘失败。';
-    setActivePlan(updated);
-    return renderSuccess('add_step', updated);
-}
-function doFinish(args) {
-    const cur = getActivePlan();
-    if (!cur)
-        return '错误:无活跃 plan 可 finish。';
-    const ps = String(args.plan_status ?? 'finished');
-    if (!VALID_PLAN_STATUS.has(ps)) {
-        return `错误:finish 的 plan_status 非法「${ps}」,合法:finished / abandoned。`;
-    }
-    const note = String(args.note ?? '').trim();
-    const updated = updatePlan(cur.id, (p) => {
-        p.status = ps;
-        p.log.push({
-            at: localIsoTimestamp(),
-            text: note || (ps === 'finished' ? '完成' : '放弃'),
-        });
-        return p;
-    });
-    if (!updated)
-        return '错误:finish 写盘失败。';
-    setActivePlan(updated);
-    // finished → 自动归档到 plans/archive/(历史完整保留,活跃目录保持干净)。
-    //   abandoned → 不归档(用户想丢就丢,但仍在 plans/ 下,可显式 delete 删掉)。
-    let archived = false;
-    if (ps === 'finished') {
-        archived = archivePlan(updated.id);
-    }
-    // finish 后清活跃缓存(下轮 read 自动从 in_progress 列表兜底,本会话不再「活跃」)
-    clearActivePlan();
-    const archivedNote = ps === 'finished'
-        ? (archived ? '(已自动归档到 plans/archive/)' : '(⚠ 归档失败,plan 仍留在 plans/,可手动 list 排查)')
-        : '';
-    return `${renderSuccess('finish', updated)}\n${archivedNote}`.trimEnd();
-}
-function doList(args) {
-    const scopeRaw = String(args.scope ?? 'active');
-    const scope = scopeRaw === 'archived' || scopeRaw === 'all' ? scopeRaw : 'active';
-    const plans = listPlans(scope);
-    if (plans.length === 0) {
-        return `list: 无 ${scope === 'active' ? '进行中' : scope === 'archived' ? '已归档' : ''}plan。`;
-    }
-    // 一行一条:id | status | 标题 | 进度
-    const lines = [`list (${scope},${plans.length} 条):`];
-    for (const p of plans) {
-        const done = p.steps.filter((s) => s.status === 'done' || s.status === 'skipped').length;
-        const status = p.status === 'in_progress' ? 'live' : p.status === 'finished' ? 'done' : 'gone';
-        lines.push(`  ${p.id}  [${status}]  ${p.title}  (${done}/${p.steps.length})`);
-    }
-    return lines.join('\n');
-}
-function doDelete(args) {
-    const id = String(args.id ?? '').trim();
-    if (!id)
-        return '错误:delete 必填 id(从 list 拿)。';
-    // 安全护栏:active 状态下不能直接 delete 当前活跃(避免误删正在用的 plan)
-    const cur = getActivePlan();
-    if (cur && cur.id === id) {
-        return `错误:不能 delete 当前活跃 plan「${cur.title}」,需先 finish(自动归档)再 delete 归档副本。`;
-    }
-    const ok = deletePlanAnywhere(id);
-    if (!ok)
-        return `错误:delete 失败,id「${id}」在 plans/ 和 plans/archive/ 都找不到。`;
-    return `delete ✓: 已永久删除「${id}」(.mocode/plans/ 与 archive/ 都不再存在)。`;
-}
-function doUnarchive(args) {
-    const id = String(args.id ?? '').trim();
-    if (!id)
-        return '错误:unarchive 必填 id(从 list scope=archived 拿)。';
-    if (!unarchivePlan(id)) {
-        return `错误:unarchive 失败,id「${id}」在 plans/archive/ 找不到(可能已还原,或被 delete)。`;
-    }
-    // 还原后读一次拿回 plan 对象(若 status=in_progress 还可顺手恢复为活跃)
-    const fresh = readPlan(id);
-    if (!fresh)
-        return `unarchive ✓: 「${id}」已还原到 plans/(读取失败,但文件在)。`;
-    if (fresh.status === 'in_progress') {
-        setActivePlan(fresh);
-        return `${renderSuccess('unarchive', fresh)}\n(已自动设为活跃)。`.trimEnd();
-    }
-    return `${renderSuccess('unarchive', fresh)}\n(注:该 plan 状态为 ${fresh.status},未自动激活 —— 显式 create 才激活)`;
-}
-// ── helpers ──
-/** 从盘上找一个 in_progress plan(进程级 state 丢失/首次访问时兜底)。无 → null。 */
-function findInProgressFromDisk() {
-    const all = listPlans();
-    return all.find((p) => p.status === 'in_progress') ?? null;
-}
-/** 工具结果统一格式:`<action>: <一行摘要>\n\n<完整 plan 渲染>`。
- *  超 MAX_OUTPUT 截 plan 渲染尾部(罕见;plan 文件本身就小)。 */
-function renderSuccess(action, p) {
-    const done = p.steps.filter((s) => s.status === 'done' || s.status === 'skipped').length;
-    const head = `${action} ✓: 「${p.title}」 进度 ${done}/${p.steps.length} (status=${p.status})`;
-    const body = renderPlanForLLM(p);
-    const full = `${head}\n\n${body}`;
-    if (full.length <= MAX_OUTPUT)
-        return full;
-    return full.slice(0, MAX_OUTPUT) + `\n\n…(plan 渲染已截断 ${full.length - MAX_OUTPUT} 字符)`;
-}

package/dist/tools/builtins/use-skill.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const useSkillTool: Tool;

package/dist/tools/builtins/web-fetch.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const webFetchTool: Tool;

package/dist/tools/builtins/web-search.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const webSearchTool: Tool;

package/dist/tools/builtins/write-file.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '../types.js';
-export declare const writeFileTool: Tool;

package/dist/tools/constants.d.ts

@@ -1,52 +0,0 @@
-export declare const MAX_FILE_LINES = 2000;
-export declare const MAX_OUTPUT = 20000;
-export declare const MAX_RESULTS = 100;
-/** 进 history 的单条工具结果上限(字符)。push-time 第一层裁剪,保 head + 标记 + tail。 */
-export declare const MAX_HISTORY_RESULT = 8000;
-/** use_skill 结果(SKILL.md 正文)的放宽上限:指令须完整,中截会破坏语义。 */
-export declare const MAX_SKILL_RESULT = 64000;
-/** 微压缩时旧工具结果截到的存根长度(字符)。 */
-export declare const MAX_OLD_TOOL_STUB = 600;
-/** 单条记忆 body 上限(字符)。进 history 前 memory_search 结果另有 MAX_MEMORY_RESULT 兜底。 */
-export declare const MAX_MEMORY_ENTRY = 4000;
-/** 启动注入 systemPrompt 的索引条目上限(遗忘封顶后 active 条目 ≤ MAX_ACTIVE,索引再封一层)。 */
-export declare const MAX_INDEX_ENTRIES = 50;
-/** active 记忆封顶:超则按 recallCount 低 × lastRecalledAt 老 淘汰到 archived。 */
-export declare const MAX_ACTIVE = 100;
-/** 衰减:active + !pinned + (lastRecalledAt|createdAt) 早于 DECAY_DAYS → archived。 */
-export declare const DECAY_DAYS = 30;
-/** GC:archived 超 GC_DAYS → 硬删。 */
-export declare const GC_DAYS = 90;
-/** memory_search 结果(召回的记忆正文)的放宽上限:指令性内容,中截破坏语义,对齐 use_skill。 */
-export declare const MAX_MEMORY_RESULT = 64000;
-export declare const IGNORE: string[];
-/** Hot/Cold 划分:当前 step 起往前 N 个 user turn 之内的工具结果视为 Hot(绝对不压),
- * 之外的视为 Cold(可调度器压)。默认 4 = 跨过 4 个用户问题仍生效。 */
-export declare const HOT_TURN_WINDOW = 4;
-/** Cold 区内可被就地 stub 的 tool 消息最低 age(经过的消费者 push 数)。默认 2,
- * 与 lifecycle.ts DEFAULT_AGE_THRESHOLD 对齐。 */
-export declare const TOOL_OLD_AGE = 2;
-/** 五区预算占比(总和 0.95,留 5% 给 Reserve)。对齐 user 修正版:
- * System 15 / History 20 / Hot Tool 25 / Cold Tool 25 / Summary 10。 */
-export declare const BUDGET_RATIO: {
-    readonly system: 0.15;
-    readonly history: 0.2;
-    readonly toolRecent: 0.25;
-    readonly toolOld: 0.25;
-    readonly summary: 0.1;
-    readonly reserve: 0.05;
-};
-/**
- * plan 模式下从工具 schema 里剔除的工具(模型根本看不到 → 调不到):
- * 写盘 / 命令 / 记忆写入类 + task(派生子 agent,plan 模式只读不可有副作用)。单一事实源,
- * 被 llm(planChatTools)与 agent(防御 backstop)共用。
- * 只读工具(read_file/glob/grep/codegraph/web_search/web_fetch/use_skill/ask_human/memory_search/memory_list)保留。
- */
-export declare const PLAN_DISABLED_TOOLS: Set<string>;
-/**
- * 按当前 isMemoryEnabled() 现算 plan 模式应屏蔽的工具。
- * memoryEnabled=false 时记忆工具整体不在 builtinTools 里,plan 屏蔽集里也无须再列 ——
- * 反之留着只是死名字。统一过滤,避免 Set 里残留与已下架工具不一致的概念性冗余。
- * 调用方(agent/core 串行分支、llm/planChatTools)每次 chat 时调本函数拿当前值。
- */
-export declare function getPlanDisabledTools(): Set<string>;