agent-afk 5.341.0 → 5.342.0

package/dist/agent/episodes/extract.d.ts

@@ -0,0 +1,2 @@
+import type { EpisodeInput } from './types.js';
+export declare function extractEpisodeInput(sessionId: string): EpisodeInput;

package/dist/agent/episodes/index.d.ts

@@ -0,0 +1,6 @@
+export type { EpisodeRecord, EpisodeInput } from './types.js';
+export { extractEpisodeInput } from './extract.js';
+export { synthesizeEpisode } from './synthesize.js';
+export { writeEpisode, formatEpisodeContent, sanitizeNarrative } from './writer.js';
+import type { EpisodeRecord } from './types.js';
+export declare function synthesizeAndWriteEpisode(sessionId: string): Promise<EpisodeRecord>;

package/dist/agent/episodes/session-end-hook.d.ts

@@ -0,0 +1,2 @@
+import type { HookHandler } from '../hooks.js';
+export declare function createEpisodeSessionEndHook(): HookHandler;

package/dist/agent/episodes/synthesize.d.ts

@@ -0,0 +1,2 @@
+import type { EpisodeInput, EpisodeRecord } from './types.js';
+export declare function synthesizeEpisode(input: EpisodeInput): Promise<EpisodeRecord>;

package/dist/agent/episodes/types.d.ts

@@ -0,0 +1,24 @@
+export interface EpisodeRecord {
+    sessionId: string;
+    goal: string;
+    approach: string;
+    pivots: string[];
+    decisions: string[];
+    outcome: string;
+    openQuestions: string[];
+    filesKey: string[];
+    tags: string[];
+    narrative: string;
+    synthesizedAt: string;
+}
+export interface EpisodeInput {
+    sessionId: string;
+    firstUserMessage: string;
+    markSequence: string[];
+    toolsUsed: string[];
+    toolErrors: string[];
+    lastAssistantMessage: string;
+    facetSummary?: string;
+    durationMs?: number;
+    costUsd?: number;
+}

package/dist/agent/episodes/writer.d.ts

@@ -0,0 +1,4 @@
+import type { EpisodeRecord } from './types.js';
+export declare function sanitizeNarrative(text: string): string;
+export declare function formatEpisodeContent(episode: EpisodeRecord): string;
+export declare function writeEpisode(episode: EpisodeRecord, memoryDir?: string): Promise<void>;

package/dist/agent/provider.d.ts

