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

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/artifact-delivery.js

@@ -0,0 +1,26 @@
+import { realpathSync, statSync } from 'node:fs';
+import { isAbsolute, relative, sep } from 'node:path';
+export function registerArtifactDeliveries(ctx) {
+    // Tool-registration-only hosts have no conversation event surface.
+    if (typeof ctx.on !== 'function')
+        return;
+    ctx.on('tools/result', (exec, result) => {
+        if (result.isError || exec.signal.aborted || !['gotry_itinerary_render', 'gotry_itinerary_deck_render'].includes(exec.name))
+            return;
+        const value = result.value;
+        const session = exec.agent?.session, cwd = session?.header.cwd;
+        if (!session || !cwd || !isAbsolute(cwd) || value?.ok !== true || typeof value.path !== 'string' || !isAbsolute(value.path))
+            return;
+        const boundary = ctx.get('sessionProjections')?.stateOf(session, 'turnBoundary');
+        if (!boundary || boundary.openTurnStartSeq === null)
+            return;
+        try {
+            const path = realpathSync(value.path), root = realpathSync(cwd), inside = relative(root, path);
+            if (inside === '..' || inside.startsWith('..' + sep) || isAbsolute(inside) || !statSync(path).isFile())
+                return;
+            session.append('deliverables/presented', { turn: boundary.lastTurn, callId: exec.callId,
+                files: [{ path: value.path, description: 'GoTry itinerary' }] });
+        }
+        catch { /* A deleted or escaped file cannot become a delivery. */ }
+    });
+}

