@manyoars/oars 0.3.0 → 0.4.1

package/dist/sessions/schema.d.ts

@@ -1,12 +1,13 @@
 import type { CanonicalAction } from './actions.js';
+import type { ArgClass, TargetClass } from './call-shape.js';
 import type { RepoSize } from './public-vocabulary.js';
 import type { SessionFunnel, SessionSetup, SessionTrust } from './session-shape.js';
 /** Stamped `cv` on every captured record. Bump it when the captured field list changes or a stored value of an existing captured record or skeleton changes: a bump re-reads every transcript. */
-export declare const CAPTURE_VERSION = "17";
+export declare const CAPTURE_VERSION = "25";
 /** Capture versions the reader derives from. A version-3 record is upgraded on read; a newer one is read for the fields this code knows. */
 export declare const OLDEST_READABLE_CAPTURE = 3;
 /** Stamped `v` on every derived record. A bump re-derives from the log; no transcript is read. */
-export declare const EXTRACTOR_VERSION = "12";
+export declare const EXTRACTOR_VERSION = "15";
 export declare const PROMPT_HEAD_CHARS = 300;
 export declare const ERROR_EXAMPLE_CHARS = 160;
 /** The reference scripts cut a normalized signature at 110 characters. */
@@ -15,6 +16,12 @@ export declare const SIGNATURE_CHARS = 110;
 export declare const ERROR_LINE_CHARS = 1000;
 /** Per-session cap on `files` and `fileHashes` (L3): the hand run on the copy store had p99 61 and max 209 files per session; 100 is the round number above p99. */
 export declare const FILES_PER_SESSION_MAX = 100;
+/**
+ * What the next human prompt did to a prompt's work (t882, `docs/sessions-store.md` "Prompt intervention"): a closed list, not a grade. `user-stop` (EXTRACTOR 14) is a prompt the human stopped: a rejected call, or an interrupt. `unknown` is a prompt the records cannot say anything about (the last of its
+ * transcript, or one whose next prompt ran a shell call captured before `segments`); a prompt derived before EXTRACTOR 13 has no value at all, which is a different thing, and one derived at 13 read a stop as `unknown`.
+ */
+export declare const PROMPT_INTERVENTIONS: readonly ["none", "after-error", "redo", "revert", "user-stop", "unknown"];
+export type PromptIntervention = (typeof PROMPT_INTERVENTIONS)[number];
 export declare const PROMPT_CLASSES: readonly ["no-tools", "orchestration", "research", "edit-verify", "edit-only", "explore-only", "shell-only", "mixed"];
 export type PromptClass = (typeof PROMPT_CLASSES)[number];
 /** The statuses agents recover from differently (pool vocabulary spec Section 7); any other status is `other`. */
@@ -32,7 +39,14 @@ export interface Usage {
     output: number;
     thinking: number;
 }
