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

package/toolkit/skills/multi-task-flow/tests/ui/pr-status.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import { bindPRStatus, publishPRStatus } from "../../web/pr-status";
+import type { PRSnapshot } from "../../lib/pr-details";
+
+test("PR icons distinguish merge and CI states and share one request per URL", async () => {
+  const original = globalThis.fetch;
+  let calls = 0;
+  const url = "https://github.com/example/repo/pull/985";
+  const snapshot: PRSnapshot = { data: { number: 985, title: "PR", url, state: "MERGED", mergedAt: null, mergeable: "UNKNOWN", ci: "成功", checks: [] }, observed_at: null, stale: false, loading: false, error: null };
+  globalThis.fetch = (async () => { calls++; return Response.json(snapshot); }) as typeof fetch;
+  const a = document.createElement("a"), b = document.createElement("a");
+  a.setAttribute("aria-label", "打开任务 PR"); b.setAttribute("aria-label", "打开交付单元 PR"); document.body.append(a, b);
+  try {
+    bindPRStatus(a, "task", "one", url); bindPRStatus(b, "group", "two", url);
+    await new Promise(resolve => setTimeout(resolve, 0));
+    expect(calls).toBe(1); expect(a.dataset.prState).toBe("MERGED"); expect(b.dataset.ciState).toBe("成功");
+    expect(a.getAttribute("aria-label")).toContain("已合并 · CI 成功");
+    publishPRStatus(url, { ...snapshot, data: { ...snapshot.data!, ci: "失败" } }); expect(a.dataset.ciState).toBe("失败");
+    publishPRStatus(url, { ...snapshot, data: { ...snapshot.data!, ci: "运行中" } }); expect(b.dataset.ciState).toBe("运行中");
+    a.remove(); publishPRStatus(url, snapshot); expect(b.dataset.ciState).toBe("成功");
+  } finally { globalThis.fetch = original; a.remove(); b.remove(); }
+});
+
+test("an older card response cannot overwrite a newer popover publication", async () => {
+  const original = globalThis.fetch;
+  const url = "https://github.com/example/repo/pull/986";
+  let resolve!: (value: Response) => void;
+  globalThis.fetch = (() => new Promise<Response>(done => { resolve = done; })) as typeof fetch;
+  const trigger = document.createElement("a"); document.body.append(trigger);
+  const latest: PRSnapshot = { data: { number: 986, title: "PR", url, state: "MERGED", mergedAt: null, mergeable: "UNKNOWN", ci: "成功", checks: [] }, observed_at: "2026-11-07T01:00:00Z", stale: false, loading: false, error: null };
+  try {
+    bindPRStatus(trigger, "task", "one", url);
+    publishPRStatus(url, latest);
+    resolve(Response.json({ ...latest, observed_at: null, data: { ...latest.data!, state: "OPEN", ci: "失败" } }));
+    await new Promise(done => setTimeout(done, 0));
+    expect(trigger.dataset.prState).toBe("MERGED"); expect(trigger.dataset.ciState).toBe("成功");
+    const next = document.createElement("a"); document.body.append(next);
+    bindPRStatus(next, "group", "two", url);
+    expect(next.dataset.prState).toBe("MERGED"); next.remove();
+  } finally { globalThis.fetch = original; trigger.remove(); }
+});
+
+test("out-of-order timestamped PR publications retain the newer observed result", () => {
+  const url = "https://github.com/example/repo/pull/987";
+  const snapshot: PRSnapshot = { data: { number: 987, title: "PR", url, state: "MERGED", mergedAt: null, mergeable: "UNKNOWN", ci: "成功", checks: [] }, observed_at: "2026-11-07T02:00:00Z", stale: false, loading: false, error: null };
+  publishPRStatus(url, snapshot);
+  const trigger = document.createElement("a"); document.body.append(trigger);
+  try {
+    bindPRStatus(trigger, "task", "one", url);
+    publishPRStatus(url, { ...snapshot, observed_at: "2026-11-07T01:00:00Z", data: { ...snapshot.data!, state: "OPEN", ci: "失败" } });
+    expect(trigger.dataset.prState).toBe("MERGED"); expect(trigger.dataset.ciState).toBe("成功");
+  } finally { trigger.remove(); }
+});

package/toolkit/skills/multi-task-flow/tests/ui/profile-editor.test.ts