package/dist/src/gotry-web-api.js

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute } from 'node:path';
+import { verifyFlyaiCandidate } from '../../bin/gotry-flyai-verification.js';
+import { listArtifacts } from '../capabilities/artifacts.js';
+import { atomicWriteJson, clearFlyaiKey, displayEndpoint, endpointFingerprint, flyaiConfigPath, isPlaceholderFlyaiKey, maskFlyaiKey, readFlyaiConfig, readFlyaiVerification, removeFlyaiVerification, resolveFlyaiEndpoint, resolveFlyaiKey, saveFlyaiKey, sha256Hex, writeFlyaiVerification, } from '../capabilities/flyai-config.js';
+const json = (value, status = 200) => Response.json(value, { status, headers: { 'cache-control': 'no-store' } });
+const rejection = (error, status = 400) => json({ ok: false, error }, status);
+const BODY_LIMIT = 8192;
+async function readInput(request) {
+    if (request.headers.get('content-type')?.split(';')[0].trim() !== 'application/json')
+        return rejection('需要 JSON 请求。', 415);
+    const reader = request.body?.getReader();
+    if (!reader)
+        return rejection('请求为空。');
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            bytes += chunk.value.byteLength;
+            if (bytes > BODY_LIMIT) {
+                await reader.cancel();
+                return rejection('请求过大。', 413);
+            }
+            chunks.push(chunk.value);
+        }
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : rejection('请求无效。');
+    }
+    catch {
+        return rejection('请求无效。');
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export function createGotryWebHandlers(options) {
+    const homeDir = options.homeDir ?? homedir(), env = options.env ?? process.env;
+    const paths = { homeDir, env }, configPath = flyaiConfigPath(homeDir);
+    let mutations = Promise.resolve();
+    const status = () => {
+        const current = resolveFlyaiKey(paths), endpoint = resolveFlyaiEndpoint(paths), receipt = readFlyaiVerification(homeDir);
+        const matches = current.key && receipt?.keySha256 === sha256Hex(current.key) && receipt.source === current.source
+            && receipt.endpointFingerprint === endpointFingerprint(endpoint.url) && receipt.endpointDebug === endpoint.debug;
+        return { ok: true, configured: Boolean(current.key), verified: Boolean(matches && receipt?.verdict === 'verified'),
+            writable: current.source !== 'env' && current.source !== 'env-debug' && process.platform !== 'win32', source: current.source,
+            endpoint: displayEndpoint(endpoint.url), endpointDebug: endpoint.debug,
+            ...(matches && receipt ? { checkedAt: receipt.at, verdict: receipt.verdict } : {}) };
+    };
+    const bytesAt = () => existsSync(configPath) ? readFileSync(configPath, 'utf8') : undefined;
+    async function mutate(input, signal) {
+        if (signal.aborted)
+            return rejection('操作已取消。', 409);
+        if (!status().writable)
+            return rejection('当前 Key 由环境变量提供或此平台不支持安全写入。', 409);
+        if (input.action === 'clear') {
+            const result = clearFlyaiKey(paths);
+            if (!result.ok)
+                return rejection('无法清除配置，请检查本机配置文件及权限。', 409);
+            removeFlyaiVerification(homeDir);
+            return json(status());
+        }
+        const key = typeof input.key === 'string' ? input.key.trim() : '';
+        if (!key || key.length > 2048 || /[\r\n\0]/.test(key) || isPlaceholderFlyaiKey(key))
+            return rejection('请粘贴控制台中的真实 API Key。');
+        const before = readFlyaiConfig(configPath);
+        if (!before.ok)
+            return rejection('原配置损坏，已保留原文件，请先修复。', 409);
+        const previousBytes = bytesAt(), endpoint = resolveFlyaiEndpoint(paths), fingerprint = endpointFingerprint(endpoint.url);
+        if (!fingerprint)
+            return rejection('当前服务地址无效。', 409);
+        const verify = await verifyFlyaiCandidate(key, { env: { ...env, HOME: homeDir }, signal });
+        if (signal.aborted || verify.verdict !== 'hit')
+            return json({ ok: false, verdict: signal.aborted ? 'cancelled' : verify.verdict,
+                error: signal.aborted ? '验证已取消，旧配置保留。' : verify.error ?? '验证失败，旧配置保留。' }, 422);
+        if (!status().writable || bytesAt() !== previousBytes || fingerprint !== endpointFingerprint(resolveFlyaiEndpoint(paths).url)) {
+            return rejection('配置在验证期间发生变化，请重新读取后再试。', 409);
+        }
+        const saved = saveFlyaiKey(key, paths);
+        if (!saved.ok)
+            return rejection('安全保存失败，旧配置保留，请检查本机权限。', 409);
+        const receiptSaved = writeFlyaiVerification({ schema: 'gotry.flyai-verification.v1', source: 'config',
+            keySha256: sha256Hex(key), maskedKey: maskFlyaiKey(key), verdict: 'verified', endpointFingerprint: fingerprint,
+            endpointDebug: endpoint.debug, at: new Date().toISOString() }, homeDir);
+        if (!receiptSaved) {
+            const restored = previousBytes === undefined
+                ? (() => { try {
+                    rmSync(configPath, { force: true });
+                    return true;
+                }
+                catch {
+                    return false;
+                } })()
+                : atomicWriteJson(configPath, before.data).ok;
+            return rejection(restored ? '验证回执保存失败，旧配置已恢复。' : '验证回执保存失败，恢复旧配置失败，请检查本机文件。', 409);
+        }
+        return json(status());
+    }
+    return {
+        async flyai(request) {
+            if (request.method === 'GET')
+                return json(status());
+            if (request.method !== 'POST')
+                return rejection('不支持此操作。', 405);
+            const input = await readInput(request);
+            if (input instanceof Response)
+                return input;
+            if (!['save', 'clear'].includes(String(input.action)) || Object.keys(input).some(key => key !== 'action' && key !== 'key')
+                || (input.action === 'clear' && 'key' in input))
+                return rejection('请求无效。');
+            const operation = mutations.then(() => mutate(input, request.signal)).catch(() => rejection('操作失败，未能确认保存，请重新读取状态。', 500));
+            mutations = operation.then(() => undefined);
+            return operation;
+        },
+        async artifacts(request) {
+            const query = new URL(request.url).searchParams;
+            if ([...query.keys()].some(key => !['sessionId', 'search', 'offset', 'limit'].includes(key)))
+                return rejection('查询字段无效。');
+            const sessionId = query.get('sessionId') ?? '';
+            if (!/^[A-Za-z0-9_-]{1,256}$/.test(sessionId))
+                return rejection('需要有效会话。');
+            const cwd = await options.workspaceForSession(sessionId);
+            if (!cwd || !isAbsolute(cwd))
+                return rejection('会话工作目录不可用。', 404);
+            try {
+                return json({ ok: true, ...await listArtifacts({ stateRoot: options.stateRoot, cwd,
+                        handoffRoot: env.GOTRY_TURN_HANDOFF_ROOT ?? (options.stateRoot !== '.' ? options.stateRoot : cwd),
+                        search: query.get('search') ?? undefined, offset: query.has('offset') ? Number(query.get('offset')) : undefined,
+                        limit: query.has('limit') ? Number(query.get('limit')) : 20 }) });
+            }
+            catch {
+                return rejection('查询参数无效或产物暂时不可读取。');
+            }
+        },
+    };
+}
+export function registerGotryWebApi(ctx, stateRoot) {
+    if (typeof ctx.inject !== 'function')
+        return;
+    ctx.inject(['connection', 'sessions'], scope => {
+        const connection = scope.get('connection');
+        const handlers = createGotryWebHandlers({ stateRoot, workspaceForSession: async (sessionId) => {
+                const id = sessionId;
+                const live = scope.sessions.get(id)?.header;
+                const stored = live ? undefined : await scope.get('sessionPersistence')?.stat(sessionId);
+                return (live ?? stored?.header)?.cwd;
+            } });
+        // DSH's streaming adapter always attaches a request body; GET cannot use
+        // it. Exact routes have one body mode, so reads and bounded writes differ.
+        scope.effect(() => connection.fetch.register({ path: '/api/gotry/flyai', methods: ['GET'], requestBody: 'buffered', fetch: handlers.flyai }));
+        scope.effect(() => connection.fetch.register({ path: '/api/gotry/flyai/write', methods: ['POST'], requestBody: 'streaming', fetch: handlers.flyai }));
+        scope.effect(() => connection.fetch.register({ path: '/api/gotry/artifacts', methods: ['GET'], requestBody: 'buffered', fetch: handlers.artifacts }));
+    });
+}