agent-tempo 1.5.1 → 1.6.1

package/dist/pi/cue-pump.js

@@ -1,6 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CuePump = void 0;
+exports.buildPiInjector = buildPiInjector;
+/**
+ * Build the per-tick {@link MessageInjector} from the live runtime, PREFERRING the
+ * stable `pi.sendMessage` handle (interactive root-cause fix, #677) and falling
+ * back to `session.sendCustomMessage` only when `pi.sendMessage` is unavailable.
+ * Pure + feature-detected (`typeof`) so it's safe whatever Pi build is loaded and
+ * unit-testable without a real Pi.
+ */
+function buildPiInjector(rt) {
+    if (!rt)
+        return null;
+    const pi = rt.pi;
+    const send = typeof pi?.sendMessage === 'function' ? pi.sendMessage.bind(pi) : null;
+    if (send) {
+        const sendUser = typeof pi?.sendUserMessage === 'function' ? pi.sendUserMessage.bind(pi) : null;
+        return {
+            inject: (msg, opts) => send(msg, opts),
+            // #688 — escalate with `deliverAs: 'followUp'`. maybeEscalate can fire while a
+            // turn is ALREADY in flight (one that started BEFORE the inject — a busy
+            // false-positive), and a bare sendUserMessage (no deliverAs) while Pi is
+            // streaming throws "Agent is already processing". followUp is correct in BOTH
+            // cases: cold-idle (behavior ignored → the user message still starts a turn,
+            // escalation works) and busy (queues + drains in order, no throw). NOT 'steer'
+            // — steer would let a peer cue preempt the operator's in-flight turn, breaking
+            // the operator-vs-peer guarantee (see file header).
+            ...(sendUser ? { escalate: (text) => sendUser(text, { deliverAs: 'followUp' }) } : {}),
+            lastTurnStartAt: () => rt.lastTurnStartAt,
+        };
+    }
+    const session = rt.session;
+    if (session) {
+        return {
+            inject: (msg, opts) => session.sendCustomMessage(msg, opts),
+            lastTurnStartAt: () => rt.lastTurnStartAt,
+        };
+    }
+    return null;
+}
 const DEFAULT_POLL_MS = 1_000;
 const log = (...args) => {
     // eslint-disable-next-line no-console
@@ -8,14 +46,22 @@ const log = (...args) => {
 };
 class CuePump {
     source;
-    resolveSession;
+    resolveInjector;
     intervalMs;
+    now;
     timer = null;
     draining = false;
+    /**
+     * The last cue injected via the escalation-eligible `pi.sendMessage` route,
+     * pending a turn-start check on the next tick. Cleared once a turn starts or
+     * once escalated (escalate-once invariant).
+     */
+    lastInject = null;
     constructor(opts) {
         this.source = opts.source;
-        this.resolveSession = opts.resolveSession;
+        this.resolveInjector = opts.resolveInjector;
         this.intervalMs = opts.intervalMs ?? DEFAULT_POLL_MS;
+        this.now = opts.now ?? Date.now;
     }
     start() {
         if (this.timer)
@@ -33,28 +79,40 @@ class CuePump {
         }
     }
     /**
-     * One poll cycle: fetch pending cues, inject each into the live session, ack
-     * the ones successfully injected. Re-entrancy guarded so a slow tick never
-     * overlaps the next interval.
+     * One poll cycle: (1) escalate a previously-injected cue that never woke a turn,
+     * then (2) fetch pending cues, inject each into the live agent, ack the ones
+     * successfully injected. Re-entrancy guarded so a slow tick never overlaps the
+     * next interval.
      */
     async tick() {
         if (this.draining)
             return;
         this.draining = true;
         try {
+            const injector = this.resolveInjector();
+            // (1) Escalation check — runs even with no new pending. If the previous
+            // tick injected a cue via pi.sendMessage and NO turn has started since, the
+            // cue may be sitting in a cold-idle agent's queue unprocessed → re-inject as
+            // a user message (which always wakes a turn). Once per cue.
+            await this.maybeEscalate(injector);
             const pending = await this.source.fetchPending();
             if (pending.length === 0)
                 return;
-            const session = this.resolveSession();
-            if (!session) {
-                // No live session yet — leave cues queued; next tick retries.
+            if (!injector) {
+                // No live injection target yet (no `pi` handle / session) — leave cues
+                // queued; next tick retries once an instance attaches/rebinds. Logged so a
+                // live bring-up can see cues are HELD (not lost) while waiting to attach.
+                log(`no live injector — holding ${pending.length} cue(s) for next tick`);
                 return;
             }
             const delivered = [];
+            let lastDeliveredText = null;
             for (const msg of pending) {
+                const content = msg.from ? `[cue from ${msg.from}] ${msg.text}` : msg.text;
                 try {
-                    await this.injectCue(session, msg);
+                    await this.injectCue(injector, msg, content);
                     delivered.push(msg.id);
+                    lastDeliveredText = content;
                 }
                 catch (err) {
                     log(`failed to inject cue ${msg.id}:`, err);
@@ -63,18 +121,54 @@ class CuePump {
                 }
             }
             await this.source.ackDelivered(delivered);
+            // Track ONLY the LAST cue injected via the escalation-eligible route so the
+            // NEXT tick can re-inject it as a user message if no turn started. Tracking
+            // just the last is intentional and does NOT drop earlier cues' delivery:
+            // every cue in this batch was already injected via pi.sendMessage (queued in
+            // Pi), so they ALL drain once any turn starts — escalation only needs to WAKE
+            // a turn, and re-injecting one cue as a user message does exactly that. The
+            // session-fallback route omits `escalate` → no tracking.
+            if (injector.escalate && lastDeliveredText !== null) {
+                this.lastInject = { text: lastDeliveredText, injectedAt: this.now(), escalated: false };
+            }
         }
         finally {
             this.draining = false;
         }
     }
     /**
-     * Inject one cue into the live session (D10 — see file header). Operator cues
+     * If a previously sendMessage-injected cue has not been followed by a turn, the
+     * `triggerTurn` wake didn't take — re-inject the SAME cue as a user-role message
+     * (always starts a turn). Escalates at most once per cue; clears the tracker
+     * once a turn is observed.
+     */
+    async maybeEscalate(injector) {
+        const pending = this.lastInject;
+        if (!pending || pending.escalated)
+            return;
+        if (!injector?.escalate)
+            return;
+        const turnAt = injector.lastTurnStartAt();
+        if (turnAt !== null && turnAt >= pending.injectedAt) {
+            // A turn started after the inject → the cue was picked up; stop tracking.
+            this.lastInject = null;
+            return;
+        }
+        try {
+            await injector.escalate(pending.text);
+            pending.escalated = true;
+            log('escalated un-woken cue via sendUserMessage');
+        }
+        catch (err) {
+            log('cue escalation failed:', err);
+        }
+    }
+    /**
+     * Inject one cue into the live agent (D10 — see file header). Operator cues
      * `steer` (same-turn priority); peer cues `followUp` (queue). `triggerTurn` is
      * always set: a no-op mid-turn, the required cold-idle wake otherwise.
      */
-    async injectCue(session, msg) {
-        const content = msg.from ? `[cue from ${msg.from}] ${msg.text}` : msg.text;
+    async injectCue(injector, msg, content) {
         // LOAD-BEARING Pi-runtime invariant (D10) — confirmed sound through Pi 0.78.x
         // (researcher-cited; a D6 "behaviors-to-revalidate-on-bump" item):
         //   peer cue     = { deliverAs: 'followUp', triggerTurn: true } → QUEUES; drains
@@ -87,9 +181,10 @@ class CuePump {
         // The guarantee this comment protects: a future Pi version MUST keep followUp
         // non-interrupting AND triggerTurn a no-op-while-busy. If that regresses, peer
         // cues silently become preemptions, defeating operator-vs-peer. Not unit-testable
-        // here (the session is mocked) — locked by researcher confirmation + the D6 Pi
-        // version floor (≥ #2860 + #5115) + a real-Pi mid-turn integration smoke.
-        await session.sendCustomMessage({ customType: 'cue', content, display: true }, { deliverAs: msg.isMaestro ? 'steer' : 'followUp', triggerTurn: true });
+        // here (the injector is mocked) — locked by researcher confirmation + the D6 Pi
+        // version floor (≥ #2860 + #5115) + a real-Pi mid-turn integration smoke. The
+        // #677 sendUserMessage escalation is the belt-and-suspenders for a missed wake.
+        await injector.inject({ customType: 'cue', content, display: true }, { deliverAs: msg.isMaestro ? 'steer' : 'followUp', triggerTurn: true });
     }
 }
 exports.CuePump = CuePump;

package/dist/pi/extension.d.ts

@@ -9,21 +9,9 @@ import { InnerLoopPublisher } from './inner-loop-publisher';
 /** Runtime mode. Headless = recruited unsupervised player (MD-C gate active). */
 export type PiExtensionMode = 'interactive' | 'headless';
 export type PiToolAccess = 'restricted' | 'standard' | 'full';
-/**
- * B1 runtime guard (#645 H4) — the type gate's blind spot.
- *
- * `PiEventPayload.session` is UNDECLARED in Pi 0.78's `.d.ts` — it's an
- * interactive-only RUNTIME field, so the pi-drift type gate can't assert it. In
- * INTERACTIVE mode the `session_start` payload MUST carry `session` (the cue +
- * reset pumps inject into it); a null session there means injection is silently
- * inert — a likely Pi API drift. (Headless legitimately omits it — it wires
- * `rt.session` via `setRuntimeSession` — so the guard is interactive-only.)
- *
- * Pure + injected `warn` so it unit-tests without the workflow harness.
- */
-export declare function warnIfInteractiveSessionMissing(mode: PiExtensionMode, payload: {
+export declare function noteInteractiveSessionAbsent(mode: PiExtensionMode, payload: {
     session?: unknown;
-}, warn: (msg: string) => void): void;
+}, note: (msg: string) => void): void;
 export interface PiExtensionOptions {
     /** Default `'interactive'`. Headless installs the MD-C tool_call gate. */
     mode?: PiExtensionMode;
@@ -35,7 +23,7 @@ export interface PiExtensionOptions {
  * extension-instance rebuilds. Holds the durable attachment (handle + lease +
  * heartbeat, inside `wf`), the phase driver, the cue pump, and the session ptr.
  */
-interface PiPlayerRuntime {
+export interface PiPlayerRuntime {
     readonly workflowId: string;
     readonly wf: PiWorkflowClient;
     readonly driver: PhaseDriver;
@@ -50,6 +38,19 @@ interface PiPlayerRuntime {
     /** 3d D14 — polls the workflow's pending reset → clean-wipe (newSession) + ack. */
     readonly reset: ResetPump;
     session: PiAgentSession | null;
+    /**
+     * #677 — THIS player's CURRENT Pi `ExtensionAPI` handle. Repointed on every
+     * instance rebuild (`session_start` re-bind) so the cue pump injects through the
+     * live `pi.sendMessage` (the stable interactive-injection path; Pi 0.78.1's
+     * SessionStartEvent has no `session` field). Re-resolved per tick — never captured.
+     */
+    pi: ExtensionAPI | null;
+    /**
+     * #677 — epoch-ms of the last observed `turn_start`/`agent_start`. The cue pump
+     * reads it to decide whether a sendMessage-injected cue actually woke a turn; if
+     * not, it escalates to `sendUserMessage`. `null` until the first turn starts.
+     */
+    lastTurnStartAt: number | null;
     lastSessionId?: string;
 }
 /**
@@ -94,6 +95,19 @@ export declare function __seedRuntimeForTests(workflowId: string, rt: PiPlayerRu
  * for the full singleton reset). TEST ESCAPE HATCH — do NOT call from production code.
  */
 export declare function __clearRuntimesForTests(): void;
+/**
+ * Read the live runtime for a workflowId out of the module-scope map. TEST ESCAPE
+ * HATCH — do NOT call from production code. Used by the #677 rebind test to assert
+ * the post-switch tick injects through the NEW pi (cue pump) AND that the
+ * InnerLoopPublisher rebound to it.
+ */
+export declare function __getPiRuntimeForTests(workflowId: string): PiPlayerRuntime | undefined;
+/**
+ * Reset the one-time interactive-session breadcrumb flag (#677). TEST ESCAPE HATCH
+ * — do NOT call from production code. The flag is module-scope and fires at most
+ * once per process, so tests asserting the note must reset it between cases.
+ */
+export declare function __resetInteractiveSessionNoteForTests(): void;
 /** Default export — interactive-mode extension (the human `pi` CLI entry). */
 declare const piExtension: (pi: ExtensionAPI) => void;
 export default piExtension;

package/dist/pi/extension.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnIfInteractiveSessionMissing = warnIfInteractiveSessionMissing;
+exports.noteInteractiveSessionAbsent = noteInteractiveSessionAbsent;
 exports.createPiExtension = createPiExtension;
 exports.detachAllPiRuntimesForExit = detachAllPiRuntimesForExit;
 exports.setRuntimeSession = setRuntimeSession;
@@ -41,6 +41,8 @@ exports.__setPiClientFactoryForTests = __setPiClientFactoryForTests;
 exports.__resetPiRuntimesForTests = __resetPiRuntimesForTests;
 exports.__seedRuntimeForTests = __seedRuntimeForTests;
 exports.__clearRuntimesForTests = __clearRuntimesForTests;
+exports.__getPiRuntimeForTests = __getPiRuntimeForTests;
+exports.__resetInteractiveSessionNoteForTests = __resetInteractiveSessionNoteForTests;
 /**
  * agent-tempo Pi extension — interactive (Phase 2) + headless (Phase 3a) runtime.
  *
@@ -93,24 +95,37 @@ const log = (...args) => {
     console.error('[agent-tempo:pi]', ...args);
 };
 const nowIso = () => new Date().toISOString();
-const PI_AGENT_TYPE = 'claude'; // Pi is not yet a first-class AgentType.
+// Pi IS a first-class AgentType (#666). #676 FIX-2: was a stale 'claude'
+// placeholder — that made a Pi session misreport its agentType metadata AND
+// recruit's mirror-fallback resolve to 'claude'.
+const PI_AGENT_TYPE = 'pi';
 /**
- * B1 runtime guard (#645 H4) — the type gate's blind spot.
+ * Interactive-session breadcrumb (#645 H4 → reworded for #677).
  *
- * `PiEventPayload.session` is UNDECLARED in Pi 0.78's `.d.ts` — it's an
- * interactive-only RUNTIME field, so the pi-drift type gate can't assert it. In
- * INTERACTIVE mode the `session_start` payload MUST carry `session` (the cue +
- * reset pumps inject into it); a null session there means injection is silently
- * inert — a likely Pi API drift. (Headless legitimately omits it — it wires
- * `rt.session` via `setRuntimeSession` — so the guard is interactive-only.)
+ * Pi 0.78.1's `SessionStartEvent` carries NO `session` field, so in INTERACTIVE
+ * mode `payload.session` is null. Pre-#677 that meant cue/reset injection was inert
+ * (it read `payload.session`), so this was a WARNING. Post-#677 injection routes
+ * through the stable `pi.sendMessage` handle (re-resolved per tick) and a missing
+ * session is the EXPECTED path — NOT an error. The "is `pi.sendMessage` still
+ * wired?" correctness signal now lives at BUILD time in the H4 drift gate
+ * (`test/pi-drift/assert.ts` `_passSendMsg` / `_sendSurfaceCallShape`), so this
+ * runtime check's correctness role is redundant.
  *
- * Pure + injected `warn` so it unit-tests without the workflow harness.
+ * What remains is value as a ONE-TIME, non-alarming boot breadcrumb: during Pi
+ * bring-up it confirms at a glance "you're on the expected 0.78.1 no-session path;
+ * cues route via pi.sendMessage." Fires AT MOST ONCE per process (the
+ * module-scope `notedInteractiveSessionAbsent` flag) — not per switch, not per
+ * tick. Pure + injected `note` so it unit-tests without the workflow harness.
  */
-function warnIfInteractiveSessionMissing(mode, payload, warn) {
-    if (mode === 'interactive' && payload.session == null) {
-        warn('WARNING: interactive session_start carried no session — cue/reset injection inert; ' +
-            'possible Pi API drift (#645)');
-    }
+let notedInteractiveSessionAbsent = false;
+function noteInteractiveSessionAbsent(mode, payload, note) {
+    if (mode !== 'interactive' || payload.session != null)
+        return;
+    if (notedInteractiveSessionAbsent)
+        return;
+    notedInteractiveSessionAbsent = true;
+    note('interactive session_start has no `session` field — expected on Pi ≥0.78.1; ' +
+        'cues/reset route via pi.sendMessage (re-resolved per tick).');
 }
 // MD-C shell/exec tool-class membership is owned by `tool-capability.ts`
 // (`classify(name) === 'exec'`, content signed off by tempo-security). F1
@@ -173,6 +188,21 @@ function createPiExtension(options = {}) {
         };
         (0, render_tools_1.renderToPi)(pi, (0, server_tools_1.buildAllTempoTools)(toolOpts));
         log(`registered tools (player=${currentPlayerId}, conductor=${isConductor}, mode=${mode})`);
+        // ── #677 PART B — interactive-only `/tempo-reset` command ──
+        // Pi's `newSession` (clean-wipe) is ExtensionCommandContext-ONLY (not on the
+        // SDK session), so an interactive Pi conductor can ONLY be reset by the operator
+        // running this command. The reset pump's interactive branch notifies the
+        // operator to run it when a peer/conductor requests a reset (operator-mediated
+        // is the ceiling). Headless players have no command surface → not registered.
+        if (mode === 'interactive' && typeof pi.registerCommand === 'function') {
+            pi.registerCommand('tempo-reset', {
+                description: "Clean-wipe this Pi session's context (agent-tempo reset).",
+                handler: async (_args, ctx) => {
+                    log('/tempo-reset — clean-wiping session context (newSession)');
+                    await ctx.newSession();
+                },
+            });
+        }
         // ── MD-C tool-access gate (HEADLESS ONLY) ──
         // Interactive Pi = a human owns their machine → no gate. Headless = recruited
         // unsupervised → MD-C governs tool access. TOOL-CLASS CHECK FIRST: shell/exec
@@ -258,6 +288,16 @@ function createPiExtension(options = {}) {
             const existing = runtimes.get(workflowId);
             if (existing) {
                 existing.session = payload.session ?? existing.session;
+                // #677 — repoint to THIS instance's `pi`. Pi rebuilds the extension
+                // instance on every session switch; the surviving runtime + its cue pump
+                // (created on first attach) re-resolve the injector from `rt.pi` each tick,
+                // so the cue pump injects through the LIVE handle, not the stale one.
+                existing.pi = pi;
+                // #677 FREEBIE — the InnerLoopPublisher was captured-once on the FIRST pi
+                // and goes stale after a switch (README:251 carry-item — same root cause).
+                // Re-start it on the new pi so its `pi.on(...)` observers track the live
+                // instance. `start()` re-registers handlers; its flush timer is idempotent.
+                existing.pub.start(pi);
                 log(`re-bound ${currentPlayerId} (Pi instance rebuilt; lease intact)`);
                 return existing;
             }
@@ -271,7 +311,11 @@ function createPiExtension(options = {}) {
             const driver = new phase_driver_1.PhaseDriver();
             const pump = new cue_pump_1.CuePump({
                 source: wf,
-                resolveSession: () => runtimes.get(workflowId)?.session ?? null,
+                // #677 — re-resolve the injector from the SURVIVING runtime each tick:
+                // prefer `rt.pi.sendMessage` (stable interactive path), fall back to
+                // `rt.session.sendCustomMessage`. Reading `runtimes.get(workflowId)` (not a
+                // captured `rt`) is what makes a post-rebind tick use the NEW pi.
+                resolveInjector: () => (0, cue_pump_1.buildPiInjector)(runtimes.get(workflowId) ?? null),
             });
             // 3c — inner-loop publisher + its loopback-HTTP sink. The client no-ops
             // unless AGENT_TEMPO_INGEST_TOKEN is present (daemon-spawned headless
@@ -285,8 +329,16 @@ function createPiExtension(options = {}) {
             const reset = new reset_pump_1.ResetPump({
                 source: wf,
                 resolveSession: () => runtimes.get(workflowId)?.session ?? null,
+                // #677 PART B — interactive can't auto-wipe (no session field / newSession is
+                // command-context-only); the reset pump notifies the operator via this handle.
+                resolvePi: () => runtimes.get(workflowId)?.pi ?? null,
             });
-            const rt = { workflowId, wf, driver, pump, pub, reset, session: payload.session ?? null };
+            const rt = {
+                workflowId, wf, driver, pump, pub, reset,
+                session: payload.session ?? null,
+                pi, // #677 — first-attach instance's pi (repointed on each rebind)
+                lastTurnStartAt: null,
+            };
             runtimes.set(workflowId, rt);
             await wf.ensureSessionWorkflow();
             const result = driver.handle('session_start', payload, nowIso());
@@ -303,8 +355,9 @@ function createPiExtension(options = {}) {
         }
         // ── Lifecycle: session_start → first attach OR re-bind ──
         pi.on('session_start', async (payload) => {
-            // B1 (#645 H4): warn loudly if interactive session_start lost its session.
-            warnIfInteractiveSessionMissing(mode, payload, log);
+            // #677: one-time INFO breadcrumb when interactive session_start has no
+            // `session` field (the expected 0.78.1 path — injection routes via pi.sendMessage).
+            noteInteractiveSessionAbsent(mode, payload, log);
             try {
                 const rt = await attachOrRebind(payload);
                 await refreshSessionId(rt, rt.session?.id);
@@ -321,6 +374,10 @@ function createPiExtension(options = {}) {
                     return;
                 if (payload.session)
                     rt.session = payload.session;
+                // #677 — a turn has begun → stamp for the cue pump's escalation check (so
+                // a sendMessage-injected cue that DID wake a turn is not re-escalated).
+                if (event === 'agent_start')
+                    rt.lastTurnStartAt = Date.now();
                 const result = rt.driver.handle(event, payload, nowIso());
                 try {
                     await rt.wf.performAction(result.action);
@@ -342,6 +399,9 @@ function createPiExtension(options = {}) {
                     return;
                 if (payload.session)
                     rt.session = payload.session;
+                // #677 — turn_start marks a live turn for the cue pump's escalation check.
+                if (event === 'turn_start')
+                    rt.lastTurnStartAt = Date.now();
                 rt.driver.handle(event, payload, nowIso());
             });
         }
@@ -441,6 +501,23 @@ function __seedRuntimeForTests(workflowId, rt) {
 function __clearRuntimesForTests() {
     runtimes.clear();
 }
+/**
+ * Read the live runtime for a workflowId out of the module-scope map. TEST ESCAPE
+ * HATCH — do NOT call from production code. Used by the #677 rebind test to assert
+ * the post-switch tick injects through the NEW pi (cue pump) AND that the
+ * InnerLoopPublisher rebound to it.
+ */
+function __getPiRuntimeForTests(workflowId) {
+    return runtimes.get(workflowId);
+}
+/**
+ * Reset the one-time interactive-session breadcrumb flag (#677). TEST ESCAPE HATCH
+ * — do NOT call from production code. The flag is module-scope and fires at most
+ * once per process, so tests asserting the note must reset it between cases.
+ */
+function __resetInteractiveSessionNoteForTests() {
+    notedInteractiveSessionAbsent = false;
+}
 /** Default export — interactive-mode extension (the human `pi` CLI entry). */
 const piExtension = createPiExtension();
 exports.default = piExtension;

package/dist/pi/index.d.ts

@@ -18,8 +18,8 @@ export { PhaseDriver } from './phase-driver';
 export type { PiPhase, WorkflowAction, PhaseDriverResult } from './phase-driver';
 export { PiWorkflowClient } from './workflow-client';
 export type { PiWorkflowClientOptions } from './workflow-client';
-export { CuePump } from './cue-pump';
-export type { CueSource, SessionResolver, CuePumpOptions } from './cue-pump';
+export { CuePump, buildPiInjector } from './cue-pump';
+export type { CueSource, MessageInjector, InjectorResolver, InjectorRuntime, CuePumpOptions, } from './cue-pump';
 export { renderToPi, toPiResult } from './render-tools';
 export { createLazyProxy } from './lazy-proxy';
 export { zodShapeToTypeBox, UnsupportedZodFeatureError } from './zod-to-typebox';

package/dist/pi/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PI_NODE_FLOOR = exports.TESTED_PI_VERSION = exports.PI_AI_PACKAGE = exports.PI_PACKAGE = exports.probePi = exports.UnsupportedZodFeatureError = exports.zodShapeToTypeBox = exports.createLazyProxy = exports.toPiResult = exports.renderToPi = exports.CuePump = exports.PiWorkflowClient = exports.PhaseDriver = exports.default = void 0;
+exports.PI_NODE_FLOOR = exports.TESTED_PI_VERSION = exports.PI_AI_PACKAGE = exports.PI_PACKAGE = exports.probePi = exports.UnsupportedZodFeatureError = exports.zodShapeToTypeBox = exports.createLazyProxy = exports.toPiResult = exports.renderToPi = exports.buildPiInjector = exports.CuePump = exports.PiWorkflowClient = exports.PhaseDriver = exports.default = void 0;
 /**
  * agent-tempo Pi integration — barrel.
  *
@@ -27,6 +27,7 @@ var workflow_client_1 = require("./workflow-client");
 Object.defineProperty(exports, "PiWorkflowClient", { enumerable: true, get: function () { return workflow_client_1.PiWorkflowClient; } });
 var cue_pump_1 = require("./cue-pump");
 Object.defineProperty(exports, "CuePump", { enumerable: true, get: function () { return cue_pump_1.CuePump; } });
+Object.defineProperty(exports, "buildPiInjector", { enumerable: true, get: function () { return cue_pump_1.buildPiInjector; } });
 var render_tools_1 = require("./render-tools");
 Object.defineProperty(exports, "renderToPi", { enumerable: true, get: function () { return render_tools_1.renderToPi; } });
 Object.defineProperty(exports, "toPiResult", { enumerable: true, get: function () { return render_tools_1.toPiResult; } });

package/dist/pi/pi-types.d.ts

@@ -243,10 +243,60 @@ export interface PiToolDefinition {
      */
     execute: (toolCallId: string, params: Record<string, unknown>, signal?: unknown, onUpdate?: unknown, ctx?: unknown) => Promise<PiToolResult> | PiToolResult;
 }
+/**
+ * The context Pi passes to a registered command handler (#677 PART B). NARROW
+ * structural slice — `/tempo-reset` only calls `newSession()` (clean-wipe).
+ * Pi's real `ExtensionCommandContext` (much larger) is assignable to this.
+ *
+ * `newSession` is command-context-ONLY in Pi — it is NOT on the SDK session
+ * object — which is exactly why an interactive Pi conductor CANNOT be auto-reset:
+ * the reset pump can only NOTIFY the operator to run `/tempo-reset` themselves
+ * (operator-mediated is the ceiling; see reset-pump.ts).
+ */
+export interface PiCommandContext {
+    /** Start a FRESH session (clean-wipe, no replay). */
+    newSession(): Promise<{
+        cancelled: boolean;
+    }>;
+}
+/** Options for {@link ExtensionAPI.registerCommand} (#677 PART B) — the slice we set. */
+export interface PiCommandOptions {
+    description?: string;
+    handler: (args: string, ctx: PiCommandContext) => Promise<void>;
+}
 /** The `pi` object passed to `export default function(pi: ExtensionAPI) {}`. */
 export interface ExtensionAPI {
     on(event: PiLifecycleEvent | string, handler: PiEventHandler): void;
     registerTool(def: PiToolDefinition): void;
+    /**
+     * Register an interactive slash command (#677 PART B — `/tempo-reset`). Optional
+     * in the slice: only the interactive Pi CLI surfaces commands (headless has no
+     * command surface). Kept loose by the architect's registerCommand ruling — see
+     * test/pi-drift/assert.ts `_registerSurfaceExists`.
+     */
+    registerCommand?(name: string, options: PiCommandOptions): void;
+    /**
+     * Inject a custom message into the live session through the STABLE `pi` handle
+     * (#677). Same message shape as `PiAgentSession.sendCustomMessage`'s param0
+     * (`Pick<CustomMessage, "customType"|"content"|"display"|"details">`). This is
+     * the interactive cue-injection path: Pi 0.78.1's `SessionStartEvent` carries
+     * NO `session` field, so `PiEventPayload.session` is null in interactive mode —
+     * routing cues through `pi.sendMessage` (re-resolved per tick from the surviving
+     * runtime) injects reliably regardless. Optional in the slice (Pi provides it; a
+     * fake/older Pi may not — the cue pump feature-detects with `typeof`).
+     */
+    sendMessage?(message: PiOutboundMessage, options?: PiCustomMessageOptions): void;
+    /**
+     * Inject a USER-role message — ALWAYS triggers a turn (#677 escalation path).
+     * When `sendMessage`'s `triggerTurn` fails to wake a cold-idle agent, the cue
+     * pump re-injects the SAME cue via this user-role call (a user message always
+     * starts a turn). It LOSES the `cue` customType + operator-vs-peer steer/followUp
+     * semantics, so it is FALLBACK-ONLY (never the primary route). Optional in the
+     * slice for the same reason as `sendMessage`.
+     */
+    sendUserMessage?(content: string, options?: {
+        deliverAs?: 'steer' | 'followUp';
+    }): void;
 }
 /** An extension is a default-exported function receiving the `ExtensionAPI`. */
 export type PiExtension = (pi: ExtensionAPI) => void | Promise<void>;