@@ -0,0 +1,81 @@
+import { expect, test } from "bun:test";
+import { createProfileEditor } from "../../web/profile-editor";
+const profile = { model: "gpt-6.1-sol", thinking: "medium" };
+const capabilities = [{ model: "gpt-6.1-sol", thinking: ["medium", "high"] }];
+
+test("editor submits a full pair and keeps server failures visible", async () => {
+  let received: unknown;
+  const editor = createProfileEditor({ capabilities, update: async (...args) => { received = args; throw new Error("Ledger version changed"); } }, "task", "a", profile, profile, null);
+  document.body.append(editor);
+  (editor.querySelector(".profile-save") as HTMLButtonElement).click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  expect(received).toEqual(["task", "a", profile, false]);
+  expect(editor.querySelector('[role="alert"]')?.textContent).toBe("Ledger version changed");
+  editor.remove();
+});
+
+test("unavailable capabilities disable mutation and frozen profiles have no edit controls", () => {
+  const unavailable = createProfileEditor({ capabilities: null, capabilityError: "Catalog unavailable", update: async () => {} }, "task", "a", profile, profile, null);
+  expect((unavailable.querySelector(".profile-save") as HTMLButtonElement).disabled).toBe(true);
+  expect(unavailable.textContent).toContain("Catalog unavailable");
+  const frozen = createProfileEditor({ capabilities, update: async () => {} }, "task", "a", profile, profile, "对话创建请求已提交，须先对账");
+  expect(frozen.querySelector("select")).toBeNull();
+  expect(frozen.textContent).toContain("须先对账");
+});
+
+test("run default inheritance is selected and cleared as one pair", async () => {
+  let received: unknown;
+  const editor = createProfileEditor({ capabilities, update: async (...args) => { received = args; } }, "task", "a", null, profile, null);
+  expect((editor.querySelector('input[type="range"]') as HTMLInputElement).disabled).toBe(true);
+  (editor.querySelector(".profile-save") as HTMLButtonElement).click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  expect(received).toEqual(["task", "a", null, false]);
+});
+
+test("run profile uses a neutral settings icon trigger", () => {
+  const editor = createProfileEditor({ capabilities, update: async () => {} }, "run", "run", profile, profile, null);
+  const trigger = editor.querySelector<HTMLElement>(".profile-trigger")!;
+  expect(trigger.textContent?.trim()).toBe("");
+  expect(trigger.dataset.profileStatus).toBeUndefined();
+  expect(trigger.dataset.tooltip).toBe("默认执行配置");
+  expect(trigger.querySelector('[data-lucide="settings-2"]')).not.toBeNull();
+});
+
+test("profile dropdown uses a model list and discrete thinking slider", async () => {
+  let received: unknown;
+  const editor = createProfileEditor({ capabilities, update: async (...args) => { received = args; } }, "task", "a", profile, profile, null);
+  expect(editor.querySelector("details")?.open).toBe(false);
+  expect(editor.querySelectorAll('[aria-haspopup="listbox"]')).toHaveLength(1);
+  const slider = editor.querySelector('input[type="range"]') as HTMLInputElement;
+  slider.value = "1"; slider.dispatchEvent(new Event("input"));
+  expect(slider.getAttribute("aria-valuetext")).toBe("high");
+  (editor.querySelector(".profile-save") as HTMLButtonElement).click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  expect(received).toEqual(["task", "a", { model: profile.model, thinking: "high" }, false]);
+});
+
+test("inheritance cannot submit a default pair absent from the capability catalog", () => {
+  const editor = createProfileEditor({ capabilities: [], update: async () => {} }, "task", "a", null, profile, null);
+  expect((editor.querySelector(".profile-save") as HTMLButtonElement).disabled).toBe(true);
+});
+
+test("model menu supports keyboard selection and Escape without closing the profile panel", () => {
+  const editor = createProfileEditor({ capabilities: [...capabilities, { model: "gpt-6-luna", thinking: ["medium"] }], update: async () => {} }, "task", "a", profile, profile, null);
+  document.body.append(editor);
+  const details = editor.querySelector("details")!; details.open = true;
+  const trigger = editor.querySelector<HTMLButtonElement>('[aria-haspopup="listbox"]')!;
+  trigger.click();
+  expect(trigger.getAttribute("aria-expanded")).toBe("true");
+  const list = editor.querySelector<HTMLElement>('[role="listbox"]')!;
+  const selected = list.querySelector<HTMLButtonElement>('[aria-selected="true"]')!;
+  selected.dispatchEvent(new window.KeyboardEvent("keydown", { key: "End", bubbles: true }));
+  expect(document.activeElement?.textContent).toBe("gpt-6-luna");
+  (document.activeElement as HTMLButtonElement).click();
+  expect(trigger.textContent).toBe("gpt-6-luna");
+  expect(trigger.getAttribute("aria-expanded")).toBe("false");
+  trigger.click();
+  list.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+  expect(document.activeElement).toBe(trigger);
+  expect(details.open).toBe(true);
+  editor.remove();
+});

