@nklisch/pi-enhanced 0.2.7 → 0.3.0

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/service/service-adapter.ts

@@ -1,9 +1,4 @@
-/**
- * service-adapter.ts — Adapter that wraps SubagentManager to satisfy SubagentsService.
- *
- * Handles model resolution at the API boundary, record serialization
- * (stripping non-serializable fields), and session gating.
- */
+/** Adapter from the public service contract to the authoritative manager. */
 
 import type { Model } from "@earendil-works/pi-ai";
 import { resolveDispatchAgentType } from "#src/config/agent-type-resolution";
@@ -14,38 +9,45 @@ import type {
 } from "#src/lifecycle/lifecycle-interceptor";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { WorkspaceProvider } from "#src/lifecycle/workspace";
-import type { SpawnOptions, SubagentRecord, SubagentsService } from "#src/service/service";
+import type { AgentSpawnConfig, DeliveryOutcome, ManagerSteerOutcome, ResumeOutcome, StopOutcome } from "#src/lifecycle/subagent-manager";
+import type { Subagent } from "#src/lifecycle/subagent";
+import type {
+  LaunchDelivery,
+  LaunchOptions,
+  ListOptions,
+  ResultDelivery,
+  ResumeDelivery,
+  StopDelivery,
+  SteerDelivery,
+  SubagentRecord,
+  SubagentsService,
+} from "#src/service/service";
 import { formatModelLabel } from "#src/session/model-label";
 import { resolveEffectiveThinkingLevel } from "#src/session/thinking-level";
 import type { ModelRegistry } from "#src/session/model-resolver";
 import { resolveDefaultModel } from "#src/session/session-config";
-import type { AgentInvocation, SessionContext, Subagent, ThinkingLevel } from "#src/types";
+import type { AgentInvocation, SessionContext, SubagentMode, ThinkingLevel } from "#src/types";
+import { describeActivity } from "#src/ui/display";
 
-/** Narrow interface for the SubagentManager — avoids coupling to the concrete class. */
 export interface SubagentManagerLike {
-  spawn(snapshot: ParentSnapshot, type: string, prompt: string, options: unknown): string;
+  launch(snapshot: ParentSnapshot, type: string, prompt: string, options: AgentSpawnConfig): Promise<DeliveryOutcome>;
+  resume(id: string, prompt: string, mode: SubagentMode, timeoutSeconds: number | undefined, signal?: AbortSignal): Promise<ResumeOutcome>;
+  stop(id: string, settlementTimeoutSeconds?: number): Promise<StopOutcome>;
+  steer(id: string, message: string): Promise<ManagerSteerOutcome>;
   getRecord(id: string): Subagent | undefined;
   listAgents(): Subagent[];
-  abort(id: string): boolean;
   waitForAll(): Promise<void>;
   hasRunning(): boolean;
   registerWorkspaceProvider(provider: WorkspaceProvider): () => void;
-  registerLifecycleInterceptor(
-    interceptor: SubagentLifecycleInterceptor,
-  ): SubagentLifecycleRegistration;
+  registerLifecycleInterceptor(interceptor: SubagentLifecycleInterceptor): SubagentLifecycleRegistration;
 }
 
-/**
- * Narrow runtime interface consumed by the service adapter.
- * `SubagentRuntime` satisfies this structurally; tests use plain stubs.
- */
 export interface ServiceRuntimeLike {
   readonly currentCtx: SessionContext | undefined;
   buildSnapshot(inheritContext: boolean): ParentSnapshot;
   getSessionInfo(): { parentSessionFile: string; parentSessionId: string };
 }
 
