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

package/toolkit/skills/multi-task-flow/tests/browser/README.md

@@ -0,0 +1,38 @@
+# Browser width regression
+
+The agreed seam is the rendered mock example: click a task to open details and click Close to dismiss them. Compare each task's actual DOM width and each board column's width across closed → open → closed states. At each viewport, also compare board columns with grid cards: their outer widths must match, while board task cards must be 22px narrower to allow for the group container. Backend behavior is outside this test. Happy DOM cannot verify this contract.
+
+Build the existing `demo:static` surface and use its current owned preview server. In the Codex in-app browser REPL, bind the preview tab and viewport capability, import the checked-in runner, then run it:
+
+```js
+var regression = await import("file:///absolute/repo/skills/multi-task-flow/tests/browser/card-width-regression.ts");
+await regression.checkCardWidths(tab, viewport);
+```
+
+Alternatively paste the exported function without `export`. It throws with per-object measurements on failure, returns measurements on success, and resets the viewport in `finally`. The default matrix covers both board and grid at 1304, 768, 1024, 1120 and 1444px, with 1470px viewport height. Every task and board column is matched by object ID; no expected CSS sizing formula is repeated in the assertions.
+
+The first red run on the board at 1304px measured columns 360 → 290.75 → 360px and task cards 338 → 268.75 → 338px. Fixed container-derived board tracks made that case green. The next slice caught grid cards changing 292.5 → 288.75px at 1304px and 246.5 → 330.328125px at 1120px when the document scrollbar appeared. A stable root scrollbar gutter made both layouts green.
+
+The sizing contract distinguishes the outer track from nested content: board columns match grid task cards, and board task cards are naturally smaller. A red cross-layout test at 1304px found the incorrect 310.75px column next to 288.75px grid cards. Removing the extra 22px from the board track made this test green. Removing the board strip's horizontal padding prevents a spurious scrollbar when two outer tracks exactly fit the task area.
+
+Final real-browser measurements (closed/open/reclosed values are equal; all 10 tasks and both board columns were checked):
+
+| Viewport | Grid task / board column | Nested board task | Maximum width change |
+| - | - | - | - |
+| 768 | 341.5 | 319.5 | 0 |
+| 1024 | 306.328125 | 284.328125 | 0 |
+| 1120 | 330.328125 | 308.328125 | 0 |
+| 1304 | 288.75 | 266.75 | 0 |
+| 1444 | 255 | 233 | 0 |
+
+Inspector limits are fixed at 243px minimum and 740px maximum. These constants were selected from the task-card design range once; runtime limits must not multiply the current card width. The test also rejects layouts where an extra complete task track and its gap could fit while retaining a 243px inspector. The red run at 1304px found a 597.5px inspector and only 597.5px of task space. After reserving the absolute minimum and maximizing whole task tracks, task space is 906.25px (three tracks), and the inspector receives 288.75px of remainder.
+
+| Viewport | Task area with details | Inspector | Complete task tracks |
+| - | - | - | - |
+| 768 | 341.5 | 341.5 | 1 |
+| 1024 | 632.6640625 | 306.3359375 | 2 |
+| 1120 | 680.6640625 | 330.3359375 | 2 |
+| 1304 | 906.25 | 288.75 | 3 |
+| 1444 | 1080 | 255 | 4 |
+
+No case caused horizontal document overflow. Both board columns fit at every measured viewport except 768px, where the board scrolls inside its one available track. Detail widths happen to be close to card widths in this evenly divided layout, but the product limits are absolute rather than one/two current cards. These measurements are acceptance evidence from this candidate, not substitutes for rerunning after UI changes.

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);
+  });
+});