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

package/toolkit/skills/multi-task-flow/tests/browser/card-width-regression.ts

@@ -0,0 +1,74 @@
+/**
+ * Real-browser acceptance test. Run against the built, mock-only preview.html.
+ * Pass a browser tab (Playwright locator/evaluate API plus getAXState) and the
+ * browser's viewport capability. No simulated DOM or CSS formula assertions.
+ * For the Codex browser REPL, paste this exported function without `export`,
+ * then await checkCardWidths(tab, viewport). Always reset viewport in finally.
+ */
+export async function checkCardWidths(tab, viewport, widths = [1304, 768, 1024, 1120, 1444], layouts = ["board", "grid"]) {
+  const results = [];
+  const measure = () => tab.playwright.evaluate(() => ({
+    cards: [...document.querySelectorAll("#task-list [data-task-id]")].map(el => ({
+      id: el.getAttribute("data-task-id"), width: el.getBoundingClientRect().width,
+    })),
+    columns: [...document.querySelectorAll("#task-list [data-group-id]")].map(el => ({
+      id: el.getAttribute("data-group-id"), width: el.getBoundingClientRect().width,
+    })),
+    workspaceWidth: document.querySelector(".workspace").getBoundingClientRect().width,
+    taskAreaWidth: document.querySelector(".workspace-tasks").getBoundingClientRect().width,
+    detailWidth: document.querySelector("#details").getBoundingClientRect().width,
+    detailVisible: !document.querySelector("#details").hidden,
+    pageOverflow: document.documentElement.scrollWidth > innerWidth,
+  }));
+  const compare = (before, after) => before.length === after.length && before.every(a => {
+    const b = after.find(item => item.id === a.id);
+    return b && a.width > 0 && Math.abs(a.width - b.width) < 1;
+  });
+  try {
+    for (const width of widths) {
+      await viewport.set({ width, height: 1470 });
+      for (const layout of layouts) {
+        if (await tab.playwright.locator("#close-details").isVisible()) {
+          await tab.playwright.locator("#close-details").click();
+          await tab.getAXState({ emit: false });
+        }
+        await tab.playwright.locator(`#task-layout-${layout}`).click();
+        await tab.getAXState({ emit: false });
+        const closed = await measure();
+        await tab.playwright.getByRole("button", { name: "选择任务：只读视图服务与实时更新，状态：待开始", exact: true }).click();
+        await tab.getAXState({ emit: false });
+        const opened = await measure();
+        await tab.playwright.locator("#close-details").click();
+        await tab.getAXState({ emit: false });
+        const reclosed = await measure();
+        const outerCardWidth = layout === "board" ? opened.columns[0]?.width : opened.cards[0]?.width;
+        // Fixed product limits; adding one more complete task track must leave
+        // less than the 243px minimum inspector width (including both gaps).
+        const inspectorFits = opened.detailWidth >= 242.99 && opened.detailWidth <= 740.01
+          && opened.workspaceWidth - (opened.taskAreaWidth + outerCardWidth + 20) - 20 < 243;
+        const passed = inspectorFits && closed.cards.length > 0 && (layout !== "board" || closed.columns.length > 0)
+          && !closed.detailVisible && opened.detailVisible && !reclosed.detailVisible
+          && [opened, reclosed].every(state => compare(closed.cards, state.cards) && compare(closed.columns, state.columns))
+          && [closed, opened, reclosed].every(state => !state.pageOverflow);
+        results.push({ width, layout, passed, closed, opened, reclosed });
+      }
+    }
+  } finally {
+    await viewport.reset();
+    await tab.getAXState({ emit: false });
+  }
+  const crossLayout = widths.map(width => {
+    const board = results.find(row => row.width === width && row.layout === "board");
+    const grid = results.find(row => row.width === width && row.layout === "grid");
+    if (!board || !grid) return { width, passed: true, skipped: true };
+    const passed = ["closed", "opened", "reclosed"].every(state => {
+      const gridWidth = grid[state].cards[0].width;
+      return board[state].columns.every(column => Math.abs(column.width - gridWidth) < 1)
+        && board[state].cards.every(card => Math.abs(gridWidth - card.width - 22) < 1);
+    });
+    return { width, passed };
+  });
+  if (results.some(result => !result.passed) || crossLayout.some(result => !result.passed))
+    throw new Error(JSON.stringify({ passed: false, results, crossLayout }));
+  return { passed: true, results, crossLayout };
+}

