[Bug] Host audit log reuses seq on about half its entries when five or more hooks run at once; no entry is lost #250

Activity

1. Premmethuku75

   added

   type:bugSomething isn't workingSomething isn't working

   status:needs-triageNot yet triaged. Applied by the issue formsNot yet triaged. Applied by the issue forms

   on Oct 10, 2026
2. github-project-automation

   added this to ACS Project Trackeron Oct 10, 2026
3. 4ktLuffy commented on Oct 31, 2026

   

   4ktLuffy

   on Oct 31, 2026

   More actions

   I tested this on macOS arm64 at b383e40 and it's correct, the collisions reproduce. Nothing is lost and every entry is valid JSON; the sequential control gives 1..10 every time.

   One thing is off for macOS though: two hooks are already enough, and the rate doesn't grow with K. Four runs, 10 trials per K, Guardian down (trials with a repeat / entries repeating a seq):

   K=2:   8-10 of 10,  8-10 of 20
   K=5:   6-9 of 10,   8-14 of 50
   K=10:  4-7 of 10,   4-17 of 100
   K=20:  7-10 of 10, 13-34 of 200
   

   So "five or more" holds for Windows, not here. I didn't run the Guardian-up case.

   To recheck, from reference-implementations/agt with nothing on 8787: bun run probe250.ts 10 2,5,10,20

   probe250.ts

   // Run from reference-implementations/agt/:
   //   bun --no-install run <path>/probe250.ts [trials=10] [K list=2,5,10,20]
   // Guardian must NOT be running (port 8787 closed). Every shim then fails open.
   import { mkdtempSync, readFileSync, existsSync, rmSync } from "node:fs";
   import { tmpdir } from "node:os";
   import { join, resolve } from "node:path";
   const trials = Number(process.argv[2] ?? 10);
   const Ks = (process.argv[3] ?? "2,5,10,20").split(",").map(Number);
   const PROJECT = resolve(".");
   const payload = JSON.stringify({ session_id: "sess-1", hook_event_name: "PreToolUse", tool_name: "Bash", tool_input: { command: "ls -la" } });
   // The shipped command from hosts/claude-code/settings.json, run through a shell as Claude Code does.
   const CMD = 'bun run "$CLAUDE_PROJECT_DIR/hosts/claude-code/acs-hook.ts"';
   async function shim(dir: string) {
     const p = Bun.spawn(["sh", "-c", CMD], { stdin: new TextEncoder().encode(payload), stdout: "pipe", stderr: "pipe", cwd: dir,
       env: { ...process.env, CLAUDE_PROJECT_DIR: PROJECT, ACS_AUDIT_LOG: join(dir, "audit.jsonl"), ACS_SESSION_DIR: join(dir, "sessions") } });
     const [o, e] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
     return { code: await p.exited, out: o, err: e };
   }
   function analyse(dir: string) {
     const f = join(dir, "audit.jsonl");
     const lines = existsSync(f) ? readFileSync(f, "utf8").split("\n").filter(Boolean) : [];
     const ents: any[] = []; let bad = 0;
     for (const l of lines) { try { ents.push(JSON.parse(l)); } catch { bad++; } }
     const seqs = new Set(ents.map((e) => e.seq));
     return { ents, bad, repeated: ents.length - seqs.size, seqs: ents.map((e) => e.seq) };
   }
   // port check
   const closed = await fetch("http://localhost:8787/acs", { method: "POST", body: "{}" }).then(() => false, () => true);
   console.log(`port 8787 closed: ${closed}`);
   if (!closed) { console.log("ABORT: something listens on 8787"); process.exit(2); }
   const base = mkdtempSync(join(tmpdir(), "acs250-"));
   const rows: string[] = [];
   async function batch(K: number, parallel: boolean) {
     let trialsWith = 0, rep = 0, missing = 0, badJson = 0, entries = 0, nonzero = 0, notProceed = 0, maxSame = 0; const outs = new Set<string>();
     const examples: number[][] = [];
     for (let t = 0; t < trials; t++) {
       const dir = mkdtempSync(join(base, "t-"));
       let rs;
       if (parallel) rs = await Promise.all(Array.from({ length: K }, () => shim(dir)));
       else { rs = []; for (let i = 0; i < K; i++) rs.push(await shim(dir)); }
       for (const r of rs) { if (r.code !== 0) nonzero++; outs.add(r.out.trim()); }
       const a = analyse(dir);
       entries += a.ents.length; rep += a.repeated; badJson += a.bad; missing += Math.max(0, K - a.ents.length - a.bad);
       if (a.repeated > 0) trialsWith++;
       for (const e of a.ents) if (e.outcome !== "proceeded") notProceed++;
       const cnt = new Map<number, number>(); for (const s of a.seqs) cnt.set(s, (cnt.get(s) ?? 0) + 1);
       maxSame = Math.max(maxSame, ...cnt.values());
       if (examples.length < 2) examples.push(a.seqs);
       rmSync(dir, { recursive: true, force: true });
     }
     const label = parallel ? `parallel K=${K}` : `sequential K=${K}`;
     const row = `| ${label} | ${trialsWith} of ${trials} | ${rep} of ${K * trials} | ${missing} | ${badJson} |`;
     console.log(row, ` nonzero_exits=${nonzero} entries=${entries} non-proceeded=${notProceed} distinct_stdout=${outs.size} max_entries_sharing_one_seq=${maxSame} ex_seqs=${JSON.stringify(examples[0])}`);
     rows.push(row);
   }
   await batch(10, false);
   for (const K of Ks) await batch(K, true);
   rmSync(base, { recursive: true, force: true });
   console.log("\n| K | trials with a repeated seq | entries repeating a seq already used | entries missing | entries not valid JSON |\n|---|---|---|---|---|");
   for (const r of rows) console.log(r);