@agentknight/sdk 0.9.37 → 0.9.38

package/dist/chunks/{chunk-DSHLLGE2.js → chunk-SREMK7S4.js}

@@ -1,6 +1,6 @@
 import {
   SessionOperationError
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 
 // src/adapters/copilot/runtime/session-identity.ts
 function assertMainSessionId(sessionId) {

package/dist/chunks/{chunk-7JRY2FRZ.js → chunk-UIM3KQRC.js}

@@ -1,9 +1,9 @@
 import {
   isContentfulAssistant
-} from "./chunk-QLGX7333.js";
+} from "./chunk-34DUD2Y4.js";
 import {
   SessionOperationError
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 import {
   CONVERSATION_SOURCE_ID_LIMIT,
   SESSION_DIRECTORY_LIST_OPERATION,
@@ -13,6 +13,7 @@ import {
   SessionGitProjectSchema,
   TIMELINE_IMAGE_OPERATION,
   TIMELINE_SYNC_OPERATION,
+  TimelineResyncReasonSchema,
   WORKBENCH_OPERATIONS,
   WorkbenchAskResultSchema,
   WorkbenchCommandResultSchema,
@@ -21,14 +22,14 @@ import {
   WorkbenchInsightsSchema,
   WorkbenchQueueMutationResultSchema,
   WorkbenchQueueSnapshotSchema
-} from "./chunk-N2LIXMIM.js";
+} from "./chunk-GNQC2IS2.js";
 
 // src/operation-diagnostics.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { getSystemErrorMap } from "node:util";
-import { ZodError } from "zod";
+import { z, ZodError } from "zod";
 
 // src/copilot-connection-errors.ts
 function isClosedCopilotConnection(error) {
@@ -71,6 +72,29 @@ function sessionRestoreFailure(error) {
 }
 
 // src/operation-diagnostics.ts
+var diagnosticCount = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var timelineSyncDiagnosticSchema = z.object({
+  mode: z.enum(["snapshot", "resume", "replay"]),
+  epochMatches: z.boolean(),
+  requestedSequence: diagnosticCount,
+  currentSequence: diagnosticCount,
+  oldestAvailableSequence: diagnosticCount,
+  retainedEvents: diagnosticCount,
+  retainedBytes: diagnosticCount,
+  baselinePublished: z.boolean(),
+  headReadAttempts: diagnosticCount,
+  headReadRestarts: diagnosticCount,
+  restartCause: z.enum(["epoch-changed", "sequence-changed", "cold-step-changed", "head-reconciled"]),
+  status: z.enum(["snapshot", "replay", "resync"]),
+  resyncReason: TimelineResyncReasonSchema,
+  responseItems: diagnosticCount,
+  responseEvents: diagnosticCount,
+  hasMore: z.boolean(),
+  historyReadMode: z.enum(["reload", "reuse"]),
+  historyReadPages: diagnosticCount,
+  historyRawEvents: diagnosticCount,
+  historyItems: diagnosticCount
+}).partial();
 var current = new AsyncLocalStorage();
 var systemCodes = new Set([...getSystemErrorMap().values()].map(([code]) => code));
 var errorTypes = /* @__PURE__ */ new Set(["Error", "TypeError", "RangeError", "SyntaxError", "AbortError", "TimeoutError", "AggregateError"]);
@@ -142,20 +166,25 @@ async function measureOperationPhase(phase, action) {
   const diagnostics = current.getStore();
   if (diagnostics?.running !== true) return action();
   const start = performance.now();
+  const token = diagnostics.startPhase(phase, start);
   try {
     return await action();
   } catch (error) {
     diagnostics.recordFailure(error, phase);
     throw error;
   } finally {
-    diagnostics.durations[phase] += performance.now() - start;
-    if (phase === "read") diagnostics.readCount += 1;
+    diagnostics.finishPhase(token);
+    if (diagnostics.running) {
+      diagnostics.durations[phase] += performance.now() - start;
+      if (phase === "read") diagnostics.readCount += 1;
+    }
   }
 }
 async function measureOperationStage(stage, action) {
   const diagnostics = current.getStore();
   if (diagnostics?.running !== true) return action();
   const start = performance.now();
+  const token = diagnostics.startStage(stage, start);
   let failed = false;
   try {
     return await action();
@@ -164,9 +193,14 @@ async function measureOperationStage(stage, action) {
     diagnostics.recordStageFailure(error, stage);
     throw error;
   } finally {
+    diagnostics.finishStage(token);
     diagnostics.recordStage(stage, performance.now() - start, failed);
   }
 }
+function recordTimelineSyncDiagnostic(details) {
+  const diagnostics = current.getStore();
+  if (diagnostics?.running === true) diagnostics.recordTimelineSync(details);
+}
 function recordOperationTimelineRead(diagnostic) {
   const diagnostics = current.getStore();
   if (diagnostics?.running === true) diagnostics.recordTimelineRead(diagnostic);
@@ -179,18 +213,51 @@ var OperationDiagnostics = class {
   #stages = /* @__PURE__ */ new Map();
   #stageFailures = /* @__PURE__ */ new Map();
   #timelineReads = [];
-  async run(action) {
+  #activePhases = /* @__PURE__ */ new Map();
+  #activeStages = /* @__PURE__ */ new Map();
+  #timelineSync;
+  async run(action, options = {}) {
+    const alreadyRunning = this.#running;
     this.#running = true;
     try {
-      return await current.run(this, () => measureOperationPhase("handle", action));
+      return await current.run(this, () => options.measureHandle === false ? action() : measureOperationPhase("handle", action));
     } finally {
-      this.#running = false;
-      this.#stageFailures.clear();
+      this.#running = alreadyRunning;
+      if (!alreadyRunning) {
+        this.#stageFailures.clear();
+        this.#activePhases.clear();
+        this.#activeStages.clear();
+      }
     }
   }
   get running() {
     return this.#running;
   }
+  startPhase(phase, start) {
+    const token = /* @__PURE__ */ Symbol();
+    this.#activePhases.set(token, { name: phase, start });
+    return token;
+  }
+  finishPhase(token) {
+    this.#activePhases.delete(token);
+  }
+  startStage(stage, start) {
+    const token = /* @__PURE__ */ Symbol();
+    this.#activeStages.set(token, { name: stage, start });
+    return token;
+  }
+  finishStage(token) {
+    this.#activeStages.delete(token);
+  }
+  recordTimelineSync(details) {
+    const parsed = timelineSyncDiagnosticSchema.safeParse(details);
+    if (this.#running && parsed.success) {
+      this.#timelineSync = {
+        ...this.#timelineSync,
+        ...Object.fromEntries(Object.entries(parsed.data).filter(([, value]) => value !== void 0))
+      };
+    }
+  }
   recordFailure(error, phase) {
     const stage = [...this.#stageFailures].find(([, failure]) => Object.is(error, failure))?.[0];
     this.#failure ??= { phase, ...diagnosticError(error), ...stage === void 0 ? {} : { stage } };
@@ -242,10 +309,28 @@ var OperationDiagnostics = class {
         ...sample,
         elapsedMs: Math.round(sample.elapsedMs)
       })) },
-      ...this.#timelineReads.length === 0 ? {} : { timelineReads: [...this.#timelineReads] }
+      ...this.#timelineReads.length === 0 ? {} : { timelineReads: [...this.#timelineReads] },
+      ...this.#timelineSync === void 0 ? {} : { timelineSync: { ...this.#timelineSync } },
+      ...this.#activePhases.size === 0 ? {} : {
+        activePhases: activeSamples(this.#activePhases).map(({ name, ...sample }) => ({ phase: name, ...sample }))
+      },
+      ...this.#activeStages.size === 0 ? {} : {
+        activeStages: activeSamples(this.#activeStages).map(({ name, ...sample }) => ({ stage: name, ...sample }))
+      }
     };
   }
 };
+function activeSamples(active) {
+  const now = performance.now();
+  const samples = /* @__PURE__ */ new Map();
+  for (const { name, start } of active.values()) {
+    const sample = samples.get(name) ?? { name, activeCalls: 0, elapsedMs: 0 };
+    sample.activeCalls++;
+    sample.elapsedMs = Math.max(sample.elapsedMs, Math.round(Math.max(0, now - start)));
+    samples.set(name, sample);
+  }
+  return [...samples.values()];
+}
 var OperationMetrics = class {
   #samples = /* @__PURE__ */ new Map();
   record(request, diagnostics, failed) {
@@ -2114,7 +2199,7 @@ var PromptPreparationError = class extends Error {
 // src/session-project-identity.ts
 import { realpath as realpath2, stat } from "node:fs/promises";
 import { isAbsolute as isAbsolute2 } from "node:path";
-var SESSION_PROJECT_IDENTITY_CONCURRENCY = 4;
+var SESSION_PROJECT_IDENTITY_CONCURRENCY = 20;
 var errors = {
   SESSION_NOT_FOUND: "The session is unavailable",
   SESSION_ROOT_UNAVAILABLE: "The session working directory is unavailable",
@@ -2133,7 +2218,7 @@ async function rootIdentity(workingDirectory) {
   const root = await realpath2(workingDirectory);
   const info = await stat(root);
   if (!info.isDirectory()) throw new SessionProjectIdentityError("SESSION_ROOT_UNAVAILABLE");
-  return `${root}\0${info.dev}\0${info.ino}`;
+  return { path: root, key: `${root}\0${info.dev}\0${info.ino}` };
 }
 var SessionProjectIdentityReader = class {
   constructor(metadata, inspect = resolveGitProjectIdentity) {
@@ -2143,6 +2228,7 @@ var SessionProjectIdentityReader = class {
   metadata;
   inspect;
   #active = 0;
+  #inspections = /* @__PURE__ */ new Map();
   async get(sessionId) {
     if (this.#active >= SESSION_PROJECT_IDENTITY_CONCURRENCY) {
       throw new SessionProjectIdentityError("PROJECT_IDENTITY_BUSY");
@@ -2164,7 +2250,7 @@ var SessionProjectIdentityReader = class {
       let project;
       let inspectionError;
       try {
-        const identity = await this.inspect(cwd);
+        const identity = await this.#inspectRoot(initialRoot);
         project = SessionGitProjectSchema.parse({
           localRepositoryKey: identity.localRepositoryKey,
           worktreeRoot: identity.worktreeRoot,
@@ -2180,7 +2266,7 @@ var SessionProjectIdentityReader = class {
       if (latest === void 0) throw new SessionProjectIdentityError("SESSION_NOT_FOUND");
       if (latest.workingDirectory !== cwd) throw new SessionProjectIdentityError("SESSION_ROOT_CHANGED");
       try {
-        if (await rootIdentity(cwd) !== initialRoot) {
+        if ((await rootIdentity(cwd)).key !== initialRoot.key) {
           throw new SessionProjectIdentityError("SESSION_ROOT_CHANGED");
         }
       } catch (cause) {
@@ -2195,11 +2281,22 @@ var SessionProjectIdentityReader = class {
       this.#active--;
     }
   }
+  async #inspectRoot(root) {
+    const pending = this.#inspections.get(root.key);
+    if (pending !== void 0) return pending;
+    const inspection = Promise.resolve().then(() => this.inspect(root.path));
+    this.#inspections.set(root.key, inspection);
+    try {
+      return await inspection;
+    } finally {
+      this.#inspections.delete(root.key);
+    }
+  }
 };
 
 // src/session-workbench-runtime.ts
 import { createHash as createHash4 } from "node:crypto";
-import { z } from "zod";
+import { z as z2 } from "zod";
 var WorkbenchRuntimeError = class extends SessionOperationError {
   constructor(code, message) {
     super(code, message);
@@ -2209,21 +2306,21 @@ var WorkbenchRuntimeError = class extends SessionOperationError {
 var WorkbenchOutcomeUncertainError = class extends Error {
   code = "stale-runtime";
 };
-var queueSchema = z.object({
-  items: z.array(z.object({
-    id: z.string().min(1).max(256),
-    kind: z.enum(["message", "command"]),
-    displayText: z.string().max(1e5),
-    agentMode: z.enum(["interactive", "plan", "autopilot", "shell"])
+var queueSchema = z2.object({
+  items: z2.array(z2.object({
+    id: z2.string().min(1).max(256),
+    kind: z2.enum(["message", "command"]),
+    displayText: z2.string().max(1e5),
+    agentMode: z2.enum(["interactive", "plan", "autopilot", "shell"])
   })).max(512),
-  steeringMessages: z.array(z.string().max(1e5)).max(512)
+  steeringMessages: z2.array(z2.string().max(1e5)).max(512)
 });
-var resultBase = { runtimeSettingsChanged: z.boolean().optional() };
-var invocationSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("text"), text: z.string().max(64 * 1024), markdown: z.boolean().optional(), preserveAnsi: z.boolean().optional(), ...resultBase }),
-  z.object({ kind: z.literal("completed"), message: z.string().max(64 * 1024).optional(), ...resultBase }),
-  z.object({ kind: z.literal("agent-prompt"), prompt: z.string().min(1).max(64 * 1024), displayPrompt: z.string().max(64 * 1024), mode: z.enum(["interactive", "plan", "autopilot"]).optional(), notice: z.string().max(64 * 1024).optional(), ...resultBase }),
-  z.object({ kind: z.literal("select-subcommand"), command: z.string().max(256), title: z.string().max(4096), options: z.array(z.object({ name: z.string().max(256), description: z.string().max(4096), group: z.string().max(256).optional() })).max(256), ...resultBase })
+var resultBase = { runtimeSettingsChanged: z2.boolean().optional() };
+var invocationSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("text"), text: z2.string().max(64 * 1024), markdown: z2.boolean().optional(), preserveAnsi: z2.boolean().optional(), ...resultBase }),
+  z2.object({ kind: z2.literal("completed"), message: z2.string().max(64 * 1024).optional(), ...resultBase }),
+  z2.object({ kind: z2.literal("agent-prompt"), prompt: z2.string().min(1).max(64 * 1024), displayPrompt: z2.string().max(64 * 1024), mode: z2.enum(["interactive", "plan", "autopilot"]).optional(), notice: z2.string().max(64 * 1024).optional(), ...resultBase }),
+  z2.object({ kind: z2.literal("select-subcommand"), command: z2.string().max(256), title: z2.string().max(4096), options: z2.array(z2.object({ name: z2.string().max(256), description: z2.string().max(4096), group: z2.string().max(256).optional() })).max(256), ...resultBase })
 ]);
 function nanoAiu(value) {
   if (!Number.isSafeInteger(value) || value < 0) {
@@ -2322,7 +2419,7 @@ var SessionWorkbenchRuntime = class {
     }
   }
   async ask(sessionId, question) {
-    z.string().trim().min(1).max(16 * 1024).parse(question);
+    z2.string().trim().min(1).max(16 * 1024).parse(question);
     this.dependencies.assertAvailable(sessionId);
     const runtime = this.dependencies.getRuntime(sessionId);
     if (runtime.workbench.compacting || runtime.workbench.activeQuestions > 0 || this.#activeQuestions >= 2) {
@@ -2335,7 +2432,12 @@ var SessionWorkbenchRuntime = class {
       if (session.rpc.ui.ephemeralQuery === void 0) {
         throw new WorkbenchRuntimeError("unsupported", "This runtime does not support side questions");
       }
-      const result = z.object({ answer: z.string().max(64 * 1024) }).parse(
+      const { modelId } = await session.rpc.model.getCurrent();
+      this.#assertGeneration(sessionId, generation);
+      if (modelId === "auto") {
+        throw new WorkbenchRuntimeError("unsupported", "Choose a specific model instead of Auto to use Ask.");
+      }
+      const result = z2.object({ answer: z2.string().max(64 * 1024) }).parse(
         await session.rpc.ui.ephemeralQuery({ question })
       );
       this.#assertGeneration(sessionId, generation);
@@ -2399,14 +2501,14 @@ var SessionWorkbenchRuntime = class {
         let outcome;
         switch (input.action) {
           case "edit":
-            z.string().trim().min(1).max(1e5).parse(input.text);
+            z2.string().trim().min(1).max(1e5).parse(input.text);
             outcome = (await queue.updateText({ id: input.id, prompt: input.text, displayPrompt: input.text })).updated ? "updated" : "unchanged";
             break;
           case "remove":
             outcome = (await queue.removeAt({ id: input.id })).removed ? "removed" : "not-found";
             break;
           case "move":
-            z.number().int().nonnegative().max(511).parse(input.toPosition);
+            z2.number().int().nonnegative().max(511).parse(input.toPosition);
             outcome = (await queue.moveItem({ id: input.id, toPosition: input.toPosition })).changed ? "moved" : "unchanged";
             break;
           case "send-now":
@@ -2589,7 +2691,7 @@ var SessionWorkbenchRuntime = class {
         await this.dependencies.configureSession(sessionId, { modelId: selected });
       } else {
         const mode = command.name === "plan" ? "plan" : command.name === "autopilot" ? "autopilot" : selected;
-        const parsedMode = z.enum(["interactive", "plan", "autopilot"]).safeParse(mode);
+        const parsedMode = z2.enum(["interactive", "plan", "autopilot"]).safeParse(mode);
         if (!parsedMode.success) throw new WorkbenchRuntimeError("unsupported", "Choose a model or mode using session configuration");
         await this.dependencies.configureSession(sessionId, { agentMode: parsedMode.data });
       }
@@ -2646,6 +2748,7 @@ export {
   validateOperationResponse,
   measureOperationPhase,
   measureOperationStage,
+  recordTimelineSyncDiagnostic,
   recordOperationTimelineRead,
   OperationDiagnostics,
   OperationMetrics,

package/dist/chunks/{chunk-VXZ25DKC.js → chunk-YSJRQ35E.js}

@@ -1,14 +1,14 @@
 import {
   AgentSessionRenameError,
   validateSessionName
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 import {
   ConversationItemSchema,
   GroupChatInfoSchema,
   GroupChatParticipantSchema,
   SESSION_TIMELINE_PAGE_SIZE,
   SessionSummarySchema
-} from "./chunk-N2LIXMIM.js";
+} from "./chunk-GNQC2IS2.js";
 
 // src/group-chat.ts
 import { createHash, randomUUID } from "node:crypto";

package/dist/chunks/{copilot-adapter-KM6RMGFR.js → copilot-adapter-USX4UEWH.js}

@@ -15,26 +15,27 @@ import {
   measureOperationStage,
   recordOperationFailure,
   recordOperationTimelineRead,
+  recordTimelineSyncDiagnostic,
   resolveGitProjectIdentity,
   sanitizeGitRemoteUrl
-} from "./chunk-7JRY2FRZ.js";
+} from "./chunk-UIM3KQRC.js";
 import {
   assertMainSessionId,
   isResearchSessionId
-} from "./chunk-DSHLLGE2.js";
+} from "./chunk-SREMK7S4.js";
 import {
   GroupChatError,
   GroupChatMessageSchema,
   GroupChatRuntime
-} from "./chunk-VXZ25DKC.js";
+} from "./chunk-YSJRQ35E.js";
 import {
   isContentfulAssistant
-} from "./chunk-QLGX7333.js";
+} from "./chunk-34DUD2Y4.js";
 import {
   AgentSessionRenameError,
   SessionOperationError,
   validateSessionName
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 import {
   ConversationItemSchema,
   CopilotModelOptionSchema,
@@ -54,7 +55,7 @@ import {
   WorkbenchScheduleEntrySchema,
   WorkbenchScheduleProposalSchema,
   WorkbenchScheduleSnapshotSchema
-} from "./chunk-N2LIXMIM.js";
+} from "./chunk-GNQC2IS2.js";
 
 // src/copilot-adapter.ts
 import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
@@ -2046,9 +2047,16 @@ var TimelineHistory = class {
     const pageSize = options.pageSize;
     const runtime = this.ports.state(sessionId);
     const shouldReloadHead = options.cursor === void 0 && this.ports.provisional(sessionId) === void 0 && this.ports.lifecycle.canRefreshSessionConnection(sessionId);
+    const reload = shouldReloadHead || this.ports.current(sessionId) === void 0 && !this.ports.hasPendingSend(sessionId);
+    recordTimelineSyncDiagnostic({
+      historyReadMode: reload ? "reload" : "reuse",
+      historyReadPages: 0,
+      historyRawEvents: 0,
+      historyItems: 0
+    });
     const session = await measureOperationStage(
       "session-open",
-      () => shouldReloadHead || this.ports.current(sessionId) === void 0 && !this.ports.hasPendingSend(sessionId) ? this.ports.lifecycle.reloadSession(sessionId) : this.ports.lifecycle.getSession(sessionId)
+      () => reload ? this.ports.lifecycle.reloadSession(sessionId) : this.ports.lifecycle.getSession(sessionId)
     );
     beginRead();
     const toolLifecycles = runtime.toolLifecycles;
@@ -2057,6 +2065,8 @@ var TimelineHistory = class {
     let hasMore = true;
     let cursorStatus = "ok";
     let rawEventCount = 0;
+    let readPages = 0;
+    let readEvents = 0;
     let rawEvents = [];
     let displayItems = [];
     const rawEventLimit = pageSize * MAX_TIMELINE_RAW_EVENT_MULTIPLIER;
@@ -2073,8 +2083,11 @@ var TimelineHistory = class {
         includeEphemeral: false
       }));
       const events = response.events;
+      readPages++;
+      readEvents += events.length;
+      recordTimelineSyncDiagnostic({ historyReadPages: readPages, historyRawEvents: readEvents });
       const candidateRawEvents = [...events, ...rawEvents];
-      const candidateDisplayItems = normalizeTimelineEvents(candidateRawEvents, toolLifecycles, resolveInputProvenance);
+      const candidateDisplayItems = await measureOperationStage("timeline-normalize", () => normalizeTimelineEvents(candidateRawEvents, toolLifecycles, resolveInputProvenance));
       const candidatePageItems = candidateDisplayItems.slice(-pageSize);
       if (candidateDisplayItems.length > pageSize && displayItems.length >= pageSize) {
         displayItems = candidateDisplayItems;
@@ -2108,13 +2121,13 @@ var TimelineHistory = class {
     const hydratedNormalizer = new ConversationNormalizer((failure) => {
       this.ports.callbacks()?.onImageProjectionFailure?.(sessionId, failure);
     }, toolLifecycles, resolveInputProvenance);
-    hydratedNormalizer.apply(rawEvents);
+    await measureOperationStage("timeline-normalize", () => hydratedNormalizer.apply(rawEvents));
     if (hydratedNormalizer.pendingImageAssetIds().length > 0) {
-      await this.ports.resolveImages(
+      await measureOperationStage("timeline-image-resolve", () => this.ports.resolveImages(
         sessionId,
         session,
         hydratedNormalizer
-      );
+      ));
       displayItems = hydratedNormalizer.snapshot();
       if (timelineItemsSize(displayItems.slice(-pageSize)) > TIMELINE_PAGE_PAYLOAD_BUDGET_BYTES) {
         throw new Error(
@@ -2123,6 +2136,7 @@ var TimelineHistory = class {
       }
     }
     await this.#observePersistedSessionLog(sessionId);
+    recordTimelineSyncDiagnostic({ historyItems: Math.min(displayItems.length, pageSize) });
     return SessionTimelinePageSchema.parse({
       items: displayItems.slice(-pageSize),
       cursor,

package/dist/chunks/{managed-agent-adapter-4W4HC67T.js → managed-agent-adapter-EMBDKITT.js}

@@ -1,13 +1,13 @@
 import {
   AgentSelectionSchema,
   assertSelectionSnapshotFits
-} from "./chunk-U2HBI4SH.js";
+} from "./chunk-6YF3VZLR.js";
 import {
   isResearchSessionId
-} from "./chunk-DSHLLGE2.js";
+} from "./chunk-SREMK7S4.js";
 import {
   GroupChatError
-} from "./chunk-VXZ25DKC.js";
+} from "./chunk-YSJRQ35E.js";
 import {
   AgentModelListingError,
   AgentSessionRenameError,
@@ -15,11 +15,11 @@ import {
   UnsupportedAgentOperationError,
   captureWorkbenchAccess,
   validateSessionName
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 import {
   InteractionResponseSchema,
   SessionSummarySchema
-} from "./chunk-N2LIXMIM.js";
+} from "./chunk-GNQC2IS2.js";
 
 // src/managed-agent-adapter.ts
 import { createHash, randomUUID } from "node:crypto";

package/dist/chunks/{pi-adapter-IFNN3F4N.js → pi-adapter-KT5M7Z6R.js}

@@ -1,16 +1,16 @@
 import {
   latestPreviewItems
-} from "./chunk-QLGX7333.js";
+} from "./chunk-34DUD2Y4.js";
 import {
   AgentSessionRenameError,
   UnsupportedAgentOperationError,
   validateSessionName
-} from "./chunk-UJZPAP64.js";
+} from "./chunk-6GVMVE5N.js";
 import {
   InteractionRequestSchema,
   REASONING_EFFORTS,
   SESSION_TIMELINE_PAGE_SIZE
-} from "./chunk-N2LIXMIM.js";
+} from "./chunk-GNQC2IS2.js";
 
 // src/pi-adapter.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";

package/dist/index.d.ts

@@ -892,9 +892,9 @@ declare const ConversationItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         assistant: "assistant";
     }>;
     operation: z.ZodEnum<{
+        deleted: "deleted";
         created: "created";
         updated: "updated";
-        deleted: "deleted";
     }>;
     content: z.ZodString;
     todos: z.ZodArray<z.ZodObject<{
@@ -1140,9 +1140,9 @@ declare const SessionTimelinePageSchema: z.ZodObject<{
             assistant: "assistant";
         }>;
         operation: z.ZodEnum<{
+            deleted: "deleted";
             created: "created";
             updated: "updated";
-            deleted: "deleted";
         }>;
         content: z.ZodString;
         todos: z.ZodArray<z.ZodObject<{
@@ -1884,6 +1884,8 @@ type OutboundArguments = {
 interface RelaySocket {
     readonly connected: boolean;
     readonly active: boolean;
+    /** Native Socket.IO backlog; invalidated when the registered connection ends. */
+    readonly sendBuffer?: unknown[];
     readonly io: {
         readonly engine?: {
             readonly transport?: {