harnery 0.32.0 → 0.34.0

package/dist/core/hooks/events/ulid.js

@@ -1,47 +0,0 @@
-/**
- * Tiny ULID generator. Crockford-base32, 10-char timestamp (48-bit ms epoch)
- * + 16-char random (80-bit). 26 chars total, monotonically-sortable.
- *
- * Library-free so the module stays dep-free (no `ulid` package). Quality is
- * sufficient for event_id uniqueness: the kth event in a millisecond uses a
- * fresh 80-bit random, collision probability negligible.
- */
-const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export function ulid() {
-    const ts = encodeTime(Date.now());
-    const rnd = encodeRandom();
-    return ts + rnd;
-}
-function encodeTime(ms) {
-    let out = "";
-    let n = BigInt(ms);
-    const base = BigInt(32);
-    for (let i = 0; i < 10; i++) {
-        const mod = Number(n % base);
-        out = ALPHABET[mod] + out;
-        n = n / base;
-    }
-    return out;
-}
-function encodeRandom() {
-    const bytes = new Uint8Array(10);
-    crypto.getRandomValues(bytes);
-    // Map each pair of bytes to 3 alphabet chars (5 bits per char, 16 chars).
-    let out = "";
-    let buf = 0n;
-    let bits = 0;
-    for (const b of bytes) {
-        buf = (buf << 8n) | BigInt(b);
-        bits += 8;
-        while (bits >= 5) {
-            bits -= 5;
-            const idx = Number((buf >> BigInt(bits)) & 0x1fn);
-            out += ALPHABET[idx];
-        }
-    }
-    if (bits > 0) {
-        const idx = Number((buf << BigInt(5 - bits)) & 0x1fn);
-        out += ALPHABET[idx];
-    }
-    return out.slice(0, 16);
-}

package/dist/lib/docs-frontmatter-migrate.d.ts

@@ -1,33 +0,0 @@
-import { type DocKind } from "./docs-frontmatter.js";
-export declare function initDocsMigrationContext(opts: {
-    repoRoot: string;
-    submodules: readonly string[];
-}): void;
-export interface FrontmatterMigrationOpts {
-    repo?: string;
-    apply?: boolean;
-}
-export type FrontmatterMigrationStatus = "would-update" | "updated" | "skipped" | "error";
-export interface FrontmatterMigrationRow {
-    repo: string;
-    path: string;
-    kind: DocKind;
-    status: FrontmatterMigrationStatus;
-    fields: string[];
-    message?: string;
-}
-export interface FrontmatterConversion {
-    status: "convert" | "skipped" | "error";
-    content?: string;
-    fields: string[];
-    message?: string;
-}
-/**
- * Convert one lifecycle document without writing it.
- *
- * Only recognized bold fields in the opening block are removed. Narrative
- * labels and bold examples deeper in the body are left byte-for-byte intact.
- */
-export declare function convertLifecycleFrontmatter(content: string, kind: DocKind): FrontmatterConversion;
-export declare function runFrontmatterMigration(opts: FrontmatterMigrationOpts): FrontmatterMigrationRow[];
-//# sourceMappingURL=docs-frontmatter-migrate.d.ts.map

package/dist/lib/docs-frontmatter-migrate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"docs-frontmatter-migrate.d.ts","sourceRoot":"","sources":["../../src/lib/docs-frontmatter-migrate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAqC,MAAM,uBAAuB,CAAC;AAKxF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,GAAG,IAAI,CAGP;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,0BAA0B,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE1F,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,0BAA0B,CAAC;IACnC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAsKD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,qBAAqB,CAsHjG;AAoCD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,wBAAwB,GAAG,uBAAuB,EAAE,CA+DjG"}

package/dist/lib/docs-frontmatter-migrate.js