package/toolkit/skills/multi-task-flow/tests/ui/resource-popover.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { attachResourcePopover, closeResourcePopover, refreshResourcePopover, timingText, type ResourceSource } from "../../web/resource-popover";
+import type { View } from "../../web/model";
+const view = { nodes: [{ id: "n", kind: "task", ref_id: "task" }], tasks: [{ id: "task", pr: { url: "https://github.com/example/repo/pull/42" } }], planned_intervals: [{ node_id: "n", start: "2026-11-07T00:00:00Z", end: "2026-11-07T00:10:00Z" }] } as View;
+const source = (): ResourceSource => ({ kind: "task", id: "task", thread: "thread", start: "2026-11-07T00:00:00Z", end: "2026-11-07T00:15:00Z", view, output: () => ({ state: "available", text: "<unsafe>\nFull response", thread_title: "真实标题", thread_id: "thread", turn_id: "turn", message_id: "message", phase: "commentary", message_status: "in_progress", observed_at: null, stale: false }) });
+beforeEach(() => { closeResourcePopover(); document.body.replaceChildren(); });
+afterEach(() => { closeResourcePopover(); document.body.replaceChildren(); });
+test("interactive dialog supports keyboard entry and Escape without reopening or copying the response", async () => {
+  const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "conversation", source());
+  trigger.focus();
+  const panel = document.querySelector<HTMLElement>(".resource-popover")!;
+  expect(panel.getAttribute("role")).toBe("dialog"); expect(panel.textContent).toContain("真实标题"); expect(panel.querySelector("unsafe")).toBeNull();
+  expect([...panel.querySelectorAll("button")].map(b => b.getAttribute("aria-label"))).toEqual(["复制对话 ID", "复制标题"]);
+  document.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
+  expect(panel.contains(document.activeElement)).toBe(true);
+  document.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+  expect(trigger.getAttribute("aria-expanded")).toBe("false"); expect(document.activeElement).toBe(trigger); expect(document.querySelector(".resource-popover")).toBeNull();
+});
+test("stream refresh preserves response scroll and switches to the latest message", () => {
+  const s = source(); let output = s.output()!; s.output = () => output;
+  const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "conversation", s); trigger.focus();
+  const body = document.querySelector<HTMLElement>(".resource-body")!; body.scrollTop = 120;
+  output = { ...output, text: "new streamed message" }; refreshResourcePopover();
+  expect(body.textContent).toContain("new streamed message"); expect(body.scrollTop).toBe(120);
+  trigger.remove(); refreshResourcePopover(); expect(document.querySelector(".resource-popover")).toBeNull();
+});
+test("scrolling the popover body does not reposition the floating panel", () => {
+  const trigger = document.createElement("button"); document.body.append(trigger);
+  let top = 300;
+  trigger.getBoundingClientRect = () => ({ top, bottom: top + 24, left: 40, right: 120, width: 80, height: 24, x: 40, y: top, toJSON: () => ({}) }) as DOMRect;
+  attachResourcePopover(trigger, "conversation", source()); trigger.focus();
+  const panel = document.querySelector<HTMLElement>(".resource-popover")!;
+  const positionedTop = panel.style.top;
+  top = 500;
+  document.querySelector<HTMLElement>(".resource-body")!.dispatchEvent(new Event("scroll", { bubbles: true }));
+  expect(panel.style.top).toBe(positionedTop);
+});
+test("elapsed budget includes the entire recorded duration and rejects nonpositive schedules", () => {
+  expect(timingText(source())).toContain("用时占比：150%\n超出排期：50%");
+  const s = source(); s.view = { ...view, planned_intervals: [] }; expect(timingText(s)).toContain("用时占比：不可用");
+  s.start = null; expect(timingText(s)).not.toContain("150%");
+});
+test("a new trigger replaces the previous dialog", () => {
+  const a = document.createElement("button"), b = document.createElement("button"); document.body.append(a, b);
+  attachResourcePopover(a, "conversation", source()); attachResourcePopover(b, "time", source()); a.focus(); b.focus();
+  expect(a.getAttribute("aria-expanded")).toBe("false"); expect(document.querySelectorAll(".resource-popover")).toHaveLength(1);
+});
+
+test("hover allows entering the dialog across the gap and closes after leaving both", async () => {
+  const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "conversation", source());
+  trigger.dispatchEvent(new window.PointerEvent("pointerenter", { pointerType: "mouse" }));
+  await new Promise(r => setTimeout(r, 270));
+  const panel = document.querySelector<HTMLElement>(".resource-popover")!;
+  trigger.dispatchEvent(new window.PointerEvent("pointerleave", { pointerType: "mouse" })); panel.dispatchEvent(new window.PointerEvent("pointerenter", { pointerType: "mouse" }));
+  await new Promise(r => setTimeout(r, 200)); expect(panel.isConnected).toBe(true);
+  panel.dispatchEvent(new window.PointerEvent("pointerleave", { pointerType: "mouse" }));
+  await new Promise(r => setTimeout(r, 200)); expect(panel.isConnected).toBe(false);
+});
+
+test("copy controls write only their own identity value", async () => {
+  const writes: string[] = [];
+  const clipboard = Object.getOwnPropertyDescriptor(window.navigator, "clipboard");
+  Object.defineProperty(window.navigator, "clipboard", { configurable: true, value: { writeText: async (value: string) => { writes.push(value); } } });
+  const previous = Object.getOwnPropertyDescriptor(globalThis, "navigator");
+  Object.defineProperty(globalThis, "navigator", { configurable: true, value: window.navigator });
+  try {
+    const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "conversation", source()); trigger.focus();
+    const buttons = document.querySelectorAll<HTMLButtonElement>(".resource-popover button"); buttons[0]!.click(); buttons[1]!.click(); await Promise.resolve();
+    expect(writes).toEqual(["thread", "真实标题"]); expect(buttons[0]!.dataset.feedback).toBe("已复制");
+  } finally {
+    if (clipboard) Object.defineProperty(window.navigator, "clipboard", clipboard); else Reflect.deleteProperty(window.navigator, "clipboard");
+    if (previous) Object.defineProperty(globalThis, "navigator", previous); else Reflect.deleteProperty(globalThis, "navigator");
+  }
+});
+
+test("failed PR transport exposes retry without losing its trigger", async () => {
+  const original = globalThis.fetch;
+  globalThis.fetch = (async () => { throw new Error("network unavailable"); }) as typeof fetch;
+  try {
+    const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "pr", source()); trigger.dispatchEvent(new window.PointerEvent("pointerenter", { pointerType: "mouse" }));
+    await new Promise(r => setTimeout(r, 270));
+    expect(document.querySelector('.resource-body')?.textContent).toContain("详情加载失败");
+    expect(document.querySelector<HTMLButtonElement>('button[data-retry]')?.textContent).toBe("重试");
+    expect(trigger.getAttribute("aria-expanded")).toBe("true");
+  } finally { globalThis.fetch = original; }
+});
+
+test("PR identity renders before the details response", async () => {
+  const original = globalThis.fetch;
+  let resolve!: (response: Response) => void;
+  globalThis.fetch = (() => new Promise<Response>(r => { resolve = r; })) as typeof fetch;
+  try {
+    const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "pr", source()); trigger.dispatchEvent(new window.PointerEvent("pointerenter", { pointerType: "mouse" })); await new Promise(r => setTimeout(r, 270));
+    const panel = document.querySelector<HTMLElement>(".resource-popover")!;
+    expect(panel.textContent).toContain("#42"); expect(panel.textContent).toContain("https://github.com/example/repo/pull/42");
+    expect(panel.getAttribute("aria-busy")).toBe("true"); expect(panel.querySelectorAll(".resource-skeleton").length).toBeGreaterThan(0);
+    resolve(new Response(JSON.stringify({ data: { number: 42, title: "PR 标题", url: "https://github.com/example/repo/pull/42", state: "OPEN", mergedAt: null, mergeable: "MERGEABLE", checks: [], ci: "未配置" }, observed_at: null, stale: false, loading: false, error: null })));
+    await new Promise(r => setTimeout(r, 0));
+  } finally { globalThis.fetch = original; }
+});
+
+test("unbound PR shows an immediate empty state without fetching", async () => {
+  const original = globalThis.fetch; let calls = 0; globalThis.fetch = (async () => { calls++; throw new Error("must not fetch"); }) as typeof fetch;
+  try {
+    const unbound = { ...source(), view: { ...view, tasks: [{ id: "task", pr: null }] } as View };
+    const trigger = document.createElement("button"); document.body.append(trigger); attachResourcePopover(trigger, "pr", unbound); trigger.focus(); await new Promise(r => setTimeout(r, 0));
+    expect(document.querySelector(".resource-body")?.textContent).toContain("尚未关联 PR"); expect(calls).toBe(0);
+  } finally { globalThis.fetch = original; }
+});

