@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/api/background-work.js

@@ -0,0 +1,151 @@
+export const BACKGROUND_WORK_PROTOCOL_VERSION = 1;
+export const BACKGROUND_WORK_REGISTRY_KEY = "dm-subagents.background-work.v1";
+const MAX_PROVIDER_NAME_LENGTH = 128;
+const MAX_PROVIDERS = 100;
+const MAX_ITEM_ID_LENGTH = 256;
+const MAX_SESSION_ID_LENGTH = 4096;
+const MAX_WAKE_CHANNEL_LENGTH = 256;
+const MAX_ITEMS_PER_PROVIDER = 1e4;
+function registry() {
+  const key = Symbol.for(BACKGROUND_WORK_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === undefined) {
+    const created = {
+      version: BACKGROUND_WORK_PROTOCOL_VERSION,
+      providers: new Map
+    };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed background-work registry at Symbol.for("${BACKGROUND_WORK_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== BACKGROUND_WORK_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
+    throw new Error(`Unsupported background-work registry at Symbol.for("${BACKGROUND_WORK_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength)
+    throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\x00"))
+    throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Background-work provider must be an object.");
+  }
+  const provider = value;
+  const unknownFields = Object.keys(provider).filter((key) => !["name", "listActiveWork", "wakeChannels", "reconcile"].includes(key));
+  if (unknownFields.length > 0)
+    throw new Error(`Background-work provider has unknown fields: ${unknownFields.join(", ")}.`);
+  const name = validateString(provider.name, "Background-work provider name", MAX_PROVIDER_NAME_LENGTH);
+  if (typeof provider.listActiveWork !== "function") {
+    throw new Error(`Background-work provider '${name}' must expose listActiveWork().`);
+  }
+  if (provider.reconcile !== undefined && typeof provider.reconcile !== "function") {
+    throw new Error(`Background-work provider '${name}' reconcile must be a function when provided.`);
+  }
+  if (provider.wakeChannels !== undefined) {
+    if (!Array.isArray(provider.wakeChannels)) {
+      throw new Error(`Background-work provider '${name}' wakeChannels must be an array when provided.`);
+    }
+    const channels = provider.wakeChannels.map((channel, index) => validateString(channel, `Background-work provider '${name}' wakeChannels[${index}]`, MAX_WAKE_CHANNEL_LENGTH));
+    if (new Set(channels).size !== channels.length) {
+      throw new Error(`Background-work provider '${name}' wakeChannels must not contain duplicates.`);
+    }
+  }
+  return value;
+}
+function validateItem(provider, value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Background-work provider '${provider}' item ${index} must be an object.`);
+  }
+  const item = value;
+  const unknownFields = Object.keys(item).filter((key) => key !== "id" && key !== "sessionId");
+  if (unknownFields.length > 0) {
+    throw new Error(`Background-work provider '${provider}' item ${index} has unknown fields: ${unknownFields.join(", ")}.`);
+  }
+  return {
+    id: validateString(item.id, `Background-work provider '${provider}' item ${index} id`, MAX_ITEM_ID_LENGTH),
+    sessionId: validateString(item.sessionId, `Background-work provider '${provider}' item ${index} sessionId`, MAX_SESSION_ID_LENGTH)
+  };
+}
+export function registerBackgroundWorkProvider(provider) {
+  const validated = validateProvider(provider);
+  const current = registry();
+  if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
+    throw new Error(`Background-work registry supports at most ${MAX_PROVIDERS} providers.`);
+  }
+  current.providers.set(validated.name, validated);
+  return () => {
+    if (current.providers.get(validated.name) === validated)
+      current.providers.delete(validated.name);
+  };
+}
+export function listBackgroundWorkProviders() {
+  const current = registry();
+  if (current.providers.size > MAX_PROVIDERS)
+    throw new Error(`Background-work registry contains more than ${MAX_PROVIDERS} providers.`);
+  const providers = [];
+  for (const [key, value] of current.providers) {
+    const provider = validateProvider(value);
+    if (key !== provider.name)
+      throw new Error(`Background-work registry key '${key}' does not match provider name '${provider.name}'.`);
+    providers.push(provider);
+  }
+  return providers;
+}
+export function listBackgroundWorkWakeChannels() {
+  const channels = new Set;
+  for (const provider of listBackgroundWorkProviders()) {
+    for (const channel of provider.wakeChannels ?? [])
+      channels.add(channel);
+  }
+  return [...channels];
+}
+export function snapshotBackgroundWork(sessionId, nowMs = Date.now()) {
+  validateString(sessionId, "Background-work snapshot sessionId", MAX_SESSION_ID_LENGTH);
+  const providers = listBackgroundWorkProviders();
+  const items = [];
+  const identities = new Set;
+  for (const provider of providers) {
+    try {
+      provider.reconcile?.({ sessionId, nowMs });
+    } catch (error) {
+      throw new Error(`Background-work provider '${provider.name}' reconcile failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    let active;
+    try {
+      active = provider.listActiveWork({ sessionId, nowMs });
+    } catch (error) {
+      throw new Error(`Background-work provider '${provider.name}' listActiveWork failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (!Array.isArray(active)) {
+      throw new Error(`Background-work provider '${provider.name}' listActiveWork() must return an array.`);
+    }
+    if (active.length > MAX_ITEMS_PER_PROVIDER) {
+      throw new Error(`Background-work provider '${provider.name}' returned ${active.length} items; maximum is ${MAX_ITEMS_PER_PROVIDER}.`);
+    }
+    active.forEach((value, index) => {
+      const item = validateItem(provider.name, value, index);
+      const identity = `${provider.name}\x00${item.sessionId}\x00${item.id}`;
+      if (identities.has(identity)) {
+        throw new Error(`Background-work provider '${provider.name}' returned duplicate item '${item.id}' for session '${item.sessionId}'.`);
+      }
+      identities.add(identity);
+      if (item.sessionId === sessionId)
+        items.push({ provider: provider.name, ...item });
+    });
+  }
+  return {
+    providers: providers.map((provider) => provider.name),
+    items
+  };
+}

package/extensions/dm-subagents/src/api/capability-ceiling.js

@@ -0,0 +1,12 @@
+export {
+  SUBAGENT_CAPABILITY_CEILING_ENV,
+  SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
+  SUBAGENT_CAPABILITY_CEILING_VERSION,
+  decodeSubagentCapabilityCeiling,
+  encodeSubagentCapabilityCeiling,
+  intersectSubagentCapabilityCeilings,
+  parseSubagentCapabilityCeiling,
+  registerSubagentCapabilityCeiling,
+  resolveCurrentSubagentCapabilityCeiling,
+  resolveSubagentCapabilityCeiling
+} from "../runs/shared/capability-ceiling.js";

package/extensions/dm-subagents/src/api/control-channel.js

@@ -0,0 +1,3 @@
+export {
+  requestAsyncStop
+} from "../runs/background/control-channel.js";

package/extensions/dm-subagents/src/api/delegation.js

@@ -0,0 +1,5 @@
+export const SUBAGENT_DELEGATION_REQUEST_EVENT = "prompt-template:subagent:request";
+export const SUBAGENT_DELEGATION_STARTED_EVENT = "prompt-template:subagent:started";
+export const SUBAGENT_DELEGATION_UPDATE_EVENT = "prompt-template:subagent:update";
+export const SUBAGENT_DELEGATION_RESPONSE_EVENT = "prompt-template:subagent:response";
+export const SUBAGENT_DELEGATION_CANCEL_EVENT = "prompt-template:subagent:cancel";

package/extensions/dm-subagents/src/api/dm-args.js

@@ -0,0 +1,3 @@
+export {
+  resolvePiLaunchToolPlan
+} from "../runs/shared/dm-args.js";

package/extensions/dm-subagents/src/api/external-job-provider.js

@@ -0,0 +1,137 @@
+export const EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION = 1;
+export const EXTERNAL_JOB_PROVIDER_REGISTRY_KEY = "dm-subagents.external-job-providers.v1";
+const MAX_PROVIDER_NAME_LENGTH = 128;
+const MAX_PROVIDERS = 100;
+const MAX_JOB_ID_LENGTH = 256;
+const MAX_FAILURE_CODE_LENGTH = 128;
+const MAX_FAILURE_MESSAGE_LENGTH = 4096;
+const MAX_URL_LENGTH = 4096;
+
+export class ExternalJobProviderError extends Error {
+  code;
+  blockingJobId;
+  constructor(message, options) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "ExternalJobProviderError";
+    this.code = options.code;
+    this.blockingJobId = options.blockingJobId;
+  }
+}
+function registry() {
+  const key = Symbol.for(EXTERNAL_JOB_PROVIDER_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === undefined) {
+    const created = {
+      version: EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
+      providers: new Map
+    };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
+    throw new Error(`Unsupported external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength)
+    throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\x00"))
+    throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateOptionalString(value, field, maxLength) {
+  if (value === undefined)
+    return;
+  return validateString(value, field, maxLength);
+}
+function validateState(value, field) {
+  if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "stopped" || value === "blocked")
+    return value;
+  throw new Error(`${field} must be queued, running, completed, failed, stopped, or blocked.`);
+}
+function validateHandle(provider, value, field, extraFields = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${field} from external-job provider '${provider}' must be an object.`);
+  const handle = value;
+  const supported = new Set(["providerJobId", "state", "handleUrl", "conversationUrl", "failureCode", "failureMessage", "blockingJobId", ...extraFields]);
+  const unknown = Object.keys(handle).filter((key) => !supported.has(key));
+  if (unknown.length > 0)
+    throw new Error(`${field} from external-job provider '${provider}' has unknown fields: ${unknown.join(", ")}.`);
+  const handleUrl = validateOptionalString(handle.handleUrl, `${field}.handleUrl`, MAX_URL_LENGTH);
+  const conversationUrl = validateOptionalString(handle.conversationUrl, `${field}.conversationUrl`, MAX_URL_LENGTH);
+  const failureCode = validateOptionalString(handle.failureCode, `${field}.failureCode`, MAX_FAILURE_CODE_LENGTH);
+  const failureMessage = validateOptionalString(handle.failureMessage, `${field}.failureMessage`, MAX_FAILURE_MESSAGE_LENGTH);
+  const blockingJobId = validateOptionalString(handle.blockingJobId, `${field}.blockingJobId`, MAX_JOB_ID_LENGTH);
+  return {
+    providerJobId: validateString(handle.providerJobId, `${field}.providerJobId`, MAX_JOB_ID_LENGTH),
+    state: validateState(handle.state, `${field}.state`),
+    ...handleUrl ? { handleUrl } : {},
+    ...conversationUrl ? { conversationUrl } : {},
+    ...failureCode ? { failureCode } : {},
+    ...failureMessage ? { failureMessage } : {},
+    ...blockingJobId ? { blockingJobId } : {}
+  };
+}
+export function validateExternalJobHandle(provider, value, field = "External-job handle") {
+  return validateHandle(provider, value, field);
+}
+export function validateExternalJobResult(provider, value, field = "External-job result") {
+  const result = validateHandle(provider, value, field, ["output", "artifactPath"]);
+  const record = value;
+  const output = validateOptionalString(record.output, `${field}.output`, 1024 * 1024);
+  const artifactPath = validateOptionalString(record.artifactPath, `${field}.artifactPath`, MAX_URL_LENGTH);
+  return {
+    ...result,
+    ...output !== undefined ? { output } : {},
+    ...artifactPath !== undefined ? { artifactPath } : {}
+  };
+}
+function validateProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("External-job provider must be an object.");
+  const provider = value;
+  const name = validateString(provider.name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  for (const op of ["start", "status", "result", "reattach"]) {
+    if (typeof provider[op] !== "function")
+      throw new Error(`External-job provider '${name}' must expose ${op}().`);
+  }
+  return value;
+}
+export function registerExternalJobProvider(provider) {
+  const validated = validateProvider(provider);
+  const current = registry();
+  if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
+    throw new Error(`External-job provider registry supports at most ${MAX_PROVIDERS} providers.`);
+  }
+  current.providers.set(validated.name, validated);
+  return () => {
+    if (current.providers.get(validated.name) === validated)
+      current.providers.delete(validated.name);
+  };
+}
+export function listExternalJobProviders() {
+  const current = registry();
+  if (current.providers.size > MAX_PROVIDERS)
+    throw new Error(`External-job provider registry contains more than ${MAX_PROVIDERS} providers.`);
+  const providers = [];
+  for (const [key, value] of current.providers) {
+    const provider = validateProvider(value);
+    if (key !== provider.name)
+      throw new Error(`External-job provider registry key '${key}' does not match provider name '${provider.name}'.`);
+    providers.push(provider);
+  }
+  return providers;
+}
+export function getExternalJobProvider(name) {
+  const safeName = validateString(name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  return listExternalJobProviders().find((provider) => provider.name === safeName);
+}

package/extensions/dm-subagents/src/api/external-runs.js

@@ -0,0 +1,233 @@
+import { sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.js";
+export const EXTERNAL_RUN_REGISTRY_VERSION = 2;
+export const EXTERNAL_RUN_REGISTRY_KEY = "dm-subagents.external-runs.v2";
+export const EXTERNAL_RUN_LIMITS = {
+  maxCachedRuns: 100,
+  maxSnapshotRuns: 20,
+  maxIdentityLength: 160,
+  maxSessionIdLength: 4096,
+  maxTextLength: 160,
+  maxPreviewLength: 4096,
+  maxPathLength: 4096,
+  maxSerializedBytes: 32 * 1024
+};
+const trustedRecordsByRegistry = new WeakMap;
+const RUN_FIELD_NAMES = [
+  "id",
+  "sessionId",
+  "source",
+  "label",
+  "state",
+  "startedAt",
+  "updatedAt",
+  "endedAt",
+  "currentAction",
+  "preview",
+  "reportPath",
+  "transcriptPath"
+];
+const RUN_FIELDS = new Set(RUN_FIELD_NAMES);
+const UPDATE_FIELDS = new Set([...RUN_FIELDS].filter((field) => field !== "id" && field !== "sessionId" && field !== "source"));
+function registry() {
+  const key = Symbol.for(EXTERNAL_RUN_REGISTRY_KEY);
+  const target = globalThis;
+  const existing = target[key];
+  if (existing === undefined) {
+    const created = { version: EXTERNAL_RUN_REGISTRY_VERSION, runs: new Map };
+    target[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing))
+    throw new Error(`Malformed external-run registry at Symbol.for("${EXTERNAL_RUN_REGISTRY_KEY}").`);
+  const candidate = existing;
+  if (candidate.version !== EXTERNAL_RUN_REGISTRY_VERSION || !(candidate.runs instanceof Map))
+    throw new Error(`Unsupported external-run registry at Symbol.for("${EXTERNAL_RUN_REGISTRY_KEY}").`);
+  return candidate;
+}
+function trustedRecords(current) {
+  const cached = trustedRecordsByRegistry.get(current);
+  if (cached)
+    return cached;
+  const records = new Map;
+  trustedRecordsByRegistry.set(current, records);
+  return records;
+}
+function inputObject(value, field, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${field} must be an object.`);
+  const input = value;
+  const unknown = Object.keys(input).filter((key) => !allowed.has(key));
+  if (unknown.length)
+    throw new Error(`${field} has unknown fields: ${unknown.join(", ")}.`);
+  return input;
+}
+function identity(value, field, maxLength = EXTERNAL_RUN_LIMITS.maxIdentityLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value || value.includes("\x00"))
+    throw new Error(`${field} must be a non-empty trimmed string without NUL characters.`);
+  if (value.length > maxLength)
+    throw new Error(`${field} must be at most ${maxLength} characters.`);
+  const safe = sanitizeDisplayText(value);
+  if (!safe || safe !== value)
+    throw new Error(`${field} must contain only display-safe text.`);
+  return value;
+}
+function displayText(value, field, maxLength, required = false) {
+  if (value === undefined && !required)
+    return;
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${field} must be a non-empty string.`);
+  const safe = sanitizeDisplayText(value.slice(0, Math.max(maxLength * 4, maxLength)));
+  if (!safe)
+    throw new Error(`${field} must contain displayable text.`);
+  return truncateDisplayText(safe, maxLength);
+}
+function timestamp(value, field, required = false) {
+  if (value === undefined && !required)
+    return;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 8640000000000000)
+    throw new Error(`${field} must be a non-negative safe timestamp.`);
+  return value;
+}
+function state(value, field) {
+  if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "stopped")
+    return value;
+  throw new Error(`${field} is invalid.`);
+}
+function validateRun(value) {
+  const run = inputObject(value, "External run", RUN_FIELDS);
+  const updatedAt = timestamp(run.updatedAt, "External run updatedAt");
+  const endedAt = timestamp(run.endedAt, "External run endedAt");
+  const currentAction = displayText(run.currentAction, "External run currentAction", EXTERNAL_RUN_LIMITS.maxTextLength);
+  const preview = displayText(run.preview, "External run preview", EXTERNAL_RUN_LIMITS.maxPreviewLength);
+  const reportPath = displayText(run.reportPath, "External run reportPath", EXTERNAL_RUN_LIMITS.maxPathLength);
+  const transcriptPath = displayText(run.transcriptPath, "External run transcriptPath", EXTERNAL_RUN_LIMITS.maxPathLength);
+  return {
+    id: identity(run.id, "External run id"),
+    sessionId: identity(run.sessionId, "External run sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength),
+    source: displayText(run.source, "External run source", EXTERNAL_RUN_LIMITS.maxTextLength, true),
+    label: displayText(run.label, "External run label", EXTERNAL_RUN_LIMITS.maxTextLength, true),
+    state: state(run.state, "External run state"),
+    startedAt: timestamp(run.startedAt, "External run startedAt", true),
+    ...updatedAt !== undefined ? { updatedAt } : {},
+    ...endedAt !== undefined ? { endedAt } : {},
+    ...currentAction ? { currentAction } : {},
+    ...preview ? { preview } : {},
+    ...reportPath ? { reportPath } : {},
+    ...transcriptPath ? { transcriptPath } : {}
+  };
+}
+function key(sessionId, id) {
+  return `${sessionId}\x00${id}`;
+}
+function clone(run) {
+  return { ...run };
+}
+function trustedRecord(value, normalized) {
+  const candidate = value;
+  return {
+    value,
+    normalized,
+    keys: Object.keys(candidate),
+    values: RUN_FIELD_NAMES.map((field) => candidate[field])
+  };
+}
+function trustedRecordValue(value, record) {
+  if (!record || record.value !== value || !value || typeof value !== "object")
+    return;
+  try {
+    const candidate = value;
+    const keys = Object.keys(candidate);
+    if (keys.length !== record.keys.length || keys.some((key, index) => key !== record.keys[index]))
+      return;
+    for (const [index, field] of RUN_FIELD_NAMES.entries()) {
+      if (candidate[field] !== record.values[index])
+        return;
+    }
+    return record.normalized;
+  } catch {
+    return;
+  }
+}
+function rememberTrustedRecord(current, cacheKey, value, normalized) {
+  trustedRecords(current).set(cacheKey, trustedRecord(value, normalized));
+}
+function normalizeCachedRecord(current, cacheKey, value) {
+  const run = validateRun(value);
+  rememberTrustedRecord(current, cacheKey, value, run);
+  return run;
+}
+export function registerExternalRun(input) {
+  const run = validateRun(input);
+  const current = registry();
+  const runKey = key(run.sessionId, run.id);
+  if (current.runs.has(runKey))
+    throw new Error(`External run '${run.id}' is already registered for session '${run.sessionId}'.`);
+  if (current.runs.size >= EXTERNAL_RUN_LIMITS.maxCachedRuns)
+    throw new Error(`External-run registry supports at most ${EXTERNAL_RUN_LIMITS.maxCachedRuns} cached runs.`);
+  current.runs.set(runKey, run);
+  rememberTrustedRecord(current, runKey, run, run);
+  return clone(run);
+}
+export function updateExternalRun(sessionId, id, update) {
+  const safeSessionId = identity(sessionId, "External run sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength);
+  const safeId = identity(id, "External run id");
+  const patch = inputObject(update, "External run update", UPDATE_FIELDS);
+  const current = registry();
+  const runKey = key(safeSessionId, safeId);
+  const previous = current.runs.get(runKey);
+  if (!previous)
+    throw new Error(`External run '${safeId}' is not registered for session '${safeSessionId}'.`);
+  const next = validateRun({ ...previous, ...patch });
+  current.runs.set(runKey, next);
+  rememberTrustedRecord(current, runKey, next, next);
+  return clone(next);
+}
+export function unregisterExternalRun(sessionId, id) {
+  const current = registry();
+  const runKey = key(identity(sessionId, "External run sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength), identity(id, "External run id"));
+  const deleted = current.runs.delete(runKey);
+  if (deleted)
+    trustedRecords(current).delete(runKey);
+  return deleted;
+}
+function snapshotBytes(runs) {
+  return Buffer.byteLength(JSON.stringify(runs), "utf8");
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function snapshotExternalRuns(sessionId, options = {}) {
+  const safeSessionId = identity(sessionId, "External-run snapshot sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength);
+  const current = registry();
+  const trusted = trustedRecords(current);
+  const sessionPrefix = `${safeSessionId}\x00`;
+  const runs = [];
+  for (const [cacheKey, value] of current.runs.entries()) {
+    if (typeof cacheKey !== "string" || !cacheKey.startsWith(sessionPrefix))
+      continue;
+    try {
+      const run = trustedRecordValue(value, trusted.get(cacheKey)) ?? normalizeCachedRecord(current, cacheKey, value);
+      if (run.sessionId === safeSessionId)
+        runs.push(run);
+    } catch (error) {
+      const message = `Malformed cached external run '${cacheKey}': ${getErrorMessage(error)}`;
+      if (!options.ignoreMalformed)
+        throw new Error(message, { cause: error instanceof Error ? error : undefined });
+      current.runs.delete(cacheKey);
+      trusted.delete(cacheKey);
+      options.onMalformedRecord?.(message);
+    }
+  }
+  runs.sort((left, right) => {
+    const leftActive = left.state === "queued" || left.state === "running";
+    const rightActive = right.state === "queued" || right.state === "running";
+    if (leftActive !== rightActive)
+      return leftActive ? -1 : 1;
+    return (right.updatedAt ?? right.endedAt ?? right.startedAt) - (left.updatedAt ?? left.endedAt ?? left.startedAt) || left.id.localeCompare(right.id);
+  });
+  const snapshot = runs.slice(0, EXTERNAL_RUN_LIMITS.maxSnapshotRuns).map(clone);
+  while (snapshot.length > 0 && snapshotBytes(snapshot) > EXTERNAL_RUN_LIMITS.maxSerializedBytes)
+    snapshot.pop();
+  return snapshot;
+}
+export const listExternalRuns = snapshotExternalRuns;

package/extensions/dm-subagents/src/api/intercom-bridge.js

@@ -0,0 +1,3 @@
+export {
+  resolveIntercomSessionTarget
+} from "../intercom/intercom-bridge.js";