-export type Harness = 'claude-code' | 'cursor' | 'codex' | 'copilot' | 'gemini' | 'grok' | 'vscode-copilot';
+/** The five usage categories, in the order a record lists the ones it observed. */
+export declare const USAGE_FIELDS: readonly ["input", "cacheWrite", "cacheRead", "output", "thinking"];
+export type UsageField = (typeof USAGE_FIELDS)[number];
+/** Whether a stored session or prompt recorded `field`. A record with no `usageObserved` was captured before version 20, when every category read as observed. */
+export declare const observesUsage: (record: {
+    usageObserved?: readonly UsageField[];
+}, field: UsageField) => boolean;
+export type Harness = 'claude-code' | 'cursor' | 'codex' | 'copilot' | 'gemini' | 'grok' | 'opencode' | 'pi' | 'vscode-copilot' | 'otel';
 /** The harness a session record came from; a record that does not name one is Claude Code's. */
 export declare const harnessOf: (session: {
     harness?: Harness;
@@ -171,6 +185,14 @@ export interface SessionObservation {
     costUsd: number | null;
     /** Summed assistant usage of the file's own line (a main transcript's sidechain lines are not counted; a subagent transcript is its own line). */
     usage: Usage;
+    /**
+     * Which `usage` categories at least one counted response reported (class P). A category not listed was never recorded by the source, so its `usage` number is a
+     * placeholder zero and not a measurement; a listed one is a sum over `usageResponses` responses, which a partial sum covers only in part. Absent on a record captured
+     * before version 20: every category reads as observed there.
+     */
+    usageObserved?: UsageField[];
+    /** How many responses reported any usage (class P); compare with `assistantTurns` or `turns` for the share a sum covers. Same absence rule as `usageObserved`. */
+    usageResponses?: number;
     /** What the transcript shows of the setup the session ran with (class A); absent when it shows none, and on a record captured before version 12. */
     setup?: SessionSetup;
     /** The tool names at each funnel stage the transcript shows (class A); same absence rules. */
@@ -188,7 +210,7 @@ export type PromptStop = 'interrupt' | 'rejected';
 /**
  * One per user prompt: the `prompt_graphs.py` and `cost_per_class.py` records joined. Derived. Classes: `session`,
  * `contextFingerprint`, `frame`, `head`, `ts`, `skills`, `verify`, `stopped`, `commits`, and `redo` (A); `kind`, `v`, `rev`, `index`, `wallSec`, `cls`, `tools`,
- * `shape`, `errors`, `thinking`, `sideTools`, `turns`, `model`, `efforts`, `usage`, `recovery`, `explore`, `act`, and `bigrams` (P).
+ * `shape`, `errors`, `thinking`, `sideTools`, `turns`, `model`, `efforts`, `usage`, `recovery`, `explore`, `act`, `bigrams`, and `intervention` (P).
  */
 export interface PromptObservation {
     kind: 'prompt';
@@ -216,6 +238,9 @@ export interface PromptObservation {
     efforts: string[];
     skills: string[];
     usage: Usage;
+    /** Carried from the capture record: the categories and response count the prompt's `usage` rests on (see `UserPromptObservation`). */
+    usageObserved?: UsageField[];
+    usageResponses?: number;
     /** The two tools after the first error of each error run (the recovery pair); empty when no error. */
     recovery: string[];
     explore: number;
@@ -235,6 +260,8 @@ export interface PromptObservation {
     commits?: number;
     /** A later prompt edited a path this one edited, within `REDO_WINDOW` prompts, with no commit `commits` can see between them. */
     redo?: boolean;
+    /** Whether a human stepped in after this prompt's work, and how (EXTRACTOR 13): what the next prompt did, never a grade. Absent on a prompt derived earlier. Class P: a member of a closed list. */
+    intervention?: PromptIntervention;
 }
 /**
  * One per tool error: the `error_signatures.py` record. Derived. Classes: `session`, `agent`, `ts`, `sig`, `example` (A); `kind`, `v`,
@@ -268,7 +295,7 @@ export interface ErrorObservation {
     agent?: string;
 }
 export type ToolStatus = 'ok' | 'error' | 'none';
-/** A package a shell step pulled, in public names (`<literal>` outside the allowlist). */
+/** A package a shell step pulled. The package name is kept as it is after redaction (`<literal>` when redaction changes it, it is not a name, or it is over 128 characters); the registry is a public name. */
 export interface PullIdentity {
     registry: string;
     name: string;
@@ -280,6 +307,11 @@ export interface ShellIdentity {
     program: string;
     sub: string | null;
     flags: string[];
+    /**
+     * Only on `git checkout` (CAPTURE 23), the class of what it acts on and never the target's text: `path` where the line proves a path (a `--` marker, or a flag that only takes
+     * paths), `word` where a target word the segment drops (a slash, quotes) stands with no such proof, so it is a branch or a path and the line cannot say which. Absent with no such word.
+     */
+    target?: 'path' | 'word';
     /** Absent when the command pulled nothing. */
     pulls?: PullIdentity[];
 }
@@ -295,6 +327,8 @@ export interface StepCost {
     /** The output tokens of the call's response, shared evenly among that response's calls; null when it reported none. */
     tokens: number | null;
     durationMs: number | null;
+    /** True when `tokens` was divided among the response's calls, not measured for this call; absent when the response made one call. */
+    allocated?: true;
 }
 /**
  * How a step came about (recall spec Section 2.3), naming the step it came from by position. `next`: order within a prompt's line of work.
@@ -315,7 +349,7 @@ export interface StepObservation {
     action: CanonicalAction;
     /** The harness's own name for the tool when the action table lists it or every name it holds is public, else `<literal>` (the tool record keeps it, class A). */
     native: string;
-    /** What the step acted on, in public names only; null for an action that has none (a file's path never appears here). */
+    /** What the step acted on; a skill-run name, host, and pull name are kept as they are after redaction (`<literal>` when redaction changes them, they are not names, or they are over 128 characters), and every other name is public or `<literal>`. Null for an action that has none (a file's path never appears here). */
     identity: StepIdentity;
     /** The call's status when it reports this segment; `none` for a segment it does not, such as one a pipe hides. */
     status: ToolStatus;
@@ -361,17 +395,25 @@ export interface ToolObservation {
     targetBase: TargetBase | null;
     /** The input's key names, sorted. Class A (EXTRACTOR 11). */
     keys: string[];
+    /** The class of the call's path target (`targetClassOf`): a member of `TARGET_CLASSES`, `none` for a call with no path target. Absent on a record captured before CAPTURE 22. Class P: a closed list, never the path or its base name. */
+    targetClass?: TargetClass;
+    /** The classes of the call's arguments (`argClassOf`), a sorted set of `ARG_CLASSES` members, `['none']` for a call with no argument value. Absent on a record captured before CAPTURE 22. Class P: never a value. */
+    argClass?: ArgClass[];
     /** The class of a failed call (`errorCodeOf`): a member of `ERROR_CODES`, never result text. Absent on a call that did not fail and on a record captured before CAPTURE 14. Class P. */
     errorCode?: string;
     /** From the call's line to its first result's line; null when either timestamp is missing or no result is in the file. */
     durationMs: number | null;
     toolUseId: string | null;
     harnessVersion: string | null;
+    /** The model the call's own line names (`requestedModel`, else the message's model), so a step is attributed to the model that made it and not only to its prompt's majority (t867). Absent when the line names none and on a record captured before it. Class P, like the prompt's. */
+    model?: string;
+    /** The skill whose run the call's line sits in (`attributionSkill`): the harness stops naming it on the first line after the run, so that is where a run ends. Absent outside a run and on an earlier record. Class A, since a skill's name can be private. */
+    skill?: string;
     /** A sidechain line inside a main transcript. */
     side: boolean;
     /** The prompt index the call ran under; null before the first prompt. */
     prompt: number | null;
-    /** What the call was in the canonical vocabulary; absent on a record captured before this field existed. Class P. */
+    /** What the call was in the canonical vocabulary; absent on a record captured before this field existed. Class A since CAPTURE 24: a step identity's skill-run name, host, and pull name are kept as they are after redaction and can be private; class P before. */
     steps?: StepObservation[];
     /** Each command of a shell call, in order (CAPTURE 6); on every shell call and no other. Absent on a record captured earlier. */
     segments?: ShellSegment[];
@@ -457,6 +499,14 @@ export interface UserPromptObservation {
     efforts: string[];
     skills: string[];
     usage: Usage;
+    /**
+     * Which `usage` categories at least one counted response reported (class P). A category not listed was never recorded by the source, so its `usage` number is a
+     * placeholder zero and not a measurement; a listed one is a sum over `usageResponses` responses, which a partial sum covers only in part. Absent on a record captured
+     * before version 20: every category reads as observed there.
+     */
+    usageObserved?: UsageField[];
+    /** How many responses reported any usage (class P); compare with `assistantTurns` or `turns` for the share a sum covers. Same absence rule as `usageObserved`. */
+    usageResponses?: number;
     /** Class A: the session's prompt fingerprint at the time of the prompt, when one had been seen. */
     promptFingerprint: string | null;
     /** Where and when this prompt ran; absent on a record captured before this field existed. Class A (EXTRACTOR 11): its fields pool only as cells. */
@@ -590,7 +640,7 @@ export interface RecallCall {
 /** One hook invocation, appended to `hook-calls.jsonl` by the hook itself; `measure` counts these per session. Class A: `session`, `at`, `error`; P: `event`, `hit`, `ms`, `startMs`. */
 export interface HookCall {
     at: string;
-    event: 'session-start' | 'pre-tool' | 'post-tool' | 'stop' | 'nightly';
+    event: 'session-start' | 'prompt' | 'pre-tool' | 'post-tool' | 'stop' | 'nightly';
     /** The Claude Code session the hook ran in; null for the nightly run. */
     session: string | null;
     /** Whether the hook had something to say (an injected block, a recall hit, or a session deposited). */
@@ -606,7 +656,7 @@ export interface HookCall {
 export declare const STEPS: readonly ["deposit", "verify", "derive", "label", "index", "recall", "read"];
 export type Step = (typeof STEPS)[number];
 /** The trigger names of spec 4.1 (the ones nothing local starts are in the schema only: `weekly` (A21) and the hosted `sync`, `cron`, `release`, `run-end`, and `run-start`). The SessionEnd hook is `stop`, never `session-end`. */
-export declare const TRIGGERS: readonly ["session-start", "pre-tool", "post-tool", "stop", "nightly", "manual", "weekly", "sync", "cron", "release", "run-end", "run-start"];
+export declare const TRIGGERS: readonly ["session-start", "prompt", "pre-tool", "post-tool", "stop", "nightly", "manual", "weekly", "sync", "cron", "release", "run-end", "run-start"];
 export type Trigger = (typeof TRIGGERS)[number];
 /** `deferred`: a Stop deposit that found the store locked and recorded its session in the pending list. It is neither a success nor a failed run. */
 export declare const STEP_STATUSES: readonly ["ok", "error", "skipped", "deferred"];

package/dist/sessions/schema.js

@@ -30,6 +30,16 @@
 // reads, not moved ones. A Copilot CLI session with rotated `events.N.jsonl` archives is now read as one session, so its `prompts`, `tools`, `lines`, and skeleton move; one
 // with no archives is unchanged. EXTRACTOR stays 11. A version-16 store's next deposit captures every transcript again from the harness or `raw/`.
 //
+// Version 24 (CAPTURE 24, t903) changes three stored values and no field name: a step identity's skill-run name, host, and pull's package name are kept as they are after the operator's redaction (`redactDomains`, the secret and email patterns, the name shape, and the 128-character cap still apply; the operator's exclusion terms are applied at the deposit's gate, not at capture), where before each was `<literal>` unless a public list held it. A store opened at version 23 or older keeps its `<literal>` values until its next deposit captures every transcript again from the harness or `raw/`; the tool record's `steps` moves from class P to class A because those names can be private.
+//
+// Version 23 (CAPTURE 23) keeps a `git checkout` step's target class, `target` `path` or `word` (never the target's text), so the `revert` rule can tell `git checkout -- src/a.ts` and `git checkout --ours src/a.ts` (a
+// path) from `git checkout feature/x` (a branch or a path). It also writes a Codex `turn_aborted` with reason `interrupted` as the interrupt marker user line, so that prompt record exists and the session's
+// `prompts`, `tsLast` (the marker is a line), and skeleton move; a Codex session with no such turn is unchanged. A `git checkout` step captured before reads as it did (no `target`). EXTRACTOR 15 reads a Codex or Gemini decline in its fixed text as `user-stop`.
+//
+// Version 22 (CAPTURE 22, t870) adds the optional `targetClass` and `argClass` to a tool call (`call-shape.ts`): the class of its path target (`source`, `test`, `config`, `doc`, `lockfile`, `generated`, `data`, `none`, `other`) and the sorted set
+// of the classes of its arguments (`path`, `url`, `pattern`, `command`, `number`, `flag`, `text`, `none`), each computed from the path and the input at capture and stored as a closed-list member, never the path or a value. It changes no value
+// captured before, so EXTRACTOR stays 12; a version-21 store's next deposit captures every transcript again, and a call of an older record has neither field.
+//
 // EXTRACTOR 12 gives a derived prompt the strata of its user-prompt record, so its own `explore` count reaches the pool's wire as a bucket. No transcript is read: a store at
 // 11 re-derives from its log alone.
 //
@@ -78,11 +88,11 @@
 // harness versions, and tool names (an MCP name's part after its prefix is redacted). `redact` masks secrets by pattern and entropy, emails, and the
 // organization domains the operator names. The skeleton holds hashes only.
 /** Stamped `cv` on every captured record. Bump it when the captured field list changes or a stored value of an existing captured record or skeleton changes: a bump re-reads every transcript. */
-export const CAPTURE_VERSION = '17';
+export const CAPTURE_VERSION = '25';
 /** Capture versions the reader derives from. A version-3 record is upgraded on read; a newer one is read for the fields this code knows. */
 export const OLDEST_READABLE_CAPTURE = 3;
 /** Stamped `v` on every derived record. A bump re-derives from the log; no transcript is read. */
-export const EXTRACTOR_VERSION = '12';
+export const EXTRACTOR_VERSION = '15';
 export const PROMPT_HEAD_CHARS = 300;
 export const ERROR_EXAMPLE_CHARS = 160;
 /** The reference scripts cut a normalized signature at 110 characters. */
@@ -91,6 +101,11 @@ export const SIGNATURE_CHARS = 110;
 export const ERROR_LINE_CHARS = 1000;
 /** Per-session cap on `files` and `fileHashes` (L3): the hand run on the copy store had p99 61 and max 209 files per session; 100 is the round number above p99. */
 export const FILES_PER_SESSION_MAX = 100;
+/**
+ * What the next human prompt did to a prompt's work (t882, `docs/sessions-store.md` "Prompt intervention"): a closed list, not a grade. `user-stop` (EXTRACTOR 14) is a prompt the human stopped: a rejected call, or an interrupt. `unknown` is a prompt the records cannot say anything about (the last of its
+ * transcript, or one whose next prompt ran a shell call captured before `segments`); a prompt derived before EXTRACTOR 13 has no value at all, which is a different thing, and one derived at 13 read a stop as `unknown`.
+ */
+export const PROMPT_INTERVENTIONS = ['none', 'after-error', 'redo', 'revert', 'user-stop', 'unknown'];
 export const PROMPT_CLASSES = ['no-tools', 'orchestration', 'research', 'edit-verify', 'edit-only', 'explore-only', 'shell-only', 'mixed'];
 /** The statuses agents recover from differently (pool vocabulary spec Section 7); any other status is `other`. */
 export const HTTP_STATUSES = ['400', '401', '403', '404', '408', '409', '413', '429', '500', '502', '503', '504', '529'];
@@ -100,6 +115,10 @@ export const EXIT_CLASSES = ['0', '1', '2', '126', '127', 'signal'];
 export const HARNESS_ERROR_CLASSES = ['user-rejected', 'interrupted', 'permission-denied', 'input-validation', 'tool-use-error', 'timeout'];
 /** The `errorCode` of a failed call (class P): a member of this set, never text from the result. `other` covers an exit status or HTTP status outside the lists, and a failure that names no class. */
 export const ERROR_CODES = new Set([...EXIT_CLASSES, ...HTTP_STATUSES, ...HARNESS_ERROR_CLASSES, 'other']);
+/** The five usage categories, in the order a record lists the ones it observed. */
+export const USAGE_FIELDS = ['input', 'cacheWrite', 'cacheRead', 'output', 'thinking'];
+/** Whether a stored session or prompt recorded `field`. A record with no `usageObserved` was captured before version 20, when every category read as observed. */
+export const observesUsage = (record, field) => record.usageObserved === undefined || record.usageObserved.includes(field);
 /** The harness a session record came from; a record that does not name one is Claude Code's. */
 export const harnessOf = (session) => session.harness ?? 'claude-code';
 /** A language's share of the files a transcript touched (pool vocabulary spec Section 7): none, incidental, secondary, primary. The lower edge is inclusive, so 10 percent is secondary and 50 is primary. */
@@ -109,7 +128,7 @@ export const REPO_FILE_BUCKETS = ['under-100', '100-1k', '1k-10k', '10k-100k', '
 /** The pipeline steps the log names (runtime-commons pipeline spec 3.1); `label` is the local labeler step (A5) that no command runs yet; `index` is the hook-index write the nightly and manual runs log. */
 export const STEPS = ['deposit', 'verify', 'derive', 'label', 'index', 'recall', 'read'];
 /** The trigger names of spec 4.1 (the ones nothing local starts are in the schema only: `weekly` (A21) and the hosted `sync`, `cron`, `release`, `run-end`, and `run-start`). The SessionEnd hook is `stop`, never `session-end`. */
-export const TRIGGERS = ['session-start', 'pre-tool', 'post-tool', 'stop', 'nightly', 'manual', 'weekly', 'sync', 'cron', 'release', 'run-end', 'run-start'];
+export const TRIGGERS = ['session-start', 'prompt', 'pre-tool', 'post-tool', 'stop', 'nightly', 'manual', 'weekly', 'sync', 'cron', 'release', 'run-end', 'run-start'];
 /** `deferred`: a Stop deposit that found the store locked and recorded its session in the pending list. It is neither a success nor a failed run. */
 export const STEP_STATUSES = ['ok', 'error', 'skipped', 'deferred'];
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

package/dist/sessions/session-shape.d.ts

@@ -4,12 +4,15 @@ type Obj = {
 };
 /** The harness's tool-rejection results, both worded for the operator declining: a classifier or hook denial is policy, and the model carries on. */
 export declare const REJECTED_RE: RegExp;
-/** The harness writes this as a user line when the operator cut a turn short; a rejection is followed by it too, so it is not a second interrupt. */
+/** The harness writes this as a user line when the operator cut a turn short; a rejection is followed by it too, so it is not a second interrupt. The Codex reader writes it for a `turn_aborted` with reason `interrupted` (CAPTURE 23). */
 export declare const INTERRUPT_MARKER = "[Request interrupted by user";
+/**
+ * A decline in the fixed text Codex or Gemini CLI writes for a call the operator refused: Codex's `exec command rejected by user` and `patch rejected by user` (events.rs:456-457), and Gemini's `[Operation Cancelled]`
+ * followed by a user cancel or denial. The text is the whole match, never a guess from other wording; `errorCodeOf` classes the same lines `user-rejected`, and the `user-stop` bucket reads them (EXTRACTOR 15).
+ */
+export declare const DECLINED_RE: RegExp;
 /** An adapter's neutral line naming tools: `offered` and `loaded` are arrays of tool names. */
 export declare const SHAPE_TOOLS_LINE = "oars-tools";
-/** An adapter's neutral line for a turn the operator cut short, for a harness whose record is not a Claude marker line. */
-export declare const SHAPE_INTERRUPT_LINE = "oars-interrupt";
 export type TrustEventKind = 'interrupt' | 'rejection' | 'denial';
 /** One stop, with the tool in flight (null when none is known) and the prompt it fell in (null before the first). */
 export interface TrustEvent {

package/dist/sessions/session-shape.js

@@ -4,14 +4,19 @@
 // here is projected or uploaded.
 //
 // One collector per transcript, fed line by line by `captureSession`. It reads the Claude Code line shapes (a census of 2.1.312 to 2.1.318) and
-// two neutral lines an adapter may write for a harness whose records are not Claude-shaped (`oars-tools`, `oars-interrupt`).
+// one neutral line an adapter may write for a harness whose records are not Claude-shaped (`oars-tools`).
 const isObj = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const str = (value) => (typeof value === 'string' ? value : undefined);
 const names = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item !== '') : []);
 /** The harness's tool-rejection results, both worded for the operator declining: a classifier or hook denial is policy, and the model carries on. */
 export const REJECTED_RE = /^The user doesn't want to (?:proceed with this tool use|take this action)/;
-/** The harness writes this as a user line when the operator cut a turn short; a rejection is followed by it too, so it is not a second interrupt. */
+/** The harness writes this as a user line when the operator cut a turn short; a rejection is followed by it too, so it is not a second interrupt. The Codex reader writes it for a `turn_aborted` with reason `interrupted` (CAPTURE 23). */
 export const INTERRUPT_MARKER = '[Request interrupted by user';
+/**
+ * A decline in the fixed text Codex or Gemini CLI writes for a call the operator refused: Codex's `exec command rejected by user` and `patch rejected by user` (events.rs:456-457), and Gemini's `[Operation Cancelled]`
+ * followed by a user cancel or denial. The text is the whole match, never a guess from other wording; `errorCodeOf` classes the same lines `user-rejected`, and the `user-stop` bucket reads them (EXTRACTOR 15).
+ */
+export const DECLINED_RE = /^(?:(?:exec command|patch) rejected by user\s*$|\[Operation Cancelled\] (?:Reason: )?(?:User (?:cancelled|denied)|Operation cancelled by user))/;
 /** A policy refusal: the permission rules or the auto-mode classifier (`Permission ... has been denied`), or a hook (`PreToolUse:Bash hook error`). Not the human's. */
 const DENIED_RE = /^(?:Permission (?:to use .{1,200}?|for this action) has been denied|[A-Za-z]+:[^\s]+ hook error|Hook [A-Za-z]+:[^\s]+ denied)/;
 /** A plugin's MCP server names its tools `mcp__plugin_<plugin>_<server>__<tool>`; that is the only evidence of an installed plugin read here.
@@ -21,8 +26,6 @@ const PLUGIN_TOOL_RE = /^mcp__plugin_([A-Za-z0-9-]+)_/;
 const STOP_HOOK_RE = /^Stop(?::|$)/;
 /** An adapter's neutral line naming tools: `offered` and `loaded` are arrays of tool names. */
 export const SHAPE_TOOLS_LINE = 'oars-tools';
-/** An adapter's neutral line for a turn the operator cut short, for a harness whose record is not a Claude marker line. */
-export const SHAPE_INTERRUPT_LINE = 'oars-interrupt';
 /** The permission modes each harness documents; any other value is stored as `other` (spec row `permissionMode`). Keyed by harness so a new one must add its entry. */
 const PERMISSION_MODES = {
     'claude-code': new Set(['default', 'acceptEdits', 'plan', 'auto', 'dontAsk', 'bypassPermissions']),
@@ -35,6 +38,12 @@ const PERMISSION_MODES = {
     cursor: new Set(),
     // Grok Build's reader reads no mode (its `current_mode_update` carries one, but this reader does not read it), so no value is documented to keep.
     grok: new Set(),
+    // OpenCode's reader reads no permission mode (a session records the agent, not a mode), so no value is documented to keep.
+    opencode: new Set(),
+    // Pi has no permission modes: its tools run as the user, and a session records none.
+    pi: new Set(),
+    // A trace carries no permission mode.
+    otel: new Set(),
 };
 /**
  * Which trust counts a harness's transcript records completely. A zero is stored only where the harness would have shown the event; where it would not,
@@ -52,6 +61,12 @@ const COMPLETE = {
     cursor: { interrupts: false, rejections: false, denials: false, timing: false },
     // Grok Build's reader writes the prompts and replies with their line times (seconds), and reads no cancel, tool refusal, or hook denial.
     grok: { interrupts: false, rejections: false, denials: false, timing: true },
+    // OpenCode's reader writes each message with its own time (so the runs are real) and reads no interrupt, refusal, or denial: a refused or aborted tool is an error state with a message.
+    opencode: { interrupts: false, rejections: false, denials: false, timing: true },
+    // Pi's reader writes the prompts and the responses with their entry times, and reads no interrupt, refusal, or denial: an aborted call is a tool error and no more.
+    pi: { interrupts: false, rejections: false, denials: false, timing: true },
+    // A trace's spans carry their own start and end times; it records no interrupt, refusal, or denial count.
+    otel: { interrupts: false, rejections: false, denials: false, timing: true },
 };
 const firstText = (content) => {
     if (typeof content === 'string')
@@ -217,8 +232,6 @@ export const createShape = (harness, stored, options) => {
                 offer(names(line.offered));
                 load(names(line.loaded));
             }
-            else if (type === SHAPE_INTERRUPT_LINE)
-                interrupt(inFlight(), at.prompt);
             else if (type === 'attachment') {
                 if (isObj(line.attachment))
                     attachment(line.attachment);

package/dist/sessions/sources.js

@@ -7,6 +7,9 @@ import { copilotRoot, openCopilotStore } from './copilot.js';
 import { cursorRoot, openCursorStore } from './cursor.js';
 import { grokRoot, openGrokStore } from './grok.js';
 import { geminiRoot, openGeminiStore } from './gemini.js';
+import { openPiStore, piRoot } from './pi.js';
+import { openOtelStore, otelRoot } from './otel.js';
+import { opencodeRoot, openOpencodeStore } from './opencode.js';
 import { openVscodeCopilotStore, vscodeAppData } from './vscode-copilot.js';
 /** A session handed back to its own store was listed by it, so a miss is a bug in the caller. */
 const need = (value) => {
@@ -132,6 +135,54 @@ const grok = {
         };
     },
 };
+const opencode = {
+    name: 'opencode',
+    harness: 'opencode',
+    label: 'OpenCode',
+    root: (_platform, env, home) => opencodeRoot(env, home),
+    storeFile: (root) => join(root, 'opencode.db'),
+    open: async (root) => {
+        const store = await openOpencodeStore(root);
+        if (store === undefined)
+            return undefined;
+        const byId = new Map(store.sessions.map((session) => [session.id, session]));
+        return {
+            sessions: store.sessions.map((session) => ({
+                id: session.id,
+                folder: session.folder,
+                size: session.size,
+                mtimeMs: session.mtimeMs,
+                ...(session.parent === null ? {} : { subagent: { parent: `opencode-${session.parent}`, agentType: session.agent, spawnedBy: null } }),
+            })),
+            transcript: (session) => store.transcript(need(byId.get(session.id))),
+            rejected: store.rejected,
+            unreadable: [],
+            where: () => join(root, 'opencode.db'),
+            close: store.close,
+        };
+    },
+};
+const pi = {
+    name: 'pi',
+    harness: 'pi',
+    label: 'Pi',
+    root: (_platform, env, home) => piRoot(env, home),
+    storeFile: (root) => join(root, 'sessions'),
+    open: async (root) => {
+        const store = await openPiStore(root);
+        if (store === undefined)
+            return undefined;
+        const byId = new Map(store.sessions.map((session) => [session.id, session]));
+        return {
+            sessions: store.sessions.map((session) => ({ id: session.id, folder: session.folder, size: session.size, mtimeMs: session.mtimeMs })),
+            transcript: async (session) => await store.transcript(need(byId.get(session.id))),
+            rejected: store.rejected,
+            unreadable: store.unreadable,
+            where: (session) => byId.get(session.id)?.file ?? root,
+            close: () => undefined,
+        };
+    },
+};
 const vscodeCopilot = {
     name: 'vscode-copilot',
     harness: 'vscode-copilot',
@@ -153,7 +204,30 @@ const vscodeCopilot = {
         };
     },
 };
+// A folder of OTLP JSON trace files (`$OARS_OTEL_TRACES`, else the config folder's `otel-traces`): a configured folder rather than an `import` command, so the cursor, the
+// allowlist, the nightly run, and the fail-open reads are the ones every other source has.
+const otel = {
+    name: 'otel',
+    harness: 'otel',
+    label: 'OpenTelemetry GenAI',
+    root: (platform, env, home) => otelRoot(env, home, platform),
+    storeFile: (root) => root,
+    open: async (root) => {
+        const store = await openOtelStore(root);
+        if (store === undefined)
+            return undefined;
+        const byId = new Map(store.sessions.map((session) => [session.id, session]));
+        return {
+            sessions: store.sessions.map((session) => ({ id: session.id, folder: session.folder, size: session.size, mtimeMs: session.mtimeMs, ...(session.subagent === undefined ? {} : { subagent: session.subagent }) })),
+            transcript: (session) => store.transcript(need(byId.get(session.id))),
+            rejected: store.rejected,
+            unreadable: store.unreadable,
+            where: (session) => byId.get(session.id)?.file ?? root,
+            close: () => undefined,
+        };
+    },
+};
 /** Every non-Claude source, in the order the deposit reads them. */
-export const SOURCES = [cursor, codex, copilot, gemini, grok, vscodeCopilot];
+export const SOURCES = [cursor, codex, copilot, gemini, grok, opencode, pi, vscodeCopilot, otel];
 /** How a source is named in a deposit line; a name the table does not know (a test's) is its own label. */
 export const sourceLabel = (name, table = SOURCES) => table.find((source) => source.name === name)?.label ?? name;

package/dist/sessions/store.d.ts

@@ -13,7 +13,7 @@ export interface SessionsRuntime {
     projectsRoot: string;
     /** Cursor's `User` folder (`cursorRoot` in cursor.ts), kept as the alias of `sourceRoots.cursor`; absent means no Cursor source. */
     cursorRoot?: string;
-    /** Where each non-Claude source's store lives, by `Source.name` (sources.ts); a source with no root is not read. `deposit` reads one only when `--allow` names it. */
+    /** Where each non-Claude source's store lives, by `Source.name` (sources.ts); a source with no root is not read; one with a root is read unless the allowlist names other entries only or denies it. */
     sourceRoots?: {
         [source: string]: string;
     };
@@ -52,7 +52,17 @@ export interface State {
     redactDomains: string[];
     /** Every `--allow` entry any deposit used (folders, prefixes, globs): the SessionEnd hook deposits a session only from a folder these name. */
     allow: string[];
+    /** What the person chose about sending to a pool: the raw-copy consent and the folders switched down. Never read by capture. */
+    pool: PoolChoices;
 }
+/** The answer to the raw-copy prompt (`granted`, `declined`, or not asked yet) and the per-folder switches (an `--allow`-style entry mapped to what it may send). */
+export interface PoolChoices {
+    rawConsent: 'granted' | 'declined' | null;
+    folders: {
+        [entry: string]: FolderSend;
+    };
+}
+export type FolderSend = 'skeleton' | 'off';
 export declare const paths: (storeDir: string) => {
     observations: string;
     state: string;
@@ -77,6 +87,8 @@ export declare const sidOf: (salt: string) => string;
  */
 export declare const localSalt: (storeDir: string) => Promise<AccountSalt>;
 export declare const readState: (storeDir: string) => Promise<State>;
+/** Changes the pool choices under the store lock, so a deposit running at the same time keeps them (it writes the state it read). */
+export declare const updatePoolChoices: (storeDir: string, change: (choices: PoolChoices) => void) => Promise<PoolChoices>;
 export declare const readRedactDomains: (storeDir: string) => Promise<string[]>;
 /** The `--allow` entries and `--redact-domain` set earlier deposits used; the nightly run repeats them. */
 export declare const readSaved: (storeDir: string) => Promise<{

package/dist/sessions/store.js

@@ -4,7 +4,7 @@ import { performance } from 'node:perf_hooks';
 import { appendFile, mkdir, open, readdir, readFile, rename, rm, stat, utimes, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { CliError, ExitCode } from '../errors.js';
-import { compileAllow, requireEntries, slugOf } from './allow.js';
+import { compileAllow, mergeAllow, runAllow, slugOf } from './allow.js';
 import { SOURCES } from './sources.js';
 import { buildIndex, indexPath } from './hook-index.js';
 import { archiveRaw } from './archive.js';
@@ -74,15 +74,30 @@ export const readState = async (storeDir) => {
             }
             const domains = Array.isArray(parsed.redactDomains) ? parsed.redactDomains.filter((entry) => typeof entry === 'string') : [];
             const allow = Array.isArray(parsed.allow) ? parsed.allow.filter((entry) => typeof entry === 'string') : [];
-            return { files, redactDomains: domains, allow };
+            const pool = isRecord(parsed.pool) ? parsed.pool : {};
+            const folders = {};
+            if (isRecord(pool.folders))
+                for (const [entry, mode] of Object.entries(pool.folders))
+                    if (mode === 'skeleton' || mode === 'off')
+                        folders[entry] = mode;
+            return { files, redactDomains: domains, allow, pool: { rawConsent: pool.rawConsent === 'granted' || pool.rawConsent === 'declined' ? pool.rawConsent : null, folders } };
         }
     }
     catch (error) {
         if (!isMissing(error) && !(error instanceof SyntaxError))
             throw error;
     }
-    return { files: {}, redactDomains: [], allow: [] };
+    return { files: {}, redactDomains: [], allow: [], pool: { rawConsent: null, folders: {} } };
 };
+/** Changes the pool choices under the store lock, so a deposit running at the same time keeps them (it writes the state it read). */
+export const updatePoolChoices = (storeDir, change) => withLock(storeDir, async (held) => {
+    const state = await readState(storeDir);
+    change(state.pool);
+    if (!(await held()))
+        throw new StoreLockLostError();
+    await writeAtomic(paths(storeDir).state, JSON.stringify(state));
+    return state.pool;
+});
 export const readRedactDomains = async (storeDir) => (await readState(storeDir)).redactDomains;
 /** The `--allow` entries and `--redact-domain` set earlier deposits used; the nightly run repeats them. */
 export const readSaved = async (storeDir) => {
@@ -385,14 +400,17 @@ export const refresh = async (runtime, redactDomains, at, trace, held = () => Pr
     }
     // The pool is derived for the index's fit reads only: one that cannot be read or written costs the index those, never the index itself (`currentPool` says so on stderr). Loaded here, not at the top: the pool imports every read family, and a lookup hook never reaches this step. It runs before the clock starts, so the index's `ms` is the index and not the derive (the first pool run takes 12 to 17 s on a store copy).
     // A module that will not load costs the index the same fit reads, with one line on stderr, as `currentPool` does when the pool cannot be built.
-    const reads = await import('./pool.js').then(async ({ currentPool }) => (await currentPool(runtime.storeDir, store))?.reads ?? [], (error) => {
+    const current = await import('./pool.js').then(async ({ currentPool }) => currentPool(runtime.storeDir, store), (error) => {
         process.stderr.write(`oars: the read pool module could not be loaded, and the index keeps no fit reads: ${error instanceof Error ? error.message : String(error)}
 `);
-        return [];
+        return undefined;
     });
+    const reads = current?.reads ?? [];
     const indexStarted = performance.now();
     try {
-        const index = buildIndex(store, redactDomains, at, reads);
+        // The next-node reads for each harness and version, derived over the same pool; a deposit that has no pool leaves the index without them.
+        const next = current === undefined ? undefined : (await import('./recall-frames.js')).nextByFrame(current.pool, store);
+        const index = buildIndex(store, redactDomains, at, reads, next);
         await requireHold(held);
         await writeAtomic(indexPath(runtime.storeDir), JSON.stringify(index));
         if (trace !== undefined) {
@@ -529,32 +547,32 @@ export const withLock = async (storeDir, work, options = { waitMs: 10_000, stale
     }
 };
 export const deposit = (runtime, options, trace) => withLock(runtime.storeDir, (holds) => depositLocked(runtime, options, holds, trace));
-/** Writes `state.json` only while this run holds the lock; a run that lost it throws before the write, so the holder that took over keeps its entries. */
+/** Throws `StoreLockLostError` when this run's token no longer stands. */
 const requireHold = async (held) => {
     if (!(await held()))
         throw new StoreLockLostError();
 };
+/** Writes `state.json` only while this run holds the lock; a run that lost it throws before the write, so the holder that took over keeps its entries. */
 const writeStateHeld = async (runtime, state, held) => {
-    if (!(await held()))
-        throw new StoreLockLostError();
+    await requireHold(held);
     await writeAtomic(paths(runtime.storeDir).state, JSON.stringify(state));
 };
 const depositLocked = async (runtime, options, holds, trace) => {
-    requireEntries(options.allow);
-    const allow = compileAllow(options.allow);
+    const state = await readState(runtime.storeDir);
+    const entries = runAllow(state.allow, options.allow);
+    const allow = compileAllow(entries);
     const folders = await projectFolders(runtime.projectsRoot);
     const allowed = folders.filter((name) => allow.allows(name));
     const roots = sourceRoots(runtime);
     const table = sourcesOf(runtime);
     const missing = allow.unmatched([...folders, ...table.filter((source) => roots.has(source.name)).map((source) => source.name)]);
-    const state = await readState(runtime.storeDir);
     refuseNewer(state);
     // A log written by a newer oars is refused even when state.json is older or lost; the Stop-hook path reads only state.json.
     const held = (await scanLog(paths(runtime.storeDir).observations)).newerCaptures;
     if (held > 0)
         throw new CliError(`The log holds captures by a newer oars (sessions: ${String(held)}); upgrade oars.`, ExitCode.UNEXPECTED, 'unexpected');
     state.redactDomains = [...new Set([...state.redactDomains, ...options.redactDomains])];
-    state.allow = [...new Set([...state.allow, ...options.allow])];
+    state.allow = mergeAllow(state.allow, options.allow);
     const context = await contextFor(runtime, state, options.now, holds);
     const result = {
         sessions: 0,
@@ -871,7 +889,8 @@ const rawOnlyTranscripts = async (context, project, onDisk) => {
     // Listed from raw/ itself, so a lost state.json (no entries to name the files) still finds them; a file with no entry counts as behind.
     const behind = (await rawRelatives(root, [])).filter((relative) => {
         const entry = context.state.files[`${prefix}${relative}`];
-        return !onDisk.has(`${prefix}${relative}`) && (entry === undefined || entry.v !== CAPTURE_VERSION || entry.s !== context.salt.sid);
+        // A domain named after the capture changes what the redactor masks, so a file recorded under another domain set is behind too.
+        return !onDisk.has(`${prefix}${relative}`) && (entry === undefined || entry.v !== CAPTURE_VERSION || entry.s !== context.salt.sid || !sameSet(entry.d, context.domains));
     });
     const found = [];
     for (const relative of behind) {
@@ -1214,6 +1233,8 @@ const writeLive = async (file, temp, latest) => {
  */
 export const compactLog = async (storeDir, renameWaitMs = LOG_RENAME_WAIT_MS, held = () => Promise.resolve(true)) => {
     const file = paths(storeDir).observations;
+    // A run that lost the lock must not sweep a temp file the later holder is writing.
+    await requireHold(held);
     // Under the lock no other compaction is running, so any temp file here is one a crash left.
     for (const entry of await listDir(storeDir)) {
         if (entry.name.startsWith(`${basename(file)}.`) && entry.name.endsWith('.tmp'))
@@ -1230,8 +1251,7 @@ export const compactLog = async (storeDir, renameWaitMs = LOG_RENAME_WAIT_MS, he
         if ((await stat(file)).size !== size)
             throw new Error('the log changed while it was being rewritten');
         // The size check cannot see a run that took a broken lock and has not appended yet; its token can.
-        if (!(await held()))
-            throw new StoreLockLostError();
+        await requireHold(held);
         await renameWhenFree(temp, file, renameWaitMs);
     }
     finally {

package/dist/sessions/survival.d.ts

@@ -15,6 +15,8 @@ export type SurvivalCounts = {
 /** Runs one read-only git command in a repository and answers its stdout; rejects on any failure. */
 export type Git = (root: string, args: readonly string[], stdin?: string) => Promise<string>;
 export declare const survivalFile: (storeDir: string) => string;
+export declare const runGit: Git;
+export declare const cwdOfProject: (runtime: Pick<SessionsRuntime, "projectsRoot" | "storeDir">, project: string, sessions: ReadonlySet<string>) => Promise<string | undefined>;
 /** The latest state of each sha. The file only adds to what `books` shows, so a missing or unreadable one reads as nothing observed yet. */
 export declare const readSurvival: (storeDir: string) => Promise<Map<string, SurvivalState>>;
 /**