package/toolkit/skills/multi-task-flow/tests/check-skills-installation.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { test } from 'bun:test';
+import { checkSkillsInstallation } from '../scripts/check-skills-installation.ts';
+
+test('a source-only skills installation runs official TS entrypoints and detects missing resources', () => {
+  const isolated = realpathSync(mkdtempSync(join(tmpdir(), 'loomhelm-skills-only-')));
+  const source = resolve(import.meta.dirname, '../..');
+  const manifest = JSON.parse(readFileSync(join(source,'source-manifest.json'),'utf8'));
+  const sources = new Set([...manifest.files,...manifest.additions].map(file => resolve(source,'..',file.path)));
+  try {
+    cpSync(source, join(isolated,'skills'), { recursive:true, filter:path => !['node_modules','.cache','dist'].includes(path.split('/').at(-1)) && !path.endsWith('.node') && (!path.endsWith('.js') || sources.has(path)) });
+    const unprepared = checkSkillsInstallation(isolated,{probe:true});
+    assert.equal(unprepared.sourceComplete,true);
+    assert.equal(unprepared.ready,false); assert.equal(unprepared.ok,false);
+    assert.equal(unprepared.code,'SKILLS_RUNTIME_DEPENDENCY_MISSING');
+    assert.deepEqual(unprepared.dependencies.missing.sort(),['sharp','zod']);
+    assert.equal(unprepared.entrypoints.status,'blocked');
+    const install = spawnSync(process.execPath, ['install','--cwd',join(isolated,'skills'),'--frozen-lockfile','--ignore-scripts','--backend=copy'], {env:process.env,encoding:'utf8'});
+    assert.equal(install.status,0,install.stderr);
+    const report = checkSkillsInstallation(isolated,{probe:true});
+    assert.equal(report.ok,true,JSON.stringify(report)); assert.equal(report.ready,true);
+    assert.equal(report.skills,29); assert.deepEqual(report.requiredSparsePaths,['skills']);
+    assert.equal(existsSync(join(isolated,'bin')),false);
+    assert.equal(existsSync(join(isolated,'skills/bin/plan_review_view.js')),false);
+    assert.equal(existsSync(join(isolated,'skills/bin/native/posix.node')),false);
+    const plan=readFileSync(join(isolated,'skills/dev-plan/references/plan-cases/positive-fast-track.md'),'utf8');
+    const finalized=spawnSync('/bin/bash',['-p',join(isolated,'skills/bin/plan-cli.sh'),'--input','-'],{cwd:source,env:process.env,input:plan,encoding:'utf8',timeout:30000});
+    assert.equal(finalized.status,0,finalized.stderr); assert.match(finalized.stdout,/<proposed_plan>/);
+    const context=join(isolated,'skills/dot-codex-development/scripts/context.ts');
+    const original=readFileSync(context); writeFileSync(context,'// tampered');
+    assert.equal(checkSkillsInstallation(isolated).sourceComplete,false);
+    writeFileSync(context,original);
+    renameSync(context,join(isolated,'context.ts')); symlinkSync(join(isolated,'context.ts'),context);
+    assert.equal(checkSkillsInstallation(isolated).ok,false);
+    rmSync(context); renameSync(join(isolated,'context.ts'),context);
+    renameSync(join(isolated,'skills/bin'),join(isolated,'bin'));
+    const broken=checkSkillsInstallation(isolated,{probe:true});
+    assert.equal(broken.ok,false); assert.equal(broken.ready,false);
+    assert.ok(broken.missing.includes('skills/bin/plan_review_view.ts'));
+  } finally { rmSync(isolated,{recursive:true,force:true}); }
+},60000);

package/toolkit/skills/multi-task-flow/tests/codex-cli-create.test.ts