package/toolkit/skills/multi-task-flow/tests/ui/responsive-width-contract.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+const css = readFileSync(new URL("../../web/app.css", import.meta.url), "utf8");
+
+test("medium layout shares container-derived card tracks across detail states", () => {
+  const medium = css.split("@media (min-width: 768px) and (max-width: 1444px) {")[1]!.split("@media (max-width: 767px)")[0]!;
+  expect(medium).toContain("container-type: inline-size");
+  expect(medium).toContain("round(down, calc((100cqw + 20px) / 263px), 1)");
+  expect(medium).toContain("repeat(auto-fill, var(--stable-task-card-width))");
+  expect(medium).not.toContain("minmax(243px, 1fr)");
+});
+
+test("identity actions follow the project name instead of filling the title row", () => {
+  expect(css).toContain(".identity-copy { flex: 0 1 auto; min-width: 0; }");
+  expect(css).toContain("text-overflow: ellipsis; white-space: nowrap;");
+});
+
+test("mobile theme entry shares the title row centerline", () => {
+  expect(css).toContain(".topbar .theme-control { position: absolute; top: 12px; right: 16px; width: 44px; height: 44px; min-height: 44px; }");
+});
+
+test("compact header icons use optical rather than box-edge spacing", () => {
+  expect(css).toContain(".run-profile-control { flex: 0 0 auto; min-width: 0; margin-left: -1px; }");
+  expect(css).toContain("display: inline-flex; align-items: center; justify-content: center; width: 30px;");
+  expect(css).toContain("width: 16px; height: 16px; flex: 0 0 16px; transform: translateX(-0.5px);");
+});
+
+test("mobile header actions use 44px touch targets and 18px icons", () => {
+  expect(css).toContain(".topbar .plan-info-trigger { width: 44px; height: 44px; min-height: 44px; flex: 0 0 44px; margin-left: -8px; }");
+  expect(css).toContain(".topbar .theme-control .theme-trigger { width: 44px; height: 44px; min-height: 44px;");
+  expect(css).toContain(".run-profile-control { flex: 0 0 44px; width: 44px; margin-left: -8px; }");
+  expect(css).toContain("width: 18px; height: 18px; flex: 0 0 18px;");
+});

