pi-smart-router 0.6.0 → 0.7.0

package/.pi/extensions/smart-router/commands.ts

@@ -105,6 +105,38 @@ export function getSmartRouterArgumentCompletions(prefix: string): CompletionIte
   return filtered.length > 0 ? filtered : null;
 }
 
+/** Throw AbortError when ESC / ctx.signal has cancelled the command. */
+export function throwIfCommandAborted(signal: AbortSignal | undefined): void {
+  if (!signal?.aborted) {
+    return;
+  }
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    throw reason;
+  }
+  const error = new Error(typeof reason === 'string' && reason.length > 0 ? reason : 'Aborted');
+  error.name = 'AbortError';
+  throw error;
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === 'AbortError';
+}
+
+/**
+ * Wrap fetch so LiteLLM pricing requests honor ctx.signal without changing
+ * refreshPricingCatalog's signature (out of File Scope for SP-172).
+ */
+export function createSignalAwareFetch(signal: AbortSignal | undefined): typeof fetch | undefined {
+  if (!signal) {
+    return undefined;
+  }
+  return ((input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+    throwIfCommandAborted(signal);
+    return fetch(input, { ...init, signal });
+  }) as typeof fetch;
+}
+
 export function registerSmartRouterCommand(
   pi: ExtensionAPI,
   runtime: SmartRouterRuntime,
@@ -117,6 +149,7 @@ export function registerSmartRouterCommand(
       try {
         bindSharedModelRegistry(runtime, ctx.modelRegistry);
         const parsed = parseSmartRouterArgs(args);
+        const signal = ctx.signal;
 
         if (parsed.command === 'status') {
           ctx.ui.notify(formatStatusMessage(runtime, runtime.lastDecision), 'info');
@@ -124,13 +157,21 @@ export function registerSmartRouterCommand(
         }
 
         if (parsed.command === 'history') {
+          throwIfCommandAborted(signal);
           const rows = await runtime.store.listTelemetry({ limit: parsed.limit });
+          throwIfCommandAborted(signal);
           ctx.ui.notify(formatHistoryMessage(rows), 'info');
           return;
         }
 
         if (parsed.command === 'pricing') {
-          const { modelCount, lastUpdated } = await refreshPricingCatalog(runtime);
+          throwIfCommandAborted(signal);
+          const { modelCount, lastUpdated } = await refreshPricingCatalog(
+            runtime,
+            createSignalAwareFetch(signal),
+          );
+          // Abort before fleet mutation so cancel does not leave a half-rebuilt fleet.
+          throwIfCommandAborted(signal);
           await rebuildFleet(runtime, pi, ctx.cwd);
           ctx.ui.notify(
             `Pricing refreshed: ${modelCount} models loaded (last_updated: ${lastUpdated}). Fleet rebuilt (${runtime.streamDeps.fleet.length} models).`,
@@ -140,6 +181,7 @@ export function registerSmartRouterCommand(
         }
 
         if (parsed.command === 'export' && parsed.subcommand === 'dataset') {
+          throwIfCommandAborted(signal);
           const result = await exportDatasetToFile(runtime.store, ctx.cwd, parsed.limit);
           if (!result) {
             ctx.ui.notify('No routing dataset records to export.', 'info');
@@ -153,6 +195,7 @@ export function registerSmartRouterCommand(
         }
 
         if (parsed.command === 'export' && parsed.subcommand === 'telemetry-contrib') {
+          throwIfCommandAborted(signal);
           const result = await exportTelemetryContrib({
             store: runtime.store,
             cwd: ctx.cwd,
@@ -226,6 +269,7 @@ export function registerSmartRouterCommand(
           return;
         }
 
+        throwIfCommandAborted(signal);
         runtime.fleetMode = parsed.mode;
         await rebuildFleet(runtime, pi, ctx.cwd);
         pi.appendEntry(FLEET_MODE_ENTRY_TYPE, { mode: parsed.mode });
@@ -234,6 +278,10 @@ export function registerSmartRouterCommand(
           'info',
         );
       } catch (error) {
+        if (isAbortError(error) || ctx.signal?.aborted) {
+          ctx.ui.notify('Cancelled.', 'info');
+          return;
+        }
         const message = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(message, 'error');
       }

package/.pi/extensions/smart-router/delegate-stream.ts

@@ -2,6 +2,7 @@ import {
   type Api,
   type AssistantMessage,
   type AssistantMessageEvent,
+  type AssistantMessageEventStream,
   type Context,
   type Model,
   type SimpleStreamOptions,
@@ -11,13 +12,31 @@ import {
 import { parseAssistantMessageError } from '../../../src/infrastructure/delegation/provider-error.js';
 import {
   buildDelegationContext,
+  forwardDelegatedEvent,
   modelToExecutionModel,
+  pushFailoverNotice,
   resolveDelegationOptions,
   type DelegatedStreamResult,
   type DelegationHeadroomContext,
+  type FailoverNoticeInfo,
+  type FlushDelegatedEventsOptions,
 } from './delegation-runtime.js';
 import type { StreamDelegationDeps } from './types.js';
+import { throwIfAborted } from './utils.js';
 
+function isTerminalEvent(
+  event: AssistantMessageEvent,
+): event is Extract<AssistantMessageEvent, { type: 'done' | 'error' }> {
+  return event.type === 'done' || event.type === 'error';
+}
+
+/**
+ * Buffer the full inner stream (no outer push).
+ *
+ * Used by the planning-delegate ephemeral sub-call: only the final observation
+ * text is injected into primary context — intermediate tokens must not reach the
+ * user-facing outer stream (SP-170: planning stays buffered by design).
+ */
 export async function collectDelegatedStream(
   targetModel: Model<Api>,
   context: Context,
@@ -25,9 +44,7 @@ export async function collectDelegatedStream(
   options: SimpleStreamOptions | undefined,
   headroomContext?: DelegationHeadroomContext,
 ): Promise<DelegatedStreamResult> {
-  if (options?.signal?.aborted) {
-    throw new Error('Request was aborted');
-  }
+  throwIfAborted(options);
 
   const delegationOptions = await resolveDelegationOptions(
     deps.modelRegistry,
@@ -41,9 +58,7 @@ export async function collectDelegatedStream(
   let finalMessage: AssistantMessage | undefined;
 
   for await (const event of inner) {
-    if (options?.signal?.aborted) {
-      throw new Error('Request was aborted');
-    }
+    throwIfAborted(options);
     events.push(event);
 
     if (event.type === 'done') {
@@ -60,31 +75,145 @@ export async function collectDelegatedStream(
   return { finalMessage, failed, events };
 }
 
-export async function delegateWithOutcome(
+export interface PipeDelegatedStreamOptions extends FlushDelegatedEventsOptions {
+  readonly outer: AssistantMessageEventStream;
+  /**
+   * When set, push a synthetic failover `text_delta` immediately after the first
+   * live `start` event (before further retry tokens).
+   */
+  readonly failoverNotice?: FailoverNoticeInfo;
+  /**
+   * When true (default), forward non-terminal events live and hold `done`/`error`
+   * until {@link commitPipedTerminal}. Set false to buffer only (no outer push).
+   */
+  readonly live?: boolean;
+}
+
+export interface PipedDelegatedStreamResult extends DelegatedStreamResult {
+  /** Terminal event held back so callers can decide failover before commit. */
+  readonly heldTerminal: AssistantMessageEvent | undefined;
+  readonly flushOptions: FlushDelegatedEventsOptions;
+  readonly outer: AssistantMessageEventStream | undefined;
+}
+
+/**
+ * Live-pipe provider events to `outer` as they arrive (SP-170).
+ *
+ * Non-terminal events (`start`, `text_delta`, …) are forwarded immediately so the
+ * UI is not frozen. Terminal `done`/`error` are held until the caller commits or
+ * discards them (failover discards without ending the outer stream).
+ */
+export async function pipeDelegatedStream(
   targetModel: Model<Api>,
   context: Context,
   deps: StreamDelegationDeps,
   options: SimpleStreamOptions | undefined,
-  sessionId: string | undefined,
-  headroomContext?: DelegationHeadroomContext,
-): Promise<DelegatedStreamResult> {
-  const delegationContext = buildDelegationContext(
-    context,
-    targetModel,
-    deps,
-    sessionId,
-  );
+  headroomContext: DelegationHeadroomContext | undefined,
+  pipe: PipeDelegatedStreamOptions,
+): Promise<PipedDelegatedStreamResult> {
+  throwIfAborted(options);
 
-  const result = await collectDelegatedStream(
+  const delegationOptions = await resolveDelegationOptions(
+    deps.modelRegistry,
     targetModel,
-    delegationContext,
-    deps,
     options,
     headroomContext,
   );
+  const delegateStream = deps.delegateStream ?? defaultDelegateStream;
+  const inner = delegateStream(targetModel, context, delegationOptions);
+  const events: AssistantMessageEvent[] = [];
+  let finalMessage: AssistantMessage | undefined;
+  let heldTerminal: AssistantMessageEvent | undefined;
+  let noticePushed = false;
+  const live = pipe.live !== false;
+  const flushOptions: FlushDelegatedEventsOptions = {
+    ...(pipe.sanitizeErrors !== undefined
+      ? { sanitizeErrors: pipe.sanitizeErrors }
+      : {}),
+    ...(pipe.contextWindow !== undefined
+      ? { contextWindow: pipe.contextWindow }
+      : {}),
+  };
+
+  for await (const event of inner) {
+    throwIfAborted(options);
+    events.push(event);
+
+    if (event.type === 'done') {
+      finalMessage = event.message;
+      heldTerminal = event;
+      continue;
+    }
+    if (event.type === 'error') {
+      finalMessage = event.error;
+      heldTerminal = event;
+      continue;
+    }
+
+    if (!live) {
+      continue;
+    }
 
+    forwardDelegatedEvent(pipe.outer, event, flushOptions);
+
+    if (
+      !noticePushed &&
+      pipe.failoverNotice &&
+      event.type === 'start'
+    ) {
+      pushFailoverNotice(pipe.outer, pipe.failoverNotice, event.partial);
+      noticePushed = true;
+    }
+  }
+
+  // Error-only streams never emit `start` — still surface the notice before commit
+  // when the caller is about to show a successful retry that also lacked start
+  // (handled by commit path via leftover failoverNotice on next pipe call).
+
+  const failed =
+    finalMessage !== undefined &&
+    (finalMessage.stopReason === 'error' || finalMessage.stopReason === 'aborted');
+
+  return {
+    finalMessage,
+    failed,
+    events,
+    heldTerminal,
+    flushOptions,
+    outer: pipe.outer,
+  };
+}
+
+/** Forward a held terminal event and end the outer stream. */
+export function commitPipedTerminal(
+  result: PipedDelegatedStreamResult,
+  overrides?: FlushDelegatedEventsOptions,
+): void {
+  const outer = result.outer;
+  if (!outer) {
+    return;
+  }
+  const opts = { ...result.flushOptions, ...overrides };
+  if (result.heldTerminal) {
+    forwardDelegatedEvent(outer, result.heldTerminal, opts);
+  }
+  const endMessage =
+    result.heldTerminal && isTerminalEvent(result.heldTerminal)
+      ? result.heldTerminal.type === 'done'
+        ? result.heldTerminal.message
+        : result.heldTerminal.error
+      : result.finalMessage;
+  outer.end(endMessage);
+}
+
+function recordDelegateOutcome(
+  targetModel: Model<Api>,
+  deps: StreamDelegationDeps,
+  sessionId: string | undefined,
+  result: DelegatedStreamResult,
+): void {
   if (!result.finalMessage) {
-    return result;
+    return;
   }
 
   if (result.failed) {
@@ -100,6 +229,46 @@ export async function delegateWithOutcome(
       id: targetModel.id,
     });
   }
+}
+
+/**
+ * Delegate with outcome recording. When `pipe` is provided, live-forwards to outer
+ * (holding the terminal event). Otherwise collects into a buffer (planning / probes).
+ */
+export async function delegateWithOutcome(
+  targetModel: Model<Api>,
+  context: Context,
+  deps: StreamDelegationDeps,
+  options: SimpleStreamOptions | undefined,
+  sessionId: string | undefined,
+  headroomContext?: DelegationHeadroomContext,
+  pipe?: PipeDelegatedStreamOptions,
+): Promise<PipedDelegatedStreamResult | DelegatedStreamResult> {
+  const delegationContext = buildDelegationContext(
+    context,
+    targetModel,
+    deps,
+    sessionId,
+  );
+
+  const result = pipe
+    ? await pipeDelegatedStream(
+        targetModel,
+        delegationContext,
+        deps,
+        options,
+        headroomContext,
+        pipe,
+      )
+    : await collectDelegatedStream(
+        targetModel,
+        delegationContext,
+        deps,
+        options,
+        headroomContext,
+      );
+
+  recordDelegateOutcome(targetModel, deps, sessionId, result);
 
   return result;
 }

package/.pi/extensions/smart-router/delegation-runtime.ts

@@ -271,6 +271,85 @@ export interface FlushDelegatedEventsOptions {
   readonly contextWindow?: number;
 }
 
+export interface FailoverNoticeInfo {
+  readonly failedModelId: string;
+  readonly alternateModelId: string;
+  readonly errorObj?: ReturnType<typeof parseAssistantMessageError>;
+}
+
+/** Build the operator-visible failover notice string. */
+export function buildFailoverNoticeText(
+  failedModelId: string,
+  alternateModelId: string,
+  errorObj?: ReturnType<typeof parseAssistantMessageError>,
+): string {
+  const reason = errorObj?.message || errorObj?.code || 'Unavailable';
+  return (
+    `> ⚠️ **pi-smart-router failover:** \`${failedModelId}\` failed (${reason}). ` +
+    `Retrying with \`${alternateModelId}\`...`
+  );
+}
+
+/**
+ * Push a synthetic failover `text_delta` to the live outer stream (SP-170).
+ * Call after the retry stream's `start` (or with a start partial) — no buffered-array mutation.
+ */
+export function pushFailoverNotice(
+  outer: AssistantMessageEventStream,
+  notice: FailoverNoticeInfo,
+  startPartial: AssistantMessage,
+): void {
+  const text = buildFailoverNoticeText(
+    notice.failedModelId,
+    notice.alternateModelId,
+    notice.errorObj,
+  );
+  const delta = `${text}\n\n`;
+  const partial: AssistantMessage = {
+    ...startPartial,
+    content: [{ type: 'text', text: delta }, ...startPartial.content],
+  };
+  outer.push({
+    type: 'text_delta',
+    contentIndex: 0,
+    delta,
+    partial,
+  });
+}
+
+/**
+ * Sanitize a single delegated event for live forwarding (length-stop + optional error UX).
+ */
+export function sanitizeDelegatedEvent(
+  event: AssistantMessageEvent,
+  options?: FlushDelegatedEventsOptions,
+): AssistantMessageEvent {
+  const lengthStopHints =
+    options?.contextWindow !== undefined
+      ? { contextWindow: options.contextWindow }
+      : undefined;
+  const events = [event];
+  sanitizeLengthStopEvents(events, lengthStopHints);
+  if (options?.sanitizeErrors) {
+    sanitizeDelegatedErrorEvents(events, lengthStopHints);
+  }
+  return events[0]!;
+}
+
+/** Push one sanitized event to the outer live stream (does not end the stream). */
+export function forwardDelegatedEvent(
+  outer: AssistantMessageEventStream,
+  event: AssistantMessageEvent,
+  options?: FlushDelegatedEventsOptions,
+): void {
+  outer.push(sanitizeDelegatedEvent(event, options));
+}
+
+/**
+ * Flush a buffered event list to outer and end the stream.
+ * Prefer live `forwardDelegatedEvent` / pipe paths for primary delegation (SP-170).
+ * Still used for terminal error-only buffers and legacy collect paths.
+ */
 export function flushDelegatedEvents(
   outer: AssistantMessageEventStream,
   events: readonly AssistantMessageEvent[],
@@ -291,15 +370,17 @@ export function flushDelegatedEvents(
   outer.end();
 }
 
+/**
+ * @deprecated SP-170 — prefer `pushFailoverNotice` on the live outer stream.
+ * Mutates a buffered event array (legacy collect-then-flush path only).
+ */
 export function injectFailoverNotice(
   events: AssistantMessageEvent[],
   failedModelId: string,
   alternateModelId: string,
   errorObj?: ReturnType<typeof parseAssistantMessageError>,
 ): void {
-  const reason = errorObj?.message || errorObj?.code || 'Unavailable';
-  const notice = `> ⚠️ **pi-smart-router failover:** \`${failedModelId}\` failed (${reason}). Retrying with \`${alternateModelId}\`...`;
-
+  const notice = buildFailoverNoticeText(failedModelId, alternateModelId, errorObj);
   let noticeInjected = false;
 
   for (let i = 0; i < events.length; i++) {

package/.pi/extensions/smart-router/extension-setup.ts

@@ -4,8 +4,8 @@ import {
   type ExtensionAPI,
 } from '@earendil-works/pi-coding-agent';
 
+import { resolveOperatorConfigFromEnv } from '../../../src/config/defaults.js';
 import { ExecutionLedger } from '../../../src/domain/delegation/execution-ledger.js';
-import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import type { SessionRoutingSnapshot } from '../../../src/infrastructure/telemetry/outcome-recorder.js';
 import { createRouterFromFleet, LifecycleHookState } from '../../../src/index.js';
 
@@ -14,7 +14,11 @@ import {
   createExtensionDatasetRecorder,
   createExtensionOutcomeRecorder,
 } from './dataset-export.js';
-import { createDispatchOptions, initHydraMatcher } from './fleet-bootstrap.js';
+import {
+  createDispatchOptions,
+  createOperatorAwareSessionPinner,
+  initHydraMatcher,
+} from './fleet-bootstrap.js';
 import { setupSessionHooks } from './session-lifecycle.js';
 import { createStreamSimple } from './stream-delegation.js';
 import type { SmartRouterRuntime } from './types.js';
@@ -35,7 +39,8 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
   const modelRegistry = ModelRegistry.inMemory(authStorage);
   const hydraMatcher = await initHydraMatcher();
   const store = createExtensionStore(cwd);
-  const sessionPinner = new SessionPinner({ store });
+  const operatorConfig = resolveOperatorConfigFromEnv();
+  const sessionPinner = createOperatorAwareSessionPinner(store, operatorConfig);
   const executionLedger = new ExecutionLedger();
   const lifecycleHookState = new LifecycleHookState();
   const datasetNotify: DatasetNotify = {
@@ -62,7 +67,9 @@ export async function createSmartRouterRuntime(cwd: string): Promise<{
     sessionRouting,
     streamDeps: {
       router: createRouterFromFleet([], {
-        ...createDispatchOptions(store, sessionPinner, hydraMatcher),
+        ...createDispatchOptions(store, sessionPinner, hydraMatcher, {
+          operatorConfig,
+        }),
         lifecycleHookState,
       }),
       modelRegistry,

package/.pi/extensions/smart-router/fleet-bootstrap.ts

@@ -6,13 +6,18 @@ import {
 } from '@earendil-works/pi-coding-agent';
 
 import { mapFleetFromRegistry } from '../../../src/config/pi-model-mapper.js';
-import { DEFAULT_OPERATOR_CONFIG } from '../../../src/config/defaults.js';
+import {
+  DEFAULT_OPERATOR_CONFIG,
+  resolveOperatorConfigFromEnv,
+} from '../../../src/config/defaults.js';
 import {
   HydraMatcher,
   createOnnxEmbeddingProvider,
 } from '../../../src/domain/matching/hydra-matcher.js';
 import { SessionPinner } from '../../../src/domain/pinning/session-pinner.js';
 import type { ModelProfile, PriceCatalog } from '../../../src/domain/types/index.js';
+import type { QuotaWindowPosition } from '../../../src/domain/types/entities.js';
+import type { OperatorConfig } from '../../../src/domain/types/schemas.js';
 import type { StorePort } from '../../../src/domain/types/store-port.js';
 import { getDefaultSystemInfo } from '../../../src/infrastructure/hardware/hardware-probe.js';
 import { DEFAULT_LOCAL_CONFIG } from '../../../src/infrastructure/local/local-zero-tier.js';
@@ -27,6 +32,16 @@ import { resolveModelScope } from './pi-model-scope.js';
 import type { FleetMode, SmartRouterRuntime } from './types.js';
 import { resolveRateLimiter } from './utils.js';
 
+/** Optional overrides for extension dispatch wiring (SP-173). */
+export interface CreateDispatchOptionsExtras {
+  /** Base operator config before env merge; defaults to DEFAULT_OPERATOR_CONFIG. */
+  readonly operatorConfig?: OperatorConfig;
+  /** Live price catalog when fleet discovery has loaded one. */
+  readonly priceCatalog?: PriceCatalog | null;
+  /** Rolling subscription quota position when available. */
+  readonly quotaWindowPosition?: QuotaWindowPosition;
+}
+
 /** Minimal settings surface used for scoped fleet discovery. */
 export interface ScopedSettingsReader {
   getEnabledModels(): string[] | null | undefined;
@@ -152,26 +167,58 @@ export function createDispatchOptions(
   store: StorePort,
   sessionPinner: SessionPinner,
   hydraMatcher?: HydraMatcher,
+  extras?: CreateDispatchOptionsExtras,
 ): GatewayDispatchOptions {
+  const operatorConfig = resolveOperatorConfigFromEnv(
+    extras?.operatorConfig ?? DEFAULT_OPERATOR_CONFIG,
+  );
   const telemetryEmitter = new RoutingTelemetryEmitter({
     onRecord: (record) => {
       store.appendTelemetry(record);
     },
+    sessionPinner,
+    saarConfig: operatorConfig.saar,
+    ...(extras?.priceCatalog !== undefined ? { priceCatalog: extras.priceCatalog } : {}),
+    ...(extras?.quotaWindowPosition !== undefined
+      ? { quotaWindowPosition: extras.quotaWindowPosition }
+      : {}),
   });
   const rateLimiter = resolveRateLimiter(store);
 
   return {
     sessionPinner,
-    hardwareConfig: DEFAULT_OPERATOR_CONFIG.local,
+    hardwareConfig: operatorConfig.local,
     systemInfoProvider: getDefaultSystemInfo,
     localConfig: DEFAULT_LOCAL_CONFIG,
-    loopEscalationConfig: DEFAULT_OPERATOR_CONFIG.loop_escalation,
+    loopEscalationConfig: operatorConfig.loop_escalation,
+    saarConfig: operatorConfig.saar,
+    planningDelegateConfig: operatorConfig.planning_delegate,
+    pinOnlyFallback: operatorConfig.pin_only_fallback,
+    ...(extras?.priceCatalog !== undefined ? { priceCatalog: extras.priceCatalog } : {}),
+    ...(extras?.quotaWindowPosition !== undefined
+      ? { quotaWindowPosition: extras.quotaWindowPosition }
+      : {}),
     ...(hydraMatcher ? { hydraMatcher } : {}),
     ...(rateLimiter ? { rateLimiter } : {}),
     telemetryEmitter,
   };
 }
 
+/**
+ * Build a SessionPinner wired with operator SAAR / pin-only settings (SP-173).
+ * No operator-config.json loader exists yet — env + optional base config only.
+ */
+export function createOperatorAwareSessionPinner(
+  store: StorePort,
+  operatorConfig: OperatorConfig = resolveOperatorConfigFromEnv(),
+): SessionPinner {
+  return new SessionPinner({
+    store,
+    saarConfig: operatorConfig.saar,
+    pinOnlyFallback: operatorConfig.pin_only_fallback,
+  });
+}
+
 export async function rebuildFleet(
   runtime: SmartRouterRuntime,
   pi: ExtensionAPI,
@@ -189,7 +236,9 @@ export async function rebuildFleet(
   runtime.priceCatalog = catalog;
   runtime.fleetScopeFingerprint = fingerprint;
   const router = createRouterFromFleet(fleet, {
-    ...createDispatchOptions(runtime.store, runtime.sessionPinner, runtime.hydraMatcher),
+    ...createDispatchOptions(runtime.store, runtime.sessionPinner, runtime.hydraMatcher, {
+      priceCatalog: catalog,
+    }),
     lifecycleHookState: runtime.lifecycleHookState,
   });
   router.register(createHooksAdapter(pi));

package/.pi/extensions/smart-router/index.ts

@@ -24,6 +24,7 @@ import {
 } from './dataset-export.js';
 import {
   createDispatchOptions,
+  createOperatorAwareSessionPinner,
   discoverFleet,
   formatLmuStatus,
   initHydraMatcher,
@@ -62,6 +63,7 @@ export {
   createDispatchOptions,
   createExtensionDatasetRecorder,
   createExtensionOutcomeRecorder,
+  createOperatorAwareSessionPinner,
   createSmartRouterRuntime,
   createStreamSimple,
   deriveTurnType,

package/.pi/extensions/smart-router/planning-delegate.ts

@@ -32,6 +32,7 @@ import {
 import { collectDelegatedStream } from './delegate-stream.js';
 import { findFleetProfile, resolveRegistryModel } from './delegation-runtime.js';
 import type { StreamDelegationDeps } from './types.js';
+import { throwIfAborted } from './utils.js';
 
 /** Prefix for injected planning observations visible to the primary model. */
 export const PLANNING_DELEGATE_OBSERVATION_PREFIX =
@@ -169,7 +170,12 @@ export function injectPlanningDelegateObservation(
   };
 }
 
-/** Default frontier sub-call via provider stream (ephemeral one-shot delegate). */
+/** Default frontier sub-call via provider stream (ephemeral one-shot delegate).
+ *
+ * SP-170: intentionally uses collectDelegatedStream (buffered), not live outer
+ * piping. Only the final observation text is injected into the primary context;
+ * intermediate frontier tokens must not reach the user-facing stream.
+ */
 export async function defaultSpawnPlanningDelegate(
   frontierModel: Model<Api>,
   compressedContext: Context,
@@ -225,6 +231,9 @@ export async function resolvePlanningDelegatePath(
   options: SimpleStreamOptions | undefined,
   deps: StreamDelegationDeps,
 ): Promise<PlanningDelegateResolution> {
+  // Abort before planning sub-call work (SP-171 phase boundary).
+  throwIfAborted(options);
+
   const observability = decision.features!.planning_delegate!;
   const delegateModelId = observability.delegate_model_id!;
   const primaryModelId = decision.selected_model_id;
@@ -252,6 +261,7 @@ export async function resolvePlanningDelegatePath(
     context,
     observability.compressed_context,
   );
+  throwIfAborted(options);
   const spawnFn = deps.spawnPlanningDelegate ?? defaultSpawnPlanningDelegate;
   const spawnResult = await spawnFn(frontierModel, compressedContext, options, deps);