@krtclcdy/tersio 2.25.7 → 2.25.8

package/extensions/pstack/playbooks/orchestrate.md

@@ -12,15 +12,15 @@ Three rules carry the rest.
 
 #### Roles and placement
 
-- **Coordinator (this chat).** Local. Frames, authors briefs, drains the inbox, owns the human report, makes judgment calls. It never authors or edits code. Conflicted merges, restacks, and code changes are always tasks. Mechanically landing a verified unit (fast-forward or clean cherry-pick of a worker's commit, then push) is bookkeeping the coordinator may do itself on repos where local git is cheap. Queueing finished work behind an idle stacker is how a deadline harvests nothing. The loop is agentic end to end. Agents are spawned, resumed, and drained only through the Task tool. State reads and writes go through `scripts/orch/orch.ts` at drain points, one command in and one line out. The CLI never spawns, waits, or wakes anything.
+- **Coordinator (this chat).** Local. Frames, authors briefs, drains the inbox, owns the human report, makes judgment calls. It never authors or edits code. Conflicted merges, restacks, and code changes are always tasks. Mechanically landing a verified unit (fast-forward or clean cherry-pick of a worker's commit, then push) is bookkeeping the coordinator may do itself on repos where local git is cheap. Queueing finished work behind an idle stacker is how a deadline harvests nothing. The loop is agentic end to end. Agents are spawned, resumed, and drained only through the Task tool. State reads and writes go through the state store at drain points, one command in and one line out. The store never spawns, waits, or wakes anything.
 - **Sub-coordinator.** Always local, durable, one per track, and only when the program exceeds what one coordinator's drains can manage. A track the coordinator can drain itself needs no middle layer. Each nested layer re-pays a full orientation preamble, and a blocking sub-coordinator hides its children while the parent idles. Owns its track's units and boards, authors its workers' briefs, spawns its own workers and verifiers (nesting works to depth 3, and a nested spawn has the full Task schema including `environment`). Rolls up aggregates at wave boundaries. Never forwards raw child reports. Cap in-flight children at what one drain can process, roughly ten, as a rolling window. Never as blocking batches, which cost the slowest child of every batch.
-- **Worker / verifier.** Always unless the task needs this machine: `control-ui` or `control-cli` runtime verification. Reading local transcripts under `agent-transcripts/`. Simulators and local IDE state. Auth that exists only here. Cloud agents cannot read the local store, so their briefs inline what they need or point at repo paths. Prefer fewer, broader workers. One writer per worktree or branch (principle-separate-before-serializing-shared-state). Run a unit's verifier on a different model family from its worker.
+- **Worker / verifier.** Always unless the task needs this machine: runtime verification on the real surface. Reading local transcripts under the workspace's transcript root. Simulators and local IDE state. Auth that exists only here. Cloud agents cannot read the local store, so their briefs inline what they need or point at repo paths. Prefer fewer, broader workers. One writer per worktree or branch (principle-separate-before-serializing-shared-state). Run a unit's verifier on a different model family from its worker.
 
 Depth stays at coordinator, track, worker. Author the track decomposition per project (build, landing, and verification are common cuts, not a required shape). Hard-coded swarm trees were tried and parked as too rigid.
 
 #### Store layout
 
-Create `orchestrate/<project-slug>/` in the current agent's store (path in the system prompt). Every file has exactly one writer. Owners publish facts, readers aggregate at read time. Use `bun scripts/orch/orch.ts` for bookkeeping, written below as `orch`, while its canonical plain TSV and JSON stay readable without the CLI.
+Create `orchestrate/<project-slug>/` in the current agent's store (path in the system prompt). Every file has exactly one writer. Owners publish facts, readers aggregate at read time. Keep the bookkeeping in plain TSV and JSON, readable without any CLI.
 
 - `preferences.md` is the standing-orders register: numbered lines, one constraint each (model policy, stack shape and count, verification bar, forbidden paths, escalation policy). Paste it verbatim into every spawn and every resume. Directives decay across resumes, and each dropped one costs a human turn. When you catch yourself restating an instruction, append the line before you act (principle-encode-lessons-in-structure).
 - `overview.md` is the durable PR and issue DB. Append. Never rewrite wholesale per event.

package/extensions/pstack/playbooks/session-pickup.md

@@ -2,7 +2,7 @@
 
 **You own the resume point. Read the prior trail, don't redo it.**
 
-1. Locate the prior trail. A local transcript under the active workspace's `agent-transcripts/` directory (the system prompt names the path. Do not glob across every workspace's transcript root, that crosses workspace boundaries and reads private chats from unrelated projects), a cloud-agent URL, or a pushed branch. Read the metadata overview and last messages first, then scan back for the decision points. Parse a long transcript in a subagent and keep the reduced timeline in the main thread (the **principle-guard-the-context-window** skill).
+1. Locate the prior trail. A local transcript under the workspace's transcript root (the system prompt names the path. Do not glob across every workspace's transcript root, that crosses workspace boundaries and reads private chats from unrelated projects), a cloud-agent URL, or a pushed branch. Read the metadata overview and last messages first, then scan back for the decision points. Parse a long transcript in a subagent and keep the reduced timeline in the main thread (the **principle-guard-the-context-window** skill).
 2. Reconstruct operational state. The branch and worktree, what already landed (`git log`, `git diff` against the base), the open todos, the decisions made. The prior trail is authoritative input. Resist the bias to re-derive it.
 3. Diff done vs pending. Compare what shipped against what was planned, name the resume point, do not re-run the prior repro or redo completed work. A "let me verify from scratch" pass means you're treating the trail as untrustworthy when it's authoritative.
 4. Route the remaining work to the matching playbook and pick the verdict: continue the execution, ship a finished recommendation, ratify or override a prior conclusion, or postmortem a failed run. The pickup playbook ends here. The routed playbook owns the rest.

