oh-my-codex 0.8.6 → 0.8.7

package/scripts/team-hardening-benchmark.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { mkdtemp, rm, readFile, writeFile } from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { performance } from 'node:perf_hooks';
+
+import { initTeamState, createTask, claimTask, readTask, writeAtomic } from '../dist/team/state.js';
+import { monitorTeam } from '../dist/team/runtime.js';
+import { planWorktreeTarget, ensureWorktree } from '../dist/team/worktree.js';
+
+async function initRepo() {
+  const cwd = await mkdtemp(join(tmpdir(), 'omx-team-bench-repo-'));
+  execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.name', 'Test User'], { cwd, stdio: 'ignore' });
+  await writeFile(join(cwd, 'README.md'), 'hello\n', 'utf-8');
+  execFileSync('git', ['add', 'README.md'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['commit', '-m', 'init'], { cwd, stdio: 'ignore' });
+  return cwd;
+}
+
+async function benchReclaim(iterations = 10) {
+  const samples = [];
+  for (let i = 0; i < iterations; i += 1) {
+    const cwd = await mkdtemp(join(tmpdir(), 'omx-team-bench-reclaim-'));
+    try {
+      await initTeamState('team-bench', 'bench reclaim', 'executor', 2, cwd);
+      const task = await createTask('team-bench', { subject: 'recover', description: 'd', status: 'pending' }, cwd);
+      const claim = await claimTask('team-bench', task.id, 'worker-1', task.version ?? 1, cwd);
+      if (!claim.ok) throw new Error('claim failed');
+
+      const taskPath = join(cwd, '.omx', 'state', 'team', 'team-bench', 'tasks', `task-${task.id}.json`);
+      const current = JSON.parse(await readFile(taskPath, 'utf-8'));
+      current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
+      await writeAtomic(taskPath, JSON.stringify(current, null, 2));
+
+      const start = performance.now();
+      await monitorTeam('team-bench', cwd);
+      const elapsed = performance.now() - start;
+      const reopened = await readTask('team-bench', task.id, cwd);
+      if (reopened?.status !== 'pending') throw new Error('task not reclaimed');
+      samples.push(elapsed);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  }
+  return samples;
+}
+
+async function benchDirtyWorktree(iterations = 10) {
+  const samples = [];
+  for (let i = 0; i < iterations; i += 1) {
+    const repo = await initRepo();
+    try {
+      const plan = planWorktreeTarget({ cwd: repo, scope: 'launch', mode: { enabled: true, detached: true, name: null } });
+      if (!plan.enabled) throw new Error('plan disabled');
+      const first = ensureWorktree(plan);
+      if (!first.enabled) throw new Error('ensure disabled');
+      await writeFile(join(first.worktreePath, 'DIRTY.txt'), 'dirty\n', 'utf-8');
+      const start = performance.now();
+      let blocked = false;
+      try {
+        ensureWorktree(plan);
+      } catch (error) {
+        blocked = /worktree_dirty/.test(String(error));
+      }
+      const elapsed = performance.now() - start;
+      if (!blocked) throw new Error('dirty reuse was not blocked');
+      samples.push(elapsed);
+    } finally {
+      await rm(repo, { recursive: true, force: true });
+    }
+  }
+  return samples;
+}
+
+function summarize(name, values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const avg = sorted.reduce((a, b) => a + b, 0) / sorted.length;
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const p95 = sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))];
+  console.log(`${name}: n=${sorted.length} avg_ms=${avg.toFixed(2)} median_ms=${median.toFixed(2)} p95_ms=${p95.toFixed(2)}`);
+}
+
+const reclaim = await benchReclaim(10);
+const dirty = await benchDirtyWorktree(10);
+console.log('team-hardening benchmark');
+summarize('expired-claim-reclaim', reclaim);
+summarize('dirty-worktree-detection', dirty);

package/templates/AGENTS.md

@@ -2,6 +2,8 @@
 
 You are running with oh-my-codex (OMX), a multi-agent orchestration layer for Codex CLI.
 Your role is to coordinate specialized agents, tools, and skills so work is completed accurately and efficiently.