package/toolkit/skills/multi-task-flow/tests/ui/service-navigation.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { runClientScript } from "../../lib/service-pages";
+
+test("navigation and compatibility warnings stay inside the dashboard", async () => {
+  const dom = new Window({
+    url: "http://localhost/runs/orchestration-viewer/",
+  });
+  dom.document.body.innerHTML =
+    '<div class="shell"><header><div class="brand-mark" aria-hidden="true"><span>icon</span></div></header><main><div id="connection-notice" hidden></div></main></div>';
+  dom.setInterval = (() => setTimeout(() => {}, 0)) as typeof dom.setInterval;
+  dom.fetch = async (url) =>
+    new dom.Response(
+      JSON.stringify(
+        url === "api/service"
+          ? { build_id: "candidate", warning: "兼容性提示" }
+          : {},
+      ),
+      { status: 200 },
+    );
+  dom.eval(runClientScript);
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  expect(dom.document.body.children.length).toBe(1);
+  const home = dom.document.querySelector("header a");
+  expect(home?.getAttribute("href")).toBe("/");
+  expect(home?.getAttribute("aria-label")).toBe("全部编排运行");
+  expect(home?.getAttribute("aria-hidden")).toBeNull();
+  expect(dom.document.querySelector("main .notice")?.textContent).toBe(
+    "兼容性提示",
+  );
+  expect(dom.document.body.textContent).not.toContain("service ensure");
+  await dom.happyDOM.close();
+});
+test("lease failures signal the dashboard without adding another banner", async () => {
+  const dom = new Window({
+    url: "http://localhost/runs/orchestration-viewer/",
+  });
+  dom.document.body.innerHTML =
+    '<div class="shell"><div id="connection-notice">快照提示</div></div>';
+  dom.setInterval = (() => setTimeout(() => {}, 0)) as typeof dom.setInterval;
+  let expired = false;
+  dom.document.addEventListener("service-session", (event) => {
+    expired = event instanceof dom.CustomEvent && Boolean(event.detail.expired);
+  });
+  dom.fetch = async () => new dom.Response("{}", { status: 401 });
+  dom.eval(runClientScript);
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  expect(expired).toBe(true);
+  expect(dom.document.body.children.length).toBe(1);
+  expect(dom.document.querySelector("#connection-notice")?.textContent).toBe(
+    "快照提示",
+  );
+  await dom.happyDOM.close();
+});

package/toolkit/skills/multi-task-flow/tests/ui/setup.ts

@@ -0,0 +1,13 @@
+import { Window } from "happy-dom";
+
+const dom = new Window({ url: "http://localhost/" });
+
+Object.assign(globalThis, {
+  window: dom,
+  document: dom.document,
+  HTMLElement: dom.HTMLElement,
+  HTMLButtonElement: dom.HTMLButtonElement,
+  DOMRect: dom.DOMRect,
+  Event: dom.Event,
+  Node: dom.Node,
+});

package/toolkit/skills/multi-task-flow/tests/ui/task-context-menu.test.ts

