mocode-ai 1.6.5 → 1.6.7

package/dist/index.js

@@ -38,10 +38,26 @@ process.on('unhandledRejection', (e) => {
     exitAltScreen();
     process.exit(1);
 });
+/** 取 args 中任意位置的非 flag 参数；排除带值 flag（--sandbox-root）的下一个值。 */
+function firstPositional(args, options = {}) {
+    const valueFlags = options.valueFlags ?? [];
+    return args.find((a, idx) => {
+        if (a.startsWith('-'))
+            return false;
+        if (valueFlags.includes(args[idx - 1] ?? ''))
+            return false;
+        return true;
+    });
+}
 /**
- * 入口:装配并启动 REPL。支持 --resume <id> 续接历史会话(裸 --resume 列出会话)。
+ * 入口:
+ * - 后台任务:`mocode run --bg "任务"`（detached 子进程，状态落 .mocode/jobs/）。
+ * - Job runner 内部模式:`mocode --job-runner <id>`（由 run --bg 派生，用户不直接用）。
+ * - Headless（一次性 / 非交互）:`mocode -p "任务"` 或 `echo "任务" | mocode`，
+ *   可选 --json / --verbose / --dangerously-skip-permissions。
+ * - 交互 REPL（默认）;支持 --resume <id> 续接历史会话(裸 --resume 列出会话)。
  * `mocode config` 走首跑配置向导(动态加载 commands/config,不引入 REPL/config 图,故缺配置也能跑)。
- * REPL / session 用动态 import 按需加载——只在真正启动时才拉入 config 依赖图。
+ * REPL / session / headless / jobs 用动态 import 按需加载——只在真正启动时才拉入 config 依赖图。
  * 显式 process.exit(0)——OpenAI 客户端的 keep-alive 会卡住事件循环。
  */
 async function main() {
@@ -58,12 +74,160 @@ async function main() {
             process.exit(1);
         }
     }
+    // --session-dir <path>:会话独立落盘目录(不写主 .mocode/sessions)。
+    const sd = args.indexOf('--session-dir');
+    let sessionDirOverride;
+    if (sd !== -1) {
+        sessionDirOverride = args[sd + 1];
+        if (!sessionDirOverride || sessionDirOverride.startsWith('--')) {
+            console.error('mocode: --session-dir requires a path');
+            process.exit(1);
+        }
+    }
+    const useWorktree = args.includes('--worktree');
+    const botFlagIdx = args.indexOf('--bot');
+    const botName = botFlagIdx !== -1 ? args[botFlagIdx + 1] : undefined;
     // 首跑配置向导:写 ~/.mocode/config。独立模块,不触发 config 校验,故零配置也能跑。
+    if (args[0] === 'bots') {
+        const { runBotsCli } = await import('./bots/cli.js');
+        const code = await runBotsCli(args.slice(1));
+        process.exit(code);
+    }
+    if (args[0] === 'schedule') {
+        const { runScheduleCli } = await import('./schedule/cli.js');
+        const code = await runScheduleCli(args.slice(1));
+        process.exit(code);
+    }
+    if (args[0] === 'resume-job') {
+        const { resumeBackgroundJob } = await import('./jobs/launch.js');
+        const rec = resumeBackgroundJob(args[1] ?? '');
+        if (!rec) {
+            process.stderr.write('mocode: job not found\n');
+            process.exit(1);
+        }
+        process.stdout.write(`Resumed ${rec.id} from last checkpoint.\n`);
+        process.exit(0);
+    }
+    if (args[0] === 'attach') {
+        const { runAttachCli } = await import('./jobs/attach.js');
+        const code = await runAttachCli(args.slice(1));
+        await shutdownRuntime();
+        process.exit(code);
+    }
+    if (args[0] === 'approve' || args[0] === 'deny') {
+        const { runApproveCli } = await import('./jobs/approve-cli.js');
+        const code = runApproveCli(args.slice(1), args[0] === 'approve' ? 'approved' : 'denied');
+        process.exit(code);
+    }
     if (args[0] === 'config') {
         const { runConfigWizard } = await import('./commands/config.js');
         await runConfigWizard();
         process.exit(0);
     }
