@nledford/omp-coord 0.3.1 → 0.3.2

package/.omp-plugin/marketplace.json

@@ -7,7 +7,7 @@
       "name": "omp-coord",
       "source": "./",
       "description": "Shared subagent caps, build and test queues, claims, pause, a decision log and messages across omp sessions working in one project on one machine.",
-      "version": "0.3.1",
+      "version": "0.3.2",
       "author": { "name": "Nathaniel Ledford" },
       "homepage": "https://github.com/nledford/omp-coord",
       "repository": "https://github.com/nledford/omp-coord",

package/CHANGELOG.md

@@ -6,6 +6,20 @@ Add each user-visible change under Unreleased as it lands, in one of: Added, Cha
 
 ## [Unreleased]
 
+## [0.3.2] - 2026-10-28
+
+### Changed
+
+- **Breaking:** the extension no longer starts agents' bash commands with `export OMP_COORD_AGENT=<agent id>;`, and no longer sets `OMP_COORD_AGENT` at all. The rewritten command showed up in the conversation, and agents copied the prefix into later calls. Instead `omp-coord run` finds the agent from `PI_SESSION_ID`, the id omp gives each bash call for its agent's conversation, which the extension records on the board (the main session as `Main`, each subagent when its run starts, dropped when it ends). A script that read `OMP_COORD_AGENT` inside an agent's command must read `PI_SESSION_ID` or ask the board instead; `OMP_COORD_AGENT=<name> omp-coord run …` still names the agent for a job started where omp gives no `PI_SESSION_ID`, or one the board doesn't know. Only commands a `queue` rule matches are rewritten now, as before 0.2.3; omp's `bash.patterns` rules and other extensions see every other command as the agent wrote it.
+
+### Deprecated
+
+- `tagAgentCommands` does nothing and is still accepted, so existing `.omp-coord.json` files keep loading; remove it. Queued jobs record their agent whether it was on or not.
+
+### Fixed
+
+- A job queued by an agent now records the agent whether or not `tagAgentCommands` was on. A board made by an older omp-coord gains the two new columns when this version opens it; while a session of the scope (or an older `omp-coord run`) still uses the old version, its saves drop the recorded ids: the main session's comes back within 2 s, but a subagent's only at its next run, so while any older omp-coord is in use a subagent's jobs may show no agent (display only). omp gives bash calls `PI_SESSION_ID` from 18.12.4 on (the plugin still runs on 18.12.0 to 18.12.3, where jobs record no agent unless a script sets `OMP_COORD_AGENT`).
+
 ## [0.3.1] - 2026-10-27
 
 ### Fixed
@@ -82,7 +96,8 @@ Add each user-visible change under Unreleased as it lands, in one of: Added, Cha
 - An SQLite event log per scope, with retention.
 - Packaging as an omp plugin, with a marketplace catalog; queued commands run on omp's own Bun.
 
-[Unreleased]: https://github.com/nledford/omp-coord/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/nledford/omp-coord/compare/v0.3.2...HEAD
+[0.3.2]: https://github.com/nledford/omp-coord/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/nledford/omp-coord/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/nledford/omp-coord/compare/v0.2.3...v0.3.0
 [0.2.3]: https://github.com/nledford/omp-coord/compare/v0.2.2...v0.2.3

package/docs/commands.md

@@ -61,7 +61,7 @@ Every time is milliseconds since the epoch (`Date.now()`); a session is its lett
 | `line[]` | Sessions waiting for a slot: `pool`, `session`, `position` (from 1), `since`, `heldUntil` (`null` unless a freed slot is held for it). |
 | `agents[]` | One per agent holding a slot, by session letter then `since`: `id` (`null` for a spawn with no key and no first run yet), `type`, `parent` (`Main` or an agent id), `session`, `pool` (`null`: outside the caps), `state` (`starting` or `running`), `since`. |
 | `claims[]` | `kind` (`branch`, `worktree`, `pr`), `target`, `session`, `agent`, `note`, `since`. |