package/extensions/pstack/playbooks/shipping.md

@@ -4,14 +4,14 @@
 
 This is the half after `playbooks/babysit.md`.
 
-1. **Resolve the forge, then verify every PR independently.** GitHub CLI (`gh`) is the default. If `command -v origin` succeeds and Origin can resolve the repository, use `origin pr ...` for view, watch, edit, and merge operations. Otherwise stay on `gh` and record the fallback. Never require Graphite (`gt`). One subagent per PR, not batched, each exercising the real surface with the matching control skill (such as the `control-ui` or `control-cli` skill) against parent versus head. Each returns `PASS`, `PASS+NOTES` or `FAIL` and posts that verdict on its own PR. Safe means a verdict from an agent that did not write the code. CI green is not a verdict, and an approving bot review is not a verdict.
+1. **Resolve the forge, then verify every PR independently.** GitHub CLI (`gh`) is the default. If `command -v origin` succeeds and Origin can resolve the repository, use `origin pr ...` for view, watch, edit, and merge operations. Otherwise stay on `gh` and record the fallback. Never require Graphite (`gt`). One subagent per PR, not batched, each exercising the real surface through the repo's own control skill where one exists against parent versus head. Each returns `PASS`, `PASS+NOTES` or `FAIL` and posts that verdict on its own PR. Safe means a verdict from an agent that did not write the code. CI green is not a verdict, and an approving bot review is not a verdict.
 2. **Land only the contiguous verified run rooted at the bottom.** Walk up from the lowest unmerged PR and stop at the first one without a passing verdict, where both `PASS` and `PASS+NOTES` pass. A verified PR sitting above an unverified one is not landable. Report the ceiling as a PR number and say what breaks the chain.
 3. **Re-check that each verdict still describes the patch.** Record the verdict head SHA, base SHA, and stable `git patch-id` of that PR's base-to-head diff. A rebase or base retarget rewrites SHAs and can silently invalidate a verdict without touching a check. Before landing a PR, compare the recorded patch-id with its current base-to-head patch-id. When the two patches differ only in tests, docs, or lint config, build what each lane ran. Build it twice at the verdict SHA and once at the current head. A difference is noise if the two builds at the verdict SHA also show it, or if it is an embedded commit SHA. Judge each difference, not each file, and report each kind of noise with its files. If only noise differs, that lane's result stays valid, and checks and a review of the change run fresh. Do not reuse a lane result from a dev server or from anything else with no build output. Rerun that lane. Re-verify anything else when the patch changed. When it did not, keep the code verdict but re-run mergeability and CI at the current head. Never use matching commit messages or a green check from an older SHA as a substitute.
 4. **Prepare only the bottom PR.** Fetch current trunk. Rebase the lowest verified branch onto the exact trunk tip when needed, push it, and retarget only that PR to trunk with `origin pr edit <pr> --base <trunk>` or `gh pr edit <pr> --base <trunk>`. Re-run step 3 after the push. Do not retarget, arm, or merge descendants yet.
 5. **Land one PR at a time.** If the bottom PR is mergeable now, squash it with `origin pr merge <pr> --squash` or `gh pr merge <pr> --squash`. If requirements are still running and the user asked for merge-when-ready, arm only that PR with `origin pr merge <pr> --squash --auto` or `gh pr merge <pr> --squash --auto`. Origin's `--auto` is Origin merge-when-ready. GitHub's `--auto` is GitHub auto-merge. Wait for that PR to merge before preparing the next one.
 6. **Do not read GitHub `autoMergeRequest` as stack readiness.** At most it says GitHub auto-merge was requested for one GitHub PR. It does not prove Origin merge-when-ready is armed, that a descendant is queued, that a patch verdict is current, or that the contiguous stack is safe. Confirm the active forge's state for the current bottom PR, and say that the state is unknown if the active forge cannot report it.
 7. **Recompute after every merge.** Fetch trunk, confirm the merged SHA is present, drop the merged PR from the frozen bottom-to-top list, and inspect the new bottom PR's base, head, checks, and patch-id. A host may retarget a child automatically, but do not assume it did. Repeat steps 3 through 6 for that one PR. Independent work stays outside this chain and ships on its own.
