pi-sessions 0.7.2 → 0.9.0

package/extensions/shared/model-resolution.ts

@@ -0,0 +1,73 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { modelsAreEqual } from "@earendil-works/pi-ai";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { resolveCliModel } from "@earendil-works/pi-coding-agent";
+
+export type AuthenticatedModelResolution =
+  | {
+      ok: true;
+      model: Model<Api>;
+      thinkingLevel: ThinkingLevel | undefined;
+      warning: string | undefined;
+    }
+  | {
+      ok: false;
+      error: string;
+      warning: string | undefined;
+    };
+
+/**
+ * Resolves a model pattern with Pi's CLI grammar (fuzzy aliases, slash ids,
+ * `:thinking` suffixes), then narrows the result to a fresh entry from the
+ * runtime's available snapshot. resolveCliModel intentionally searches every
+ * model for CLI setup flows; nested extension work must only run activated,
+ * authenticated models, and the available object crosses that boundary.
+ */
+export function resolveAuthenticatedModel(options: {
+  modelRuntime: ModelRuntime;
+  modelPattern: string;
+  thinkingLevel?: ThinkingLevel | undefined;
+}): AuthenticatedModelResolution {
+  const resolved = resolveCliModel({
+    cliModel: options.modelPattern,
+    ...(options.thinkingLevel ? { cliThinking: options.thinkingLevel } : {}),
+    modelRuntime: options.modelRuntime,
+  });
+
+  if (resolved.error || !resolved.model) {
+    return {
+      ok: false,
+      error: stripCliGuidance(resolved.error) ?? `Unknown model "${options.modelPattern}".`,
+      warning: resolved.warning,
+    };
+  }
+
+  const available = options.modelRuntime
+    .getAvailableSnapshot()
+    .find((model) => modelsAreEqual(model, resolved.model));
+  if (!available) {
+    return {
+      ok: false,
+      error: `Model "${resolved.model.provider}/${resolved.model.id}" is not an available authenticated model.`,
+      warning: resolved.warning,
+    };
+  }
+
+  return {
+    ok: true,
+    model: available,
+    thinkingLevel: options.thinkingLevel ?? resolved.thinkingLevel,
+    warning: resolved.warning,
+  };
+}
+
+// resolveCliModel errors reference --list-models, which does not exist in extension surfaces.
+function stripCliGuidance(error: string | undefined): string | undefined {
+  const stripped = error?.replace(/(?:^|\s+)[^.!?\n]*--list-models[^.!?\n]*(?:[.!?]|$)/, "").trim();
+  return stripped || undefined;
+}
+
+export function formatAvailableModelList(models: readonly Model<Api>[]): string {
+  return models.map((model) => `${model.provider}/${model.id}`).join(", ");
+}

package/extensions/shared/model-runtime.ts

@@ -0,0 +1,33 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+
+export type ModelRuntimeProvider = (modelRegistry: ModelRegistry) => Promise<ModelRuntime>;
+
+// Workaround for a missing extension API: resolveCliModel and createAgentSession want a
+// ModelRuntime, but ExtensionContext only exposes the ModelRegistry compatibility facade,
+// which keeps its runtime private. Until pi exposes the runtime to extensions, build a
+// fresh one per use and mirror the registered providers (e.g. pi-claude-bridge) so their
+// configs — including live streamSimple closures — carry over by reference.
+export async function createSessionModelRuntime(
+  modelRegistry: ModelRegistry,
+): Promise<ModelRuntime> {
+  const modelRuntime = await ModelRuntime.create({ allowModelNetwork: false });
+
+  for (const providerId of modelRegistry.getRegisteredProviderIds()) {
+    const config = modelRegistry.getRegisteredProviderConfig(providerId);
+    if (config) {
+      modelRuntime.registerProvider(providerId, config);
+    }
+  }
+
+  await modelRuntime.refresh({ allowNetwork: false });
+  return modelRuntime;
+}
+
+// A model reference carried on the session context is stale relative to the mirrored runtime
+// (it was resolved against the facade's private runtime, not this one). Re-resolve it against
+// the runtime's snapshot so downstream calls use the mirror's live provider config, falling
+// back to the original reference when the runtime has not seen it.
+export function freshenModel(runtime: ModelRuntime, model: Model<Api>): Model<Api> {
+  return runtime.getModel(model.provider, model.id) ?? model;
+}

package/extensions/shared/model.ts

