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

package/dist/src/turn-deadline.js

@@ -13,18 +13,47 @@
  *   `gotry_turn_handoff.v1` 工单并指令模型告知用户 ETA 与回访方式。
  * - handoff 工单是**新的独立格式**,落在 `<stateRoot>/gotry-state/
  *   turn-handoffs/`,不与 `async/` 的 loop 求解工单混用——async-collect
- *   对无 spec 的 state 会立即结算 failed(假失败),收集器是未来的
- *   agent tick(loopx),不是 async-collect。
+ *   对无 spec 的 state 会立即结算 failed(假失败)。产品通过原生 jobs
+ *   启动独立收集器;仅落单不代表后台已开始。
  */
 import { randomUUID } from 'node:crypto';
 import { mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { classifyTurn, TURN_HANDOFF_ETA_LABEL, turnPolicyFor } from './turn-policy.js';
 export const TURN_DEADLINE_SOFT = 'TURN_DEADLINE_SOFT';
 export const TURN_DEADLINE_EXHAUSTED = 'TURN_DEADLINE_EXHAUSTED';
 export const TURN_DEADLINE_HANDOFF = 'TURN_DEADLINE_HANDOFF';
 export const TURN_HANDOFF_SCHEMA = 'gotry_turn_handoff.v1';
-export async function writeTurnHandoffTicket(stateRoot, userMessage) {
+function handoffContext(events) {
+    const questionIds = new Set(events.filter(event => event.type === 'tool/call' && event.data.name === 'ask_user_question')
+        .map(event => event.type === 'tool/call' ? event.data.callId : ''));
+    // Human constraints are lossless. Refuse dispatch if they exceed the input
+    // budget; silently cutting an accessibility/budget answer changes the task.
+    const answers = events.filter(event => (event.type === 'user/message' && event.data.source.kind === 'user')
+        || (event.type === 'tool/call' && questionIds.has(event.data.callId))
+        || (event.type === 'tool/result' && event.data.message.source.kind === 'tool' && questionIds.has(event.data.message.source.callId)))
+        .map(event => JSON.stringify(event.data)).join('\n');
+    if (answers.length > 64_000)
+        throw new Error('Prior user answers exceed the handoff context limit; planning paused without dropping constraints. Start a new session with the complete trip constraints.');
+    let remaining = 18_000;
+    const evidence = [];
+    for (const event of [...events].reverse()) {
+        if (event.type !== 'tool/result' || (event.data.message.source.kind === 'tool' && questionIds.has(event.data.message.source.callId)))
+            continue;
+        const row = JSON.stringify(event.data);
+        // Evidence may be excerpted, with an explicit marker and valid JSON.
+        const excerpt = row.length > remaining
+            ? JSON.stringify({ truncated: true, excerpt: row.slice(-Math.floor(remaining / 2)) }) : row;
+        if (excerpt.length + 1 > remaining)
+            break;
+        evidence.unshift(excerpt);
+        remaining -= excerpt.length + 1;
+        if (remaining < 100)
+            break;
+    }
+    return answers || evidence.length ? `${answers}\n${evidence.join('\n')}` : undefined;
+}
+export async function writeTurnHandoffTicket(stateRoot, userMessage, details = {}) {
     const ticket = {
         schema: TURN_HANDOFF_SCHEMA,
         id: `th-${Date.now().toString(36)}-${randomUUID().slice(0, 6)}`,
@@ -33,6 +62,7 @@ export async function writeTurnHandoffTicket(stateRoot, userMessage) {
         requestedAt: new Date().toISOString(),
         etaLabel: TURN_HANDOFF_ETA_LABEL,
         status: 'open',
+        ...details,
     };
     await writeTicketJson(stateRoot, ticket);
     return ticket;
@@ -41,7 +71,7 @@ function handoffDir(stateRoot) {
     const root = stateRoot === '.' ? process.cwd() : stateRoot;
     return join(root, 'gotry-state', 'turn-handoffs');
 }
-async function writeTicketJson(stateRoot, ticket) {
+export async function writeTicketJson(stateRoot, ticket) {
     const dir = handoffDir(stateRoot);
     await mkdir(dir, { recursive: true });
     const path = join(dir, `${ticket.id}.json`);
@@ -95,12 +125,14 @@ export async function listTurnHandoffTickets(stateRoot) {
                 objective: raw.objective,
                 requestedAt: raw.requestedAt,
                 etaLabel: raw.etaLabel,
+                ...(raw.jobId ? { jobId: raw.jobId } : {}),
                 ...(raw.settledAt ? { settledAt: raw.settledAt } : {}),
                 ...(raw.error ? { error: raw.error } : {}),
             };
-            if (raw.status !== 'open' && raw.deliverableFile) {
+            if ((raw.status === 'settled' || raw.status === 'failed') && raw.deliverableFile === `${raw.id}.deliverable.md`) {
                 try {
                     const text = await readFile(join(dir, raw.deliverableFile), 'utf-8');
+                    view.deliverablePath = resolve(dir, raw.deliverableFile);
                     view.deliverableExcerpt = text.length > 600 ? `${text.slice(0, 600)}…` : text;
                 }
                 catch { /* 交付物缺失时视图降级,不阻塞列表 */ }
@@ -140,7 +172,12 @@ function exhaustionResult(reason) {
     };
 }
 function handoffResult(ticket) {
-    const instruction = `Turn handed off to background planning. Async ticket ${ticket.id} created (ETA ${ticket.etaLabel}). Stop dispatching tools and tell the user in one short message: the deep planning continues in the background, the expected time, and to check back later (mention ticket ${ticket.id}).`;
+    const state = ticket.status === 'running' && ticket.jobId
+        ? `Background planning started as native background job ${ticket.jobId} (estimated ${ticket.etaLabel}; not a guarantee). Track or cancel with job_list/job_output/job_kill.`
+        : ticket.status === 'failed'
+            ? `Background planning could not start: ${ticket.error ?? 'unknown failure'}. Tell the user it failed; do not promise later delivery.`
+            : 'The ticket is queued; the background worker has not started. Tell the user it is pending, not running; do not promise a completion time.';
+    const instruction = `Async ticket ${ticket.id} persisted. ${state} Stop research and answer from existing results. Never claim a file was created when its tool call failed or was refused. For any successfully written output, call present with its exact existing path before the final response. Mention ticket ${ticket.id}.`;
     return {
         isError: true,
         error: {
@@ -177,6 +214,7 @@ export function installTurnDeadline(ctx, options = {}) {
     };
     const stateByAgent = new Map();
     const softExecutions = new Map();
+    const handoffExecutions = new Map();
     const finalOnlyDisposers = new Map();
     const clearAgent = (agentId) => {
         stateByAgent.delete(agentId);
@@ -184,6 +222,10 @@ export function installTurnDeadline(ctx, options = {}) {
             if (owner.agentId === agentId)
                 softExecutions.delete(token);
         }
+        for (const [token, owner] of handoffExecutions) {
+            if (owner.agentId === agentId)
+                handoffExecutions.delete(token);
+        }
         finalOnlyDisposers.get(agentId)?.();
         finalOnlyDisposers.delete(agentId);
     };
@@ -200,7 +242,7 @@ export function installTurnDeadline(ctx, options = {}) {
         }
         const inheritedNames = globalTools.schemas()
             .map(schema => schema.name)
-            .filter(name => name !== 'run_code');
+            .filter(name => name !== 'run_code' && name !== 'present');
         if (inheritedNames.length === 0)
             return;
         finalOnlyDisposers.set(agentId, scopedTools.restrict({ deny: inheritedNames }));
@@ -249,16 +291,68 @@ export function installTurnDeadline(ctx, options = {}) {
         const state = stateByAgent.get(agentId)
             ?? { startedAt: now(), policy: { ...defaultPolicy, softMs: softPin ?? defaultPolicy.softMs, hardMs: hardPin ?? defaultPolicy.hardMs } };
         stateByAgent.set(agentId, state);
+        // Present validates files on disk and publishes native deliverable events;
+        // it must remain callable after the research window closes.
+        if (exec.name === 'present')
+            return next();
         const elapsed = now() - state.startedAt;
         if (elapsed > state.policy.hardMs) {
-            // Synchronous schema suppression so same-step follow-up calls cannot
-            // loop on refusal results (the 2026-09-02 trajectory failure).
-            enterFinalOnly(exec.agent);
             if (state.policy.exit === 'handoff' && state.userMessage && options.stateRoot) {
-                return writeTurnHandoffTicket(options.stateRoot, state.userMessage)
-                    .then(ticket => handoffResult(ticket))
+                const root = options.stateRoot === '.'
+                    ? (exec.agent.session?.header.cwd ?? process.cwd()) : resolve(options.stateRoot);
+                const written = exec.name === 'write' && !state.handoff ? Promise.resolve().then(() => next()) : undefined;
+                if (!state.handoff) {
+                    const session = exec.agent.session;
+                    // Reserve the handoff before executing the write body. Parallel or
+                    // repeated calls see the same promise and cannot write/dispatch twice.
+                    state.handoff = (async () => {
+                        try {
+                            await written;
+                        }
+                        finally {
+                            enterFinalOnly(exec.agent);
+                        }
+                        let context;
+                        let contextError;
+                        try {
+                            context = handoffContext(session?.snapshotEvents() ?? []);
+                        }
+                        catch (error) {
+                            contextError = error instanceof Error ? error.message : 'handoff context unavailable';
+                        }
+                        const ticket = await writeTurnHandoffTicket(root, state.userMessage, {
+                            workspaceCwd: session?.header.cwd,
+                            ownerSessionId: session ? String(session.id) : undefined,
+                            context,
+                        });
+                        if (contextError) {
+                            await settleTurnHandoffTicket(root, ticket, 'failed', `# Planning paused\n\n${contextError}`, contextError);
+                            return { ...ticket, status: 'failed', error: contextError };
+                        }
+                        return options.startHandoff ? options.startHandoff(ticket, exec.agent, root) : ticket;
+                    })();
+                }
+                // The triggering call may be the output write itself. Execute it once,
+                // preserve its actual outcome, then require native present. Attach a
+                // rejection handler now even if the pending tool itself rejects.
+                const handoff = state.handoff.then(handoffResult, () => exhaustionResult(`${TURN_DEADLINE_EXHAUSTED}: ticket persistence failed; no background worker was started`));
+                return (async () => {
+                    const output = await written;
+                    const guidance = await handoff;
+                    if (output) {
+                        handoffExecutions.set(exec.token, { agentId, contexts: guidance.additionalContexts ?? [] });
+                        // Keep the registry's canonical result object. Rebuilding it after
+                        // restricting inherited schemas would make DSH re-resolve a tool
+                        // that has just been hidden and report UNKNOWN_TOOL after saving.
+                        return output;
+                    }
+                    return guidance;
+                })()
                     .catch(() => exhaustionResult(`${TURN_DEADLINE_EXHAUSTED}: hard deadline ${state.policy.hardMs}ms reached (ticket persistence failed; degraded to converge)`));
             }
+            // Suppress inherited research schemas immediately on refusal; DSH's
+            // scoped schemas remain visible but hit this same per-call guard.
+            enterFinalOnly(exec.agent);
             return Promise.resolve(exhaustionResult(`${TURN_DEADLINE_EXHAUSTED}: turn exceeded hard deadline of ${state.policy.hardMs}ms (elapsed ${elapsed}ms); provide a final answer using existing results`));
         }
         if (elapsed > state.policy.softMs) {
@@ -269,17 +363,20 @@ export function installTurnDeadline(ctx, options = {}) {
     ctx.on('tools/post-execute', (exec, _result, next) => {
         return next().then(decision => {
             const owner = softExecutions.get(exec.token);
-            if (!owner)
+            const handoff = handoffExecutions.get(exec.token);
+            handoffExecutions.delete(exec.token);
+            if (!owner && !handoff)
                 return decision;
             softExecutions.delete(exec.token);
-            const text = owner.exit === 'handoff'
+            const text = owner?.exit === 'handoff'
                 ? 'Turn has crossed the soft deadline of a deep-planning turn. Wrap up context gathering now; the turn will hand off to background planning at the hard deadline.'
                 : 'Turn has crossed the soft deadline. Stop dispatching new tools and produce the final answer from gathered evidence.';
             return {
                 ...decision,
                 additionalContexts: [
                     ...(decision.additionalContexts ?? []),
-                    convergenceContext(TURN_DEADLINE_SOFT, text),
+                    ...(handoff?.contexts ?? []),
+                    ...(owner ? [convergenceContext(TURN_DEADLINE_SOFT, text)] : []),
                 ],
             };
         });

package/dist/src/turn-handoff-job.js

@@ -0,0 +1,124 @@
+/** Connect durable planning tickets to DSH's owned jobs and managed processes. */
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { settleTurnHandoffTicket, writeTicketJson } from './turn-deadline.js';
+const require = createRequire(import.meta.url);
+export async function startTurnHandoffJob(ctx, ticket, owner, stateRoot) {
+    if (ticket.status !== 'open')
+        return ticket;
+    const jobs = ctx.get('jobs');
+    const subprocess = ctx.get('subprocess');
+    if (!jobs || !subprocess)
+        return ticket; // Queued, never announced as running.
+    let current = ticket;
+    let handle;
+    let cancelled = false;
+    let release;
+    const prepared = new Promise(resolve => { release = resolve; });
+    let announceStarted;
+    const started = new Promise(resolve => { announceStarted = resolve; });
+    const fail = async (reason) => {
+        await settleTurnHandoffTicket(stateRoot, current, 'failed', `# Planning failed\n\n${reason}\n\nNo completed plan was produced.`, reason);
+        current = { ...current, status: 'failed', error: reason };
+    };
+    try {
+        const jobId = jobs.start({
+            kind: 'gotry-planning', owner: owner.id, label: `${ticket.id}: ${ticket.objective.slice(0, 100)}`, outputLimitBytes: 12_000,
+            run() {
+                return {
+                    cancel() { cancelled = true; handle?.terminate(); },
+                    done: (async () => {
+                        if (!await prepared) {
+                            announceStarted();
+                            return { status: 'failed', detail: 'ticket persistence failed' };
+                        }
+                        let timer;
+                        try {
+                            if (cancelled)
+                                throw new Error('planning cancelled');
+                            const extension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
+                            const collector = join(import.meta.dirname, '..', 'scripts', `turn-handoff-collect.${extension}`);
+                            const argv = extension === 'ts'
+                                ? [process.execPath, require.resolve('tsx/cli'), collector, ticket.id, stateRoot]
+                                : [process.execPath, collector, ticket.id, stateRoot];
+                            handle = subprocess.spawn({
+                                argv, cwd: ticket.workspaceCwd ?? stateRoot,
+                                stdio: { stdin: 'ignore', stdout: { maxBytes: 16_000 }, stderr: { maxBytes: 16_000 } },
+                                // Collector cleanup includes the wrapper's detached DSH group
+                                // (5s+1s), then its own 8s+1s bound and durable settlement.
+                                graceMs: 11_000,
+                                // This dedicated planning child inherits the configured model
+                                // environment explicitly; secrets never enter tickets or output.
+                                env: { GOTRY_HANDOFF_JOB_ID: current.jobId,
+                                    GOTRY_HANDOFF_PLANNER_BIN: process.env.GOTRY_HANDOFF_PLANNER_BIN,
+                                    GOTRY_HANDOFF_PLANNER_TIMEOUT_MS: process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS,
+                                    DSH_HOME: process.env.DSH_HOME,
+                                    LLM_API_KEY: process.env.LLM_API_KEY, LLM_BASE_URL: process.env.LLM_BASE_URL,
+                                    LLM_MODEL: process.env.LLM_MODEL, GOTRY_LLM_MODEL: process.env.GOTRY_LLM_MODEL,
+                                    DEEPSEEK_API_KEY: process.env.DEEPSEEK_API_KEY, DEEPSEEK_BASE_URL: process.env.DEEPSEEK_BASE_URL },
+                            });
+                            announceStarted();
+                            const plannerTimeout = Number(process.env.GOTRY_HANDOFF_PLANNER_TIMEOUT_MS);
+                            const timeout = Number.isSafeInteger(plannerTimeout) && plannerTimeout > 0 ? plannerTimeout : 900_000;
+                            timer = setTimeout(() => handle.terminate(), timeout + 12_000);
+                            const direct = await handle.done.then(outcome => ({ ok: true, outcome }), error => ({ ok: false, error }));
+                            // Direct success or failure does not prove managed-range exit.
+                            if (!direct.ok)
+                                handle.terminate();
+                            try {
+                                await handle.waitForExit();
+                            }
+                            catch (cleanupError) {
+                                handle.terminate();
+                                const cleanupDiagnostic = cleanupError instanceof Error ? cleanupError.message : 'unknown cleanup error';
+                                const cleanupReason = `managed-range cleanup could not be confirmed: ${cleanupDiagnostic}`;
+                                if (!direct.ok) {
+                                    const diagnostic = direct.error instanceof Error ? direct.error.message : 'planning failed';
+                                    throw new AggregateError([direct.error, cleanupError], `${diagnostic}; ${cleanupReason}`);
+                                }
+                                throw new Error(cleanupReason, { cause: cleanupError });
+                            }
+                            if (!direct.ok)
+                                throw direct.error;
+                            const outcome = direct.outcome;
+                            const path = join(stateRoot, 'gotry-state', 'turn-handoffs', `${ticket.id}.json`);
+                            const settled = JSON.parse(await readFile(path, 'utf8'));
+                            if (cancelled)
+                                throw new Error('planning cancelled');
+                            if (outcome.exitCode !== 0 || settled.status !== 'settled' || settled.deliverableFile !== `${ticket.id}.deliverable.md`) {
+                                throw new Error(settled.error ?? `planning collector failed (exit ${outcome.exitCode ?? outcome.signal})`);
+                            }
+                            const deliverablePath = join(stateRoot, 'gotry-state', 'turn-handoffs', settled.deliverableFile);
+                            const content = await readFile(deliverablePath, 'utf8');
+                            if (!content.trim())
+                                throw new Error('planning collector produced an empty deliverable');
+                            current = settled;
+                            return { status: 'completed', detail: `ticket ${ticket.id} settled`, result: `Planning completed: ${ticket.id}. Deliverable: ${deliverablePath}\nCall present with this exact path, then report the result.\n\n${content.slice(0, 8_000)}` };
+                        }
+                        catch (error) {
+                            const reason = error instanceof Error ? error.message : 'planning failed';
+                            await fail(reason);
+                            return { status: cancelled ? 'killed' : 'failed', detail: reason, result: `Ticket ${ticket.id} failed: ${reason}` };
+                        }
+                        finally {
+                            if (timer)
+                                clearTimeout(timer);
+                            announceStarted();
+                        }
+                    })(),
+                };
+            },
+        });
+        current = { ...ticket, status: 'running', jobId };
+        await writeTicketJson(stateRoot, current);
+        release(true);
+        await started;
+        return current;
+    }
+    catch (error) {
+        release(false);
+        await fail(error instanceof Error ? error.message : 'background job registration failed');
+        return current;
+    }
+}

package/extension/README.md

@@ -2,7 +2,7 @@
 
 # Stai browser extension
 
-Stai (formerly GoTry Session Bridge) connects supported travel-search pages to GoTry. The Chrome Web Store and unpacked builds have different extension IDs but use the same bridge contract.
+Stai (formerly Stai Travel Bridge) connects supported travel-search pages to GoTry. The Chrome Web Store and unpacked builds have different extension IDs but use the same bridge contract.
 
 ## What it does
 

package/extension/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 # Stai 浏览器扩展
 
-Stai（原名 GoTry Session Bridge）将已支持的旅行检索页面连接至 GoTry。商店版与本地加载版的扩展 ID 不同，但使用相同的桥接合同。
+Stai（原名 Stai Travel Bridge）将已支持的旅行检索页面连接至 GoTry。商店版与本地加载版的扩展 ID 不同，但使用相同的桥接合同。
 
 ## 功能
 

package/extension/background.js

@@ -1,5 +1,5 @@
 /**
- * GoTry Session Bridge — MV3 Service Worker(RFC docs/rfc/user-session-data-rfc.md §2.2 通道 C,2026-08-29 定案为 PRIMARY 传输)。
+ * Stai Travel Bridge — MV3 Service Worker(RFC docs/rfc/user-session-data-rfc.md §2.2 通道 C,2026-08-29 定案为 PRIMARY 传输)。
  *
  * 职责(与 Node 侧 session/extension-bridge.ts 配对,零构建纯 JS):
  *   - 长轮询取活:POST /jobs(桥最多 hold 20s;每次响应/失败都重置 SW 30s 生命周期,任务秒级触达);

package/extension/content-bridge.js

@@ -1,5 +1,5 @@
 /**
- * GoTry Session Bridge — ISOLATED-world 桥(manifest 默认 world,document_start)。
+ * Stai Travel Bridge — ISOLATED-world 桥(manifest 默认 world,document_start)。
  *
  * MAIN world(content-main.js)拿不到 chrome API;本脚本监听页面里的
  * gotry-ctrip-sniff 自定义事件,把响应文本经 chrome.runtime.sendMessage 转发给

package/extension/content-main.js

@@ -1,5 +1,5 @@
 /**
- * GoTry Session Bridge — MAIN-world 网络嗅探(manifest world:"MAIN",document_start)。
+ * Stai Travel Bridge — MAIN-world 网络嗅探(manifest world:"MAIN",document_start)。
  *
  * MAIN world 没有 chrome.runtime,只负责:hook 站点自己的 fetch/XHR,把命中
  * 嗅探面的响应文本以 CustomEvent 派发到页面里;ISOLATED 侧的 content-bridge.js

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Stai Travel Bridge",
-  "version": "0.2.0.28",
+  "version": "0.2.0.30",
   "description": "Stai 连接获准的旅行检索与供应商门户：检索结果经本机或授权后端桥接；门户可触发一次性登录代填，扩展不持久保存凭据。",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnuzBX8rT8+RZKEUip5VRA0cY056pExy9PNdN9YCiuY3dgglRbcIBhjuFJoR6EX3/MaUv82vJVyItRVrowXLTwDk4WZof0vwFgKL0zBK304PC46pUaAKTSu1PgXeL1+j5KTAGz/9a9+RnPdbj7jND5rM/MOmBHNPVPpp1NlwxRGIgF9OxHSOfXORcH4Iyte1aJSFUJbFtNS/DaE5D+KjyupPLyIqVN/dCiKnNsTCEHQB9ngeli665PFp76hkccHQQZ4sVuMLS4zBPcazUsp1kcnW+xsQoUATkODTCY+Pzk3zUVF1QOESTjRCVnbNi8tkO43RMRs2q63gX/3inFivcEwIDAQAB",
   "permissions": [
@@ -56,5 +56,5 @@
       "run_at": "document_start"
     }
   ],
-  "version_name": "0.2.0-rc.28"
+  "version_name": "0.2.0-rc.30"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danceiny/gotry",
-  "version": "0.2.0-rc.28",
+  "version": "0.2.0-rc.30",
   "description": "GoTry — 从出发到下一次出发的 AI 旅行 Agent(dsh 插件)。npm/源码入口共用锁定的 dsh runtime + README 安装路径。",
   "type": "module",
   "main": "ts/src/index.ts",
@@ -78,6 +78,7 @@
     "ts/src/artifact-gate.ts",
     "ts/src/tool-packet.ts",
     "ts/src/turn-deadline.ts",
+    "ts/src/turn-handoff-job.ts",
     "ts/src/turn-policy.ts",
     "ts/src/memory-capture.ts",
     "ts/src/memory-utility.ts",

package/ts/capabilities/artifacts.ts

@@ -31,7 +31,7 @@ import { isAbsolute, join, resolve, sep } from 'node:path'
 import { openLedgerIfExists } from '../src/state-ledger.ts'
 
 export interface ArtifactEntry {
-  source: 'async-run' | 'cwd-file'
+  source: 'async-run' | 'cwd-file' | 'turn-handoff'
   id: string
   title: string
   path: string
@@ -56,6 +56,8 @@ export interface ArtifactReadView {
 
 export interface ListArtifactsOptions {
   stateRoot: string
+  /** Host-owned handoff storage can differ from the existing async state. */
+  handoffRoot?: string
   cwd?: string
   limit?: number
   /** Zero-based nonnegative integer; values outside the eligible set return an empty page with the known total. */
@@ -266,6 +268,28 @@ async function listCwdArtifacts(cwd: string): Promise<ArtifactEntry[]> {
   return entries
 }
 
+/** Durable handoff outputs live outside async/, including honest failure notes. */
+async function listHandoffArtifacts(root: string): Promise<ArtifactEntry[]> {
+  const dir = join(root, 'gotry-state', 'turn-handoffs')
+  const names = await readdir(dir).catch(() => [] as string[])
+  const entries: ArtifactEntry[] = []
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue
+    try {
+      const ticket = JSON.parse(await readFile(join(dir, name), 'utf8'))
+      if (ticket.schema !== 'gotry_turn_handoff.v1' || name !== `${ticket.id}.json`
+        || !['settled', 'failed'].includes(ticket.status) || ticket.deliverableFile !== `${ticket.id}.deliverable.md`) continue
+      const path = await realpath(join(dir, ticket.deliverableFile))
+      if (!underRoot(path, root) || hasDeniedSegment(path)) continue
+      const info = await stat(path)
+      if (!info.isFile()) continue
+      entries.push({ source: 'turn-handoff', id: ticket.id, title: String(ticket.objective ?? ticket.id),
+        path, status: ticket.status, updated: new Date(info.mtimeMs).toISOString(), bytes: info.size })
+    } catch { /* A corrupt or missing output cannot be advertised as a file. */ }
+  }
+  return entries
+}
+
 export async function listArtifacts(opts: ListArtifactsOptions): Promise<ListArtifactsResult> {
   const limit = clampLimit(opts.limit)
   const offset = normalizeOffset(opts.offset, 'offset')
@@ -274,6 +298,8 @@ export async function listArtifacts(opts: ListArtifactsOptions): Promise<ListArt
   const cwd = opts.cwd ? resolve(opts.cwd) : process.cwd()
   const canonicalRoot = await realpath(root).catch(() => root)
   const canonicalCwd = await realpath(cwd).catch(() => cwd)
+  const handoffRoot = rootOf(opts.handoffRoot ?? opts.cwd ?? opts.stateRoot)
+  const canonicalHandoffRoot = await realpath(handoffRoot).catch(() => handoffRoot)
 
   // 1) collect all eligible entries per source, without per-source limits —
   //    pageSize is applied to the merged/deduped/sorted set so older cwd files
@@ -281,6 +307,8 @@ export async function listArtifacts(opts: ListArtifactsOptions): Promise<ListArt
   const collected: ArtifactEntry[] = [
     ...listRunsFromLedger(canonicalRoot, 'local'),
     ...(await listDeliverableFiles(canonicalRoot)),
+    ...(await listHandoffArtifacts(canonicalRoot)),
+    ...(canonicalHandoffRoot !== canonicalRoot ? await listHandoffArtifacts(canonicalHandoffRoot) : []),
     ...(await listCwdArtifacts(canonicalCwd)),
   ]
 
@@ -318,6 +346,7 @@ export async function listArtifacts(opts: ListArtifactsOptions): Promise<ListArt
     offset,
     roots: [canonicalRoot, canonicalCwd],
   }
+  if (!result.roots.includes(canonicalHandoffRoot)) result.roots.push(canonicalHandoffRoot)
   if (hasMore) result.nextOffset = start + page.length
   if (needle !== '') result.search = needle
   return result
@@ -332,6 +361,7 @@ export async function listArtifacts(opts: ListArtifactsOptions): Promise<ListArt
  */
 export async function readArtifact(opts: {
   stateRoot: string
+  handoffRoot?: string
   cwd?: string
   path: string
   offset?: number
@@ -341,6 +371,8 @@ export async function readArtifact(opts: {
   const cwd = opts.cwd ? resolve(opts.cwd) : process.cwd()
   const canonicalRoot = await realpath(root).catch(() => root)
   const canonicalCwd = await realpath(cwd).catch(() => cwd)
+  const handoffRoot = rootOf(opts.handoffRoot ?? opts.cwd ?? opts.stateRoot)
+  const canonicalHandoffRoot = await realpath(handoffRoot).catch(() => handoffRoot)
   const raw = String(opts.path ?? '').trim()
   if (!raw) return { ok: false, error: 'path 必填(来自 gotry_artifacts_list 的 path,或异步工单 id)' }
 
@@ -357,10 +389,13 @@ export async function readArtifact(opts: {
       text = run.deliverable
       filePath = asyncDeliverablePath(root, raw)
     } else {
-      const p = asyncDeliverablePath(root, raw)
+      const handoff = /^th-[a-z0-9-]+$/i.test(raw)
+        ? [join(handoffRoot, 'gotry-state', 'turn-handoffs', `${raw}.deliverable.md`),
+          join(root, 'gotry-state', 'turn-handoffs', `${raw}.deliverable.md`)] : []
+      const p = handoff.find(path => existsSync(path)) ?? asyncDeliverablePath(root, raw)
       const canonical = await realpath(p).catch(() => null)
       if (canonical) {
-        if (!underRoot(canonical, canonicalRoot) || hasDeniedSegment(canonical)) {
+        if (!(underRoot(canonical, canonicalRoot) || underRoot(canonical, canonicalHandoffRoot)) || hasDeniedSegment(canonical)) {
           return { ok: false, error: `路径越界:${raw}`, hint: `只读 ${root} 与 dsh 工作目录内的文本产物` }
         }
         const ext = canonical.slice(canonical.lastIndexOf('.') + 1).toLowerCase()
@@ -384,7 +419,7 @@ export async function readArtifact(opts: {
     // 路径(realpath 后的 cwd),而 macOS 上 /var 与 /private/var 这类符号链接会让
     // canonical 路径不匹配字面 cwd,导致 list→read 串联断裂。边界权威仍是下方
     // realpath 后的 canonical 复检,这里放宽不改变可读集合。
-    const inScope = (p: string) => (underRoot(p, cwd) || underRoot(p, root) || underRoot(p, canonicalCwd) || underRoot(p, canonicalRoot)) && !hasDeniedSegment(p)
+    const inScope = (p: string) => (underRoot(p, cwd) || underRoot(p, root) || underRoot(p, canonicalCwd) || underRoot(p, canonicalRoot) || underRoot(p, handoffRoot) || underRoot(p, canonicalHandoffRoot)) && !hasDeniedSegment(p)
     // Prefer an existing candidate so a cwd miss does not mask a valid state-root file.
     const allowed = candidates.find(p => inScope(p) && existsSync(p)) ?? candidates.find(inScope)
     if (!allowed) {
@@ -394,7 +429,7 @@ export async function readArtifact(opts: {
     if (!canonical) {
       return { ok: false, error: `文件不存在:${raw}`, hint: '先 gotry_artifacts_list 看在册产物' }
     }
-    if (!(underRoot(canonical, canonicalCwd) || underRoot(canonical, canonicalRoot)) || hasDeniedSegment(canonical)) {
+    if (!(underRoot(canonical, canonicalCwd) || underRoot(canonical, canonicalRoot) || underRoot(canonical, canonicalHandoffRoot)) || hasDeniedSegment(canonical)) {
       return { ok: false, error: `路径越界:${raw}`, hint: `只读 ${root} 与 dsh 工作目录内的文本产物` }
     }
     const ext = canonical.slice(canonical.lastIndexOf('.') + 1).toLowerCase()

package/ts/capabilities/session/extension-bridge.ts

@@ -62,17 +62,17 @@ export function localExtensionInstalled(home = homedir()): boolean {
  * 影响面统一行:账号会话通道断 → 列表底部工具不提供;其余工具不受影响。
  * 纯函数(默认 HOME 可注入)。
  *
- * 双语对照:CN=本函数返回值;EN 权威见 docs/capability-onboarding.md「Session Bridge 安装」段。
+ * 双语对照:CN=本函数返回值;EN 权威见 docs/capability-onboarding.md「Stai Travel Bridge 安装」段。
  */
 const EXTENSION_IMPACT_LINE = '影响面:gotry_session_search / gotry_session_login(账号会话通道)不可用;携程机票/酒店实时检索、12306 余票、Dida 实时报价都依赖此通道。其它工具(机票 FlyAI、酒店 hbcli、地图、天气等)不受影响。'
 export function needsExtensionSummary(opts: { localInstalled?: boolean; home?: string } = {}): string {
   const local = opts.localInstalled ?? localExtensionInstalled(opts.home)
   if (local) {
-    return 'GoTry Session Bridge 扩展未连接(未安装或已停用)。推荐 Chrome 应用商店一键装(自动更新) '
+    return 'Stai Travel Bridge 扩展未连接(未安装或已停用)。推荐 Chrome 应用商店一键装(自动更新) '
       + `${EXTENSION_STORE_URL} ;或 npx @danceiny/gotry setup 落位后 chrome://extensions 开发者模式「加载已解压的扩展程序」指向 ~/.gotry/extension。`
       + EXTENSION_IMPACT_LINE
   }
-  return 'GoTry Session Bridge 扩展未连接。若你已从 Chrome 商店安装(自动更新):打开 Chrome 并确认扩展已启用即可自动连接,无需再装。'
+  return 'Stai Travel Bridge 扩展未连接。若你已从 Chrome 商店安装(自动更新):打开 Chrome 并确认扩展已启用即可自动连接,无需再装。'
     + `若尚未安装:应用商店一键装 ${EXTENSION_STORE_URL} (装完零弹窗,浏览器自己当安装器)。`
     + EXTENSION_IMPACT_LINE
 }

package/ts/capabilities/session-search.ts

@@ -2,7 +2,7 @@
  * 会话检索编排层(RFC §3.2):transport → adapter entry → networkHint 嗅探 → 解析 → ReadGuard → 证据链。
  *
  * 传输车道(2026-08-29 定案,RFC §2.2):**扩展桥为默认**——一次性安装的 MV3 扩展
- * (GoTry Session Bridge)在自己标签页被动嗅探 batchSearch,零 Chrome 系统弹窗;
+ * (Stai Travel Bridge)在自己标签页被动嗅探 batchSearch,零 Chrome 系统弹窗;
  *  cdp(attach 日常 Chrome,Chrome 144+ 每连接弹权限框)降为显式后备
  * (`GOTRY_SESSION_TRANSPORT=cdp` opt-in,诊断/测试用);persistent 仅测试。
  *