@@ -0,0 +1,89 @@
+import { test, expect } from "bun:test";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createCliThread, initializationPrompt, runInitialization, INITIALIZATION_PROMPT, verifyRepositoryIdentity, type CliRun } from "../lib/codex-cli-create";
+
+const input = { title: "test", prompt: "DO NOT EXECUTE THIS TASK", cwd: process.cwd(), model: "gpt-6.1-sol", thinking: "max" };
+const completed: CliRun = { thread_id: "thread-a", exit_code: 0, turn_completed: true, events: ["thread.started", "turn.completed"] };
+const read = async () => ({ id: "thread-a", cwd: "/codex/owned", model: input.model, reasoningEffort: input.thinking });
+
+test("initialization prompt gives the creation phase enough context without authorizing work", () => {
+  expect(INITIALIZATION_PROMPT).toContain("Task Agent");
+  expect(initializationPrompt("Delivery Agent")).toContain("Delivery Agent");
+  expect(INITIALIZATION_PROMPT).toContain("主 Agent 稍后会发送正式派发消息");
+  expect(INITIALIZATION_PROMPT).toContain("不要开始正式任务");
+  expect(INITIALIZATION_PROMPT).not.toContain("初始化完成");
+  expect(INITIALIZATION_PROMPT).not.toContain("请简短回复");
+});
+
+test("bind requires both process exit and initialization completion, preserving identity on every ambiguous result", async () => {
+  for (const result of [ { ...completed, exit_code: 1 }, { ...completed, exit_code: null }, { ...completed, turn_completed: false }, { ...completed, error: "timeout" } ]) {
+    let reads = 0;
+    const receipt = await createCliThread(input, { run: async () => result, read: async () => { reads++; return read(); }, verify: () => "a".repeat(40) });
+    expect(receipt.outcome).toBe("unknown"); expect(receipt.thread_id).toBe("thread-a"); expect(reads).toBe(0);
+  }
+});
+test("actual profile and Codex ownership are required; initial HEAD is separate from baseline", async () => {
+  const deps = { run: async () => completed, read, verify: () => "a".repeat(40) };
+  const success = await createCliThread(input, deps);
+  expect(success.outcome).toBe("succeeded"); expect(success.initial_head).toBe("a".repeat(40));
+  expect(success).not.toHaveProperty("development_baseline");
+  expect((await createCliThread(input, { ...deps, read: async () => ({ ...await read(), model: "other" }) })).outcome).toBe("unknown");
+  expect((await createCliThread(input, { ...deps, verify: () => { throw new Error("ownership mismatch"); } })).outcome).toBe("unknown");
+});
+test("repository identity is checked before starting the external CLI", async () => {
+  expect(() => verifyRepositoryIdentity(input.cwd!, { host: "github.com", owner: "other", name: "repo" })).toThrow("Repository identity");
+  let started = false;
+  const receipt = await createCliThread(
+    { ...input, repository: { host: "github.com", owner: "other", name: "repo" } },
+    { run: async () => { started = true; return completed; }, read, verify: () => "a".repeat(40) },
+  );
+  expect(receipt.outcome).toBe("unknown");
+  expect(started).toBe(false);
+});
+test("real subprocess receives literal argv and EOF, never the formal prompt; thread identity persists before exit", async () => {
+  const root = mkdtempSync(join(tmpdir(), "cli-adapter-"));
+  const oldPath = process.env.PATH;
+  try {
+    const executable = join(root, "codex"), capture = join(root, "argv.json");
+    writeFileSync(executable, `#!/usr/bin/env node\nconst fs=require('node:fs');fs.writeFileSync(${JSON.stringify(capture)},JSON.stringify({argv:process.argv.slice(2),nativeRequestId:process.env.MULTI_TASK_FLOW_NATIVE_REQUEST_ID}));process.stdin.on('end',()=>{console.log(JSON.stringify({type:'thread.started',thread_id:'real-event'}));setTimeout(()=>console.log(JSON.stringify({type:'turn.completed'})),30)});process.stdin.resume();`);
+    chmodSync(executable, 0o755); process.env.PATH = `${root}:${oldPath}`;
+    const observed: string[] = [];
+    const result = await runInitialization({ ...input, native_request_id: "native-test", onThreadStarted: id => observed.push(id) });
+    expect(result.exit_code).toBe(0); expect(result.turn_completed).toBe(true); expect(observed).toEqual(["real-event"]);
+    expect(JSON.parse(readFileSync(capture, "utf8"))).toEqual({ argv: ["exec", "-C", input.cwd, "--worktree", "--json", "-m", input.model, "-c", 'model_reasoning_effort="max"', INITIALIZATION_PROMPT], nativeRequestId: "native-test" });
+    writeFileSync(executable, `#!/usr/bin/env node\nconsole.log(JSON.stringify({type:'thread.started',thread_id:'partial'}));console.log(JSON.stringify({type:'item.started',item:{type:'command_execution'}}));setInterval(()=>{},1000);`);
+    const failed = await runInitialization(input);
+    expect(failed.thread_id).toBe("partial"); expect(failed.error).toContain("attempted work"); expect(failed.exit_code).not.toBe(0);
+  } finally { process.env.PATH = oldPath; rmSync(root, { recursive: true, force: true }); }
+}, 10000);
+
+test("aborting initialization terminates tool descendants and closes inherited pipes", async () => {
+  const root = mkdtempSync(join(tmpdir(), "cli-descendants-"));
+  const oldPath = process.env.PATH;
+  let pid: number | undefined;
+  try {
+    const executable = join(root, "codex"), pidFile = join(root, "descendant.pid"), heartbeat = join(root, "heartbeat");
+    const descendant = `const fs=require('node:fs');fs.writeFileSync(${JSON.stringify(pidFile)},String(process.pid));process.on('SIGTERM',()=>{});fs.appendFileSync(${JSON.stringify(heartbeat)},'x');console.log(JSON.stringify({type:'item.started',item:{type:'command_execution'}}));setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),10);`;
+    writeFileSync(executable, `#!/usr/bin/env node\nconst {spawn}=require('node:child_process');console.log(JSON.stringify({type:'thread.started',thread_id:'descendant-test'}));spawn(process.execPath,['-e',${JSON.stringify(descendant)}],{stdio:['ignore',process.stdout,process.stderr]});setInterval(()=>{},1000);`);
+    chmodSync(executable, 0o755); process.env.PATH = `${root}:${oldPath}`;
+    const result = await runInitialization(input);
+    pid = Number(readFileSync(pidFile, "utf8"));
+    expect(result.thread_id).toBe("descendant-test");
+    expect(result.error).toContain("attempted work");
+    expect(result.exit_code).not.toBe(0);
+    const before = readFileSync(heartbeat, "utf8");
+    await new Promise(resolve => setTimeout(resolve, 350));
+    expect(readFileSync(heartbeat, "utf8")).toBe(before);
+  } finally {
+    // Only this test's recorded subprocess; the supervisor normally reaps it.
+    if (pid) { try {
+      const command = execFileSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      if (command.includes(root)) process.kill(pid, "SIGKILL");
+    } catch {} }
+    process.env.PATH = oldPath;
+    rmSync(root, { recursive: true, force: true });
+  }
+}, 10000);

