@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/scripts/dsh-artifact-e2e.js

@@ -0,0 +1,150 @@
+/**
+ * dsh artifact view isolated Host contract proof (issue #285).
+ *
+ * 真实执行:在临时 stateRoot/cwd 下装载 gotry-tools 插件,触发 gotry_artifacts_list
+ * + gotry_artifacts_read 的 execute + output.presentationMeta + presentResult,断言
+ * DSH 0.1.5-rc.1 的 Host ToolResult contract(SearchPathsResultView /
+ * ReadResultView / GenericCallView.locations),并跑一次隔离 select → preview →
+ * modify → view-updated 文件读取循环。
+ *
+ * 本脚本不代替 Web renderer E2E:它证明的是 DSH host 装载 → 真实 execute →
+ * 持久化 meta → Host presenter contract。fresh-profile Web custom-card 路径由
+ * 显式命令 `npx tsx scripts/dsh-artifact-web-e2e.ts` 另行覆盖；该浏览器命令
+ * 不属于跨平台 full suite。
+ *
+ * 隔离:全临时目录;不写 gotry-state;结束即删。
+ */
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { apply } from '../src/index.js';
+function toolResult(tool, args, value) {
+    return {
+        isError: false,
+        content: tool.output.render(args, value),
+        meta: tool.output.presentationMeta?.(args, value),
+    };
+}
+async function main() {
+    // ── 1) 隔离环境 ─────────────────────────────────────────────────────────────
+    const home = mkdtempSync(join(tmpdir(), 'gotry-285-home-'));
+    const stateRoot = join(home, 'state');
+    const cwd = join(home, 'workspace');
+    mkdirSync(stateRoot, { recursive: true });
+    mkdirSync(cwd, { recursive: true });
+    // fixture:一个工作区 md,以及后续追加新内容
+    const fixturePath = join(cwd, 'trip-2027.md');
+    writeFileSync(fixturePath, [
+        '# 行程 2027',
+        '',
+        'Day 1: 北京 → 曼谷',
+        'Day 2: 曼谷 → 清迈',
+        'Day 3: 清迈 → 清莱',
+        'Day 4: 清莱 → 曼谷',
+        'Day 5: 曼谷 → 北京',
+    ].join('\n'));
+    // ── 2) 装载 gotry-tools 插件(同 dsh host 装载路径:apply(ctx, config))─────
+    const registered = [];
+    const sections = [];
+    const variables = {};
+    const preExecutes = [];
+    const ctx = {
+        tools: { register: (t) => registered.push(t) },
+        systemPrompt: {
+            section: (s) => { sections.push(s); },
+            variable: (name, provider) => { variables[name] = provider; },
+        },
+        on: (event, fn) => {
+            if (event === 'tools/pre-execute')
+                preExecutes.push(fn);
+            return () => undefined;
+        },
+    };
+    apply(ctx, {
+        stateRoot,
+        timeoutMs: 30_000,
+        hbcliBin: 'hbcli-not-on-path',
+        sessionAccess: 'off',
+    });
+    const exec = { agent: { session: { header: { cwd } } } };
+    const byName = (n) => {
+        const t = registered.find(t => t.name === n);
+        if (!t)
+            throw new Error(`FAIL: 插件装载后未找到 ${n},已注册: ${registered.map(t => t.name).join(',')}`);
+        return t;
+    };
+    // ── 3) select 阶段:gotry_artifacts_list 真实 execute + presentResult ─────
+    const listTool = byName('gotry_artifacts_list');
+    const listPayload = await listTool.execute({ limit: 20 }, exec);
+    assert.equal(listPayload.ok, true, 'list execute 应 ok');
+    assert.ok(Array.isArray(listPayload.artifacts) && listPayload.artifacts.length >= 1, 'list 应发现 fixture md');
+    const fixtureEntry = listPayload.artifacts.find(a => a.path?.endsWith('/trip-2027.md'));
+    assert.ok(fixtureEntry, `list 应包含 trip-2027.md,实际: ${listPayload.artifacts.map(a => a.path).join(',')}`);
+    console.log(`[1/4] SELECT  list.execute → ${listPayload.artifacts.length} 项 (含 fixture trip-2027.md)`);
+    const listView = listTool.presentResult?.({}, toolResult(listTool, {}, listPayload));
+    assert.equal(listView?.card, 'search', 'list card 应为 "search" (SearchPathsResultView)');
+    assert.equal(listView?.shape, 'paths', 'list shape 应为 "paths" (SearchPathsResultView)');
+    assert.ok(Array.isArray(listView?.paths), 'list paths 应为数组(UI 渲染 deliverables 列表直接绑路径)');
+    assert.deepEqual(listView?.paths, listPayload.artifacts.map(a => a.path), 'list paths 数组应与 artifacts 顺序一致');
+    assert.equal(listView?.total, listPayload.total, 'list total 应与 execute 一致');
+    assert.equal(listView?.truncated, Boolean(listPayload.truncated), 'list truncated 应与 execute 一致');
+    const listFallback = listTool.output.render({}, listPayload);
+    assert.ok((listFallback[0]?.text ?? '').length > 0, 'list output.render 应带 summary,供无 search 卡能力的 UI fallback');
+    console.log(`[1/4] CONTRACT list → SearchPathsResultView{ card:'search', shape:'paths', paths:[${listView.paths.length}], total=${listView.total}, truncated=${listView.truncated} }`);
+    // ── 4) preview 阶段:gotry_artifacts_read 真实 execute + presentResult ───
+    const readTool = byName('gotry_artifacts_read');
+    const readCall = readTool.presentCall?.({ path: 'trip-2027.md' });
+    assert.equal(readCall?.kind, 'read', 'read presentCall kind 应为 "read"(editor follow-along)');
+    assert.ok(Array.isArray(readCall?.locations), 'read presentCall locations 应为数组');
+    assert.equal(readCall?.locations?.[0]?.path, 'trip-2027.md', 'read locations[0].path 应等于目标路径');
+    assert.equal(readCall?.locations?.[0]?.line, 1, 'read locations[0].line 应为 1(call 阶段就锁住身份)');
+    console.log(`[2/4] PREVIEW read.presentCall → GenericCallView{ kind:'read', locations:[{path:'trip-2027.md',line:1}] }`);
+    const read1Payload = await readTool.execute({ path: 'trip-2027.md' }, exec);
+    assert.equal(read1Payload.ok, true, 'read 应 ok');
+    assert.equal(read1Payload.source, 'cwd', 'read 在 cwd 中应分类为 cwd source');
+    assert.equal(read1Payload.totalLines, 7, 'fixture 7 行(标题+空行+5 day+空尾)');
+    assert.equal(read1Payload.lines?.[0]?.number, 1, '首行 number 应为 1(file line numbering 保留)');
+    assert.ok(read1Payload.lines?.[0]?.text.includes('行程 2027'), '首行应为标题');
+    assert.equal(read1Payload.lang, 'markdown', '扩展名映射 lang=markdown');
+    console.log(`[2/4] PREVIEW read.execute → { source:'${read1Payload.source}', totalLines:${read1Payload.totalLines}, lines:[${read1Payload.lines?.length}], lang:'${read1Payload.lang}' }`);
+    const read1View = readTool.presentResult?.({ path: 'trip-2027.md' }, toolResult(readTool, { path: 'trip-2027.md' }, read1Payload));
+    assert.equal(read1View?.card, 'read', 'read card 应为 "read" (ReadResultView)');
+    assert.equal(read1View?.path, read1Payload.path, 'read view path 应等于 execute path');
+    assert.equal(read1View?.offset, read1Payload.offset, 'read view offset 应保留(call→result 一致)');
+    assert.equal(read1View?.lines?.length, read1Payload.lines?.length, 'read view lines 长度应等于 execute lines');
+    assert.equal(read1View?.totalLines, read1Payload.totalLines, 'read view totalLines 应等于 execute totalLines');
+    assert.equal(read1View?.lang, 'markdown', 'read view lang 应为 markdown');
+    const identity = read1View?.content?.[0]?.text ?? '';
+    assert.ok(identity.includes('source:'), 'read fallback content[0] 应含 source 身份行');
+    assert.ok(identity.includes('cwd'), `read identity 应明示 source=cwd,实际: ${identity}`);
+    assert.ok(identity.includes(read1Payload.path ?? ''), 'read identity 应含完整 path(便于 UI 高亮与跳转)');
+    assert.ok((read1View?.content?.[1]?.text ?? '').includes('行程 2027'), 'read fallback content[1] 应为正文');
+    console.log(`[2/4] CONTRACT read → ReadResultView{ card:'read', path:'${read1View.path}', totalLines:${read1View.totalLines}, identity:'${identity.slice(0, 80)}...' }`);
+    // ── 5) modify 阶段:写入新内容到 fixture(模拟 agent/用户在侧栏修产物)──
+    appendFileSync(fixturePath, '\nDay 6: 曼谷 → 普吉\nDay 7: 普吉 → 曼谷\nDay 8: 曼谷 → 北京');
+    console.log(`[3/4] MODIFY  fixture 追加 3 行,模拟产物版本变更`);
+    // ── 6) view-updated 阶段:再 read,断言看到新版本 ───────────────────────
+    const read2Payload = await readTool.execute({ path: 'trip-2027.md' }, exec);
+    assert.equal(read2Payload.ok, true, 'view-updated read 应 ok');
+    assert.equal(read2Payload.totalLines, 10, '新版本 totalLines 应为 10(原 7 + 3)');
+    assert.ok(read2Payload.lines?.[0]?.text.includes('行程 2027'), 'view-updated 首行仍为标题');
+    assert.ok(read2Payload.lines?.some(l => l.text.includes('Day 6')), 'view-updated 应包含新追加 Day 6');
+    const read2View = readTool.presentResult?.({ path: 'trip-2027.md' }, toolResult(readTool, { path: 'trip-2027.md' }, read2Payload));
+    assert.equal(read2View?.totalLines, 10, 'view-updated ReadResultView totalLines 应等于 10');
+    assert.ok((read2View?.content?.[1]?.text ?? '').includes('Day 6'), 'view-updated fallback content 应含 Day 6(UI 重新打开产物拿到最新版本)');
+    console.log(`[3/4] VIEW-UPDATED read.execute → { totalLines:${read2Payload.totalLines}, lines:[${read2Payload.lines?.length}] },ReadResultView.content 含 Day 6`);
+    // ── 7) 边界:越界路径 / 非白名单扩展名 / 不存在文件 ────────────────────
+    const outOfScope = await readTool.execute({ path: '../../../../etc/passwd' }, exec);
+    assert.equal(outOfScope.ok, false, '越界路径必须被拒');
+    assert.ok(/scope|outside|workspace|越界/i.test(outOfScope.error ?? ''), `越界错误信息应明示 scope,实际: ${outOfScope.error}`);
+    console.log(`[4/4] GUARDRAIL 越界路径拒 ok=false,error 含 scope 类字样`);
+    const notFound = await readTool.execute({ path: 'never-written.md' }, exec);
+    assert.equal(notFound.ok, false, '不存在文件应 ok=false(不静默 ok)');
+    assert.ok(/not found|不存在/i.test(notFound.error ?? ''), `不存在错误信息应明示 not found,实际: ${notFound.error}`);
+    console.log(`[4/4] GUARDRAIL 不存在文件拒 ok=false,error 含 not-found 类字样`);
+    // ── 清理 ────────────────────────────────────────────────────────────────
+    rmSync(home, { recursive: true, force: true });
+    console.log('\nDSH ARTIFACT HOST CONTRACT PROOF: list/read metadata, source identity, view-updated loop, guardrails OK; fresh-profile Web custom-card path covered separately by `npx tsx scripts/dsh-artifact-web-e2e.ts` (not part of the cross-platform full suite)');
+}
+await main();

