@nledford/omp-coord 0.3.1 → 0.4.0

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.4.0",
       "author": { "name": "Nathaniel Ledford" },
       "homepage": "https://github.com/nledford/omp-coord",
       "repository": "https://github.com/nledford/omp-coord",

package/CHANGELOG.md

@@ -6,6 +6,30 @@ Add each user-visible change under Unreleased as it lands, in one of: Added, Cha
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-28
+
+### Added
+
+- `examples/omp-coord.json` has two `refuse` rules that protect git's rerere cache, which every worktree of a repository shares: deleting `rr-cache` (`rm`, `find -delete`, `git clean` and the like) and `git rerere clear`, `forget` and `gc` are refused, with a reason that points to `git -c rerere.enabled=false …` for throwaway builds. Reading the cache, `git rerere status`, `diff`, `remaining` and a command that names a throwaway repository under `/tmp` (an `rr-cache` path there, or `git -C`/`GIT_DIR=` for `git rerere`) are allowed; the limits are in the docs. Copy the rules into your `.omp-coord.json` above any `queue` rules to use them; no code or default changed. See [queues](docs/queues.md#example-protecting-gits-rerere-cache).
+
+### Changed
+
+- **Breaking:** while any `refuse` rule is configured, a bash command longer than 32,768 characters is refused with a message, instead of being judged by the patterns: a pattern that stalls on a very long line froze the session's `tool_call` check (omp gives it 30 s and fails closed), and one that runs out of backtracking budget answered "no match" and let the command through. A command that used to run and is now refused: write the long script to a file with the write tool and run it from a short command. Configs without a `refuse` rule (queue rules only) are not affected. See [queues](docs/queues.md#agents-commands).
+
+## [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 +106,9 @@ 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.4.0...HEAD
+[0.4.0]: https://github.com/nledford/omp-coord/compare/v0.3.2...v0.4.0
+[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

@@ -14,7 +14,7 @@
 | `agents.startTimeoutSeconds` | `120` | How long an approved spawn may take to start before its slot frees. |
 | `agents.queueSpawns` | `true` | While the session is the only one in the scope, keep omp's per-session spawn queue (`task.maxConcurrency`) at what the caps allow it, so spawns past the cap wait and start by themselves instead of being refused ([agent slots](agent-slots.md#spawns-wait-their-turn)); with other sessions, or paused, spawns over the cap are refused as before. A `task.maxConcurrency` you set yourself stays the ceiling. `false` keeps the refusals always. |
 | `messages.perMinute` | `10` | Messages one session may send per minute. It slows two sessions that keep answering each other; it does not stop them. Each delivered message starts a turn in an idle session. |
-| `commands` | `[]` | Rules for agents' bash commands, first match wins: `{ "pattern": "<regex>", "action": "refuse", "reason": "…" }`, or `{ "pattern", "action": "queue", "queue": "<name>", "lane"? }`. The user's own `!` commands are not affected. |
+| `commands` | `[]` | Rules for agents' bash commands, first match wins: `{ "pattern": "<regex>", "action": "refuse", "reason": "…" }`, or `{ "pattern", "action": "queue", "queue": "<name>", "lane"? }`. The user's own `!` commands are not affected. Nothing is refused unless a rule is listed; `examples/omp-coord.json` has ready-made `refuse` rules, including two that protect git's rerere cache ([queues](queues.md#example-protecting-gits-rerere-cache)). |
 | `queues.<name>.slots` | required | How many jobs of this queue run at once, across all processes in the scope. Queue names use letters, digits, `.`, `_`, `-`. |
 | `queues.<name>.order` | `"fifo"` | `"fifo"`, `"fair-share"` or `"priority"` (see [queues](queues.md#order)). |
 | `queues.<name>.lanes` | `["normal"]` | Lane names, first served first; the last is the default. |
@@ -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,25 @@ 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.
+A command matching a `refuse` rule is refused with the rule's reason. While any `refuse` rule is configured, a command longer than 32,768 characters is refused too, with a message that says so (create the file with the write tool and run it from a short command): the check runs inside omp's `tool_call` handler, which omp gives 30 seconds and fails closed, and a regex that runs out of its backtracking budget answers "no match", so a very long line could otherwise stall the session or slip past a rule. Configs without a `refuse` rule are not affected.
+
+### Example: protecting git's rerere cache
+
+`examples/omp-coord.json` carries two `refuse` rules (copy them into your `.omp-coord.json`; nothing is refused unless a rule is in the file) for a cache that every worktree of a repository shares: `<git-common-dir>/rr-cache`, where `git rerere` keeps recorded conflict resolutions. A command that deletes entries from it takes away resolutions other sessions' agents recorded, and their next rebase hits the same conflicts again. Rules are first-match-wins, so list them before any `queue` rule: a command that matches both (`rm -rf .git/rr-cache && bun test`) is queued, not refused, when the `queue` rule comes first.
+
+- **Refused**: `rm`, `rmdir`, `unlink`, `trash`, `shred`, `find … -delete` and `git clean` (also `git --work-tree=<path> clean`) in a command line (up to the next `;`, `&` or newline, a backslash-newline continuing the line, so also `… | xargs rm`) that names a path containing `rr-cache` (`.git/rr-cache`, `"$(git rev-parse --git-common-dir)/rr-cache"`); the same delete as the very next command after `cd` into such a path (`cd .git/rr-cache && rm -rf *`, also `cd -- …`, `pushd`, a delete on the next line, also `cd "$(git rev-parse --git-common-dir)/rr-cache"` and inside `( … )` or `sh -c "…"`); and `git rerere clear`, `forget` and `gc`, with up to 64 `git` global options before `rerere` (values may be quoted, escaped or `$(…)`, up to 4,096 characters each), after `sudo`, `env`, `xargs`, `timeout [-s SIG] [-k D] N` (`sudo`, `env`, `xargs` and `time` with short flags that take no value, so `sudo -u me git …`, `xargs -I{} git …` and `env -u X git …` get through), `nice` (and `nice -n 10`), `!`, `if`, `while`, `until`, `elif`, `do`, `then`, `else`, `{`, a pipe or `;`, and with `git` given by path (`/usr/bin/git`). The reason names the alternative: run the throwaway command with `git -c rerere.enabled=false …`, so its resolutions never reach the shared cache.
+- **Not refused**: reading the cache (`ls`, `cat`, `du`), `git rerere status`, `diff` and `remaining`, and anything aimed at a throwaway repository under `/tmp`, `/private/tmp`, `/var/folders` or `$TMPDIR` (also `${TMPDIR:-/tmp}`): an `rr-cache` path that starts there (and has no `..` after it), or, for `git rerere`, a `GIT_DIR=`, `--git-dir` or `git -C` that points there in the same command (between `;`, `&`, `|` or a newline) before `rerere`.
+
+These rules match command text, like every rule here, so they stop mistakes, not a determined dodge. Limits:
+
+- A path that does not spell `rr-cache` (`rm -rf .git/rr-*`, a variable holding the path, a script that deletes it) gets through, and so does `mv`.
+- A `cd` in an earlier call, or a delete that is not the next command after the `cd`, is not seen; neither is `cd … && find . -exec rm …` (a `find … -delete` is). A redirection or `|| exit` after the `cd` is allowed for.
+- Text that merely mentions the words is refused too (`git commit -m "…; git rerere gc is refused"`, a heredoc line, `git log -S"git rerere gc"`), as is a verb and `rr-cache` in the same command line even when unrelated: `grep rm .git/rr-cache` and `ls .git/rr-cache | grep rm` are refused. So is `git rerere clear` written as the start of a quoted string (`sh -c 'git rerere clear'` is meant to be caught, and so is `git commit -m 'git rerere clear'`).
+- A throwaway repository is recognized only inside the one command: `cd /tmp/x && git rerere clear` and an earlier `export GIT_DIR=…` are refused (write `git -C /tmp/x rerere clear`), and so is one outside the temporary folders, because text cannot tell it from the project's own.
+- Other ways to run the same thing get through. After a `cd`: `if cd …; then rm …`, `&& { rm …; }`, `&& (rm …)`, `&& nice rm …`, and a loop such as `for d in .git/rr-cache/*; do rm -rf "$d"; done`. For `git rerere`: `eval git rerere clear`, `parallel`, `stdbuf`, `find … -exec git rerere forget {} +`, `git rerere 'clear'`, `xargs` with options that take a value (`xargs -n 1`, `xargs -I{}`), `timeout --signal=KILL`, and a command inside `python -c` or `node -e`. A guard that reads command text cannot close these; it stops the usual spellings.
+- A delete and the `rr-cache` path more than 2,000 characters apart in one command line are not connected; that bound, and the other limits on how far a match reaches, keep matching time small, and the 32,768-character cap above bounds it for every pattern: the tests time adversarial lines of 5 KB to 30 KB, each under half a second on a busy machine, and check that a real offense after each is still refused. A regex that runs out of its engine's backtracking budget answers "no match", which would let a command through; reviewers found such stalling lines of a few hundred bytes (since fixed), and none is known up to the cap (the tests run shapes of up to about 32 KB).
+- A `GIT_DIR=` before an `sh -c "git rerere clear"` is not seen inside the quoted string, and a variable whose name merely ends in `GIT_DIR=` counts as one.
+- Only the first throwaway option counts: `git -C /tmp/x -C /work/repo rerere clear` is exempt, though a later `-C` points at the project. `${TMPDIR:-<anything>}` is exempt whatever the default.
+- A quoted path with a space in it (`"/tmp/my dir/.git/rr-cache"`) is judged by the part after the space.

package/examples/omp-coord.json

@@ -22,6 +22,16 @@
     "test": { "slots": 3, "order": "fair-share", "agingMinutes": 10, "timeoutMinutes": 30 }
   },
   "commands": [
+    {
+      "pattern": "(?:(?<![\\w.-])(?:rm|rmdir|unlink|trash|shred)(?![\\w.-])|\\s-delete\\b|(?=((?<![\\w.-])git\\b[^;&|\\n]{0,200}?\\sclean\\b))\\1)[^;&\\n]{0,2000}(?:\\\\\\n[^;&\\n]{0,2000}){0,4}(?:^|[\\s=(])(?!['\"]?(?:(?:/private)?/(?:tmp|var/folders)/|\\$\\{?TMPDIR(?::-[^}\\s]*)?\\}?['\"]?/)(?![^\\s;&|=(]*\\.\\./))['\"]?[^\\s;&|=(]*rr-cache|(?:^|[\\s=(])(?!['\"]?(?:(?:/private)?/(?:tmp|var/folders)/|\\$\\{?TMPDIR(?::-[^}\\s]*)?\\}?['\"]?/)(?![^\\s;&|=(]*\\.\\./))['\"]?[^\\s;&|=(]*rr-cache[^;&\\n]{0,2000}(?:\\\\\\n[^;&\\n]{0,2000}){0,4}(?:(?<![\\w.-])(?:rm|rmdir|unlink|trash|shred)(?![\\w.-])|\\s-delete\\b|(?<![\\w.-])git\\b[^;&|\\n]{0,200}\\sclean\\b)|(?<![\\w.-])git\\b[^;&|\\n]{0,200}\\s--work-tree[=\\s][^;&|\\n]{0,200}rr-cache[^;&|\\n]{0,200}\\sclean\\b|(?:^|[;&|\\n({\\`]|(?<=\\s)['\"])[^\\S\\n]*(?:cd|pushd)[^\\S\\n]+(?:-[-\\w]*[^\\S\\n]+)?(?!['\"]?(?:(?:/private)?/(?:tmp|var/folders)/|\\$\\{?TMPDIR(?::-[^}\\s]*)?\\}?['\"]?/)(?![^\\s;&|=(]*\\.\\./))(?=[^;&|\\n]{0,2000}(?:\\\\\\n[^;&|\\n]{0,2000}){0,4}rr-cache)(?:\"[^\"\\n]*\"|'[^'\\n]*'|\\$\\([^)\\n]*\\)|[^\\s;&|\"'$<>]|\\$(?!\\())+(?:(?:[^\\S\\n]+\\d+|[^\\S\\n]*)&?[<>]&?[^\\s;&|<>]*){0,4}(?:[^\\S\\n]*\\|\\|[^\\S\\n]*(?:exit|return)(?:[^\\S\\n]+\\d+)?)?[^\\S\\n]*(?:\\\\\\n[^\\S\\n]*)?(?:&&|;|\\n)[\\s\\\\]*(?:(?:sudo|command)\\s+)*(?:/\\S*/)?(?:(?:(?<![\\w.-])(?:rm|rmdir|unlink|trash|shred)(?![\\w.-])|\\s-delete\\b|(?<![\\w.-])git\\b[^;&|\\n]{0,200}\\sclean\\b)|find\\b[^;&|\\n]{0,2000}(?:\\\\\\n[^;&|\\n]{0,2000}){0,4}\\s-delete\\b)",
+      "action": "refuse",
+      "reason": "git's rerere cache is shared by every worktree and session, and deleting it loses other sessions' recorded resolutions: to keep a throwaway build's resolutions out, run that command with `git -c rerere.enabled=false …`"
+    },
+    {
+      "pattern": "(?:^|[;&|\\n({\\`]|(?<=\\s)['\"])(?![^;&|\\n]{0,500}?(?:GIT_DIR=|--git-dir[=\\s]|\\s-C\\s+)['\"]?(?:(?:/private)?/(?:tmp|var/folders)/|\\$\\{?TMPDIR(?::-[^}\\s]*)?\\}?['\"]?/)(?![^\\s;&|=(]*\\.\\./)(?=[^;&|\\n]{0,500}?\\srerere\\b))[^\\S\\n]*(?:(?:\\w+=(?:\"[^\"\\n]*\"|'[^'\\n]*'|\\$\\([^)\\n]*\\)|\\`[^\\`\\n]*\\`|[^\\s\"'$\\`]|\\$(?!\\()){0,512}|sudo(?:\\s+-\\w+)*|command|exec|nice(?:\\s+-\\w+(?:\\s+\\d+)?)?|!|if|while|until|elif|env(?:\\s+-\\w+)*|time(?:\\s+-\\w+)*|nohup|do|then|else|xargs(?:\\s+-\\w+)*|timeout(?:\\s+(?:-[sk]\\s+\\S+|--?[\\w-]+)){0,4}\\s+\\S+)\\s+){0,8}(?:(?:/[\\w.-]+)+/)?git\\b(?:(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)(?:-c(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)(?!-)(?:[^\\s\"'$\\`\\\\]|\\\\[^\\n]|\\$(?!\\()|\\$\\([^)\\n]*\\)|\\`[^\\`\\n]*\\`|\"[^\"]*\"|'[^']*'){1,4096}|-C(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)(?!-)(?:[^\\s\"'$\\`\\\\]|\\\\[^\\n]|\\$(?!\\()|\\$\\([^)\\n]*\\)|\\`[^\\`\\n]*\\`|\"[^\"]*\"|'[^']*'){1,4096}|--(?:git-dir|work-tree|namespace|exec-path)(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)(?!-)(?:[^\\s\"'$\\`\\\\]|\\\\[^\\n]|\\$(?!\\()|\\$\\([^)\\n]*\\)|\\`[^\\`\\n]*\\`|\"[^\"]*\"|'[^']*'){1,4096}|--[\\w-]+(?:=(?:[^\\s\"'$\\`\\\\]|\\\\[^\\n]|\\$(?!\\()|\\$\\([^)\\n]*\\)|\\`[^\\`\\n]*\\`|\"[^\"]*\"|'[^']*'){0,4096})?|-\\w+)){0,64}(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)rerere(?:(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)--?[\\w-]+){0,8}(?:\\s+(?:\\\\\\n\\s*)*|(?:\\\\\\n\\s*)+)(?:clear|forget|gc)\\b",
+      "action": "refuse",
+      "reason": "git's rerere cache is shared by every worktree and session, and deleting it loses other sessions' recorded resolutions: to keep a throwaway build's resolutions out, run that command with `git -c rerere.enabled=false …`"
+    },
     { "pattern": "(^|[;&|(\\s])(npm|pnpm|yarn|bun)\\s+(run\\s+)?test\\b", "action": "queue", "queue": "test" },
     { "pattern": "(^|[;&|(\\s])(npm|pnpm|yarn|bun)\\s+run\\s+build\\b", "action": "queue", "queue": "build" },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nledford/omp-coord",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "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

@@ -26,10 +26,22 @@ export interface Runner {
   config: string;
 }
 
+/**
+ * Longest command a `refuse` rule is judged on. omp's `tool_call` check is synchronous here and fails closed after 30 s,
+ * and a regex that spends its whole backtracking budget answers "no match", which would let the command through. A
+ * longer command is refused instead, so the cost of every pattern is bounded by this length.
+ */
+export const MAX_CHECKED_COMMAND = 32_768;
+
 export function decideCommand(rules: CommandRule[], command: string, runner: Runner): CommandDecision {
   // Already queued: a command that runs `omp-coord run`, or one this extension rewrote.
   if (/(^|[;&|(\s'"/])omp-coord'?\s+'?run\b/.test(command) || runner.argv.every(a => command.includes(a)))
     return { kind: "allow" };
+  if (command.length > MAX_CHECKED_COMMAND && rules.some(r => r.action === "refuse"))
+    return {
+      kind: "refuse",
+      reason: `the command is ${command.length} characters, over the ${MAX_CHECKED_COMMAND} that omp-coord's refuse rules can check: create the file with the write tool and run it from a short command`,
+    };
   const rule = rules.find(r => r.pattern.test(command));
   if (!rule) return { kind: "allow" };
   if (rule.action === "refuse") return { kind: "refuse", reason: rule.reason };
@@ -54,27 +66,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.