package/toolkit/skills/multi-task-flow/tests/codex-desktop-follower.test.ts

@@ -0,0 +1,29 @@
+import { expect, test } from "bun:test";
+import { createServer, type Socket } from "node:net";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CodexDesktopFollower } from "../lib/codex-desktop-follower";
+import type { JsonRecord } from "../lib/codex-socket";
+const wait=async(condition:()=>boolean)=>{for(let i=0;i<100&&!condition();i++)await Bun.sleep(5);expect(condition()).toBe(true)};
+test("desktop follower receives fragmented snapshots, native text patches and completion without execution requests",async()=>{
+ const root=mkdtempSync(join(tmpdir(),"desktop-follow-")),path=join(root,"ipc.sock");let socket!:Socket;const calls:JsonRecord[]=[],events:JsonRecord[]=[];let failures=0;
+ const send=(m:JsonRecord,fragment=false)=>{const text=Buffer.from(JSON.stringify(m));const head=Buffer.alloc(4);head.writeUInt32LE(text.length);const bytes=Buffer.concat([head,text]);if(fragment){socket.write(bytes.subarray(0,3));socket.write(bytes.subarray(3))}else socket.write(bytes)};
+ const server=createServer(s=>{socket=s;let buffer=Buffer.alloc(0);s.on("data",(chunk:Buffer)=>{buffer=Buffer.concat([buffer,chunk]);while(buffer.length>=4){const length=buffer.readUInt32LE(0);if(buffer.length<length+4)return;const m=JSON.parse(buffer.subarray(4,length+4).toString());buffer=buffer.subarray(length+4);calls.push(m);if(m.method==="initialize")send({type:"response",requestId:m.requestId,method:m.method,resultType:"success",result:{clientId:"observer"}});if(m.method==="thread-owner-discovery")send({type:"response",requestId:m.requestId,method:m.method,resultType:"success",handledByClientId:"owner",result:{}})}})});
+ await new Promise<void>(r=>server.listen(path,r));const follower=new CodexDesktopFollower(path,e=>events.push(e),()=>failures++);follower.retain(["bound"]);
+ const broadcast=(change:JsonRecord,owner="owner",version=11)=>send({type:"broadcast",method:"thread-stream-state-changed",version,sourceClientId:owner,params:{hostId:"local",conversationId:"bound",change}},true);
+ try{
+ await wait(()=>calls.some(c=>c.method==="thread-stream-following-changed"));
+ broadcast({type:"snapshot",revision:1,conversationState:{turns:[{id:"turn",status:"inProgress",items:[{id:"a",type:"agentMessage",text:"first",phase:"commentary",completedAtMs:null}]}]}});
+ await wait(()=>events.length===1);
+ broadcast({type:"patches",baseRevision:1,revision:2,patches:[{op:"replace",path:["turns",0,"items",0,"text"],value:"first more"}]});
+ await wait(()=>events.length===2);expect(events[1]).toMatchObject({method:"item/agentMessage/delta",params:{itemId:"a",delta:" more"}});
+ broadcast({type:"patches",baseRevision:2,revision:3,patches:[{op:"replace",path:["turns",0,"items",0,"completedAtMs"],value:20}]});
+ await wait(()=>events.length===3);expect(events[2]).toMatchObject({method:"item/completed",params:{item:{text:"first more"}}});
+ broadcast({type:"patches",baseRevision:3,revision:4,patches:[]},"stranger");await Bun.sleep(5);expect(events).toHaveLength(3);
+ broadcast({type:"patches",baseRevision:8,revision:9,patches:[]});await wait(()=>calls.filter(c=>c.method==="thread-owner-discovery").length===2);
+ expect(calls.map(c=>c.method).every(m=>["initialize","thread-owner-discovery","thread-stream-following-changed"].includes(String(m)))).toBe(true);
+ expect(calls.filter(c=>c.method==="thread-owner-discovery").every(c=>(c.params as JsonRecord).conversationId==="bound")).toBe(true);
+ expect(failures).toBe(0);
+ }finally{follower.close();socket?.destroy();await new Promise<void>(r=>server.close(()=>r()));rmSync(root,{recursive:true,force:true})}
+},5000);