package/dist/scripts/dsh-artifact-web-e2e.js

@@ -0,0 +1,443 @@
+/**
+ * Fresh-profile, installed-package Web E2E for GoTry artifact cards.
+ *
+ * The only model endpoint is a local OpenAI-compatible SSE relay. The test
+ * starts `gotry web --no-open --port 0`, captures the authenticated `dsh web:`
+ * URL, then drives the real composer with a fresh headless Chrome profile.
+ * It verifies the public Client cards, path selection, the normal read → edit
+ * → gotry_artifacts_read sequence, and the visibly refreshed content/version.
+ * Temporary package install, HOME/DSH_HOME, workspace, relay, browser, and
+ * server state are cleaned on both success and failure.
+ */
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { execFile as execFileCallback } from 'node:child_process';
+import puppeteer from 'puppeteer-core';
+const execFile = promisify(execFileCallback);
+const ROOT = join(import.meta.dirname, '..', '..');
+const CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const TIMEOUT_MS = 120_000;
+function sse(data) {
+    return `data: ${JSON.stringify(data)}\n\n`;
+}
+function toolResponse(id, name, args) {
+    return sse({
+        id,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-artifact-web',
+        choices: [{ index: 0, delta: { role: 'assistant', tool_calls: [{ index: 0, id: `${id}-call`, type: 'function', function: { name, arguments: JSON.stringify(args) } }] }, finish_reason: null }],
+    }) + sse({
+        id: `${id}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-artifact-web',
+        choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }],
+    }) + 'data: [DONE]\n\n';
+}
+function textResponse(id, text) {
+    return sse({
+        id,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-artifact-web',
+        choices: [{ index: 0, delta: { role: 'assistant', content: text }, finish_reason: null }],
+    }) + sse({
+        id: `${id}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-artifact-web',
+        choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+    }) + 'data: [DONE]\n\n';
+}
+function toolNames(body) {
+    return (body.tools ?? []).map(tool => {
+        const fn = tool.function;
+        return String(fn?.name ?? tool.name ?? '');
+    }).filter(Boolean);
+}
+function hasToolMessage(body) {
+    return (body.messages ?? []).some(message => message.role === 'tool');
+}
+function lastUserText(body) {
+    const message = [...(body.messages ?? [])].reverse().find(item => item.role === 'user');
+    const content = message?.content;
+    if (typeof content === 'string')
+        return content;
+    return JSON.stringify(content ?? '');
+}
+async function startRelay() {
+    const bodies = [];
+    const servedTools = [];
+    let phase = 'first-list';
+    const server = createServer((req, res) => {
+        if (req.method !== 'POST' || !req.url?.endsWith('/chat/completions')) {
+            res.writeHead(404).end('not found');
+            return;
+        }
+        const chunks = [];
+        req.on('data', chunk => chunks.push(Buffer.from(chunk)));
+        req.on('end', () => {
+            let body = {};
+            try {
+                body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            }
+            catch { /* dsh will report malformed upstream */ }
+            bodies.push(body);
+            res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
+            const names = toolNames(body);
+            const hasArtifacts = names.includes('gotry_artifacts_list') || names.includes('gotry_artifacts_read');
+            let payload;
+            if (!hasArtifacts) {
+                payload = textResponse(`aux-${bodies.length}`, '');
+            }
+            else if (phase === 'first-list') {
+                phase = 'first-read';
+                servedTools.push('gotry_artifacts_list');
+                payload = toolResponse('artifact-first-list', 'gotry_artifacts_list', { limit: 20 });
+            }
+            else if (phase === 'first-read' && hasToolMessage(body)) {
+                phase = 'first-final';
+                servedTools.push('gotry_artifacts_read');
+                payload = toolResponse('artifact-first-read', 'gotry_artifacts_read', { path: 'trip-2027.md' });
+            }
+            else if (phase === 'first-final' && hasToolMessage(body)) {
+                phase = 'second-read';
+                payload = textResponse('artifact-first-final', '已展示行程产物。');
+            }
+            else if (phase === 'second-read' && lastUserText(body).includes('修改')) {
+                phase = 'second-edit';
+                servedTools.push('read');
+                payload = toolResponse('artifact-second-read', 'read', { file_path: 'trip-2027.md' });
+            }
+            else if (phase === 'second-edit' && hasToolMessage(body)) {
+                phase = 'second-artifact-read';
+                servedTools.push('edit');
+                payload = toolResponse('artifact-second-edit', 'edit', { file_path: 'trip-2027.md', old_string: 'Day 5: return', new_string: 'Day 5: return\nDay 6: revision requested', replace_all: false });
+            }
+            else if (phase === 'second-artifact-read' && hasToolMessage(body)) {
+                phase = 'second-final';
+                servedTools.push('gotry_artifacts_read');
+                payload = toolResponse('artifact-second-artifact-read', 'gotry_artifacts_read', { path: 'trip-2027.md' });
+            }
+            else if (phase === 'second-final' && hasToolMessage(body)) {
+                payload = textResponse('artifact-second-final', '已更新并重新读取行程产物。');
+            }
+            else {
+                payload = textResponse(`unexpected-${bodies.length}`, '');
+            }
+            res.end(payload);
+        });
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    return {
+        port: server.address().port,
+        bodies,
+        servedTools,
+        close: () => new Promise(resolve => server.close(() => resolve())),
+    };
+}
+async function run(command, args, options) {
+    const result = await execFile(command, args, { cwd: options.cwd, env: options.env, maxBuffer: 16 * 1024 * 1024 });
+    return result.stdout;
+}
+function waitForLine(child, pattern, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let output = '';
+        const timer = setTimeout(() => { reject(new Error(`timed out waiting for ${pattern}; output=${output.slice(-4000)}`)); }, timeoutMs);
+        const onData = (chunk) => {
+            output += chunk.toString();
+            const match = output.match(pattern);
+            if (!match)
+                return;
+            clearTimeout(timer);
+            child.stdout.off('data', onData);
+            child.stderr.off('data', onData);
+            resolve({ url: match[1], output });
+        };
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onData);
+    });
+}
+async function main() {
+    assert.ok(existsSync(CHROME), `Chrome missing: ${CHROME}`);
+    const outputDir = process.env.GOTRY_ARTIFACT_WEB_E2E_OUT || mkdtempSync(join(tmpdir(), 'gotry-artifact-web-evidence-'));
+    mkdirSync(outputDir, { recursive: true });
+    const packageDir = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-pack-'));
+    const consumerDir = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-consumer-'));
+    const workspaceDir = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-workspace-'));
+    const homeDir = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-home-'));
+    const dshHome = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-dsh-'));
+    const userDataDir = mkdtempSync(join(tmpdir(), 'gotry-artifact-web-chrome-'));
+    const fixture = '# Trip 2027\n\nDay 1: arrival\nDay 2: city walk\nDay 3: museum\nDay 4: rest\nDay 5: return\n';
+    writeFileSync(join(workspaceDir, 'trip-2027.md'), fixture, { mode: 0o600 });
+    writeFileSync(join(consumerDir, 'package.json'), JSON.stringify({ private: true, dependencies: {} }, null, 2));
+    const relay = await startRelay();
+    let browser = null;
+    let page = null;
+    let server = null;
+    let passed = false;
+    let serverOutput = '';
+    const assertions = {
+        isolation: { home: homeDir, dshHome, workspace: workspaceDir, userDataDir, liveFlags: { GOTRY_SESSION_LIVE: '0', GOTRY_HBCLI_LIVE: '0', GOTRY_HOTELBYTE_SKILLS_LIVE: '0' } },
+    };
+    try {
+        await run(process.execPath, [join(ROOT, 'scripts/build-dist.mjs')], { cwd: ROOT, env: process.env });
+        await run('npm', ['pack', '--ignore-scripts', '--pack-destination', packageDir], { cwd: ROOT, env: process.env });
+        const tarball = join(packageDir, readdirSync(packageDir).find(name => name.endsWith('.tgz')) || '');
+        assert.ok(existsSync(tarball), 'npm pack did not produce a GoTry tarball');
+        const packageJson = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
+        await run('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund', tarball], { cwd: consumerDir, env: { ...process.env, HOME: homeDir } });
+        const installedRoot = join(consumerDir, 'node_modules', '@danceiny', 'gotry');
+        const installedBin = join(installedRoot, 'bin', 'gotry-inner.js');
+        assert.ok(existsSync(installedBin), 'packed GoTry binary missing');
+        assert.ok(existsSync(join(installedRoot, 'client', 'client.js')), 'packed public client missing');
+        assert.equal(JSON.parse(readFileSync(join(installedRoot, 'package.json'), 'utf8')).exports['./client'], './client/client.js');
+        assertions.package = { version: packageJson.version, tarball: basename(tarball), installedClient: join(installedRoot, 'client', 'client.js') };
+        const env = {
+            ...process.env,
+            HOME: homeDir,
+            DSH_HOME: dshHome,
+            GOTRY_ONBOARDING_SKIP: '1',
+            GOTRY_SETUP_SKIP: '1',
+            GOTRY_SESSION_LIVE: '0',
+            GOTRY_HBCLI_LIVE: '0',
+            GOTRY_HOTELBYTE_SKILLS_LIVE: '0',
+            LLM_API_KEY: 'synthetic-artifact-web-key',
+            LLM_BASE_URL: `http://127.0.0.1:${relay.port}/v1`,
+            LLM_MODEL: 'synthetic-artifact-web',
+        };
+        const child = spawn(process.execPath, [installedBin, 'web', '--no-open', '--port', '0'], { cwd: workspaceDir, env, stdio: ['ignore', 'pipe', 'pipe'] });
+        server = child;
+        child.stdout.on('data', chunk => { serverOutput += chunk.toString(); });
+        child.stderr.on('data', chunk => { serverOutput += chunk.toString(); });
+        const urlResult = await waitForLine(child, /dsh web: (http:\/\/127\.0\.0\.1:\d+\/\?token=[^\s)]+)/, TIMEOUT_MS);
+        serverOutput += urlResult.output;
+        assertions.server = { authenticatedUrlCaptured: true, urlHost: new URL(urlResult.url).host, port: new URL(urlResult.url).port };
+        browser = await puppeteer.launch({ executablePath: CHROME, headless: true, userDataDir, args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'] });
+        page = await browser.newPage();
+        page.on('console', (message) => { serverOutput += `\n[browser console ${message.type()}] ${message.text()}`; });
+        page.on('pageerror', (error) => { serverOutput += `\n[browser pageerror] ${error.stack || error.message}`; });
+        page.setDefaultTimeout(30_000);
+        await page.goto(urlResult.url, { waitUntil: 'networkidle2', timeout: 30_000 });
+        // A fresh DSH profile may show the product's first-run disclosure before
+        // the composer is mounted. Dismiss that visible UI gate through its real
+        // button; do not seed cookies or attach an existing browser profile.
+        await page.evaluate(() => {
+            const button = [...document.querySelectorAll('button')].find(node => node.textContent?.trim() === '继续');
+            button?.click();
+        });
+        // Register the isolated fixture through DSH's authenticated public RPC
+        // carrier. The browser still selects the resulting workspace through the
+        // real workspace picker; no DSH registry file or user profile is seeded.
+        const workspaceTitle = basename(workspaceDir);
+        const workspaceRpc = await page.evaluate(async (path) => {
+            const rpcId = crypto.randomUUID();
+            const response = await fetch(`/api/workspace/create`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    type: 'client-request',
+                    rpcId,
+                    method: 'workspace/create',
+                    payload: { args: { request: { path } } },
+                }),
+            });
+            return { status: response.status, body: await response.text() };
+        }, workspaceDir);
+        assert.equal(workspaceRpc.status, 200, `workspace RPC failed: ${workspaceRpc.status} ${workspaceRpc.body}`);
+        const workspaceResult = JSON.parse(workspaceRpc.body);
+        assert.equal(workspaceResult.result?.ok, true, `workspace RPC rejected: ${workspaceRpc.body}`);
+        assertions.workspace = { rpc: 'workspace/create', title: workspaceResult.result?.value?.workspace?.title || workspaceTitle };
+        // Reconnect the public workspace feed so the browser observes the
+        // host-authoritative registration through its normal baseline path.
+        await page.reload({ waitUntil: 'networkidle2', timeout: 30_000 });
+        await page.evaluate(() => {
+            const button = [...document.querySelectorAll('button')].find(node => node.textContent?.trim() === '继续');
+            button?.click();
+        });
+        await page.waitForFunction((title) => document.body.innerText.includes(title), { timeout: 30_000 }, workspaceTitle);
+        await page.click('button[aria-label="选择工作区"], button[aria-label="Select workspace"]');
+        await page.waitForFunction((title) => [...document.querySelectorAll('[role="menuitem"], [role="option"], button')].some(node => node.textContent?.trim() === title), { timeout: 30_000 }, workspaceTitle);
+        await page.evaluate((title) => {
+            const node = [...document.querySelectorAll('[role="menuitem"], [role="option"], button')].find(candidate => candidate.textContent?.trim() === title);
+            node?.click();
+        }, workspaceTitle);
+        await page.waitForSelector('[contenteditable="true"]');
+        const submit = async (text) => {
+            const editor = await page.$('[contenteditable="true"]');
+            assert.ok(editor, 'real composer missing');
+            await editor.click();
+            await page.keyboard.type(text);
+            const button = await page.$('button[aria-label="发送消息"], button[aria-label="Send message"]');
+            assert.ok(button, 'real composer submit button missing');
+            await button.click();
+        };
+        await submit('请列出并打开刚才生成的 trip-2027.md 行程产物。');
+        const revealArtifactCalls = async () => {
+            await page.evaluate(() => {
+                for (const process of document.querySelectorAll('[data-turn-process]')) {
+                    if (process.getAttribute('aria-expanded') !== 'true')
+                        process.click();
+                }
+            });
+        };
+        await page.waitForFunction(() => document.querySelector('[data-turn-process="1"]') !== null, { timeout: 60_000 });
+        await revealArtifactCalls();
+        await page.waitForSelector('[data-gotry-artifact-card="list"]');
+        await page.waitForSelector('[data-gotry-artifact-card="list"][data-gotry-artifact-state="ok"]');
+        await page.waitForSelector('[data-gotry-artifact-card="read"] [data-gotry-artifact-line="1"]');
+        assert.equal(await page.$eval('[data-gotry-artifact-card="list"]', (node) => {
+            const rect = node.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        }), true, 'artifact list card is not visibly rendered');
+        assert.equal(await page.$eval('[data-gotry-artifact-card="read"]', (node) => {
+            const rect = node.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        }), true, 'artifact read card is not visibly rendered');
+        const pathButton = await page.$('[data-gotry-artifact-path$="trip-2027.md"]');
+        assert.ok(pathButton, 'list card path button missing');
+        await pathButton.click();
+        await page.waitForSelector('[data-gotry-artifact-selection$="trip-2027.md"]');
+        const firstSnapshot = await page.evaluate(() => ({
+            listCards: document.querySelectorAll('[data-gotry-artifact-card="list"]').length,
+            readCards: document.querySelectorAll('[data-gotry-artifact-card="read"]').length,
+            paths: [...document.querySelectorAll('[data-gotry-artifact-path]')].map(node => node.textContent),
+            selected: document.querySelector('[data-gotry-artifact-selection]')?.textContent || null,
+            identity: document.querySelector('[data-gotry-artifact-identity]')?.textContent || null,
+            line1: document.querySelector('[data-gotry-artifact-line="1"]')?.textContent || null,
+        }));
+        assert.equal(firstSnapshot.listCards, 1);
+        assert.ok(firstSnapshot.readCards >= 1);
+        assert.ok(firstSnapshot.paths.some((path) => path?.endsWith('trip-2027.md')));
+        assert.ok(firstSnapshot.selected?.endsWith('trip-2027.md'));
+        assert.match(firstSnapshot.identity || '', /来源|source/);
+        assertions.firstTurn = firstSnapshot;
+        await submit('请修改刚才的行程产物，在末尾追加 Day 6，然后重新读取并展示更新版本。');
+        await page.waitForFunction(() => document.querySelector('[data-turn-process="2"]') !== null, { timeout: 60_000 });
+        await revealArtifactCalls();
+        await page.waitForFunction(() => document.querySelectorAll('[data-gotry-artifact-card="read"]').length >= 2, { timeout: 60_000 });
+        await page.waitForFunction(() => [...document.querySelectorAll('[data-gotry-artifact-card="read"]')].some(node => node.textContent?.includes('Day 6: revision requested')), { timeout: 60_000 });
+        // The artifact card has the fresh read result, but the public DSH file
+        // preview intentionally keeps its old page until the user acknowledges
+        // the changed-file banner. Exercise that visible reload control instead
+        // of treating the custom card or hidden DOM as sidebar evidence.
+        await page.waitForSelector('[data-textpreview-changed]', { timeout: 60_000 });
+        const staleRightPreview = await page.$eval('[data-textpreview-state="text"]', (node) => {
+            const rect = node.getBoundingClientRect();
+            const body = node.querySelector('[data-textpreview-body]');
+            return {
+                visible: rect.width > 0 && rect.height > 0,
+                changedBanner: Boolean(node.querySelector('[data-textpreview-changed]')),
+                includesDay6: body?.textContent?.includes('Day 6: revision requested') || false,
+            };
+        });
+        assert.equal(staleRightPreview.visible, true, 'right file preview is not visibly rendered before reload');
+        assert.equal(staleRightPreview.changedBanner, true, 'right file preview did not show the changed-file banner');
+        assert.equal(staleRightPreview.includesDay6, false, 'right file preview unexpectedly contained Day 6 before reload');
+        const reloadButton = await page.$('[data-textpreview-changed] [data-textpreview-reload-now]');
+        assert.ok(reloadButton, 'right file preview reload control missing');
+        const reloadControl = await page.$eval('[data-textpreview-changed] [data-textpreview-reload-now]', (node) => {
+            const rect = node.getBoundingClientRect();
+            return {
+                visible: rect.width > 0 && rect.height > 0,
+                text: node.textContent?.trim() || '',
+                ariaLabel: node.getAttribute('aria-label'),
+            };
+        });
+        assert.equal(reloadControl.visible, true, 'right file preview reload control is not visible');
+        assert.match(reloadControl.text, /重新载入|Reload/);
+        await reloadButton.click();
+        await page.waitForFunction(() => {
+            const preview = document.querySelector('[data-textpreview-state="text"]');
+            const body = preview?.querySelector('[data-textpreview-body]');
+            return Boolean(preview && body?.textContent?.includes('Day 6: revision requested'));
+        }, { timeout: 60_000 });
+        await page.$eval('[data-textpreview-body]', (node) => {
+            const body = node;
+            body.scrollTop = body.scrollHeight;
+        });
+        const rightPreviewAfterReload = await page.$eval('[data-textpreview-state="text"]', (node) => {
+            const rect = node.getBoundingClientRect();
+            const body = node.querySelector('[data-textpreview-body]');
+            const day6 = [...(node.querySelectorAll('[data-textpreview-line]'))].find(line => line.textContent?.includes('Day 6: revision requested'));
+            const day6Rect = day6?.getBoundingClientRect();
+            return {
+                visible: rect.width > 0 && rect.height > 0,
+                changedBanner: Boolean(node.querySelector('[data-textpreview-changed]')),
+                bodyIncludesDay6: body?.textContent?.includes('Day 6: revision requested') || false,
+                day6Visible: Boolean(day6Rect && day6Rect.width > 0 && day6Rect.height > 0 && day6Rect.top < window.innerHeight && day6Rect.bottom > 0),
+                bodyText: body?.textContent || '',
+            };
+        });
+        assert.equal(rightPreviewAfterReload.visible, true, 'right file preview is not visibly rendered after reload');
+        assert.equal(rightPreviewAfterReload.changedBanner, false, 'right file preview still shows the changed-file banner after reload');
+        assert.equal(rightPreviewAfterReload.bodyIncludesDay6, true, 'right file preview body does not contain Day 6 after reload');
+        assert.equal(rightPreviewAfterReload.day6Visible, true, 'right file preview Day 6 is not visible after reload');
+        // DSH may collapse a completed turn after the last tool result arrives;
+        // reopen the real process disclosure and place the revised card in view so
+        // the receipt proves visible, not merely hidden-DOM, refreshed evidence.
+        await revealArtifactCalls();
+        await page.evaluate(() => {
+            const cards = document.querySelectorAll('[data-gotry-artifact-card="read"]');
+            cards[cards.length - 1]?.scrollIntoView({ block: 'center' });
+        });
+        assert.equal(await page.$eval('[data-gotry-artifact-card="read"]:last-of-type', (node) => {
+            const rect = node.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        }), true, 'updated artifact read card is not visibly rendered');
+        const finalSnapshot = await page.evaluate(() => ({
+            readCards: document.querySelectorAll('[data-gotry-artifact-card="read"]').length,
+            updated: [...document.querySelectorAll('[data-gotry-artifact-card="read"]')].some(node => node.textContent?.includes('Day 6: revision requested')),
+            versions: [...document.querySelectorAll('[data-gotry-artifact-version]')].map(node => node.getAttribute('data-gotry-artifact-version')),
+            identities: [...document.querySelectorAll('[data-gotry-artifact-identity]')].map(node => node.textContent),
+            updatedLine: [...document.querySelectorAll('[data-gotry-artifact-line]')].find(node => node.textContent?.includes('Day 6'))?.textContent || null,
+        }));
+        assert.ok(finalSnapshot.readCards >= 2);
+        assert.equal(finalSnapshot.updated, true);
+        assert.ok(finalSnapshot.versions.filter(Boolean).length >= 2);
+        assert.ok(finalSnapshot.updatedLine?.includes('Day 6'));
+        assertions.secondTurn = { ...finalSnapshot, rightPreview: rightPreviewAfterReload, reloadControl };
+        assert.deepEqual(relay.servedTools, ['gotry_artifacts_list', 'gotry_artifacts_read', 'read', 'edit', 'gotry_artifacts_read']);
+        assertions.relay = { toolCalls: relay.servedTools, bodyCount: relay.bodies.length };
+        const screenshotPath = join(outputDir, 'artifact-web-e2e.png');
+        await page.screenshot({ path: screenshotPath, fullPage: true });
+        const domPath = join(outputDir, 'artifact-web-e2e.dom.json');
+        writeFileSync(domPath, JSON.stringify(assertions, null, 2) + '\n', { mode: 0o600 });
+        const screenshotSha256 = createHash('sha256').update(readFileSync(screenshotPath)).digest('hex');
+        const domSha256 = createHash('sha256').update(readFileSync(domPath)).digest('hex');
+        const receipt = { screenshot: { path: screenshotPath, sha256: screenshotSha256 }, domAssertions: { path: domPath, sha256: domSha256 }, serverOutputSha256: createHash('sha256').update(serverOutput).digest('hex') };
+        writeFileSync(join(outputDir, 'artifact-web-e2e.receipt.json'), JSON.stringify(receipt, null, 2) + '\n', { mode: 0o600 });
+        passed = true;
+        console.log(`DSH ARTIFACT WEB E2E: PASS fresh Chrome profile, list→select/open→preview→read→edit→updated read; screenshot=${screenshotPath}; screenshotSha256=${screenshotSha256}; dom=${domPath}; domSha256=${domSha256}`);
+    }
+    finally {
+        if (page && !passed) {
+            try {
+                const failureHtml = join(outputDir, 'artifact-web-e2e.failure.html');
+                const failurePng = join(outputDir, 'artifact-web-e2e.failure.png');
+                writeFileSync(failureHtml, await page.content(), { mode: 0o600 });
+                await page.screenshot({ path: failurePng, fullPage: true });
+                writeFileSync(join(outputDir, 'artifact-web-e2e.failure.log'), serverOutput, { mode: 0o600 });
+                console.error(`DSH ARTIFACT WEB E2E failure artifacts: html=${failureHtml}; screenshot=${failurePng}; log=${join(outputDir, 'artifact-web-e2e.failure.log')}`);
+            }
+            catch { /* browser may have failed before a document existed */ }
+        }
+        await browser?.close().catch(() => { });
+        if (server && !server.killed) {
+            server.kill('SIGTERM');
+            await new Promise(resolve => { server?.once('close', () => resolve()); setTimeout(resolve, 2_000); });
+        }
+        await relay.close().catch(() => { });
+        for (const directory of [packageDir, consumerDir, workspaceDir, homeDir, dshHome, userDataDir]) {
+            rmSync(directory, { recursive: true, force: true });
+        }
+    }
+}
+await main();