@agentknight/sdk 0.9.35

package/dist/chunks/chunk-JFHUAIRY.js

@@ -0,0 +1,2659 @@
+import {
+  isContentfulAssistant
+} from "./chunk-MVUOCZFL.js";
+import {
+  SessionOperationError
+} from "./chunk-SJHJER3B.js";
+import {
+  CONVERSATION_SOURCE_ID_LIMIT,
+  SESSION_DIRECTORY_LIST_OPERATION,
+  SESSION_FILE_READ_OPERATION,
+  SESSION_PROJECT_IDENTITY_OPERATION,
+  SESSION_RESOURCE_READ_OPERATION,
+  SessionGitProjectSchema,
+  TIMELINE_IMAGE_OPERATION,
+  TIMELINE_SYNC_OPERATION,
+  WORKBENCH_OPERATIONS,
+  WorkbenchAskResultSchema,
+  WorkbenchCommandResultSchema,
+  WorkbenchCommandSchema,
+  WorkbenchCompactResultSchema,
+  WorkbenchInsightsSchema,
+  WorkbenchQueueMutationResultSchema,
+  WorkbenchQueueSnapshotSchema
+} from "./chunk-ZKAN2FO7.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";
+
+// src/copilot-connection-errors.ts
+function isClosedCopilotConnection(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  switch (error.message) {
+    case "Connection is closed.":
+      return !("code" in error) || error.code === 1;
+    case "Connection is disposed.":
+      return !("code" in error) || error.code === 2;
+    case "Pending response rejected since connection got disposed":
+      return !("code" in error) || error.code === -32097;
+    default:
+      return false;
+  }
+}
+function isDisposedCopilotSession(error) {
+  return error instanceof Error && (error.message === "Session has been disposed" || (!("code" in error) || error.code === -32603) && /^Request session\.[A-Za-z0-9.]+ failed with message: Session has been disposed$/u.test(error.message));
+}
+
+// src/session-restore-error.ts
+var restoreMessages = /* @__PURE__ */ new Set([
+  "First event must be session.start or session.resume",
+  "session resume failed: First event must be session.start or session.resume",
+  "Request session.resume failed with message: session resume failed: First event must be session.start or session.resume"
+]);
+function isSessionRestoreFailure(error) {
+  for (let depth = 0; depth < 8 && error instanceof Error; depth++) {
+    if ("code" in error && error.code === "SESSION_RESTORE_FAILED" || restoreMessages.has(error.message)) return true;
+    error = error.cause;
+  }
+  return false;
+}
+function sessionRestoreFailure(error) {
+  return isSessionRestoreFailure(error) ? {
+    code: "SESSION_RESTORE_FAILED",
+    message: "The session could not be restored. Retry to reconnect."
+  } : void 0;
+}
+
+// src/operation-diagnostics.ts
+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"]);
+var operations = /* @__PURE__ */ new Set([
+  TIMELINE_SYNC_OPERATION,
+  TIMELINE_IMAGE_OPERATION,
+  SESSION_DIRECTORY_LIST_OPERATION,
+  SESSION_FILE_READ_OPERATION,
+  SESSION_PROJECT_IDENTITY_OPERATION,
+  SESSION_RESOURCE_READ_OPERATION,
+  ...WORKBENCH_OPERATIONS
+]);
+var operationName = (request) => operations.has(request.operation) ? request.operation : "unknown";
+function diagnosticReference(kind, value) {
+  return `${kind}:${createHash("sha256").update(`${kind}:${value}`).digest("hex").slice(0, 16)}`;
+}
+function diagnosticRequest(request) {
+  return {
+    requestRef: diagnosticReference("request", request.requestId),
+    machineRef: diagnosticReference("machine", request.machineId),
+    ...request.sessionId === void 0 ? {} : { sessionRef: diagnosticReference("session", request.sessionId) },
+    ...request.operationId === void 0 ? {} : { operationRef: diagnosticReference("operation", request.operationId) }
+  };
+}
+function diagnosticError(error) {
+  const fields = {
+    errorType: error instanceof ZodError ? "ZodError" : error instanceof Error ? errorTypes.has(error.name) ? error.name : "CustomError" : "NonError"
+  };
+  fields.errorCategory = errorCategory(error);
+  if (error instanceof Error && "code" in error && typeof error.code === "string" && systemCodes.has(error.code)) fields.errorCode = error.code;
+  if (error instanceof Error && "code" in error && typeof error.code === "number" && [-32700, -32600, -32601, -32602, -32603, -32097].includes(error.code)) fields.rpcCode = error.code;
+  if (error instanceof ZodError) {
+    fields.issueCount = error.issues.length;
+    fields.issueCodes = [...new Set(error.issues.map((issue) => issue.code))].slice(0, 8);
+  }
+  if (error instanceof Error && error.cause !== void 0 && error.cause !== error) {
+    const cause = error.cause;
+    fields.causeType = cause instanceof Error && errorTypes.has(cause.name) ? cause.name : "Other";
+    fields.causeCategory = errorCategory(cause);
+    if (cause instanceof Error && "code" in cause && typeof cause.code === "string" && systemCodes.has(cause.code)) fields.causeCode = cause.code;
+  }
+  if (error instanceof AggregateError) {
+    fields.childCount = error.errors.length;
+    fields.childCategories = error.errors.slice(0, 2).map((child) => errorCategory(child));
+  }
+  return fields;
+}
+function errorCategory(error) {
+  if (isSessionRestoreFailure(error)) return "SESSION_RESTORE_FAILED";
+  if (isClosedCopilotConnection(error)) return "COPILOT_CONNECTION_CLOSED";
+  if (isDisposedCopilotSession(error)) return "COPILOT_SESSION_DISPOSED";
+  if (error instanceof ZodError) return "SCHEMA_VALIDATION";
+  if (error instanceof Error && "code" in error && (error.code === "SESSION_NOT_SHARED" || error.code === "AGENT_OPERATION_UNSUPPORTED")) return error.code;
+  return "OTHER";
+}
+function recordOperationFailure(error, phase) {
+  const diagnostics = current.getStore();
+  if (diagnostics?.running === true) diagnostics.recordFailure(error, phase);
+}
+function validateOperationResponse(action) {
+  try {
+    return action();
+  } catch (error) {
+    recordOperationFailure(error, "validate-response");
+    throw error;
+  }
+}
+async function measureOperationPhase(phase, action) {
+  const diagnostics = current.getStore();
+  if (diagnostics?.running !== true) return action();
+  const start = performance.now();
+  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;
+  }
+}
+async function measureOperationStage(stage, action) {
+  const diagnostics = current.getStore();
+  if (diagnostics?.running !== true) return action();
+  const start = performance.now();
+  let failed = false;
+  try {
+    return await action();
+  } catch (error) {
+    failed = true;
+    diagnostics.recordStageFailure(error, stage);
+    throw error;
+  } finally {
+    diagnostics.recordStage(stage, performance.now() - start, failed);
+  }
+}
+function recordOperationTimelineRead(diagnostic) {
+  const diagnostics = current.getStore();
+  if (diagnostics?.running === true) diagnostics.recordTimelineRead(diagnostic);
+}
+var OperationDiagnostics = class {
+  durations = { handle: 0, read: 0, wait: 0, emit: 0 };
+  readCount = 0;
+  #failure;
+  #running = false;
+  #stages = /* @__PURE__ */ new Map();
+  #stageFailures = /* @__PURE__ */ new Map();
+  #timelineReads = [];
+  async run(action) {
+    this.#running = true;
+    try {
+      return await current.run(this, () => measureOperationPhase("handle", action));
+    } finally {
+      this.#running = false;
+      this.#stageFailures.clear();
+    }
+  }
+  get running() {
+    return this.#running;
+  }
+  recordFailure(error, phase) {
+    const stage = [...this.#stageFailures].find(([, failure]) => Object.is(error, failure))?.[0];
+    this.#failure ??= { phase, ...diagnosticError(error), ...stage === void 0 ? {} : { stage } };
+  }
+  recordStageFailure(error, stage) {
+    if (!this.#running) return;
+    if (![...this.#stageFailures.values()].some((failure) => Object.is(error, failure))) {
+      this.#stageFailures.set(stage, error);
+    }
+  }
+  recordStage(stage, elapsedMs, failed) {
+    if (!this.#running) return;
+    const sample = this.#stages.get(stage) ?? { calls: 0, elapsedMs: 0, failedCalls: 0 };
+    sample.calls++;
+    sample.elapsedMs += elapsedMs;
+    sample.failedCalls += failed ? 1 : 0;
+    this.#stages.set(stage, sample);
+  }
+  recordTimelineRead(diagnostic) {
+    if (this.#timelineReads.length < 8) {
+      this.#timelineReads.push({ readRef: diagnostic.readRef, joined: diagnostic.readJoins > 0 });
+    }
+  }
+  get activeMs() {
+    return Math.max(0, this.durations.handle - this.durations.wait) + this.durations.emit;
+  }
+  fields(request) {
+    return {
+      operation: operationName(request),
+      version: request.version,
+      ...diagnosticRequest(request),
+      ...this.details()
+    };
+  }
+  details() {
+    return {
+      diagnosticVersion: 2,
+      handleMs: Math.round(this.durations.handle),
+      readMs: Math.round(this.durations.read),
+      readCount: this.readCount,
+      waitMs: Math.round(this.durations.wait),
+      emitMs: Math.round(this.durations.emit),
+      activeMs: Math.round(this.activeMs),
+      phase: "handle",
+      ...this.#failure,
+      // Nested or parallel stage durations overlap; they must not be summed as wall-clock time.
+      ...this.#stages.size === 0 ? {} : { stages: [...this.#stages].map(([stage, sample]) => ({
+        stage,
+        ...sample,
+        elapsedMs: Math.round(sample.elapsedMs)
+      })) },
+      ...this.#timelineReads.length === 0 ? {} : { timelineReads: [...this.#timelineReads] }
+    };
+  }
+};
+var OperationMetrics = class {
+  #samples = /* @__PURE__ */ new Map();
+  record(request, diagnostics, failed) {
+    const operation = operationName(request);
+    const sample = this.#samples.get(operation) ?? {
+      operation,
+      requests: 0,
+      failures: 0,
+      handleMs: 0,
+      readMs: 0,
+      waitMs: 0,
+      emitMs: 0,
+      maxActiveMs: 0,
+      maxReadMs: 0
+    };
+    sample.requests += 1;
+    sample.failures += failed ? 1 : 0;
+    for (const [field, phase] of [
+      ["handleMs", "handle"],
+      ["readMs", "read"],
+      ["waitMs", "wait"],
+      ["emitMs", "emit"]
+    ]) sample[field] += Math.round(diagnostics.durations[phase]);
+    sample.maxActiveMs = Math.max(sample.maxActiveMs, Math.round(diagnostics.activeMs));
+    sample.maxReadMs = Math.max(sample.maxReadMs, Math.round(diagnostics.durations.read));
+    this.#samples.set(operation, sample);
+  }
+  drain() {
+    const samples = [...this.#samples.values()];
+    this.#samples.clear();
+    return samples;
+  }
+};
+
+// src/conversation-normalizer.ts
+import { createHash as createHash2 } from "node:crypto";
+var SUMMARY_LIMIT = 4096;
+var IDENTIFIER_LIMIT = 256;
+var TASK_COMPLETE_TOOL_NAME = "task_complete";
+var MAX_INLINE_IMAGE_BYTES = 3 * 1024 * 1024;
+var MAX_INLINE_IMAGE_MESSAGE_BYTES = 3 * 1024 * 1024;
+var MAX_INLINE_IMAGES_PER_MESSAGE = 4;
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+function splitToolImages(images) {
+  const groups = [];
+  let group = [];
+  let groupBytes = 0;
+  for (const image of images) {
+    const imageBytes = image.attachment.byteLength ?? 0;
+    if (group.length > 0 && (group.length >= MAX_INLINE_IMAGES_PER_MESSAGE || groupBytes + imageBytes > MAX_INLINE_IMAGE_MESSAGE_BYTES)) {
+      groups.push(group);
+      group = [];
+      groupBytes = 0;
+    }
+    group.push(image);
+    groupBytes += imageBytes;
+  }
+  if (group.length > 0) {
+    groups.push(group);
+  }
+  return groups;
+}
+function protocolId(value) {
+  if (value.length <= IDENTIFIER_LIMIT) {
+    return value;
+  }
+  const digest = createHash2("sha256").update(value).digest("hex");
+  return `sha256:${digest}`;
+}
+function scopedId(scope, value) {
+  const id = `${scope}:${value}`;
+  if (id.length <= IDENTIFIER_LIMIT) {
+    return id;
+  }
+  const digest = createHash2("sha256").update(value).digest("hex");
+  return `${scope}:sha256:${digest}`;
+}
+function assistantMessageId(data) {
+  return scopedId("assistant", data.apiCallId ?? data.messageId);
+}
+function eventRevision(timestamp, previousRevision) {
+  const timestampRevision = Date.parse(timestamp);
+  if (!Number.isSafeInteger(timestampRevision) || timestampRevision < 0) {
+    throw new Error(`Invalid SDK event timestamp: ${timestamp}`);
+  }
+  const revision = previousRevision === void 0 || timestampRevision > previousRevision ? timestampRevision : previousRevision + 1;
+  if (!Number.isSafeInteger(revision)) {
+    throw new Error(`SDK event revision exceeds the safe integer range: ${timestamp}`);
+  }
+  return revision;
+}
+function removeInternalMarkup(value) {
+  return value.replace(
+    /<skill-context\b[^>]*>[\s\S]*?<\/skill-context\s*>/giu,
+    " "
+  ).replace(/<skill-context\b[^>]*>[\s\S]*/giu, " ").replace(/<\/?system_notification\b[^>]*>/giu, " ");
+}
+function stripInternalMarkup(value) {
+  return removeInternalMarkup(value).replace(/\s+/gu, " ").trim();
+}
+function limitSummary(value, limit = SUMMARY_LIMIT) {
+  if (value.length <= limit) {
+    return value;
+  }
+  return `${value.slice(0, limit - 1)}\u2026`;
+}
+function boundedText(value, limit, fallback) {
+  const normalized = stripInternalMarkup(value);
+  return limitSummary(normalized.length === 0 ? fallback : normalized, limit);
+}
+function boundedOptionalText(value, limit) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = stripInternalMarkup(value);
+  return normalized.length === 0 ? void 0 : limitSummary(normalized, limit);
+}
+function boundedOptionalMessageContent(value, limit) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = removeInternalMarkup(value).trim();
+  return normalized.length === 0 ? void 0 : limitSummary(normalized, limit);
+}
+function appendSourceEventId(sourceEventIds, eventId) {
+  return [...sourceEventIds, eventId].slice(-CONVERSATION_SOURCE_ID_LIMIT);
+}
+function appendOptionalSourceId(sourceIds, sourceId) {
+  if (sourceId === void 0) {
+    return sourceIds === void 0 ? void 0 : [...sourceIds];
+  }
+  return [...sourceIds ?? [], sourceId].filter((candidate, index, all) => all.indexOf(candidate) === index).slice(-CONVERSATION_SOURCE_ID_LIMIT);
+}
+function appendAssistantContent(existing, next) {
+  const combined = existing.length > 0 && next.length > 0 ? `${existing}
+
+${next}` : existing || next;
+  if (combined.length <= 5e5) {
+    return combined;
+  }
+  return `\u2026${combined.slice(combined.length - 499999)}`;
+}
+function boundAttachment(attachment) {
+  return {
+    ...attachment,
+    name: boundedText(attachment.name, 1024, "Attachment"),
+    ...attachment.mimeType === void 0 ? {} : {
+      mimeType: boundedText(
+        attachment.mimeType,
+        256,
+        "application/octet-stream"
+      )
+    },
+    ...attachment.uri === void 0 ? {} : { uri: boundedText(attachment.uri, 32768, "unknown") }
+  };
+}
+function summarizeUnknown(value) {
+  if (typeof value === "string") {
+    return limitSummary(stripInternalMarkup(value));
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  try {
+    return limitSummary(stripInternalMarkup(JSON.stringify(value)));
+  } catch {
+    return "[unserializable]";
+  }
+}
+function isDisplayableHumanMessage(event) {
+  if (event.type !== "user.message" || event.agentId !== void 0) {
+    return false;
+  }
+  const source = event.data.source;
+  return event.data.isAutopilotContinuation !== true && (source === void 0 || source === "user" || source === "mobile");
+}
+function projectAttachment(attachment) {
+  switch (attachment.type) {
+    case "file":
+      return {
+        kind: attachment.mimeType?.startsWith("image/") ? "image" : "file",
+        name: attachment.displayName,
+        ...attachment.mimeType === void 0 ? {} : { mimeType: attachment.mimeType },
+        uri: attachment.path
+      };
+    case "directory":
+      return {
+        kind: "file",
+        name: attachment.displayName,
+        uri: attachment.path
+      };
+    case "selection":
+      return {
+        kind: "selection",
+        name: attachment.displayName,
+        uri: attachment.filePath
+      };
+    case "github_reference":
+      return {
+        kind: "github-reference",
+        name: attachment.title,
+        uri: attachment.url
+      };
+    case "github_commit":
+      return {
+        kind: "github-reference",
+        name: attachment.message,
+        uri: attachment.url
+      };
+    case "github_release":
+      return {
+        kind: "github-reference",
+        name: attachment.name,
+        uri: attachment.url
+      };
+    case "github_actions_job":
+      return {
+        kind: "github-reference",
+        name: attachment.jobName,
+        uri: attachment.url
+      };
+    case "github_repository":
+      return {
+        kind: "github-reference",
+        name: `${attachment.repo.owner}/${attachment.repo.name}`,
+        uri: attachment.url
+      };
+    case "github_file_diff":
+      return {
+        kind: "github-reference",
+        name: "GitHub file diff",
+        uri: attachment.url
+      };
+    case "github_tree_comparison":
+      return {
+        kind: "github-reference",
+        name: "GitHub tree comparison",
+        uri: attachment.url
+      };
+    case "github_url":
+      return {
+        kind: "github-reference",
+        name: attachment.url,
+        uri: attachment.url
+      };
+    case "github_file":
+    case "github_snippet":
+      return {
+        kind: "github-reference",
+        name: attachment.path,
+        uri: attachment.url
+      };
+    case "blob":
+      return {
+        kind: attachment.mimeType.startsWith("image/") ? "image" : "file",
+        name: attachment.displayName ?? "Attachment",
+        mimeType: attachment.mimeType
+      };
+    case "extension_context":
+      return {
+        kind: "unknown",
+        name: attachment.title
+      };
+  }
+}
+function projectCitation(source) {
+  if (source.url !== void 0) {
+    return {
+      kind: "github-reference",
+      name: source.title ?? source.path ?? source.id,
+      uri: source.url
+    };
+  }
+  if (source.path !== void 0) {
+    return {
+      kind: "file",
+      name: source.title ?? source.path,
+      uri: source.path
+    };
+  }
+  return {
+    kind: "unknown",
+    name: source.title ?? source.id
+  };
+}
+function normalizeImageMimeType(value) {
+  return value.toLowerCase() === "image/jpg" ? "image/jpeg" : value.toLowerCase();
+}
+function hasImageSignature(bytes, mimeType) {
+  switch (mimeType) {
+    case "image/jpeg":
+      return bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+    case "image/png":
+      return bytes.length >= 8 && bytes.subarray(0, 8).equals(
+        Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])
+      );
+    case "image/webp":
+      return bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP";
+    case "image/gif":
+      return bytes.length >= 6 && (bytes.subarray(0, 6).toString("ascii") === "GIF87a" || bytes.subarray(0, 6).toString("ascii") === "GIF89a");
+    default:
+      return false;
+  }
+}
+function decodeImageBase64(value, expectedMimeType) {
+  const dataUrlMatch = /^data:([^;,]+);base64,(.*)$/isu.exec(value);
+  if (dataUrlMatch !== null && normalizeImageMimeType(dataUrlMatch[1] ?? "") !== expectedMimeType) {
+    return void 0;
+  }
+  const payload = dataUrlMatch?.[2] ?? value;
+  const normalized = payload.replaceAll("-", "+").replaceAll("_", "/");
+  if (normalized.length === 0 || normalized.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(normalized)) {
+    return void 0;
+  }
+  const bytes = Buffer.from(normalized, "base64");
+  return bytes.toString("base64").replace(/=+$/u, "") === normalized.replace(/=+$/u, "") ? bytes : void 0;
+}
+function projectInlineToolImage(data, mimeTypeValue, name, expectedByteLength, source = "binary-result") {
+  const mimeType = normalizeImageMimeType(mimeTypeValue);
+  const metadata = {
+    kind: "image",
+    name: boundedText(name, 1024, "Copilot image"),
+    mimeType: boundedText(mimeType, 256, "application/octet-stream")
+  };
+  if (!SUPPORTED_IMAGE_MIME_TYPES.has(mimeType)) {
+    return {
+      attachment: metadata,
+      failure: { source, reason: "mime-unsupported", mimeType }
+    };
+  }
+  const bytes = decodeImageBase64(data, mimeType);
+  if (bytes === void 0) {
+    return {
+      attachment: metadata,
+      failure: { source, reason: "data-invalid", mimeType }
+    };
+  }
+  if (bytes.length === 0) {
+    return {
+      attachment: metadata,
+      failure: { source, reason: "data-empty", mimeType, actualByteLength: 0 }
+    };
+  }
+  if (bytes.length > MAX_INLINE_IMAGE_BYTES) {
+    return {
+      attachment: metadata,
+      failure: {
+        source,
+        reason: "data-too-large",
+        mimeType,
+        actualByteLength: bytes.length
+      }
+    };
+  }
+  if (expectedByteLength !== void 0 && bytes.length !== expectedByteLength) {
+    return {
+      attachment: metadata,
+      failure: {
+        source,
+        reason: "length-mismatch",
+        mimeType,
+        expectedByteLength,
+        actualByteLength: bytes.length
+      }
+    };
+  }
+  if (!hasImageSignature(bytes, mimeType)) {
+    return {
+      attachment: metadata,
+      failure: {
+        source,
+        reason: "signature-mismatch",
+        mimeType,
+        actualByteLength: bytes.length
+      }
+    };
+  }
+  return {
+    attachment: {
+      ...metadata,
+      data: bytes.toString("base64"),
+      byteLength: bytes.length,
+      sha256: createHash2("sha256").update(bytes).digest("hex")
+    }
+  };
+}
+function projectToolBinaryResult(result, name, assets) {
+  if (result.type !== "image") {
+    return void 0;
+  }
+  if ("data" in result) {
+    return projectInlineToolImage(
+      result.data,
+      result.mimeType,
+      result.description ?? name
+    );
+  }
+  if ("assetId" in result) {
+    const asset = assets.get(result.assetId);
+    if (asset === void 0 || asset.data.type !== "image") {
+      return {
+        attachment: {
+          kind: "image",
+          name: boundedText(result.description ?? name, 1024, "Copilot image"),
+          mimeType: boundedText(
+            normalizeImageMimeType(result.mimeType),
+            256,
+            "application/octet-stream"
+          )
+        },
+        failure: {
+          source: "binary-asset",
+          reason: "asset-missing",
+          mimeType: normalizeImageMimeType(result.mimeType),
+          expectedByteLength: result.byteLength
+        }
+      };
+    }
+    const projected = projectInlineToolImage(
+      asset.data.data,
+      asset.data.mimeType,
+      result.description ?? asset.data.description ?? name,
+      void 0,
+      "binary-asset"
+    );
+    const attachment = projected.attachment;
+    if (projected.failure !== void 0) {
+      return { ...projected, sourceEventId: asset.eventId, sourceTimestamp: asset.timestamp };
+    }
+    if (attachment.sha256 !== void 0 && result.assetId !== `sha256:${attachment.sha256}`) {
+      return {
+        attachment: {
+          kind: "image",
+          name: attachment.name,
+          ...attachment.mimeType === void 0 ? {} : { mimeType: attachment.mimeType }
+        },
+        sourceEventId: asset.eventId,
+        sourceTimestamp: asset.timestamp,
+        failure: {
+          source: "binary-asset",
+          reason: "asset-hash-mismatch",
+          mimeType: attachment.mimeType ?? "application/octet-stream",
+          expectedByteLength: result.byteLength,
+          ...attachment.byteLength === void 0 ? {} : { actualByteLength: attachment.byteLength }
+        }
+      };
+    }
+    return {
+      attachment,
+      sourceEventId: asset.eventId,
+      sourceTimestamp: asset.timestamp
+    };
+  }
+  return {
+    attachment: {
+      kind: "image",
+      name: boundedText(result.description ?? name, 1024, "Copilot image"),
+      mimeType: boundedText(
+        normalizeImageMimeType(result.mimeType),
+        256,
+        "application/octet-stream"
+      )
+    },
+    failure: {
+      source: "binary-result",
+      reason: "asset-missing",
+      mimeType: normalizeImageMimeType(result.mimeType),
+      expectedByteLength: result.byteLength
+    }
+  };
+}
+function projectToolContentImage(image, name) {
+  return projectInlineToolImage(
+    image.data,
+    image.mimeType,
+    name,
+    void 0,
+    "content"
+  );
+}
+function permissionName(kind) {
+  const words = kind.replaceAll("_", " ").replaceAll("-", " ");
+  return `${words.charAt(0).toUpperCase()}${words.slice(1)} permission`;
+}
+var ConversationToolLifecycles = class {
+  #starts = /* @__PURE__ */ new Map();
+  get(toolCallId) {
+    return this.#starts.get(toolCallId);
+  }
+  remember(toolCallId, start) {
+    const previous = this.#starts.get(toolCallId);
+    const lifecycle = previous?.sourceEventId === start.sourceEventId && !start.hasTurnContext ? previous : start;
+    this.#starts.delete(toolCallId);
+    this.#starts.set(toolCallId, lifecycle);
+    while (this.#starts.size > 1024) {
+      const oldest = this.#starts.keys().next().value;
+      if (oldest === void 0) break;
+      this.#starts.delete(oldest);
+    }
+    return lifecycle;
+  }
+  clear() {
+    this.#starts.clear();
+  }
+};
+var ConversationNormalizer = class {
+  constructor(onImageFailure, toolLifecycles = new ConversationToolLifecycles(), resolveInputProvenance) {
+    this.onImageFailure = onImageFailure;
+    this.toolLifecycles = toolLifecycles;
+    this.resolveInputProvenance = resolveInputProvenance;
+  }
+  onImageFailure;
+  toolLifecycles;
+  resolveInputProvenance;
+  #items = /* @__PURE__ */ new Map();
+  #binaryAssets = /* @__PURE__ */ new Map();
+  #pendingToolImages = /* @__PURE__ */ new Map();
+  #toolTurns = /* @__PURE__ */ new Map();
+  #taskCompletionToolCalls = /* @__PURE__ */ new Map();
+  #subagentTurns = /* @__PURE__ */ new Map();
+  #permissionTurns = /* @__PURE__ */ new Map();
+  #loopTurns = /* @__PURE__ */ new Map();
+  #currentTurnId;
+  #hasCurrentTurnContext = false;
+  #reportedImageFailures = /* @__PURE__ */ new Set();
+  apply(events) {
+    const changed = [];
+    for (const event of events) {
+      if (event.type === "session.binary_asset" && event.data.type === "image") {
+        this.#binaryAssets.set(event.data.assetId, {
+          eventId: event.id,
+          timestamp: event.timestamp,
+          data: event.data
+        });
+      }
+      if (event.type === "tool.execution_start" && event.data.toolName === TASK_COMPLETE_TOOL_NAME) {
+        this.#taskCompletionToolCalls.set(
+          event.data.toolCallId,
+          event.agentId !== void 0 || event.data.parentToolCallId !== void 0 || this.#taskCompletionToolCalls.get(event.data.toolCallId) === "subagent" ? "subagent" : "assistant"
+        );
+      }
+    }
+    for (const event of events) {
+      if (event.type === "session.binary_asset") {
+        const pending = this.#pendingToolImages.get(event.data.assetId);
+        if (pending !== void 0) {
+          for (const projection of pending.values()) {
+            if (this.#unresolvedToolImageAssetIds(projection.event).length === 0) {
+              this.#removePendingToolImage(projection.event);
+              changed.push(
+                ...this.#projectToolImages(
+                  projection.event,
+                  projection.turnId,
+                  projection.toolName
+                )
+              );
+            }
+          }
+        }
+        continue;
+      }
+      const inputProvenance = event.type === "user.message" && event.agentId === void 0 && event.data.isAutopilotContinuation !== true ? this.resolveInputProvenance?.(event) : void 0;
+      if (event.type === "user.message" && (inputProvenance !== void 0 || isDisplayableHumanMessage(event))) {
+        const turnId = protocolId(event.data.interactionId ?? event.id);
+        const item = {
+          id: scopedId("message", event.id),
+          revision: 1,
+          turnId,
+          timestamp: event.timestamp,
+          ...inputProvenance?.actor === "subagent" ? {
+            kind: "assistant-message",
+            actor: "subagent",
+            agentId: inputProvenance.agentId,
+            final: true,
+            sourceMessageIds: [event.id]
+          } : { kind: "human-message", actor: "human" },
+          sourceEventIds: [event.id],
+          ...event.data.interactionId === void 0 ? {} : { sourceInteractionIds: [protocolId(event.data.interactionId)] },
+          content: limitSummary(event.data.content, 1e5),
+          attachments: event.data.attachments?.slice(0, 100).map(projectAttachment).map(boundAttachment) ?? []
+        };
+        this.#currentTurnId = turnId;
+        this.#hasCurrentTurnContext = true;
+        this.#items.set(item.id, item);
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "assistant.turn_start") {
+        if (event.agentId !== void 0) {
+          this.#loopTurns.set(event.data.turnId, {
+            turnId: protocolId(
+              this.#currentTurnId ?? event.data.interactionId ?? event.data.turnId
+            ),
+            hasTurnContext: this.#currentTurnId === void 0 ? event.data.interactionId !== void 0 : this.#hasCurrentTurnContext
+          });
+          continue;
+        }
+        const turnId = protocolId(
+          event.data.interactionId ?? this.#currentTurnId ?? event.data.turnId
+        );
+        const hasTurnContext = event.data.interactionId !== void 0 || this.#hasCurrentTurnContext;
+        this.#loopTurns.set(event.data.turnId, { turnId, hasTurnContext });
+        this.#currentTurnId = turnId;
+        this.#hasCurrentTurnContext = hasTurnContext;
+        continue;
+      }
+      if (event.type === "skill.invoked") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const step = {
+          id: scopedId("skill", event.id),
+          kind: "skill",
+          name: boundedText(event.data.name, 256, "Skill"),
+          ...boundedOptionalText(event.data.description, 2048) === void 0 ? {} : {
+            description: boundedOptionalText(
+              event.data.description,
+              2048
+            )
+          },
+          status: "completed",
+          ...boundedOptionalText(event.data.source, 256) === void 0 ? {} : { source: boundedOptionalText(event.data.source, 256) }
+        };
+        const item = this.#upsertActivityStep(
+          event.id,
+          event.timestamp,
+          turnId,
+          step
+        );
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "tool.execution_start") {
+        const lifecycle = this.toolLifecycles.remember(event.data.toolCallId, {
+          sourceEventId: protocolId(event.id),
+          timestamp: event.timestamp,
+          turnId: this.#resolveTurnId(
+            event.data.turnId,
+            this.#currentTurnId ?? protocolId(event.id)
+          ),
+          hasTurnContext: event.data.turnId === void 0 ? this.#hasCurrentTurnContext : this.#loopTurns.get(event.data.turnId)?.hasTurnContext ?? false,
+          name: boundedText(event.data.toolName, 256, "Tool"),
+          actor: event.agentId !== void 0 || event.data.parentToolCallId !== void 0 ? "subagent" : "assistant"
+        });
+        const turnId = lifecycle.turnId;
+        this.#toolTurns.set(event.data.toolCallId, turnId);
+        if (event.data.toolName === TASK_COMPLETE_TOOL_NAME) {
+          continue;
+        }
+        const step = {
+          id: scopedId("tool", event.data.toolCallId),
+          kind: "tool",
+          name: lifecycle.name,
+          status: "running"
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            protocolId(event.id),
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "tool.execution_complete") {
+        const lifecycle = this.toolLifecycles.get(event.data.toolCallId);
+        const turnId = lifecycle?.turnId ?? this.#resolveTurnId(
+          event.data.turnId,
+          this.#toolTurns.get(event.data.toolCallId) ?? this.#currentTurnId ?? event.id
+        );
+        if (this.#taskCompletionToolCalls.has(event.data.toolCallId) || lifecycle?.name === TASK_COMPLETE_TOOL_NAME || event.data.toolDescription?.name === TASK_COMPLETE_TOOL_NAME) {
+          if (lifecycle !== void 0) {
+            this.#taskCompletionToolCalls.set(event.data.toolCallId, lifecycle.actor);
+          }
+          const taskCompletion = this.#projectTaskCompletion(event, turnId);
+          if (taskCompletion !== void 0) {
+            changed.push(taskCompletion);
+            continue;
+          }
+          const step2 = {
+            id: scopedId("tool", event.data.toolCallId),
+            kind: "tool",
+            name: TASK_COMPLETE_TOOL_NAME,
+            status: event.data.success ? "completed" : "failed"
+          };
+          changed.push(
+            this.#upsertActivityStep(
+              event.id,
+              event.timestamp,
+              turnId,
+              step2
+            )
+          );
+          continue;
+        }
+        const existingStep = this.#findActivityStep(
+          scopedId("tool", event.data.toolCallId)
+        );
+        const step = {
+          id: scopedId("tool", event.data.toolCallId),
+          kind: "tool",
+          name: lifecycle?.name ?? (existingStep?.kind === "tool" ? existingStep.name : boundedText(event.data.toolDescription?.name ?? "unknown-tool", 256, "Tool")),
+          status: event.data.success ? "completed" : "failed"
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step,
+            lifecycle
+          )
+        );
+        const toolName = lifecycle?.name ?? existingStep?.name ?? "Copilot tool";
+        const unresolvedAssetIds = this.#unresolvedToolImageAssetIds(event);
+        if (unresolvedAssetIds.length > 0) {
+          const projection = { event, turnId, toolName };
+          for (const assetId of unresolvedAssetIds) {
+            let projections = this.#pendingToolImages.get(assetId);
+            if (projections === void 0) {
+              projections = /* @__PURE__ */ new Map();
+              this.#pendingToolImages.set(assetId, projections);
+            }
+            projections.set(event.data.toolCallId, projection);
+          }
+        } else {
+          changed.push(
+            ...this.#projectToolImages(event, turnId, toolName)
+          );
+        }
+        continue;
+      }
+      if (event.type === "subagent.started") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const subagentId = event.agentId ?? event.data.toolCallId;
+        this.#subagentTurns.set(subagentId, turnId);
+        const step = {
+          id: scopedId("subagent", subagentId),
+          kind: "subagent",
+          name: boundedText(event.data.agentDisplayName, 256, "Subagent"),
+          status: "running",
+          description: boundedText(
+            event.data.agentDescription,
+            2048,
+            "Subagent task"
+          ),
+          ...boundedOptionalText(event.data.model, 256) === void 0 ? {} : { model: boundedOptionalText(event.data.model, 256) }
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "subagent.completed") {
+        const subagentId = event.agentId ?? event.data.toolCallId;
+        const turnId = this.#subagentTurns.get(subagentId) ?? this.#currentTurnId ?? protocolId(event.id);
+        const existingStep = this.#findActivityStep(
+          scopedId("subagent", subagentId)
+        );
+        const step = {
+          id: scopedId("subagent", subagentId),
+          kind: "subagent",
+          name: boundedText(event.data.agentDisplayName, 256, "Subagent"),
+          status: "completed",
+          ...existingStep?.kind === "subagent" && existingStep.description !== void 0 ? { description: existingStep.description } : {},
+          ...event.data.model === void 0 ? existingStep?.kind === "subagent" && existingStep.model !== void 0 ? { model: existingStep.model } : {} : {
+            model: boundedText(event.data.model, 256, "unknown-model")
+          },
+          ...event.data.durationMs === void 0 ? {} : { durationMs: event.data.durationMs }
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "subagent.failed") {
+        const subagentId = event.agentId ?? event.data.toolCallId;
+        const turnId = this.#subagentTurns.get(subagentId) ?? this.#currentTurnId ?? protocolId(event.id);
+        const existingStep = this.#findActivityStep(
+          scopedId("subagent", subagentId)
+        );
+        const step = {
+          id: scopedId("subagent", subagentId),
+          kind: "subagent",
+          name: boundedText(event.data.agentDisplayName, 256, "Subagent"),
+          status: "failed",
+          ...existingStep?.kind === "subagent" && existingStep.description !== void 0 ? { description: existingStep.description } : {},
+          ...event.data.model === void 0 ? existingStep?.kind === "subagent" && existingStep.model !== void 0 ? { model: existingStep.model } : {} : {
+            model: boundedText(event.data.model, 256, "unknown-model")
+          },
+          ...event.data.durationMs === void 0 ? {} : { durationMs: event.data.durationMs },
+          error: summarizeUnknown(event.data.error)
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "permission.requested") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const request = event.data.permissionRequest;
+        this.#permissionTurns.set(event.data.requestId, turnId);
+        const step = {
+          id: scopedId("permission", event.data.requestId),
+          kind: "permission",
+          name: permissionName(request.kind),
+          status: "running",
+          ...request.kind === "shell" ? {
+            description: boundedText(
+              request.intention,
+              2048,
+              "Shell command"
+            )
+          } : {}
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "permission.completed") {
+        const turnId = this.#permissionTurns.get(event.data.requestId) ?? this.#currentTurnId ?? protocolId(event.id);
+        const stepId = scopedId("permission", event.data.requestId);
+        const existingStep = this.#findActivityStep(stepId);
+        const result = event.data.result.kind;
+        const failed = result === "cancelled" || result.startsWith("denied");
+        const step = {
+          id: stepId,
+          kind: "permission",
+          name: existingStep?.kind === "permission" ? existingStep.name : "Permission",
+          status: failed ? "failed" : "completed",
+          ...existingStep?.kind === "permission" && existingStep.description !== void 0 ? { description: existingStep.description } : {},
+          resultSummary: result
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "user_input.requested") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        this.#permissionTurns.set(event.data.requestId, turnId);
+        const step = {
+          id: scopedId("permission", event.data.requestId),
+          kind: "permission",
+          name: "User input",
+          status: "running",
+          description: boundedText(event.data.question, 2048, "User input")
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "user_input.completed") {
+        const turnId = this.#permissionTurns.get(event.data.requestId) ?? this.#currentTurnId ?? protocolId(event.id);
+        const stepId = scopedId("permission", event.data.requestId);
+        const existingStep = this.#findActivityStep(stepId);
+        const step = {
+          id: stepId,
+          kind: "permission",
+          name: "User input",
+          status: "completed",
+          ...existingStep?.kind === "permission" && existingStep.description !== void 0 ? { description: existingStep.description } : {},
+          resultSummary: event.data.answer === void 0 ? "completed" : boundedText(event.data.answer, 4096, "completed")
+        };
+        changed.push(
+          this.#upsertActivityStep(
+            event.id,
+            event.timestamp,
+            turnId,
+            step
+          )
+        );
+        continue;
+      }
+      if (event.type === "session.warning") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const warningType = event.data.warningType.replaceAll("_", " ");
+        const warningLabel = boundedText(warningType, 240, "Session");
+        const item = {
+          id: scopedId("notice", event.id),
+          kind: "notice",
+          revision: 1,
+          turnId,
+          timestamp: event.timestamp,
+          actor: event.agentId === void 0 ? "system" : "subagent",
+          sourceEventIds: [event.id],
+          severity: "warning",
+          title: limitSummary(
+            `${warningLabel.charAt(0).toUpperCase()}${warningLabel.slice(1)} warning`,
+            256
+          ),
+          content: boundedText(event.data.message, 4096, "Session warning")
+        };
+        this.#items.set(item.id, item);
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "session.error") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const errorType = event.data.errorType.replaceAll("_", " ");
+        const errorLabel = boundedText(errorType, 240, "Session");
+        const title = `${errorLabel.charAt(0).toUpperCase()}${errorLabel.slice(1)} error`;
+        const item = {
+          id: scopedId("notice", event.id),
+          kind: "notice",
+          revision: 1,
+          turnId,
+          timestamp: event.timestamp,
+          actor: event.agentId === void 0 ? "system" : "subagent",
+          sourceEventIds: [event.id],
+          severity: "error",
+          title: limitSummary(
+            event.data.errorCode === void 0 ? title : `${title} \xB7 ${event.data.errorCode}`,
+            256
+          ),
+          content: boundedText(event.data.message, 4096, "Session error")
+        };
+        this.#items.set(item.id, item);
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "system.notification" && event.data.kind.type === "shell_completed") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const kind = event.data.kind;
+        const description = boundedText(
+          kind.description ?? `Shell ${kind.shellId}`,
+          4096,
+          "Shell completed"
+        );
+        const item = {
+          id: scopedId("notice", event.id),
+          kind: "notice",
+          revision: 1,
+          turnId,
+          timestamp: event.timestamp,
+          actor: event.agentId === void 0 ? "system" : "subagent",
+          sourceEventIds: [event.id],
+          severity: kind.exitCode === void 0 || kind.exitCode === 0 ? "success" : "error",
+          title: "Shell completed",
+          content: kind.exitCode === void 0 ? description : limitSummary(`${description} \xB7 exit ${kind.exitCode}`, 4096)
+        };
+        this.#items.set(item.id, item);
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "session.plan_changed") {
+        const turnId = this.#currentTurnId ?? protocolId(event.id);
+        const id = scopedId("plan", turnId);
+        const existing = this.#items.get(id);
+        const operation = event.data.operation === "create" ? "created" : event.data.operation === "update" ? "updated" : "deleted";
+        const item = {
+          id,
+          kind: "plan-update",
+          revision: eventRevision(
+            event.timestamp,
+            existing?.kind === "plan-update" ? existing.revision : void 0
+          ),
+          turnId,
+          timestamp: existing?.kind === "plan-update" ? existing.timestamp : event.timestamp,
+          actor: event.agentId === void 0 ? "assistant" : "subagent",
+          sourceEventIds: existing?.kind === "plan-update" ? appendSourceEventId(existing.sourceEventIds, event.id) : [event.id],
+          operation,
+          content: `Plan ${operation}`,
+          todos: []
+        };
+        this.#items.set(id, item);
+        changed.push(item);
+        continue;
+      }
+      if (event.type === "assistant.message") {
+        if (event.agentId !== void 0 || event.data.parentToolCallId !== void 0) {
+          continue;
+        }
+        if (event.data.content.trim().length === 0 && (event.data.citations?.sources.length ?? 0) === 0) {
+          continue;
+        }
+        const turnId = protocolId(
+          event.data.interactionId ?? (event.data.turnId === void 0 ? this.#currentTurnId : this.#loopTurns.get(event.data.turnId)?.turnId) ?? event.data.turnId ?? event.id
+        );
+        const id = assistantMessageId(event.data);
+        const existing = this.#items.get(id);
+        const citationAttachments = event.data.citations?.sources.slice(0, 100).map(projectCitation).map(boundAttachment) ?? [];
+        const attachments = [
+          ...existing?.kind === "assistant-message" ? existing.attachments ?? [] : [],
+          ...citationAttachments
+        ].filter(
+          (attachment, index, all) => all.findIndex(
+            (candidate) => candidate.kind === attachment.kind && candidate.name === attachment.name && candidate.uri === attachment.uri
+          ) === index
+        ).slice(-100);
+        const sourceMessageIds = appendOptionalSourceId(
+          existing?.kind === "assistant-message" ? existing.sourceMessageIds : void 0,
+          protocolId(event.data.messageId)
+        );
+        const sourceInteractionIds = appendOptionalSourceId(
+          existing?.kind === "assistant-message" ? existing.sourceInteractionIds : void 0,
+          event.data.interactionId === void 0 ? void 0 : protocolId(event.data.interactionId)
+        );
+        const item = {
+          id,
+          kind: "assistant-message",
+          revision: eventRevision(
+            event.timestamp,
+            existing?.kind === "assistant-message" ? existing.revision : void 0
+          ),
+          turnId,
+          timestamp: existing?.kind === "assistant-message" ? existing.timestamp : event.timestamp,
+          actor: "assistant",
+          sourceEventIds: existing?.kind === "assistant-message" ? appendSourceEventId(existing.sourceEventIds, event.id) : [event.id],
+          ...sourceMessageIds === void 0 ? {} : { sourceMessageIds },
+          ...sourceInteractionIds === void 0 ? {} : { sourceInteractionIds },
+          content: appendAssistantContent(
+            existing?.kind === "assistant-message" ? existing.content : "",
+            event.data.content
+          ),
+          ...attachments.length === 0 ? {} : { attachments },
+          ...event.data.model === void 0 ? existing?.kind === "assistant-message" && existing.model !== void 0 ? { model: existing.model } : {} : {
+            model: boundedText(event.data.model, 256, "unknown-model")
+          },
+          final: event.data.chunkCount === void 0 || event.data.chunkIndex === void 0 || event.data.chunkIndex + 1 >= event.data.chunkCount
+        };
+        this.#currentTurnId = turnId;
+        this.#hasCurrentTurnContext = event.data.interactionId !== void 0 || (event.data.turnId === void 0 ? this.#hasCurrentTurnContext : this.#loopTurns.get(event.data.turnId)?.hasTurnContext ?? false);
+        this.#items.set(id, item);
+        changed.push(item);
+      }
+    }
+    return changed;
+  }
+  snapshot() {
+    return [...this.#items.values()];
+  }
+  pendingImageAssetIds() {
+    return [...this.#pendingToolImages.keys()];
+  }
+  #projectTaskCompletion(event, turnId) {
+    if (!event.data.success) {
+      return void 0;
+    }
+    const content = boundedOptionalMessageContent(
+      event.data.result?.content,
+      4096
+    );
+    if (content === void 0) {
+      return void 0;
+    }
+    const id = scopedId("notice", event.data.toolCallId);
+    const existing = this.#items.get(id);
+    const item = {
+      id,
+      kind: "notice",
+      revision: eventRevision(
+        event.timestamp,
+        existing?.kind === "notice" ? existing.revision : void 0
+      ),
+      turnId,
+      timestamp: existing?.kind === "notice" ? existing.timestamp : event.timestamp,
+      actor: event.agentId !== void 0 || event.data.parentToolCallId !== void 0 || this.#taskCompletionToolCalls.get(event.data.toolCallId) === "subagent" || existing?.kind === "notice" && existing.actor === "subagent" ? "subagent" : "assistant",
+      sourceEventIds: existing?.kind === "notice" ? appendSourceEventId(existing.sourceEventIds, event.id) : [event.id],
+      severity: "success",
+      title: "Task completed",
+      content
+    };
+    this.#items.set(id, item);
+    return item;
+  }
+  #unresolvedToolImageAssetIds(event) {
+    return (event.data.result?.binaryResultsForLlm?.filter(
+      (result) => result.type === "image" && "assetId" in result
+    ).map((result) => result.assetId).filter((assetId) => !this.#binaryAssets.has(assetId)) ?? []).filter((assetId, index, all) => all.indexOf(assetId) === index);
+  }
+  #removePendingToolImage(event) {
+    for (const [assetId, projections] of this.#pendingToolImages) {
+      projections.delete(event.data.toolCallId);
+      if (projections.size === 0) {
+        this.#pendingToolImages.delete(assetId);
+      }
+    }
+  }
+  #projectToolImages(event, turnId, toolName) {
+    const binaryImages = event.data.result?.binaryResultsForLlm?.map(
+      (result, index) => projectToolBinaryResult(
+        result,
+        `${toolName} image ${index + 1}`,
+        this.#binaryAssets
+      )
+    ).filter(
+      (image) => image !== void 0
+    ) ?? [];
+    const contentImages = event.data.result?.contents?.filter(
+      (content) => content.type === "image"
+    ).map(
+      (image, index) => projectToolContentImage(
+        image,
+        `${toolName} image ${binaryImages.length + index + 1}`
+      )
+    ) ?? [];
+    const projectedImages = [...binaryImages, ...contentImages].filter(
+      (image, index, all) => all.findIndex(
+        (candidate) => [
+          candidate.attachment.mimeType,
+          candidate.attachment.sha256 ?? candidate.attachment.data ?? candidate.attachment.name
+        ].join("\0") === [
+          image.attachment.mimeType,
+          image.attachment.sha256 ?? image.attachment.data ?? image.attachment.name
+        ].join("\0")
+      ) === index
+    );
+    for (const image of projectedImages) {
+      if (image.failure === void 0) {
+        continue;
+      }
+      const fingerprint = [
+        event.data.toolCallId,
+        image.failure.source,
+        image.failure.reason,
+        image.failure.mimeType,
+        image.failure.expectedByteLength,
+        image.failure.actualByteLength
+      ].join("\0");
+      if (this.#reportedImageFailures.has(fingerprint)) {
+        continue;
+      }
+      this.#reportedImageFailures.add(fingerprint);
+      this.onImageFailure?.({
+        ...image.failure,
+        toolCallId: event.data.toolCallId,
+        toolName
+      });
+    }
+    const imageGroups = splitToolImages(projectedImages);
+    return imageGroups.map((imageGroup, groupIndex) => {
+      const multipleGroups = imageGroups.length > 1;
+      const id = scopedId(
+        "tool-image",
+        multipleGroups ? `${event.data.toolCallId}:${groupIndex + 1}` : event.data.toolCallId
+      );
+      const existing = this.#items.get(id);
+      const imageItem = {
+        id,
+        kind: "assistant-message",
+        // The same source events must produce the same revision in live and batched history reads.
+        revision: Math.max(
+          eventRevision(event.timestamp, existing?.kind === "assistant-message" ? existing.revision : void 0),
+          ...imageGroup.flatMap((image) => image.sourceTimestamp === void 0 ? [] : [eventRevision(image.sourceTimestamp)])
+        ),
+        turnId,
+        timestamp: existing?.kind === "assistant-message" ? existing.timestamp : event.timestamp,
+        actor: event.agentId !== void 0 || event.data.parentToolCallId !== void 0 || this.toolLifecycles.get(event.data.toolCallId)?.actor === "subagent" ? "subagent" : "assistant",
+        sourceEventIds: [
+          ...imageGroup.flatMap(
+            (image) => image.sourceEventId === void 0 ? [] : [image.sourceEventId]
+          ),
+          event.id
+        ].filter(
+          (sourceEventId, index, all) => all.indexOf(sourceEventId) === index
+        ),
+        content: "",
+        attachments: imageGroup.map((image) => image.attachment),
+        ...event.agentId === void 0 ? {} : { agentId: protocolId(event.agentId) },
+        final: true
+      };
+      this.#items.set(imageItem.id, imageItem);
+      return imageItem;
+    });
+  }
+  #resolveTurnId(loopTurnId, fallback) {
+    return protocolId(
+      (loopTurnId === void 0 ? void 0 : this.#loopTurns.get(loopTurnId)?.turnId) ?? loopTurnId ?? fallback
+    );
+  }
+  #findActivityStep(stepId) {
+    const activity = this.#items.get(scopedId("activity", stepId));
+    return activity?.kind === "activity-group" ? activity.steps[0] : void 0;
+  }
+  #upsertActivityStep(eventId, timestamp, turnId, step, lifecycle) {
+    const id = scopedId("activity", step.id);
+    const existing = this.#items.get(id);
+    const existingGroup = existing?.kind === "activity-group" ? existing : void 0;
+    const item = {
+      id,
+      kind: "activity-group",
+      revision: eventRevision(
+        timestamp,
+        existingGroup?.revision ?? (lifecycle === void 0 ? void 0 : Date.parse(lifecycle.timestamp))
+      ),
+      turnId,
+      timestamp: lifecycle?.timestamp ?? existingGroup?.timestamp ?? timestamp,
+      actor: "assistant",
+      sourceEventIds: existingGroup === void 0 ? lifecycle === void 0 ? [eventId] : appendSourceEventId([lifecycle.sourceEventId], eventId) : appendSourceEventId(existingGroup.sourceEventIds, eventId),
+      status: step.status,
+      steps: [{
+        ...step,
+        timestamp: lifecycle?.timestamp ?? existingGroup?.steps[0]?.timestamp ?? timestamp
+      }]
+    };
+    this.#items.set(id, item);
+    return item;
+  }
+};
+
+// src/session-runtime.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/timeline-read-flight.ts
+import { randomUUID } from "node:crypto";
+var MAX_IN_FLIGHT_KEYS = 32;
+var TimelineReadFlights = class {
+  #reads = /* @__PURE__ */ new Map();
+  get size() {
+    return this.#reads.size;
+  }
+  invalidate() {
+    this.#reads.clear();
+  }
+  invalidateContent() {
+    for (const [key, flight] of this.#reads) {
+      if (flight.state.reading) this.#reads.delete(key);
+    }
+  }
+  read(options, load, report) {
+    const key = JSON.stringify([
+      options.cursor ?? null,
+      options.pageSize,
+      options.metadataOnly,
+      options.assistantPreview === true
+    ]);
+    const existing = this.#reads.get(key);
+    if (existing !== void 0) {
+      report?.({
+        readRef: existing.readRef,
+        readStarts: 0,
+        readJoins: 1,
+        untrackedReads: 0,
+        inFlightReads: this.size
+      });
+      return existing.promise;
+    }
+    const readRef = randomUUID();
+    const state = { reading: false };
+    const pending = load(() => {
+      state.reading = true;
+    });
+    if (this.size >= MAX_IN_FLIGHT_KEYS) {
+      report?.({
+        readRef,
+        readStarts: 1,
+        readJoins: 0,
+        untrackedReads: 1,
+        inFlightReads: this.size
+      });
+      return pending;
+    }
+    const read = pending.finally(() => {
+      if (this.#reads.get(key)?.promise === read) {
+        this.#reads.delete(key);
+      }
+    });
+    this.#reads.set(key, { readRef, promise: read, state });
+    report?.({
+      readRef,
+      readStarts: 1,
+      readJoins: 0,
+      untrackedReads: 0,
+      inFlightReads: this.size
+    });
+    return read;
+  }
+};
+
+// src/session-runtime.ts
+var SessionRuntime = class {
+  workbench = {
+    identity: randomUUID2(),
+    activeMutations: 0,
+    activeQuestions: 0,
+    compacting: false
+  };
+  admitMutation() {
+    if (this.workbench.compacting) {
+      throw new Error("Session context compaction is in progress");
+    }
+    this.workbench.activeMutations += 1;
+    return () => {
+      this.workbench.activeMutations -= 1;
+    };
+  }
+  timelineReads = new TimelineReadFlights();
+  toolLifecycles = new ConversationToolLifecycles();
+  connection = {
+    generation: 0,
+    session: void 0,
+    reload: void 0,
+    sendAwareReload: false,
+    sendReady: false,
+    sendInProgressCount: 0,
+    sendCompletionWaiters: /* @__PURE__ */ new Set()
+  };
+  follower = {
+    current: void 0,
+    recoveryAttempt: 0,
+    recoveryTimer: void 0
+  };
+  live = {
+    recentEventIds: { ids: /* @__PURE__ */ new Set(), order: [] },
+    normalizer: void 0,
+    initializingEvents: void 0
+  };
+  activity = {
+    activeRootTurn: false,
+    busy: false,
+    turnEndIdleTimer: void 0
+  };
+  plan = {
+    timer: void 0,
+    generation: 0,
+    pending: void 0,
+    run: void 0,
+    snapshotRevision: 0
+  };
+  configuration = {
+    transition: void 0
+  };
+  watched = false;
+  stopFollower() {
+    if (this.follower.current !== void 0) {
+      this.follower.current.stopped = true;
+      this.follower.current = void 0;
+    }
+  }
+  clearFollowerRecovery() {
+    if (this.follower.recoveryTimer !== void 0) {
+      clearTimeout(this.follower.recoveryTimer);
+      this.follower.recoveryTimer = void 0;
+    }
+    this.follower.recoveryAttempt = 0;
+  }
+  clearTurnEndIdleTimer() {
+    if (this.activity.turnEndIdleTimer !== void 0) {
+      clearTimeout(this.activity.turnEndIdleTimer);
+      this.activity.turnEndIdleTimer = void 0;
+    }
+  }
+  clearPlanSyncScheduling() {
+    if (this.plan.timer !== void 0) {
+      clearTimeout(this.plan.timer);
+      this.plan.timer = void 0;
+    }
+    this.plan.pending = void 0;
+    this.plan.generation = 0;
+  }
+  unwatch() {
+    this.watched = false;
+    this.clearPlanSyncScheduling();
+    this.clearTurnEndIdleTimer();
+    this.activity.activeRootTurn = false;
+    this.stopFollower();
+    this.clearFollowerRecovery();
+    this.live.initializingEvents = void 0;
+  }
+  prepareReload(preserveTimelineState) {
+    this.timelineReads.invalidate();
+    this.connection.sendReady = false;
+    this.stopFollower();
+    if (!preserveTimelineState) {
+      this.live.recentEventIds.ids.clear();
+      this.live.recentEventIds.order.length = 0;
+      this.live.normalizer = void 0;
+    }
+    this.clearTurnEndIdleTimer();
+    this.live.initializingEvents = this.watched ? [] : void 0;
+  }
+  stopResources() {
+    this.timelineReads.invalidate();
+    this.stopFollower();
+    this.clearFollowerRecovery();
+    this.clearTurnEndIdleTimer();
+    this.clearPlanSyncScheduling();
+  }
+  invalidateConnection() {
+    this.connection.generation += 1;
+    this.stopResources();
+    this.prepareReload(true);
+    this.connection.session = void 0;
+    this.connection.reload = void 0;
+    this.connection.sendAwareReload = false;
+    this.activity.activeRootTurn = false;
+    this.activity.busy = false;
+  }
+  canDisposeAfterConnectionFailure() {
+    return this.connection.session === void 0 && this.connection.reload === void 0 && this.connection.sendInProgressCount === 0 && this.connection.sendCompletionWaiters.size === 0 && this.workbench.activeMutations === 0 && this.workbench.activeQuestions === 0 && !this.workbench.compacting && !this.watched && this.follower.current === void 0 && this.follower.recoveryTimer === void 0 && this.activity.turnEndIdleTimer === void 0 && this.plan.timer === void 0 && this.plan.pending === void 0 && this.plan.run === void 0 && this.timelineReads.size === 0 && this.configuration.transition === void 0;
+  }
+  dispose() {
+    this.connection.generation += 1;
+    this.stopResources();
+    this.toolLifecycles.clear();
+    for (const resolve2 of this.connection.sendCompletionWaiters) {
+      resolve2();
+    }
+    this.connection.sendCompletionWaiters.clear();
+    this.connection.session = void 0;
+    this.connection.reload = void 0;
+    this.connection.sendAwareReload = false;
+    this.connection.sendReady = false;
+    this.connection.sendInProgressCount = 0;
+    this.live.recentEventIds.ids.clear();
+    this.live.recentEventIds.order.length = 0;
+    this.live.normalizer = void 0;
+    this.live.initializingEvents = void 0;
+    this.activity.activeRootTurn = false;
+    this.activity.busy = false;
+    this.plan.pending = void 0;
+    this.plan.generation = 0;
+    this.plan.run = void 0;
+    this.plan.snapshotRevision = 0;
+    this.configuration.transition = void 0;
+    this.watched = false;
+  }
+};
+var SessionRuntimeRegistry = class {
+  #runtimes = /* @__PURE__ */ new Map();
+  getOrCreate(sessionId) {
+    const existing = this.#runtimes.get(sessionId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const runtime = new SessionRuntime();
+    this.#runtimes.set(sessionId, runtime);
+    return runtime;
+  }
+  peek(sessionId) {
+    return this.#runtimes.get(sessionId);
+  }
+  delete(sessionId) {
+    const runtime = this.#runtimes.get(sessionId);
+    if (runtime !== void 0) {
+      runtime.dispose();
+      this.#runtimes.delete(sessionId);
+    }
+  }
+  deleteIf(sessionId, runtime) {
+    if (this.#runtimes.get(sessionId) !== runtime) {
+      return false;
+    }
+    runtime.dispose();
+    this.#runtimes.delete(sessionId);
+    return true;
+  }
+  stopResources() {
+    for (const runtime of this.#runtimes.values()) {
+      runtime.stopResources();
+    }
+  }
+  invalidateConnections() {
+    const watched = [];
+    for (const [sessionId, runtime] of this.#runtimes) {
+      runtime.invalidateConnection();
+      if (runtime.watched) {
+        watched.push(sessionId);
+      }
+    }
+    return watched;
+  }
+  clear() {
+    for (const runtime of this.#runtimes.values()) {
+      runtime.dispose();
+    }
+    this.#runtimes.clear();
+  }
+};
+
+// src/adapters/copilot/timeline/live-projection.ts
+var RECENT_EVENT_ID_LIMIT = 4e3;
+var TURN_END_IDLE_FALLBACK_MS = 5e3;
+var LiveTimelineProjection = class {
+  constructor(ports) {
+    this.ports = ports;
+  }
+  ports;
+  #previews = /* @__PURE__ */ new WeakMap();
+  watch(sessionId) {
+    const runtime = this.ports.state(sessionId);
+    if (!runtime.watched) {
+      runtime.live.normalizer = void 0;
+      runtime.live.recentEventIds.ids.clear();
+      runtime.live.recentEventIds.order.length = 0;
+      this.#previews.delete(runtime.live);
+    }
+    runtime.watched = true;
+  }
+  queueLiveEvent(sessionId, event) {
+    const runtime = this.ports.state(sessionId);
+    runtime.timelineReads.invalidateContent();
+    this.updateSessionActivity(sessionId, event);
+    this.ports.observeLive(sessionId, event);
+    if (runtime.watched) this.ports.directEvent(sessionId);
+    const initializing = runtime.live.initializingEvents;
+    if (initializing !== void 0) {
+      initializing.push(event);
+      return;
+    }
+    this.forwardEvent(sessionId, event);
+  }
+  previewDelta(sessionId, event) {
+    const key = this.ports.state(sessionId).live;
+    if (event.type !== "assistant.message_delta" || event.agentId !== void 0 || event.data.parentToolCallId !== void 0) return;
+    if (event.data.deltaContent.length === 0) return;
+    let state = this.#previews.get(key);
+    if (state === void 0) {
+      state = { deltaContent: "" };
+      this.#previews.set(key, state);
+    }
+    if (state.messageId !== event.data.messageId) {
+      state.messageId = event.data.messageId;
+      state.deltaContent = "";
+      delete state.streaming;
+    }
+    state.deltaContent = (state.deltaContent + event.data.deltaContent).slice(0, 4096);
+    const canonical = state.canonical?.final === false ? state.canonical : void 0;
+    const previous = state.streaming ?? canonical;
+    const revision = Date.parse(event.timestamp) - 1;
+    if (previous !== void 0 && revision <= previous.revision) return;
+    const item = {
+      id: canonical?.id ?? assistantMessageId(event.data),
+      kind: "assistant-message",
+      actor: "assistant",
+      turnId: previous?.turnId ?? event.id,
+      revision,
+      timestamp: previous?.timestamp ?? new Date(revision).toISOString(),
+      sourceEventIds: [...previous?.sourceEventIds ?? [], event.id].slice(-1e3),
+      content: (canonical === void 0 ? state.deltaContent : `${canonical.content}
+
+${state.deltaContent}`).slice(0, 4096),
+      final: false
+    };
+    state.streaming = item;
+    this.ports.callbacks()?.onAssistantPreview?.(sessionId, item);
+  }
+  forwardEvent(sessionId, event) {
+    const runtime = this.ports.state(sessionId);
+    const recent = runtime.live.recentEventIds;
+    if (recent.ids.has(event.id)) {
+      return;
+    }
+    runtime.timelineReads.invalidateContent();
+    recent.ids.add(event.id);
+    recent.order.push(event.id);
+    while (recent.order.length > RECENT_EVENT_ID_LIMIT) {
+      const expiredId = recent.order.shift();
+      if (expiredId !== void 0) {
+        recent.ids.delete(expiredId);
+      }
+    }
+    this.previewDelta(sessionId, event);
+    if (event.type === "session.context_cleared" || event.type === "session.snapshot_rewind") {
+      runtime.live.normalizer = void 0;
+      this.#previews.delete(runtime.live);
+      runtime.toolLifecycles = new ConversationToolLifecycles();
+      this.ports.callbacks()?.onTimelineInvalidated?.(sessionId, {
+        reason: event.type === "session.context_cleared" ? "clear" : "rewind",
+        sourceEventId: event.id,
+        timestamp: event.timestamp
+      });
+      return;
+    }
+    if (event.type === "mcp.headers_refresh_required") {
+      if (!runtime.watched) return;
+      void this.ports.headers(sessionId, event.data).catch(
+        (error) => {
+          this.ports.callbacks()?.onSyncError(sessionId, error);
+        }
+      );
+      return;
+    }
+    if (event.type === "session_limits_exhausted.requested") {
+      if (!runtime.watched) return;
+      void this.ports.limits(sessionId, event.data).catch(
+        (error) => {
+          this.ports.callbacks()?.onSyncError(sessionId, error);
+        }
+      );
+      return;
+    }
+    let normalizer = runtime.live.normalizer;
+    if (normalizer === void 0) {
+      normalizer = new ConversationNormalizer((failure) => {
+        this.ports.callbacks()?.onImageProjectionFailure?.(sessionId, failure);
+      }, runtime.toolLifecycles, this.ports.inputProvenance(sessionId));
+      runtime.live.normalizer = normalizer;
+    }
+    this.emitNormalizedItems(sessionId, event, normalizer.apply([event]));
+    if (runtime.watched && event.type === "tool.execution_complete" && normalizer.pendingImageAssetIds().length > 0) {
+      this.ports.resolveImages(sessionId, normalizer);
+    }
+    if (runtime.watched && (event.type === "session.plan_changed" || event.type === "session.todos_changed")) {
+      this.ports.schedulePlan(sessionId, event);
+    }
+  }
+  emitNormalizedItems(sessionId, event, items) {
+    const runtime = this.ports.state(sessionId);
+    for (const item of items) {
+      if (item.kind === "assistant-message" && isContentfulAssistant(item)) {
+        if (event.type === "assistant.message") {
+          this.#previews.set(runtime.live, { canonical: item, deltaContent: "" });
+        }
+        if (!runtime.watched) this.ports.callbacks()?.onAssistantPreview?.(sessionId, item);
+      } else if (!runtime.watched && item.kind === "human-message" && item.actor === "human") {
+        this.ports.callbacks()?.onAssistantPreview?.(sessionId, item);
+      }
+      if (!runtime.watched) continue;
+      if (item.kind === "plan-update" && (event.type === "session.plan_changed" || event.type === "session.todos_changed")) {
+        continue;
+      }
+      this.ports.callbacks()?.onConversationItem(sessionId, item);
+    }
+  }
+  updateSessionActivity(sessionId, event) {
+    this.ports.changed();
+    if (event.agentId !== void 0) {
+      return;
+    }
+    const runtime = this.ports.state(sessionId);
+    if (event.type === "session.resume" && event.data.sessionWasActive === true) {
+      this.#clearTurnEndIdleTimer(sessionId);
+      if (!runtime.activity.busy) {
+        runtime.activity.busy = true;
+        this.ports.callbacks()?.onSessionActivity?.(
+          sessionId,
+          "working",
+          event.timestamp
+        );
+      }
+      return;
+    }
+    if (event.type === "assistant.turn_start") {
+      this.#clearTurnEndIdleTimer(sessionId);
+      runtime.activity.activeRootTurn = true;
+      if (!runtime.activity.busy) {
+        runtime.activity.busy = true;
+        this.ports.callbacks()?.onSessionActivity?.(
+          sessionId,
+          "working",
+          event.timestamp
+        );
+      }
+      return;
+    }
+    if (event.type === "assistant.turn_end") {
+      runtime.activity.activeRootTurn = false;
+      this.#scheduleTurnEndIdleFallback(sessionId, event.timestamp);
+      return;
+    }
+    if (event.type === "session.idle" || event.type === "session.error" || event.type === "session.shutdown") {
+      runtime.activity.activeRootTurn = false;
+      this.markSessionIdle(sessionId, event.timestamp);
+    }
+  }
+  #scheduleTurnEndIdleFallback(sessionId, occurredAt) {
+    this.#clearTurnEndIdleTimer(sessionId);
+    const runtime = this.ports.state(sessionId);
+    const timer = setTimeout(() => {
+      runtime.activity.turnEndIdleTimer = void 0;
+      if (!runtime.activity.activeRootTurn) {
+        this.markSessionIdle(sessionId, occurredAt);
+      }
+    }, TURN_END_IDLE_FALLBACK_MS);
+    runtime.activity.turnEndIdleTimer = timer;
+  }
+  #clearTurnEndIdleTimer(sessionId) {
+    this.ports.peek(sessionId)?.clearTurnEndIdleTimer();
+  }
+  markSessionIdle(sessionId, occurredAt) {
+    this.#clearTurnEndIdleTimer(sessionId);
+    const runtime = this.ports.state(sessionId);
+    if (runtime.activity.busy) {
+      runtime.activity.busy = false;
+      this.ports.callbacks()?.onSessionActivity?.(sessionId, "idle", occurredAt);
+    }
+  }
+};
+
+// src/git-remote-url.ts
+function sanitizeGitRemoteUrl(value) {
+  const remote = value.trim();
+  if (!remote) return void 0;
+  try {
+    const url = new URL(remote);
+    if (!["http:", "https:", "ssh:", "git:"].includes(url.protocol) || !url.hostname) {
+      return void 0;
+    }
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    if (/^[A-Za-z]:[\\/]/.test(remote)) return void 0;
+    const scp = /^(?:([^@\s]+)@)?([^:\s]+):(.+)$/.exec(remote);
+    if (!scp) return void 0;
+    const username = scp[1];
+    const host = scp[2];
+    const path = scp[3];
+    if (!host || !path) return void 0;
+    const safeUser = username === "git" ? "git@" : "";
+    return `${safeUser}${host}:${path.split(/[?#]/, 1)[0]}`;
+  }
+}
+
+// src/git-project-identity.ts
+import { execFile } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var NotGitDirectoryError = class extends Error {
+  constructor(options) {
+    super("The working directory is not a Git repository", options);
+  }
+};
+function gitEnvironment() {
+  const env = { ...process.env, LC_ALL: "C" };
+  for (const key of [
+    "GIT_DIR",
+    "GIT_COMMON_DIR",
+    "GIT_WORK_TREE",
+    "GIT_INDEX_FILE",
+    "GIT_PREFIX",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_CONFIG",
+    "GIT_CONFIG_PARAMETERS",
+    "GIT_CONFIG_COUNT"
+  ]) {
+    delete env[key];
+  }
+  return env;
+}
+async function git(args, env) {
+  const { stdout } = await execFileAsync("git", args, {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 2e3,
+    maxBuffer: 1024 * 1024,
+    env
+  });
+  return stdout;
+}
+function absoluteGitPath(value) {
+  if (!value || value.includes("\0") || !isAbsolute(value)) {
+    throw new Error("Git did not return an absolute repository path");
+  }
+  return resolve(value);
+}
+async function resolveGitProjectIdentity(workingDirectory, env = gitEnvironment()) {
+  if (!isAbsolute(workingDirectory) || workingDirectory.includes("\0")) {
+    throw new Error("Git project inspection requires an absolute working directory");
+  }
+  let output;
+  try {
+    output = await git([
+      "-C",
+      workingDirectory,
+      "rev-parse",
+      "--path-format=absolute",
+      "--show-toplevel",
+      "--git-common-dir"
+    ], env);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === 128 && "stdout" in error && error.stdout === "" && "stderr" in error && typeof error.stderr === "string" && /^fatal: not a git repository \(or any of the parent directories\): \.git\r?\n$/.test(error.stderr)) {
+      throw new NotGitDirectoryError({ cause: error });
+    }
+    throw error;
+  }
+  const roots = output.replace(/\r?\n$/, "").split(/\r?\n/);
+  if (roots.length !== 2) throw new Error("Git returned ambiguous repository paths");
+  const worktreeRoot = await realpath(absoluteGitPath(roots[0]));
+  const commonGitDirectory = await realpath(absoluteGitPath(roots[1]));
+  const worktrees = await git(["-C", workingDirectory, "worktree", "list", "--porcelain", "-z"], env);
+  if (!worktrees.endsWith("\0\0")) throw new Error("Git returned an incomplete worktree list");
+  const primary = worktrees.split("\0\0", 1)[0]?.split("\0");
+  const first = primary?.[0];
+  if (!first?.startsWith("worktree ")) throw new Error("Git did not identify its primary worktree");
+  const mainWorktreeRoot = primary?.includes("bare") ? void 0 : absoluteGitPath(first.slice("worktree ".length));
+  let origin;
+  try {
+    origin = await git([
+      "--git-dir",
+      commonGitDirectory,
+      "config",
+      "--local",
+      "--includes",
+      "--get",
+      "remote.origin.url"
+    ], env);
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === 1 && "stdout" in error && error.stdout === "" && "stderr" in error && error.stderr === "")) {
+      throw error;
+    }
+  }
+  const gitRemoteUrl = origin === void 0 ? void 0 : sanitizeGitRemoteUrl(origin);
+  return {
+    worktreeRoot,
+    commonGitDirectory,
+    localRepositoryKey: createHash3("sha256").update(commonGitDirectory).digest("base64url"),
+    ...mainWorktreeRoot === void 0 ? {} : { mainWorktreeRoot },
+    ...gitRemoteUrl === void 0 ? {} : { gitRemoteUrl }
+  };
+}
+
+// src/prompt-preparation-error.ts
+var PromptPreparationError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : "Prompt preparation failed", { cause });
+    this.name = "PromptPreparationError";
+  }
+};
+
+// 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 errors = {
+  SESSION_NOT_FOUND: "The session is unavailable",
+  SESSION_ROOT_UNAVAILABLE: "The session working directory is unavailable",
+  SESSION_ROOT_CHANGED: "The session working directory changed",
+  PROJECT_IDENTITY_BUSY: "Too many project identity requests",
+  PROJECT_IDENTITY_UNAVAILABLE: "The session project identity is unavailable"
+};
+var SessionProjectIdentityError = class extends Error {
+  constructor(code, options) {
+    super(errors[code], options);
+    this.code = code;
+  }
+  code;
+};
+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}`;
+}
+var SessionProjectIdentityReader = class {
+  constructor(metadata, inspect = resolveGitProjectIdentity) {
+    this.metadata = metadata;
+    this.inspect = inspect;
+  }
+  metadata;
+  inspect;
+  #active = 0;
+  async get(sessionId) {
+    if (this.#active >= SESSION_PROJECT_IDENTITY_CONCURRENCY) {
+      throw new SessionProjectIdentityError("PROJECT_IDENTITY_BUSY");
+    }
+    this.#active++;
+    try {
+      const metadata = await this.metadata(sessionId);
+      if (metadata === void 0) throw new SessionProjectIdentityError("SESSION_NOT_FOUND");
+      const cwd = metadata.workingDirectory;
+      if (!cwd || !isAbsolute2(cwd) || cwd.includes("\0")) {
+        throw new SessionProjectIdentityError("SESSION_ROOT_UNAVAILABLE");
+      }
+      let initialRoot;
+      try {
+        initialRoot = await rootIdentity(cwd);
+      } catch (cause) {
+        throw new SessionProjectIdentityError("SESSION_ROOT_UNAVAILABLE", { cause });
+      }
+      let project;
+      let inspectionError;
+      try {
+        const identity = await this.inspect(cwd);
+        project = SessionGitProjectSchema.parse({
+          localRepositoryKey: identity.localRepositoryKey,
+          worktreeRoot: identity.worktreeRoot,
+          ...identity.mainWorktreeRoot === void 0 ? {} : { mainWorktreeRoot: identity.mainWorktreeRoot },
+          ...identity.gitRemoteUrl === void 0 ? {} : { gitRemoteUrl: identity.gitRemoteUrl }
+        });
+      } catch (error) {
+        if (!(error instanceof NotGitDirectoryError)) {
+          inspectionError = new SessionProjectIdentityError("PROJECT_IDENTITY_UNAVAILABLE", { cause: error });
+        }
+      }
+      const latest = await this.metadata(sessionId);
+      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) {
+          throw new SessionProjectIdentityError("SESSION_ROOT_CHANGED");
+        }
+      } catch (cause) {
+        throw new SessionProjectIdentityError("SESSION_ROOT_CHANGED", { cause });
+      }
+      if (inspectionError !== void 0) throw inspectionError;
+      return project;
+    } catch (cause) {
+      if (cause instanceof SessionProjectIdentityError) throw cause;
+      throw new SessionProjectIdentityError("PROJECT_IDENTITY_UNAVAILABLE", { cause });
+    } finally {
+      this.#active--;
+    }
+  }
+};
+
+// src/session-workbench-runtime.ts
+import { createHash as createHash4 } from "node:crypto";
+import { z } from "zod";
+var WorkbenchRuntimeError = class extends SessionOperationError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "WorkbenchRuntimeError";
+  }
+};
+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"])
+  })).max(512),
+  steeringMessages: z.array(z.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 })
+]);
+function nanoAiu(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new WorkbenchRuntimeError("invalid-result", "Runtime nano-AIU value cannot be represented without precision loss");
+  }
+  return value.toString();
+}
+async function readWorkbenchMetrics(rpc) {
+  if (rpc.usage === void 0 || rpc.model === void 0 || rpc.metadata?.contextInfo === void 0) {
+    throw new WorkbenchRuntimeError("unsupported", "Runtime usage/context inspection is unavailable");
+  }
+  const [usage, model, attribution] = await Promise.all([
+    rpc.usage.getMetrics(),
+    rpc.model.getCurrent(),
+    rpc.metadata.getContextAttribution?.()
+  ]);
+  const attributed = attribution?.contextAttribution;
+  const modelId = attributed?.modelId ?? model.modelId;
+  const { contextInfo } = await rpc.metadata.contextInfo({
+    promptTokenLimit: attributed?.promptTokenLimit ?? 0,
+    outputTokenLimit: attributed === void 0 || attributed === null ? 0 : Math.max(0, attributed.limit - attributed.promptTokenLimit),
+    ...modelId === void 0 ? {} : { selectedModel: modelId }
+  });
+  return {
+    ...modelId === void 0 ? {} : { modelId },
+    totalPremiumRequestCost: usage.totalPremiumRequestCost,
+    totalUserRequests: usage.totalUserRequests,
+    ...usage.totalNanoAiu === void 0 ? {} : { totalNanoAiu: nanoAiu(usage.totalNanoAiu) },
+    tokens: Object.entries(usage.tokenDetails ?? {}).flatMap(([kind, detail]) => detail === void 0 ? [] : [{ kind, count: detail.tokenCount }]),
+    models: Object.entries(usage.modelMetrics).flatMap(([modelId2, metric]) => metric === void 0 ? [] : [{
+      modelId: modelId2,
+      inputTokens: metric.usage.inputTokens,
+      outputTokens: metric.usage.outputTokens,
+      cacheReadTokens: metric.usage.cacheReadTokens,
+      cacheWriteTokens: metric.usage.cacheWriteTokens,
+      requests: metric.requests.count,
+      premiumRequestCost: metric.requests.cost,
+      ...metric.totalNanoAiu === void 0 ? {} : { totalNanoAiu: nanoAiu(metric.totalNanoAiu) }
+    }]),
+    context: contextInfo ?? null
+  };
+}
+function projectWorkbenchInsights(result) {
+  return WorkbenchInsightsSchema.parse({
+    sampledAt: result.sampledAt,
+    generation: result.runtimeGeneration,
+    ...result.modelId === void 0 ? {} : { model: result.modelId },
+    totalUserRequests: result.totalUserRequests,
+    premiumRequestCost: result.totalPremiumRequestCost,
+    ...result.totalNanoAiu === void 0 ? {} : { nanoAiu: result.totalNanoAiu },
+    tokens: result.tokens,
+    models: result.models.map((model) => ({
+      model: model.modelId,
+      requests: model.requests,
+      premiumRequestCost: model.premiumRequestCost,
+      tokens: [
+        { kind: "input", count: model.inputTokens },
+        { kind: "output", count: model.outputTokens },
+        { kind: "cache-read", count: model.cacheReadTokens },
+        { kind: "cache-write", count: model.cacheWriteTokens }
+      ]
+    })),
+    ...result.context === null ? {} : { context: {
+      currentTokens: result.context.totalTokens,
+      tokenLimit: result.context.promptTokenLimit,
+      systemTokens: result.context.systemTokens,
+      conversationTokens: result.context.conversationTokens,
+      toolTokens: result.context.toolDefinitionsTokens
+    } },
+    canCompact: result.compactAllowed,
+    ...result.compactDisabledReason === void 0 ? {} : { compactUnavailableReason: result.compactDisabledReason }
+  });
+}
+var SessionWorkbenchRuntime = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  #activeQuestions = 0;
+  #queueMutations = /* @__PURE__ */ new Map();
+  #generation(runtime) {
+    return `${runtime.workbench.identity}:${runtime.connection.generation}`;
+  }
+  async #session(sessionId) {
+    this.dependencies.assertAvailable(sessionId);
+    const session = await this.dependencies.getSession(sessionId);
+    this.dependencies.assertAvailable(sessionId);
+    const runtime = this.dependencies.getRuntime(sessionId);
+    const generation = this.#generation(runtime);
+    return { session, runtime, generation };
+  }
+  #assertGeneration(sessionId, generation) {
+    this.dependencies.assertAvailable(sessionId);
+    if (this.#generation(this.dependencies.getRuntime(sessionId)) !== generation) {
+      throw new WorkbenchOutcomeUncertainError("Session runtime changed during the operation; do not replay mutations");
+    }
+  }
+  async ask(sessionId, question) {
+    z.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) {
+      throw new WorkbenchRuntimeError("busy", "A side question or context compaction is already in progress");
+    }
+    runtime.workbench.activeQuestions += 1;
+    this.#activeQuestions += 1;
+    try {
+      const { session, generation } = await this.#session(sessionId);
+      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(
+        await session.rpc.ui.ephemeralQuery({ question })
+      );
+      this.#assertGeneration(sessionId, generation);
+      return WorkbenchAskResultSchema.parse({ answer: result.answer });
+    } finally {
+      runtime.workbench.activeQuestions -= 1;
+      this.#activeQuestions -= 1;
+    }
+  }
+  async queueSnapshot(sessionId) {
+    const { session, generation } = await this.#session(sessionId);
+    const queue = session.rpc.queue;
+    if (queue === void 0) throw new WorkbenchRuntimeError("unsupported", "Runtime queue management is unavailable");
+    const pending = queueSchema.parse(await queue.pendingItems());
+    this.#assertGeneration(sessionId, generation);
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of pending.items) {
+      const existing = groups.get(row.id);
+      if (existing !== void 0) {
+        existing.displayTexts.push(row.displayText);
+        existing.actions = existing.actions.filter((action) => action !== "edit");
+        if (row.agentMode === "shell") existing.actions = existing.actions.filter((action) => action !== "send-now");
+      } else {
+        const actions = ["remove", "move"];
+        if (row.kind === "message" && row.agentMode !== "shell") {
+          actions.push("send-now");
+          if (this.dependencies.supportsAttachmentPreservingQueueEdits()) actions.push("edit");
+        }
+        groups.set(row.id, { id: row.id, kind: row.kind, displayTexts: [row.displayText], actions });
+      }
+    }
+    return {
+      runtimeGeneration: generation,
+      revision: createHash4("sha256").update(JSON.stringify(pending)).digest("hex"),
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      items: [...groups.values()],
+      steeringMessages: pending.steeringMessages
+    };
+  }
+  async mutatePendingQueue(sessionId, input) {
+    const previous = this.#queueMutations.get(sessionId);
+    let release = () => {
+    };
+    const current2 = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    this.#queueMutations.set(sessionId, current2);
+    await previous;
+    try {
+      const { session, runtime, generation } = await this.#session(sessionId);
+      if (input.runtimeGeneration !== generation) throw new WorkbenchRuntimeError("stale-runtime", "Queue belongs to an earlier session runtime");
+      const releaseMutation = runtime.admitMutation();
+      try {
+        const snapshot = await this.queueSnapshot(sessionId);
+        if (snapshot.revision !== input.revision) return { outcome: "stale-snapshot", snapshot };
+        const item = snapshot.items.find((entry) => entry.id === input.id);
+        if (item === void 0) return { outcome: "not-found", snapshot };
+        if (!item.actions.includes(input.action)) return { outcome: "not-editable", snapshot };
+        const queue = session.rpc.queue;
+        if (queue === void 0) throw new WorkbenchRuntimeError("unsupported", "Runtime queue management is unavailable");
+        let outcome;
+        switch (input.action) {
+          case "edit":
+            z.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);
+            outcome = (await queue.moveItem({ id: input.id, toPosition: input.toPosition })).changed ? "moved" : "unchanged";
+            break;
+          case "send-now":
+            outcome = (await queue.sendNow({ id: input.id })).steered ? "sent" : "not-steered";
+            break;
+        }
+        this.#assertGeneration(sessionId, generation);
+        return { outcome, snapshot: await this.queueSnapshot(sessionId) };
+      } finally {
+        releaseMutation();
+      }
+    } finally {
+      release();
+      if (this.#queueMutations.get(sessionId) === current2) this.#queueMutations.delete(sessionId);
+    }
+  }
+  async listCommands(sessionId) {
+    const { session, generation } = await this.#session(sessionId);
+    if (session.rpc.commands === void 0) throw new WorkbenchRuntimeError("unsupported", "Runtime command discovery is unavailable");
+    const { commands } = await session.rpc.commands.list({ includeBuiltins: true, includeSkills: true, includeClientCommands: true });
+    if (commands.length > 256) throw new WorkbenchRuntimeError("invalid-result", "Runtime command catalog exceeds the supported size");
+    const projected = commands.map((command) => {
+      const name = command.name.toLowerCase();
+      let action = command.kind === "skill" || command.kind === "builtin" && ["help", "version", "review", "diff", "skills"].includes(name) ? "invoke" : "unsupported";
+      if (["ask", "btw"].includes(name)) action = "ask";
+      if (["model", "mode", "plan", "autopilot"].includes(name)) action = "configure";
+      if (["usage", "context"].includes(name)) action = "insights";
+      if (name === "compact") action = "compact";
+      const executable = action !== "unsupported" && (action !== "compact" || this.dependencies.supportsCoordinatedCompaction());
+      return {
+        name: command.name,
+        aliases: command.aliases ?? [],
+        description: command.description,
+        kind: command.kind,
+        ...command.input === void 0 ? {} : { inputHint: command.input.hint },
+        inputRequired: command.input?.required === true,
+        allowDuringAgentExecution: command.allowDuringAgentExecution,
+        executable,
+        action,
+        ...executable ? {} : { disabledReason: action === "compact" ? "Runtime compaction coordination is unverified" : "This command has no supported workbench action" }
+      };
+    });
+    for (const name of ["ask", "btw"]) {
+      if (!projected.some((command) => command.name === name || command.aliases.includes(name))) {
+        projected.push({ name, aliases: [], description: "Ask a side question", kind: "workbench", inputHint: "Question", inputRequired: true, allowDuringAgentExecution: true, executable: true, action: "ask" });
+      }
+    }
+    this.#assertGeneration(sessionId, generation);
+    return { runtimeGeneration: generation, commands: projected };
+  }
+  async invokeRuntimeCommand(sessionId, input) {
+    const catalog = await this.listCommands(sessionId);
+    const name = input.name.replace(/^\/+/u, "").toLowerCase();
+    const command = catalog.commands.find((candidate) => candidate.name.toLowerCase() === name || candidate.aliases.some((alias) => alias.toLowerCase() === name));
+    if (command === void 0) throw new WorkbenchRuntimeError("unknown-command", "Unknown slash command; choose explicitly to send it as text");
+    if (!command.executable || command.action !== "invoke") throw new WorkbenchRuntimeError("unsupported", command.disabledReason ?? `Use the ${command.action} workbench action for this command`);
+    if (command.inputRequired && !input.input?.trim()) throw new WorkbenchRuntimeError("unsupported", "This command requires input");
+    const { session, runtime, generation } = await this.#session(sessionId);
+    if (catalog.runtimeGeneration !== generation) throw new WorkbenchRuntimeError("stale-runtime", "Command catalog belongs to an earlier runtime");
+    const invoke = session.rpc.commands?.invoke;
+    const isProcessing = session.rpc.metadata.isProcessing;
+    if (invoke === void 0 || isProcessing === void 0) throw new WorkbenchRuntimeError("unsupported", "Runtime command invocation or activity inspection is unavailable");
+    const release = runtime.admitMutation();
+    try {
+      if (!command.allowDuringAgentExecution && (runtime.activity.busy || (await isProcessing()).processing)) {
+        throw new WorkbenchRuntimeError("busy", "This command cannot run while the main task is active");
+      }
+      const result = invocationSchema.parse(await invoke({ name: command.name, ...input.input === void 0 ? {} : { input: input.input } }));
+      this.#assertGeneration(sessionId, generation);
+      return result;
+    } finally {
+      release();
+    }
+  }
+  async #compactionDisabledReason(sessionId, session, runtime) {
+    if (!this.dependencies.supportsCoordinatedCompaction()) return "Runtime compaction coordination is unverified";
+    if (runtime.workbench.activeQuestions > 0) return "A side question is still running";
+    if (runtime.workbench.activeMutations > 0 || runtime.connection.sendInProgressCount > 0 || runtime.configuration.transition !== void 0) return "A session mutation is in progress";
+    if (runtime.activity.busy || runtime.activity.activeRootTurn || this.dependencies.hasPendingInteraction(sessionId)) return "The session has active work or a pending interaction";
+    if (session.rpc.metadata.isProcessing === void 0 || session.rpc.permissions.pendingRequests === void 0 || session.rpc.queue === void 0 || session.rpc.history === void 0) return "Runtime idle-state inspection is unavailable";
+    const [activity, pending, permissions] = await Promise.all([
+      session.rpc.metadata.isProcessing(),
+      session.rpc.queue.pendingItems(),
+      session.rpc.permissions.pendingRequests()
+    ]);
+    if (activity.processing || pending.items.length > 0 || pending.steeringMessages.length > 0 || permissions.items.length > 0) return "The runtime has active work, queued items or a pending approval";
+    if (runtime.activity.busy || runtime.activity.activeRootTurn || this.dependencies.hasPendingInteraction(sessionId)) return "Session activity changed while checking whether compaction is safe";
+    return void 0;
+  }
+  async readInsights(sessionId) {
+    const { session, runtime, generation } = await this.#session(sessionId);
+    const metrics = await readWorkbenchMetrics(session.rpc);
+    const reason = runtime.workbench.compacting ? "Context compaction is in progress" : await this.#compactionDisabledReason(sessionId, session, runtime);
+    this.#assertGeneration(sessionId, generation);
+    return {
+      ...metrics,
+      runtimeGeneration: generation,
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      compactAllowed: reason === void 0,
+      ...reason === void 0 ? {} : { compactDisabledReason: reason }
+    };
+  }
+  async compactContext(sessionId) {
+    const { session, runtime, generation } = await this.#session(sessionId);
+    if (runtime.workbench.compacting) throw new WorkbenchRuntimeError("busy", "Context compaction is already in progress");
+    runtime.workbench.compacting = true;
+    try {
+      const reason = await this.#compactionDisabledReason(sessionId, session, runtime);
+      if (reason !== void 0) throw new WorkbenchRuntimeError(this.dependencies.supportsCoordinatedCompaction() ? "busy" : "unsupported", reason);
+      const history = session.rpc.history;
+      if (history === void 0) throw new WorkbenchRuntimeError("unsupported", "Runtime context compaction is unavailable");
+      this.#assertGeneration(sessionId, generation);
+      const result = await history.compact();
+      this.#assertGeneration(sessionId, generation);
+      return {
+        outcome: !result.success ? "failed" : !result.summaryContent?.trim() ? "no-summary" : result.tokensRemoved <= 0 ? "no-tokens-released" : "compacted",
+        tokensRemoved: result.tokensRemoved,
+        messagesRemoved: result.messagesRemoved,
+        insights: await this.readInsights(sessionId)
+      };
+    } finally {
+      runtime.workbench.compacting = false;
+    }
+  }
+  #queueOutput(snapshot) {
+    return WorkbenchQueueSnapshotSchema.parse({
+      generation: snapshot.runtimeGeneration,
+      revision: snapshot.revision,
+      items: snapshot.items.map((item) => ({ id: item.id, kind: item.kind, texts: item.displayTexts, actions: item.actions })),
+      steeringMessages: snapshot.steeringMessages
+    });
+  }
+  async queue(sessionId) {
+    return this.#queueOutput(await this.queueSnapshot(sessionId));
+  }
+  async mutateQueue(sessionId, input) {
+    const action = input.action === "edit" ? { action: input.action, text: input.prompt } : input.action === "move" ? { action: input.action, toPosition: input.toPosition } : { action: input.action };
+    const result = await this.mutatePendingQueue(sessionId, {
+      runtimeGeneration: input.generation,
+      revision: input.revision,
+      id: input.id,
+      ...action
+    });
+    if (["not-found", "not-steered", "stale-snapshot", "not-editable"].includes(result.outcome)) {
+      throw new SessionOperationError(`QUEUE_${result.outcome.replaceAll("-", "_").toUpperCase()}`, `Queue action was not applied: ${result.outcome}; refresh the queue`);
+    }
+    return WorkbenchQueueMutationResultSchema.parse({
+      changed: result.outcome !== "unchanged",
+      snapshot: this.#queueOutput(result.snapshot)
+    });
+  }
+  async commands(sessionId) {
+    const catalog = await this.listCommands(sessionId);
+    return catalog.commands.map((command) => WorkbenchCommandSchema.parse({
+      name: command.name,
+      description: command.description,
+      ...command.inputHint === void 0 ? {} : { argumentHint: command.inputHint },
+      kind: command.kind === "workbench" ? "client" : command.kind,
+      allowDuringExecution: command.allowDuringAgentExecution,
+      supported: command.executable,
+      ...command.disabledReason === void 0 ? {} : { reason: command.disabledReason }
+    }));
+  }
+  async invokeCommand(sessionId, name, input) {
+    const catalog = await this.listCommands(sessionId);
+    const canonical = name.replace(/^\/+/u, "").toLowerCase();
+    const command = catalog.commands.find((entry) => entry.name.toLowerCase() === canonical || entry.aliases.some((alias) => alias.toLowerCase() === canonical));
+    if (command === void 0) throw new WorkbenchRuntimeError("unknown-command", "Unknown slash command; choose explicitly to send it as text");
+    if (!command.executable) throw new WorkbenchRuntimeError("unsupported", command.disabledReason ?? "This command is unavailable");
+    if (command.action === "ask") return { kind: "text", text: (await this.ask(sessionId, input)).answer };
+    if (command.action === "insights") return { kind: "text", text: JSON.stringify(await this.insights(sessionId), null, 2) };
+    if (command.action === "compact") {
+      const result = await this.compact(sessionId);
+      return { kind: "text", text: result.success ? `Compacted ${result.tokensRemoved} tokens` : "Context compaction did not produce a smaller summary" };
+    }
+    if (command.action === "configure") {
+      if (this.dependencies.configureSession === void 0) throw new WorkbenchRuntimeError("unsupported", "Session configuration is unavailable");
+      const selected = input.trim();
+      if (command.name === "model" && selected.length > 0) {
+        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);
+        if (!parsedMode.success) throw new WorkbenchRuntimeError("unsupported", "Choose a model or mode using session configuration");
+        await this.dependencies.configureSession(sessionId, { agentMode: parsedMode.data });
+      }
+      return { kind: "completed" };
+    }
+    const { runtime } = await this.#session(sessionId);
+    const release = runtime.admitMutation();
+    try {
+      const result = await this.invokeRuntimeCommand(sessionId, { name, input });
+      switch (result.kind) {
+        case "text":
+          return WorkbenchCommandResultSchema.parse({ kind: "text", text: result.text });
+        case "completed":
+          return result.message === void 0 ? { kind: "completed" } : WorkbenchCommandResultSchema.parse({ kind: "text", text: result.message });
+        case "select-subcommand":
+          return WorkbenchCommandResultSchema.parse({
+            kind: "select-subcommand",
+            choices: result.options.map((option) => ({ name: result.command, label: option.description || option.name, input: option.name }))
+          });
+        case "agent-prompt": {
+          if (this.dependencies.sendCommandPrompt === void 0) {
+            throw new WorkbenchRuntimeError("unsupported", "Agent-prompt commands require the main prompt delivery path");
+          }
+          const sent = await this.dependencies.sendCommandPrompt(sessionId, result);
+          return WorkbenchCommandResultSchema.parse({ kind: "sent", messageId: sent.messageId });
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+  async insights(sessionId) {
+    return projectWorkbenchInsights(await this.readInsights(sessionId));
+  }
+  async compact(sessionId) {
+    const result = await this.compactContext(sessionId);
+    return WorkbenchCompactResultSchema.parse({
+      success: result.outcome === "compacted",
+      tokensRemoved: result.tokensRemoved,
+      messagesRemoved: result.messagesRemoved
+    });
+  }
+};
+
+export {
+  isClosedCopilotConnection,
+  isDisposedCopilotSession,
+  isSessionRestoreFailure,
+  sessionRestoreFailure,
+  diagnosticReference,
+  diagnosticRequest,
+  diagnosticError,
+  recordOperationFailure,
+  validateOperationResponse,
+  measureOperationPhase,
+  measureOperationStage,
+  recordOperationTimelineRead,
+  OperationDiagnostics,
+  OperationMetrics,
+  isDisplayableHumanMessage,
+  ConversationNormalizer,
+  SessionRuntime,
+  SessionRuntimeRegistry,
+  LiveTimelineProjection,
+  sanitizeGitRemoteUrl,
+  NotGitDirectoryError,
+  resolveGitProjectIdentity,
+  PromptPreparationError,
+  SESSION_PROJECT_IDENTITY_CONCURRENCY,
+  SessionProjectIdentityError,
+  SessionProjectIdentityReader,
+  readWorkbenchMetrics,
+  projectWorkbenchInsights,
+  SessionWorkbenchRuntime
+};