+In the safe first-step 2-layer prompt architecture, this AGENTS.md file is the orchestrator authority for the workspace: it defines global operating policy, delegation rules, safety constraints, and completion standards.
+Role prompts under `prompts/*.md` are narrower subagent execution surfaces; they should follow this orchestration contract rather than override it.
 
 <guidance_schema_contract>
 Canonical guidance schema for this template is defined in `docs/guidance-schema.md`.
@@ -26,10 +28,12 @@ Keep runtime marker contracts stable and non-destructive when overlays are appli
 - Choose the lightest-weight path that preserves quality (direct action, MCP, or agent).
 - Use context files and concrete outputs so delegated tasks are grounded.
 - Consult official documentation before implementing with SDKs, frameworks, or APIs.
+<!-- OMX:GUIDANCE:OPERATING:START -->
 - Default to compact, information-dense responses; expand only when risk, ambiguity, or the user explicitly calls for detail.
 - Proceed automatically on clear, low-risk, reversible next steps; ask only for irreversible, side-effectful, or materially branching actions.
 - Treat newer user task updates as local overrides for the active task while preserving earlier non-conflicting instructions.
 - Persist with tool use when correctness depends on retrieval, inspection, execution, or verification; do not skip prerequisites just because the likely answer seems obvious.
+<!-- OMX:GUIDANCE:OPERATING:END -->
 </operating_principles>
 
 ---
@@ -50,6 +54,7 @@ For non-trivial SDK/API/framework usage, delegate to `dependency-expert` to chec
 <child_agent_protocol>
 Codex CLI spawns child agents via the `spawn_agent` tool (requires `multi_agent = true`).
 To inject role-specific behavior, the parent MUST read the role prompt and pass it in the spawned agent message.
+Treat the role prompt as a role-local execution surface layered under AGENTS.md: it can specialize behavior for that subtask, but it must stay consistent with AGENTS.md-level orchestration and safety rules.
 
 Delegation steps:
 1. Decide which agent role to delegate to (e.g., `architect`, `executor`, `debugger`)
@@ -65,8 +70,8 @@ spawn_agent(message: "<test-engineer prompt>\n\nTask: Write tests for the auth c
 ```
 
 Each child agent:
-- Receives its role-specific prompt (from ~/.codex/prompts/)
-- Inherits AGENTS.md context (via child_agents_md feature flag)
+- Receives its role-specific prompt (from ~/.codex/prompts/) as the canonical subagent surface for that role
+- Inherits AGENTS.md context (via child_agents_md feature flag) and treats it as higher-level orchestration authority
 - Runs in an isolated context with its own tool access
 - Returns results to the parent when complete
 
@@ -75,6 +80,7 @@ Key constraints:
 - Each child has its own context window (not shared with parent)
 - Parent must read prompt file BEFORE calling spawn_agent
 - Child agents can access skills ($name) but should focus on their assigned role
+- Child role prompts should report recommended handoffs upward instead of recursively orchestrating unless the parent explicitly authorizes recursion
 </child_agent_protocol>
 
 <invocation_conventions>
@@ -285,7 +291,13 @@ Sizing guidance:
 - Standard changes: standard verifier
 - Large or security/architectural changes (>20 files): thorough verifier
 
+<!-- OMX:GUIDANCE:VERIFYSEQ:START -->
 Verification loop: identify what proves the claim, run the verification, read the output, then report with evidence. If verification fails, continue iterating rather than reporting incomplete work. Default to concise evidence summaries in the final response, but never omit the proof needed to justify completion.
+
+- Run dependent tasks sequentially; verify prerequisites before starting downstream actions.
+- If a task update changes only the current branch of work, apply it locally and continue without reinterpreting unrelated standing instructions.
+- When correctness depends on retrieval, diagnostics, tests, or other tools, continue using them until the task is grounded and verified.
+<!-- OMX:GUIDANCE:VERIFYSEQ:END -->
 </verification>
 
 <execution_protocols>