@@ -0,0 +1,74 @@
+import { afterEach, expect, test } from "bun:test";
+import { atomUrl, groupUrl, installTaskContextMenu, milestoneUrl, taskPRs, taskUrl } from "../../web/task-context-menu";
+import { parseViewerTarget } from "../../lib/service-pages";
+import type { Task, View } from "../../web/model";
+import { parseViewState } from "../../web/view-state";
+const task = { id: "C2", title: "完整任务标题", thread_id: "thread-123", pr: { url: "https://github.com/example/repo/pull/1" } } as Task;
+const view = { tasks: [task], follow_prs: [{ origin_task_id: "C2", pr: { url: "https://github.com/example/repo/pull/2" } }] } as View;
+const group = { id: "G2", title: "交付单元二" };
+let controller: ReturnType<typeof installTaskContextMenu> | undefined;
+afterEach(() => { controller?.destroy(); document.body.replaceChildren(); });
+function setup(value = view, reject = false) {
+  controller?.destroy(); document.body.replaceChildren();
+  const copied: string[] = [];
+  document.body.innerHTML = '<div class="task-card" data-context-task="C2"><button>任务</button></div>';
+  controller = installTaskContextMenu({ getData: () => value, writeText: async text => { if (reject) throw Error("denied"); copied.push(text); } });
+  const target = document.querySelector<HTMLElement>("[data-context-task]")!;
+  const event = new window.MouseEvent("contextmenu", { bubbles: true, cancelable: true, clientX: 30, clientY: 40 });
+  target.dispatchEvent(event); expect(event.defaultPrevented).toBe(true); return copied;
+}
+const button = (text: string) => [...document.querySelectorAll<HTMLButtonElement>(".task-context-menu button")].find(item => item.textContent === text)!;
+test("task URL drops credentials, history and filters; restores task details", () => {
+  const url = new URL(taskUrl("http://user:secret@localhost:12000/runs/run-a/?plan=old&q=hidden&group=other&zoom=2&ticket=secret#token", "C2"));
+  expect(url.pathname).toBe("/runs/run-a/"); expect([...url.searchParams.keys()]).toEqual(["selected", "detail"]); expect(url.username + url.password + url.hash).toBe("");
+  const state = parseViewState(url.search); expect(state.selected).toEqual({ kind: "task", id: "C2" }); expect(state.detail).toBe(true); expect(state.plan).toBeNull(); expect(state.query).toBe("");
+});
+test("group URL selects the delivery unit and preserves only canonical detail state", () => {
+  const url = new URL(groupUrl("http://user:secret@localhost:12000/runs/run-a/?plan=old&q=hidden#token", group.id));
+  expect(url.pathname).toBe("/runs/run-a/");
+  expect([...url.searchParams.keys()]).toEqual(["selected", "detail"]);
+  expect(parseViewState(url.search).selected).toEqual({ kind: "group", id: group.id });
+});
+test("milestone and atom URLs preserve their focus targets", () => {
+  const milestone = new URL(milestoneUrl("http://localhost:12000/runs/run-a/?q=hidden", "core-merge", "group-atom-core-4"));
+  expect(parseViewState(milestone.search)).toMatchObject({ selected: { kind: "milestone", id: "core-merge" }, atom: "group-atom-core-4", detail: true });
+  const atom = new URL(atomUrl("http://localhost:12000/runs/run-a/", { kind: "task", id: "C2" }, "atom-C2"));
+  expect(parseViewState(atom.search)).toMatchObject({ selected: { kind: "task", id: "C2" }, atom: "atom-C2", detail: true });
+});
+test("five copy actions use full title, raw ID and canonical conversation URL", async () => {
+  let copied = setup(); expect(document.querySelectorAll('.task-context-menu > [role=menuitem]')).toHaveLength(5);
+  button("复制任务名").click(); await Promise.resolve(); expect(copied).toEqual([task.title]);
+  copied = setup(); button("复制任务 ID").click(); await Promise.resolve(); expect(copied).toEqual(["C2"]);
+  copied = setup(); button("复制对话链接").click(); await Promise.resolve(); expect(copied).toEqual(["codex://threads/thread-123"]);
+});
+test("multiple PRs require explicit selection", async () => {
+  const copied = setup(); button("复制 PR 链接 ›").click(); expect(copied).toEqual([]); expect(document.querySelectorAll('.task-context-submenu button')).toHaveLength(2);
+  button("https://github.com/example/repo/pull/2").click(); await Promise.resolve(); expect(copied).toEqual(["https://github.com/example/repo/pull/2"]);
+  expect(taskPRs(task, { ...view, follow_prs: [...view.follow_prs, { origin_task_id: "C2", pr: task.pr! }] } as View)).toHaveLength(2);
+});
+test("missing resource actions are disabled, copy rejection is visible", async () => {
+  setup({ ...view, tasks: [{ ...task, thread_id: null, pr: null }], follow_prs: [] }); expect(document.querySelectorAll('[aria-disabled=true]')).toHaveLength(2); expect(document.querySelector('.task-context-menu')?.textContent).toContain("尚未绑定对话");
+  setup(view, true); button("复制任务名").click(); await Promise.resolve(); await Promise.resolve(); expect(document.querySelector('[role=status]')?.textContent).toContain("复制失败");
+});
+test("delivery unit menu copies its stable ID and URL", async () => {
+  const copied: string[] = [];
+  document.body.innerHTML = '<article data-context-kind="group" data-context-id="G2"><button>交付单元</button></article>';
+  controller = installTaskContextMenu({ getData: () => ({ ...view, groups: [group] } as View), writeText: async text => { copied.push(text); } });
+  const target = document.querySelector<HTMLElement>("[data-context-kind=group]")!;
+  target.dispatchEvent(new window.MouseEvent("contextmenu", { bubbles: true, cancelable: true, clientX: 10, clientY: 10 }));
+  expect([...document.querySelectorAll<HTMLButtonElement>(".task-context-menu button")].map(button => button.textContent)).toEqual(["复制交付单元 ID", "复制交付单元链接"]);
+  document.querySelector<HTMLButtonElement>(".task-context-menu button")!.click();
+  await Promise.resolve();
+  expect(copied).toEqual([group.id]);
+});
+test("keyboard opening, navigation and Escape; blank space retains native menu", () => {
+  setup(); controller!.close(); const target = document.querySelector('button')!; target.focus();
+  target.dispatchEvent(new window.KeyboardEvent("keydown", { key: "F10", shiftKey: true, bubbles: true, cancelable: true })); expect(document.activeElement?.textContent).toBe("复制任务名");
+  document.activeElement!.dispatchEvent(new window.KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true })); expect(document.activeElement?.textContent).toBe("复制任务 ID");
+  document.activeElement!.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Escape", bubbles: true })); expect(document.querySelector('.task-context-menu')).toBeNull();
+  const event = new window.MouseEvent("contextmenu", { bubbles: true, cancelable: true }); document.body.dispatchEvent(event); expect(event.defaultPrevented).toBe(false);
+});
+test("authentication redirects only accept same-service run links and legal view state", () => {
+  expect(parseViewerTarget('/runs/run-a/?selected=task%3Atask.v2&detail=1&plan=plan.v2&q=hidden', 'http://localhost', { allowHome: false })?.target).toBe('/runs/run-a/?selected=task%3Atask.v2&detail=1&plan=plan.v2&q=hidden');
+  for (const value of ['https://evil.test/runs/run-a/?selected=task:C2', '//evil.test/runs/run-a/?selected=task:C2', '/login?selected=task:C2', '/runs/run-a/../', '/runs/%2e%2e/', '/runs\\run-a/', '/runs/run-a/?selected=other:C2', '/runs/run-a/?selected=task:<script>', 'http://user:pass@localhost/runs/run-a/?selected=task:C2', '/runs/run-a/?ticket=secret', '/runs/run-a/?selected=task:C2&selected=task:C3', '/runs/run-a/?q=%0d%0aLocation:%20https://evil.test']) expect(parseViewerTarget(value, 'http://localhost', { allowHome: false })).toBeNull();
+});