@@ -1,364 +0,0 @@
-import { existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import { dump as dumpYaml, JSON_SCHEMA } from "js-yaml";
-import { normalizeStatus, parseFrontmatter } from "./docs-frontmatter.js";
-let REPO_ROOT = "";
-let SUBMODULES = [];
-export function initDocsMigrationContext(opts) {
-    REPO_ROOT = opts.repoRoot;
-    SUBMODULES = opts.submodules;
-}
-const FIELD_KEYS = {
-    status: "status",
-    date: "date",
-    "last updated": "last_updated",
-    "date identified": "date",
-    "date resolved": "resolved",
-    "date fixed": "resolved",
-    prerequisites: "prerequisites",
-    severity: "severity",
-    resolved: "resolved",
-    affected: "affected",
-    impact: "affected",
-    owner: "owner",
-    continues: "continues",
-    "what you're picking up": "synopsis",
-};
-const FIELD_ORDER = [
-    "status",
-    "date",
-    "last_updated",
-    "status_note",
-    "prerequisites",
-    "owner",
-    "severity",
-    "resolved",
-    "affected",
-    "continues",
-    "synopsis",
-];
-function normalizeLabel(label) {
-    return label.trim().toLowerCase();
-}
-function openingFields(body) {
-    const lines = body.split("\n");
-    const fields = [];
-    for (let index = 0; index < Math.min(lines.length, 40); index++) {
-        const line = lines[index];
-        if (/^##\s+/.test(line) || (index > 0 && /^---\s*$/.test(line)))
-            break;
-        const match = line.match(/^\*\*([^*]+):\*\*\s*(.*)$/) ?? line.match(/^\*\*([^*]+)\*\*:\s*(.*)$/);
-        if (!match)
-            continue;
-        const label = normalizeLabel(match[1]);
-        if (!(label in FIELD_KEYS))
-            continue;
-        fields.push({ index, label, value: match[2].trim() });
-    }
-    return fields;
-}
-function cleanNote(value) {
-    let note = value.trim().replace(/^[-–—\s]+/, "");
-    if (note.startsWith("(") && note.endsWith(")"))
-        note = note.slice(1, -1);
-    return note
-        .replace(/\*\*/g, "")
-        .replace(/^[*_`]+|[*_`]+$/g, "")
-        .trim();
-}
-function cleanStatusToken(value) {
-    return value.trim().replace(/^[*_`]+|[*_`]+$/g, "");
-}
-function splitStatus(raw, kind) {
-    const clean = raw.replace(/^[^\p{L}\p{N}]+/u, "").trim();
-    if (!clean)
-        return { error: "empty status value" };
-    const separator = clean.match(/\s+[-–—]\s+|\s*\(/);
-    if (separator?.index != null) {
-        const token = cleanStatusToken(clean.slice(0, separator.index));
-        const normalized = normalizeStatus(token, kind);
-        if (normalized) {
-            const note = cleanNote(clean.slice(separator.index));
-            return { status: normalized, ...(note ? { note } : {}) };
-        }
-    }
-    const whole = normalizeStatus(cleanStatusToken(clean), kind);
-    if (whole)
-        return { status: whole };
-    const words = clean.split(/\s+/);
-    for (const count of [1, 2, 3]) {
-        if (words.length <= count)
-            continue;
-        const token = cleanStatusToken(words.slice(0, count).join(" "));
-        const normalized = normalizeStatus(token, kind);
-        if (!normalized)
-            continue;
-        const note = cleanNote(words.slice(count).join(" "));
-        return { status: normalized, ...(note ? { note } : {}) };
-    }
-    return { error: `unsupported ${kind} status '${raw}'` };
-}
-function leadingDate(raw) {
-    const match = raw.match(/^(\d{4}-\d{2}-\d{2})(.*)$/);
-    if (!match)
-        return { value: raw };
-    const note = cleanNote(match[2]);
-    return { value: match[1], ...(note ? { note } : {}) };
-}
-function splitSeverity(raw) {
-    const plain = raw.replace(/\*\*/g, "").trim();
-    const leading = plain.match(/^(low|medium|high|critical)\b(.*)$/i);
-    if (leading) {
-        const note = cleanNote(leading[2]);
-        return {
-            severity: leading[1].toLowerCase(),
-            ...(note ? { note } : {}),
-        };
-    }
-    const severity = /\bcritical\b/i.test(plain)
-        ? "critical"
-        : /\bhigh\b/i.test(plain)
-            ? "high"
-            : /\b(?:medium|moderate)\b/i.test(plain)
-                ? "medium"
-                : /\blow\b/i.test(plain)
-                    ? "low"
-                    : null;
-    if (!severity)
-        return { error: `unsupported severity '${raw}'` };
-    return { severity, note: plain };
-}
-function serializeFields(fields) {
-    return FIELD_ORDER.filter((key) => Object.hasOwn(fields, key))
-        .map((key) => dumpYaml({ [key]: fields[key] }, {
-        schema: JSON_SCHEMA,
-        noRefs: true,
-        lineWidth: -1,
-        sortKeys: false,
-    }).trimEnd())
-        .join("\n");
-}
-function mergeStatusNote(existing, notes) {
-    const parts = [
-        ...(typeof existing === "string" && existing.trim() ? [existing.trim()] : []),
-        ...notes.filter(Boolean),
-    ];
-    return parts.length > 0 ? parts.join("; ") : undefined;
-}
-function valuesEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}
-/**
- * Convert one lifecycle document without writing it.
- *
- * Only recognized bold fields in the opening block are removed. Narrative
- * labels and bold examples deeper in the body are left byte-for-byte intact.
- */
-export function convertLifecycleFrontmatter(content, kind) {
-    const parsed = parseFrontmatter(content);
-    const boldFields = openingFields(parsed.body);
-    const statusFields = boldFields.filter((field) => field.label === "status");
-    const hasYamlStatus = typeof parsed.data.status === "string" && parsed.data.status.trim();
-    if (statusFields.length === 0 && !hasYamlStatus) {
-        const variant = parsed.body
-            .split("\n")
-            .slice(0, 40)
-            .find((line) => /^\*\*Status/i.test(line));
-        return {
-            status: variant ? "error" : "skipped",
-            fields: [],
-            message: variant ? `unsupported bold status shape '${variant.trim()}'` : "no opening status",
-        };
-    }
-    if (statusFields.length === 0 && hasYamlStatus && boldFields.length === 0) {
-        return {
-            status: "skipped",
-            fields: [],
-            message: "already has YAML status",
-        };
-    }
-    if (statusFields.length > 1) {
-        return {
-            status: "error",
-            fields: [],
-            message: "multiple opening Status fields",
-        };
-    }
-    const migrated = {};
-    const notes = [];
-    const remove = new Set();
-    const hasOpeningDate = boldFields.some((field) => field.label === "date");
-    for (const field of boldFields) {
-        const key = FIELD_KEYS[field.label];
-        let value = field.value;
-        if (key === "status") {
-            const split = splitStatus(field.value, kind);
-            if ("error" in split)
-                return { status: "error", fields: [], message: split.error };
-            value = split.status;
-            if (split.note &&
-                /^\d{4}-\d{2}-\d{2}$/.test(split.note) &&
-                kind === "plan" &&
-                split.status === "proposed" &&
-                !hasOpeningDate &&
-                !Object.hasOwn(parsed.data, "date")) {
-                migrated.date = split.note;
-            }
-            else if (split.note) {
-                notes.push(split.note);
-            }
-        }
-        else if (key === "date" || key === "last_updated" || key === "resolved") {
-            const date = leadingDate(field.value);
-            value = date.value;
-            if (date.note)
-                notes.push(`${key}: ${date.note}`);
-        }
-        else if (key === "prerequisites" && field.value.toLowerCase() === "none") {
-            value = [];
-        }
-        else if (key === "severity") {
-            const severity = splitSeverity(field.value);
-            if ("error" in severity) {
-                return { status: "error", fields: [], message: severity.error };
-            }
-            value = severity.severity;
-            if (severity.note)
-                notes.push(`severity: ${severity.note}`);
-        }
-        if (Object.hasOwn(migrated, key)) {
-            return {
-                status: "error",
-                fields: [],
-                message: `multiple opening '${field.label}' fields`,
-            };
-        }
-        if (Object.hasOwn(parsed.data, key)) {
-            if (!valuesEqual(parsed.data[key], value)) {
-                return {
-                    status: "error",
-                    fields: [],
-                    message: `YAML '${key}' conflicts with bold '${field.label}'`,
-                };
-            }
-        }
-        else {
-            migrated[key] = value;
-        }
-        remove.add(field.index);
-    }
-    const statusNote = mergeStatusNote(parsed.data.status_note, notes);
-    if (notes.length > 0 && Object.hasOwn(parsed.data, "status_note")) {
-        return {
-            status: "error",
-            fields: [],
-            message: "YAML 'status_note' conflicts with migrated metadata notes",
-        };
-    }
-    if (statusNote) {
-        migrated.status_note = statusNote;
-    }
-    const body = parsed.body
-        .split("\n")
-        .filter((_, index) => !remove.has(index))
-        .join("\n")
-        .replace(/^\n+/, "");
-    const newFields = serializeFields(migrated);
-    const yaml = parsed.raw ? `${parsed.raw.trimEnd()}\n${newFields}`.trim() : newFields;
-    const next = `---\n${yaml}\n---\n\n${body}`;
-    return {
-        status: "convert",
-        content: next,
-        fields: Object.keys(migrated),
-    };
-}
-function walkMarkdown(dir) {
-    if (!existsSync(dir))
-        return [];
-    const files = [];
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const path = join(dir, entry.name);
-        if (entry.isDirectory())
-            files.push(...walkMarkdown(path));
-        else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
-            files.push(path);
-        }
-    }
-    return files;
-}
-function lifecycleFiles(repoPath) {
-    const kinds = [
-        { dir: "plans", kind: "plan" },
-        { dir: "issues", kind: "issue" },
-        { dir: "handoffs", kind: "handoff" },
-    ];
-    return kinds.flatMap(({ dir, kind }) => walkMarkdown(join(repoPath, "docs", dir)).map((path) => ({ path, kind })));
-}
-function isInitializedRepo(path) {
-    return existsSync(join(path, ".git"));
-}
-function writeAtomic(path, content) {
-    const temp = join(dirname(path), `.${Date.now()}-${process.pid}.frontmatter.tmp`);
-    writeFileSync(temp, content, "utf8");
-    renameSync(temp, path);
-}
-export function runFrontmatterMigration(opts) {
-    const targets = [
-        { name: "(root)", path: REPO_ROOT },
-        ...SUBMODULES.map((name) => ({ name, path: resolve(REPO_ROOT, name) })).filter((target) => isInitializedRepo(target.path)),
-    ];
-    const filter = opts.repo === "." ? "(root)" : opts.repo;
-    const selected = filter ? targets.filter((target) => target.name === filter) : targets;
-    if (filter && selected.length === 0)
-        throw new Error(`Unknown repository: ${opts.repo}`);
-    const rows = [];
-    const pending = [];
-    for (const target of selected) {
-        for (const file of lifecycleFiles(target.path)) {
-            const displayPath = relative(REPO_ROOT, file.path);
-            let content;
-            try {
-                content = readFileSync(file.path, "utf8");
-            }
-            catch {
-                rows.push({
-                    repo: target.name,
-                    path: displayPath,
-                    kind: file.kind,
-                    status: "error",
-                    fields: [],
-                    message: "unable to read file",
-                });
-                continue;
-            }
-            const conversion = convertLifecycleFrontmatter(content, file.kind);
-            if (conversion.status === "error" || conversion.status === "skipped") {
-                rows.push({
-                    repo: target.name,
-                    path: displayPath,
-                    kind: file.kind,
-                    status: conversion.status,
-                    fields: conversion.fields,
-                    message: conversion.message,
-                });
-                continue;
-            }
-            const row = {
-                repo: target.name,
-                path: displayPath,
-                kind: file.kind,
-                status: "would-update",
-                fields: conversion.fields,
-            };
-            rows.push(row);
-            pending.push({ row, path: file.path, content: conversion.content });
-        }
-    }
-    if (opts.apply && !rows.some((row) => row.status === "error")) {
-        for (const item of pending) {
-            writeAtomic(item.path, item.content);
-            item.row.status = "updated";
-        }
-    }
-    return rows.sort((a, b) => a.path.localeCompare(b.path));
-}