@@ -1,18 +1,15 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
-import type { ModelReference } from "./settings.ts";
+
+export interface ExactModelReference {
+  provider: string;
+  modelId: string;
+}
 
 export function findModelByReference(
-  availableModels: Model<Api>[],
-  reference: ModelReference,
+  availableModels: readonly Model<Api>[],
+  reference: ExactModelReference,
 ): Model<Api> | undefined {
   return availableModels.find(
     (model) => model.provider === reference.provider && model.id === reference.modelId,
   );
 }
-
-export function resolveConfiguredModel(
-  availableModels: Model<Api>[],
-  configuredModel: ModelReference | undefined,
-): Model<Api> | undefined {
-  return configuredModel ? findModelByReference(availableModels, configuredModel) : undefined;
-}

package/extensions/shared/rendering/collapsible-text.ts

@@ -0,0 +1,89 @@
+import {
+  type Component,
+  getKeybindings,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import type { RenderTheme } from "./theme.ts";
+
+interface CollapsibleTextKeybindings {
+  getKeys(keybinding: "app.tools.expand"): string[];
+}
+
+export interface CollapsibleTextOptions {
+  collapsedRows: number;
+  theme: RenderTheme;
+  keybindings?: CollapsibleTextKeybindings | undefined;
+}
+
+export class CollapsibleText implements Component {
+  private text = "";
+  private expanded = false;
+  private visibleSupplementalRows = 0;
+  private hiddenSupplementalRows = 0;
+  private readonly collapsedRows: number;
+  private readonly theme: RenderTheme;
+  private readonly keybindings: CollapsibleTextKeybindings;
+
+  constructor(options: CollapsibleTextOptions) {
+    this.collapsedRows = Math.max(1, Math.floor(options.collapsedRows));
+    this.theme = options.theme;
+    this.keybindings = options.keybindings ?? getKeybindings();
+  }
+
+  setText(text: string): void {
+    this.text = text;
+  }
+
+  setExpanded(expanded: boolean): void {
+    this.expanded = expanded;
+  }
+
+  setSupplementalRowCounts(visibleRows: number, hiddenRows: number): void {
+    this.visibleSupplementalRows = Math.max(0, Math.floor(visibleRows));
+    this.hiddenSupplementalRows = Math.max(0, Math.floor(hiddenRows));
+  }
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    const renderWidth = Math.max(1, width);
+    const rows = wrapTextWithAnsi(this.text, renderWidth);
+    if (this.expanded) {
+      return rows.map((row) => padToWidth(row, renderWidth));
+    }
+    const hiddenBodyRows = Math.max(0, rows.length - this.collapsedRows);
+    if (hiddenBodyRows === 0 && this.hiddenSupplementalRows === 0) {
+      return rows.map((row) => padToWidth(row, renderWidth));
+    }
+
+    const remaining = hiddenBodyRows + this.hiddenSupplementalRows;
+    const total = rows.length + this.visibleSupplementalRows + this.hiddenSupplementalRows;
+    const visibleRows = rows
+      .slice(0, this.collapsedRows)
+      .map((row) => padToWidth(row, renderWidth));
+    const hintRows = wrapTextWithAnsi(this.formatExpandHint(remaining, total), renderWidth).map(
+      (row) => padToWidth(row, renderWidth),
+    );
+    return [...visibleRows, ...hintRows];
+  }
+
+  private formatExpandHint(remaining: number, total: number): string {
+    const keys = this.keybindings.getKeys("app.tools.expand").join("/");
+    const lineLabel = remaining === 1 ? "line" : "lines";
+    if (!keys) {
+      return this.theme.fg(
+        "muted",
+        `(${remaining} more ${lineLabel}, ${total} total, expand key unbound)`,
+      );
+    }
+    return `${this.theme.fg("muted", `(${remaining} more ${lineLabel}, ${total} total, `)}${this.theme.fg(
+      "dim",
+      keys,
+    )}${this.theme.fg("muted", " to expand)")}`;
+  }
+}
+
+function padToWidth(text: string, width: number): string {
+  return `${text}${" ".repeat(Math.max(0, width - visibleWidth(text)))}`;
+}

package/extensions/shared/rendering/expandable-content-layout.ts

@@ -0,0 +1,84 @@
+import { type Component, Container, Spacer, Text, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { CollapsibleText } from "./collapsible-text.ts";
+import type { RenderTheme } from "./theme.ts";
+
+export interface ExpandableContentPresentation {
+  header: string;
+  metadata?: string[] | undefined;
+  expandedMetadata?: string[] | undefined;
+  body?:
+    | {
+        text: string;
+        collapsedRows: number;
+        spacingBefore?: number | undefined;
+      }
+    | undefined;
+}
+
+export class ExpandableContentLayout implements Component {
+  private presentation: ExpandableContentPresentation | undefined;
+  private expanded = false;
+  private body: CollapsibleText | undefined;
+  private bodyRows: number | undefined;
+
+  constructor(private readonly theme: RenderTheme) {}
+
+  update(presentation: ExpandableContentPresentation, expanded: boolean): void {
+    this.presentation = presentation;
+    this.expanded = expanded;
+
+    if (!presentation.body) {
+      this.body = undefined;
+      this.bodyRows = undefined;
+      return;
+    }
+
+    if (!this.body || this.bodyRows !== presentation.body.collapsedRows) {
+      this.body = new CollapsibleText({
+        collapsedRows: presentation.body.collapsedRows,
+        theme: this.theme,
+      });
+      this.bodyRows = presentation.body.collapsedRows;
+    }
+    this.body.setText(presentation.body.text);
+    this.body.setExpanded(expanded);
+  }
+
+  invalidate(): void {
+    this.body?.invalidate();
+  }
+
+  render(width: number): string[] {
+    if (!this.presentation) {
+      return [];
+    }
+
+    const container = new Container();
+    container.addChild(new Text(this.presentation.header, 0, 0));
+
+    const visibleMetadata = this.presentation.metadata ?? [];
+    const expandedMetadata = this.presentation.expandedMetadata ?? [];
+    const metadata = [...visibleMetadata, ...(this.expanded ? expandedMetadata : [])];
+    if (metadata.length > 0) {
+      container.addChild(new Text(metadata.join("\n"), 0, 0));
+    }
+
+    if (this.body && this.presentation.body?.text) {
+      this.body.setSupplementalRowCounts(
+        countRenderedRows(visibleMetadata, width),
+        countRenderedRows(expandedMetadata, width),
+      );
+      const spacingBefore = this.presentation.body.spacingBefore ?? 1;
+      if (spacingBefore > 0) {
+        container.addChild(new Spacer(spacingBefore));
+      }
+      container.addChild(this.body);
+    }
+    return container.render(width);
+  }
+}
+
+function countRenderedRows(lines: readonly string[], width: number): number {
+  const renderWidth = Math.max(1, width);
+  return lines.reduce((total, line) => total + wrapTextWithAnsi(line, renderWidth).length, 0);
+}

package/extensions/shared/rendering/theme.ts

@@ -0,0 +1,5 @@
+export interface RenderTheme {
+  bold(text: string): string;
+  fg(token: string, text: string): string;
+  bg(token: string, text: string): string;
+}

package/extensions/shared/session-broker/client.ts

@@ -2,10 +2,15 @@ import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import net from "node:net";
 import { readFrames, writeFrame } from "./framing.ts";
-import { BROKER_FRAME_SCHEMA, type SessionMessagingBrokerFrame } from "./protocol.ts";
+import {
+  BROKER_FRAME_SCHEMA,
+  type OutboundSessionEnvelope,
+  type SessionEnvelopeSendFailureReason,
+  type SessionMessagingBrokerFrame,
+} from "./protocol.ts";
 import { getSessionMessagingSocketPath } from "./socket-path.ts";
 
-export const INCOMING_SESSION_MESSAGE_EVENT = "session_messaging.incoming_message";
+export const INCOMING_SESSION_ENVELOPE_EVENT = "session_messaging.incoming";
 
 const REQUEST_TIMEOUT_MS = 10_000;
 const SOCKET_PATH = getSessionMessagingSocketPath();
@@ -17,24 +22,22 @@ interface PendingListRequest {
 }
 
 interface PendingSendRequest {
-  resolve(result: SessionMessageSendResult): void;
+  resolve(result: SessionEnvelopeSendResult): void;
   reject(error: Error): void;
   timeout: NodeJS.Timeout;
 }
 
-export interface SessionMessageSendResult {
-  messageId: string;
-  delivered: boolean;
-  error?: string | undefined;
-}
+export type SessionEnvelopeSendResult =
+  | { delivered: true }
+  | {
+      delivered: false;
+      reason?: SessionEnvelopeSendFailureReason | undefined;
+      error?: string | undefined;
+    };
 
-export interface SendSessionMessageOptions {
-  messageId: string;
+export interface SendSessionEnvelopeOptions {
   target: string;
-  body: string;
-  sentAt: string;
-  requestResponse?: boolean | undefined;
-  sourceToolCallId?: string | undefined;
+  envelope: OutboundSessionEnvelope;
 }
 
 export class SessionMessagingClient extends EventEmitter {
@@ -139,39 +142,33 @@ export class SessionMessagingClient extends EventEmitter {
     });
   }
 
-  sendMessage(options: SendSessionMessageOptions): Promise<SessionMessageSendResult> {
+  sendEnvelope(options: SendSessionEnvelopeOptions): Promise<SessionEnvelopeSendResult> {
     const socket = this.requireSocket();
     const requestId = randomUUID();
 
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingSends.delete(requestId);
-        reject(new Error("Session message send timed out."));
+        reject(new Error("Session envelope send timed out."));
       }, REQUEST_TIMEOUT_MS + 1_000);
       this.pendingSends.set(requestId, { resolve, reject, timeout });
       writeFrame(socket, {
         type: "send",
         requestId,
-        messageId: options.messageId,
         target: options.target,
-        body: options.body,
-        requestResponse: options.requestResponse,
-        sourceToolCallId: options.sourceToolCallId,
-        sentAt: options.sentAt,
+        envelope: options.envelope,
       });
     });
   }
 
   acknowledgeIncoming(
     requestId: string,
-    messageId: string,
     result: { delivered: true } | { delivered: false; error: string },
   ): void {
     const socket = this.requireSocket();
     writeFrame(socket, {
       type: "incoming_ack",
       requestId,
-      messageId,
       delivered: result.delivered,
       error: result.delivered ? undefined : result.error,
     });
@@ -209,18 +206,22 @@ export class SessionMessagingClient extends EventEmitter {
         break;
       }
       case "incoming":
-        this.emit(INCOMING_SESSION_MESSAGE_EVENT, frame.requestId, frame.message);
+        this.emit(INCOMING_SESSION_ENVELOPE_EVENT, frame.requestId, frame.envelope);
         break;
       case "send_result": {
         const pending = this.pendingSends.get(frame.requestId);
         if (!pending) return;
         clearTimeout(pending.timeout);
         this.pendingSends.delete(frame.requestId);
-        pending.resolve({
-          messageId: frame.messageId,
-          delivered: frame.delivered,
-          error: frame.error,
-        });
+        pending.resolve(
+          frame.delivered
+            ? { delivered: true }
+            : {
+                delivered: false,
+                ...(frame.reason === undefined ? {} : { reason: frame.reason }),
+                ...(frame.error === undefined ? {} : { error: frame.error }),
+              },
+        );
         break;
       }
       case "error":

package/extensions/shared/session-broker/protocol.ts

@@ -1,6 +1,87 @@
 import { type Static, Type } from "typebox";
 
-export const SESSION_MESSAGE_PAYLOAD_SCHEMA = Type.Object({
+export const TASK_REPORT_REFERENCE_SCHEMA = Type.Object({
+  reference: Type.String({
+    description:
+      "A precise reference such as a file path and line range, symbol name, command, URL, session id, or external artifact.",
+  }),
+  description: Type.Optional(
+    Type.String({
+      description: "Why this reference matters or what evidence the parent should take from it.",
+    }),
+  ),
+});
+
+export const TASK_REPORT_SCHEMA = Type.Object({
+  status: Type.Union(
+    [
+      Type.Literal("done", {
+        description: "The delegated task or requested follow-up is complete.",
+      }),
+      Type.Literal("blocked", {
+        description:
+          "The task cannot continue without a specific decision, clarification, permission, dependency, or other action outside the scope of the task.",
+      }),
+      Type.Literal("incomplete", {
+        description:
+          "Useful work was performed, but the requested result could not be completed and it's uncertain what should be done to reach completion.",
+      }),
+    ],
+    { description: "The subagent's assessment of the task at the end of this turn." },
+  ),
+  summary: Type.String({
+    description:
+      "A concise, 3-4 sentence self-contained account of the outcome and its most important evidence.",
+  }),
+  details: Type.Optional(
+    Type.String({
+      description:
+        "Optional supporting context such as reasoning, implementation notes, validation performed, limitations, unexpected behavior or roadblocks, or failed approaches.",
+    }),
+  ),
+  references: Type.Optional(
+    Type.Array(TASK_REPORT_REFERENCE_SCHEMA, {
+      description: "Supporting material for the report.",
+    }),
+  ),
+  nextSteps: Type.Optional(
+    Type.Array(Type.String(), {
+      description:
+        "Optional concrete actions that would extend or build on the state of the work. If blocked or incomplete, call out specifically what is causing the early return.",
+    }),
+  ),
+});
+
+const OUTBOUND_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+  kind: Type.Literal("message"),
+  messageId: Type.String(),
+  body: Type.String(),
+  requestResponse: Type.Optional(Type.Boolean()),
+  sentAt: Type.String(),
+  sourceToolCallId: Type.Optional(Type.String()),
+});
+const OUTBOUND_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+  kind: Type.Literal("cancel"),
+  cancelId: Type.String(),
+  sentAt: Type.String(),
+});
+const OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+  Type.Object({
+    kind: Type.Literal("subagent_report"),
+    reportId: Type.String(),
+    sentAt: Type.String(),
+  }),
+  TASK_REPORT_SCHEMA,
+]);
+
+export const OUTBOUND_SESSION_ENVELOPE_SCHEMA = Type.Union([
+  OUTBOUND_MESSAGE_ENVELOPE_SCHEMA,
+  OUTBOUND_CANCEL_ENVELOPE_SCHEMA,
+  OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
+
+export const SESSION_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+  kind: Type.Literal("message"),
   messageId: Type.String(),
   source: Type.String(),
   target: Type.String(),
@@ -9,6 +90,29 @@ export const SESSION_MESSAGE_PAYLOAD_SCHEMA = Type.Object({
   sentAt: Type.String(),
   sourceToolCallId: Type.Optional(Type.String()),
 });
+export const SESSION_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+  kind: Type.Literal("cancel"),
+  cancelId: Type.String(),
+  source: Type.String(),
+  target: Type.String(),
+  sentAt: Type.String(),
+});
+export const SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+  Type.Object({
+    kind: Type.Literal("subagent_report"),
+    reportId: Type.String(),
+    source: Type.String(),
+    target: Type.String(),
+    sentAt: Type.String(),
+  }),
+  TASK_REPORT_SCHEMA,
+]);
+
+export const SESSION_ENVELOPE_SCHEMA = Type.Union([
+  SESSION_MESSAGE_ENVELOPE_SCHEMA,
+  SESSION_CANCEL_ENVELOPE_SCHEMA,
+  SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
 
 const REGISTER_CLIENT_FRAME_SCHEMA = Type.Object({
   type: Type.Literal("register"),
@@ -24,17 +128,12 @@ const LIST_CLIENT_FRAME_SCHEMA = Type.Object({
 const SEND_CLIENT_FRAME_SCHEMA = Type.Object({
   type: Type.Literal("send"),
   requestId: Type.String(),
-  messageId: Type.String(),
   target: Type.String(),
-  body: Type.String(),
-  requestResponse: Type.Optional(Type.Boolean()),
-  sentAt: Type.String(),
-  sourceToolCallId: Type.Optional(Type.String()),
+  envelope: OUTBOUND_SESSION_ENVELOPE_SCHEMA,
 });
 const INCOMING_ACK_CLIENT_FRAME_SCHEMA = Type.Object({
   type: Type.Literal("incoming_ack"),
   requestId: Type.String(),
-  messageId: Type.String(),
   delivered: Type.Boolean(),
   error: Type.Optional(Type.String()),
 });
@@ -55,13 +154,18 @@ const SESSIONS_BROKER_FRAME_SCHEMA = Type.Object({
 const INCOMING_BROKER_FRAME_SCHEMA = Type.Object({
   type: Type.Literal("incoming"),
   requestId: Type.String(),
-  message: SESSION_MESSAGE_PAYLOAD_SCHEMA,
+  envelope: SESSION_ENVELOPE_SCHEMA,
 });
+export const SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA = Type.Union([
+  Type.Literal("no_session"),
+  Type.Literal("disconnected"),
+]);
+
 const SEND_RESULT_BROKER_FRAME_SCHEMA = Type.Object({
   type: Type.Literal("send_result"),
   requestId: Type.String(),
-  messageId: Type.String(),
   delivered: Type.Boolean(),
+  reason: Type.Optional(SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA),
   error: Type.Optional(Type.String()),
 });
 const ERROR_BROKER_FRAME_SCHEMA = Type.Object({
@@ -86,7 +190,21 @@ export const BROKER_FRAME_SCHEMA = Type.Union([
   ERROR_BROKER_FRAME_SCHEMA,
 ]);
 
-export type SessionMessagePayload = Static<typeof SESSION_MESSAGE_PAYLOAD_SCHEMA>;
+export type SessionEnvelopeSendFailureReason = Static<
+  typeof SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA
+>;
+export type TaskReportReference = Static<typeof TASK_REPORT_REFERENCE_SCHEMA>;
+export type TaskReport = Static<typeof TASK_REPORT_SCHEMA>;
+export type OutboundSessionMessageEnvelope = Static<typeof OUTBOUND_MESSAGE_ENVELOPE_SCHEMA>;
+export type OutboundSessionCancelEnvelope = Static<typeof OUTBOUND_CANCEL_ENVELOPE_SCHEMA>;
+export type OutboundSubagentReportEnvelope = Static<
+  typeof OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA
+>;
+export type OutboundSessionEnvelope = Static<typeof OUTBOUND_SESSION_ENVELOPE_SCHEMA>;
+export type SessionMessageEnvelope = Static<typeof SESSION_MESSAGE_ENVELOPE_SCHEMA>;
+export type SessionCancelEnvelope = Static<typeof SESSION_CANCEL_ENVELOPE_SCHEMA>;
+export type SessionSubagentReportEnvelope = Static<typeof SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA>;
+export type SessionEnvelope = Static<typeof SESSION_ENVELOPE_SCHEMA>;
 export type SessionMessagingSendClientFrame = Static<typeof SEND_CLIENT_FRAME_SCHEMA>;
 export type SessionMessagingIncomingAckClientFrame = Static<
   typeof INCOMING_ACK_CLIENT_FRAME_SCHEMA

package/extensions/shared/session-index/common.ts

@@ -3,9 +3,10 @@ import type { FileTouchOp, FileTouchSource, PathScope } from "../../session-sear
 import { safeParseTypeBoxJson } from "../typebox.ts";
 import type { SqliteDatabase } from "./sqlite.ts";
 
-export const INDEX_SCHEMA_VERSION = 12;
+export const INDEX_SCHEMA_VERSION = 14;
 
-export type SessionOrigin = "handoff" | "fork" | "unknown_child";
+export type SessionOrigin = "handoff" | "subagent" | "fork" | "unknown_child";
+export type SessionKind = "user" | "subagent";
 export type SessionLineageRelation =
   | "self"
   | "parent"
@@ -32,7 +33,6 @@ export interface SessionRow {
   parentSessionId?: string | undefined;
   sessionOrigin?: SessionOrigin | undefined;
   handoffGoal?: string | undefined;
-  handoffNextTask?: string | undefined;
   indexedFileSize?: number | undefined;
   indexedFileMtimeMs?: number | undefined;
   indexedFileAnchor?: string | undefined;
@@ -50,7 +50,6 @@ export interface SessionLineageRow {
   parentSessionId?: string | undefined;
   sessionOrigin?: SessionOrigin | undefined;
   handoffGoal?: string | undefined;
-  handoffNextTask?: string | undefined;
 }
 
 export interface SessionRelatedSessionRow extends SessionLineageRow {
@@ -93,6 +92,7 @@ export interface SearchSessionsParams {
   before?: string | undefined;
   touched?: string[] | undefined;
   changed?: string[] | undefined;
+  kind?: SessionKind | undefined;
   sort?: SearchSort | undefined;
   limit?: number | undefined;
   excludeSessionIds?: string[] | undefined;
@@ -135,7 +135,6 @@ export interface SearchSessionResult {
   firstUserPrompt?: string | undefined;
   sessionOrigin?: SessionOrigin | undefined;
   handoffGoal?: string | undefined;
-  handoffNextTask?: string | undefined;
   relation?: SessionLineageRelation | undefined;
   snippet: string;
   evidence: SessionSearchEvidence[];
@@ -156,6 +155,7 @@ export type SessionIndexDatabase = SqliteDatabase;
 export const NULLABLE_STRING_SCHEMA = Type.Union([Type.String(), Type.Null()]);
 export const SESSION_ORIGIN_SCHEMA = Type.Union([
   Type.Literal("handoff"),
+  Type.Literal("subagent"),
   Type.Literal("fork"),
   Type.Literal("unknown_child"),
 ]);