package/toolkit/skills/multi-task-flow/tests/ui/timeline-window.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { defaultTimelineWindow } from "../../web/timeline-window";
+
+describe("dashboard timeline window", () => {
+  test("fits a timeline containing only a milestone", () => {
+    const window = defaultTimelineWindow([{ start: "2026-10-31T12:00:00.000Z" }]);
+    expect(window.start?.getTime()).toBeLessThan(Date.parse("2026-10-31T12:00:00.000Z"));
+    expect(window.end?.getTime()).toBeGreaterThan(Date.parse("2026-10-31T12:00:00.000Z"));
+  });
+
+  test("ignores unknown timestamps without losing known entries", () => {
+    const window = defaultTimelineWindow([{ start: "not-a-date" }, { start: "2026-10-31T12:00:00.000Z", end: null }]);
+    expect(window.start).toBeInstanceOf(Date);
+    expect(window.end).toBeInstanceOf(Date);
+  });
+});

package/toolkit/skills/multi-task-flow/tests/ui/timestamp.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { formatLocalTime, fullLocalTime } from "../../web/time";
+import { renderTimestamp, refreshTimestamps } from "../../web/timestamp";
+import { renderStatusRow } from "../../web/status-row";
+
+describe("local timestamps", () => {
+  const now = Date.parse("2026-11-05T12:00:00Z");
+  test("uses the exact twelve-hour and seven-day boundaries", () => {
+    expect(formatLocalTime(new Date(now - 12 * 3600000 + 1).toISOString(), now)).toMatch(/^\d{2}:\d{2}$/);
+    expect(formatLocalTime(new Date(now - 12 * 3600000).toISOString(), now)).toBe("12小时前");
+    expect(formatLocalTime(new Date(now - 7 * 86400000 + 1).toISOString(), now)).toBe("6天前");
+    expect(formatLocalTime(new Date(now - 7 * 86400000).toISOString(), now)).toMatch(/^10月29日 \d{2}:\d{2}$/);
+  });
+  test("shows absolute dates and seconds without a timezone label", () => {
+    expect(fullLocalTime("2026-11-05T10:42:03Z")).toMatch(/^2026\/11\/05 \d{2}:42:03$/);
+  });
+  test("omits absent times and exposes a full absolute tooltip on focus", () => {
+    expect(renderTimestamp(null).textContent).toBe("");
+    const row = renderStatusRow({ name: "验收", status: "planned" });
+    expect(row.querySelector("time")).toBeNull();
+    document.body.replaceChildren(renderTimestamp("2026-11-05T10:42:03Z"));
+    const time = document.querySelector("time")!;
+    time.focus();
+    expect(document.querySelector(".timestamp-tooltip.is-open")?.textContent).toBe(fullLocalTime(time.dateTime));
+    expect(document.querySelector(".timestamp-tooltip")?.textContent).toContain("2026");
+    time.textContent = "stale";
+    refreshTimestamps();
+    expect(time.textContent).not.toBe("stale");
+  });
+});

package/toolkit/skills/multi-task-flow/tests/ui/tooltip.test.ts