+    // Job runner 内部模式：detached 子进程入口。
+    const runnerIdx = args.indexOf('--job-runner');
+    if (runnerIdx !== -1) {
+        const jobId = args[runnerIdx + 1];
+        if (!jobId) {
+            process.stderr.write('mocode: --job-runner requires a job id\n');
+            process.exit(1);
+        }
+        const { isModelConfigured } = await import('./config/index.js');
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured; cannot run background job.\n');
+            process.exit(1);
+        }
+        const { runJobRunner } = await import('./jobs/runner.js');
+        const code = await runJobRunner(jobId, args.includes('--resume'));
+        process.exit(code);
+    }
+    // 调度守护进程内部模式：detached 进程入口。
+    const schedDaemonIdx = args.indexOf('--schedule-daemon');
+    if (schedDaemonIdx !== -1) {
+        const portIdx = args.indexOf('--port');
+        const port = portIdx !== -1 ? Number(args[portIdx + 1]) : undefined;
+        const { runDaemon } = await import('./schedule/daemon.js');
+        runDaemon(port);
+        return; // 常驻：不显式 exit，detached 进程靠事件循环存活
+    }
+    // 后台任务：mocode run [--bg] "任务"。
+    if (args[0] === 'run') {
+        const rest = args.slice(1);
+        const background = rest.includes('--bg');
+        const prompt = firstPositional(rest, { valueFlags: ['--sandbox-root'] });
+        const { isModelConfigured } = await import('./config/index.js');
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured. Set LLM_BASE_URL / LLM_API_KEY / LLM_MODEL ' +
+                '(or run `mocode config`) first.\n');
+            process.exit(1);
+        }
+        if (background) {
+            const { launchBackgroundJob } = await import('./jobs/launch.js');
+            const { resolvePrompt } = await import('./headless.js');
+            const resolved = await resolvePrompt(prompt);
+            if (!resolved) {
+                process.stderr.write('mocode: empty task (use `mocode run --bg "task"` or pipe via stdin)\n');
+                process.exit(1);
+            }
+            const { record } = launchBackgroundJob(resolved, {
+                ...(sessionDirOverride ? { sessionDir: sessionDirOverride } : {}),
+                ...(useWorktree ? { worktree: true } : {}),
+                ...(botName ? { botName } : {}),
+            });
+            process.stdout.write(`Job started: ${record.id}\n  pid: ${record.pid ?? '?'}\n  log: ${record.logPath}\n` +
+                `  track with: mocode /jobs (in TUI) or read the log file\n`);
+            process.exit(0);
+        }
+        // 前台 run：等价 -p，走 headless。
+        const { runHeadless, resolvePrompt } = await import('./headless.js');
+        const resolved = await resolvePrompt(prompt);
+        if (!resolved) {
+            process.stderr.write('mocode: empty task\n');
+            process.exit(1);
+        }
+        const code = await runHeadless({
+            prompt: resolved,
+            json: rest.includes('--json'),
+            verbose: rest.includes('--verbose'),
+            skipPermissions: rest.includes('--dangerously-skip-permissions'),
+            sandboxRootOverride,
+            sessionDir: sessionDirOverride,
+            worktree: useWorktree,
+            ...(botName ? { botName } : {}),
+        });
+        await shutdownRuntime();
+        process.exit(code);
+    }
+    // Headless：-p / --print [prompt]。prompt 缺省时从 stdin（管道）读取。
+    const printIdx = args.findIndex((a) => a === '-p' || a === '--print');
+    if (printIdx !== -1) {
+        // 任意位置的非 flag 参数都作为 prompt（不要求紧跟 -p）；排除 --sandbox-root 的值。
+        const inlinePrompt = firstPositional(args.filter((_, idx) => idx !== printIdx), { valueFlags: ['--sandbox-root'] });
+        const { runHeadless, resolvePrompt } = await import('./headless.js');
+        const { isModelConfigured } = await import('./config/index.js');
+        const prompt = await resolvePrompt(inlinePrompt);
+        if (!prompt) {
+            process.stderr.write('mocode: empty prompt (use -p "..." or pipe via stdin)\n');
+            process.exit(1);
+        }
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured. Set LLM_BASE_URL / LLM_API_KEY / LLM_MODEL ' +
+                '(or run `mocode config`) before using -p.\n');
+            process.exit(1);
+        }
+        const exitCode = await runHeadless({
+            prompt,
+            json: args.includes('--json'),
+            verbose: args.includes('--verbose'),
+            skipPermissions: args.includes('--dangerously-skip-permissions'),
+            sandboxRootOverride,
+            sessionDir: sessionDirOverride,
+            worktree: useWorktree,
+            ...(botName ? { botName } : {}),
+        });
+        await shutdownRuntime();
+        process.exit(exitCode);
+    }
     const i = args.indexOf('--resume');
     if (i !== -1) {
         const { listSessions, loadSession } = await import('./session/index.js');
@@ -97,4 +261,8 @@ async function main() {
     await shutdownRuntime();
     process.exit(0);
 }
-main();
+main().catch((e) => {
+    exitAltScreen();
+    process.stderr.write(`${e instanceof Error ? e.stack || e.message : String(e)}\n`);
+    process.exit(1);
+});

package/dist/jobs/approval.js

@@ -0,0 +1,153 @@
+// 异步审批（park-and-wait）：bg 任务在非 TTY 下需要授权时，不 fail-closed 拒绝，
+// 而是——
+//   1. 写 <jobId>.approval.json 请求（含工具名/参数摘要）；
+//   2. job 记录置 paused，发通知（MOCODE_NOTIFY_WEBHOOK）；
+//   3. 进程挂起，每 1.5s 轮询 <jobId>.approval.decision；
+//   4. `mocode approve <jobId>` 写决定 → checker 在同进程内返回 allow，
+//      agent 带着完整内存历史继续，无需序列化。
+//
+// 已知限制：等待依赖进程存活；机器重启 / 进程被杀则需重新发起（v1 不做断点重放）。
+// MOCODE_APPROVAL_TIMEOUT_MS 可设最大等待（默认 0 = 一直等），超时按 deny。
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config/index.js';
+import { createPermissionChecker } from '../permissions/index.js';
+import { sendNotification } from '../notify/index.js';
+import { jobsRoot, updateJob } from './store.js';
+function requestPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.approval.json`);
+}
+function decisionPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.approval.decision`);
+}
+function argsPreview(tool, args) {
+    if (tool === 'run_command' && typeof args.command === 'string')
+        return args.command.slice(0, 200);
+    if (typeof args.path === 'string')
+        return String(args.path);
+    if (typeof args.url === 'string')
+        return String(args.url);
+    try {
+        return JSON.stringify(args).slice(0, 200);
+    }
+    catch {
+        return '(unserializable args)';
+    }
+}
+function writeApprovalRequest(jobId, tool, args, prompt) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    const payload = {
+        jobId,
+        tool,
+        argsPreview: argsPreview(tool, args),
+        prompt,
+        createdAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(requestPath(jobId), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+export function hasPendingApproval(jobId) {
+    try {
+        fs.accessSync(requestPath(jobId));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** 挂起轮询，直到外部写决定文件；消费后清理请求/决定文件。 */
+async function awaitDecision(jobId) {
+    const dp = decisionPath(jobId);
+    const maxMs = Number(process.env.MOCODE_APPROVAL_TIMEOUT_MS ?? 0);
+    const startedAt = Date.now();
+    for (;;) {
+        try {
+            const v = fs.readFileSync(dp, 'utf8').trim();
+            if (v === 'approved' || v === 'denied') {
+                try {
+                    fs.rmSync(dp);
+                    fs.rmSync(requestPath(jobId));
+                }
+                catch {
+                    // cleanup best-effort
+                }
+                return v;
+            }
+        }
+        catch {
+            // 决定文件尚未出现
+        }
+        if (maxMs > 0 && Date.now() - startedAt > maxMs) {
+            try {
+                fs.rmSync(requestPath(jobId));
+            }
+            catch {
+                // ignore
+            }
+            return 'denied';
+        }
+        await sleep(1500);
+    }
+}
+/**
+ * 异步审批 checker：包正常 checker，命中“需授权”时挂起等待。
+ * 一旦批准，jobApproved=true → 本次运行后续动作不再逐个询问（语义：批准这个任务）。
+ */
+export function createAsyncApprovalChecker(deps) {
+    const inner = createPermissionChecker(config, deps.sandboxRoot);
+    let jobApproved = false;
+    return async (tool, args, signal, options) => {
+        if (jobApproved)
+            return 'allow';
+        const decision = await inner(tool, args, signal, options);
+        if (decision === 'allow')
+            return 'allow';
+        // 需要授权：置 paused + 写请求 + 通知，然后挂起。
+        updateJob(deps.jobId, { status: 'paused' }, { force: true });
+        writeApprovalRequest(deps.jobId, tool.name, args, deps.getPrompt());
+        await sendNotification(config.notifyWebhook, {
+            status: 'waiting',
+            tool: tool.name,
+            prompt: deps.getPrompt(),
+            sessionId: deps.jobId,
+            elapsedMs: 0,
+            model: config.model,
+        });
+        const result = await awaitDecision(deps.jobId);
+        if (result === 'approved') {
+            jobApproved = true;
+            updateJob(deps.jobId, { status: 'running' }, { force: true });
+            return 'allow';
+        }
+        return 'deny';
+    };
+}
+/** CLI/TUI 批准或拒绝：写决定文件。无挂起请求时报错。 */
+export function approveJob(jobId, decision) {
+    if (!hasPendingApproval(jobId))
+        return { ok: false, reason: 'no pending approval for this job' };
+    fs.writeFileSync(decisionPath(jobId), decision, 'utf8');
+    return { ok: true };
+}
+/** 列出所有挂起的审批请求。 */
+export function listPendingApprovals() {
+    let files;
+    try {
+        files = fs.readdirSync(jobsRoot());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        if (!f.endsWith('.approval.json'))
+            continue;
+        try {
+            out.push(JSON.parse(fs.readFileSync(path.join(jobsRoot(), f), 'utf8')));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return out;
+}

package/dist/jobs/approve-cli.js

@@ -0,0 +1,30 @@
+// `mocode approve <jobId>` / `mocode deny <jobId>`：写决定文件，唤醒挂起的 bg job。
+import { approveJob, listPendingApprovals } from './approval.js';
+export function runApproveCli(rawArgs, decision) {
+    let id = rawArgs[0];
+    // 无参数：恰好一个挂起审批时自动选中，否则列出全部。
+    if (!id) {
+        const pending = listPendingApprovals();
+        if (pending.length === 1) {
+            id = pending[0]?.jobId;
+        }
+        else {
+            if (pending.length === 0)
+                process.stdout.write('No pending approvals.\n');
+            else {
+                for (const p of pending) {
+                    process.stdout.write(`  ${p.jobId}  ${p.tool}  ${p.argsPreview.split('\n')[0]}\n`);
+                }
+                process.stdout.write('Usage: mocode approve <jobId>\n');
+            }
+            return pending.length === 1 ? 0 : 1;
+        }
+    }
+    const r = approveJob(id, decision);
+    if (!r.ok) {
+        process.stderr.write(`mocode: ${r.reason ?? 'failed'}\n`);
+        return 1;
+    }
+    process.stdout.write(`${decision === 'approved' ? 'Approved' : 'Denied'} ${id}; job continues.\n`);
+    return 0;
+}

package/dist/jobs/attach.js

@@ -0,0 +1,61 @@
+// C4 Reattach：`mocode attach [id前缀]`——从头回放 job 日志，并实时跟随新输出，
+// 直到 job 进入终态（succeeded/failed/killed）且日志排空后退出。
+//
+// 纯 stdout 流式（与 headless 同性质），故不嵌进全屏 TUI：TUI 内 /jobs attach
+// 只提示在另一终端运行。轮询而非持久句柄——跨平台、且 job 文件由别的进程写入。
+import fs from 'node:fs';
+import { getJob, listJobs } from './store.js';
+const TERMINAL = new Set(['succeeded', 'failed', 'killed']);
+const POLL_MS = 500;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveJob(idPrefix) {
+    if (!idPrefix) {
+        const running = listJobs().filter((j) => !TERMINAL.has(j.status));
+        return running.length === 1 ? running[0] : (listJobs()[0] ?? null);
+    }
+    const matches = listJobs().filter((j) => j.id.startsWith(idPrefix));
+    return matches.length === 1 ? matches[0] : null;
+}
+export async function runAttachCli(rawArgs) {
+    const idPrefix = rawArgs[0];
+    const initial = resolveJob(idPrefix);
+    if (!initial) {
+        process.stderr.write('mocode: no unique matching job to attach\n');
+        return 1;
+    }
+    process.stdout.write(`── attach ${initial.id} ──\n`);
+    let offset = 0;
+    let stableRounds = 0;
+    for (;;) {
+        // 1) 排空当前新增日志。
+        try {
+            const stat = fs.statSync(initial.logPath);
+            if (stat.size > offset) {
+                const buf = Buffer.alloc(stat.size - offset);
+                const fd = fs.openSync(initial.logPath, 'r');
+                fs.readSync(fd, buf, 0, buf.length, offset);
+                fs.closeSync(fd);
+                offset = stat.size;
+                process.stdout.write(buf);
+                stableRounds = 0;
+            }
+        }
+        catch {
+            // 日志暂时不可读（尚未创建/被锁），下轮再试。
+        }
+        // 2) 查最新状态。
+        const job = getJob(initial.id) ?? initial;
+        if (TERMINAL.has(job.status)) {
+            // 终态后再多等两轮，确保末尾输出已落盘并排空，避免丢最后几行。
+            stableRounds += 1;
+            if (stableRounds >= 2) {
+                if (!process.stdout.isTTY)
+                    process.stdout.write(`\n[${job.status}]`);
+                else
+                    process.stdout.write(`\n${job.status}\n`);
+                return job.status === 'succeeded' ? 0 : 1;
+            }
+        }
+        await sleep(POLL_MS);
+    }
+}

package/dist/jobs/checkpoint.js

@@ -0,0 +1,33 @@
+// D3 checkpoint 存储：每个 bg job 在工具批次提交后把完整 history 快照
+// 原子写到 <id>.checkpoint.json。崩溃 / 机器重启后可用
+// `mocode resume-job <id>` 从最后一个 checkpoint 在新进程断点续跑。
+import fs from 'node:fs';
+import path from 'node:path';
+import { jobsRoot } from './store.js';
+function checkpointPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.checkpoint.json`);
+}
+export function writeCheckpoint(jobId, history) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    const target = checkpointPath(jobId);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(history)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function readCheckpoint(jobId) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(checkpointPath(jobId), 'utf8'));
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteCheckpoint(jobId) {
+    try {
+        fs.rmSync(checkpointPath(jobId));
+    }
+    catch {
+        // already gone
+    }
+}

package/dist/jobs/launch.js

@@ -0,0 +1,107 @@
+// 后台任务 launcher / kill：spawn 一个 detached 子进程，父进程退出不影响它
+//（detached + 独立进程组），stdio 重定向到日志文件。
+//
+// 形态自适应：编译产物 src/index.js 存在 → node 直跑；否则（开发态）用 node 加载
+// tsx loader 单进程跑 src/index.ts（不用 tsx CLI：它会 respawn 一个不 hide 的弹窗 node）。
+//
+// 通用件 buildEntryArgs / spawnDetached 也供 schedule 守护进程复用（src/schedule/daemon.ts）。
+import { spawn, spawnSync } from 'node:child_process';
+import { openSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { createJobId, saveJob, updateJob, logPathFor, getJob } from './store.js';
+const jobsDir = path.dirname(fileURLToPath(import.meta.url));
+const srcDir = path.resolve(jobsDir, '..');
+const projectRoot = path.resolve(srcDir, '..');
+const compiledEntry = path.join(srcDir, 'index.js');
+const sourceEntry = path.join(srcDir, 'index.ts');
+const tsxLoader = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'loader.mjs');
+const tsxPreflight = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'preflight.cjs');
+/**
+ * 构造「node …入口… internalArgs」的完整参数。
+ * 生产/开发形态自动选择，调用方只需给入口之后的内部参数（如 ['--job-runner', id]）。
+ */
+export function buildEntryArgs(internalArgs) {
+    if (existsSync(compiledEntry))
+        return [compiledEntry, ...internalArgs];
+    return ['--require', tsxPreflight, '--import', pathToFileURL(tsxLoader).href, sourceEntry, ...internalArgs];
+}
+/**
+ * detached spawn 一个 node 子进程。stdio 重定向到 logPath（stdout+stderr 同一 fd）。
+ * 调用方负责后续 saveJob 等状态回写。
+ */
+export function spawnDetached(internalArgs, logPath, cwd = process.cwd()) {
+    const outFd = openSync(logPath, 'a');
+    const child = spawn(process.execPath, buildEntryArgs(internalArgs), {
+        detached: true,
+        stdio: ['ignore', outFd, outFd],
+        cwd,
+        env: process.env,
+        windowsHide: true,
+    });
+    child.unref();
+    return child;
+}
+/** 创建记录并启动 detached job。spawn 失败时记录置 failed。 */
+export function launchBackgroundJob(prompt, opts = {}) {
+    const id = createJobId();
+    const logPath = logPathFor(id);
+    const record = {
+        id,
+        prompt,
+        status: 'running',
+        cwd: process.cwd(),
+        logPath,
+        startedAt: new Date().toISOString(),
+        ...(opts.sessionDir ? { sessionDir: opts.sessionDir } : {}),
+        ...(opts.worktree ? { worktree: true } : {}),
+        ...(opts.botName ? { botName: opts.botName } : {}),
+    };
+    saveJob(record);
+    const child = spawnDetached(['--job-runner', id], logPath);
+    if (child.pid)
+        saveJob({ ...record, pid: child.pid });
+    child.on('error', () => {
+        updateJob(id, { status: 'failed', finishedAt: new Date().toISOString() }, { force: true });
+    });
+    return { record: { ...record, pid: child.pid }, child };
+}
+/**
+ * 树杀进程并置 killed。
+ * Windows：taskkill /T /F 杀整棵进程树；POSIX：负 pid 杀整个进程组。
+ */
+export function killTree(pid) {
+    if (process.platform === 'win32') {
+        const r = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+        return r.status === 0;
+    }
+    try {
+        process.kill(-pid, 'SIGTERM');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 树杀 job 并置 killed。 */
+export function killBackgroundJob(record) {
+    if (typeof record.pid !== 'number')
+        return false;
+    if (!killTree(record.pid))
+        return false;
+    updateJob(record.id, { status: 'killed', finishedAt: new Date().toISOString() }, { force: true });
+    return true;
+}
+/** D3: 从最后 checkpoint 在新 detached 进程中断点续跑同一 job。 */
+export function resumeBackgroundJob(id) {
+    const record = getJob(id);
+    if (!record)
+        return null;
+    updateJob(id, { status: 'running', finishedAt: undefined, exitCode: undefined }, { force: true });
+    const child = spawnDetached(['--job-runner', id, '--resume'], record.logPath);
+    // 续跑是新 detached 进程，必须回写新 PID，否则后续 /jobs kill 会指向已死的旧 PID。
+    if (child.pid)
+        updateJob(id, { pid: child.pid }, { force: true });
+    return getJob(id);
+}

package/dist/jobs/runner.js

@@ -0,0 +1,59 @@
+// Job runner：detached 子进程的内部入口（`mocode --job-runner <id>`）。
+// 复用 runHeadless 跑任务（输出已被 launcher 重定向到 <id>.log），
+// 结束后按退出码回写 job 终态，并 best-effort 发结束通知（MOCODE_NOTIFY_WEBHOOK）。
+import { getJob, updateJob } from './store.js';
+import { deleteCheckpoint } from './checkpoint.js';
+import { runHeadless } from '../headless.js';
+import { sendNotification } from '../notify/index.js';
+import { config } from '../config/index.js';
+export async function runJobRunner(jobId, resume = false) {
+    const record = getJob(jobId);
+    if (!record) {
+        process.stderr.write(`job runner: unknown job ${jobId}\n`);
+        return 1;
+    }
+    const startedAt = Date.now();
+    let exitCode;
+    try {
+        exitCode = await runHeadless({
+            prompt: record.prompt,
+            json: false,
+            verbose: false,
+            skipPermissions: false,
+            ...(record.sessionDir ? { sessionDir: record.sessionDir } : {}),
+            ...(record.worktree ? { worktree: true } : {}),
+            ...(record.botName ? { botName: record.botName } : {}),
+            jobId,
+            ...(resume ? { resumeFromCheckpoint: true } : {}),
+        });
+    }
+    catch (e) {
+        updateJob(jobId, { status: 'failed', finishedAt: new Date().toISOString(), exitCode: 1 }, { force: true });
+        process.stderr.write(`job runner crashed: ${e instanceof Error ? e.message : String(e)}\n`);
+        await sendNotification(config.notifyWebhook, {
+            status: 'failed',
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+        return 1;
+    }
+    const status = exitCode === 0 ? 'succeeded' : 'failed';
+    // force：被手动 kill 后进程仍可能在此回写，killed 状态由 killBackgroundJob 强制保留。
+    updateJob(jobId, { status, finishedAt: new Date().toISOString(), exitCode }, { force: false });
+    if (status === 'succeeded')
+        deleteCheckpoint(jobId);
+    // 被 kill 的 job（记录仍是 killed）不发常规成功/失败通知，避免与用户意图冲突。
+    const after = getJob(jobId);
+    if (after?.status !== 'killed') {
+        await sendNotification(config.notifyWebhook, {
+            status,
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+    }
+    return exitCode;
+}