package/toolkit/skills/multi-task-flow/tests/codex-observer.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { framePayload, websocketFrame } from "../lib/codex-socket";
+
+describe("Codex socket framing", () => {
+  test("decodes masked frames across all length encodings without consuming the next frame", () => {
+    for (const size of [0, 125, 126, 65535, 65536]) {
+      const text = "a".repeat(size);
+      const frame = websocketFrame(text);
+      const result = framePayload(Buffer.concat([frame, websocketFrame("next")]));
+      expect(result?.payload.toString()).toBe(text);
+      expect(result?.consumed).toBe(frame.length);
+      expect(framePayload(frame.subarray(0, frame.length - 1))).toBeNull();
+    }
+  });
+  test("preserves raw ping/pong payload bytes and opcode", () => {
+    const bytes = Buffer.from([0xff, 0x00, 0x81]);
+    const frame = websocketFrame(bytes, 10);
+    expect(frame[0]! & 15).toBe(10);
+    expect(framePayload(frame)?.payload).toEqual(bytes);
+  });
+  test("rejects oversized input before buffering the declared payload", () => {
+    const frame = Buffer.alloc(10); frame[0] = 0x81; frame[1] = 127; frame.writeBigUInt64BE(65n * 1024n * 1024n, 2);
+    expect(() => framePayload(frame)).toThrow("limit");
+  });
+});

