@gtrabanco/pi-agentic-workflow 4.10.0 → 5.0.0-canary.20261104.1

package/README.md

@@ -64,7 +64,7 @@ Two JSON files, both optional:
 {
   "default": { "model": "anthropic/claude-opus-4-5", "thinking": "high" },
   "commands": {
-    "plan-feature": { "model": ["anthropic/claude-sonnet-4-5", "openai/gpt-5.2"], "thinking": "medium" },
+    "unit-lane": { "model": ["anthropic/claude-sonnet-4-5", "openai/gpt-5.2"], "thinking": "medium" },
     "review-change": { "thinking": "max" }
   },
   "onUnavailableRoute": "stop",
@@ -84,7 +84,7 @@ whatever the session already had, because the shipped default route is
   resolves and has credentials, without touching the session while probing; when
   every entry is unusable the command stops (or, with `onUnavailableRoute`
   `inherit`, warns and runs on the current model), naming each candidate and why
-  it was skipped. `plan-feature` above tries `anthropic/claude-sonnet-4-5` first,
+  it was skipped. `unit-lane` above tries `anthropic/claude-sonnet-4-5` first,
   then `openai/gpt-5.2`.
 - `thinking` is one of `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`,
   or `"inherit"`.
@@ -263,8 +263,8 @@ nothing runs on a model you did not pick. To run anyway on the current model, se
 ## Your session after a command
 
 By default (**`onSettle: "keep"`**), the routed model and thinking level **stay**
-in the open chat window once the command settles. If `plan-feature` runs on
-`glm-5` and you want to tweak the plan it produced, your next prompt keeps
+in the open chat window once the command settles. If `unit-lane` runs on
+`glm-5` and you want to tweak the SPEC it produced, your next prompt keeps
 running on `glm-5` — same for a follow-up question. When you don't need the
 heavy model, switch it yourself with `/model` (or Ctrl+P) to something cheaper;
 nothing restores over your choice.
@@ -313,7 +313,7 @@ dialog.
 
 | You see | Means |
 | --- | --- |
-| `refused: invalid configuration` | A config file was rejected. The same message names the field, e.g. `$.commands.plan-feature.model`. Run `/agentic-workflow-settings` to see the file, or fix the JSON. |
+| `refused: invalid configuration` | A config file was rejected. The same message names the field, e.g. `$.commands.unit-lane.model`. Run `/agentic-workflow-settings` to see the file, or fix the JSON. |
 | `stopped: the configured model` … `is not in the model registry` | The reference is wrong or the provider is not configured. Use `/model` to see the exact `provider/modelId`. |
 | `has no configured credentials` | The model exists but you cannot use it yet. Authenticate, or set `onUnavailableRoute` to `inherit`. |
 | `could not be selected` | Pi refused the switch. The command stops with the reason — unless `onUnavailableRoute` is `inherit`, in which case it warns and runs on your current model. |
@@ -324,11 +324,16 @@ dialog.
 
 ## Notes
 
-- Verified against the peer floor Pi 0.99.1 (2026-09-29) (`pi install`, package skills, friendly
-  command registration, routed set/clear, settings console round-trip, `sendUserMessage`
-  with prompt template expansion). Also verified against Pi 1.2.0 (2026-10-14) via a local
-  two-leg `tsc --noEmit` run (legs `0.99.1` + `latest`, the `latest` leg resolving to pi
-  1.2.0; COMPAT-OK); continuously against the
+- Verified against the peer floor Pi 1.1.0 (2026-11-03): the session telemetry
+  reads `tool_execution_end.durationMs`, which 1.0.4's published types do not
+  carry and 1.1.0's do (`npm pack @earendil-works/pi-coding-agent@1.0.4` and
+  `@1.1.0`, then `dist/core/extensions/types.d.ts` — 0 vs 2 occurrences). The
+  pre-telemetry surface was verified behaviourally at Pi 0.99.1 (2026-09-29)
+  (`pi install`, package skills, friendly command registration, routed set/clear,
+  settings console round-trip, `sendUserMessage` with prompt template expansion).
+  Also verified against Pi 1.5.0 (2026-11-02) via a local two-leg `tsc --noEmit`
+  run (legs `0.99.1` + `latest`, the `latest` leg resolving to pi 1.5.0;
+  COMPAT-OK); continuously against the
   `latest` dist-tag by the `pi-compat-guard` PR gate (the leg is a moving tripwire,
   not a pinned version — a breaking release shows red here first).
 - The package declares Pi as a peer dependency; it bundles no copy of Pi.