-/** Adapter that wraps SubagentManager to satisfy SubagentsService. */
 export class SubagentsServiceAdapter implements SubagentsService {
   constructor(
     private readonly manager: SubagentManagerLike,
@@ -55,139 +57,204 @@ export class SubagentsServiceAdapter implements SubagentsService {
     private readonly settings?: { readonly fallbackSubagent?: string | false },
   ) {}
 
-  spawn(type: string, prompt: string, options?: SpawnOptions): string {
-    if (!this.runtime.currentCtx) {
-      throw new Error("No active session — cannot spawn agents outside a session.");
-    }
-
+  async launch(type: string, prompt: string, options?: LaunchOptions): Promise<LaunchDelivery> {
+    const ctx = this.requireContext();
     this.agentRegistry?.reload();
     const resolution = this.agentRegistry
       ? resolveDispatchAgentType(type, this.agentRegistry, this.settings?.fallbackSubagent)
       : { type, requestedType: type, fellBack: false };
     if ("error" in resolution) throw new Error(resolution.error);
-    const resolvedType = resolution.type;
 
+    const resolvedType = resolution.type;
+    const agentConfig = this.agentRegistry?.resolveAgentConfig(resolvedType);
     const model = options?.model
       ? this.resolveModelOption(options.model)
       : this.resolveTypeDefaultModel(resolvedType);
+    const mode = normalizeMode(options?.mode ?? agentConfig?.mode);
     const description = options?.description ?? prompt.slice(0, 80);
-    const isBackground = !(options?.foreground ?? false);
-    const snapshot = this.runtime.buildSnapshot(options?.inheritContext ?? false);
-    const requestedThinking = (options?.thinkingLevel
-      ?? this.agentRegistry?.resolveAgentConfig(resolvedType).thinking) as ThinkingLevel | undefined;
-    const effectiveThinkingLevel = resolveEffectiveThinkingLevel(
-      model,
-      requestedThinking,
-      snapshot.thinkingLevel,
-    );
+    const thinking = options?.thinkingLevel ?? agentConfig?.thinking;
+    const maxTurns = normalizeMaxTurns(options?.maxTurns ?? agentConfig?.maxTurns);
+    const timeoutSeconds = options?.timeoutSeconds ?? agentConfig?.timeoutSeconds;
+    const inheritContext = options?.inheritContext ?? agentConfig?.inheritContext ?? false;
+    const snapshot = this.runtime.buildSnapshot(inheritContext);
+    const effectiveThinkingLevel = resolveEffectiveThinkingLevel(model, thinking, snapshot.thinkingLevel);
     const invocation: AgentInvocation = {
       modelName: formatModelLabel(model),
-      maxTurns: options?.maxTurns,
-      inheritContext: options?.inheritContext,
-      runInBackground: isBackground,
+      maxTurns,
+      inheritContext,
+      mode,
+      timeoutSeconds,
     };
-
     const parent = this.runtime.getSessionInfo();
-    return this.manager.spawn(snapshot, resolvedType, prompt, {
+
+    const outcome = await this.manager.launch(snapshot, resolvedType, prompt, {
       description,
       model,
-      maxTurns: options?.maxTurns,
+      maxTurns,
       thinkingLevel: effectiveThinkingLevel,
-      inheritContext: options?.inheritContext,
-      bypassQueue: options?.bypassQueue,
-      isBackground,
+      inheritContext,
+      mode,
+      timeoutSeconds: normalizeTimeout(timeoutSeconds),
       origin: "service",
       invocation,
+      signal: options?.signal,
       lifecycleParentSession: parent.parentSessionId
-        ? {
-            parentSessionFile: parent.parentSessionFile || undefined,
-            parentSessionId: parent.parentSessionId,
-          }
+        ? { parentSessionFile: parent.parentSessionFile || undefined, parentSessionId: parent.parentSessionId }
         : undefined,
     });
+    if (outcome.kind === "joined") outcome.record.markConsumed();
+    return this.toLaunchDelivery(outcome);
   }
 
-  getRecord(id: string): SubagentRecord | undefined {
-    const record = this.manager.getRecord(id);
-    return record ? toSubagentRecord(record) : undefined;
+  async resume(
+    agentId: string,
+    prompt: string,
+    options?: Pick<LaunchOptions, "mode" | "timeoutSeconds" | "signal">,
+  ): Promise<ResumeDelivery> {
+    const mode = options?.mode ?? "detached";
+    const outcome = await this.manager.resume(
+      agentId,
+      prompt,
+      mode,
+      normalizeTimeout(options?.timeoutSeconds),
+      options?.signal,
+    );
+    if (outcome.kind === "joined") {
+      outcome.record.markConsumed();
+      return { kind: "joined", record: toSubagentRecord(outcome.record) };
+    }
+    if (outcome.kind === "detached") return outcome;
+    return outcome;
   }
 
-  listAgents(): SubagentRecord[] {
-    return this.manager.listAgents().map(toSubagentRecord);
+  async stop(agentId: string, settlementTimeoutSeconds = 5): Promise<StopDelivery> {
+    const timeout = normalizeSettlementTimeout(settlementTimeoutSeconds);
+    const outcome = await this.manager.stop(agentId, timeout);
+    if (outcome.kind === "not_found") return outcome;
+    if (outcome.kind === "already_terminal") return { ...outcome, record: toSubagentRecord(outcome.record) };
+    return { ...outcome, record: toSubagentRecord(outcome.record) };
   }
 
-  abort(id: string): boolean {
-    return this.manager.abort(id);
+  async steer(agentId: string, message: string): Promise<SteerDelivery> {
+    const outcome = await this.manager.steer(agentId, message);
+    if (outcome.kind === "not_found") return outcome;
+    if (outcome.kind === "rejected") return { ...outcome, agentId };
+    return { ...outcome, agentId };
   }
 
-  async steer(id: string, message: string): Promise<boolean> {
-    const record = this.manager.getRecord(id);
-    if (!record) {
-      return false;
-    }
-    const outcome = await record.steer(message);
-    return outcome.kind !== "rejected";
+  list(options?: ListOptions): SubagentRecord[] {
+    const state = options?.state ?? "all";
+    const limit = normalizeListLimit(options?.limit);
+    return this.manager.listAgents()
+      .filter((record) => state === "all" || (state === "active" ? record.isActive() : !record.isActive()))
+      .slice(0, limit)
+      .map(toSubagentRecord);
   }
 
-  async waitForAll(): Promise<void> {
-    return this.manager.waitForAll();
+  getResult(agentId: string): ResultDelivery {
+    const record = this.manager.getRecord(agentId);
+    if (!record) return { kind: "not_found", agentId };
+    if (!record.isActive()) record.markConsumed();
+    return { kind: "result", record: toSubagentRecord(record) };
   }
 
-  hasRunning(): boolean {
-    return this.manager.hasRunning();
+  getRecord(agentId: string): SubagentRecord | undefined {
+    const record = this.manager.getRecord(agentId);
+    return record ? toSubagentRecord(record) : undefined;
   }
 
-  registerWorkspaceProvider(provider: WorkspaceProvider): () => void {
-    return this.manager.registerWorkspaceProvider(provider);
-  }
+  waitForAll(): Promise<void> { return this.manager.waitForAll(); }
+  hasRunning(): boolean { return this.manager.hasRunning(); }
+  registerWorkspaceProvider(provider: WorkspaceProvider): () => void { return this.manager.registerWorkspaceProvider(provider); }
+  registerLifecycleInterceptor(interceptor: SubagentLifecycleInterceptor): SubagentLifecycleRegistration { return this.manager.registerLifecycleInterceptor(interceptor); }
 
-  registerLifecycleInterceptor(
-    interceptor: SubagentLifecycleInterceptor,
-  ): SubagentLifecycleRegistration {
-    return this.manager.registerLifecycleInterceptor(interceptor);
+  private requireContext(): SessionContext {
+    if (!this.runtime.currentCtx) throw new Error("No active session — cannot launch agents outside a session.");
+    return this.runtime.currentCtx;
   }
 
-  /** Resolve a model-string override against the current session's registry. */
-  private resolveModelOption(modelInput: string): Model<any> {
+  private resolveModelOption(input: string): Model<any> {
     const registry = this.runtime.currentCtx?.modelRegistry;
-    if (!registry) {
-      throw new Error("No model registry available.");
-    }
-    const resolved = this.resolveModel(modelInput, registry);
-    if (typeof resolved === "string") {
-      throw new Error(resolved);
-    }
+    if (!registry) throw new Error("No model registry available.");
+    const resolved = this.resolveModel(input, registry);
+    if (typeof resolved === "string") throw new Error(resolved);
     return resolved;
   }
 
-  /** Resolve the agent type's configured model with the same fallback used by session assembly. */
   private resolveTypeDefaultModel(type: string): Model<any> {
     const ctx = this.runtime.currentCtx!;
     const configured = this.agentRegistry?.resolveAgentConfig(type).model;
     if (!ctx.modelRegistry) return ctx.model as Model<any>;
     return resolveDefaultModel(ctx.model, ctx.modelRegistry, configured) as Model<any>;
   }
+
+  private toLaunchDelivery(outcome: DeliveryOutcome): LaunchDelivery {
+    return outcome.kind === "joined"
+      ? { kind: "joined", record: toSubagentRecord(outcome.record) }
+      : outcome;
+  }
 }
 
-/**
- * Convert an internal Subagent to a serializable SubagentRecord.
- * Uses an explicit allowlist — new fields must be opted in.
- */
 export function toSubagentRecord(record: Subagent): SubagentRecord {
+  const activeTools = [...record.activeTools.values()];
   const out: SubagentRecord = {
     id: record.id,
     type: record.type,
     description: record.description,
+    runId: record.runId,
+    mode: record.mode,
     status: record.status,
+    stopRequested: record.stopRequested,
+    terminalReason: record.stateTerminalReason,
     toolUses: record.toolUses,
     startedAt: record.startedAt,
-    lifetimeUsage: record.lifetimeUsage,
+    activeRuntimeMs: record.activeRuntimeMs,
+    modelLabel: record.modelLabel,
+    thinkingLevel: record.effectiveThinkingLevel,
+    activeTools,
+    currentActivity: describeActivity(record.activeTools, record.responseText),
+    lifetimeUsage: { ...record.lifetimeUsage },
     compactionCount: record.compactionCount,
   };
-
-  if (record.result !== undefined) out.result = record.result;
+  if (record.result !== undefined) out.result = boundResult(record.result, record.outputFile);
   if (record.error !== undefined) out.error = record.error;
   if (record.completedAt !== undefined) out.completedAt = record.completedAt;
-
+  if (record.outputFile !== undefined) out.outputFile = record.outputFile;
   return out;
 }
+
+const MAX_RESULT_OUTPUT = 12_000;
+function boundResult(result: string, outputFile: string | undefined): string {
+  return result.length > MAX_RESULT_OUTPUT
+    ? result.slice(0, MAX_RESULT_OUTPUT) + `\n\nOutput truncated. Full transcript: ${outputFile ?? "unavailable"}`
+    : result;
+}
+
+function normalizeMode(value: string | undefined): SubagentMode {
+  if (value == null) return "detached";
+  if (value !== "joined" && value !== "detached") throw new RangeError("mode must be joined or detached");
+  return value;
+}
+
+function normalizeMaxTurns(value: number | undefined): number | undefined {
+  if (value == null) return undefined;
+  if (!Number.isInteger(value) || value < 0) throw new RangeError("maxTurns must be a non-negative integer");
+  return value;
+}
+
+function normalizeTimeout(value: number | undefined): number | undefined {
+  if (value == null) return undefined;
+  if (!Number.isInteger(value) || value <= 0) throw new RangeError("timeoutSeconds must be a positive integer");
+  return value;
+}
+
+function normalizeSettlementTimeout(value: number): number {
+  if (!Number.isInteger(value) || value <= 0 || value > 30) throw new RangeError("settlementTimeoutSeconds must be an integer from 1 to 30");
+  return value;
+}
+
+function normalizeListLimit(value: number | undefined): number {
+  const limit = value ?? 20;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new RangeError("limit must be an integer from 1 to 100");
+  return limit;
+}

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/service/service.ts

@@ -1,19 +1,11 @@
-/**
- * service.ts — Public API surface for cross-extension access to subagents.
- *
- * Consumers declare this package as an optional peer dependency and use
- * dynamic import to access the accessor functions:
- *
- *   const { getSubagentsService } = await import("@nklisch/pi-subagents");
- *   const svc = getSubagentsService();
- *   svc?.spawn("Explore", "Check for stale TODOs");
- */
+/** Public cross-extension contract for subagent execution control. */
 
 import type {
   SubagentLifecycleInterceptor,
   SubagentLifecycleRegistration,
+  SubagentExecutionMode,
 } from "#src/lifecycle/lifecycle-interceptor";
-import type { SubagentStatus } from "#src/lifecycle/subagent";
+import type { SubagentStatus, SubagentStopReason, SubagentTerminalReason } from "#src/lifecycle/subagent-state";
 import type { LifetimeUsage } from "#src/lifecycle/usage";
 import type {
   Workspace,
@@ -22,7 +14,7 @@ import type {
   WorkspacePrepareContext,
   WorkspaceProvider,
 } from "#src/lifecycle/workspace";
-
+import type { ThinkingLevel } from "#src/types";
 
 export {
   MAX_LIFECYCLE_CONTINUATION_ROUNDS,
@@ -40,13 +32,7 @@ export {
   type SubagentLifecycleStartContext,
   type SubagentLifecycleStartDecision,
 } from "#src/lifecycle/lifecycle-interceptor";
-// SubagentStatus is defined in the lifecycle layer (single home) and re-exported
-// here for the public API surface — mirrors the LifetimeUsage / workspace pattern.
-export type { SubagentStatus } from "#src/lifecycle/subagent";
-// Generative extension seam (ADR 0002, Phase 16 Step 2). The provider type
-// and all four collaborator types it references are re-exported by name so
-// consumers can import them directly rather than recovering them via
-// indexed-access inference (e.g. `Parameters<WorkspaceProvider["prepare"]>[0]`).
+export type { SubagentStatus, SubagentStopReason, SubagentTerminalReason } from "#src/lifecycle/subagent-state";
 export type {
   LifetimeUsage,
   Workspace,
@@ -55,73 +41,86 @@ export type {
   WorkspacePrepareContext,
   WorkspaceProvider,
 };
+export type { SubagentExecutionMode as SubagentMode };
 
-/** Serializable snapshot of an agent's state — no live session objects. */
 export interface SubagentRecord {
   id: string;
   type: string;
   description: string;
+  runId: number;
+  mode: SubagentExecutionMode;
   status: SubagentStatus;
+  stopRequested: boolean;
+  terminalReason?: SubagentTerminalReason;
   result?: string;
   error?: string;
   toolUses: number;
   startedAt: number;
   completedAt?: number;
+  activeRuntimeMs: number;
+  modelLabel: string;
+  thinkingLevel: ThinkingLevel;
+  activeTools: string[];
+  currentActivity: string;
   lifetimeUsage: LifetimeUsage;
   compactionCount: number;
+  outputFile?: string;
 }
 
-/** Options for spawning an agent via the service. */
-export interface SpawnOptions {
+export interface LaunchOptions {
   description?: string;
   model?: string;
   maxTurns?: number;
-  thinkingLevel?: string;
+  thinkingLevel?: ThinkingLevel;
   inheritContext?: boolean;
-  foreground?: boolean;
-  bypassQueue?: boolean;
+  mode?: SubagentExecutionMode;
+  timeoutSeconds?: number;
+  signal?: AbortSignal;
 }
 
-/** The public service contract for cross-extension subagent access. */
-export interface SubagentsService {
-  /** Spawn an agent. Returns the agent ID immediately. */
-  spawn(type: string, prompt: string, options?: SpawnOptions): string;
-
-  /** Get a snapshot of an agent's current state. */
-  getRecord(id: string): SubagentRecord | undefined;
-
-  /** List all tracked agents, most recent first. */
-  listAgents(): SubagentRecord[];
-
-  /** Abort a running or queued agent. Returns false if not found. */
-  abort(id: string): boolean;
-
-  /** Send a steering message to a running agent. */
-  steer(id: string, message: string): Promise<boolean>;
+export type LaunchDelivery =
+  | { kind: "detached"; agentId: string; runId: number }
+  | { kind: "joined"; record: SubagentRecord };
+
+export type ResumeDelivery = LaunchDelivery |
+  { kind: "not_found"; agentId: string } |
+  { kind: "wrong_state"; agentId: string; status: SubagentStatus };
+
+export type StopDelivery =
+  | { kind: "stopped"; agentId: string; runId: number; reason: SubagentStopReason; record: SubagentRecord }
+  | { kind: "stop_pending"; agentId: string; runId: number; reason: SubagentStopReason; record: SubagentRecord }
+  | { kind: "already_terminal"; agentId: string; runId: number; record: SubagentRecord }
+  | { kind: "not_found"; agentId: string };
+
+export type SteerDelivery =
+  | { kind: "delivered" | "buffered"; agentId: string; runId: number }
+  | { kind: "rejected"; agentId: string; runId: number; status: SubagentStatus }
+  | { kind: "not_found"; agentId: string };
+
+export type ResultDelivery =
+  | { kind: "result"; record: SubagentRecord }
+  | { kind: "not_found"; agentId: string };
+
+export type SubagentListState = "active" | "terminal" | "all";
+export interface ListOptions {
+  state?: SubagentListState;
+  limit?: number;
+}
 
-  /** Wait for all running and queued agents to complete. */
+export interface SubagentsService {
+  launch(type: string, prompt: string, options?: LaunchOptions): Promise<LaunchDelivery>;
+  resume(agentId: string, prompt: string, options?: Pick<LaunchOptions, "mode" | "timeoutSeconds" | "signal">): Promise<ResumeDelivery>;
+  stop(agentId: string, settlementTimeoutSeconds?: number): Promise<StopDelivery>;
+  steer(agentId: string, message: string): Promise<SteerDelivery>;
+  list(options?: ListOptions): SubagentRecord[];
+  getResult(agentId: string): ResultDelivery;
+  getRecord(agentId: string): SubagentRecord | undefined;
   waitForAll(): Promise<void>;
-
-  /** Whether any agents are running or queued. */
   hasRunning(): boolean;
-
-  /**
-   * Register the single workspace provider that supplies a child's working
-   * directory plus bracketed setup/teardown. Throws if one is already
-   * registered. Returns a disposer that unregisters the provider.
-   */
   registerWorkspaceProvider(provider: WorkspaceProvider): () => void;
-
-  /**
-   * Register an ordered async lifecycle provider. It receives only immutable
-   * execution facts and prompt/result decisions, never a manager or session.
-   */
-  registerLifecycleInterceptor(
-    interceptor: SubagentLifecycleInterceptor,
-  ): SubagentLifecycleRegistration;
+  registerLifecycleInterceptor(interceptor: SubagentLifecycleInterceptor): SubagentLifecycleRegistration;
 }
 
-/** Event channel constants for pi.events subscriptions. */
 export const SUBAGENT_EVENTS = {
   STARTED: "subagents:started",
   COMPLETED: "subagents:completed",
@@ -132,24 +131,17 @@ export const SUBAGENT_EVENTS = {
   STEERED: "subagents:steered",
 } as const;
 
-// ---- Accessor functions ----
-
 const SERVICE_KEY = Symbol.for("@nklisch/pi-subagents:service");
 
-/** Publish the SubagentsService on globalThis for cross-extension access. */
 export function publishSubagentsService(service: SubagentsService): void {
   (globalThis as Record<symbol, unknown>)[SERVICE_KEY] = service;
 }
 
-/** Retrieve the published SubagentsService, or undefined if not yet published. */
 export function getSubagentsService(): SubagentsService | undefined {
-  return (globalThis as Record<symbol, unknown>)[SERVICE_KEY] as
-    | SubagentsService
-    | undefined;
+  return (globalThis as Record<symbol, unknown>)[SERVICE_KEY] as SubagentsService | undefined;
 }
 
-/** Remove the SubagentsService from globalThis (call on shutdown/reload). */
 export function unpublishSubagentsService(): void {
-  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Symbol-keyed global property; Map.delete() is not applicable
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Symbol-keyed global property
   delete (globalThis as Record<symbol, unknown>)[SERVICE_KEY];
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/conversation.ts

@@ -1,9 +1,9 @@
 /**
  * conversation.ts — Render a subagent session's messages as formatted text.
  *
- * Extracted from agent-runner.ts (issue #265) into the session domain, where the
- * other message-extraction helpers (content-items, context) live. Consumed by
- * the get_subagent_result tool's verbose output.
+ * Extracted into the session domain, alongside the other message-extraction
+ * helpers. Kept for read-only transcript/navigation surfaces; parent result
+ * delivery itself remains bounded.
  */
 
 import type { AgentSession } from "@earendil-works/pi-coding-agent";

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/query-source.ts

@@ -0,0 +1,28 @@
+/** Shared file adapter for query and transcript consumers. */
+import {
+  buildSessionContext,
+  parseSessionEntries,
+  type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import type { SessionMessage } from "#src/types";
+
+/** Parse exactly the same public Pi JSONL/context pipeline used by navigation. */
+export function parseSessionFileMessages(
+  content: string,
+): readonly SessionMessage[] {
+  const entries = parseSessionEntries(content);
+  const sessionEntries = entries.filter((entry): entry is SessionEntry => entry.type !== "session");
+  return buildSessionContext(sessionEntries).messages;
+}
+
+export interface SessionFileReader {
+  readFile(path: string): string;
+}
+
+export function readSessionFileMessages(
+  outputFile: string,
+  reader: SessionFileReader | ((path: string) => string),
+): readonly SessionMessage[] {
+  const readFile = typeof reader === "function" ? reader : (path: string) => reader.readFile(path);
+  return parseSessionFileMessages(readFile(outputFile));
+}