-8. **Watch the current frontier until it merges or fails. Do not mutate the queue around it.** With Origin, use `origin pr view <pr> --checks --comments` and `origin pr checks <pr> --watch`, then re-read the PR until it reports merged or blocked. With GitHub, use `scripts/watch-pr/watch-pr --queued-stack --stack-prs <bottom>` only as an event wake and poll `gh pr view <pr> --json state,mergedAt,mergeStateStatus,statusCheckRollup,autoMergeRequest` after each wake, ignoring `READY` until `mergedAt` is non-null or `state` is `MERGED`. Only then run step 7. Hard-fail only when `state` is `CLOSED` with no `mergedAt`, a required check concludes `FAILURE` or `CANCELLED` and blocks merge after auto-merge is no longer pending, or `mergeStateStatus` is `UNSTABLE` or `DIRTY` with no auto-merge pending. `BLOCKED` while checks are pending or auto-merge is armed is not failure. Do not use Babysit's queued `WAITING`/`merge-queue` stop condition here. Hold the watch under a repeating loop in dynamic mode. Report each merge and the new ceiling. If the queue stalls, diagnose before mutating.
+8. **Watch the current frontier until it merges or fails. Do not mutate the queue around it.** With Origin, use `origin pr view <pr> --checks --comments` and `origin pr checks <pr> --watch`, then re-read the PR until it reports merged or blocked. With GitHub, use an event wake if the repo has one, and poll `gh pr view <pr> --json state,mergedAt,mergeStateStatus,statusCheckRollup,autoMergeRequest` after each wake, ignoring `READY` until `mergedAt` is non-null or `state` is `MERGED`. Only then run step 7. Hard-fail only when `state` is `CLOSED` with no `mergedAt`, a required check concludes `FAILURE` or `CANCELLED` and blocks merge after auto-merge is no longer pending, or `mergeStateStatus` is `UNSTABLE` or `DIRTY` with no auto-merge pending. `BLOCKED` while checks are pending or auto-merge is armed is not failure. Do not use Babysit's queued `WAITING`/`merge-queue` stop condition here. Hold the watch under a repeating loop in dynamic mode. Report each merge and the new ceiling. If the queue stalls, diagnose before mutating.
 9. **Stop at the ceiling.** When the verified run is merged, report what landed, what the next unverified PR is, and what verifying it would take. Extending the run is a new pass through step 1.
 
 **Reply:** the verified run and its ceiling, each PR's verdict and who produced it, what you armed and how you confirmed it, what landed, and what the next gap needs.

package/extensions/pstack/playbooks/worktree-cleanup.md

@@ -1,6 +1,6 @@
 ### Worktree and simulator cleanup
 
-1. Snapshot and audit. Record `df -h /`, then run `scripts/worktree-audit.sh [-b <pr-base-ref>] [repo-path]` (principle-build-the-lever). Without `-b` it checks `MERGED` against `origin/HEAD`, so pass `-b origin/<branch>` when PRs target another branch. It reads paths from `git worktree list`, never hand-typed, since a hand-typed `myrepo-worktrees/x` misses one that lives in a sibling worktrees directory (principle-encode-lessons-in-structure). It classifies each worktree by size, age, merge state, uncommitted work, PR state, and the newest chat that touched it, then suggests a bucket. The transcript scan is slow, so background it.
+1. Snapshot and audit. Record `df -h /`, then read paths from `git worktree list` and classify each worktree by size, age, merge state, uncommitted work, PR state, and the newest chat that touched it, then suggest a bucket. The transcript scan is slow, so background it.
 2. The bucket is advice, not permission. The pinned and active chats are the real artifact (principle-prove-it-works). Get that set from the user or sidebar and cross-check every candidate. The lever has marked `safe` a worktree the user had pinned, so the pinned set wins.
 3. Verify usage before deleting. For every `verify-recent-chat` row, or anything you doubt, fan subagents out to read the transcripts and report whether the chat is pinned or ongoing and which worktrees it touches (principle-guard-the-context-window, transcripts are bulk). A pinned chat spawns arena and repro trees into sibling worktrees via background subagents, and those are in use even when their names never hit the sidebar.
 4. Pause on irreversible loss. `wip:N` is N tracked uncommitted edits. Show the diff and get a decision first, since removing a clean worktree is recoverable from its branch but uncommitted work is gone. `scratch:N` is untracked throwaway, safe to drop, but name the files. Per Autonomy, clean and merged and not-in-use proceeds. `wip` and in-use pause.

package/extensions/pstack/skills/reflect/SKILL.md

@@ -11,10 +11,10 @@ Invoke when the user says "reflect" or "the reflect skill". Skip when the conver
 
 ## 1. Locate the active transcript
 