package/toolkit/skills/multi-task-flow/tests/codex-subscription.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { LoadedThreadSubscriptions } from "../lib/codex-subscription";
+import type { JsonRecord } from "../lib/codex-socket";
+
+test("only rejoins bound loaded threads, without overrides or turns, deduplicates and releases subscriptions", async () => {
+  const calls: Array<[string, JsonRecord]> = [];
+  const subscription = new LoadedThreadSubscriptions(async (method, params) => {
+    calls.push([method, params]);
+    return method === "thread/loaded/list" ? (params.cursor ? {data:["live"]} : {data:["unrelated"],nextCursor:"second"}) : {};
+  });
+  subscription.retain(["live", "cold"]);
+  await subscription.ensure("unbound"); expect(calls).toHaveLength(0);
+  await Promise.all([subscription.ensure("live"),subscription.ensure("live")]);
+  expect(calls).toEqual([["thread/loaded/list",{limit:100}],["thread/loaded/list",{limit:100,cursor:"second"}],["thread/resume",{threadId:"live",excludeTurns:true}]]);
+  await subscription.ensure("live");expect(calls).toHaveLength(3);
+  await subscription.ensure("cold");expect(calls.filter(([m])=>m==="thread/resume")).toHaveLength(1);
+  subscription.retain([]);
+  expect(calls.at(-1)).toEqual(["thread/unsubscribe",{threadId:"live"}]);
+});
+
+test("rebinding during a loaded-list read cannot resume the former binding", async () => {
+  let resolve!: (v:JsonRecord)=>void;const calls:string[]=[];
+  const subscription=new LoadedThreadSubscriptions(async m=>{calls.push(m);return await new Promise(r=>{resolve=r})});
+  subscription.retain(["live"]);const pending=subscription.ensure("live");
+  subscription.retain([]);subscription.retain(["live"]);
+  resolve({data:["live"]});await pending;expect(calls).toEqual(["thread/loaded/list"]);
+});
+
+test("stop cancels pending joins and a removed subscription is released after resume completes", async () => {
+  for(const stop of [false,true]) {
+    let resolve!: (v:JsonRecord)=>void;const calls:string[]=[];
+    const subscription=new LoadedThreadSubscriptions(async m=>{calls.push(m);return m==="thread/resume"?await new Promise(r=>{resolve=r}):{data:["live"]}});
+    subscription.retain(["live"]);const pending=subscription.ensure("live");await Promise.resolve();
+    if(stop)subscription.close();else subscription.retain([]);
+    resolve({});await pending;
+    expect(calls).toEqual(stop?["thread/loaded/list","thread/resume"]:["thread/loaded/list","thread/resume","thread/unsubscribe"]);
+  }
+});

package/toolkit/skills/multi-task-flow/tests/codex-thread-create.test.ts