@@ -194,11 +194,6 @@ export interface ProviderQuery extends AsyncIterable<ProviderEvent> {
     setBeforeTurnEnd?(cb: ((continuation: number, assistantText?: string) => Promise<{
         continueWith?: string;
     } | undefined>) | undefined): void;
-    reauth?(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     close(): void | Promise<void>;
 }
 export interface ProviderCommandInfo {

package/dist/agent/providers/anthropic-direct/query/cwd-dependents.d.ts

@@ -12,6 +12,7 @@ export type CwdDependentsFactory = (newCwd: string) => {
 export interface CwdDependentsFactoryArgs {
     stableSystemPrefix: StableSystemParts;
     config: AgentConfig;
+    resolvedSessionId: string | undefined;
     surface: string;
     runtimeStateSource: RuntimeStateSource;
     getCurrentCwd: () => string | undefined;

package/dist/agent/providers/anthropic-direct/query-runtime.d.ts

@@ -57,11 +57,6 @@ export declare class AnthropicDirectQuery implements ProviderQuery {
     getContextUsage(): Promise<ProviderContextUsage>;
     mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
     accountInfo(): Promise<ProviderAccountInfo>;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     rewindFiles(userMessageId: string, options?: {
         dryRun?: boolean;
     }): Promise<ProviderRewindResult>;

package/dist/agent/providers/openai-compatible/index.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
     private _stateStore;
     private readonly _injectedMemoryStore;
     private readonly _injectedStateStore;
-    private readonly schemas;
+    private schemas;
     private _defaultHeaders;
     private _sharedReadRoots;
     private _sharedWriteRoots;
@@ -23,6 +23,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
         baseURL?: string;
         defaultHeaders?: Record<string, string>;
     }): void;
+    setSubscribeHandler(handler: import('../../tools/types.js').ToolHandler): void;
     query(args: ProviderQueryArgs): ProviderQuery;
     private buildDispatcher;
     private ensureSharedRoots;

package/dist/agent/providers/openai-compatible/index.options.d.ts

@@ -20,6 +20,7 @@ export interface OpenAICompatibleProviderOptions extends ChildSessionOptions {
     composeExecutor?: ComposeExecutor;
     memoryStore?: MemoryStore;
     workspaceStore?: WorkspaceStore;
+    subscribeHandler?: import('../../tools/types.js').ToolHandler;
     stateStore?: StateStore;
     surface?: string;
     readOnlyMemory?: boolean;

package/dist/agent/providers/openai-compatible/provider-schemas.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAICompatibleProviderOptions } from './index.options.js';
+import type { AnthropicToolDef } from '../anthropic-direct/types.js';
+export declare function buildProviderSchemas(opts: OpenAICompatibleProviderOptions): AnthropicToolDef[];

package/dist/agent/providers/router/provider-router.d.ts

@@ -46,11 +46,6 @@ export declare class ProviderRouter implements ProviderQuery {
     setPermissionMode(mode: string): Promise<void>;
     setCwd(cwd: string): void;
     setSystemPrompt(basePrompt: string | undefined): boolean;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     supportedCommands(): Promise<ProviderCommandInfo[]>;
     supportedModels(): Promise<ProviderModelInfo[]>;
     supportedAgents(): Promise<ProviderAgentInfo[]>;

package/dist/agent/session/agent-session.d.ts

@@ -57,11 +57,6 @@ export declare class AgentSession implements IAgentSession {
     setPermissionMode(mode: PermissionMode): Promise<void>;
     setSystemPrompt(basePrompt: string | undefined): boolean;
     setCwd(cwd: string): void;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     getPrePlanMode(): PermissionMode | undefined;
     setPlanExitQueueCheck(fn: () => boolean): void;
     takePendingPlanExitSeed(): Promise<{

package/dist/agent/session/ledger-lifecycle.d.ts

@@ -14,6 +14,12 @@ export interface LedgerEnsureContext {
 export declare class LedgerLifecycle {
     private writer;
     private initAttempted;
+    private start;
+    initialize(ctx: {
+        depth?: number;
+        parentSessionId?: string;
+        cwd?: string;
+    }): void;
     ensure(ctx: LedgerEnsureContext): void;
     recordUser(text: string, input?: string): void;
     recordEvent(event: OutputEvent): void;

package/dist/agent/session/session-config.d.ts

@@ -17,11 +17,6 @@ export declare function setModel(model: AgentModelInput | undefined, deps: Confi
 export declare function setPermissionMode(mode: PermissionMode, deps: ConfigDeps): Promise<void>;
 export declare function setSystemPrompt(basePrompt: string | undefined, deps: ConfigDeps): boolean;
 export declare function setCwd(cwd: string, deps: ConfigDeps): void;
-export declare function reauth(deps: ConfigDeps): Promise<{
-    accountId: string;
-    oldAccountId: string;
-    swapped: boolean;
-} | null>;
 export declare function takePendingPlanExitSeed(deps: ConfigDeps): Promise<{
     message: string;
     mode: PermissionMode;

package/dist/agent/session/session-meta.d.ts

@@ -9,6 +9,14 @@ export interface SessionMeta {
     startedAt?: number;
     afkVersion?: string;
     forkedFrom?: string;
+    gitHead?: SessionStart | null;
 }
+export interface SessionStart {
+    branch: string | null;
+    headSha: string | null;
+    capturedAt: number;
+}
+export declare function captureGitHead(cwd: string): SessionStart;
 export declare function writeSessionMeta(meta: SessionMeta): Promise<void>;
 export declare function readSessionMeta(sessionId: string): SessionMeta | null;
+export declare function readSessionStart(sessionId: string): SessionStart | null;

package/dist/bundled-plugins/awa-bundled/skills/consumer-map/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: consumer-map
+description: "Read-only consumer graph and blast-radius analysis — takes either a diff (PR number, patch file, git diff) or a named target (symbol, module, config key) and maps the full consumer surface: direct callers, transitive importers (depth 2), test/config/schema refs, hot paths, and event-pipeline members. Emits a scored Impact Report with a PROCEED / NARROW_SCOPE / HUMAN_GATE verdict before any mutation. Replaces blast-radius and impact-map with a single skill covering both entry points."
+argument-hint: "<PR-number | diff-file | symbol | module | config-key> [--repo <path>] [--symbols <comma-list>]"
+skills: [contract]
+allowed-tools: bash, read_file, grep, glob, agent
+failure_modes:
+  - diff mode: no diff artifact obtainable (verbal description only, no PR/patch/diff)
+  - diff mode: symbols_changed list incomplete (renamed vs. deleted not distinguished)
+  - target mode: ambiguous target (multiple symbols share the name across packages)
+  - probe context leak (framing or diff hunks accidentally included in probe prompt)
+  - uncovered entries in report (verdict emitted before all files/symbols accounted for)
+  - verdict ignored and mutations proceed without operator acknowledgment
+---
+
+## Overview
+
+`consumer-map` is a pure decision-support skill. It never edits files, never commits changes, and never dispatches write-path skills. Its sole artifact is an Impact Report with a machine-readable verdict.
+
+Two input modes, one pipeline:
+
+- **Diff mode** — pass a PR number, patch file, or `git diff` output. The skill parses the diff to extract `files_touched` and `symbols_changed`, then maps their consumer surface. Use when you have a change and want to know what it hits.
+- **Target mode** — pass a symbol name, module path, config key, environment variable, API endpoint, or schema column. The skill resolves the target to concrete file paths and exported symbols, then maps their consumer surface. Use when you are considering a change and want to know who depends on the target.
+
+If the input is ambiguous — a bare number that could be a PR or a line count, a name that matches multiple distinct entities — the skill stops and asks for disambiguation before dispatching any probes.
+
+---
+
+## Wave 1 — Input normalization (inline, ≤5 tool calls, no agent dispatch)
+
+**Diff mode:**
+Fetch the diff artifact (via `git diff`, `gh pr diff <N>`, or a passed file path) and parse it directly. Emit a structured manifest:
+
+```json
+{ "files_touched": [...], "symbols_changed": [...], "hunk_map": { "<file>": [[start, end], ...] } }
+```
+
+`symbols_changed` captures: functions renamed or deleted, exported types modified, function signatures altered. If no diff artifact is obtainable:
+
+> `BLOCKED: no diff artifact — run \`git diff\` or \`gh pr diff <N>\` and pass the output, or use target mode with a symbol name`
+
+**Target mode:**
+Resolve `<target>` to a canonical name, source file, and type (function / module / type / config key / env var / schema column / other). Populate `files_touched` with the target's source file(s) and `symbols_changed` with the target's exported names.
+
+If `<target>` is ambiguous — multiple symbols share the name across packages or the string matches more than one distinct entity — halt immediately and request disambiguation. Do not guess.
+
+No probe dispatch occurs before Wave 1 completes and emits a non-empty manifest.
+
+---
+
+## Wave 2 — Parallel consumer probes (3 agents, simultaneous dispatch, context-blind)
+
+All three agents are dispatched in a single tool-use block. Each is read-only and scoped to a single consumer class. Each receives only `files_touched` and `symbols_changed` from the Wave 1 manifest — **no patch framing, no bug description, no diff hunks, no stated intent of the change**. The denial of framing is the mechanism: probes cannot confirm what they cannot see.
+
+**Probe A — Direct callers and importers**
+For each symbol in `symbols_changed`, grep the entire repo for call sites, imports, and type references. For each file in `files_touched`, find direct importers. Returns:
+- `callsites` — deduplicated `file:line:snippet` list, grouped by file
+- `hot_paths` — callsites that reach user-facing surfaces, public APIs, or test fixtures
+- `missing_coverage` — symbols with zero test-file callsites
+- `event_pipeline_members` — if any touched file participates in an event/message pipeline, name the chain
+
+Covers source files only (excludes test and config files — those are Probe C's domain).
+
+**Probe B — Transitive consumers (depth 2)**
+For each direct consumer file found by Probe A's methodology (re-derived independently — Probe B does not see Probe A's output), find their callers and importers one level up. Returns:
+- `transitive_consumers` — second-order impact list with `file | importer_count | hub` per entry
+- `hub` flag: files imported by ≥5 other modules
+
+Stops at depth 2 to bound scope. If depth-2 fan-out exceeds 80 files, truncate and note `TRANSITIVE_OVERFLOW`.
+
+**Probe C — Test, config, schema, and CI consumers**
+Search test files, fixture data, env files, `.env.example`, CI config, migration files, schema definitions, and any JSON/YAML/TOML config referencing any symbol or file from the manifest by name or key. Returns separate sub-lists:
+- `test_sites` — test files that exercise the target
+- `mock_sites` — mocks, stubs, or fixture data referencing the target
+- `config_keys` — config, env, or schema references
+- `migration_refs` — migration files touching the target
+- `ci_refs` — CI/CD config referencing the target
+
+---
+
+## Wave 3 — Synthesis gate (inline, no agent dispatch)
+
+After all three probes complete, merge and deduplicate across all maps.
+
+**Completeness check:** every entry in `files_touched` and every symbol in `symbols_changed` must appear in at least one report section before a verdict is emitted. A report with uncovered entries is incomplete — loop back to targeted re-probing (max one additional pass) before declaring `BLOCKED: incomplete coverage`.
+
+**Classify every site:**
+
+| Class | Source |
+|---|---|
+| `DIRECT` | Probe A direct import/call site |
+| `TRANSITIVE` | Probe B second-order consumer |
+| `TEST` | Probe C test or mock site |
+| `CONFIG` | Probe C config, env, schema, or migration ref |
+| `EXTERNAL` | Any site outside the repo root (submodule, vendored dep) |
+
+**Compute impact score:**
+
+```
+score = (direct_count × 3) + (transitive_count × 1) + (test_count × 0.5) + (config_count × 0.5)
+```
+
+**Map score to tier:**
+
+| Score | Tier |
+|---|---|
+| < 5 | `LOW` |
+| 5–14 | `MEDIUM` |
+| 15–39 | `HIGH` |
+| ≥ 40 | `CRITICAL` |
+
+**Map tier to verdict:**
+
+| Tier | Verdict |
+|---|---|
+| `LOW` or `MEDIUM` | `PROCEED` — consumer surface is well-understood |
+| `HIGH` | `NARROW_SCOPE` — recommend scoping the change to a subset of consumers before invoking a write-path skill |
+| `CRITICAL` | `HUMAN_GATE` — do not dispatch refactor/forge/mint until a human reviews the report |
+
+---
+
+## Output structure
+
+Emit a single structured Impact Report:
+
+```
+## Impact Report
+
+### Input mode                    ← diff | target
+### Files touched (N)             ← from Wave 1
+### Symbols changed (N)           ← from Wave 1
+### Consumer map                  ← table of file | class | distance | hub | safe-to-ignore
+### Hot paths at risk             ← callsites reaching public API / user surface (Probe A)
+### Blast-radius amplifiers       ← shared utilities (≥3 importers) + event pipeline members (Probe A)
+### Transitive reach              ← hub files + depth-2 fan-out summary (Probe B)
+### Test and config surface       ← test_sites, mock_sites, config_keys, migration_refs, ci_refs (Probe C)
+### Coverage gaps                 ← symbols with zero test callsites (Probe A)
+### Safe zones                    ← modules/directories confirmed to have no dependency on the target
+### Impact tier                   ← LOW | MEDIUM | HIGH | CRITICAL with score breakdown
+### Verdict                       ← PROCEED | NARROW_SCOPE | HUMAN_GATE
+```
+
+For `NARROW_SCOPE`: append a **Regression test list** — the specific test files and test names that cover the affected callsites, derived from Probe A's `callsites` map and Probe C's `test_sites`. These are mandatory reading for anyone applying the change.
+
+---
+
+## Decision gates
+
+- **Ambiguous input** → stop before Wave 1, request disambiguation. Do not guess.
+- **CRITICAL tier** → emit `HUMAN_GATE` and halt. Do not chain into any write-path skill automatically.
+- **TRANSITIVE_OVERFLOW** → flag in report, cap transitive list at 80 entries, note that the true impact is larger than scored.
+- **Empty result** (zero consumers found) → report `LOW` tier but note the search surface so the caller can judge whether the grep was exhaustive.
+- **Incomplete probe** — if any Wave 2 probe does not return within its timeout, mark that consumer class as `INCOMPLETE` in the report rather than silently omitting it. An `INCOMPLETE` class cannot count toward a `PROCEED` verdict — the tier is computed on known data, but the verdict is capped at `NARROW_SCOPE` until the incomplete class is resolved.
+- **Uncovered entries** — if the completeness check fails after one re-probe pass, emit `BLOCKED: incomplete coverage` rather than a tier verdict on partial data.

package/dist/bundled-plugins/awa-bundled/skills/devils-advocate/SKILL.md

@@ -38,6 +38,18 @@ Until the verifier returns `CONFIRMED`, the convergent recommendation is a **can
 
 **Scope guard:** skip when the proposal is purely local with no composition surface, or is anchored to an external referent that survives independently of the system. Does not fire when `dissent = true` — that path surfaces the matrix directly; adding a Wave 3.5 gate on already-uncertain output adds friction without signal. Fires once per convergent verdict, not per critic.
 
+**Post-synthesis annotation — Consumer surface (inline, no dispatch):**
+After Wave 3 picks a recommendation — and after Wave 3.5 resolves, if it fired — the coordinator runs an inline consumer-surface check before surfacing. This is deterministic coordinator work, not a sub-agent dispatch.
+
+1. **Trigger:** fires only when the final recommendation names concrete code symbols (function, class, type, exported name) or file paths. If the recommendation is purely conceptual (an architectural stance, a process change, a scoping decision with no named code artifact), skip entirely.
+2. **Skip on dissent:** when `dissent = true`, the matrix is surfaced directly and the operator makes the call. Adding consumer counts to an already-uncertain matrix adds noise, not signal.
+3. **Extraction:** from the recommendation text, extract only the exported symbol names and/or file paths it references. Do not extract from the rationale, critic outputs, or the original proposal — the annotation checks the recommendation's own named targets, nothing more.
+4. **Bounded grep:** run at most 5 grep/glob calls against the repo to count importers of each extracted symbol or file. Use the ≥3 importer threshold for `shared_utilities` — a file imported by fewer than 3 modules is not a shared utility and does not warrant annotation.
+5. **Append:** add a `Consumer surface:` line to the recommendation output. For each symbol or file that meets the ≥3 threshold, show `<name> — <N> importers (search scope: <glob used>)`. For symbols below the threshold, omit them. If no concrete symbols were extractable from the recommendation, write `Consumer surface: not checked`. If symbols were extracted and checked but none met the ≥3 threshold, write `Consumer surface: checked — no symbol ≥3 importers (scope: <glob used>)`. Never write `accounted` or any verdict that implies completeness.
+6. **Defer:** when any symbol shows ≥3 importers, append: `For the full consumer graph, run /consumer-map <target> or /consumer-map <PR-number>.` This annotation is a lightweight signal, not a substitute for that skill.
+
+**Why not a verdict:** grep-only coverage misses dynamic imports, string-keyed config references, event-pipeline membership, and transitive consumers beyond one level. Emitting `ACCOUNTED` or `BLIND_SPOT` on incomplete evidence would create false assurance or false alarm. Raw counts with explicit search scope let the operator and downstream skills make their own judgment.
+
 **Merge + surface:**
 - Recommendation = `original` → the proposal survived critique; proceed with it. **With a steelman annotation present, the strengthened form is what survived and is therefore what you proceed with** — it is the artifact Wave 3 actually scored, and executing the verbatim text instead would run a version that never won: one that can omit a prerequisite the steelman made explicit, or reinstate a claim it dropped as indefensible. Rank and execute must name the same artifact. Surface it **as** the strengthened version, with `gaps_filled` (assumptions the proposal depends on but never stated) and `weak_claims_dropped` (claims too weak to defend) shown as an explicit delta against what the user wrote, so they can see exactly what changed and reject it if they disagree. The substitution must be **visible, never silent** — do not present strengthened text as if it were the user's verbatim proposal. With no steelman annotation, `original` is the verbatim proposal and proceeds unchanged.
 - Recommendation ≠ `original`, `dissent = false`, ≥2 critics returned the same alternative → convergent path: run Wave 3.5, then surface the alternative with rationale (on `OVERRIDE`, re-rank first) before acting.

package/dist/bundled-plugins/awa-bundled/skills/ground-state/SKILL.md

@@ -12,7 +12,7 @@ failure_modes:
 ## Sub-agent contract
 /contract
 
-**Constraint: read-only reconnaissance.** You MUST NOT call `edit_file`, `write_file`, or any mutating bash command (no `git commit`, `git push`, `git checkout`, `mv`, `rm`, file redirection, package installs, etc.). Read-only tools only: `read_file`, `grep`, `glob`, `list_directory`, `memory_search`, and read-only bash (`git status`, `git log`, `git diff`, `cat`, `ls`, `find`, etc.). `memory_search` is non-mutating and is the **only** way to reach the cross-session fact archive — it is in scope for this skill, do not strip it from this list.
+**Constraint: read-only reconnaissance.** You MUST NOT call `edit_file`, `write_file`, or any mutating bash command (no `git commit`, `git push`, `git checkout`, `mv`, `rm`, file redirection, package installs, etc.). Read-only tools only: `read_file`, `grep`, `glob`, `list_directory`, `memory_search`, and git queries (via `bash` or `git_read` when bash is unavailable). Under `git_read`, non-git shell commands (`cat`, `ls`, `stat`, `tail`) are not available; use `read_file`, `glob`, and `list_directory` instead. `memory_search` is non-mutating and is the **only** way to reach the cross-session fact archive — it is in scope for this skill, do not strip it from this list.
 
 If the survey reveals a fix that's tempting to apply, **return it as a recommendation in the snapshot** — the orchestrator decides whether to act. Even if the invoking brief sounds prescriptive ("draft the edit", "apply the change"), this skill stops at the snapshot and the preamble artifact. The orchestrator dispatches a separate implementation step afterward.
 
@@ -48,7 +48,7 @@ Check for relevant tooling and configs. Use the domain table below to decide whi
 
 | Domain | What to scan |
 |--------|-------------|
-| `software` | CI configs (`ls .github/workflows/ 2>/dev/null`), package scripts (`package.json`, `Makefile`, `pyproject.toml`), linters/formatters, authoritative config files for the task. |
+| `software` | CI configs (`list_directory` or `glob` on `.github/workflows/`), package scripts (`package.json`, `Makefile`, `pyproject.toml`), linters/formatters, authoritative config files for the task. |
 | `research` | Reference manager (.bib files), LaTeX setup, data analysis tools (Jupyter, R scripts), collaboration setup. |
 | `design` | Design tool configs, prototyping tools, handoff configs (Storybook), asset pipeline scripts. |
 | `business` | Modeling tool configs, presentation formats, data source configs, collaboration tool structure. |
@@ -66,14 +66,11 @@ Return: relevant facts with 1-line summaries, **plus the stores actually consult
 
 Read `SPINE.md` from the repo root (same directory as `AFK.md`). If the file does not exist or is empty, skip silently -- do not mention it in the snapshot. If it exists and has entries, extract its invariant (INV-*), rejected-pattern (REJ-*), and taste entries (TST-*) and include them in the snapshot so architectural constraints are visible before proposing changes.
 
-### Eval-pipeline recency survey *(bash — software domain only)*
+### Eval-pipeline recency survey *(software domain only)*
 
 For software-domain sessions, check whether the eval-run pipeline is current. This guard catches silent regressions that accumulate when the pipeline goes unrun during high-velocity sprints.
 
-Run:
-```
-tail -1 ~/.afk/agent-framework/improve/eval-runs/.index.jsonl 2>/dev/null
-```
+Read the last line of `~/.afk/agent-framework/improve/eval-runs/.index.jsonl` (use `read_file`; if the file does not exist, treat as "never run").
 
 Parse the `timestamp` field from the output. Then compute the age in days relative to today's date.
 
@@ -110,8 +107,8 @@ After the snapshot is assembled, construct the **Brief Anchor** — a path-verif
 
 **Construction procedure:**
 
-1. From your state survey output, extract the verified `cwd` (absolute path from `pwd`), `branch` (from `git rev-parse --abbrev-ref HEAD`), and `HEAD` SHA (from `git rev-parse HEAD`).
-2. From your infrastructure survey output, extract the 2–4 canonical file paths most relevant to the task. For each, run `stat <path>` — include the path only if `stat` exits 0. Paths that fail `stat` are omitted; if zero paths survive, set the list to `(none verified)`.
+1. From your state survey output, extract the verified `cwd` (from `git rev-parse --show-toplevel` combined with `git rev-parse --show-prefix` to reconstruct the full session path: `<toplevel>/<prefix>`), `branch` (from `git rev-parse --abbrev-ref HEAD`), and `HEAD` SHA (from `git rev-parse HEAD`).
+2. From your infrastructure survey output, extract the 2–4 canonical file paths most relevant to the task. For each, verify existence with `glob` or `read_file`; include the path only if it exists. Paths that don't exist are omitted; if zero paths survive, set the list to `(none verified)`.
 3. Assemble the preamble block:
 
 ```
@@ -119,7 +116,7 @@ After the snapshot is assembled, construct the **Brief Anchor** — a path-verif
 - **cwd**: <absolute path>
 - **branch**: <branch name>
 - **HEAD**: <full SHA>
-- **canonical paths** (stat each on entry; emit GROUNDING_FAILED:<path> and abort if missing):
+- **canonical paths** (verify each on entry; emit GROUNDING_FAILED:<path> and abort if missing):
   - <verified_path_1>
   - <verified_path_2>  ← omit line if not applicable
 ```
@@ -129,7 +126,7 @@ After the snapshot is assembled, construct the **Brief Anchor** — a path-verif
 **Orchestrator usage contract:**
 
 - Prepend the Brief Anchor verbatim to every sub-agent brief that reads files, runs `git`/`gh` commands, or references explicit paths. Skip for pure-reasoning tasks.
-- Sub-agents receiving the anchor `stat` each listed path on entry. A missing path returns `GROUNDING_FAILED:<path>` — the orchestrator re-dispatches once with the corrected path. If the retry also returns `GROUNDING_FAILED`, emit `BRIEF_GROUND_ABORT` with both the expected and actual paths **plus the corrective command** the operator should run — `git worktree list` to find the intended checkout, then `cd <correct-worktree>` — and halt the wave.
+- Sub-agents receiving the anchor verify each listed path on entry (via `glob` or `read_file`). A missing path returns `GROUNDING_FAILED:<path>` — the orchestrator re-dispatches once with the corrected path. If the retry also returns `GROUNDING_FAILED`, emit `BRIEF_GROUND_ABORT` with both the expected and actual paths **plus the corrective command** the operator should run — `git worktree list` to find the intended checkout, then `cd <correct-worktree>` — and halt the wave.
 - The anchor is session-scoped: one construction pass per `ground-state` invocation. Do not re-invoke `ground-state` mid-session to refresh it; instead pass the existing anchor through.
 
 **Skip when:**

package/dist/cli/commands/episode.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerEpisodeCommand(program: Command): void;