-Before fanning out, find this conversation's transcript in the `agent-transcripts/` directory the system prompt names. Do not glob across every workspace's transcript root. That crosses workspace boundaries and reads private chats from unrelated projects.
+Before fanning out, find this conversation's transcript in the transcript root the system prompt names. Do not glob across every workspace's transcript root. That crosses workspace boundaries and reads private chats from unrelated projects.
 
 ```bash
-ls -t <agent-transcripts>/*.jsonl <agent-transcripts>/*/*.jsonl <agent-transcripts>/*/subagents/*.jsonl 2>/dev/null | head -10
+ls -t <transcript-root>/*.jsonl <transcript-root>/*/*.jsonl <transcript-root>/*/subagents/*.jsonl 2>/dev/null | head -10
 ```
 
 That covers the legacy flat (`<id>.jsonl`), current nested (`<id>/<id>.jsonl`), and subagent (`<parent>/subagents/<child>.jsonl`) layouts. For each candidate, read the first JSONL line. Take the file whose `message.content[0].text` contains the conversation's opening user prompt. If none matches, pass a tight digest of the session instead.

package/extensions/pstack/skills/show-me-your-work/SKILL.md

@@ -34,7 +34,7 @@ ts	phase	decision	why	evidence	result
 
 Write each entry the way you'd tell a teammate what you did. Plain words, concrete actions, no AI speak or abstract jargon (the **unslop** skill applies to log text too).
 
-Use the helper `scripts/log.sh <logfile> <phase> <decision> <why> <evidence> <result>`. It stamps `ts`, writes the header on first use, strips stray tabs/newlines, and prefixes any cell starting with `=`, `+`, `-`, or `@` with a single quote. A bare `printf` appending a row works too, but mind those same bytes if cells come from generated or user-supplied text.
+Append a row with `printf`, minding those same bytes if cells come from generated or user-supplied text. Prefix any cell starting with `=`, `+`, `-`, or `@` with a single quote.
 
 Log decision points and checkpoints, not every action: a fork chosen, a unit completed with its verification result, a pivot or revert with its trigger, a blocker surfaced, a gate fixed. For loop runs, one row per iteration. Skip the trivial and self-evident.
 
@@ -53,7 +53,7 @@ Commit it only when the work is ambitious enough that a reviewer needs the trail
 
 ## Audit the log against the transcript
 
-At the end of the run, before handing back, check the log told the truth. Read this run's transcript under the active workspace's `agent-transcripts/` directory (the system prompt names the path). Don't glob across every workspace's transcript root. That reads unrelated private chats. Walk this run's rows against what actually happened. Each stretch of them begins at one of this run's `start` rows, or at the first row if this run created the log, and ends at the next `start` row of another run:
+At the end of the run, before handing back, check the log told the truth. Read this run's transcript under the workspace's transcript root (the system prompt names the path). Don't glob across every workspace's transcript root. That reads unrelated private chats. Walk this run's rows against what actually happened. Each stretch of them begins at one of this run's `start` rows, or at the first row if this run created the log, and ends at the next `start` row of another run:
 
 - Check that every row maps to a real decision or action.
 - Check that each row's evidence resolves and shows what the row claims.

package/extensions/rtk/filter.ts

@@ -5,6 +5,8 @@ import { join } from 'node:path';
 import { resolveRtkBinary } from '../shared/utils.ts';
 import { readRtkDefault } from '../shared/plugin-settings.ts';
 import { getSharedComboState, lastCustomValue, sessionEntries } from '../shared/session-state.ts';
+import { appendUsage } from '../shared/usage-ledger.ts';
+import { isPiHost } from '../shared/host.ts';
 import type { ExtensionApi, ExtensionCtx, SessionEntry, ToolResultEvent } from '../shared/types.ts';
 
 /** Tool name to `rtk pipe --filter` name. Exported so the OpenCode host reuses one map. */
