harnery 0.30.0 → 0.31.1

package/dist/core/agents/coord-client.js

@@ -8,7 +8,7 @@
  */
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 // NOTE: kept dependency-free (node builtins only); this file is vendored verbatim into
 // a downstream consumer, so it cannot import the coordEnv helper.
 const MAX_INSTANCE_ID_LENGTH = 128;
@@ -53,52 +53,171 @@ export function resolveContainedFile(directory, fileName) {
 /**
  * Resolve the monorepo root for coord-state purposes.
  *
- * Resolves the coordination root,
- * including the `--git-common-dir` fallback that strips
- * `<superproject>/.git/modules/<name>/` to recover the superproject for
- * submodule worktrees. Without that fallback, a TS coord caller running
- * inside a `harn worktree add-submodule` checkout would resolve a different
- * `.harnery/` than the bash hooks and the two layers would silently diverge.
+ * Thin alias for `resolveCoordRoot()`; kept because it is the name the CLI
+ * command modules and the vendored downstream consumer already import.
  */
 export function monorepoRoot() {
-    // Test-only override (matches bash HARNERY_COORD_ROOT_OVERRIDE). Lets tests
-    // seed `.harnery/pid-map/<pid>` + `.harnery/active/<owner>.json` fixtures
-    // in a tmpdir without needing a real git repo.
+    return resolveCoordRoot();
+}
+/**
+ * THE coordination-root resolution. Every surface — the hooks, the CLI's reads,
+ * and the CLI's canonical emits — resolves through this one function, because a
+ * root the two layers disagree about is a root that silently breaks the
+ * end-of-turn rules: the hook evaluates `state.status_checked` from the stream
+ * it reads, so an emit into a different `.harnery/events.ndjson` is invisible
+ * and rule 1/3 blocks a turn that did run `agents status`, with no sequence of
+ * CLI commands able to satisfy it.
+ *
+ * Precedence:
+ *   1. `HARNERY_COORD_ROOT_OVERRIDE` — explicit pin (tests, git hooks, and the
+ *      root every coord-helper spawn pins for its child).
+ *   2. `CLAUDE_PROJECT_DIR` — the adapter stating which project it opened. Hook
+ *      processes inherit the session's *shell* cwd, which follows `cd` into a
+ *      subdirectory or submodule that may carry a `.harnery/` of its own (or
+ *      none at all), so the adapter's own statement outranks the cwd walk.
+ *   3. The candidate root that already holds THIS session's heartbeat.
+ *   4. The nearest enclosing `.harnery/`, then a git-derived root.
+ *
+ * Step 3 is what makes CLI/hook disagreement structurally impossible rather
+ * than a coin flip. Choosing either root unconditionally is wrong in one
+ * direction each: preferring the git superproject strands a session whose
+ * adapter opened the submodule itself (its heartbeat lives in the submodule,
+ * so status/set-task wrote events the hook never read), while walking up from
+ * cwd alone strands the opposite case, a session opened on the superproject
+ * whose shell has cd'd into a submodule that carries its own `.harnery/`
+ * (regression-tested in tests/unit/coord-helper-root-pin.test.ts). The session's
+ * own heartbeat settles it: whichever root the hook registered this session in
+ * is the root the CLI must use, and the adapter-exported session id needed to
+ * recognize it is available to a plain tool-call subprocess even though
+ * `CLAUDE_PROJECT_DIR` is not.
+ */
+export function resolveCoordRoot(start = process.cwd()) {
     const rootOverride = process.env.HARNERY_COORD_ROOT_OVERRIDE;
-    if (rootOverride) {
+    if (rootOverride)
         return rootOverride;
+    const projectDir = process.env.CLAUDE_PROJECT_DIR;
+    if (projectDir) {
+        const fromProject = nearestCoordRoot(projectDir);
+        if (fromProject)
+            return fromProject;
     }
-    // 1. Superproject working tree (when running from inside a submodule).
-    const sup = spawnSync("git", ["rev-parse", "--show-superproject-working-tree"], {
-        encoding: "utf8",
-    });
-    if (sup.status === 0 && sup.stdout.trim() !== "") {
-        return sup.stdout.trim();
-    }
-    // 2. --git-common-dir fallback for submodule worktrees. `git worktree add`
-    // inside a submodule produces a worktree whose --show-superproject-working-
-    // tree is empty (the worktree has no submodule relationship of its own),
-    // but --git-common-dir points at <superproject>/.git/modules/<name>/, so
-    // we recover the superproject by stripping that suffix.
-    const common = spawnSync("git", ["rev-parse", "--git-common-dir"], {
-        encoding: "utf8",
-    });
-    if (common.status === 0) {
-        const cd = common.stdout.trim();
-        const idx = cd.indexOf("/.git/modules/");
-        if (idx !== -1) {
-            return cd.substring(0, idx);
-        }
+    // Nearest-first, so the fallback at the end keeps the historical cwd-walk
+    // behavior for a shell that has no registered session at all.
+    const ancestors = ancestorCoordRoots(start);
+    for (const candidate of ancestors) {
+        if (rootKnowsSession(candidate))
+            return candidate;
     }
-    // 3. Top-level fallback (regular checkout).
-    const top = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-        encoding: "utf8",
-    });
-    if (top.status === 0 && top.stdout.trim() !== "") {
-        return top.stdout.trim();
+    // Only reached when no enclosing root knows this session: a submodule
+    // worktree (`harn worktree add-submodule`) has no ancestor relationship with
+    // the superproject that registered the session, so ask git for it.
+    const gitRoots = gitCoordRoots(start).filter((r) => !ancestors.includes(r));
+    for (const candidate of gitRoots) {
+        if (rootKnowsSession(candidate))
+            return candidate;
     }
-    return null;
+    if (ancestors.length > 0)
+        return ancestors[0];
+    if (gitRoots.length > 0)
+        return gitRoots[0];
+    // Nothing carries `.harnery/` yet. Hand back the enclosing checkout so a
+    // first run (`harn init`, agent-hook's session.start) has somewhere to
+    // create it.
+    return gitToplevel(start);
+}
+/** Nearest enclosing directory carrying `.harnery/`, or null. */
+export function nearestCoordRoot(start) {
+    return ancestorCoordRoots(start)[0] ?? null;
+}
+/** Every enclosing directory carrying `.harnery/`, nearest first. */
+function ancestorCoordRoots(start) {
+    const found = [];
+    let dir = resolve(start);
+    while (true) {
+        if (existsSync(join(dir, ".harnery")))
+            found.push(dir);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return found;
+}
+/**
+ * Does this root's `.harnery/` already know the process asking?
+ *
+ * Two discriminators, both genuinely about *this* session: the adapter-exported
+ * session id matching a live heartbeat, and a pid-map row on our own ppid
+ * chain. Deliberately NOT the single-live-agent fallback that owner resolution
+ * ends with — a lone stranger in the wrong root is exactly how `whoami` came to
+ * report another agent's name and task as its own.
+ */
+export function rootKnowsSession(root) {
+    if (resolveOwnerBySessionEnv(root))
+        return true;
+    return resolveOwnerByPidmap(root).owner !== null;
+}
+/**
+ * Git-derived candidate roots for `start`, in preference order, filtered to
+ * those that actually carry `.harnery/`.
+ *
+ * Spawns run with `cwd: start` rather than the process cwd so an injected
+ * start dir resolves its own repository — without that, a call about some
+ * unrelated directory inherits this process's repo and can resolve a root that
+ * has nothing to do with the question asked.
+ */
+function gitCoordRoots(start) {
+    const roots = [];
+    const push = (value) => {
+        if (value && existsSync(join(value, ".harnery")) && !roots.includes(value))
+            roots.push(value);
+    };
+    // Superproject working tree (running from inside a submodule).
+    push(gitRevParse(start, "--show-superproject-working-tree"));
+    // `--git-common-dir` fallback for submodule worktrees: `git worktree add`
+    // inside a submodule produces a worktree whose superproject working tree is
+    // empty (the worktree has no submodule relationship of its own), but the
+    // common dir points at `<superproject>/.git/modules/<name>/`, so the
+    // superproject is recoverable by stripping that suffix.
+    const common = gitRevParse(start, "--git-common-dir");
+    if (common) {
+        const idx = common.indexOf("/.git/modules/");
+        if (idx !== -1)
+            push(common.substring(0, idx));
+    }
+    // Top-level (regular checkout).
+    push(gitRevParse(start, "--show-toplevel"));
+    return roots;
+}
+function gitToplevel(start) {
+    return gitRevParse(start, "--show-toplevel");
 }
+function gitRevParse(cwd, flag) {
+    const key = `${cwd}${flag}`;
+    const cached = gitRevParseCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let value = null;
+    try {
+        // `cwd` must exist or the spawn itself fails; callers pass paths that may
+        // not (a project dir from a stale env var), so treat any failure as "no
+        // answer" rather than letting it throw.
+        const r = spawnSync("git", ["rev-parse", flag], { encoding: "utf8", cwd });
+        if (r.status === 0)
+            value = r.stdout.trim() || null;
+    }
+    catch {
+        value = null;
+    }
+    gitRevParseCache.set(key, value);
+    return value;
+}
+/**
+ * Memoized because git spawns are the expensive part of resolution and every
+ * CLI command resolves the root many times per invocation. Keyed by (cwd, flag);
+ * a repository's identity does not change under a running process.
+ */
+const gitRevParseCache = new Map();
 /** Parse owner from a pid-map row (`owner` or `owner\tplatform`). */
 export function parsePidmapRowOwner(row) {
     const trimmed = row.trim();
@@ -107,9 +226,97 @@ export function parsePidmapRowOwner(row) {
 }
 /** Parse platform from a pid-map row; legacy rows default to `claude_code`. */
 export function parsePidmapRowPlatform(row) {
-    const trimmed = row.trim();
-    const tab = trimmed.indexOf("\t");
-    return tab >= 0 ? trimmed.slice(tab + 1).trim() : "claude_code";
+    const platform = row.trim().split("\t")[1]?.trim();
+    return platform || "claude_code";
+}
+/** Parse the start token from a pid-map row; rows written before it carry none. */
+export function parsePidmapRowStartToken(row) {
+    return row.trim().split("\t")[2]?.trim() || undefined;
+}
+/**
+ * Is the process now holding `pid` the one this row was written for?
+ *
+ * A pid is a number the OS re-issues, and quickly: a `pid_max` of 99999 against
+ * ~100 new processes a second recycles the whole space about every quarter
+ * hour. Believing a row past that point resolves this session to whichever
+ * agent last held the number — which is what made `whoami` report a stranger's
+ * name and files. The start token settles it, since two processes may share a
+ * pid but never a pid and a start instant.
+ *
+ * Deliberately inlined rather than imported from `state/proc-start.ts`: this
+ * file is vendored verbatim into a downstream consumer and stays on node
+ * builtins only. The token is a wire format shared with that module and with
+ * the host's commit guard, so the copies must agree byte for byte; exported so
+ * a test can hold this one against `processStartToken` and fail on drift.
+ */
+export function pidStartToken(pid) {
+    const forced = process.env.HARNERY_PID_PROBE;
+    const useProcfs = forced === "procfs" || (forced !== "ps" && existsSync("/proc/self/stat"));
+    // One machine, one probe. Falling back to the other on a read failure would
+    // answer in the wrong dialect and read as a recycled pid.
+    if (useProcfs) {
+        try {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            const afterComm = stat.slice(stat.lastIndexOf(") ") + 2);
+            // Fields after comm, 0-based: 0 is state (field 3), starttime (22) is 19.
+            const ticks = afterComm.split(" ")[19];
+            if (!ticks || !/^\d+$/.test(ticks))
+                return null;
+            // Ticks count from boot, so they repeat across reboots; the boot id scopes
+            // them. Rows written before it carry ticks alone and still compare.
+            let boot = "";
+            try {
+                const raw = readFileSync("/proc/sys/kernel/random/boot_id", "utf8")
+                    .trim()
+                    .replace(/-/g, "");
+                if (/^[0-9a-f]{8,}$/.test(raw))
+                    boot = `${raw.slice(0, 8)}.`;
+            }
+            catch {
+                /* unnamed boot: fall back to the tick-only shape */
+            }
+            return `l${boot}${ticks}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        // TZ and locale are pinned because `ps` renders the date through them, and
+        // two callers with different environments must not disagree about one
+        // process.
+        const out = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8",
+            timeout: 2000,
+            env: { ...process.env, TZ: "UTC", LC_ALL: "C" },
+        });
+        if (out.status !== 0)
+            return null;
+        const lstart = (out.stdout ?? "").split("\n")[0]?.trim().replace(/\s+/g, " ");
+        return lstart ? `p${lstart}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function pidWasRecycled(pid, row) {
+    const recorded = parsePidmapRowStartToken(row);
+    if (!recorded)
+        return false; // pre-token row: unverifiable, behave as before
+    const current = pidStartToken(pid);
+    if (!current)
+        return false;
+    if (current === recorded)
+        return false;
+    // A row predating the boot segment recorded ticks alone; compare it on what
+    // it recorded rather than pruning every live row on the first upgraded run.
+    if (recorded[0] === "l" &&
+        current[0] === "l" &&
+        recorded.includes(".") !== current.includes(".")) {
+        const ticks = (t) => (t.includes(".") ? t.slice(t.indexOf(".") + 1) : t.slice(1));
+        return ticks(recorded) !== ticks(current);
+    }
+    return true;
 }
 function readPidmapRow(pidmapDir, pid) {
     const candidate = resolve(pidmapDir, String(pid));
@@ -153,15 +360,43 @@ export function resolveOwnerWithSource() {
     const root = monorepoRoot();
     if (!root)
         return { owner: null, source: "none" };
-    // Cursor's Glass/Agents UI can run several chats under one long-lived node
-    // process, so the pid-map row for that shared ancestor is last-writer-wins.
-    // Prefer the per-chat session id when Cursor exposes one in the tool env.
+    // Every supported adapter exports its session id into the env of the
+    // subprocess it spawns for a tool call, and each heartbeat records the
+    // session id it was minted under. Matching the two names us outright, even
+    // with many live agents, so it goes ahead of the ppid walk rather than
+    // catching what the walk drops. Cursor needed this first because its
+    // Glass/Agents UI runs several chats under one node ancestor, making that row
+    // last-writer-wins; pid recycling generalises the same hazard to every
+    // adapter.
     if (shouldPreferSessionEnv()) {
         const bySession = resolveOwnerBySessionEnv(root);
         if (bySession) {
             return { owner: bySession, source: "session_env" };
         }
     }
+    if (!existsSync(resolve(root, ".harnery", "pid-map")))
+        return { owner: null, source: "none" };
+    const byPidmap = resolveOwnerByPidmap(root);
+    if (byPidmap.owner)
+        return byPidmap;
+    // Last resort: if exactly one agent is live in this coord root, it's
+    // unambiguously us — resolve to it. This is what lets the bare `agents
+    // status` / `set-task` the stop hook recommends work without a `--session-id`
+    // flag in the common single-agent case. With 0 or 2+ live agents it would be
+    // a guess, so we stay null and require the explicit flag.
+    const singleton = resolveSingleActiveOwner(root);
+    if (singleton) {
+        return { owner: singleton, source: "active_singleton" };
+    }
+    return { owner: null, source: "none" };
+}
+/**
+ * Walk our own ppid chain for a pid-map row in ONE given root.
+ *
+ * Root-parameterized (rather than resolving the root itself) so root resolution
+ * can use it as a discriminator without recursing back into itself.
+ */
+export function resolveOwnerByPidmap(root) {
     const pidmapDir = resolve(root, ".harnery", "pid-map");
     if (!existsSync(pidmapDir))
         return { owner: null, source: "none" };
@@ -172,7 +407,7 @@ export function resolveOwnerWithSource() {
         if (pid === null)
             break;
         const row = readPidmapRow(pidmapDir, pid);
-        if (row) {
+        if (row && !pidWasRecycled(pid, row)) {
             const rowOwner = parsePidmapRowOwner(row);
             const rowPlat = parsePidmapRowPlatform(row);
             if (rowPlat === prefer) {
@@ -186,31 +421,11 @@ export function resolveOwnerWithSource() {
     if (fallbackOwner) {
         return { owner: fallbackOwner, source: "pidmap_fallback" };
     }
-    // The ppid walk found nothing (e.g. a Bash-tool subshell whose process tree
-    // doesn't climb back to the harness anchor). Before guessing, try the
-    // harness-provided session id from the environment: every supported harness
-    // exports its session id into the tool subprocess env, and each heartbeat
-    // records the `session_id` it was minted under. Matching the two resolves us
-    // unambiguously even with multiple live agents, which is the case the
-    // singleton fallback below cannot handle.
-    const bySession = resolveOwnerBySessionEnv(root);
-    if (bySession) {
-        return { owner: bySession, source: "session_env" };
-    }
-    // Last resort: if exactly one agent is live in this coord root, it's
-    // unambiguously us — resolve to it. This is what lets the bare `agents
-    // status` / `set-task` the stop hook recommends work without a `--session-id`
-    // flag in the common single-agent case. With 0 or 2+ live agents it would be
-    // a guess, so we stay null and require the explicit flag.
-    const singleton = resolveSingleActiveOwner(root);
-    if (singleton) {
-        return { owner: singleton, source: "active_singleton" };
-    }
     return { owner: null, source: "none" };
 }
 /**
- * Harness-exported session-id environment variables, in precedence order. Each
- * supported harness propagates its session id into the env of the subprocess it
+ * Adapter-exported session-id environment variables, in precedence order. Each
+ * supported adapter propagates its session id into the env of the subprocess it
  * spawns for a tool call (Claude Code's Bash tool, Cursor's terminal, Codex's
  * shell). A coord CLI invoked as such a tool can therefore recover its own
  * identity from the env even when the ppid walk misses.
@@ -225,7 +440,7 @@ const SESSION_ID_ENV_VARS = [
     "CURSOR_CONVERSATION_ID",
     "CODEX_SESSION_ID",
 ];
-/** Read normalized candidates from the first non-empty harness session-id env var. */
+/** Read normalized candidates from the first non-empty adapter session-id env var. */
 function sessionIdsFromEnv() {
     for (const key of SESSION_ID_ENV_VARS) {
         const v = process.env[key]?.trim();
@@ -238,18 +453,31 @@ function sessionIdsFromEnv() {
     }
     return [];
 }
-/** Read the first non-empty harness session-id env var, or null. */
+/** Read the first non-empty adapter session-id env var, or null. */
 function sessionIdFromEnv() {
     return sessionIdsFromEnv()[0] ?? null;
 }
+/**
+ * Should the adapter-exported session id be consulted before the ppid walk?
+ *
+ * Yes, whenever one is exported. The env var is the adapter stating its own
+ * identity; the walk is a guess over a namespace the OS recycles. On a box with
+ * `pid_max` of 99999 and ~100 pids allocated per second the whole pid space
+ * turns over about every quarter hour, so a row written before that can name a
+ * pid some unrelated process now holds. Pruning cannot save the walk here:
+ * it removes rows whose pid is dead, and a recycled pid is alive. Letting a
+ * guess outrank a statement of fact is what made `agents whoami` report another
+ * agent's name and file list.
+ *
+ * This only reorders the two. Session-env resolution still requires a live
+ * heartbeat carrying that session id, so when it does not match, the walk runs
+ * exactly as before.
+ */
 function shouldPreferSessionEnv() {
-    if (!sessionIdFromEnv())
-        return false;
-    const platform = process.env.HARNERY_AGENT_COORD_PLATFORM?.trim();
-    return process.env.CURSOR_AGENT === "1" || platform === "cursor";
+    return sessionIdFromEnv() !== null;
 }
 /**
- * Resolve the owner by matching the harness session-id env var against the
+ * Resolve the owner by matching the adapter session-id env var against the
  * `session_id` of a live heartbeat in this coord root. Returns the matching
  * `instance_id`, or null if there's no session-id env var or no live heartbeat
  * carries it. "Live" reuses the same 10-minute freshness window the singleton

package/dist/core/agents/events/consume.d.ts

@@ -33,7 +33,7 @@ export interface CanonicalEvent {
     parent_session_id?: string;
     turn_id?: string;
     parent_turn_id?: string;
-    harness: string;
+    adapter: string;
     source: string;
     data: Record<string, unknown>;
 }

package/dist/core/agents/events/emit.d.ts

@@ -5,12 +5,12 @@
  * event/schema types).
  *
  * Phase 4: agent-coord uses this from CLI handlers (state.task_set,
- * state.status_checked, state.scratch_append, council.*, decision.*,
+ * state.status_checked, state.journal_append, council.*, decision.*,
  * presence.*).
  */
 declare const SCHEMA_VERSION: 1;
-export type Harness = "claude-code" | "cursor" | "codex";
-export type Source = "agent-hooks" | "agent-coord" | "user" | "system";
+export type { Adapter, Source } from "../../hooks/events/schema.js";
+import type { Adapter, Source } from "../../hooks/events/schema.js";
 export interface Envelope {
     schema_version: typeof SCHEMA_VERSION;
     event_id: string;
@@ -21,7 +21,7 @@ export interface Envelope {
     parent_session_id?: string;
     turn_id?: string;
     parent_turn_id?: string;
-    harness: Harness;
+    adapter: Adapter;
     source: Source;
     data: Record<string, unknown>;
 }
@@ -29,7 +29,7 @@ export interface EmitInput {
     event_type: string;
     instance_id: string;
     session_id: string;
-    harness: Harness;
+    adapter: Adapter;
     source?: Source;
     parent_session_id?: string;
     turn_id?: string;
@@ -39,5 +39,4 @@ export interface EmitInput {
 }
 export declare function buildEnvelope(input: EmitInput): Envelope;
 export declare function emit(coordRoot: string, input: EmitInput): Envelope;
-export {};
 //# sourceMappingURL=emit.d.ts.map

package/dist/core/agents/events/emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/events/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,QAAA,MAAM,cAAc,EAAG,CAAU,CAAC;AAKlC,MAAM,MAAM,OAAO,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,MAAM,GAAG,aAAa,GAAG,aAAa,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAexD;AAED,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,CA4BlE"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/events/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,QAAA,MAAM,cAAc,EAAG,CAAU,CAAC;AAKlC,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAexD;AAED,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,CA4BlE"}

package/dist/core/agents/events/emit.js

@@ -5,7 +5,7 @@
  * event/schema types).
  *
  * Phase 4: agent-coord uses this from CLI handlers (state.task_set,
- * state.status_checked, state.scratch_append, council.*, decision.*,
+ * state.status_checked, state.journal_append, council.*, decision.*,
  * presence.*).
  */
 import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
@@ -27,7 +27,7 @@ export function buildEnvelope(input) {
         parent_session_id: input.parent_session_id,
         turn_id: input.turn_id,
         parent_turn_id: input.parent_turn_id,
-        harness: input.harness,
+        adapter: input.adapter,
         source: input.source ?? "agent-coord",
         data: input.data,
     };

package/dist/core/agents/paths.d.ts

@@ -1,6 +1,9 @@
 /**
- * Walk up from `start` looking for a directory containing `.harnery/`, so
- * adapter + legacy code agree on the same monorepo root.
+ * Resolve the coordination root.
+ *
+ * Delegates to `resolveCoordRoot()`. This was a third, independent copy of the
+ * walk-up — the kind of duplication that let the hooks and the CLI drift onto
+ * different roots in the first place; keep resolution in one place.
  */
 export declare function findCoordRoot(start?: string): string | null;
 //# sourceMappingURL=paths.d.ts.map

package/dist/core/agents/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/core/agents/paths.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAQ1E"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/core/agents/paths.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAE1E"}

package/dist/core/agents/paths.js

@@ -1,17 +1,11 @@
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { resolveCoordRoot } from "./coord-client.js";
 /**
- * Walk up from `start` looking for a directory containing `.harnery/`, so
- * adapter + legacy code agree on the same monorepo root.
+ * Resolve the coordination root.
+ *
+ * Delegates to `resolveCoordRoot()`. This was a third, independent copy of the
+ * walk-up — the kind of duplication that let the hooks and the CLI drift onto
+ * different roots in the first place; keep resolution in one place.
  */
 export function findCoordRoot(start = process.cwd()) {
-    let dir = resolve(start);
-    while (true) {
-        if (existsSync(join(dir, ".harnery")))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
+    return resolveCoordRoot(start);
 }

package/dist/core/agents/render/prompt-context.d.ts

@@ -1,19 +1,25 @@
 /**
  * UserPromptSubmit UX renderer. Combines the peer-refresh dedup, the
- * council-pending hash-dedup, and the Cursor set-task staleness nudge.
+ * council-pending hash-dedup, the cross-adapter first-session naming nudge,
+ * the Cursor/Codex set-task staleness nudge, and the Codex status-footer
+ * reminder.
  * agent-hook's user_prompt.submit post-emit handler calls this
- * and forwards the result as the harness-shaped additionalContext payload.
+ * and forwards the result as the adapter-shaped additionalContext payload.
  *
- * Three hash-dedup'd subsections combined into one additionalContext payload:
+ * Four subsections combined into one additionalContext payload:
  *   1. Peer table: semantically-relevant peer fields hashed; only re-emits
  *      when peers change (name + instance_id + session_id + kind + started_at
  *      + sorted(files_touched) + platform, sorted by instance_id).
  *   2. Council pending: pending open-council IDs hashed; re-emits when the
  *      ID set changes.
- *   3. Task staleness nudge (cursor only, since CC enforces via the Stop hook
- *      transcript scan). Fires when `task` is null or `task_updated_at` is
- *      older than HARNERY_TASK_STALE_SECONDS (default 1800 = 30 min). Hash-deduped
- *      against the previous nudge state.
+ *   3. Focus nudge. Before the first set-task in a human-facing session, tells
+ *      every adapter to reproduce set-task's suggested session name in a fenced
+ *      code block. Cursor/Codex additionally get the existing unset/stale-task
+ *      reminder because their Stop hooks do not enforce task declarations as
+ *      reliably as Claude Code's.
+ *   4. Codex status footer: a non-deduplicated reminder to put the live status
+ *      box after the substantive answer. Stop stays observe-only, so missing the
+ *      footer can never trigger a replacement response.
  *
  * Hash files live at:
  *   .harnery/.last-peer-hash.<instance_id>
@@ -27,9 +33,15 @@ export interface PromptContextOpts {
     instanceId: string;
     sessionId: string;
     agentName?: string;
-    /** When true, run the task-staleness nudge check (cursor only; CC has the
-     * Stop-hook transcript-scan enforcement). */
+    /** When true, remind a human-facing session to print the session name before
+     * its first set-task. UserPromptSubmit enables this for every adapter. */
+    sessionNameNudge?: boolean;
+    /** When true, run the unset/stale-task check after the first set-task.
+     * Cursor/Codex use this; Claude Code has Stop-hook transcript enforcement. */
     taskNudge?: boolean;
+    /** When true, append the non-deduplicated Codex status-footer reminder.
+     * The caller enables this only for human-facing Codex sessions. */
+    statusFooterNudge?: boolean;
 }
 /**
  * Build the combined UserPromptSubmit additionalContext string. Returns "" when

package/dist/core/agents/render/prompt-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiCH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;iDAC6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAqBnE"}
+{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAoCH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;8EAC0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;kFAC8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;uEACmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CA0CnE"}