-| `queues[]` | `name`, `order`, `slots` (now), `configuredSlots`, `running[]` and `waiting[]` (in the order they will start), each job: `id`, `session`, `owner` (the owning session's id, or `null` outside omp), `lane`, `priority`, `key` (or `null`), `command`, `agent` (omp's id of the agent whose command queued it, `"Main"` for the main agent; `null` when `tagAgentCommands` is off, for a job started outside an agent's bash call, and while any session of the scope runs an omp-coord older than 0.2.3, whose saves drop it), `state`, `queuedAt`, `startedAt` (`null` while waiting), `position` (from 1 while waiting, `null` while running). |
+| `queues[]` | `name`, `order`, `slots` (now), `configuredSlots`, `running[]` and `waiting[]` (in the order they will start), each job: `id`, `session`, `owner` (the owning session's id, or `null` outside omp), `lane`, `priority`, `key` (or `null`), `command`, `agent` (omp's id of the agent whose command queued it, `"Main"` for the main agent; `null` for a job started outside an agent's bash call, on omp older than 18.12.4 (which sets no `PI_SESSION_ID`), and while any session of the scope runs an omp-coord older than this one, whose saves drop the ids the agent is found by), `state`, `queuedAt`, `startedAt` (`null` while waiting), `position` (from 1 while waiting, `null` while running). |
 | `notes[]` | The latest three decisions, oldest first: `id`, `at`, `session` (the letter when it was written, kept after that session ends; `null` outside omp), `author`, `text`. |
 
 ```json
@@ -102,5 +102,6 @@ Exit codes: `0` success, the command's own for `run`, `75` a job not run, `124`
 | `OMP_COORD_SESSION` | the extension | The session that owns jobs started from its agents' commands. |
 | `OMP_COORD_PORTS` | the extension | The session's port block, e.g. `18700-18799`, when `resources.ports` is set. |
 | `OMP_COORD_SCRATCH` | the extension | The session's scratch folder, when `resources.scratch` is set. |
-| `OMP_COORD_AGENT` | the extension, with `tagAgentCommands` | The agent whose command this is (`Main` for the main agent); `omp-coord run` records it on the job. |
+| `PI_SESSION_ID` | omp | The id of the conversation an agent's bash call belongs to. `omp-coord run` looks up which agent that is (the extension records it on the board: `Main` for the main session, the subagent's id for a subagent) and records it on the job. |
+| `OMP_COORD_AGENT` | you | The agent to record on a job started where omp gave no `PI_SESSION_ID` (a script), or one the board doesn't know. The extension no longer sets it. |
 | `OMP_COORD_JOB`, `OMP_COORD_QUEUE` | `omp-coord run` | The running job's id and queue, for nested runs. |

package/docs/configuration.md

@@ -22,7 +22,7 @@
 | `queues.<name>.onDuplicate` | `"refuse"` | `"refuse"` or `"supersede"` a waiting job with the same key. |
 | `queues.<name>.timeoutMinutes` | none | Stop a job's command after this long: SIGTERM to its process group, then SIGKILL to whatever of it is left 10 s later; it exits 124. `--timeout` overrides it per job. |
 | `queues.<name>.loadSlots` | `[]` | `[{ "above": 150, "slots": 1 }]`: fewer slots under load; `0` holds the queue. |
-| `tagAgentCommands` | `false` | Start each agent bash command with `export OMP_COORD_AGENT=<agent id>;`, so each queued job records the agent that queued it (queue lines read `session A/<agent>`). Leave it off when you use omp's `bash.patterns` allow or deny rules (a rewritten command no longer matches them) or another extension that rewrites bash commands (the last rewrite wins). |
+| `tagAgentCommands` | none | Deprecated and ignored: every queued job records the agent that queued it now (on omp 18.12.4 or later), without rewriting commands. Accepted so existing files keep loading; remove it. |
 | `resources.ports` | none | `{ "from", "to", "perSession", "perAgent" (10) }`: each session gets a block of `perSession` ports, each agent a block of `perAgent` from its session's. |
 | `resources.scratch` | none | Root of the scratch folders: `<scratch>/<letter>` per session, `<scratch>/<letter>/<agent id>` per agent. Relative to the config file. |
 | `history.retentionDays` | `30` | Events and decision-log notes older than this are deleted. |

package/docs/queues.md

@@ -49,6 +49,6 @@ A command that puts its work in the background (`cargo test &`) holds the slot o
 
 When an agent's bash command matches a `queue` rule under `commands`, the extension rewrites it to run `omp-coord run <queue> --owner <session> -- sh -c '<command>'` with omp's own binary as Bun (`BUN_BE_BUN=1`), so it needs no separate Bun install. The waiting happens inside the bash call, which counts against the bash tool's timeout: agents should run long jobs as background (`async`) bash calls. The rewritten command runs in `sh`, so shell variables the agent set earlier without exporting them are not visible to it.
 
-With `tagAgentCommands` on, the extension also starts every agent bash command with `export OMP_COORD_AGENT=<agent id>;`, and `omp-coord run` records that agent on the job: queue lines read `session A/WaveImport` instead of only `session A`. It is off by default because the rewritten command no longer matches omp's `bash.patterns` rules (they must match the whole command) and replaces any other extension's rewrite of the same call.
+`omp-coord run` records the agent whose command it is on each job, so queue lines read `session A/WaveImport` instead of only `session A`. omp (18.12.4 or later) gives every bash call the id of its agent's conversation (`PI_SESSION_ID`), and the extension records on the board which agent that is, so the command text is never touched: queue rules, omp's `bash.patterns` rules and other extensions' rewrites see exactly what the agent wrote. A script can name the agent itself with `OMP_COORD_AGENT`.
 
 A command matching a `refuse` rule is refused with the rule's reason.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nledford/omp-coord",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "files": [
     "src",
     "docs",

package/src/adapters/cli/cli.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
 /**
  * omp-coord command line: runs commands through the shared build and test queues, from `just` recipes, scripts,
- * terminals, or agents' bash calls (which the extension rewrites to go through here), and reports on the scope.
+ * terminals, or agents' bash calls (which the extension rewrites to go through here when a rule queues them), and
+ * reports on the scope.
  *
  *   omp-coord run <queue> [--lane L] [--priority N] [--key K] [--owner SESSION] [--timeout 90m] -- <command> [args…]
  *   omp-coord status [--agents | --json] | stats [days] | interrupted [hours] | notes [count] | note <text…>
@@ -24,6 +25,7 @@ import { EXIT_TIMED_OUT, runJob } from "../../app/job-runner.ts";
 import { type Config, ConfigError, findConfigFile, loadConfig } from "../../config.ts";
 import { statusView } from "../../domain/overview.ts";
 import { MAX_PRIORITY } from "../../domain/queues.ts";
+import { agentOfOmpSession } from "../../domain/sessions.ts";
 import { osLoad } from "../os/load.ts";
 import { groupRunning } from "../os/process-group.ts";
 import { BoardStore, stateDir } from "../sqlite/store.ts";
@@ -243,14 +245,16 @@ async function run(args: string[]): Promise<number> {
     mkdirSync(join(dir, "s"), { recursive: true, mode: 0o700 });
     const id = randomBytes(4).toString("hex");
     const address = join(dir, "s", `job-${id}.sock`);
+    // omp gives each bash call its agent's session id; the extension recorded which agent that is. A script outside
+    // omp (or one run before the extension bound the id) may name the agent itself.
+    const agent = agentOfOmpSession(store.read(), process.env.PI_SESSION_ID ?? "") || process.env.OMP_COORD_AGENT;
 
     return runJob(
       {
         id,
         queue,
         owner: values.owner || process.env.OMP_COORD_SESSION || null,
-        // set per command by the extension's bash hook
-        ...(process.env.OMP_COORD_AGENT ? { agent: process.env.OMP_COORD_AGENT } : {}),
+        ...(agent ? { agent } : {}),
         ...(values.lane === undefined ? {} : { lane: values.lane }),
         priority,
         ...(values.key === undefined ? {} : { key: values.key }),

package/src/adapters/omp/api.ts

@@ -19,6 +19,8 @@ export interface ExtensionContext {
   mode: "tui" | "rpc" | "json" | "print";
   hasUI: boolean;
   agent: AgentIdentity;
+  /** omp's id for this agent's own conversation: the `PI_SESSION_ID` its bash calls carry (read-only). */
+  sessionManager?: { getSessionId?(): string };
   ui: {
     notify(message: string, type?: "info" | "warning" | "error"): void;
     setStatus(key: string, text: string | undefined): void;
@@ -52,6 +54,8 @@ export type ToolCallResult = Block | { input: Record<string, unknown> };
 export interface Events {
   session_start: (event: unknown, ctx: ExtensionContext) => unknown;
   session_shutdown: (event: unknown, ctx: ExtensionContext) => unknown;
+  session_switch: (event: unknown, ctx: ExtensionContext) => unknown;
+  session_branch: (event: unknown, ctx: ExtensionContext) => unknown;
   agent_start: (event: unknown, ctx: ExtensionContext) => unknown;
   agent_end: (event: unknown, ctx: ExtensionContext) => unknown;
   before_subagent_spawn: (event: SpawnEvent, ctx: ExtensionContext) => Block | Promise<Block>;

package/src/adapters/omp/extension.ts

@@ -17,7 +17,7 @@ import { Coordinator } from "../../app/coordinator.ts";
 import type { Listener } from "../../app/ports.ts";
 import { type Config, ConfigError, findConfigFile, loadConfig } from "../../config.ts";
 import { spawnAllowance } from "../../domain/agents.ts";
-import { decideCommand, withAgent, withoutAgentExports } from "../../domain/commands.ts";
+import { decideCommand } from "../../domain/commands.ts";
 import type { Claim } from "../../domain/model.ts";
 import { osLoad } from "../os/load.ts";
 import { BoardStore, stateDir } from "../sqlite/store.ts";
@@ -55,6 +55,8 @@ interface Runtime {
   listener: Listener;
   sessionId: string;
   label: string;
+  /** omp's id for the main conversation, as agents' bash calls carry it (`PI_SESSION_ID`). */
+  ompSessionId: string | undefined;
   /** The main session's binding and context: messages for the session go through them. */
   pi: ExtensionAPI;
   ctx: ExtensionContext;
@@ -98,14 +100,24 @@ export default function ompCoord(pi: ExtensionAPI): void {
       shared.bindings.set(ctx.agent.id, pi);
       return;
     }
-    if (shared.runtime) {
-      shared.runtime.pi = pi;
-      shared.runtime.ctx = ctx;
+    const rt = shared.runtime;
+    if (rt) {
+      rt.pi = pi;
+      rt.ctx = ctx;
+      syncMainSession(rt, ctx);
       return;
     }
     await start(pi, ctx);
   });
 
+  // omp keeps one process across /new, /resume and /fork, giving the main conversation a new id without a new
+  // `session_start`: its bash calls carry that id from now on.
+  for (const event of ["session_switch", "session_branch"] as const)
+    pi.on(event, (_event, ctx) => {
+      const rt = shared.runtime;
+      if (rt && ctx.agent.kind === "main") syncMainSession(rt, ctx);
+    });
+
   pi.on("session_shutdown", (_event, ctx) => {
     if (ctx.agent.kind !== "main") {
       if (shared.bindings.get(ctx.agent.id) === pi) shared.bindings.delete(ctx.agent.id);
@@ -149,6 +161,7 @@ export default function ompCoord(pi: ExtensionAPI): void {
     const rt = shared.runtime;
     if (!rt || !isTrackedSubagent(ctx)) return;
     guarded(rt, "record an agent run", () => {
+      const ompSessionId = ompSessionIdOf(ctx);
       const parentId = ctx.agent.parentId ?? "Main";
       const count = rt.coordinator.agentStarted({
         sessionId: rt.sessionId,
@@ -157,6 +170,7 @@ export default function ompCoord(pi: ExtensionAPI): void {
         parentIsSubagent: parentId !== "Main",
         agentType: ctx.agent.name.toLowerCase(),
         evalWorker: rt.evalAgents.has(ctx.agent.id),
+        ...(ompSessionId === undefined ? {} : { ompSessionId }),
       });
       refreshQueue(rt);
       if (count && count.used > count.cap) {
@@ -183,6 +197,8 @@ export default function ompCoord(pi: ExtensionAPI): void {
     if (!rt || event.toolName !== "bash") return undefined;
     const command = event.input.command;
     if (typeof command !== "string") return undefined;
+    // the id must be on the board before the command can reach `omp-coord run`, whatever event announced a switch
+    if (ctx.agent.kind === "main") syncMainSession(rt, ctx);
 
     try {
       const cwd = typeof event.input.cwd === "string" ? resolve(ctx.cwd, event.input.cwd) : ctx.cwd;
@@ -205,20 +221,15 @@ export default function ompCoord(pi: ExtensionAPI): void {
       notify(rt, `omp-coord could not check claims: ${describe(error)}`, "error");
     }
 
-    // a copied `export OMP_COORD_AGENT=…;` would otherwise end up inside a queued job's own command
-    const own = rt.config.tagAgentCommands ? withoutAgentExports(command) : command;
-    const decision = decideCommand(rt.config.commands, own, {
+    const decision = decideCommand(rt.config.commands, command, {
       ...RUNNER,
       owner: rt.sessionId,
       config: rt.config.source,
     });
     if (decision.kind === "refuse") return { block: true, reason: `omp-coord: ${decision.reason}` };
-    const run = decision.kind === "queue" ? decision.command : own;
-    // Every agent of a session shares the omp process's environment, so the agent's id can reach `omp-coord run` (and
-    // the queue lines) only through the command itself; opt-in (`tagAgentCommands`), since the rewrite defeats omp's
-    // bash.patterns rules and other extensions' rewrites. Off, the hook changes only queued commands, as before.
-    if (rt.config.tagAgentCommands) return { input: { ...event.input, command: withAgent(ctx.agent.id, run) } };
-    if (decision.kind === "queue") return { input: { ...event.input, command: run } };
+    // Only a queued command is rewritten. Which agent runs it needs no rewrite: omp gives every bash call its agent's
+    // session id (`PI_SESSION_ID`), and the board maps that id to the agent (`session_start`, `agent_start`).
+    if (decision.kind === "queue") return { input: { ...event.input, command: decision.command } };
     return undefined;
   });
 
@@ -476,9 +487,10 @@ async function start(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
       ? "While this is the only session, spawns past the cap wait in omp's queue and start as slots free; with others, they are refused and this session holds a place in line."
       : `Spawns past the cap are refused: ${typeof handle === "string" ? handle : "omp gave the extension no settings scope"}.`;
   }
+  const ompSessionId = ompSessionIdOf(ctx);
   let joined: Pick<Runtime, "store" | "coordinator" | "listener" | "sessionId" | "label">;
   try {
-    joined = openSession(config, ctx.cwd);
+    joined = openSession(config, ctx.cwd, ompSessionId);
   } catch (error) {
     shared.inactive = `omp-coord is off: ${describe(error)}`;
     ctx.ui.notify(shared.inactive, "error");
@@ -488,6 +500,7 @@ async function start(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
   const rt: Runtime = {
     config,
     ...joined,
+    ompSessionId,
     pi,
     ctx,
     timer: undefined,
@@ -543,6 +556,7 @@ async function start(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
 function openSession(
   config: Config,
   cwd: string,
+  ompSessionId: string | undefined,
 ): Pick<Runtime, "store" | "coordinator" | "listener" | "sessionId" | "label"> {
   const dir = stateDir();
   mkdirSync(join(dir, "s"), { recursive: true, mode: 0o700 });
@@ -552,7 +566,7 @@ function openSession(
     const coordinator = new Coordinator(config, store, unixLiveness, Date, osLoad);
     const sessionId = randomBytes(6).toString("hex");
     listener = startBeacon(join(dir, "s", `${sessionId}.sock`));
-    const label = coordinator.join(identity(sessionId, cwd, listener));
+    const label = coordinator.join(identity(sessionId, cwd, listener, ompSessionId));
     return { store, coordinator, listener, sessionId, label };
   } catch (error) {
     listener?.stop();
@@ -561,8 +575,29 @@ function openSession(
   }
 }
 
-function identity(sessionId: string, cwd: string, listener: Listener) {
-  return { id: sessionId, pid: process.pid, cwd, address: listener.address };
+function identity(sessionId: string, cwd: string, listener: Listener, ompSessionId: string | undefined) {
+  return {
+    id: sessionId,
+    pid: process.pid,
+    cwd,
+    address: listener.address,
+    ...(ompSessionId === undefined ? {} : { ompSessionId }),
+  };
+}
+
+/** Records the main conversation's omp session id on the board when it is not the one already there. */
+function syncMainSession(rt: Runtime, ctx: ExtensionContext): void {
+  const id = ompSessionIdOf(ctx);
+  if (id === undefined || id === rt.ompSessionId) return;
+  guarded(rt, "record the session id", () => {
+    rt.coordinator.bindOmpSession(rt.sessionId, id);
+    rt.ompSessionId = id;
+  });
+}
+
+/** omp's id for the conversation this context belongs to: what its bash calls carry as `PI_SESSION_ID`. */
+function ompSessionIdOf(ctx: ExtensionContext): string | undefined {
+  return ctx.sessionManager?.getSessionId?.() || undefined;
 }
 
 /** `<scratch>/<session letter>[/<agent id>]`, created on first use; undefined when the scope has no scratch root. */
@@ -600,7 +635,9 @@ async function tick(rt: Runtime): Promise<void> {
   if (shared.runtime !== rt) return;
   rt.ticks++;
   const now = Date.now();
-  const { label, inbox, holds, board } = rt.coordinator.tick(identity(rt.sessionId, rt.ctx.cwd, rt.listener));
+  const { label, inbox, holds, board } = rt.coordinator.tick(
+    identity(rt.sessionId, rt.ctx.cwd, rt.listener, rt.ompSessionId),
+  );
   rt.label = label;
   rt.queue?.apply(spawnAllowance(board, rt.config.agents, rt.sessionId, now));
 

package/src/adapters/sqlite/store.ts

@@ -37,7 +37,8 @@ CREATE TABLE sessions (
   started_at  INTEGER NOT NULL,
   config_hash TEXT NOT NULL,
   ports_from  INTEGER,
-  ports_to    INTEGER
+  ports_to    INTEGER,
+  omp_session TEXT
 ) STRICT;
 CREATE TABLE slots (
   id         INTEGER PRIMARY KEY,
@@ -48,7 +49,8 @@ CREATE TABLE slots (
   pool       TEXT,
   state      TEXT NOT NULL CHECK (state IN ('starting', 'running')),
   since      INTEGER NOT NULL,
-  unqueued   TEXT CHECK (unqueued IN ('revived', 'eval'))
+  unqueued   TEXT CHECK (unqueued IN ('revived', 'eval')),
+  omp_session TEXT
 ) STRICT;
 CREATE TABLE tickets (
   session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
@@ -258,6 +260,8 @@ export class BoardStore implements BoardRepository {
     if (!has("jobs", "agent")) this.#db.exec("ALTER TABLE jobs ADD COLUMN agent TEXT");
     if (!has("slots", "unqueued"))
       this.#db.exec("ALTER TABLE slots ADD COLUMN unqueued TEXT CHECK (unqueued IN ('revived', 'eval'))");
+    if (!has("sessions", "omp_session")) this.#db.exec("ALTER TABLE sessions ADD COLUMN omp_session TEXT");
+    if (!has("slots", "omp_session")) this.#db.exec("ALTER TABLE slots ADD COLUMN omp_session TEXT");
   }
 
   #maybePruneEvents(now: number): void {
@@ -283,6 +287,7 @@ export class BoardStore implements BoardRepository {
             config_hash: string;
             ports_from: number | null;
             ports_to: number | null;
+            omp_session: string | null;
           },
           []
         >("SELECT * FROM sessions")
@@ -296,6 +301,7 @@ export class BoardStore implements BoardRepository {
           startedAt: r.started_at,
           configHash: r.config_hash,
           ports: r.ports_from === null || r.ports_to === null ? undefined : { from: r.ports_from, to: r.ports_to },
+          ...(r.omp_session ? { ompSessionId: r.omp_session } : {}),
         })),
       slots: db
         .query<
@@ -308,6 +314,7 @@ export class BoardStore implements BoardRepository {
             state: "starting" | "running";
             since: number;
             unqueued: "revived" | "eval" | null;
+            omp_session: string | null;
           },
           []
         >("SELECT * FROM slots ORDER BY id")
@@ -321,6 +328,7 @@ export class BoardStore implements BoardRepository {
           state: r.state,
           since: r.since,
           ...(r.unqueued ? { unqueued: r.unqueued } : {}),
+          ...(r.omp_session ? { ompSessionId: r.omp_session } : {}),
         })),
       waitlist: db
         .query<{ session_id: string; pool: string; since: number; hold_until: number | null; notified: number }, []>(
@@ -452,7 +460,7 @@ export class BoardStore implements BoardRepository {
     }
 
     const session = db.query(
-      "INSERT INTO sessions (id, label, pid, cwd, socket, started_at, config_hash, ports_from, ports_to) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      "INSERT INTO sessions (id, label, pid, cwd, socket, started_at, config_hash, ports_from, ports_to, omp_session) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
     );
     for (const s of board.sessions)
       session.run(
@@ -465,12 +473,23 @@ export class BoardStore implements BoardRepository {
         s.configHash,
         s.ports?.from ?? null,
         s.ports?.to ?? null,
+        s.ompSessionId ?? null,
       );
     const slot = db.query(
-      "INSERT INTO slots (session_id, agent_id, parent_id, agent_type, pool, state, since, unqueued) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+      "INSERT INTO slots (session_id, agent_id, parent_id, agent_type, pool, state, since, unqueued, omp_session) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
     );
     for (const s of board.slots)
-      slot.run(s.sessionId, s.agentId ?? null, s.parentId, s.agentType, s.pool, s.state, s.since, s.unqueued ?? null);
+      slot.run(
+        s.sessionId,
+        s.agentId ?? null,
+        s.parentId,
+        s.agentType,
+        s.pool,
+        s.state,
+        s.since,
+        s.unqueued ?? null,
+        s.ompSessionId ?? null,
+      );
     const ticket = db.query(
       "INSERT INTO tickets (session_id, pool, since, hold_until, notified) VALUES (?, ?, ?, ?, ?)",
     );

package/src/app/coordinator.ts

@@ -31,7 +31,7 @@ import type { Board, Claim, Note } from "../domain/model.ts";
 import { addNote, type NoteResult } from "../domain/notes.ts";
 import { type AgentPortsResult, agentPorts } from "../domain/ports.ts";
 import { dropJobs, type EnqueueResult, schedule, setJobPriority } from "../domain/queues.ts";
-import { registerSession, removeSession } from "../domain/sessions.ts";
+import { bindOmpSession, registerSession, removeSession } from "../domain/sessions.ts";
 import type { BoardRepository, Clock, Liveness, LoadProbe } from "./ports.ts";
 
 export interface SessionIdentity {
@@ -40,6 +40,8 @@ export interface SessionIdentity {
   cwd: string;
   /** Liveness address this session answers on. */
   address: string;
+  /** omp's id for the main conversation, kept on the board so the runner can tell whose bash call it is. */
+  ompSessionId?: string;
 }
 
 export interface TickResult {
@@ -86,7 +88,15 @@ export class Coordinator {
   #register(b: Board, me: SessionIdentity, now: number): string {
     return registerSession(
       b,
-      { id: me.id, pid: me.pid, cwd: me.cwd, socket: me.address, configHash: this.config.hash, now },
+      {
+        id: me.id,
+        pid: me.pid,
+        cwd: me.cwd,
+        socket: me.address,
+        configHash: this.config.hash,
+        ...(me.ompSessionId === undefined ? {} : { ompSessionId: me.ompSessionId }),
+        now,
+      },
       this.config.resources.ports,
     );
   }
@@ -152,6 +162,11 @@ export class Coordinator {
     return this.repo.transact(b => requestSpawn(b, this.config.agents, { ...req, now: this.clock.now() }));
   }
 
+  /** omp moved this session onto another main conversation (new, resumed or forked): its bash calls carry the new id. */
+  bindOmpSession(sessionId: string, ompSessionId: string): void {
+    this.repo.transact(b => bindOmpSession(b, sessionId, ompSessionId));
+  }
+
   agentStarted(a: {
     sessionId: string;
     agentId: string;
@@ -159,6 +174,7 @@ export class Coordinator {
     parentIsSubagent: boolean;
     agentType: string;
     evalWorker?: boolean;
+    ompSessionId?: string;
   }) {
     return this.repo.transact(b => agentStarted(b, this.config.agents, { ...a, now: this.clock.now() }));
   }

package/src/config.ts

@@ -26,12 +26,6 @@ export interface Config {
   commands: CommandRule[];
   /** Build and test queues, machine-wide within the scope. */
   queues: Queues;
-  /**
-   * Start each agent bash command with `export OMP_COORD_AGENT=<agent id>;` so queued jobs record whose they are.
-   * Off by default: the rewritten command no longer matches omp's `bash.patterns` rules and replaces other
-   * extensions' rewrites of the same call.
-   */
-  tagAgentCommands: boolean;
   /** Port ranges and scratch folders handed to sessions and their agents. */
   resources: { ports: PortPolicy | undefined; scratch: string | undefined };
   /** Retention of the event log and the decision log. */
@@ -192,7 +186,6 @@ export function parseConfig(raw: unknown, source: string, hash = "none"): Config
     },
     commands,
     queues,
-    tagAgentCommands: flag(root.tagAgentCommands ?? false, "tagAgentCommands", fail),
     resources: { ports, scratch },
     history: {
       maxAgeMs: count(history.retentionDays ?? 30, "history.retentionDays", fail) * 24 * 3_600_000,

package/src/domain/agents.ts

@@ -154,6 +154,8 @@ export function agentStarted(
      * spawn queue, so its new slot is marked "eval", not "revived".
      */
     evalWorker?: boolean;
+    /** omp's id for the agent's own session, so its bash calls can be traced to it. */
+    ompSessionId?: string;
     now: number;
   },
 ): { pool: string; used: number; cap: number } | null {
@@ -184,6 +186,7 @@ export function agentStarted(
   if (slot) {
     slot.agentId = a.agentId;
     slot.state = "running";
+    if (a.ompSessionId !== undefined) slot.ompSessionId = a.ompSessionId;
   } else {
     slot = {
       sessionId: a.sessionId,
@@ -194,6 +197,7 @@ export function agentStarted(
       state: "running",
       since: a.now,
       unqueued: a.evalWorker ? "eval" : "revived",
+      ...(a.ompSessionId === undefined ? {} : { ompSessionId: a.ompSessionId }),
     };
     board.slots.push(slot);
   }

package/src/domain/commands.ts

@@ -54,27 +54,3 @@ export function decideCommand(rules: CommandRule[], command: string, runner: Run
 function quote(word: string): string {
   return `'${word.replaceAll("'", `'\\''`)}'`;
 }
-
-/**
- * The command with the id of the agent running it exported first, so a queued job records whose it is
- * (`omp-coord run` reads `OMP_COORD_AGENT`). An export, not a `VAR=… cmd` prefix, so it reaches every command of a
- * compound line; each agent's next command sets it again.
- */
-export function withAgent(agentId: string, command: string): string {
-  return `export OMP_COORD_AGENT=${quote(agentId)}; ${withoutAgentExports(command)}`;
-}
-
-/** The command without the `export OMP_COORD_AGENT=…;` prefixes it starts with, if any. */
-export function withoutAgentExports(command: string): string {
-  return command.replace(LEADING_AGENT_EXPORTS, "");
-}
-
-/**
- * The `export OMP_COORD_AGENT=…;` prefixes already at the start of a command. The rewritten command is what the
- * conversation shows, so an agent that copies its earlier calls sends them back; without stripping, each call would
- * add one more. A value is single-quoted as `quote` writes it (`'\''` for a quote inside) or a bare word of
- * shell-safe characters only, so a hand-typed value holding `\;`, `|`, `>` or a substitution is never mistaken for
- * a prefix and nothing of the command itself is dropped. Only spaces and tabs may surround the assignment: in bash a
- * newline ends a command, so an `export` alone on its line is a command of its own, not part of a prefix.
- */
-const LEADING_AGENT_EXPORTS = /^(?:\s*export[ \t]+OMP_COORD_AGENT=(?:'(?:[^']|'\\'')*'|[\w.@%+,:/=-]+)[ \t]*;)+\s*/;