package/dist/config/defaults.js

@@ -20,14 +20,9 @@ export const DEFAULT_CONFIG = {
     // Feature 66 — the memory substrate is ask-first: nothing is provisioned
     // until the operator opts in.
     memory: { engram: false },
-    // Tool-call guards ship all-off: they are this repository's working rules,
-    // not a package opinion — a project opts in per guard in its config file.
-    guards: {
-        merge: false,
-        history: false,
-        ci: { create: false, run: false },
-        expensiveTests: { maxTokens: 0, patterns: [] },
-    },
+    // Issue #383 — the measured acceptance is opt-in: a fresh install measures
+    // nothing until an operator turns it on.
+    telemetry: { enabled: false },
     profiles: {},
     profileOrder: [],
     profileFallback: { ...DEFAULT_PROFILE_FALLBACK },

package/dist/config/merge.js

@@ -132,9 +132,11 @@ export function mergeConfigs(globalFile = {}, projectFile = {}) {
         memory: {
             engram: pick(false, projectFile.memory?.engram, globalFile.memory?.engram) === true,
         },
-        // Tool-call guards resolve like every other knob: project wins, then
-        // global, then the shipped OFF. A guard no scope mentions stays disabled.
-        guards: mergeGuards(globalFile.guards, projectFile.guards),
+        // Issue #383 — the same boolean resolution: project, then global, then the
+        // shipped "no".
+        telemetry: {
+            enabled: pick(false, projectFile.telemetry?.enabled, globalFile.telemetry?.enabled) === true,
+        },
         profiles: mergeProfiles(globalFile.profiles, projectFile.profiles),
         profileOrder: pick([], projectFile.profileOrder, globalFile.profileOrder),
         profileFallback: mergeProfileFallback(globalFile.profileFallback, projectFile.profileFallback),
@@ -147,23 +149,6 @@ export function mergeConfigs(globalFile = {}, projectFile = {}) {
         merged.advance = advance;
     return merged;
 }
-/** Guards merge whole-knob: a boolean takes project-then-global, and the
- *  expensive-tests block resolves field-by-field (patterns are replaced, not
- *  concatenated, so a project override is predictable — no hidden union). */
-function mergeGuards(globalGuards, projectGuards) {
-    return {
-        merge: pick(DEFAULT_CONFIG.guards.merge, projectGuards?.merge, globalGuards?.merge),
-        history: pick(DEFAULT_CONFIG.guards.history, projectGuards?.history, globalGuards?.history),
-        ci: {
-            create: pick(DEFAULT_CONFIG.guards.ci.create, projectGuards?.ci?.create, globalGuards?.ci?.create),
-            run: pick(DEFAULT_CONFIG.guards.ci.run, projectGuards?.ci?.run, globalGuards?.ci?.run),
-        },
-        expensiveTests: {
-            maxTokens: pick(DEFAULT_CONFIG.guards.expensiveTests.maxTokens, projectGuards?.expensiveTests?.maxTokens, globalGuards?.expensiveTests?.maxTokens),
-            patterns: pick(DEFAULT_CONFIG.guards.expensiveTests.patterns, projectGuards?.expensiveTests?.patterns, globalGuards?.expensiveTests?.patterns),
-        },
-    };
-}
 /** Project-over-global merge of the advance (conductor) knobs (feature 62).
  *  Absent from the result when neither scope declares any — the resolved
  *  shape of pre-62 configs is byte-stable. */

package/dist/config/schema.js

@@ -21,7 +21,7 @@ const ROOT_KEYS = new Set([
     "profileOrder",
     "profileFallback",
     "memory",
-    "guards",
+    "telemetry",
 ]);
 const ROUTE_KEYS = new Set(["model", "thinking"]);
 const COMMAND_NAME = /^[a-z0-9][a-z0-9._-]*$/u;
@@ -333,7 +333,7 @@ function validateConfig(value) {
         if (!ROOT_KEYS.has(key)) {
             issues.push({
                 path: `$.${displayKey(key)}`,
-                message: `unknown config key "${key}" (allowed: default, commands, onUnavailableRoute, onSettle, pathProtection, advance, recommendedModels, profiles, profileOrder, profileFallback, memory, guards)`,
+                message: `unknown config key "${key}" (allowed: default, commands, onUnavailableRoute, onSettle, pathProtection, advance, recommendedModels, profiles, profileOrder, profileFallback, memory, telemetry)`,
             });
         }
     }
@@ -403,16 +403,16 @@ function validateConfig(value) {
             config.recommendedModels = value.recommendedModels;
         }
     }
+    if (value.telemetry !== undefined) {
+        const telemetry = checkTelemetry(value.telemetry, "$.telemetry", issues);
+        if (telemetry)
+            config.telemetry = telemetry;
+    }
     if (value.memory !== undefined) {
         const memory = checkMemory(value.memory, "$.memory", issues);
         if (memory)
             config.memory = memory;
     }
-    if (value.guards !== undefined) {
-        const guards = checkGuards(value.guards, "$.guards", issues);
-        if (guards)
-            config.guards = guards;
-    }
     if (value.profiles !== undefined) {
         if (!isRecord(value.profiles)) {
             issues.push({ path: "$.profiles", message: "must be an object mapping profile names to profile definitions" });
@@ -448,125 +448,53 @@ function validateConfig(value) {
  * the loader can treat "nothing declared" like "nothing present" without a
  * second read.
  */
-/** Strict validator for the `memory` consent block (feature 66, AC3). */
-function checkMemory(value, path, issues) {
+/** Strict validator for the `telemetry` block (issue #383): one boolean switch. */
+function checkTelemetry(value, path, issues) {
     if (!isRecord(value)) {
         issues.push({ path, message: `must be a JSON object, got ${describe(value)}` });
         return undefined;
     }
     let unknown = false;
     for (const key of Object.keys(value)) {
-        if (key !== "engram") {
+        if (key !== "enabled") {
             unknown = true;
-            issues.push({ path: `${path}.${displayKey(key)}`, message: `unknown memory key "${key}" (allowed: engram)` });
+            issues.push({ path: `${path}.${displayKey(key)}`, message: `unknown telemetry key "${key}" (allowed: enabled)` });
         }
     }
     const out = {};
-    if (value.engram !== undefined) {
-        if (typeof value.engram !== "boolean") {
-            issues.push({ path: `${path}.engram`, message: `must be a boolean, got ${describe(value.engram)}` });
+    if (value.enabled !== undefined) {
+        if (typeof value.enabled !== "boolean") {
+            issues.push({ path: `${path}.enabled`, message: `must be a boolean, got ${describe(value.enabled)}` });
         }
         else {
-            out.engram = value.engram;
+            out.enabled = value.enabled;
         }
     }
     return unknown ? undefined : out;
 }
-/** Strict validator for the `guards` block. Everything absent stays off. */
-function checkGuards(value, path, issues) {
+/** Strict validator for the `memory` consent block (feature 66, AC3). */
+function checkMemory(value, path, issues) {
     if (!isRecord(value)) {
         issues.push({ path, message: `must be a JSON object, got ${describe(value)}` });
         return undefined;
     }
-    const out = {};
-    for (const key of ["merge", "history"]) {
-        if (value[key] !== undefined) {
-            if (typeof value[key] !== "boolean") {
-                issues.push({ path: `${path}.${key}`, message: `must be a boolean, got ${describe(value[key])}` });
-            }
-            else {
-                out[key] = value[key];
-            }
-        }
-    }
-    if (value.ci !== undefined) {
-        const ciPath = `${path}.ci`;
-        if (!isRecord(value.ci)) {
-            issues.push({ path: ciPath, message: `must be a JSON object, got ${describe(value.ci)}` });
-        }
-        else {
-            const ci = {};
-            for (const key of ["create", "run"]) {
-                if (value.ci[key] !== undefined) {
-                    if (typeof value.ci[key] !== "boolean") {
-                        issues.push({ path: `${ciPath}.${key}`, message: `must be a boolean, got ${describe(value.ci[key])}` });
-                    }
-                    else {
-                        ci[key] = value.ci[key];
-                    }
-                }
-            }
-            for (const key of Object.keys(value.ci)) {
-                if (key !== "create" && key !== "run") {
-                    issues.push({ path: `${ciPath}.${displayKey(key)}`, message: `unknown ci key "${key}" (allowed: create, run)` });
-                }
-            }
-            out.ci = ci;
-        }
-    }
-    if (value.expensiveTests !== undefined) {
-        out.expensiveTests = checkExpensiveTests(value.expensiveTests, `${path}.expensiveTests`, issues);
-    }
+    let unknown = false;
     for (const key of Object.keys(value)) {
-        if (key !== "merge" && key !== "history" && key !== "ci" && key !== "expensiveTests") {
-            issues.push({ path: `${path}.${displayKey(key)}`, message: `unknown guards key "${key}" (allowed: merge, history, ci, expensiveTests)` });
+        if (key !== "engram") {
+            unknown = true;
+            issues.push({ path: `${path}.${displayKey(key)}`, message: `unknown memory key "${key}" (allowed: engram)` });
         }
     }
-    return out;
-}
-function checkExpensiveTests(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push({ path, message: `must be a JSON object, got ${describe(value)}` });
-        return undefined;
-    }
     const out = {};
-    if (value.maxTokens !== undefined) {
-        if (typeof value.maxTokens !== "number" || !Number.isInteger(value.maxTokens) || value.maxTokens < 0) {
-            issues.push({ path: `${path}.maxTokens`, message: `must be a non-negative integer, got ${describe(value.maxTokens)}` });
-        }
-        else {
-            out.maxTokens = value.maxTokens;
-        }
-    }
-    if (value.patterns !== undefined) {
-        if (!Array.isArray(value.patterns)) {
-            issues.push({ path: `${path}.patterns`, message: `must be an array, got ${describe(value.patterns)}` });
+    if (value.engram !== undefined) {
+        if (typeof value.engram !== "boolean") {
+            issues.push({ path: `${path}.engram`, message: `must be a boolean, got ${describe(value.engram)}` });
         }
         else {
-            const patterns = [];
-            value.patterns.forEach((entry, index) => {
-                const entryPath = `${path}.patterns[${index}]`;
-                if (!isRecord(entry) || typeof entry.match !== "string" || entry.match === "") {
-                    issues.push({ path: entryPath, message: `must be an object with a non-empty string "match", got ${describe(entry)}` });
-                    return;
-                }
-                if (typeof entry.tokens !== "number" || !Number.isInteger(entry.tokens) || entry.tokens < 0) {
-                    issues.push({ path: `${entryPath}.tokens`, message: `must be a non-negative integer, got ${describe(entry.tokens)}` });
-                    return;
-                }
-                try {
-                    new RegExp(entry.match, "u");
-                }
-                catch {
-                    issues.push({ path: `${entryPath}.match`, message: `not a valid regular expression: ${entry.match}` });
-                    return;
-                }
-                patterns.push({ match: entry.match, tokens: entry.tokens });
-            });
-            out.patterns = patterns;
+            out.engram = value.engram;
         }
     }
-    return out;
+    return unknown ? undefined : out;
 }
 export function parseConfigFile(text) {
     if (text.trim() === "")

package/dist/config/types.d.ts

@@ -78,9 +78,8 @@ export interface ConfigFile {
     /** Feature 66 (AC3/D3): the memory-substrate consent surface — Engram's MCP
      *  registration is ask-first, so nothing is provisioned unless this says so. */
     memory?: MemoryConfigFile;
-    /** Tool-call guards (owner-gated merges, history, CI, expensive tests).
-     *  Everything absent stays off. */
-    guards?: GuardsConfigFile;
+    /** Issue #383: the per-unit cost sample. */
+    telemetry?: TelemetryConfigFile;
     /** Named user profiles keyed by profile name (feature 63, AC5). */
     profiles?: Record<string, ProfileFile>;
     /** Ordered list of profile names to probe; empty means ["default"] only
@@ -108,60 +107,14 @@ export interface MemoryConfigFile {
 export interface MemoryConfig {
     engram: boolean;
 }
-/**
- * One tool-call guard, as an operator WRITES it (this repository's working
- * rules, made mechanical; every other project gets none of it unless it
- * configures it). Each guard ships disabled — an absent key is OFF.
- *
- *   merge           every direct merge route is owner-only: `git merge`,
- *                   `gh pr merge`, and `git pull`'s merge form.
- *   history         pushes are decided by asking git (`git push --dry-run`):
- *                   a forced update, a ref delete or a push to `main` is
- *                   declined — one mechanism covering every flag spelling and
- *                   git alias.
- *   ci              CI is owner-gated: creating workflow files and triggering
- *                   workflow runs are blocked.
- *   expensiveTests  commands matching a configured pattern are estimated in
- *                   tokens; above `maxTokens` they are blocked. `tokens: 0`
- *                   blocks every match regardless of estimate.
- *
- * The only way through a guard is the explicit per-command token — the
- * command's first word — after an owner authorization in the same turn:
- * `AW_ALLOW=merge`, `AW_ALLOW=force`, `AW_ALLOW=ci`, `AW_ALLOW=cost`.
- */
-export interface GuardsConfigFile {
-    merge?: boolean;
-    history?: boolean;
-    ci?: GuardsCiFile;
-    expensiveTests?: GuardsExpensiveTestsFile;
-}
-export interface GuardsCiFile {
-    create?: boolean;
-    run?: boolean;
-}
-export interface GuardsExpensiveTestsFile {
-    /** Estimated-token ceiling; a match above it is blocked. `0` (default)
-     *  blocks every match regardless of estimate. */
-    maxTokens?: number;
-    /** Command patterns (regex source, `u` flag) and their estimated cost. */
-    patterns?: GuardsCostPattern[];
-}
-export interface GuardsCostPattern {
-    match: string;
-    tokens: number;
-}
-/** What the extension READS: every guard knob resolved. */
-export interface GuardsConfig {
-    merge: boolean;
-    history: boolean;
-    ci: {
-        create: boolean;
-        run: boolean;
-    };
-    expensiveTests: {
-        maxTokens: number;
-        patterns: GuardsCostPattern[];
-    };
+/** What an operator WRITES under `telemetry` (issue #383). */
+export interface TelemetryConfigFile {
+    /** Opt in to the per-unit cost sample. Absent or `false` measures nothing. */
+    enabled?: boolean;
+}
+/** What the extension READS: the telemetry switch, resolved (issue #383). */
+export interface TelemetryConfig {
+    enabled: boolean;
 }
 export interface ConfigIssue {
     path: string;
@@ -191,8 +144,8 @@ export interface EffectiveConfig {
     profileFallback: ProfileFallbackConfig;
     /** Feature 66: the memory-substrate consent surface. */
     memory: MemoryConfig;
-    /** The effective tool-call guards (all off unless a config file enables them). */
-    guards: GuardsConfig;
+    /** Issue #383: the measured acceptance is opt-in, like every other runtime cost. */
+    telemetry: TelemetryConfig;
     /** Feature 63: declaredness of the implicit `default` profile. */
     declared: {
         default: RouteDeclaration;

package/dist/extension/factory.d.ts

@@ -2,10 +2,6 @@ import type { LoadedConfig } from "../config/load.js";
 import type { Catalogue } from "../routing/catalogue.js";
 import type { Router } from "../routing/dispatch.js";
 import { dirtyWorktreeWarning, receiptGuard } from "./receipt-guard.js";
-import { mergeGuard } from "./merge-guard.js";
-import { historyGuard } from "./history-guard.js";
-import { ciGuard } from "./ci-guard.js";
-import { costGuard } from "./cost-guard.js";
 import type { ExtensionSurface, InvocationContext, ModelRef, RoutingControls } from "../routing/types.js";
 import type { HintStore } from "../routing/state.js";
 /**
@@ -58,18 +54,12 @@ export interface ExtensionHandle<M extends ModelRef = ModelRef> {
     catalogue: Catalogue;
     /**
      * The Pi-free predicates the adapter (`index.ts`) binds to Pi's lifecycle
-     * events: the inline-receipt block guard, the owner-gated tool guards (merge,
-     * history, CI, cost — all config-gated, all off unless a project enables
-     * them), and the dirty-worktree notice. They travel with the handle so the
-     * entry stays a thin translation layer and the decisions are unit-tested with
-     * no session (issues #182, #278).
+     * events: the inline-receipt block guard and the dirty-worktree notice. They
+     * travel with the handle so the entry stays a thin translation layer and the
+     * decisions are unit-tested with no session (issue #182).
      */
     guards: {
         receiptGuard: typeof receiptGuard;
-        mergeGuard: typeof mergeGuard;
-        historyGuard: typeof historyGuard;
-        ciGuard: typeof ciGuard;
-        costGuard: typeof costGuard;
         dirtyWorktreeWarning: typeof dirtyWorktreeWarning;
     };
 }

package/dist/extension/factory.js

@@ -2,10 +2,6 @@ import { loadConfig } from "../config/load.js";
 import { readCatalogue } from "../routing/catalogue.js";
 import { createRouter } from "../routing/dispatch.js";
 import { dirtyWorktreeWarning, receiptGuard } from "./receipt-guard.js";
-import { mergeGuard } from "./merge-guard.js";
-import { historyGuard } from "./history-guard.js";
-import { ciGuard } from "./ci-guard.js";
-import { costGuard } from "./cost-guard.js";
 import { ADVANCE_COMMAND, SETTINGS_COMMAND, SETTINGS_COMMAND_ALIAS } from "../routing/types.js";
 import { registerAdvanceCommand } from "./conductor-command.js";
 import { createProfileStateStore, stateFilePath } from "../routing/state.js";
@@ -82,5 +78,5 @@ export function createExtension(deps) {
         description: "Show and configure per-command model routing",
         handler: settingsHandler,
     });
-    return { router, catalogue, guards: { receiptGuard, mergeGuard, historyGuard, ciGuard, costGuard, dirtyWorktreeWarning } };
+    return { router, catalogue, guards: { receiptGuard, dirtyWorktreeWarning } };
 }

package/dist/extension/index.js

@@ -9,6 +9,7 @@ import { readGitStatusBounded } from "./receipt-guard.js";
 import { createPickerComponent, PICKER_MAX_VISIBLE, pagedSelect } from "../settings/picker.js";
 import { createHintStore, createSerenaReadinessStore, stateFilePath } from "../routing/state.js";
 import { createSerenaReadinessGate, readInitWorkspaceRevision } from "../routing/serena-readiness.js";
+import { createTelemetryWiring } from "./telemetry-wiring.js";
 import { provisionEngram, readDeclaredServerNamesFrom, resolveEngramBinary, declaredMcpServerPaths } from "./engram.js";
 import { runSettingsConsole } from "../settings/console.js";
 import { readConfigFile, writeConfigFile } from "../settings/store.js";
@@ -89,11 +90,14 @@ function toInvocationContext(ctx) {
         hasConfiguredAuth: (model) => ctx.modelRegistry.hasConfiguredAuth(model),
     };
 }
-function toRegistrar(pi) {
+function toRegistrar(pi, noteCommand) {
     return {
         registerCommand: (name, options) => pi.registerCommand(name, {
             ...(options.description ? { description: options.description } : {}),
             handler: async (args, ctx) => {
+                // Issue #383: the session learns which unit it is working on from the
+                // command that names it, never from a model's claim.
+                noteCommand(name, String(args ?? "").split(/\s+/).filter(Boolean));
                 await options.handler(args, toInvocationContext(ctx));
             },
         }),
@@ -229,8 +233,13 @@ export default function extension(pi) {
     // Said once per session: an override that was ignored (or a malformed file)
     // is reported the first time the guard runs, never on every tool call.
     let reportedDegradations = false;
+    // Issue #383 — the session accumulator. Pi builds a fresh extension instance
+    // per session (its runtime factory rebuilds the services, and the resource
+    // loader re-runs every factory), so one instance owns one session's sample.
+    let telemetry = null;
+    const noteCommand = (name, args) => telemetry?.noteCommand(name, args);
     const { router, guards } = createExtension({
-        registrar: toRegistrar(pi),
+        registrar: toRegistrar(pi, noteCommand),
         // Resolved per call: the router must never hold a session-bound object
         // between turns, because Pi can hand a new session to the same extension.
         surface: () => ({
@@ -276,6 +285,13 @@ export default function extension(pi) {
             ctx.ui.notify(message, "warning");
         const projectTrusted = ctx.isProjectTrusted();
         const loaded = loadConfig({ agentDir, cwd: ctx.cwd, projectTrusted });
+        if (loaded.config.telemetry?.enabled === true && telemetry === null) {
+            // The id is read once, here: pi invalidates a captured context after the
+            // session is replaced, and one extension instance serves one session.
+            const sessionId = ctx.sessionManager.getSessionId();
+            telemetry = createTelemetryWiring({ root: ctx.cwd, enabled: true, sessionId: () => sessionId });
+            telemetry.register(pi);
+        }
         const report = provisionEngram({
             consented: loaded.config.memory?.engram === true,
             configInvalid: !loaded.ok,
@@ -296,32 +312,8 @@ export default function extension(pi) {
     // names the script that proves the receipt landed (issue #182). The guard
     // itself filters to `bash`, so every tool call is checked — nesting it under
     // one tool name would make the block unreachable for the calls it exists for.
-    //
-    // Owner-gated tool guards, all config-driven (`guards` in the config files;
-    // every guard ships OFF — a project opts in per guard):
-    //   merge    `git merge`, `gh pr merge`, `git pull`'s merge form (issue #278).
-    //   history  pushes decided by git itself (`git push --dry-run`): a forced
-    //            update, a ref delete or a push to `main` is declined.
-    //   ci       writing workflow definitions and triggering workflow runs.
-    //   cost     commands estimated above the configured token budget.
-    // The only way through any of them is the explicit per-command token
-    // (`AW_ALLOW=merge|force|ci|cost`) after an owner instruction in the turn.
     pi.on("tool_call", (event, ctx) => {
         const command = "command" in event.input && typeof event.input.command === "string" ? event.input.command : undefined;
-        const inputPath = "path" in event.input && typeof event.input.path === "string" ? event.input.path : undefined;
-        const { guards: policy } = loadConfig({ agentDir, cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() }).config;
-        const merge = guards.mergeGuard({ toolName: event.toolName, command }, policy.merge);
-        if (merge.block)
-            return merge;
-        const history = guards.historyGuard({ toolName: event.toolName, command }, policy.history, { cwd: ctx.cwd });
-        if (history.block)
-            return history;
-        const ci = guards.ciGuard({ toolName: event.toolName, command, path: inputPath }, policy.ci);
-        if (ci.block)
-            return ci;
-        const cost = guards.costGuard({ toolName: event.toolName, command }, policy.expensiveTests);
-        if (cost.block)
-            return cost;
         const receipt = guards.receiptGuard({ toolName: event.toolName, command });
         if (receipt.block)
             return receipt;

package/dist/extension/telemetry-wiring.d.ts

@@ -0,0 +1,67 @@
+/**
+ * telemetry-wiring.ts — attaches the session accumulator to Pi's lifecycle
+ * (issue #383 S4/S4b, P5).
+ *
+ * The accumulator and its sink are pure; this file is the only place that knows
+ * Pi exists. It is a factory over a `pi`-shaped object so the suite can drive the
+ * five events directly, and so `#394` can add a second sink without touching how
+ * the session is observed.
+ *
+ * Two decisions worth knowing when reading it:
+ *
+ *  - **The unit comes from the command that was dispatched**, resolved against
+ *    the project's own directories. A session that ran no unit-scoped command
+ *    emits nothing: a sample without a unit would be a row the ledger cannot
+ *    attribute, which is worse than no row.
+ *  - **The sample names its session.** The sink's idempotency guard compares a
+ *    whole row, so the session id in `source` is what keeps a second session of
+ *    the same unit — the same day, the same tree — from being written over.
+ *  - **Off registers no listener at all.** A listener that wakes up to find itself
+ *    disabled is a cost with no feature, so `enabled: false` means `pi.on` is
+ *    never called.
+ */
+import { type TelemetrySink } from "../session-telemetry.js";
+/** The events this wiring listens to. */
+export declare const TELEMETRY_EVENTS: readonly ["session_start", "turn_start", "turn_end", "tool_execution_end", "session_shutdown"];
+/** The slice of `pi` the wiring needs. Pi hands every handler its context. */
+export interface PiLike {
+    on(event: string, handler: (event?: unknown, ctx?: unknown) => void): void;
+}
+export interface TelemetryWiringOptions {
+    readonly root: string;
+    readonly enabled: boolean;
+    readonly sinks?: readonly TelemetrySink[];
+    /** Where the ledger lives, relative to `root`. */
+    readonly ledgerPath?: string;
+    /** How many paths this session changed; injected so the suite owns git too. */
+    readonly changedPaths?: () => number;
+    /** The HEAD the session started on, captured at `session_start`. */
+    readonly sessionStartSha?: () => string;
+    /**
+     * The id of the session being measured, so two sessions that touch the same
+     * unit on the same day are two samples instead of one. Read lazily: the
+     * caller already holds the live context when it builds the wiring.
+     */
+    readonly sessionId?: () => string | undefined;
+    readonly now?: () => number;
+    readonly date?: () => string;
+    readonly source?: string;
+}
+export interface TelemetryWiring {
+    /** Note a dispatched command, so the session knows which unit it is working on. */
+    noteCommand(command: string, args: readonly string[]): void;
+    register(pi: PiLike): void;
+}
+/**
+ * How many distinct paths this session touched: the commits since the HEAD it
+ * started on, plus whatever is still uncommitted. It is the session's own scope —
+ * not the branch's — because the sample is the session's cost, and a long-lived
+ * branch would otherwise be charged to whichever unit happened to end it.
+ */
+export declare function sessionChangedPaths(root: string, startSha: string): number;
+/**
+ * Build the wiring. Everything it cannot know is injected: the project root, the
+ * sinks, the clock, the path count, the session id and the session's starting
+ * commit.
+ */
+export declare function createTelemetryWiring(options: TelemetryWiringOptions): TelemetryWiring;