@@ -18,8 +20,13 @@ export const FILTER_BY_TOOL = new Map([
 export const MIN_FILTER_BYTES = 1200;
 const FILTER_TIMEOUT_MS = 5000;
 
-/** Absolute, so a minimal PATH in the host cannot break the spawn. */
-const SHELL = '/bin/sh';
+// A shell that understands `<`, resolved per platform; separate flags, because Node quotes each argv element and cmd.exe rejects `"/d /s /c"`.
+/** The pipe's shell, and whether the whole command needs an extra quote pair: `cmd.exe /s` strips the outer one, so a quoted binary and redirect path must be wrapped. */
+export function filterShell(): { shell: string; flags: string[]; wrap: boolean } {
+  return process.platform === 'win32'
+    ? { shell: process.env.ComSpec || 'cmd.exe', flags: ['/d', '/s', '/c'], wrap: true }
+    : { shell: '/bin/sh', flags: ['-c'], wrap: false };
+}
 
 export type FilterExec = (
   cmd: string,
@@ -58,8 +65,10 @@ export async function filterThroughRtk(
     dir = mkdtempSync(join(tmpdir(), 'tersio-rtk-'));
     const file = join(dir, 'in.txt');
     writeFileSync(file, text, 'utf8');
-    // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect.
-    const result = await exec(SHELL, ['-c', `"${bin}" pipe -f ${filter} < "${file}"`], { signal, timeout: FILTER_TIMEOUT_MS });
+    // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect through the platform shell.
+    const { shell, flags, wrap } = filterShell();
+    const line = `"${bin}" pipe -f ${filter} < "${file}"`;
+    const result = await exec(shell, [...flags, wrap ? `"${line}"` : line], { signal, timeout: FILTER_TIMEOUT_MS });
     if (result.code !== 0) return null;
     const out = result.stdout;
     if (!out.trim() || out.length >= text.length) return null;
@@ -71,10 +80,48 @@ export async function filterThroughRtk(
   }
 }
 
+/** A bash tool call, before it runs. pi and omp hand the extension the mutable input. */
+interface BashCallEvent {
+  toolName?: unknown;
+  input?: { command?: unknown };
+}
+
+/** Ask rtk for the rewritten command; null on any failure, so the original runs. */
+async function rewriteCommand(
+  exec: FilterExec,
+  bin: string,
+  command: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  try {
+    const result = await exec(bin, ['rewrite', command], { timeout: FILTER_TIMEOUT_MS, signal });
+    const out = result.stdout.trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
 export default function rtkFilterExtension(pi: ExtensionApi): void {
   const bin = resolveRtkBinary();
   const exec = pi.exec;
   if (!bin || !exec) return;
+  // omp records the post-hook command in its transcript, so only pi leaves an audit row here:
+  // opencode rewrites in its own plugin hook, and an omp row would double-count the transcript.
+  const auditHost = isPiHost(pi) ? 'pi' : null;
+  // Registered synchronously, unlike the rtk-init hook, whose async version probe can miss the first call of a fast session.
+  pi.on('tool_call', async (event, ctx: ExtensionCtx) => {
+    const call = (event ?? {}) as BashCallEvent;
+    const input = call.input;
+    if (call.toolName !== 'bash' || !input) return;
+    const command = input.command;
+    if (typeof command !== 'string' || !command.trim() || command.startsWith('rtk ')) return;
+    if (!rtkActive(sessionEntries(ctx))) return;
+    const rewritten = await rewriteCommand(exec, bin, command, ctx?.signal);
+    if (!rewritten || rewritten === command) return;
+    input.command = rewritten;
+    if (auditHost) appendUsage('rtk-audit', `${auditHost} ${command}`);
+  });
   pi.on<ToolResultEvent>('tool_result', async (event, ctx: ExtensionCtx) => {
     const filter = FILTER_BY_TOOL.get(String(event?.toolName ?? '').toLowerCase());
     if (!filter || event?.isError) return;

package/extensions/rtk/session.ts

@@ -1,7 +1,7 @@
 import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, systemPromptIncludes } from '../shared/session-state.ts';
 import { injectPromptText, onHostEvent, setExtensionLabel, stringArrayToolParams } from '../shared/host.ts';
 import { readRtkDefault } from '../shared/plugin-settings.ts';
-import { resolveRtkBinary } from '../shared/utils.ts';
+import { resolveRtkBinary, shimCommand } from '../shared/utils.ts';
 import { announceStatus } from '../shared/status.ts';
 import type { ExtensionApi, ExtensionCtx, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
@@ -93,7 +93,9 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
       onUpdate?.({ content: [{ type: 'text', text: `${bin === null ? '' : 'rtk '}${argv.join(' ')}` }], details: { phase: 'start' } });
       try {
         // A GUI-launched host may lack ~/.bun/bin on PATH, so prefer the resolved path.
-        const result = await pi.exec(bin ?? argv[0], argv, { signal, cwd });
+        // A `.cmd` shim cannot be spawned directly on Windows, so it runs through the shell.
+        const shim = shimCommand(bin ?? argv[0], argv);
+        const result = await pi.exec(shim.cmd, shim.args, { signal, cwd });
         const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
         return {
           isError: result.code !== 0,

package/extensions/server.ts

@@ -12,7 +12,8 @@ import comboToggleExtension from './combo/index.ts';
 import tersioCommandsExtension from './commands/index.ts';
 import { getSharedComboState } from './shared/session-state.ts';
 import { formatStatus } from './shared/status.ts';
-import { resolveRtkBinary } from './shared/utils.ts';
+import { resolveRtkBinary, shimCommand } from './shared/utils.ts';
+import { appendUsage } from './shared/usage-ledger.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from './shared/types.ts';
 
 interface CommandConfig {
@@ -221,7 +222,11 @@ const plugin: Plugin.Plugin = {
       if (sid !== undefined) await ensureSession(sid);
       if (!rtkActive(sid === undefined ? undefined : sessionEntriesOf(sid))) return;
       const rewritten = await rewriteCommand(input.command);
-      if (rewritten) input.command = rewritten;
+      if (!rewritten || rewritten === input.command) return;
+      const original = input.command;
+      input.command = rewritten;
+      // The transcript stores the pre-hook command, so the rewrite leaves its own row.
+      appendUsage('rtk-audit', `opencode ${original}`);
     });
 
     // Built-in grep and glob output never reaches the bash hook; mutate result.content in place.
@@ -250,15 +255,17 @@ const plugin: Plugin.Plugin = {
 
 /** execFile with the promise shape `filterThroughRtk` expects. */
 function execRtk(cmd: string, args: string[], opts?: { signal?: AbortSignal; timeout?: number }): Promise<{ stdout: string; code: number }> {
-  return new Promise((resolve) => {
-    execFile(cmd, args, { signal: opts?.signal, timeout: opts?.timeout }, (error, stdout) => {
-      const out = stdout ?? '';
-      if (!error) return resolve({ stdout: out, code: 0 });
-      // A non-numeric code is a spawn failure (ENOENT, EACCES, killed) and must not read as success.
-      const raw = (error as { code?: unknown }).code;
-      resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
-    });
+  const { promise, resolve } = Promise.withResolvers<{ stdout: string; code: number }>();
+  // cmd.exe parses its own quoting, so the command string must reach it verbatim: Node's default escaping turns the inner quotes into `\"` and the redirect then fails.
+  const shim = shimCommand(cmd, args);
+  execFile(shim.cmd, shim.args, { signal: opts?.signal, timeout: opts?.timeout, windowsVerbatimArguments: process.platform === 'win32' }, (error, stdout) => {
+    const out = stdout ?? '';
+    if (!error) { resolve({ stdout: out, code: 0 }); return; }
+    // A non-numeric code is a spawn failure (ENOENT, EACCES, killed) and must not read as success.
+    const raw = (error as { code?: unknown }).code;
+    resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
   });
+  return promise;
 }
 
 /** `rtk rewrite` exit codes: 0 rewrite found, 1 no equivalent, 3 advisory; the code is the contract. */
@@ -309,20 +316,21 @@ function bundledSkills(): ReturnType<typeof parseSkillFile>[] {
 function rewriteCommand(command: string): Promise<string | null> {
   const bin = resolveRtkBinary();
   if (!bin) return Promise.resolve(null);
-  return new Promise((resolve) => {
-    execFile(bin, ['rewrite', command], { timeout: 5000 }, (error, stdout) => {
-      // A kill or timeout means untrustworthy output; pass the command through.
-      const err = error as { killed?: boolean; signal?: unknown; code?: unknown } | null;
-      if (err && (err.killed || err.signal)) return resolve(null);
-      const code = typeof err?.code === 'number' ? err.code : RTK_REWRITE_FOUND;
-      // Exit 1 is the only "no equivalent" answer, so anything else with output rewrites.
-      if (code === 1) return resolve(null);
-      const out = String(stdout).trim();
-      if (!out || out === command) return resolve(null);
-      if (code !== RTK_REWRITE_FOUND && code !== RTK_REWRITE_ADVISORY) return resolve(null);
-      resolve(out);
-    });
+  const { promise, resolve } = Promise.withResolvers<string | null>();
+  // A `.cmd` shim cannot be spawned directly on Windows, so it runs through the shell.
+  const shim = shimCommand(bin, ['rewrite', command]);
+  execFile(shim.cmd, shim.args, { timeout: 5000 }, (error, stdout) => {
+    // A kill or timeout means untrustworthy output; pass the command through.
+    const err = error as { killed?: boolean; signal?: unknown; code?: unknown } | null;
+    if (err && (err.killed || err.signal)) { resolve(null); return; }
+    const code = typeof err?.code === 'number' ? err.code : RTK_REWRITE_FOUND;
+    // Exit 1 is the only "no equivalent" answer, so anything else with output rewrites.
+    if (code === 1) { resolve(null); return; }
+    const out = String(stdout).trim();
+    if (!out || out === command || (code !== RTK_REWRITE_FOUND && code !== RTK_REWRITE_ADVISORY)) { resolve(null); return; }
+    resolve(out);
   });
+  return promise;
 }
 
 export default plugin;

package/extensions/shared/agent-stats.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { sqliteRead } from './sqlite.ts';
+import { homeDir } from './utils.ts';
 import { usageDbPath } from './usage-store.ts';
 
 export type RangeKey = '1h' | '24h' | '7d' | '30d' | '90d' | 'all';
@@ -83,7 +84,7 @@ export function statsDbPath(): string {
 
 /** Quota snapshots. Only omp records these, so this stays omp's own database. */
 export function agentDbPath(): string {
-  return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(os.homedir(), '.omp', 'agent', 'agent.db');
+  return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(homeDir(), '.omp', 'agent', 'agent.db');
 }
 
 /** The row shape every query groups by: a message joined to its file, since path and facts live apart. */
@@ -117,14 +118,19 @@ function providerExpr(model: string): string {
   return `CASE WHEN instr(${model}, '/') = 0 THEN '' ELSE CASE ${named} ${cases} ELSE ${named} END END`;
 }
 
-/** SQL: the project a transcript belongs to, named by its session folder. A flat session tree uses its data dir. */
+/** SQL: the project from a transcript's session folder; the separator follows the stored path, since a Windows run stores `\`. */
 function projectExpr(file: string): string {
-  const marker = `instr(${file}, '/sessions/')`;
-  const seg = `substr(${file}, ${marker} + 10, instr(substr(${file}, ${marker} + 10) || '/', '/') - 1)`;
-  const base = `replace(${file}, rtrim(${file}, replace(${file}, '/', '')), '')`;
+  // Position of the session marker under either separator; 0 when the path has none.
+  const posAt = `instr(${file}, '/sessions/')`;
+  const posWin = `instr(${file}, '\\sessions\\')`;
+  const at = `CASE WHEN ${posAt} > 0 THEN ${posAt} ELSE ${posWin} END`;
+  // Which separator to slice on: the one the matched marker used, else the one the path uses.
+  const sep = `CASE WHEN ${posAt} > 0 THEN '/' WHEN ${posWin} > 0 THEN '\\' WHEN instr(${file}, '\\') > 0 THEN '\\' ELSE '/' END`;
+  const seg = `substr(${file}, ${at} + 10, instr(substr(${file}, ${at} + 10) || ${sep}, ${sep}) - 1)`;
+  const base = `replace(${file}, rtrim(${file}, replace(${file}, ${sep}, '')), '')`;
   const dir = `substr(${file}, 1, length(${file}) - length(${base}) - 1)`;
-  const dirBase = `replace(${dir}, rtrim(${dir}, replace(${dir}, '/', '')), '')`;
-  return `CASE WHEN ${marker} > 0 THEN ${seg} ELSE ${dirBase} END`;
+  const dirBase = `replace(${dir}, rtrim(${dir}, replace(${dir}, ${sep}, '')), '')`;
+  return `CASE WHEN ${at} > 0 THEN ${seg} ELSE ${dirBase} END`;
 }
 
 /** Every column a query reads, mapped to the store's schema in one place. */
@@ -825,16 +831,18 @@ function foldTraces(rows: AgentTraceRow[]): AgentTraceRow[] {
     .toSorted((a, b) => b.lastTs - a.lastTs);
 }
 
-/** The root session file for a transcript, which is itself when it is already a root. */
+/** The root session file for a transcript, which is itself when it is already a root.
+ * Splits on whichever separator the stored path uses: a Windows run writes `\`. */
 export function rootSessionFile(sessionFile: string): string {
-  const marker = '/sessions/';
+  const marker = sessionFile.includes('/sessions/') ? '/sessions/' : '\\sessions\\';
   const at = sessionFile.indexOf(marker);
   if (at < 0) return sessionFile;
   const base = sessionFile.slice(0, at + marker.length);
-  const parts = sessionFile.slice(at + marker.length).split('/');
+  const parts = sessionFile.slice(at + marker.length).split(marker[0]);
   // `<project>/<root>.jsonl` is a root; `<project>/<root>/<child>.jsonl` belongs to that root.
   if (parts.length < 3) return sessionFile;
-  return `${base}${parts[0]}/${parts[1]}.jsonl`;
+  // Rejoined with the same separator, so a child's root matches its root file exactly.
+  return `${base}${parts[0]}${marker[0]}${parts[1]}.jsonl`;
 }
 
 /** Same normalization as the reference: ids and counters collapse, an HTTP status does not. */
@@ -1304,7 +1312,8 @@ const AGENT_TOOLS = new Set(['task', 'subagent']);
 
 /** One transcript as spans, tracks and markers: a model span runs `ts - duration` to `ts`. */
 export function readSessionTrace(sessionFile: string, limit = TRACE_SPAN_LIMIT): AgentSessionTrace {
-  const project = sessionFile.split('/sessions/')[1]?.split('/')[0] ?? '';
+  // Either separator: a Windows host writes `<drive>\...\.omp\agent\sessions\<project>\<file>`.
+  const project = sessionFile.split(/[/\\]sessions[/\\]/)[1]?.split(/[/\\]/)[0] ?? '';
   const empty: AgentSessionTrace = {
     sessionFile, project, title: '', cwd: project, startedAt: 0, endedAt: 0,
     tracks: [], markers: [], summary: emptyTraceSummary(), toolStats: [], truncated: false,

package/extensions/shared/pricing.ts

@@ -105,16 +105,18 @@ function asPrice(v: unknown): ModelPrice | null {
   return null;
 }
 
-let liveCache: { path: string; mtime: number; prices: LivePrices } | null = null;
+let liveCache: { path: string; mtime: number; size: number; prices: LivePrices } | null = null;
 
 export function loadLivePrices(): LivePrices | null {
-  // One stat per call beats one full parse: the recent-rows map prices thousands of rows.
+  // One stat per call beats a full parse; the key carries size and mtime, because Windows rounds a rapid rewrite's mtime to one value.
   try {
     const file = pricesCachePath();
-    const mtime = fs.statSync(file).mtimeMs;
-    if (liveCache && liveCache.path === file && liveCache.mtime === mtime) return liveCache.prices;
+    const stat = fs.statSync(file);
+    if (liveCache && liveCache.path === file && liveCache.mtime === stat.mtimeMs && liveCache.size === stat.size) {
+      return liveCache.prices;
+    }
     const prices = readLivePrices();
-    if (prices) liveCache = { path: file, mtime, prices };
+    if (prices) liveCache = { path: file, mtime: stat.mtimeMs, size: stat.size, prices };
     return prices;
   } catch {
     return null;

package/extensions/shared/rtk-eligible.ts

@@ -1,11 +1,8 @@
-// Eligible command heads, taken from rtk's own contract rather than a hardcoded guess.
-// `rtk rewrite <probe>` prints a rewrite and exits 0 or 3 when rtk handles the command,
-// and exits 1 when no equivalent exists. Each probe below is a representative workload
-// command, because subcommand-scoped tools such as `gh` rewrite `gh pr list` but not `gh`.
+// Eligible heads come from rtk's own contract: `rtk rewrite <probe>` exits 0 or 3 when rtk handles the command, 1 when it has no equivalent.
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizeRtkVersion, tersioDataPath } from './utils.ts';
+import { normalizeRtkVersion, shimCommand, tersioDataPath } from './utils.ts';
 
 /** Verified against rtk 1.0.1; the drift test fails when rtk's set moves. */
 export const FALLBACK_ELIGIBLE_HEADS: readonly string[] = [
@@ -33,7 +30,8 @@ const PROBES: Record<string, string> = {
 
 function probe(bin: string, command: string): boolean {
   try {
-    const out = execFileSync(bin, ['rewrite', command], { encoding: 'utf8', timeout: 5000, windowsHide: true });
+    const shim = shimCommand(bin, ['rewrite', command]);
+    const out = execFileSync(shim.cmd, shim.args, { encoding: 'utf8', timeout: 5000, windowsHide: true });
     return out.trim().length > 0;
   } catch (e) {
     // Non-zero exit throws; exit 3 still prints a rewrite, exits 1 and 2 do not.
@@ -54,16 +52,14 @@ export function deriveEligibleHeads(bin: string): Set<string> {
 
 function rtkVersion(bin: string): string {
   try {
-    return normalizeRtkVersion(execFileSync(bin, ['--version'], { encoding: 'utf8', timeout: 5000, windowsHide: true }));
+    const shim = shimCommand(bin, ['--version']);
+    return normalizeRtkVersion(execFileSync(shim.cmd, shim.args, { encoding: 'utf8', timeout: 5000, windowsHide: true }));
   } catch {
     return '';
   }
 }
 
-/**
- * Heads rtk rewrites, cached per binary version so an upgrade re-derives once.
- * Without a binary, or on any read failure, the verified fallback stands.
- */
+/** Heads rtk rewrites, cached per binary version; without a binary, or on any read failure, the verified fallback stands. */
 export function eligibleHeads(bin: string | null): ReadonlySet<string> {
   if (!bin) return new Set(FALLBACK_ELIGIBLE_HEADS);
   const version = rtkVersion(bin);

package/extensions/shared/rtk-gain.ts

@@ -1,7 +1,7 @@
 // Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK_GUIDE.md.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { rtkDirs } from './utils.ts';
 import { sqliteRead } from './sqlite.ts';
 
 export interface RtkCommandRow {
@@ -32,11 +32,7 @@ const CMD_ONE_LINE = `replace(replace(replace(rtk_cmd, char(10), ' '), char(13),
 export function rtkDbPath(): string {
   const override = process.env.TERSIO_RTK_DB;
   if (override) return override;
-  if (process.platform === 'darwin') {
-    return path.join(os.homedir(), 'Library', 'Application Support', 'rtk', 'history.db');
-  }
-  const xdg = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
-  return path.join(xdg, 'rtk', 'history.db');
+  return path.join(rtkDirs().data, 'history.db');
 }
 
 function query(db: string, sql: string): string[][] {

package/extensions/shared/sqlite.ts

@@ -1,9 +1,4 @@
-// One place that runs SQL against a database file. Bun and Node 22.5+ carry SQLite in process, so the
-// `sqlite3` binary is a fallback: hosts without it kept silently reading nothing. Reads return the sqlite3
-// CLI shape (one row per line, cells tab-joined, NULL an empty cell) because every caller parses that.
-// The write path leaves the journal mode alone: the schema sets WAL so a reader never blocks a writer,
-// and the pragma needs exclusive access, so with a reader holding the file it fails after the caller's
-// rows have already committed (see docs/ERRORS.md).
+// One place that runs SQL: Bun or Node 22.5+ in process, the `sqlite3` binary as the fallback, and rows in its CLI shape for every caller. The write path leaves the journal mode alone (see docs/ERRORS.md).
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';