package/src/core/agents/cli-emit.ts

@@ -1,64 +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, emit } from "./events/emit.ts";
-import { findCoordRoot } from "./paths.ts";
-import { projectHeartbeats } from "./state/heartbeat-projector.ts";
-
-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 function emitAndProject(
-  input: EmitInput,
-  opts: { coordRoot?: string; skipProject?: boolean } = {},
-): EmitAndProjectResult | null {
-  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/src/core/agents/codex-replay.ts

@@ -1,163 +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.ts";
-
-interface CodexEntry {
-  timestamp?: string;
-  type?: string;
-  payload?: {
-    type?: string;
-    message?: string;
-    name?: string;
-    arguments?: string;
-  };
-}
-
-const STATUS_BOX_PREFIX = "┌─ agent-";
-
-export interface CodexReplayOpts {
-  coordRoot: string;
-  sessionId: string;
-  instanceId: string;
-  jsonlPath: string;
-  lastAssistantMessage?: string;
-}
-
-export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
-  const { coordRoot, sessionId, instanceId, jsonlPath, lastAssistantMessage } = opts;
-  if (!existsSync(jsonlPath)) return { emitted: 0 };
-
-  let raw: string;
-  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: CodexEntry;
-    try {
-      entry = JSON.parse(line) as CodexEntry;
-    } 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) as { cmd?: string };
-          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: string, max: number): string {
-  if (s.length <= max) return s;
-  return s.slice(0, max);
-}