@loomhelm/multi-task-flow 0.0.0-stage → 0.2.1

package/toolkit/skills/multi-task-flow/scripts/service.ts

@@ -0,0 +1,235 @@
+import { Runtime } from "../../bin/modules/core/runtime";
+import {
+  compatibilityReport,
+  selectedRelease,
+  downgradeApproval,
+} from "../lib/service-compatibility";
+import { maintenanceCheck, maintenanceApply } from "../lib/ledger-maintenance";
+import { writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { servicePaths } from "../lib/service-paths";
+import { ServiceState } from "../lib/service-state";
+import { ServiceAuth } from "../lib/service-auth";
+import { ensureService, runDaemon, serviceStatus } from "../lib/service-lifecycle";
+import { agentLease } from "../lib/service-http";
+import { installRelease, switchRelease } from "../lib/service-maintenance";
+import { importRun } from "../lib/service-import";
+import { ContractError, requireCondition } from "../lib/errors";
+import { requireApi, ledgerContract } from "../lib/service-contract";
+import { buildView } from "../lib/view";
+import { validateLedger } from "../lib/schema";
+
+const actor = z
+  .object({
+    run_id: z.string(),
+    thread_id: z.string(),
+    api_version: z.number().int(),
+  })
+  .strict();
+const empty = z.object({}).strict();
+const source = z.object({ source: z.string().startsWith("/") }).strict();
+
+export async function serviceCommand(
+  command: string,
+  input: unknown,
+  state = new ServiceState(servicePaths()),
+): Promise<unknown> {
+  if (command === "install") {
+    const parsed = source
+      .extend({ registry_dir: z.string().startsWith("/").optional() })
+      .parse(input);
+    return installRelease(state, parsed.source, parsed.registry_dir);
+  }
+  if (command === "compatibility-check") {
+    const parsed = z
+      .union([source, z.object({ rollback: z.literal(true) }).strict()])
+      .parse(input);
+    return compatibilityReport(state, selectedRelease(state, parsed), parsed.source);
+  }
+  if (command === "ledger-maintenance-check")
+    return maintenanceCheck(state, input);
+  if (command === "ledger-maintenance-apply")
+    return maintenanceApply(state, input);
+  if (command === "upgrade") {
+    const parsed = source
+      .extend({ write_downgrade_approval: downgradeApproval.optional() })
+      .strict()
+      .parse(input);
+    return switchRelease(
+      state,
+      parsed.source,
+      false,
+      undefined,
+      parsed.write_downgrade_approval,
+    );
+  }
+  if (command === "rollback") {
+    const parsed = z
+      .object({ write_downgrade_approval: downgradeApproval.optional() })
+      .strict()
+      .parse(input);
+    return switchRelease(
+      state,
+      "",
+      true,
+      undefined,
+      parsed.write_downgrade_approval,
+    );
+  }
+  if (command === "import" || command === "migrate") {
+    const parsed = z
+      .object({ source_root: z.string().startsWith("/"), run_id: z.string() })
+      .strict()
+      .parse(input);
+    return importRun(state, parsed.source_root, parsed.run_id);
+  }
+  if (command === "ensure") return ensureService(state, actor.parse(input));
+  if (command === "renew" || command === "release") {
+    const parsed = actor.parse(input);
+    requireApi(parsed.api_version);
+    requireCondition(
+      existsSync(join(state.paths.config, "service.json")),
+      "SERVICE_NOT_INSTALLED",
+      "Viewer is not installed",
+    );
+    const lease = agentLease({ ...parsed, api_version: 1 });
+    if (command === "renew") {
+      await serviceStatus(state);
+      return state.renew(lease, state.config().agent_ttl_ms);
+    }
+    state.release(lease.id);
+    return { released: lease.id };
+  }
+  if (command === "status" || command === "doctor") {
+    empty.parse(input);
+    if (!existsSync(join(state.paths.config, "service.json")))
+      return { installed: false, running: false, root: state.paths.root };
+    try {
+      return {
+        installed: true,
+        running: true,
+        ...(await serviceStatus(state)),
+        leases: state.runtime().leases,
+      };
+    } catch {
+      return {
+        installed: true,
+        running: false,
+        root: state.paths.root,
+        configured_build: state.config().current_build,
+        runtime: state.runtime(),
+        action:
+          "Use ensure; if startup fails inspect launchctl print for the configured user service",
+      };
+    }
+  }
+  if (command === "login") {
+    const parsed = z
+      .object({ run_id: z.string().optional() })
+      .strict()
+      .parse(input);
+    await serviceStatus(state);
+    const target = parsed.run_id ? `/runs/${parsed.run_id}/` : "/";
+    const ticket = new ServiceAuth(state).ticket(target);
+    const loginUrl = new URL(
+      target,
+      `http://127.0.0.1:${state.config().port}`,
+    );
+    loginUrl.searchParams.set("ticket", ticket);
+    return {
+      login_url: loginUrl.toString(),
+      expires_in_seconds: 60,
+      single_use: true,
+    };
+  }
+  if (command === "credential-rotate" || command === "credential-revoke") {
+    empty.parse(input);
+    state.config();
+    new ServiceAuth(state).rotate();
+    state.transaction((runtime) => {
+      runtime.leases = runtime.leases.filter(
+        (lease) => lease.kind !== "browser",
+      );
+    });
+    return { sessions_revoked: true };
+  }
+  if (command === "reader-check") {
+    const parsed = z.object({ ledger: z.unknown() }).strict().parse(input);
+    const ledger = validateLedger(parsed.ledger);
+    return { contract: ledgerContract(ledger), revision: ledger.revision };
+  }
+  if (command === "read-only-view") {
+    const parsed = z.object({ ledger: z.unknown(), plan_id: z.string().optional() }).strict().parse(input);
+    const ledger = validateLedger(parsed.ledger);
+    return { view: buildView(ledger, parsed.plan_id) };
+  }
+  throw new ContractError("INVALID_COMMAND", "Unknown viewer service command");
+}
+
+if (import.meta.main) {
+  try {
+    const command = process.argv[2];
+    if (command === "daemon") {
+      requireCondition(
+        process.argv.length === 3,
+        "INVALID_ARGUMENTS",
+        "Daemon accepts no input arguments",
+      );
+      await runDaemon(new ServiceState(servicePaths()));
+    } else {
+      requireCondition(
+        command &&
+          process.argv.length === 5 &&
+          process.argv[3] === "--input" &&
+          process.argv[4] === "-",
+        "INVALID_ARGUMENTS",
+        "Usage: service.ts <command> --input -",
+      );
+      const text = await Runtime.stdin.text();
+      const inputLimit = command === "reader-check" || command === "read-only-view" ? 256 * 1024 * 1024 : 16_384;
+      requireCondition(text.length <= inputLimit, "INPUT_TOO_LARGE", "Service command input is too large");
+      const result = await serviceCommand(command, JSON.parse(text));
+      console.log(JSON.stringify({ ok: true, code: "OK", result }));
+    }
+  } catch (error) {
+    if (process.argv[2] === "daemon") {
+      try {
+        const state = new ServiceState(servicePaths());
+        state.initialize();
+        writeFileSync(
+          join(state.paths.state, "startup-failure.json"),
+          JSON.stringify({
+            at: new Date().toISOString(),
+            category: error instanceof Error ? error.name : "Unknown",
+            code:
+              error instanceof ContractError
+                ? error.code
+                : ((error as NodeJS.ErrnoException)?.code ?? "SERVICE_ERROR"),
+          }),
+          { mode: 0o600 },
+        );
+      } catch {}
+    }
+    const code =
+      error instanceof ContractError
+        ? error.code
+        : error instanceof z.ZodError || error instanceof SyntaxError
+          ? "INVALID_INPUT"
+          : "SERVICE_ERROR";
+    console.error(
+      JSON.stringify({
+        ok: false,
+        code,
+        ...(error instanceof ContractError && error.details !== undefined
+          ? { details: error.details }
+          : {}),
+        message:
+          error instanceof ContractError
+            ? error.message
+            : "Service operation failed; inspect isolated state and maintenance journal",
+      }),
+    );
+    process.exitCode = error instanceof ContractError ? error.exitCode : 1;
+  }
+}

package/toolkit/skills/multi-task-flow/scripts/test-skills-artifact.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env -S bun --no-install
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { existsSync, cpSync, mkdtempSync, readFileSync, realpathSync, rmSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+const client = resolve(import.meta.dirname, '../../..', 'clients/typescript');
+const isolated = realpathSync(mkdtempSync(join(tmpdir(),'loomhelm-source-artifact-')));
+try {
+  for (const file of ['package.json','bun.lock','src','toolkit']) cpSync(join(client,file),join(isolated,file),{recursive:true});
+  const install=spawnSync(process.execPath,['install','--frozen-lockfile','--ignore-scripts','--production','--backend=copy'],{cwd:isolated,env:process.env,encoding:'utf8'});
+  assert.equal(install.status,0,install.stderr);
+  assert.equal(existsSync(join(isolated,'dist')),false);
+  assert.equal(existsSync(join(isolated,'toolkit/skills/bin/plan_review_view.js')),false);
+  assert.equal(existsSync(join(isolated,'toolkit/skills/bin/native/posix.node')),false);
+  const inventory=JSON.parse(readFileSync(join(isolated,'toolkit/artifact-manifest.json'),'utf8'));
+  assert.equal(inventory.runtime,'bun@1.4.4'); assert.ok(inventory.files.every(file=>file.path.startsWith('skills/')));
+  mkdirSync(join(isolated,'host'),{mode:0o700});
+  const env={...process.env,PATH:'/usr/bin:/bin',CODEX_HOME:join(isolated,'host'),LOOMHELM_CODEX_APP_SERVER_SOCKET:join(isolated,'absent.sock')};
+  const invoke=(args,input='')=>spawnSync(process.execPath,[join(isolated,'src/cli.ts'),...args],{cwd:isolated,env,input,encoding:'utf8',timeout:30000});
+  const list=invoke(['skills','list']); assert.equal(list.status,0,list.stderr); assert.equal(JSON.parse(list.stdout).length,29);
+  const plan=readFileSync(join(isolated,'toolkit/skills/dev-plan/references/plan-cases/positive-fast-track.md'),'utf8');
+  const check=invoke(['skills','run','skills/bin/plan_contract_check.ts','--plan','-'],plan); assert.equal(check.status,0,check.stderr); assert.match(check.stdout,/PASS/);
+  const invalid=invoke(['flow','init','--input','-'],'{}'); assert.equal(invalid.status,2,invalid.stderr); assert.equal(JSON.parse(invalid.stdout).code,'INVALID_INPUT');
+  const ports=invoke(['skills','run','skills/global-port-manager/scripts/port_registry.ts','--help']); assert.equal(ports.status,0,ports.stderr);
+  console.log(JSON.stringify({ok:true,runtime:'bun',sourceCheckoutRequired:false,globalCodexCodeRequired:false,serverRequired:false,precompiledJsRequired:false,skills:29}));
+} finally { rmSync(isolated,{recursive:true,force:true}); }

package/toolkit/skills/multi-task-flow/scripts/test-skills-native.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env -S bun --no-install
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, readFileSync, symlinkSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { tryLockFile, readRegularNoFollow } from '../../bin/modules/core/security_file.ts';
+import { renameNoReplace } from '../../bin/modules/visual/secure_io.ts';
+const root = realpathSync(mkdtempSync(join(tmpdir(), 'loomhelm-posix-')));
+try {
+  writeFileSync(join(root, 'one'), 'one'); writeFileSync(join(root, 'two'), 'two');
+  symlinkSync('one', join(root, 'link'));
+  await assert.rejects(readRegularNoFollow(join(root, 'link')));
+  assert.throws(() => renameNoReplace(join(root, 'one'), join(root, 'two'), root));
+  assert.equal(readFileSync(join(root, 'two'), 'utf8'), 'two');
+  const lockPath = join(root, 'lock');
+  const lock = tryLockFile(lockPath); assert.ok(lock);
+  try {
+    // Fixed source protocol: independently call libc flock through Bun FFI.
+    const legacy = 'import {dlopen,FFIType} from "bun:ffi"; import {openSync,closeSync} from "node:fs"; const fd=openSync(process.argv[1],"r+"); const api=dlopen(process.platform==="darwin"?"libSystem.B.dylib":"libc.so.6",{flock:{args:[FFIType.i32,FFIType.i32],returns:FFIType.i32}});const result=api.symbols.flock(fd,6);closeSync(fd);process.exit(result===0?0:7);';
+    const blocked = spawnSync(process.execPath, ['-e', legacy, lockPath], { env: process.env });
+    assert.equal(blocked.status, 7, blocked.stderr.toString());
+    lock.release();
+    const free = spawnSync(process.execPath, ['-e', legacy, lockPath], { env: process.env });
+    assert.equal(free.status, 0, free.stderr.toString());
+  } finally { lock.release(); }
+  console.log(JSON.stringify({ ok: true, runtime: 'bun', platform: process.platform, arch: process.arch, noProjectAddon: true, nativeNoReplace: true, crossImplementationFlock: true, symlinkRefusal: true }));
+} finally { rmSync(root, { recursive: true, force: true }); }

package/toolkit/skills/multi-task-flow/scripts/test-viewer-source.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env -S bun --no-install
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, realpathSync, rmSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const root = resolve(import.meta.dirname, '../../..');
+const temporary = realpathSync(mkdtempSync(join(tmpdir(), 'viewer-source-test-')));
+const output = join(temporary, 'package');
+const env = { ...process.env, MULTI_TASK_FLOW_PROFILE:'test', MULTI_TASK_FLOW_ROOT:join(temporary,'state') };
+try {
+  const build=spawnSync(process.execPath,[join(root,'skills/multi-task-flow/scripts/build-service.ts'),'--output',output,'--service-version','0.0.0-test'],{cwd:temporary,env,encoding:'utf8',timeout:120000});
+  assert.equal(build.status,0,build.stderr);
+  const manifest=JSON.parse(readFileSync(join(output,'manifest.json'),'utf8'));
+  assert.equal(manifest.schema_version,2);
+  assert.equal(existsSync(join(output,'viewer.mjs')),false);
+  assert.equal(existsSync(join(output,'posix.node')),false);
+  const marker=join(temporary,'environment-marker');
+  const tools=join(temporary,'caller-tools'); mkdirSync(tools);
+  const gh=join(tools,'gh');
+  writeFileSync(gh, `#!/bin/sh\nprintf '%s' '{"number":42,"title":"fixture","url":"https://github.com/owner/repo/pull/42","state":"MERGED","mergedAt":null,"statusCheckRollup":[]}'\n`); chmodSync(gh,0o700);
+  const preload=join(temporary,'preload.ts');
+  writeFileSync(preload,`import {PRDetailsCache} from ${JSON.stringify(join(output,'skills/multi-task-flow/lib/pr-details.ts'))}; const snapshot=await new PRDetailsCache().read({host:"github.com",owner:"owner",name:"repo"},"https://github.com/owner/repo/pull/42"); await Bun.write(${JSON.stringify(marker)},JSON.stringify({snapshot,path:process.env.PATH,option:process.env.NODE_OPTIONS}));`);
+  const callerPath=tools+':'+process.env.PATH;
+  const invoke=spawnSync(join(output,'viewer'),['invalid','--input','-'],{cwd:temporary,env:{...env,PATH:callerPath,NODE_OPTIONS:'--trace-warnings',BUN_OPTIONS:'--preload='+preload},input:'{}',encoding:'utf8',timeout:30000});
+  assert.notEqual(invoke.status,0); assert.equal(JSON.parse(invoke.stderr).code,'INVALID_COMMAND');
+  const inherited=JSON.parse(readFileSync(marker,'utf8'));
+  assert.equal(inherited.path,callerPath); assert.equal(inherited.option,'--trace-warnings');
+  assert.equal(inherited.snapshot.data?.state,'MERGED'); assert.equal(inherited.snapshot.stale,false); assert.equal(inherited.snapshot.error,null);
+  rmSync(marker);
+  const unsafe = join(temporary,'unsafe-temp'); mkdirSync(unsafe); chmodSync(unsafe,0o777);
+  const unsafeInvoke=spawnSync(join(output,'viewer'),['invalid'],{env:{...env,TMPDIR:unsafe},encoding:'utf8',timeout:30000});
+  assert.notEqual(unsafeInvoke.status,0); assert.match(unsafeInvoke.stderr,/VIEWER_TEMP_UNTRUSTED/);
+  chmodSync(unsafe,0o700);
+  for (const resource of ['skills/bin/plan_bunfig.toml','skills/multi-task-flow/scripts/service.ts']) {
+    const path=join(output,resource), original=readFileSync(path);
+    writeFileSync(path,resource.endsWith('.toml') ? 'preload = ['+JSON.stringify(preload)+']\n' : `await Bun.write(${JSON.stringify(marker)},'unsafe');`);
+    const rejected=spawnSync(join(output,'viewer'),['invalid'],{env,encoding:'utf8',timeout:30000});
+    assert.notEqual(rejected.status,0); assert.match(rejected.stderr,/VIEWER_RESOURCE_CHECKSUM/); assert.equal(existsSync(marker),false);
+    writeFileSync(path,original);
+  }
+  const shadow=join(output,'skills/multi-task-flow/lib/service-state.tsx');
+  writeFileSync(shadow,`import {writeFileSync as __writeMarker} from 'node:fs'; __writeMarker(${JSON.stringify(marker)},'unsafe');\n`+readFileSync(join(output,'skills/multi-task-flow/lib/service-state.ts'),'utf8'));
+  const shadowInvoke=spawnSync(join(output,'viewer'),['invalid','--input','-'],{env,input:'{}',encoding:'utf8',timeout:30000});
+  assert.notEqual(shadowInvoke.status,0); assert.match(shadowInvoke.stderr,/VIEWER_RESOURCE_UNLISTED/); assert.equal(existsSync(marker),false);
+  rmSync(shadow);
+  const { verifyRelease }=await import(pathToFileURL(join(output,'skills/multi-task-flow/lib/service-release.ts')));
+  verifyRelease(output);
+  // Actual packaged TS modules own an isolated HTTP lifecycle, never user services.
+  const { ServiceState }=await import(pathToFileURL(join(output,'skills/multi-task-flow/lib/service-state.ts')));
+  const { servicePaths }=await import(pathToFileURL(join(output,'skills/multi-task-flow/lib/service-paths.ts')));
+  const { ServiceAuth }=await import(pathToFileURL(join(output,'skills/multi-task-flow/lib/service-auth.ts')));
+  const { startSharedViewer }=await import(pathToFileURL(join(output,'skills/multi-task-flow/lib/service-http.ts')));
+  const state=new ServiceState(servicePaths(env)); state.initialize(); const auth=new ServiceAuth(state); auth.initialize();
+  const viewer=await startSharedViewer(state,manifest,join(output,'skills/multi-task-flow/dist'),0);
+  try {
+    const base='http://127.0.0.1:'+viewer.port;
+    assert.equal((await fetch(base+'/api/v1/runs')).status,401);
+    assert.equal((await fetch(base+'/api/v1/runs',{headers:{authorization:'Bearer '+auth.credential()}})).status,200);
+  } finally { await viewer.stop(); }
+  writeFileSync(join(output,'skills/multi-task-flow/dist/app.js'),'tampered');
+  assert.throws(()=>verifyRelease(output),/checksum/);
+  console.log(JSON.stringify({ok:true,schemaVersion:2,runtime:'bun@1.4.4',sourceEntry:true,environmentPreserved:true,isolatedHttp:true,checksums:true,resources:Object.keys(manifest.files).length}));
+} finally { rmSync(temporary,{recursive:true,force:true}); }

package/toolkit/skills/multi-task-flow/scripts/verify-service-browser.ts

@@ -0,0 +1,181 @@
+// CI synthetic interactions plus a pure-frontend ui_demo evidence surface.
+import { chromium } from "playwright";
+import { mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { createDemoLedger } from "../examples/orchestration-viewer/ledger";
+import { buildView } from "../lib/view";
+import {
+  authFailedPage,
+  homePage,
+  homeScript,
+  runClientScript,
+} from "../lib/service-pages";
+import { startSharedViewer } from "../lib/service-http";
+import { ServiceAuth } from "../lib/service-auth";
+import {
+  serviceFixture,
+  fixtureRelease,
+  fixtureRun,
+} from "../tests/service-fixture";
+
+const output = resolve(process.argv[2]!);
+mkdirSync(output, { recursive: true });
+const dist = resolve(import.meta.dir, "../dist");
+const browser = await chromium.launch({ headless: true });
+const fixture = serviceFixture();
+const bundle = fixtureRelease(fixture.root);
+fixtureRun(fixture.state.paths.data);
+const viewer = await startSharedViewer(fixture.state, bundle.manifest, dist, 0);
+const base = `http://127.0.0.1:${viewer.port}`;
+const scenarios: string[] = [];
+try {
+  const live = await browser.newContext();
+  const page = await live.newPage();
+  const loginUrl = new URL(base + "/runs/demo-run/");
+  loginUrl.searchParams.set("ticket", new ServiceAuth(fixture.state).ticket("/runs/demo-run/"));
+  await page.goto(loginUrl.toString());
+  await page.waitForURL(base + "/runs/demo-run/");
+  await page.waitForFunction(() =>
+    document.querySelector("#connection")?.textContent?.includes("实时"),
+  );
+  const response = await page.request.get(base + "/api/v1/runs");
+  if (!response.ok())
+    throw new Error("Browser login did not retain its session");
+  scenarios.push(
+    "single-use target ticket, URL cleanup and authenticated browser session",
+  );
+  await live.close();
+
+  const ledger = createDemoLedger(Date.parse("2026-11-04T09:00:00.000Z"));
+  const sourceHtml =
+    readFileSync(join(dist, "index.html"), "utf8") +
+    '<script src="/service-client.js" defer></script>';
+  const images: string[] = [];
+  for (const viewport of [
+    { width: 1440, height: 1000 },
+    { width: 393, height: 852 },
+  ]) {
+    const context = await browser.newContext({
+      viewport,
+      colorScheme: "light",
+    });
+    await context.addInitScript(() => {
+      class MockEvents {
+        addEventListener(name: string, callback: EventListener) {
+          if (name === "open")
+            queueMicrotask(() => callback(new Event("open")));
+        }
+        close() {}
+      }
+      Object.defineProperty(window, "EventSource", { value: MockEvents });
+    });
+    await context.route("http://mtf.test/**", async (route) => {
+      const url = new URL(route.request().url());
+      let body: string;
+      let contentType = "application/json";
+      if (url.pathname === "/") {
+        body = homePage;
+        contentType = "text/html";
+      } else if (url.pathname === "/auth/failed") {
+        body = authFailedPage;
+        contentType = "text/html";
+      } else if (url.pathname === "/home.js") {
+        body = homeScript;
+        contentType = "text/javascript";
+      } else if (url.pathname === "/service-client.js") {
+        body = runClientScript;
+        contentType = "text/javascript";
+      } else if (url.pathname === "/runs/demo-run/") {
+        body = sourceHtml;
+        contentType = "text/html";
+      } else if (
+        url.pathname.endsWith("app.js") ||
+        url.pathname.endsWith("app.css")
+      ) {
+        const name = url.pathname.endsWith("app.js") ? "app.js" : "app.css";
+        body = readFileSync(join(dist, name), "utf8");
+        contentType = name.endsWith("js") ? "text/javascript" : "text/css";
+      } else if (url.pathname === "/api/v1/runs")
+        body = JSON.stringify({
+          total: 2,
+          build_id: "synthetic-build",
+          runs: [
+            {
+              id: "demo-run",
+              revision: ledger.revision,
+              owner_thread_id: "synthetic-main",
+            },
+            { id: "archive-run", error: "INCOMPATIBLE_LEDGER" },
+          ],
+        });
+      else if (url.pathname.endsWith("/api/view"))
+        body = JSON.stringify({
+          revision: ledger.revision,
+          watching: true,
+          active_plan_id: ledger.active_plan_id,
+          view: buildView(ledger, url.searchParams.get("plan") ?? undefined),
+        });
+      else if (url.pathname.endsWith("/api/preferences"))
+        body = JSON.stringify({ schema_version: 1, theme: "light" });
+      else if (url.pathname.endsWith("/api/service"))
+        body = JSON.stringify({
+          build_id: "synthetic-build",
+          warning: "自定义视图不兼容，已使用共享模板。",
+        });
+      else body = "{}";
+      await route.fulfill({ body, contentType });
+    });
+    const demo = await context.newPage();
+    await demo.clock.setFixedTime("2026-11-04T09:00:00.000Z");
+    await demo.goto("http://mtf.test/");
+    await demo.getByRole("link", { name: "demo-run", exact: true }).waitFor();
+    const homeImage = `runs-${viewport.width}.png`;
+    await demo.screenshot({ path: join(output, homeImage), fullPage: true });
+    images.push(homeImage);
+    await demo.getByRole("link", { name: "demo-run", exact: true }).click();
+    await demo
+      .getByText("自定义视图不兼容，已使用共享模板。", { exact: true })
+      .waitFor();
+    await demo.waitForFunction(
+      () =>
+        document.querySelectorAll(".task-card").length > 0 ||
+        document.querySelectorAll("[data-task-id]").length > 0,
+    );
+    const runImage = `run-${viewport.width}.png`;
+    await demo.screenshot({ path: join(output, runImage), fullPage: true });
+    images.push(runImage);
+    await demo.goto("http://mtf.test/auth/failed?redirect=%2Fruns%2Fdemo-run%2F");
+    await demo
+      .getByText("一次性登录入口已过期或已使用。", {
+        exact: true,
+      })
+      .waitFor();
+    const authFailedImage = `auth-failed-${viewport.width}.png`;
+    await demo.screenshot({ path: join(output, authFailedImage), fullPage: true });
+    images.push(authFailedImage);
+    await context.close();
+  }
+  scenarios.push(
+    "pure frontend desktop and 393x852 mobile runs, compatibility fallback and authentication failure",
+  );
+  writeFileSync(
+    join(output, "evidence.json"),
+    JSON.stringify(
+      {
+        candidate_sha: Bun.spawnSync(["git", "rev-parse", "HEAD"])
+          .stdout.toString()
+          .trim(),
+        source: "ui_demo",
+        backend: "mock-only for captures",
+        images,
+        scenarios,
+      },
+      null,
+      2,
+    ),
+  );
+} finally {
+  await viewer.stop();
+  await browser.close();
+  rmSync(fixture.root, { recursive: true, force: true });
+}