@danceiny/gotry 0.2.0-rc.29 → 0.2.0-rc.30

package/dist/scripts/turn-handoff-job-tests.js

@@ -0,0 +1,222 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Context } from '@deepseek-ai/cordis';
+import { LocalJobRegistry } from '@deepseek-ai/dsh-jobs-local';
+import LocalSubprocessRuntime from '@deepseek-ai/dsh-subprocess-local';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { JobId } from '@deepseek-ai/dsh-jobs';
+import { writeTurnHandoffTicket, writeTicketJson, listTurnHandoffTickets } from '../src/turn-deadline.js';
+import { startTurnHandoffJob } from '../src/turn-handoff-job.js';
+import { pathToFileURL } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import { listArtifacts, readArtifact } from '../capabilities/artifacts.js';
+import { apply } from '../src/index.js';
+const root = mkdtempSync(join(tmpdir(), 'gotry-native-handoff-'));
+const ctx = new Context();
+const owner = { id: SessionId('owner'), ctx };
+ctx.provide('agents', { get: (id) => id === 'owner' ? owner : undefined });
+const jobs = new LocalJobRegistry(ctx, { maxConcurrentJobsPerOwner: 10 });
+const subprocess = new LocalSubprocessRuntime(ctx);
+const detach = jobs.attachController('test');
+const planner = join(root, 'planner.mjs');
+const descendants = [];
+writeFileSync(planner, `console.error('DIAGNOSTIC, NOT THE DELIVERABLE');console.log('# Finished plan\\nOriginal request: '+process.argv[2])`);
+process.env.GOTRY_HANDOFF_PLANNER_BIN = planner;
+try {
+    const ticket = await writeTurnHandoffTicket(root, '东北旅行', { workspaceCwd: root, ownerSessionId: owner.id });
+    const running = await startTurnHandoffJob(ctx, ticket, owner, root);
+    assert.equal(running.status, 'running');
+    assert.ok(running.jobId);
+    assert.equal(jobs.list(owner.id)[0].label.includes(ticket.id), true, 'native UI jobs carry the durable ticket identity');
+    assert.deepEqual(jobs.list(SessionId('foreign')), [], 'another session cannot see the task');
+    const jobId = JobId(running.jobId);
+    assert.equal((await jobs.wait(jobId, 10_000, owner.id)).status, 'completed');
+    const views = await listTurnHandoffTickets(root);
+    assert.equal(views[0].status, 'settled');
+    assert.ok(views[0].deliverablePath);
+    assert.match(jobs.read(jobId, owner.id).result ?? '', /present/, 'completion tells the owning session to present the output');
+    const content = readFileSync(views[0].deliverablePath, 'utf8');
+    assert.ok(content.includes('# Finished plan'));
+    assert.ok(!content.includes('DIAGNOSTIC'), 'stderr cannot be accepted as the plan');
+    const artifacts = await listArtifacts({ stateRoot: root, cwd: root });
+    assert.ok(artifacts.artifacts.some(item => item.id === ticket.id), 'handoff deliverable must be discoverable');
+    assert.equal((await readArtifact({ stateRoot: root, cwd: root, path: ticket.id })).ok, true);
+    const legacyRoot = join(root, 'legacy-root');
+    mkdirSync(join(legacyRoot, 'gotry-state', 'async'), { recursive: true });
+    writeFileSync(join(legacyRoot, 'gotry-state', 'async', 'legacy.deliverable.md'), 'Legacy plan');
+    const mixed = await listArtifacts({ stateRoot: legacyRoot, cwd: root });
+    assert.ok(mixed.artifacts.some(item => item.id === 'legacy'), 'existing async outputs stay reachable');
+    assert.ok(mixed.artifacts.some(item => item.id === ticket.id), 'workspace handoffs coexist with configured async state');
+    assert.equal((await readArtifact({ stateRoot: legacyRoot, cwd: root, path: ticket.id })).ok, true);
+    const settled = JSON.parse(readFileSync(join(root, 'gotry-state', 'turn-handoffs', `${ticket.id}.json`), 'utf8'));
+    const before = jobs.list(owner.id).length;
+    assert.equal((await startTurnHandoffJob(ctx, settled, owner, root)).status, 'settled');
+    assert.equal(jobs.list(owner.id).length, before, 'terminal replay must not start more work');
+    writeFileSync(planner, `setTimeout(()=>console.log('must not complete'),60000)`);
+    const pending = await writeTurnHandoffTicket(root, 'cancel', { workspaceCwd: root });
+    const cancellable = await startTurnHandoffJob(ctx, pending, owner, root);
+    jobs.kill(JobId(cancellable.jobId), owner.id);
+    assert.equal((await jobs.wait(JobId(cancellable.jobId), 10_000, owner.id)).status, 'killed');
+    const cancelled = (await listTurnHandoffTickets(root)).find(item => item.id === pending.id);
+    assert.equal(cancelled.status, 'failed', 'cancellation must settle the durable ticket');
+    assert.match(cancelled.error, /cancelled/);
+    // The native API separates direct exit from managed-range quiescence.
+    // A cancelled collector can exit while the host still owns a live child.
+    for (const mode of ['cancel', 'direct-error', 'cleanup-error']) {
+        const actualSpawn = subprocess.spawn;
+        let settleDirect;
+        let releaseRange;
+        let rangeWaited = false;
+        let terminationRequested = false;
+        const directExited = new Promise((resolve, reject) => {
+            settleDirect = () => mode !== 'direct-error' ? resolve({ exitCode: 0, signal: null }) : reject(new Error('synthetic collector direct failure'));
+        });
+        const rangeExited = new Promise(resolve => { releaseRange = resolve; });
+        subprocess.spawn = () => ({
+            stdin: undefined, stdout: undefined, stderr: undefined, control: undefined,
+            done: directExited, collected: {}, terminate() { terminationRequested = true; }, terminateForHostExit() { },
+            async waitForExit() {
+                rangeWaited = true;
+                if (mode === 'cleanup-error')
+                    throw new Error('synthetic range observation failure');
+                await rangeExited;
+                return true;
+            },
+        });
+        let heldJobId;
+        let heldTicketId;
+        try {
+            const heldTicket = await writeTurnHandoffTicket(root, `${mode}: direct exit before range quiescence`, { workspaceCwd: root });
+            heldTicketId = heldTicket.id;
+            const held = await startTurnHandoffJob(ctx, heldTicket, owner, root);
+            heldJobId = JobId(held.jobId);
+            if (mode === 'cancel')
+                jobs.kill(heldJobId, owner.id);
+            settleDirect();
+            if (mode === 'cleanup-error') {
+                assert.equal((await jobs.wait(heldJobId, 10_000, owner.id)).status, 'failed');
+                assert.equal(terminationRequested, true, 'cleanup observation failure must still request termination');
+                assert.match((await listTurnHandoffTickets(root)).find(item => item.id === heldTicket.id).error, /managed-range cleanup could not be confirmed.*synthetic range observation failure/, 'cleanup failure is explicit, never a stopped-process claim');
+                continue;
+            }
+            const activeStatus = mode === 'cancel' ? 'stopping' : 'running';
+            const waitBy = Date.now() + 2000;
+            while (!rangeWaited && jobs.list(owner.id).find(job => job.id === heldJobId)?.status === activeStatus && Date.now() < waitBy) {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+            assert.equal(rangeWaited, true, `${mode}: direct exit must join the host-owned process range`);
+            assert.equal(jobs.list(owner.id).find(job => job.id === heldJobId)?.status, activeStatus, `${mode}: native outcome cannot settle while the managed range is live`);
+            assert.equal((await listTurnHandoffTickets(root)).find(item => item.id === heldTicket.id).status, 'running', `${mode}: durable settlement waits for managed-range quiescence too`);
+            assert.equal(terminationRequested, true, `${mode}: cleanup must be initiated`);
+        }
+        finally {
+            settleDirect();
+            releaseRange();
+            if (heldJobId)
+                await jobs.wait(heldJobId, 10_000, owner.id);
+            subprocess.spawn = actualSpawn;
+        }
+        if (mode === 'direct-error') {
+            assert.equal(jobs.list(owner.id).find(job => job.id === heldJobId)?.status, 'failed');
+            assert.match((await listTurnHandoffTickets(root)).find(item => item.id === heldTicketId).error, /synthetic collector direct failure/, 'keep the direct diagnostic after cleanup');
+        }
+    }
+    writeFileSync(planner, `setTimeout(()=>console.log('late'),60000)`);
+    process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS = '50';
+    const timeoutTicket = await writeTurnHandoffTicket(root, 'timeout', { workspaceCwd: root });
+    const timeoutJob = await startTurnHandoffJob(ctx, timeoutTicket, owner, root);
+    assert.equal((await jobs.wait(JobId(timeoutJob.jobId), 10_000, owner.id)).status, 'failed');
+    assert.match((await listTurnHandoffTickets(root)).find(item => item.id === timeoutTicket.id).error, /timed out/);
+    delete process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS;
+    // Match gotry-inner's detached DSH child, inherited pipes and real TERM
+    // forwarding bound. Its child ignores TERM, requiring wrapper-owned KILL.
+    if (process.platform !== 'win32') {
+        const pidFile = join(root, 'descendant.pid');
+        const readyFile = join(root, 'descendant.ready');
+        const lifecycle = pathToFileURL(join(import.meta.dirname, '..', '..', 'bin', 'gotry-process-liveness.js')).href;
+        const childCode = `const fs=require('node:fs');process.on('SIGTERM',()=>{});fs.writeFileSync(${JSON.stringify(readyFile)},'ready');setInterval(()=>{},1000)`;
+        writeFileSync(planner, `
+      import {writeFileSync} from 'node:fs';
+      import {spawnOwnedChild,terminateOwnedChild} from ${JSON.stringify(lifecycle)};
+      const {child,groupPid}=spawnOwnedChild(process.execPath,['-e',${JSON.stringify(childCode)}],{stdio:['ignore','inherit','inherit']});
+      writeFileSync(${JSON.stringify(pidFile)},String(child.pid));
+      let stopping=false;
+      process.on('SIGTERM',()=>{if(stopping)return;stopping=true;void terminateOwnedChild({child,groupPid}).then(()=>process.exit(143))});
+      setInterval(()=>{},1000);
+    `);
+        for (const mode of ['timeout', 'cancel']) {
+            rmSync(readyFile, { force: true });
+            rmSync(pidFile, { force: true });
+            if (mode === 'timeout')
+                process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS = '1000';
+            else
+                delete process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS;
+            const nestedTicket = await writeTurnHandoffTicket(root, `nested ${mode}`, { workspaceCwd: root });
+            const nestedJob = await startTurnHandoffJob(ctx, nestedTicket, owner, root);
+            const readyBy = Date.now() + 5000;
+            while (!existsSync(readyFile) && Date.now() < readyBy)
+                await new Promise(resolve => setTimeout(resolve, 20));
+            assert.ok(existsSync(readyFile), 'detached stubborn child actually started');
+            const pid = Number(readFileSync(pidFile, 'utf8'));
+            descendants.push(pid);
+            if (mode === 'cancel')
+                jobs.kill(JobId(nestedJob.jobId), owner.id);
+            const terminal = await jobs.wait(JobId(nestedJob.jobId), 15_000, owner.id);
+            assert.equal(terminal.status, mode === 'cancel' ? 'killed' : 'failed');
+            const processRows = execFileSync('ps', ['-eo', 'pid=,ppid=,pgid=,stat='], { encoding: 'utf8', timeout: 2000 })
+                .split('\n').filter(line => Number(line.trim().split(/\s+/)[2]) === pid);
+            assert.throws(() => process.kill(-pid, 0), { code: 'ESRCH' }, `${mode} cannot report terminal while the detached planner child is alive; group members=${JSON.stringify(processRows)}`);
+            const view = (await listTurnHandoffTickets(root)).find(item => item.id === nestedTicket.id);
+            assert.equal(view.status, 'failed');
+            assert.match(view.error, mode === 'cancel' ? /cancelled/ : /timed out/);
+        }
+        delete process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS;
+    }
+    // A fresh host can reuse a native counter id. Its new job must never make
+    // an older persisted running ticket look active or offer the wrong controls.
+    writeFileSync(planner, `setTimeout(()=>console.log('late'),60000)`);
+    const freshTicket = await writeTurnHandoffTicket(root, 'new host trip', { workspaceCwd: root });
+    const fresh = await startTurnHandoffJob(ctx, freshTicket, owner, root);
+    const stale = await writeTurnHandoffTicket(root, 'old interrupted trip', { workspaceCwd: root });
+    await writeTicketJson(root, { ...stale, status: 'running', jobId: fresh.jobId });
+    let listTool;
+    const queryCtx = {
+        tools: { register(tool) { if (tool.name === 'gotry_turn_handoff_list')
+                listTool = tool; } },
+        systemPrompt: { variable() { } }, on() { return () => { }; },
+        get: (name) => name === 'jobs' ? jobs : undefined,
+    };
+    apply(queryCtx, { stateRoot: root, timeoutMs: 1000, hbcliBin: '', sessionAccess: 'off' });
+    const oldQuery = await listTool.execute({ ticketId: stale.id }, { agent: owner });
+    assert.match(oldQuery.summary, /已中断/, 'reused native id does not identify another saved ticket');
+    const newQuery = await listTool.execute({ ticketId: fresh.id }, { agent: owner });
+    assert.match(newQuery.summary, /后台任务/, 'exact current ticket still has live controls');
+    jobs.kill(JobId(fresh.jobId), owner.id);
+    await jobs.wait(JobId(fresh.jobId), 15_000, owner.id);
+    const unhosted = new Context();
+    const waiting = await writeTurnHandoffTicket(root, 'no execution services');
+    assert.equal((await startTurnHandoffJob(unhosted, waiting, owner, root)).status, 'open');
+    assert.equal((await listTurnHandoffTickets(root)).find(item => item.id === waiting.id).jobId, undefined);
+    await unhosted.fiber.dispose();
+    // A missing controller creates no execution resource and no running claim.
+    detach();
+    const queued = await writeTurnHandoffTicket(root, 'queued');
+    const rejected = await startTurnHandoffJob(ctx, queued, owner, root);
+    assert.equal(rejected.status, 'failed');
+    assert.ok(rejected.error);
+    console.log('native handoff job tests: OK (real registry/process, ownership, managed-range quiescence, settlement, artifacts, idempotence, cancellation, controller rejection)');
+}
+finally {
+    delete process.env.GOTRY_HANDOFF_PLANNER_BIN;
+    delete process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS;
+    for (const pid of descendants) {
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch { }
+    }
+    await ctx.fiber.dispose();
+    rmSync(root, { recursive: true, force: true });
+}

package/dist/scripts/turn-handoff-web-e2e.js

@@ -0,0 +1,240 @@
+/** Isolated DSH Web handoff journey. Synthetic model/planner; real host, jobs,
+ * processes, composer, completion notice, presentation and artifact tools.
+ * Never a live travel-research or published-package acceptance receipt. */
+import assert from 'node:assert/strict';
+import { execFileSync, spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import puppeteer from 'puppeteer-core';
+const ROOT = join(import.meta.dirname, '..', '..');
+const sourceSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: ROOT, encoding: 'utf8' }).trim();
+const sourceDirty = execFileSync('git', ['status', '--porcelain'], { cwd: ROOT, encoding: 'utf8' }).trim() !== '';
+const CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const evidence = process.env.GOTRY_HANDOFF_WEB_E2E_OUT ?? mkdtempSync(join(tmpdir(), 'gotry-handoff-web-evidence-'));
+const isolated = mkdtempSync(join(tmpdir(), 'gotry-handoff-web-'));
+const product = join(isolated, 'product');
+const hostCwd = join(isolated, 'host');
+const workspace = join(isolated, 'workspace');
+const stateRoot = join(isolated, 'handoff-state');
+const home = join(isolated, 'home');
+const dshHome = join(isolated, 'dsh');
+for (const dir of [evidence, product, hostCwd, workspace, stateRoot, home, dshHome])
+    mkdirSync(dir, { recursive: true });
+const planner = join(isolated, 'planner.mjs');
+writeFileSync(planner, `console.error('DIAGNOSTIC_NOT_A_PLAN');setTimeout(()=>console.log('# Completed synthetic plan\\nWorkspace: '+process.cwd()+'\\n'+process.argv[2]),15000)`);
+const bodies = [];
+const served = [];
+let phase = 0;
+let serverLog = '';
+let notified = false;
+let relayError;
+let browser;
+let page;
+let child;
+const pageErrors = [];
+const sse = (data) => `data: ${JSON.stringify(data)}\n\n`;
+function response(name, input = {}, text = '') {
+    const block = name ? { type: 'tool_use', id: `handoff-${phase}`, name, input } : { type: 'text', text };
+    return sse({ type: 'message_start', message: { usage: { input_tokens: 10 } } })
+        + sse({ type: 'content_block_start', index: 0, content_block: block })
+        + sse({ type: 'content_block_stop', index: 0 })
+        + sse({ type: 'message_delta', delta: { stop_reason: name ? 'tool_use' : 'end_turn' }, usage: { output_tokens: 10 } })
+        + sse({ type: 'message_stop' }) + 'data: [DONE]\n\n';
+}
+const ticketDir = join(stateRoot, 'gotry-state', 'turn-handoffs');
+function ticket() {
+    const names = existsSync(ticketDir) ? readdirSync(ticketDir).filter(name => name.endsWith('.json')) : [];
+    assert.equal(names.length, 1, 'one durable ticket');
+    return JSON.parse(readFileSync(join(ticketDir, names[0]), 'utf8'));
+}
+const relay = createServer((req, res) => {
+    if (req.method !== 'POST' || !req.url?.endsWith('/messages')) {
+        res.writeHead(404).end();
+        return;
+    }
+    const chunks = [];
+    req.on('data', chunk => chunks.push(Buffer.from(chunk)));
+    req.on('end', () => {
+        try {
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            bodies.push(body);
+            res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+            const names = (body.tools ?? []).map((tool) => tool.name ?? tool.function?.name);
+            const messages = JSON.stringify(body.messages ?? []);
+            const isPlanner = names.includes('write') || names.includes('present') || names.includes('job_output');
+            if (!isPlanner) {
+                res.end(response(undefined, {}, 'Synthetic title'));
+                return;
+            }
+            let name;
+            let input = {};
+            let final = '';
+            let delay = 0;
+            if (phase === 0) {
+                name = 'write';
+                input = { file_path: 'exploration.md', content: '# Synthetic exploration\nWork hours 9-18 CST; original request retained.' };
+                // Cross the foreground deadline deliberately, while giving the later
+                // completion/query turn enough time for several native tool round trips.
+                delay = 5500;
+            }
+            else if (phase === 1) {
+                name = 'present';
+                input = { files: [{ path: join(workspace, 'exploration.md'), description: '探索稿' }] };
+            }
+            else if (phase === 2) {
+                final = '探索稿已保存，后台任务已启动。';
+            }
+            else if (phase === 3) {
+                assert.match(messages, /finished.*completed/, 'native completion notice wakes the owning session');
+                notified = true;
+                name = 'job_output';
+                input = { job_id: ticket().jobId, wait: false };
+            }
+            else if (phase === 4) {
+                assert.ok(messages.includes('Planning completed:'), 'native job result reaches the model');
+                name = 'present';
+                input = { files: [{ path: join(ticketDir, ticket().deliverableFile), description: '最终交付物' }] };
+            }
+            else if (phase === 5) {
+                name = 'gotry_artifacts_list';
+                input = { limit: 20 };
+            }
+            else if (phase === 6) {
+                assert.ok(messages.includes(ticket().id), 'artifact list includes the same ticket');
+                name = 'gotry_artifacts_read';
+                input = { path: ticket().id };
+            }
+            else {
+                final = '最终规划已完成并展示，可按工单重新读取。';
+            }
+            if (name) {
+                assert.ok(names.includes(name), `${name} remains available in phase ${phase}: ${names}`);
+                served.push(name);
+            }
+            phase++;
+            setTimeout(() => res.end(response(name, input, final)), delay);
+        }
+        catch (error) {
+            relayError = String(error);
+            res.end(response(undefined, {}, 'RELAY_TEST_FAILURE'));
+        }
+    });
+});
+try {
+    assert.ok(existsSync(CHROME), 'Chrome is required for the browser receipt');
+    assert.ok(existsSync(join(ROOT, 'dist/src/turn-handoff-job.js')), 'build dist before the browser journey');
+    // The real source launcher normally uses ts/dsh-runtime as host cwd. Run the
+    // exact built package in a private layout instead, so even legacy state reads
+    // and process-guard logs cannot touch the founder's runtime directory.
+    const packed = JSON.parse(execFileSync('npm', ['pack', '--ignore-scripts', '--json', '--pack-destination', isolated], { cwd: ROOT, encoding: 'utf8' }))[0];
+    execFileSync('tar', ['xzf', join(isolated, packed.filename), '--strip-components=1', '-C', product]);
+    symlinkSync(join(ROOT, 'node_modules'), join(product, 'node_modules'), 'dir');
+    await new Promise(resolve => relay.listen(0, '127.0.0.1', resolve));
+    const port = relay.address().port;
+    child = spawn(process.execPath, [join(product, 'bin/gotry-inner.js'), 'web', '--no-open', '--port', '0'], {
+        cwd: hostCwd,
+        env: { ...process.env, HOME: home, DSH_HOME: dshHome, GOTRY_SETUP_SKIP: '1', GOTRY_ONBOARDING_SKIP: '1',
+            GOTRY_SESSION_LIVE: '0', GOTRY_HBCLI_LIVE: '0', GOTRY_HOTELBYTE_SKILLS_LIVE: '0',
+            LLM_API_KEY: 'synthetic-only', LLM_BASE_URL: `http://127.0.0.1:${port}/v1`, LLM_MODEL: 'synthetic-handoff-web',
+            GOTRY_LLM_MODEL: 'synthetic-handoff-web', DEEPSEEK_API_KEY: 'synthetic-only', DEEPSEEK_BASE_URL: `http://127.0.0.1:${port}/v1`,
+            GOTRY_TURN_HANDOFF_ROOT: stateRoot, GOTRY_HANDOFF_PLANNER_BIN: planner,
+            GOTRY_TURN_DEADLINE_SOFT_MS: '2000', GOTRY_TURN_DEADLINE_HARD_MS: '5000' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const url = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Web startup timed out: ${serverLog.slice(-4000)}`)), 30000);
+        const collect = (chunk) => {
+            serverLog += chunk.toString();
+            const match = serverLog.match(/dsh web: (http:\/\/127\.0\.0\.1:\d+\/\?token=[^\s)]+)/);
+            if (match) {
+                clearTimeout(timer);
+                resolve(match[1]);
+            }
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.once('error', reject);
+    });
+    browser = await puppeteer.launch({ executablePath: CHROME, headless: true, userDataDir: join(isolated, 'chrome'), args: ['--no-sandbox', '--disable-gpu'] });
+    page = await browser.newPage();
+    page.setDefaultTimeout(30000);
+    page.on('pageerror', (error) => pageErrors.push(error.message));
+    await page.goto(url, { waitUntil: 'networkidle2' });
+    const dismiss = async () => {
+        await page.waitForFunction(() => [...document.querySelectorAll('button')].some(node => ['继续', 'Continue'].includes(node.textContent?.trim() ?? '')));
+        await page.evaluate(() => [...document.querySelectorAll('button')].find(node => ['继续', 'Continue'].includes(node.textContent?.trim() ?? ''))?.click());
+    };
+    await dismiss();
+    const registered = await page.evaluate(async (path) => {
+        const response = await fetch('/api/workspace/create', { method: 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ type: 'client-request', rpcId: crypto.randomUUID(), method: 'workspace/create', payload: { args: { request: { path } } } }) });
+        return response.json();
+    }, workspace);
+    assert.equal(registered.result?.ok, true, 'register the isolated workspace through public RPC');
+    await page.reload({ waitUntil: 'networkidle2' });
+    await page.waitForFunction(() => [...document.querySelectorAll('button')].some(node => /Default workspace|默认工作区/.test(node.textContent ?? '')));
+    await page.evaluate(() => [...document.querySelectorAll('button')].find(node => /Default workspace|默认工作区/.test(node.textContent ?? ''))?.click());
+    await page.waitForFunction((title) => [...document.querySelectorAll('[role="menuitem"], [role="option"], button')].some(node => node.textContent?.trim() === title), {}, basename(workspace));
+    await page.evaluate((title) => [...document.querySelectorAll('[role="menuitem"], [role="option"], button')].find(node => node.textContent?.trim() === title)?.click(), basename(workspace));
+    await page.waitForSelector('[contenteditable="true"]');
+    await page.click('[contenteditable="true"]');
+    await page.keyboard.type('12月初阿联酋国庆，借5天IRW远程办公和请假回国十几天，去东北长春泡澡，女朋友从南京过去，请探索具体规划。工作时间9-18 CST。');
+    await page.click('button[aria-label="发送消息"], button[aria-label="Send message"]');
+    await page.waitForFunction(() => /探索稿已保存|RELAY_TEST_FAILURE/.test(document.body.innerText), { timeout: 30000 });
+    assert.equal(relayError, undefined);
+    assert.ok(existsSync(join(workspace, 'exploration.md')), 'deadline draft really exists in the original workspace');
+    const running = ticket();
+    assert.equal(running.status, 'running');
+    assert.ok(running.jobId);
+    await page.screenshot({ path: join(evidence, 'running.png'), fullPage: true });
+    await page.waitForFunction(() => /最终规划已完成并展示|RELAY_TEST_FAILURE/.test(document.body.innerText), { timeout: 60000 });
+    assert.equal(relayError, undefined);
+    const settled = ticket();
+    assert.equal(settled.status, 'settled');
+    const outputPath = join(ticketDir, settled.deliverableFile);
+    const output = readFileSync(outputPath, 'utf8');
+    assert.ok(output.includes('Completed synthetic plan') && output.includes(workspace));
+    assert.ok(output.includes('9-18 CST'), 'prior constraints travel to the worker');
+    assert.ok(!output.includes('DIAGNOSTIC_NOT_A_PLAN'));
+    assert.ok(notified);
+    assert.deepEqual(pageErrors, []);
+    const fileCards = await page.evaluate(() => [...document.querySelectorAll('button')].map(node => ({ text: node.textContent, label: node.getAttribute('aria-label'), title: node.getAttribute('title') })));
+    const openLabel = await page.evaluate((path) => {
+        const button = [...document.querySelectorAll('button')].find(node => [node.getAttribute('title'), node.getAttribute('aria-label'), node.textContent].some(text => text?.includes(path) || text?.includes(path.split('/').at(-1))));
+        if (!button)
+            return false;
+        button.click();
+        return true;
+    }, outputPath);
+    assert.ok(openLabel, `native file card must offer the final output: ${JSON.stringify(fileCards).slice(-4000)}`);
+    await page.waitForFunction(() => document.body.innerText.includes('Completed synthetic plan'), { timeout: 30000 });
+    await page.screenshot({ path: join(evidence, 'completed-preview.png'), fullPage: true });
+    writeFileSync(join(evidence, 'receipt.json'), JSON.stringify({ passed: true, evidence: 'synthetic_fixture',
+        runtime: 'source-built DSH Web', layout: 'isolated tarball with repository dependencies', sourceSha, sourceDirty, nodeVersion: process.version, served, notified, ticketId: settled.id, jobId: settled.jobId,
+        draftWritten: true, finalPresented: true, previewOpened: true, status: settled.status, pageErrors }, null, 2));
+    console.log(`handoff web E2E: OK; synthetic receipt: ${evidence}`);
+}
+catch (error) {
+    if (page) {
+        await page.screenshot({ path: join(evidence, 'failure.png'), fullPage: true }).catch(() => { });
+        writeFileSync(join(evidence, 'failure-dom.txt'), await page.evaluate(() => document.body.innerText + '\n' + JSON.stringify([...document.querySelectorAll('button')].map(node => ({ text: node.textContent, label: node.getAttribute('aria-label'), title: node.getAttribute('title') })))).catch(() => ''));
+    }
+    writeFileSync(join(evidence, 'failure.json'), JSON.stringify({ error: String(error), phase, served, pageErrors,
+        serverLog: serverLog.replace(/token=[^\s)]+/g, 'token=[redacted]').slice(-5000) }, null, 2));
+    writeFileSync(join(evidence, 'requests.json'), JSON.stringify(bodies, null, 2));
+    throw error;
+}
+finally {
+    await browser?.close();
+    if (child && child.exitCode === null) {
+        const closed = new Promise(resolve => child.once('close', () => resolve()));
+        child.kill('SIGTERM');
+        const timer = setTimeout(() => child.kill('SIGKILL'), 5000);
+        await closed;
+        clearTimeout(timer);
+    }
+    await new Promise(resolve => relay.close(() => resolve()));
+    rmSync(isolated, { recursive: true, force: true });
+}

package/dist/src/index.js

@@ -48,6 +48,7 @@ import { factsFromFlyai, factsFromHotel, factsFromSession, factsFromSessionTrain
 import { hasRecognizedAvailableSeat } from '../capabilities/session/adapters/rail-12306.js';
 import { gateArtifact } from './artifact-gate.js';
 import { installTurnDeadline, listTurnHandoffTickets } from './turn-deadline.js';
+import { startTurnHandoffJob } from './turn-handoff-job.js';
 import { noteChannelVerdict, recordChannelEvent, readLatestChannelEvents } from '../capabilities/channel-health.js';
 import { routingAdvice, renderRoutingCard, toolRoutingHeadline, persistedDownChannels } from '../capabilities/channel-registry.js';
 import { registerBenchmarkEnvironmentBridge } from './benchmark-environment-bridge.js';
@@ -433,7 +434,11 @@ export function apply(ctx, config, seams = {}) {
         ? { fixedPolicy: { softMs: 300_000, hardMs: 900_000, exit: 'converge' } }
         : rawBenchmarkEnvironmentConfigPath.trim()
             ? { fixedPolicy: benchmarkPinnedPolicy() }
-            : { stateRoot: process.env.GOTRY_TURN_HANDOFF_ROOT ?? config.stateRoot ?? '.' });
+            : { stateRoot: process.env.GOTRY_TURN_HANDOFF_ROOT ?? config.stateRoot ?? '.',
+                // A one-shot headless process exits after its final response and cannot
+                // own ongoing work. Keep that ticket queued for explicit collection.
+                startHandoff: (ticket, agent, root) => typeof ctx.get === 'function' && ctx.get('connection')
+                    ? startTurnHandoffJob(ctx, ticket, agent, root) : Promise.resolve(ticket) });
     if (rawBenchmarkEnvironmentConfigPath.trim()) {
         // Benchmark mode is a deliberately minimal kernel: only the model
         // override and the environment bridge are installed besides the pinned
@@ -987,8 +992,8 @@ export function apply(ctx, config, seams = {}) {
     registerGuarded(defineTool({
         name: 'gotry_turn_handoff_list',
         description: 'List background deep-planning handoff tickets (read-only). Call this whenever the user asks about '
-            + 'a previously handed-off plan («规划好了吗» / «上次那个行程»): open = still being worked in the '
-            + 'background (ETA ' + '约 1 小时' + '), settled = deliverable ready (excerpt included, full text in the '
+            + 'a previously handed-off plan («规划好了吗» / «上次那个行程»): open = queued, worker not started; '
+            + 'running = started with a native job id (use job_list for live status); settled = deliverable ready (excerpt included, full text in the '
             + 'ticket\'s .deliverable.md), failed = honest failure note. Never fabricate a deliverable that is not here.',
         // D-30 第三刀(issue #112):query blob → 平铺 typed;全字段可选 → interpretArgs 容忍层(同 session 刀法)
         parameters: {
@@ -998,9 +1003,10 @@ export function apply(ctx, config, seams = {}) {
             schema: { type: 'json' },
             render: (_args, value) => [{ type: 'text', text: String(value.summary ?? '') }],
         },
-        async execute(args, _exec) {
+        async execute(args, exec) {
             const q = interpretArgs(args);
-            const root = process.env.GOTRY_TURN_HANDOFF_ROOT ?? config.stateRoot ?? '.';
+            const configuredRoot = process.env.GOTRY_TURN_HANDOFF_ROOT ?? config.stateRoot ?? '.';
+            const root = configuredRoot === '.' ? sessionCwd(exec) ?? '.' : configuredRoot;
             const all = await listTurnHandoffTickets(root);
             const tickets = (q.ticketId ? all.filter(t => t.id === q.ticketId) : all).slice(0, 10);
             if (tickets.length === 0) {
@@ -1014,10 +1020,19 @@ export function apply(ctx, config, seams = {}) {
             const lines = tickets.map(t => {
                 const head = `[${t.status}] ${t.id} ${t.objective.slice(0, 40)}`;
                 if (t.status === 'open')
-                    return `${head}——后台规划中,ETA ${t.etaLabel}`;
+                    return `${head}——待启动，后台尚未运行`;
+                if (t.status === 'running') {
+                    const owner = exec.agent;
+                    // Native counters restart with the host. A recycled id alone is not
+                    // the durable ticket's identity and must not offer another trip's job.
+                    const live = owner && ctx.get('jobs')?.list(owner.id).some(job => job.id === t.jobId
+                        && job.owner === owner.id && job.kind === 'gotry-planning' && job.label.startsWith(`${t.id}: `)
+                        && (job.status === 'running' || job.status === 'stopping'));
+                    return `${head}——${live ? `后台任务 ${t.jobId}，预计 ${t.etaLabel}` : '运行记录已中断，当前没有活跃后台任务'} `;
+                }
                 if (t.status === 'failed')
                     return `${head}——失败:${t.error ?? '未知原因'}(请重新发起规划)`;
-                return `${head}——已交付,摘要:${(t.deliverableExcerpt ?? '').slice(0, 120).replace(/\n/g, ' ')}`;
+                return `${head}——${t.deliverablePath ? `已交付：${t.deliverablePath}` : '交付文件缺失'}，摘要:${(t.deliverableExcerpt ?? '').slice(0, 120).replace(/\n/g, ' ')}`;
             });
             return {
                 ok: true, count: tickets.length, tickets,
@@ -2355,6 +2370,7 @@ export function apply(ctx, config, seams = {}) {
             try {
                 r = await listArtifacts({
                     stateRoot: config.stateRoot ?? '.',
+                    handoffRoot: process.env.GOTRY_TURN_HANDOFF_ROOT ?? ((config.stateRoot ?? '.') === '.' ? sessionCwd(exec) ?? '.' : config.stateRoot),
                     cwd: sessionCwd(exec),
                     limit: q.limit,
                     offset: q.offset,
@@ -2448,7 +2464,7 @@ export function apply(ctx, config, seams = {}) {
                 throw new Error('gotry_artifacts_read requires path');
             if (!q.path)
                 return JSON.parse(JSON.stringify({ ok: false, error: 'path 必填(来自 gotry_artifacts_list)' }));
-            const r = await readArtifact({ stateRoot: config.stateRoot ?? '.', cwd: sessionCwd(exec), path: q.path, offset: q.offset, limit: q.limit });
+            const r = await readArtifact({ stateRoot: config.stateRoot ?? '.', handoffRoot: process.env.GOTRY_TURN_HANDOFF_ROOT ?? ((config.stateRoot ?? '.') === '.' ? sessionCwd(exec) ?? '.' : config.stateRoot), cwd: sessionCwd(exec), path: q.path, offset: q.offset, limit: q.limit });
             if (!r.ok)
                 return JSON.parse(JSON.stringify(r));
             // 身份/来源展示(issue #285 第 1 条「显示身份/来源」):行号视图保留 read 卡的