harnery 0.33.0 → 0.34.0

package/src/lib/instructions/apply.ts

@@ -14,8 +14,9 @@
  *     so a fresh consumer gets a CLAUDE.md whose managed region imports
  *     `@AGENTS.md`. A CLAUDE.md that already imports AGENTS.md or already carries
  *     the block (a host that generates CLAUDE.md from AGENTS.md) is left alone.
- *   - `.claude/skills/<skill>/SKILL.md` — claude-code only; fully-owned files,
- *     honoring `skills.exclude` in `.harnery/config.jsonc`.
+ *   - `<adapter-skill-dir>/<skill>/SKILL.md` — fully-owned files, honoring
+ *     `skills.exclude` in `.harnery/config.jsonc`. Claude Code uses
+ *     `.claude/skills/`; Cursor and Codex use `.agents/skills/`.
  */
 
 import {
@@ -49,7 +50,15 @@ import {
 
 const AGENTS_FILE = "AGENTS.md";
 const CLAUDE_FILE = "CLAUDE.md";
-const CLAUDE_SKILLS_DIR = join(".claude", "skills");
+const ADAPTER_SKILLS_DIR: Readonly<Record<string, string>> = {
+  "claude-code": join(".claude", "skills"),
+  cursor: join(".agents", "skills"),
+  codex: join(".agents", "skills"),
+};
+
+function adapterSkillsDir(adapter: string): string | null {
+  return ADAPTER_SKILLS_DIR[adapter] ?? null;
+}
 
 /** CLAUDE.md import-shim body: points Claude Code (which reads CLAUDE.md, not AGENTS.md) at AGENTS.md. */
 function importBody(): string {
@@ -79,16 +88,17 @@ export function readSkillsExclude(projectRoot: string): Set<string> {
 
 /**
  * Which shipped skills exist for this project, so the block references only the
- * ones actually present: claude-code writes skills (unless excluded); cursor and
- * codex get the block but no skill files, so both read false there. Kept in one
- * place so `applyInstructions` and `checkInstructions` render byte-identical blocks.
+ * ones actually present for every supported adapter, unless excluded. Kept in
+ * one place so `applyInstructions` and `checkInstructions` render byte-identical
+ * blocks.
  */
 function blockSkills(projectRoot: string, adapter: string): BlockSkills {
-  const claudeCode = adapter === "claude-code";
+  const supported = adapterSkillsDir(adapter) !== null;
   const exclude = readSkillsExclude(projectRoot);
   return {
-    decide: claudeCode && !exclude.has("harn-decide"),
-    council: claudeCode && !exclude.has("harn-council"),
+    decide: supported && !exclude.has("harn-decide"),
+    council: supported && !exclude.has("harn-council"),
+    end: supported && !exclude.has("harn-end"),
   };
 }
 
@@ -105,13 +115,14 @@ export interface ApplyResult {
 
 /**
  * Inject / refresh the instructions block, the CLAUDE.md import shim (claude-code),
- * and the shipped skills (claude-code). Idempotent: a re-run on current content
+ * and the adapter-native shipped skills. Idempotent: a re-run on current content
  * writes nothing. `dryRun` reports without touching the fs.
  */
 export function applyInstructions(projectRoot: string, opts: ApplyOpts): ApplyResult {
   const actions: string[] = [];
   const warnings: string[] = [];
   const claudeCode = opts.adapter === "claude-code";
+  const skillsDir = adapterSkillsDir(opts.adapter);
   // dry-run narrates the future ("would create"); a real run narrates the past.
   const verbed = (base: string, past: string) => (opts.dryRun ? `would ${base}` : past);
 
@@ -191,15 +202,15 @@ export function applyInstructions(projectRoot: string, opts: ApplyOpts): ApplyRe
     }
   }
 
-  // ── shipped skills (claude-code only) ───────────────────────────────────
-  if (claudeCode) {
+  // ── shipped skills ───────────────────────────────────────────────────────
+  if (skillsDir) {
     const exclude = readSkillsExclude(projectRoot);
     for (const skill of SKILLS) {
       if (exclude.has(skill.id)) {
         actions.push(`· skipped skill ${skill.id} (skills.exclude)`);
         continue;
       }
-      const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+      const skillPath = join(projectRoot, skillsDir, skill.relPath);
       const content = skill.render(opts.binName);
       const before = existsSync(skillPath) ? readFileSync(skillPath, "utf8") : null;
       if (before === content) {
@@ -235,6 +246,7 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
   const actions: string[] = [];
   const warnings: string[] = [];
   const claudeCode = opts.adapter === "claude-code";
+  const skillsDir = adapterSkillsDir(opts.adapter);
 
   // ── AGENTS.md block + host addendum ─────────────────────────────────────
   const agentsPath = join(projectRoot, AGENTS_FILE);
@@ -288,10 +300,10 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
     }
   }
 
-  // ── shipped skills (claude-code) ────────────────────────────────────────
-  if (claudeCode) {
+  // ── shipped skills ───────────────────────────────────────────────────────
+  if (skillsDir) {
     for (const skill of SKILLS) {
-      const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+      const skillPath = join(projectRoot, skillsDir, skill.relPath);
       if (!existsSync(skillPath)) continue;
       if (!isOwnedFile(readFileSync(skillPath, "utf8"))) {
         warnings.push(`left ${skill.relPath} (hand-edited; no harnery ownership marker)`);
@@ -299,7 +311,7 @@ export function removeInstructions(projectRoot: string, opts: RemoveOpts): Apply
       }
       if (!opts.dryRun) {
         rmSync(skillPath);
-        // drop the now-empty skill dir (harn-decide/), leaving .claude/skills/ intact
+        // Drop the now-empty harn-* dir, leaving the adapter skills root intact.
         const dir = dirname(skillPath);
         try {
           if (readdirSync(dir).length === 0) rmdirSync(dir);
@@ -321,7 +333,7 @@ export interface CheckResult {
 
 /**
  * Read-only drift report for `init --check`: the AGENTS.md block and each
- * shipped skill (claude-code). Fresh → exit 0; any stale / missing / hand-edit
+ * shipped skill for the selected adapter. Fresh → exit 0; stale / missing / hand-edit
  * → drift (exit 2); an unreadable file → error (exit 1). Mirrors the wiki-theme
  * `--check-only` contract the first host wires into pre-commit.
  */
@@ -361,11 +373,12 @@ export function checkInstructions(
       issues.push(`${AGENTS_FILE} host addendum: present but no longer configured (re-run init)`);
     }
 
-    if (opts.adapter === "claude-code") {
+    const skillsDir = adapterSkillsDir(opts.adapter);
+    if (skillsDir) {
       const exclude = readSkillsExclude(projectRoot);
       for (const skill of SKILLS) {
         if (exclude.has(skill.id)) continue;
-        const skillPath = join(projectRoot, CLAUDE_SKILLS_DIR, skill.relPath);
+        const skillPath = join(projectRoot, skillsDir, skill.relPath);
         const c = existsSync(skillPath) ? readFileSync(skillPath, "utf8") : "";
         note(`skill ${skill.id}`, checkOwnedSkill(c, skillBody(skill.render, opts.binName)));
       }

package/src/lib/instructions/bundle.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import type { Adapter } from "../../core/hooks/events/schema.ts";
+import type { Adapter } from "../../core/adapter.ts";
 
 export type InstructionComponentRole = "always_loaded" | "just_in_time" | "runtime_config";
 
@@ -109,7 +109,7 @@ function adapterCandidates(root: string, adapter: Adapter): Candidate[] {
     addFile(join(root, ".cursor", "hooks.json"), "runtime_config");
   } else {
     addFile(join(root, "AGENTS.md"), "always_loaded");
-    addTree(join(root, ".harnery", "skills"), "just_in_time");
+    addTree(join(root, ".agents", "skills"), "just_in_time");
     addFile(join(root, ".codex", "hooks.json"), "runtime_config");
   }
 

package/src/lib/instructions/splice.ts

@@ -32,6 +32,24 @@ function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+function trimHorizontalWhitespaceBeforeNewlines(content: string): string {
+  const chunks: string[] = [];
+  let segmentStart = 0;
+  for (let index = 0; index < content.length; index++) {
+    if (content.charCodeAt(index) !== 10) continue;
+    let segmentEnd = index;
+    while (segmentEnd > segmentStart) {
+      const code = content.charCodeAt(segmentEnd - 1);
+      if (code !== 32 && code !== 9) break;
+      segmentEnd--;
+    }
+    chunks.push(content.slice(segmentStart, segmentEnd), "\n");
+    segmentStart = index + 1;
+  }
+  chunks.push(content.slice(segmentStart));
+  return chunks.join("");
+}
+
 /**
  * Marker comment style. Markdown/HTML files wrap markers in HTML comments;
  * shell files (git hooks) use `#` line comments. The style only changes the
@@ -94,7 +112,7 @@ export function spliceRegion(
     const text = content.replace(re, () => fresh);
     return { text, changed: text !== content, had: true, stale };
   }
-  const trimmed = content.replace(/\s+$/, "");
+  const trimmed = content.trimEnd();
   const text = trimmed ? `${trimmed}\n\n${fresh}\n` : `${fresh}\n`;
   return { text, changed: true, had: false, stale: false };
 }
@@ -112,9 +130,7 @@ export function removeRegion(
 ): { text: string; removed: boolean } {
   const re = regionRe(region, style);
   if (!re.test(content)) return { text: content, removed: false };
-  const stripped = content
-    .replace(re, "")
-    .replace(/[ \t]+\n/g, "\n")
+  const stripped = trimHorizontalWhitespaceBeforeNewlines(content.replace(re, ""))
     .replace(/\n{3,}/g, "\n\n")
     .trim();
   return { text: stripped ? `${stripped}\n` : "", removed: true };
@@ -150,15 +166,13 @@ export function isOwnedFile(content: string): boolean {
 export function buildOwnedSkill(opts: {
   name: string;
   description: string;
-  argumentHint?: string;
   binName: string;
   body: string;
 }): string {
   const fm = [
     "---",
     `name: ${opts.name}`,
-    `description: ${opts.description}`,
-    ...(opts.argumentHint ? [`argument-hint: ${JSON.stringify(opts.argumentHint)}`] : []),
+    `description: ${JSON.stringify(opts.description)}`,
     "---",
   ].join("\n");
   const body = opts.body.trim();

package/src/lib/instructions/templates.ts

@@ -28,10 +28,12 @@ export const HOST_ADDENDUM_REGION = "host-addendum";
 
 /** Which shipped skills exist in the project the block is rendered for. */
 export interface BlockSkills {
-  /** the `harn-decide` skill file is present (claude-code, not excluded) */
+  /** the `harn-decide` skill file is present */
   decide: boolean;
   /** the `harn-council` skill file is present */
   council: boolean;
+  /** the `harn-end` skill file is present */
+  end: boolean;
 }
 
 /**
@@ -39,22 +41,24 @@ export interface BlockSkills {
  * lines: it costs every agent context on every turn, so it states that each
  * surface *exists* and gives one line of *when* — the *how* lives in the skills
  * and each command's `--help`. Skill names are fixed (`harn-decide`,
- * `harn-council`) even for a renamed bin; only command strings track `binName`.
+ * `harn-council`, `harn-end`) even for a renamed bin; only command strings
+ * track `binName`.
  *
  * The block only points at a skill that actually exists here: a host that
- * excludes one via `skills.exclude`, or a adapter with no skill primitive
- * (cursor/codex get the block but no skill files), gets a `--help` pointer
- * instead of a dangling reference to a skill it doesn't have.
+ * excludes one via `skills.exclude` gets a CLI pointer instead of a dangling
+ * reference to a skill it doesn't have.
  */
 export function renderInstructionsBlock(
   binName: string,
-  skills: BlockSkills = { decide: true, council: true },
+  skills: BlockSkills = { decide: true, council: true, end: true },
 ): string {
   const b = binName;
 
-  const named = [skills.decide && "`harn-decide`", skills.council && "`harn-council`"].filter(
-    Boolean,
-  ) as string[];
+  const named = [
+    skills.decide && "`harn-decide`",
+    skills.council && "`harn-council`",
+    skills.end && "`harn-end`",
+  ].filter(Boolean) as string[];
   const deeper =
     named.length > 0
       ? `Procedures for the deeper flows live in the ${named.join(" and ")} skill${named.length > 1 ? "s" : ""}.`
@@ -65,6 +69,9 @@ export function renderInstructionsBlock(
   const councilPointer = skills.council
     ? "The `harn-council` skill has the steward and member flow."
     : `See \`${b} agents council --help\` for the steward and member flow.`;
+  const endPointer = skills.end
+    ? "When the whole session is genuinely finished, use the `harn-end` skill as the final workflow."
+    : `When the whole session is genuinely finished, run \`${b} agents status --end-turn --end-session\` as the final tool action.`;
   // Render the journal categories from the canonical enum so this prose can
   // never drift from what `journal add` actually accepts (the "note, plan…" list
   // silently lagged the tool by two categories before this).
@@ -87,6 +94,14 @@ active peers and the files they've claimed; \`${b} agents set-task "<focus>"\`
 declares your current focus so peers can see it. Check for peers before editing
 widely-shared files.
 
+**Task lifecycle.** Beside the activity peers already see, declare whether your
+objective is still open: \`${b} agents lifecycle blocked --reason "<why>"\` when
+it cannot proceed, \`${b} agents lifecycle done\` when it is complete, and
+\`${b} agents lifecycle active\` to reopen. \`done\` requires a current task and
+a passing Git finalization check (dirty or unpushed work refuses, and nothing is
+written). Ordinary \`set-task\` calls never change lifecycle, and a transition
+that re-mints the session title tells you the new name to copy. ${endPointer}
+
 **Dispatching a team.** Everything else here coordinates the agents already
 present. These three start new ones, and they differ by how long the objective
 outlives a single execution. \`${b} run <script>\` is one bounded pass:
@@ -251,7 +266,7 @@ The web UI is the member + steward picker; don't create from the CLI (that skips
 the steward choice). Emit the link with the objective URL-encoded:
 
 \`\`\`
-http://localhost:9000/councils/new?objective=<encoded>
+http://localhost:4276/councils/new?objective=<encoded>
 \`\`\`
 
 If the dev server isn't up, start it with \`${b} web up\`.
@@ -307,6 +322,54 @@ mismatch), and offer the right next step. Don't propose a workaround that bypass
 the guard.`;
 }
 
+function endBody(b: string): string {
+  return `Finalize only after the work is genuinely complete. This is the deliberate,
+high-confidence escape hatch for adapters that do not provide a trustworthy
+native session-end callback.
+
+## Workflow
+
+1. Finish all in-scope work, tests, documentation, commits, pushes, and
+   user-facing reporting first.
+2. Confirm no tool call, open turn, delegated child, file claim, or uncommitted
+   session write remains. Do not fabricate completion or use this skill to hide
+   unfinished work.
+3. Run the closing status and end request as the final tool action:
+
+   \`\`\`bash
+   ${b} agents status --end-turn --end-session
+   \`\`\`
+
+   When automatic identity resolution is unavailable, pass the current native
+   adapter session ID with \`--session-id <id>\`. The command durably queues the
+   authoritative end while it is still running. The adapter's stop hook records
+   \`session.ended\` only after this command, its tool span, and the current turn
+   have closed.
+4. Do not run another tool after a successful request. Reproduce the status
+   output, tell the operator the end is queued, and yield. The terminal event ID
+   becomes available after the response completes and can be verified from a
+   later session or the web UI.
+
+## Refusals and recovery
+
+- If the command reports delegated work, finish or explicitly cancel those
+  children, then try again.
+- If Git finalization fails, complete the repository's required commit and push
+  workflow before retrying.
+- If the V3 ledger is unavailable or unsafe, do not fall back to deleting a
+  projection or writing a synthetic ledger row. Report the failure.
+- Starting a new turn or tool after the request cancels the pending end. Run the
+  workflow again when the session is actually finished.
+- On a manual \`${b} agents end\` call, use \`--outcome failed\`, \`cancelled\`,
+  \`interrupted\`, or \`unknown\` only when that describes the completed session
+  honestly.
+
+Never use this skill to end another operator's session unless the operator
+explicitly identifies it. Use the web control or \`${b} agents end --instance-id
+<id>\` for that operator action; it records immediately for an idle session or
+durably queues the end for its current turn.`;
+}
+
 export const SKILLS: SkillTemplate[] = [
   {
     id: "harn-decide",
@@ -316,7 +379,6 @@ export const SKILLS: SkillTemplate[] = [
         name: "harn-decide",
         description:
           "File a decision into the docket instead of blocking on a human: search precedent, file it, and proceed on a reversible default; or pick up and resolve an open decision with cited evidence. Use whenever you're about to ask a human a decision-shaped question you could resolve yourself.",
-        argumentHint: "[<the decision / question you're facing> | resolve <id> | review]",
         binName,
         body: decideBody(binName),
       }),
@@ -329,10 +391,20 @@ export const SKILLS: SkillTemplate[] = [
         name: "harn-council",
         description:
           "Interact with the multi-agent council system: list / create / show / prompts (steward) / contribute (member). Guards against misrouting: refuses to contribute when you aren't a member, have already contributed, or weren't routed a prompt.",
-        argumentHint:
-          "[<id-or-fragment> | create <objective> | contribute <id> | prompts <id> | show <id>]",
         binName,
         body: councilBody(binName),
       }),
   },
+  {
+    id: "harn-end",
+    relPath: "harn-end/SKILL.md",
+    render: (binName) =>
+      buildOwnedSkill({
+        name: "harn-end",
+        description:
+          "Safely finalize the current Harnery agent session with an authoritative V3 session-ended event. Use when the operator says /harn-end, asks to end or close the current session, or when all work is complete and the session should stop counting as live.",
+        binName,
+        body: endBody(binName),
+      }),
+  },
 ];

package/dist/core/agents/cli-emit.d.ts

@@ -1,27 +0,0 @@
-/**
- * CLI-side canonical event emission helper. Importable from any CLI surface
- * to emit-then-project in one call.
- *
- * Pattern: every state-changing CLI command appends its event first, then
- * runs the projector synchronously for the affected owner.
- */
-import { type EmitInput, type Envelope } from "./events/emit.js";
-export interface EmitAndProjectResult {
-    envelope: Envelope;
-    projected: boolean;
-}
-/**
- * Emit a canonical event AND synchronously project it into the owner's v2
- * heartbeat. Idempotent on event_id: replays don't double-apply.
- *
- * Returns the emitted envelope so callers can inspect / log.
- *
- * Soft-fails on any internal error: never throws into the caller, because
- * this runs inside operator-facing CLI commands and a corrupt events.ndjson
- * line shouldn't break `agents set-task`.
- */
-export declare function emitAndProject(input: EmitInput, opts?: {
-    coordRoot?: string;
-    skipProject?: boolean;
-}): EmitAndProjectResult | null;
-//# sourceMappingURL=cli-emit.d.ts.map

package/dist/core/agents/cli-emit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-emit.d.ts","sourceRoot":"","sources":["../../../src/core/agents/cli-emit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAQ,MAAM,kBAAkB,CAAC;AAIvE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACvD,oBAAoB,GAAG,IAAI,CAiC7B"}

package/dist/core/agents/cli-emit.js

@@ -1,57 +0,0 @@
-/**
- * CLI-side canonical event emission helper. Importable from any CLI surface
- * to emit-then-project in one call.
- *
- * Pattern: every state-changing CLI command appends its event first, then
- * runs the projector synchronously for the affected owner.
- */
-import { emit } from "./events/emit.js";
-import { findCoordRoot } from "./paths.js";
-import { projectHeartbeats } from "./state/heartbeat-projector.js";
-/**
- * Emit a canonical event AND synchronously project it into the owner's v2
- * heartbeat. Idempotent on event_id: replays don't double-apply.
- *
- * Returns the emitted envelope so callers can inspect / log.
- *
- * Soft-fails on any internal error: never throws into the caller, because
- * this runs inside operator-facing CLI commands and a corrupt events.ndjson
- * line shouldn't break `agents set-task`.
- */
-export function emitAndProject(input, opts = {}) {
-    const root = opts.coordRoot ?? findCoordRoot();
-    if (!root)
-        return null;
-    try {
-        const envelope = emit(root, input);
-        let projected = false;
-        if (!opts.skipProject) {
-            try {
-                projectHeartbeats(root, [
-                    {
-                        schema_version: envelope.schema_version,
-                        event_id: envelope.event_id,
-                        event_type: envelope.event_type,
-                        ts: envelope.ts,
-                        instance_id: envelope.instance_id,
-                        session_id: envelope.session_id,
-                        parent_session_id: envelope.parent_session_id,
-                        turn_id: envelope.turn_id,
-                        parent_turn_id: envelope.parent_turn_id,
-                        adapter: envelope.adapter,
-                        source: envelope.source,
-                        data: envelope.data,
-                    },
-                ]);
-                projected = true;
-            }
-            catch {
-                /* projector failure is non-fatal; next agent-coord project run catches up */
-            }
-        }
-        return { envelope, projected };
-    }
-    catch {
-        return null;
-    }
-}

package/dist/core/agents/codex-replay.d.ts

@@ -1,29 +0,0 @@
-/**
- * Codex JSONL → canonical event replay.
- *
- * Production codex sessions emit canonical events from each `harn` invocation
- * via the in-process session-tee middleware (which calls `agent-coord
- * emit-event` for state.task_set / state.status_checked). But the codex
- * adapter itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
- * + tool.pre_use + turn.stop aren't emitted live.
- *
- * This module parses the Codex JSONL transcript at stop time and emits the
- * missing canonical events so the verdict has a complete turn-window view.
- *
- * Scope: just the events the stop-hook verdict reads: user_prompt.submit,
- * tool.pre_use (for exec_command function calls), state.status_checked
- * (when the cmd contains `<bin> agents status`), state.task_set (when the cmd
- * contains `<bin> agents set-task`), turn.stop (with status_box_present derived
- * from the last_assistant_message).
- */
-export interface CodexReplayOpts {
-    coordRoot: string;
-    sessionId: string;
-    instanceId: string;
-    jsonlPath: string;
-    lastAssistantMessage?: string;
-}
-export declare function replayCodexJsonl(opts: CodexReplayOpts): {
-    emitted: number;
-};
-//# sourceMappingURL=codex-replay.d.ts.map

package/dist/core/agents/codex-replay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codex-replay.d.ts","sourceRoot":"","sources":["../../../src/core/agents/codex-replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAkBH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAkH3E"}

package/dist/core/agents/codex-replay.js

@@ -1,138 +0,0 @@
-/**
- * Codex JSONL → canonical event replay.
- *
- * Production codex sessions emit canonical events from each `harn` invocation
- * via the in-process session-tee middleware (which calls `agent-coord
- * emit-event` for state.task_set / state.status_checked). But the codex
- * adapter itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
- * + tool.pre_use + turn.stop aren't emitted live.
- *
- * This module parses the Codex JSONL transcript at stop time and emits the
- * missing canonical events so the verdict has a complete turn-window view.
- *
- * Scope: just the events the stop-hook verdict reads: user_prompt.submit,
- * tool.pre_use (for exec_command function calls), state.status_checked
- * (when the cmd contains `<bin> agents status`), state.task_set (when the cmd
- * contains `<bin> agents set-task`), turn.stop (with status_box_present derived
- * from the last_assistant_message).
- */
-import { existsSync, readFileSync } from "node:fs";
-import { emit } from "./events/emit.js";
-const STATUS_BOX_PREFIX = "┌─ agent-";
-export function replayCodexJsonl(opts) {
-    const { coordRoot, sessionId, instanceId, jsonlPath, lastAssistantMessage } = opts;
-    if (!existsSync(jsonlPath))
-        return { emitted: 0 };
-    let raw;
-    try {
-        raw = readFileSync(jsonlPath, "utf8");
-    }
-    catch {
-        return { emitted: 0 };
-    }
-    let emitted = 0;
-    const lines = raw.split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const ts = entry.timestamp;
-        const t = entry.type;
-        if (t === "event_msg" && entry.payload?.type === "user_message") {
-            emit(coordRoot, {
-                event_type: "user_prompt.submit",
-                instance_id: instanceId,
-                session_id: sessionId,
-                adapter: "codex",
-                ts,
-                data: {
-                    prompt_text: clamp(entry.payload.message ?? "", 4000),
-                },
-            });
-            emitted += 1;
-            continue;
-        }
-        if (t === "response_item" && entry.payload?.type === "function_call") {
-            const name = entry.payload.name ?? "";
-            let cmd = "";
-            if (entry.payload.arguments) {
-                try {
-                    const parsed = JSON.parse(entry.payload.arguments);
-                    cmd = parsed.cmd ?? "";
-                }
-                catch {
-                    /* skip */
-                }
-            }
-            // Emit tool.pre_use for every function call.
-            emit(coordRoot, {
-                event_type: "tool.pre_use",
-                instance_id: instanceId,
-                session_id: sessionId,
-                adapter: "codex",
-                ts,
-                data: {
-                    tool_name: name === "exec_command" ? "Bash" : name,
-                    tool_input: JSON.stringify({ command: cmd }),
-                    intent: "",
-                    intent_source: "codex-replay",
-                },
-            });
-            emitted += 1;
-            // Match `<bin> agents status` / `<bin> agents set-task`, bin-agnostic, so
-            // it works for harn or any host CLI that composes harnery (a consumer's own
-            // binary). Wrapped invocations (cd && <bin> ...; PATH=... <bin> ...) pass
-            // because we scan the whole cmd string and anchor on the token before `agents`.
-            if (/(^|\s|;|&&)[\w./-]+\s+agents\s+status(\b|$)/.test(cmd)) {
-                emit(coordRoot, {
-                    event_type: "state.status_checked",
-                    instance_id: instanceId,
-                    session_id: sessionId,
-                    adapter: "codex",
-                    ts,
-                    data: { source: "codex-replay" },
-                });
-                emitted += 1;
-            }
-            if (/(^|\s|;|&&)[\w./-]+\s+agents\s+set-task(\b|$)/.test(cmd)) {
-                emit(coordRoot, {
-                    event_type: "state.task_set",
-                    instance_id: instanceId,
-                    session_id: sessionId,
-                    adapter: "codex",
-                    ts,
-                    data: { source: "codex-replay" },
-                });
-                emitted += 1;
-            }
-        }
-    }
-    // Finally, emit turn.stop with status_box_present derived from the last
-    // assistant message (codex's stop payload carries the assistant text
-    // directly, unlike CC which only has transcript_path).
-    const boxPresent = !!lastAssistantMessage && lastAssistantMessage.includes(STATUS_BOX_PREFIX);
-    emit(coordRoot, {
-        event_type: "turn.stop",
-        instance_id: instanceId,
-        session_id: sessionId,
-        adapter: "codex",
-        data: {
-            status_box_present: boxPresent,
-            tool_call_count: -1,
-            text_length: lastAssistantMessage?.length ?? 0,
-        },
-    });
-    emitted += 1;
-    return { emitted };
-}
-function clamp(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max);
-}