@@ -0,0 +1,159 @@
+import { expect, test } from "bun:test";
+import { createServer } from "node:net";
+import { createHash } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createCodexThread, sendCodexMessage, archiveCodexThread, archivedCodexThread, unarchiveCodexThread, unarchivedCodexThread } from "../lib/codex-agent-api";
+
+async function withControlServer(scenario: "unarchive-success" | "unarchive-reject" | "unarchive-timeout" | "unarchive-list" | "archive-success" | "archive-active" | "archive-reject" | "archive-timeout" | "archive-list" | "success" | "mismatch" | "reject" | "timeout" | "missing-id" | "send" | "resume-reject" | "send-missing-id" | "send-resume-timeout", verify: (calls: any[], result: Awaited<ReturnType<typeof createCodexThread>> | Awaited<ReturnType<typeof sendCodexMessage>> | Awaited<ReturnType<typeof archiveCodexThread>> | boolean, completed: boolean) => void) {
+  const dir = mkdtempSync(join(tmpdir(), "mtf-rpc-"));
+  const path = join(dir, "rpc.sock");
+  const calls: any[] = [];
+  let completed = false;
+  const server = createServer((socket) => {
+    let buffer = Buffer.alloc(0);
+    let upgraded = false;
+    const send = (value: unknown) => {
+      const bytes = Buffer.from(JSON.stringify(value));
+      const header = bytes.length < 126 ? Buffer.from([129, bytes.length]) : Buffer.from([129, 126, bytes.length >> 8, bytes.length & 255]);
+      socket.write(Buffer.concat([header, bytes]));
+    };
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+      if (!upgraded) {
+        const end = buffer.indexOf("\r\n\r\n");
+        if (end < 0) return;
+        const key = /Sec-WebSocket-Key: (.+)\r\n/i.exec(buffer.toString())![1]!.trim();
+        const accept = createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
+        socket.write(`HTTP/1.1 101 Switching Protocols\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`);
+        buffer = buffer.subarray(end + 4);
+        upgraded = true;
+      }
+      while (buffer.length >= 6) {
+        let length = buffer[1]! & 127;
+        let offset = 2;
+        if (length === 126) { if (buffer.length < 8) return; length = buffer.readUInt16BE(2); offset = 4; }
+        if (buffer.length < offset + 4 + length) return;
+        const mask = buffer.subarray(offset, offset + 4);
+        const bytes = Buffer.from(buffer.subarray(offset + 4, offset + 4 + length));
+        buffer = buffer.subarray(offset + 4 + length);
+        for (let i = 0; i < bytes.length; i++) bytes[i] = bytes[i]! ^ mask[i % 4]!;
+        const call = JSON.parse(bytes.toString()); calls.push(call);
+        const result = call.method === "thread/read" ? { thread: { status: { type: scenario === "archive-active" ? "active" : "idle" } } } : call.method === "thread/list" ? { data: call.params.cursor ? [{id: "test-thread"}] : [], nextCursor: call.params.cursor ? null : "second" } : call.method === "thread/start" ? { thread: scenario === "missing-id" ? {} : { id: "test-thread" }, model: scenario === "mismatch" ? "other-model" : "gpt-6.1-sol", reasoningEffort: "medium" } : call.method === "turn/start" ? { turn: scenario === "send-missing-id" ? {} : { id: "test-turn" } } : {};
+        if (((call.method === "thread/archive" || call.method === "thread/unarchive") && scenario.endsWith("-timeout")) || (call.method === "thread/start" && scenario === "timeout") || (call.method === "thread/resume" && scenario === "send-resume-timeout")) continue;
+        send(((call.method === "thread/archive" || call.method === "thread/unarchive") && scenario.endsWith("-reject")) || (call.method === "thread/start" && scenario === "reject") || (call.method === "thread/resume" && scenario === "resume-reject") ? { id: call.id, error: { message: "unsupported profile" } } : { id: call.id, result });
+        if (call.method === "turn/start") setTimeout(() => {
+          completed = true;
+          send({ method: "turn/completed", params: { threadId: "test-thread", turn: { id: "test-turn", status: "completed" } } });
+        }, 30);
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(path, resolve));
+  const previous = process.env.CODEX_APP_SERVER_SOCKET;
+  const previousTimeout = process.env.MULTI_TASK_FLOW_CODEX_AGENT_TIMEOUT_MS;
+  process.env.MULTI_TASK_FLOW_CODEX_AGENT_TIMEOUT_MS = "1000";
+  process.env.CODEX_APP_SERVER_SOCKET = path;
+  try {
+    const result = scenario === "unarchive-list" ? await unarchivedCodexThread("test-thread") : scenario.startsWith("unarchive-") ? await unarchiveCodexThread("test-thread", "test-unarchive") : scenario === "archive-list" ? await archivedCodexThread("test-thread") : scenario.startsWith("archive-") ? await archiveCodexThread("test-thread", "test-archive") : scenario === "send" || scenario === "resume-reject" || scenario === "send-missing-id" || scenario === "send-resume-timeout"
+      ? await sendCodexMessage({recipient_thread_id:"test-thread",prompt:"Continue"})
+      : await createCodexThread({ title: "Test", prompt: "Reply OK", model: "gpt-6.1-sol", thinking: "medium" });
+    verify(calls, result, completed);
+  } finally {
+    if (previousTimeout === undefined) delete process.env.MULTI_TASK_FLOW_CODEX_AGENT_TIMEOUT_MS;
+    else process.env.MULTI_TASK_FLOW_CODEX_AGENT_TIMEOUT_MS = previousTimeout;
+    if (previous === undefined) delete process.env.CODEX_APP_SERVER_SOCKET;
+    else process.env.CODEX_APP_SERVER_SOCKET = previous;
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    if (scenario === "send") expect(completed).toBe(true);
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test("creation sends the prompt separately, validates the returned profile and waits for persistence", async () => {
+  await withControlServer("success", (calls, result, completed) => {
+    expect(result.outcome).toBe("succeeded");
+    expect(completed).toBe(true);
+    expect(calls.map((c) => c.method)).toEqual(["initialize", "thread/start", "thread/name/set", "turn/start"]);
+    expect(calls[1].params.config).toEqual({ model_reasoning_effort: "medium" });
+    expect(calls[1].params.input).toBeUndefined();
+    expect(calls[3].params.input).toEqual([{ type: "text", text: "Reply OK" }]);
+    expect(calls[3].params.effort).toBe("medium");
+    expect(calls[1].id).toBe(result.native_request_id);
+  });
+});
+
+for (const scenario of ["mismatch", "reject", "timeout", "missing-id"] as const) {
+  test(`creation preserves ${scenario} as evidence without unsafe retry`, async () => {
+    await withControlServer(scenario, (calls, result) => {
+      expect(result.outcome).toBe(scenario === "reject" ? "failed" : "unknown");
+      expect(calls.filter((call) => call.method === "thread/start")).toHaveLength(1);
+      expect(calls.some((call) => call.method === "turn/start")).toBe(false);
+      if (scenario === "mismatch") expect(result.thread_id).toBe("test-thread");
+    });
+  });
+}
+
+test("notification rejoins the exact thread on its new connection before starting a turn", async () => {
+  await withControlServer("send", (calls, result, completed) => {
+    expect(result.outcome).toBe("sent");
+    expect(completed).toBe(false);
+    expect(calls.map(c=>c.method)).toEqual(["initialize","thread/resume","turn/start"]);
+    expect(calls[1].params).toEqual({threadId:"test-thread",excludeTurns:true});
+    expect(calls[2].params.threadId).toBe("test-thread");
+  });
+});
+test("a rejected resume does not start a turn or create a replacement", async () => {
+  await withControlServer("resume-reject", (calls, result) => {
+    expect(result.outcome).toBe("failed");
+    expect(calls.map(c=>c.method)).toEqual(["initialize","thread/resume"]);
+  });
+});
+
+test("accepted input without a turn identity remains unknown, never safe to retry", async () => {
+  await withControlServer("send-missing-id", (calls,result) => {
+    expect(result.outcome).toBe("unknown");
+    expect(calls.filter(c=>c.method==="turn/start")).toHaveLength(1);
+    expect(calls.some(c=>c.method==="thread/start")).toBe(false);
+  });
+});
+
+test("a timeout before notification input is submitted is a definite failure", async () => {
+  await withControlServer("send-resume-timeout", (calls, result) => {
+    expect(result.outcome).toBe("failed");
+    expect(calls.map(c => c.method)).toEqual(["initialize", "thread/resume"]);
+  });
+});
+
+for (const [scenario, outcome] of [["archive-success", "succeeded"], ["archive-active", "deferred"], ["archive-reject", "failed"], ["archive-timeout", "unknown"]] as const) {
+  test(`archive RPC ${scenario} retains provider facts without executing a turn`, async () => {
+    await withControlServer(scenario, (calls, result) => {
+      expect((result as any).outcome).toBe(outcome);
+      expect(calls.map(c => c.method)).toEqual(scenario === "archive-active" ? ["initialize", "thread/read"] : ["initialize", "thread/read", "thread/archive"]);
+    });
+  });
+}
+test("archive reconciliation paginates archived threads only", async () => {
+  await withControlServer("archive-list", (calls, result) => {
+    expect(result).toBe(true);
+    expect(calls.filter(c => c.method === "thread/list").map(c => c.params)).toEqual([{ archived: true, limit: 100 }, { archived: true, limit: 100, cursor: "second" }]);
+  });
+});
+
+for (const [scenario, outcome] of [["unarchive-success", "succeeded"], ["unarchive-reject", "failed"], ["unarchive-timeout", "unknown"]] as const) {
+  test(`unarchive RPC ${scenario} restores only the archive resource`, async () => {
+    await withControlServer(scenario, (calls, result) => {
+      expect(result.outcome).toBe(outcome);
+      expect(calls.map(call => call.method)).toEqual(["initialize", "thread/unarchive"]);
+      expect(calls[1].params).toEqual({ threadId: "test-thread" });
+    });
+  });
+}
+test("unarchive reconciliation requires a positive unarchived listing", async () => {
+  await withControlServer("unarchive-list", (calls, result) => {
+    expect(result).toBe(true);
+    expect(calls.filter(call => call.method === "thread/list").every(call => call.params.archived === false)).toBe(true);
+    expect(calls.some(call => call.method === "turn/start" || call.method === "thread/unarchive")).toBe(false);
+  });
+});