@@ -0,0 +1,151 @@
+import { beforeEach, expect, test } from "bun:test";
+import { attachTooltip, installTextTooltips } from "../../web/tooltip";
+
+const pause = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+function fixture() {
+  const trigger = document.createElement("button");
+  const outside = document.createElement("button");
+  const content = document.createElement("div");
+  content.textContent = "依赖状态";
+  const tooltip = attachTooltip(trigger, content, "查看依赖");
+  document.body.replaceChildren(trigger, tooltip, outside);
+  return { trigger, tooltip, outside };
+}
+function pointer(target: HTMLElement, type: string, x = 0, y = 0, pointerType = "touch") {
+  target.dispatchEvent(new window.PointerEvent(type, { bubbles: true, pointerType, clientX: x, clientY: y }));
+}
+beforeEach(() => { document.body.replaceChildren(); });
+
+test("focus opens immediately; Escape closes only the tooltip and outside click closes it", () => {
+  const { trigger, tooltip, outside } = fixture();
+  trigger.focus();
+  expect(tooltip.hidden).toBe(false);
+  expect(trigger.getAttribute("aria-describedby")).toBe(tooltip.id);
+  const escape = new window.KeyboardEvent("keydown", { key: "Escape", bubbles: true, cancelable: true });
+  trigger.dispatchEvent(escape);
+  expect(escape.defaultPrevented).toBe(true);
+  expect(tooltip.hidden).toBe(true);
+  outside.focus();
+  trigger.focus();
+  pointer(outside, "pointerdown", 0, 0, "mouse");
+  expect(tooltip.hidden).toBe(true);
+});
+
+test("hover respects its delay and blur dismisses a focus tooltip", async () => {
+  const { trigger, tooltip, outside } = fixture();
+  pointer(trigger, "pointerenter", 0, 0, "mouse");
+  expect(tooltip.hidden).toBe(true);
+  await pause(280);
+  expect(tooltip.hidden).toBe(false);
+  trigger.focus();
+  outside.focus();
+  await pause(10);
+  expect(tooltip.hidden).toBe(true);
+});
+
+test("long press opens after 500ms; movement and release cancel pending presses", async () => {
+  const { trigger, tooltip } = fixture();
+  pointer(trigger, "pointerdown", 10, 10);
+  await pause(540);
+  expect(tooltip.hidden).toBe(false);
+  pointer(trigger, "pointerup");
+  document.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+  pointer(trigger, "pointerdown", 10, 10);
+  pointer(trigger, "pointermove", 21, 10);
+  await pause(540);
+  expect(tooltip.hidden).toBe(true);
+  pointer(trigger, "pointerdown", 10, 10);
+  pointer(trigger, "pointerup", 10, 10);
+  trigger.focus();
+  await pause(540);
+  expect(tooltip.hidden).toBe(true);
+});
+
+
+test("project text tooltips preserve control IDs and cover disabled and dynamically replaced controls", async () => {
+  const button = document.createElement("button"); button.id = "zoom-in"; button.className = "icon-button"; button.dataset.tooltip = "放大";
+  document.body.append(button);
+  const dispose = installTextTooltips();
+  try {
+    expect(button.id).toBe("zoom-in");
+    document.dispatchEvent(new window.KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
+    button.focus();
+    expect(document.querySelector(".control-tooltip.is-open")?.textContent).toBe("放大");
+    button.dataset.tooltip = "更新后的说明";
+    await pause(10);
+    expect(document.querySelector(".control-tooltip.is-open")?.textContent).toBe("更新后的说明");
+    const disabled = document.createElement("button"); disabled.disabled = true; disabled.className = "icon-button"; disabled.dataset.tooltip = "PR 尚未创建";
+    button.replaceWith(disabled); await pause(10);
+    expect(document.querySelectorAll(".control-tooltip").length).toBe(1);
+    pointer(disabled, "pointerenter", 0, 0, "mouse"); await pause(280);
+    expect(document.querySelector(".control-tooltip.is-open")?.textContent).toBe("PR 尚未创建");
+    expect(document.querySelector("[title]")).toBeNull();
+  } finally { dispose(); }
+});
+
+test("ordinary control tooltips do not change an owning aria-expanded state", async () => {
+  const trigger = document.createElement("button");
+  trigger.className = "icon-button";
+  trigger.dataset.tooltip = "查看信息";
+  trigger.setAttribute("aria-expanded", "true");
+  const outside = document.createElement("button");
+  document.body.append(trigger, outside);
+  const dispose = installTextTooltips();
+  try {
+    trigger.focus();
+    expect(document.querySelector(".control-tooltip.is-open")).not.toBeNull();
+    pointer(outside, "pointerdown", 0, 0, "mouse");
+    await pause(10);
+    expect(trigger.getAttribute("aria-expanded")).toBe("true");
+  } finally { dispose(); }
+});
+
+
+test("plain text never gains a tooltip even if it carries a legacy hint", async () => {
+  const output = document.createElement("p"); output.dataset.tooltip = "Agent answer";
+  const title = document.createElement("span"); title.dataset.tooltip = "Task title";
+  const progress = document.createElement("span"); progress.dataset.tooltip = "1/2";
+  const selection = document.createElement("button"); selection.dataset.tooltip = "Select task";
+  document.body.append(output, title, progress, selection);
+  const dispose = installTextTooltips();
+  try {
+    output.dataset.tooltip = "Updated answer";
+    await pause(10);
+    expect(document.querySelector(".control-tooltip")).toBeNull();
+    for (const node of [output, title, progress, selection]) {
+      expect(node.hasAttribute("aria-describedby")).toBe(false);
+      expect(node.classList.contains("dependency-tooltip-anchor")).toBe(false);
+    }
+  } finally { dispose(); }
+});
+
+test("keeps the explicit brand mark hint", () => {
+  document.body.innerHTML = '<a class="brand-mark" data-tooltip="全部编排运行" aria-label="全部编排运行"></a>';
+  const dispose = installTextTooltips();
+
+  expect(document.querySelector(".control-tooltip")?.textContent).toBe("全部编排运行");
+
+  dispose();
+});
+
+test("cleans up a control when its tooltip eligibility is removed", async () => {
+  const button = document.createElement("button");
+  button.className = "icon-button";
+  button.dataset.tooltip = "放大";
+  document.body.append(button);
+  const dispose = installTextTooltips();
+  try {
+    button.focus();
+    expect(button.classList.contains("dependency-tooltip-anchor")).toBe(true);
+    expect(button.hasAttribute("aria-describedby")).toBe(true);
+    button.removeAttribute("data-tooltip");
+    await pause(10);
+    expect(document.querySelector(".control-tooltip")).toBeNull();
+    expect(button.classList.contains("dependency-tooltip-anchor")).toBe(false);
+    expect(button.hasAttribute("aria-describedby")).toBe(false);
+    button.dataset.tooltip = "再次显示";
+    button.classList.remove("icon-button");
+    await pause(10);
+    expect(document.querySelector(".control-tooltip")).toBeNull();
+  } finally { dispose(); }
+});