package/src/domain/model.ts

@@ -41,6 +41,11 @@ export interface SessionRecord {
   configHash: string;
   /** Port range handed to this session, when the scope hands out ports. */
   ports: PortRange | undefined;
+  /**
+   * omp's id for the main session's conversation (`PI_SESSION_ID` in its agents' bash calls). omp can change it
+   * within one process (`/new`, `/resume`, `/fork`), so the extension binds it again whenever it sees another.
+   */
+  ompSessionId?: string;
 }
 
 export interface PortRange {
@@ -102,6 +107,8 @@ export interface AgentSlot {
    * those outside the queue, as spawns of `invocationKind` "eval").
    */
   unqueued?: "revived" | "eval";
+  /** omp's id for the agent's own session (`PI_SESSION_ID` in its bash calls), once its run started. */
+  ompSessionId?: string;
 }
 
 /** A session's place in line for a pool, after a refused spawn. */

package/src/domain/sessions.ts

@@ -11,11 +11,23 @@ const LABELS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  */
 export function registerSession(
   board: Board,
-  s: { id: string; pid: number; cwd: string; socket: string; configHash: string; now: number },
+  s: {
+    id: string;
+    pid: number;
+    cwd: string;
+    socket: string;
+    configHash: string;
+    ompSessionId?: string;
+    now: number;
+  },
   ports?: Pick<PortPolicy, "from" | "to" | "perSession">,
 ): string {
   const existing = board.sessions.find(x => x.id === s.id);
-  if (existing) return existing.label;
+  if (existing) {
+    // an older omp-coord's save writes every session without it
+    if (s.ompSessionId !== undefined) existing.ompSessionId = s.ompSessionId;
+    return existing.label;
+  }
   const taken = new Set(board.sessions.map(x => x.label));
   const label = [...LABELS].find(l => !taken.has(l));
   if (!label) throw new Error(`${LABELS.length} sessions are already registered`);
@@ -36,6 +48,7 @@ export function registerSession(
     startedAt: s.now,
     configHash: s.configHash,
     ports: block,
+    ...(s.ompSessionId === undefined ? {} : { ompSessionId: s.ompSessionId }),
   });
   emit(board, s.now, "session_joined", s.id, {
     pid: s.pid,
@@ -45,6 +58,22 @@ export function registerSession(
   return label;
 }
 
+/** Records omp's id for the main session's conversation, replacing the one it had. */
+export function bindOmpSession(board: Board, sessionId: string, ompSessionId: string): void {
+  const session = board.sessions.find(s => s.id === sessionId);
+  if (session) session.ompSessionId = ompSessionId;
+}
+
+/**
+ * The agent whose bash call carries this omp session id (`PI_SESSION_ID`): `Main` for a session's main conversation,
+ * a running subagent's id for its own. Undefined for an id the board doesn't know, such as an agent whose run ended.
+ */
+export function agentOfOmpSession(board: Board, ompSessionId: string): string | undefined {
+  const slot = board.slots.find(s => s.ompSessionId === ompSessionId && s.agentId !== undefined);
+  if (slot) return slot.agentId;
+  return board.sessions.some(s => s.ompSessionId === ompSessionId) ? "Main" : undefined;
+}
+
 /**
  * Removes a session that ended or died: its slots free, it leaves the line, messages to it are dropped, and its
  * claims, ports and fair-share history go.