@robota-sdk/agent-sdk 3.0.0-beta.61 → 3.0.0-beta.63

package/dist/node/index.js

@@ -541,17 +541,17 @@ async function compactCommandContext(context, instructions) {
 function listCommandContextReferences(context) {
   return context.listContextReferences?.() ?? [];
 }
-async function addCommandContextReference(context, path) {
+async function addCommandContextReference(context, path3) {
   if (!context.addContextReference) {
     return {
       evicted: [],
       diagnostics: ["Command host does not support context reference additions."]
     };
   }
-  return context.addContextReference(path);
+  return context.addContextReference(path3);
 }
-function removeCommandContextReference(context, path) {
-  return context.removeContextReference?.(path) ?? {};
+function removeCommandContextReference(context, path3) {
+  return context.removeContextReference?.(path3) ?? {};
 }
 function clearCommandContextReferences(context) {
   return context.clearContextReferences?.() ?? { removed: [] };
@@ -1461,17 +1461,17 @@ var ProjectMemoryStore = class {
     return join5(memoryRoot2(this.cwd), TOPICS_DIRNAME);
   }
   loadStartupMemory() {
-    const path = this.getIndexPath();
-    if (!existsSync3(path)) {
-      return { content: "", path, lineCount: 0, truncated: false };
+    const path3 = this.getIndexPath();
+    if (!existsSync3(path3)) {
+      return { content: "", path: path3, lineCount: 0, truncated: false };
     }
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync3(path3, "utf8");
     const byBytes = truncateToUtf8Bytes(raw, MEMORY_INDEX_MAX_BYTES);
     const byteTruncated = Buffer.byteLength(raw, "utf8") > MEMORY_INDEX_MAX_BYTES;
     const byLines = limitLines(byBytes, MEMORY_INDEX_MAX_LINES);
     return {
       content: byLines.content,
-      path,
+      path: path3,
       lineCount: byLines.content.length === 0 ? 0 : byLines.content.split(/\r?\n/).length,
       truncated: byteTruncated || byLines.truncated
     };
@@ -1490,9 +1490,9 @@ var ProjectMemoryStore = class {
   }
   readTopic(topic) {
     const normalized = sanitizeTopic(topic);
-    const path = join5(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
-    if (!existsSync3(path)) return "";
-    return readFileSync3(path, "utf8").trimEnd();
+    const path3 = join5(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
+    if (!existsSync3(path3)) return "";
+    return readFileSync3(path3, "utf8").trimEnd();
   }
   append(input) {
     const topic = sanitizeTopic(input.topic);
@@ -2050,6 +2050,516 @@ function createInProcessSubagentRunner(deps) {
   };
 }
 
+// src/background-tasks/index.ts
+import { BackgroundTaskManager } from "@robota-sdk/agent-runtime";
+
+// src/background-tasks/background-job-orchestrator.ts
+import {
+  isTerminalBackgroundTaskStatus
+} from "@robota-sdk/agent-runtime";
+var DEFAULT_SUMMARY_LENGTH = 1e3;
+var BackgroundJobOrchestrator = class {
+  manager;
+  now;
+  idFactory;
+  unsubscribeManager;
+  listeners = /* @__PURE__ */ new Set();
+  groups = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options) {
+    this.manager = options.manager;
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.idFactory = options.idFactory ?? (() => this.nextGroupId());
+    this.sequence = options.initialGroups?.length ?? 0;
+    for (const group of options.initialGroups ?? []) this.restoreGroup(group);
+    this.unsubscribeManager = this.manager.subscribe((event) => this.handleTaskEvent(event));
+  }
+  createGroup(request) {
+    const now = this.now();
+    const state = {
+      id: this.idFactory(request),
+      parentSessionId: request.parentSessionId,
+      waitPolicy: request.waitPolicy,
+      taskIds: [...request.taskIds],
+      status: "running",
+      createdAt: now,
+      updatedAt: now,
+      results: [],
+      ...request.label ? { label: request.label } : {}
+    };
+    const record = this.createRecord(state);
+    this.groups.set(state.id, record);
+    this.captureExistingTerminalTasks(record);
+    this.emit({ type: "background_job_group_created", group: cloneGroup(record.state) });
+    this.evaluateCompletion(record);
+    return cloneGroup(record.state);
+  }
+  listGroups() {
+    return [...this.groups.values()].map((record) => cloneGroup(record.state));
+  }
+  getGroup(groupId) {
+    const record = this.groups.get(groupId);
+    return record ? cloneGroup(record.state) : void 0;
+  }
+  waitGroup(groupId) {
+    const record = this.groups.get(groupId);
+    if (!record) return Promise.reject(new Error(`Unknown background job group: ${groupId}`));
+    return record.completion;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  dispose() {
+    this.unsubscribeManager();
+    this.listeners.clear();
+  }
+  nextGroupId() {
+    this.sequence += 1;
+    return `group_${this.sequence}`;
+  }
+  restoreGroup(group) {
+    const record = this.createRecord(cloneGroup(group));
+    this.groups.set(group.id, record);
+    if (group.status === "completed") record.resolve(cloneGroup(group));
+  }
+  createRecord(state) {
+    let resolveGroup = () => {
+    };
+    const completion = new Promise((resolve6) => {
+      resolveGroup = resolve6;
+    });
+    return { state, completion, resolve: resolveGroup };
+  }
+  captureExistingTerminalTasks(record) {
+    for (const taskId of record.state.taskIds) {
+      const task = this.manager.get(taskId);
+      if (task && isTerminalBackgroundTaskStatus(task.status)) this.captureTask(record, task);
+    }
+  }
+  handleTaskEvent(event) {
+    const task = getTerminalTask(event);
+    if (!task) return;
+    for (const record of this.groups.values()) {
+      if (!record.state.taskIds.includes(task.id)) continue;
+      if (!this.captureTask(record, task)) continue;
+      if (record.state.status === "running") this.evaluateCompletion(record);
+      else this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
+    }
+  }
+  captureTask(record, task) {
+    if (record.state.results.some((result) => result.taskId === task.id)) return false;
+    record.state.results = [...record.state.results, createResultEnvelope(task)];
+    record.state.updatedAt = this.now();
+    return true;
+  }
+  evaluateCompletion(record) {
+    if (record.state.status === "completed") return;
+    if (!shouldComplete(record.state)) {
+      this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
+      return;
+    }
+    const now = this.now();
+    record.state.status = "completed";
+    record.state.completedAt = now;
+    record.state.updatedAt = now;
+    const completed = cloneGroup(record.state);
+    record.resolve(completed);
+    this.emit({ type: "background_job_group_completed", group: completed });
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+};
+function getTerminalTask(event) {
+  if (event.type === "background_task_completed" || event.type === "background_task_failed" || event.type === "background_task_cancelled") {
+    return event.task;
+  }
+  return void 0;
+}
+function shouldComplete(group) {
+  if (group.waitPolicy === "manual") return false;
+  if (group.waitPolicy === "wait_any") return group.results.length > 0;
+  return group.taskIds.every((taskId) => group.results.some((result) => result.taskId === taskId));
+}
+function createResultEnvelope(task) {
+  return {
+    taskId: task.id,
+    label: task.label,
+    status: task.status,
+    ...task.result?.output ? { summary: summarizeOutput(task.result.output) } : {},
+    ...task.transcriptPath || task.logPath ? { outputRef: task.transcriptPath ?? task.logPath } : {},
+    ...task.error ? { error: { ...task.error } } : {},
+    ...task.startedAt ? { startedAt: task.startedAt } : {},
+    ...task.completedAt ? { completedAt: task.completedAt } : {}
+  };
+}
+function summarizeOutput(output) {
+  const trimmed = output.trim();
+  if (trimmed.length <= DEFAULT_SUMMARY_LENGTH) return trimmed;
+  return `${trimmed.slice(0, DEFAULT_SUMMARY_LENGTH)}...`;
+}
+function summarizeBackgroundJobGroup(group) {
+  const completed = countResults(group, "completed");
+  const failed = countResults(group, "failed");
+  const cancelled = countResults(group, "cancelled");
+  return {
+    groupId: group.id,
+    status: group.status,
+    total: group.taskIds.length,
+    completed,
+    failed,
+    cancelled,
+    pending: Math.max(group.taskIds.length - group.results.length, 0),
+    lines: group.results.map((result) => formatResultLine(result))
+  };
+}
+function countResults(group, status) {
+  return group.results.filter((result) => result.status === status).length;
+}
+function formatResultLine(result) {
+  const detail = normalizeResultDetail(result);
+  const output = result.outputRef && result.summary ? ` (output: ${result.outputRef})` : "";
+  return `[${result.status}] ${result.label} ${result.taskId}: ${detail}${output}`;
+}
+function normalizeResultDetail(result) {
+  const detail = result.error?.message ?? result.summary ?? "";
+  const normalized = detail.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : "(no summary)";
+}
+function cloneGroup(group) {
+  return {
+    ...group,
+    taskIds: [...group.taskIds],
+    results: group.results.map((result) => ({
+      ...result,
+      ...result.error ? { error: { ...result.error } } : {}
+    }))
+  };
+}
+
+// src/background-tasks/execution-workspace-projection.ts
+import { isTerminalBackgroundTaskStatus as isTerminalBackgroundTaskStatus2 } from "@robota-sdk/agent-runtime";
+
+// src/background-tasks/execution-workspace-types.ts
+var MAIN_THREAD_ENTRY_PREFIX = "main";
+var BACKGROUND_TASK_ENTRY_PREFIX = "task";
+var BACKGROUND_GROUP_ENTRY_PREFIX = "group";
+var ENTRY_ID_SEPARATOR = ":";
+var EXECUTION_ORIGIN_METADATA_KEYS = {
+  kind: "executionOriginKind",
+  sessionId: "executionOriginSessionId",
+  turnId: "executionOriginTurnId",
+  commandName: "executionOriginCommandName",
+  toolCallId: "executionOriginToolCallId",
+  skillId: "executionOriginSkillId",
+  label: "executionOriginLabel"
+};
+function createMainThreadExecutionEntryId(sessionId) {
+  return [MAIN_THREAD_ENTRY_PREFIX, sessionId].join(ENTRY_ID_SEPARATOR);
+}
+function createBackgroundTaskExecutionEntryId(taskId) {
+  return [BACKGROUND_TASK_ENTRY_PREFIX, taskId].join(ENTRY_ID_SEPARATOR);
+}
+function createBackgroundGroupExecutionEntryId(groupId) {
+  return [BACKGROUND_GROUP_ENTRY_PREFIX, groupId].join(ENTRY_ID_SEPARATOR);
+}
+function parseExecutionWorkspaceEntryId(entryId) {
+  const [prefix, sourceId] = entryId.split(ENTRY_ID_SEPARATOR, 2);
+  if (!sourceId) return void 0;
+  if (prefix === MAIN_THREAD_ENTRY_PREFIX) return { kind: "main_thread", sourceId };
+  if (prefix === BACKGROUND_TASK_ENTRY_PREFIX) return { kind: "background_task", sourceId };
+  if (prefix === BACKGROUND_GROUP_ENTRY_PREFIX) return { kind: "background_group", sourceId };
+  return void 0;
+}
+function createExecutionOriginMetadata(origin) {
+  return {
+    [EXECUTION_ORIGIN_METADATA_KEYS.kind]: origin.kind,
+    [EXECUTION_ORIGIN_METADATA_KEYS.sessionId]: origin.sessionId,
+    ...origin.turnId ? { [EXECUTION_ORIGIN_METADATA_KEYS.turnId]: origin.turnId } : {},
+    ...origin.commandName ? { [EXECUTION_ORIGIN_METADATA_KEYS.commandName]: origin.commandName } : {},
+    ...origin.toolCallId ? { [EXECUTION_ORIGIN_METADATA_KEYS.toolCallId]: origin.toolCallId } : {},
+    ...origin.skillId ? { [EXECUTION_ORIGIN_METADATA_KEYS.skillId]: origin.skillId } : {},
+    ...origin.label ? { [EXECUTION_ORIGIN_METADATA_KEYS.label]: origin.label } : {}
+  };
+}
+
+// src/background-tasks/execution-workspace-projection.ts
+var PREVIEW_MAX_LENGTH = 120;
+var SUCCESS_EXIT_CODE = 0;
+function createExecutionWorkspaceSnapshot(input) {
+  const taskGroupIds = createTaskGroupIdMap(input.groups);
+  const entries = [
+    createMainThreadEntry(input.mainThread),
+    ...sortGroups(input.groups).map((group) => createBackgroundGroupEntry(group)),
+    ...sortTasks(input.tasks).map(
+      (task) => createBackgroundTaskEntry(task, taskGroupIds.get(task.id))
+    )
+  ].filter((entry) => matchesExecutionWorkspaceFilter(entry, input.filter));
+  return {
+    sessionId: input.sessionId,
+    selectedEntryId: input.selectedEntryId ?? entries.find((entry) => entry.kind === "main_thread")?.id ?? createMainThreadExecutionEntryId(input.sessionId),
+    updatedAt: entries[0]?.updatedAt ?? input.mainThread.updatedAt,
+    entries
+  };
+}
+function createMainThreadEntry(input) {
+  return {
+    id: createMainThreadExecutionEntryId(input.sessionId),
+    sourceId: input.sessionId,
+    kind: "main_thread",
+    origin: { kind: "user_prompt", sessionId: input.sessionId },
+    status: input.isExecuting ? "active" : "idle",
+    title: "Main thread",
+    subtitle: input.hasPendingPrompt ? "prompt queued" : `${input.historyLength} history entries`,
+    preview: trimPreview(input.preview),
+    unread: false,
+    attention: "none",
+    visibility: "default",
+    updatedAt: input.updatedAt,
+    controls: ["select"]
+  };
+}
+function createBackgroundTaskEntry(state, groupId) {
+  return {
+    id: createBackgroundTaskExecutionEntryId(state.id),
+    sourceId: state.id,
+    kind: "background_task",
+    parentId: state.parentTaskId ? createBackgroundTaskExecutionEntryId(state.parentTaskId) : createMainThreadExecutionEntryId(state.parentSessionId),
+    ...groupId ? { groupId: createBackgroundGroupExecutionEntryId(groupId) } : {},
+    origin: readExecutionOrigin(state.metadata, {
+      kind: "system",
+      sessionId: state.parentSessionId
+    }),
+    taskKind: state.kind,
+    status: state.status,
+    title: state.label,
+    subtitle: createTaskSubtitle(state),
+    preview: createTaskPreview(state),
+    currentAction: state.currentAction,
+    unread: state.unread,
+    attention: createTaskAttention(state),
+    visibility: createTaskVisibility(state),
+    updatedAt: state.lastActivityAt ?? state.updatedAt,
+    controls: createTaskControls(state)
+  };
+}
+function createBackgroundGroupEntry(group) {
+  const preview = trimPreview(
+    group.results.map((result) => result.summary ?? result.error?.message).join(" ")
+  );
+  return {
+    id: createBackgroundGroupExecutionEntryId(group.id),
+    sourceId: group.id,
+    kind: "background_group",
+    parentId: createMainThreadExecutionEntryId(group.parentSessionId),
+    origin: { kind: "system", sessionId: group.parentSessionId, label: group.label },
+    status: group.status,
+    title: group.label ?? group.id,
+    subtitle: `${group.results.length}/${group.taskIds.length} tasks`,
+    preview,
+    unread: false,
+    attention: createGroupAttention(group),
+    visibility: group.status === "completed" ? "collapsed" : "default",
+    updatedAt: group.updatedAt,
+    controls: group.status === "running" ? ["select", "wait"] : ["select"]
+  };
+}
+function readExecutionOrigin(metadata, fallback) {
+  const kind = toExecutionOriginKind(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.kind]);
+  const sessionId = toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.sessionId]);
+  return {
+    kind: kind ?? fallback.kind,
+    sessionId: sessionId ?? fallback.sessionId,
+    turnId: toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.turnId]) ?? fallback.turnId,
+    commandName: toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.commandName]) ?? fallback.commandName,
+    toolCallId: toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.toolCallId]) ?? fallback.toolCallId,
+    skillId: toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.skillId]) ?? fallback.skillId,
+    label: toStringValue(metadata?.[EXECUTION_ORIGIN_METADATA_KEYS.label]) ?? fallback.label
+  };
+}
+function createTaskGroupIdMap(groups) {
+  return new Map(groups.flatMap((group) => group.taskIds.map((taskId) => [taskId, group.id])));
+}
+function createTaskControls(state) {
+  const controls = ["select"];
+  if (isTerminalBackgroundTaskStatus2(state.status)) controls.push("close");
+  else controls.push("cancel");
+  if (state.logPath || state.transcriptPath) controls.push("read_log");
+  return controls;
+}
+function createTaskSubtitle(state) {
+  if (state.kind === "agent") return state.agentType ?? state.cwd;
+  return state.cwd;
+}
+function createTaskPreview(state) {
+  if (state.status === "failed") return trimPreview(state.error?.message);
+  if (state.status === "completed") return trimPreview(state.result?.output);
+  return trimPreview(state.promptPreview ?? state.commandPreview);
+}
+function createTaskAttention(state) {
+  if (state.status === "failed") return "failed";
+  if (state.status === "waiting_permission") return "permission";
+  if (state.unread) return "unread";
+  if (state.status === "completed") return "completed";
+  return "none";
+}
+function createTaskVisibility(state) {
+  if (state.status === "completed" && !state.unread && !state.error && (state.result?.exitCode ?? SUCCESS_EXIT_CODE) === SUCCESS_EXIT_CODE && !state.result?.signalCode && !state.worktreePath && !state.branchName) {
+    return "collapsed";
+  }
+  return "default";
+}
+function createGroupAttention(group) {
+  if (group.results.some((result) => result.status === "failed")) return "failed";
+  if (group.status === "completed") return "completed";
+  return "none";
+}
+function matchesExecutionWorkspaceFilter(entry, filter) {
+  if (!filter) return true;
+  if (filter.includeMainThread === false && entry.kind === "main_thread") return false;
+  if (filter.kinds && !filter.kinds.includes(entry.kind)) return false;
+  if (filter.visibility && !filter.visibility.includes(entry.visibility)) return false;
+  return true;
+}
+function sortTasks(tasks) {
+  return [...tasks].sort(
+    (left, right) => (right.lastActivityAt ?? right.updatedAt).localeCompare(left.lastActivityAt ?? left.updatedAt)
+  );
+}
+function sortGroups(groups) {
+  return [...groups].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function trimPreview(value) {
+  const normalized = value?.trim().replace(/\s+/g, " ");
+  if (!normalized) return void 0;
+  return normalized.length > PREVIEW_MAX_LENGTH ? `${normalized.slice(0, PREVIEW_MAX_LENGTH)}...` : normalized;
+}
+function toStringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function toExecutionOriginKind(value) {
+  if (value === "user_prompt" || value === "slash_command" || value === "model_command" || value === "tool_call" || value === "skill" || value === "transport" || value === "system") {
+    return value;
+  }
+  return void 0;
+}
+
+// src/background-tasks/execution-workspace-detail.ts
+var EXECUTION_DETAIL_PAGE_SIZE = 80;
+function createMainThreadDetailPage(input) {
+  const offset = normalizeOffset(input.cursor?.offset);
+  const page = input.history.slice(offset, offset + EXECUTION_DETAIL_PAGE_SIZE);
+  const records = page.map((entry) => ({
+    id: entry.id,
+    kind: entry.category === "chat" ? "message" : "progress",
+    text: formatHistoryEntry(entry),
+    timestamp: entry.timestamp.toISOString(),
+    sourceId: entry.type
+  }));
+  return {
+    entryId: input.entryId,
+    ...input.cursor ? { cursor: input.cursor } : {},
+    ...offset + page.length < input.history.length ? { nextCursor: { offset: offset + page.length } } : {},
+    records
+  };
+}
+function createLineDetailPage(input) {
+  const offset = input.cursor?.offset ?? 0;
+  const records = input.lines.map((line, index) => ({
+    id: `${input.entryId}:${offset}:${index}`,
+    kind: input.kind ?? "process_output",
+    text: line
+  }));
+  return {
+    entryId: input.entryId,
+    ...input.cursor ? { cursor: input.cursor } : {},
+    ...input.nextCursor ? { nextCursor: input.nextCursor } : {},
+    records
+  };
+}
+function normalizeOffset(offset) {
+  return typeof offset === "number" && Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 0;
+}
+function formatHistoryEntry(entry) {
+  if (typeof entry.data === "string") return entry.data;
+  return entry.type;
+}
+
+// src/background-tasks/execution-workspace-spawner.ts
+function createExecutionWorkspaceTaskSpawner(options) {
+  return {
+    spawnAgent: (request) => options.manager.spawn(createAgentRequest(options, request)),
+    spawnProcess: (request) => options.manager.spawn(createProcessRequest(options, request)),
+    createGroup: (request) => options.groupOrchestrator.createGroup({
+      parentSessionId: options.sessionId,
+      waitPolicy: request.waitPolicy,
+      taskIds: [...request.taskIds],
+      label: request.label
+    })
+  };
+}
+function createAgentRequest(options, request) {
+  return {
+    kind: "agent",
+    label: request.label,
+    mode: request.mode ?? "background",
+    parentSessionId: options.sessionId,
+    parentTaskId: request.parentTaskId,
+    depth: request.depth ?? 1,
+    cwd: request.cwd ?? options.cwd,
+    agentType: request.agentType,
+    prompt: request.prompt,
+    model: request.model,
+    isolation: request.isolation,
+    allowedTools: request.allowedTools ? [...request.allowedTools] : void 0,
+    disallowedTools: request.disallowedTools ? [...request.disallowedTools] : void 0,
+    permissionPolicy: request.permissionPolicy ?? "inherit-allowlist",
+    timeoutMs: request.timeoutMs,
+    idleTimeoutMs: request.idleTimeoutMs,
+    maxRuntimeMs: request.maxRuntimeMs,
+    outputLimitBytes: request.outputLimitBytes,
+    maxTextDeltas: request.maxTextDeltas,
+    repetitionWindow: request.repetitionWindow,
+    repetitionThreshold: request.repetitionThreshold,
+    metadata: createExecutionOriginMetadata(options.origin)
+  };
+}
+function createProcessRequest(options, request) {
+  return {
+    kind: "process",
+    label: request.label ?? request.command,
+    mode: request.mode ?? "background",
+    parentSessionId: options.sessionId,
+    parentTaskId: request.parentTaskId,
+    depth: request.depth ?? 0,
+    cwd: request.cwd ?? options.cwd,
+    command: request.command,
+    shell: request.shell,
+    env: request.env,
+    stdin: request.stdin,
+    timeoutMs: request.timeoutMs,
+    idleTimeoutMs: request.idleTimeoutMs,
+    maxRuntimeMs: request.maxRuntimeMs,
+    outputLimitBytes: request.outputLimitBytes,
+    metadata: createExecutionOriginMetadata(options.origin)
+  };
+}
+
+// src/background-tasks/index.ts
+import {
+  getBackgroundTaskTransitions,
+  isTerminalBackgroundTaskStatus as isTerminalBackgroundTaskStatus3,
+  transitionBackgroundTaskStatus,
+  appendPrefixedLogLines,
+  createBackgroundTaskLogPage,
+  createLimitedOutputCapture,
+  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE
+} from "@robota-sdk/agent-runtime";
+import { BackgroundTaskError } from "@robota-sdk/agent-runtime";
+
 // src/tools/agent-tool-batch.ts
 function stringifyAgentBatchResult(input) {
   const successfulJobs = input.jobs.filter((job) => job.success);
@@ -2244,7 +2754,12 @@ function createSpawnRequest(args, agentType, agentDef, deps, label = agentDef.na
     cwd: deps.cwd ?? process.cwd(),
     prompt: args.prompt,
     model: args.model,
-    isolation: args.isolation
+    isolation: args.isolation,
+    metadata: createExecutionOriginMetadata({
+      kind: "tool_call",
+      sessionId: deps.parentSessionId ?? "unknown-session",
+      label
+    })
   };
 }
 function stringifyUnknownAgentType(agentType) {
@@ -2311,260 +2826,58 @@ function stringifyAgentError(message, agentId) {
     }
   });
 }
-async function runManagedAgent(args, deps, manager) {
-  if (typeof args.prompt !== "string" || args.prompt.length === 0) {
-    return stringifyAgentError("prompt is required when jobs is omitted");
-  }
-  const singleArgs = { ...args, prompt: args.prompt };
-  const agentType = args.subagent_type ?? "general-purpose";
-  const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
-  if (!agentDef) {
-    return stringifyUnknownAgentType(agentType);
-  }
-  let agentId;
-  try {
-    const state = await manager.spawn(createSpawnRequest(singleArgs, agentType, agentDef, deps));
-    agentId = state.id;
-    const response = await manager.wait(state.id);
-    return stringifyAgentSuccess(response);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return stringifyAgentError(message, agentId);
-  }
-}
-function createAgentTool(deps) {
-  const manager = createSubagentManager(deps);
-  return createZodFunctionTool2(
-    "Agent",
-    AGENT_TOOL_DESCRIPTION,
-    asZodSchema2(AgentSchema),
-    async (params) => {
-      const args = params;
-      if (Array.isArray(args.jobs) && args.jobs.length > 0) {
-        return runManagedAgentBatch({
-          jobs: args.jobs,
-          deps,
-          manager,
-          resolveAgentDefinition: resolveAgentDefinition2,
-          createSpawnRequest
-        });
-      }
-      return runManagedAgent(
-        {
-          prompt: args.prompt,
-          ...args.subagent_type !== void 0 ? { subagent_type: args.subagent_type } : {},
-          ...args.model !== void 0 ? { model: args.model } : {},
-          ...args.isolation !== void 0 ? { isolation: args.isolation } : {}
-        },
-        deps,
-        manager
-      );
-    }
-  );
-}
-
-// src/background-tasks/index.ts
-import { BackgroundTaskManager } from "@robota-sdk/agent-runtime";
-
-// src/background-tasks/background-job-orchestrator.ts
-import {
-  isTerminalBackgroundTaskStatus
-} from "@robota-sdk/agent-runtime";
-var DEFAULT_SUMMARY_LENGTH = 1e3;
-var BackgroundJobOrchestrator = class {
-  manager;
-  now;
-  idFactory;
-  unsubscribeManager;
-  listeners = /* @__PURE__ */ new Set();
-  groups = /* @__PURE__ */ new Map();
-  sequence = 0;
-  constructor(options) {
-    this.manager = options.manager;
-    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-    this.idFactory = options.idFactory ?? (() => this.nextGroupId());
-    this.sequence = options.initialGroups?.length ?? 0;
-    for (const group of options.initialGroups ?? []) this.restoreGroup(group);
-    this.unsubscribeManager = this.manager.subscribe((event) => this.handleTaskEvent(event));
-  }
-  createGroup(request) {
-    const now = this.now();
-    const state = {
-      id: this.idFactory(request),
-      parentSessionId: request.parentSessionId,
-      waitPolicy: request.waitPolicy,
-      taskIds: [...request.taskIds],
-      status: "running",
-      createdAt: now,
-      updatedAt: now,
-      results: [],
-      ...request.label ? { label: request.label } : {}
-    };
-    const record = this.createRecord(state);
-    this.groups.set(state.id, record);
-    this.captureExistingTerminalTasks(record);
-    this.emit({ type: "background_job_group_created", group: cloneGroup(record.state) });
-    this.evaluateCompletion(record);
-    return cloneGroup(record.state);
-  }
-  listGroups() {
-    return [...this.groups.values()].map((record) => cloneGroup(record.state));
-  }
-  getGroup(groupId) {
-    const record = this.groups.get(groupId);
-    return record ? cloneGroup(record.state) : void 0;
-  }
-  waitGroup(groupId) {
-    const record = this.groups.get(groupId);
-    if (!record) return Promise.reject(new Error(`Unknown background job group: ${groupId}`));
-    return record.completion;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  dispose() {
-    this.unsubscribeManager();
-    this.listeners.clear();
-  }
-  nextGroupId() {
-    this.sequence += 1;
-    return `group_${this.sequence}`;
-  }
-  restoreGroup(group) {
-    const record = this.createRecord(cloneGroup(group));
-    this.groups.set(group.id, record);
-    if (group.status === "completed") record.resolve(cloneGroup(group));
-  }
-  createRecord(state) {
-    let resolveGroup = () => {
-    };
-    const completion = new Promise((resolve6) => {
-      resolveGroup = resolve6;
-    });
-    return { state, completion, resolve: resolveGroup };
-  }
-  captureExistingTerminalTasks(record) {
-    for (const taskId of record.state.taskIds) {
-      const task = this.manager.get(taskId);
-      if (task && isTerminalBackgroundTaskStatus(task.status)) this.captureTask(record, task);
-    }
-  }
-  handleTaskEvent(event) {
-    const task = getTerminalTask(event);
-    if (!task) return;
-    for (const record of this.groups.values()) {
-      if (!record.state.taskIds.includes(task.id)) continue;
-      if (!this.captureTask(record, task)) continue;
-      if (record.state.status === "running") this.evaluateCompletion(record);
-      else this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
-    }
-  }
-  captureTask(record, task) {
-    if (record.state.results.some((result) => result.taskId === task.id)) return false;
-    record.state.results = [...record.state.results, createResultEnvelope(task)];
-    record.state.updatedAt = this.now();
-    return true;
-  }
-  evaluateCompletion(record) {
-    if (record.state.status === "completed") return;
-    if (!shouldComplete(record.state)) {
-      this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
-      return;
-    }
-    const now = this.now();
-    record.state.status = "completed";
-    record.state.completedAt = now;
-    record.state.updatedAt = now;
-    const completed = cloneGroup(record.state);
-    record.resolve(completed);
-    this.emit({ type: "background_job_group_completed", group: completed });
-  }
-  emit(event) {
-    for (const listener of this.listeners) listener(event);
-  }
-};
-function getTerminalTask(event) {
-  if (event.type === "background_task_completed" || event.type === "background_task_failed" || event.type === "background_task_cancelled") {
-    return event.task;
-  }
-  return void 0;
-}
-function shouldComplete(group) {
-  if (group.waitPolicy === "manual") return false;
-  if (group.waitPolicy === "wait_any") return group.results.length > 0;
-  return group.taskIds.every((taskId) => group.results.some((result) => result.taskId === taskId));
-}
-function createResultEnvelope(task) {
-  return {
-    taskId: task.id,
-    label: task.label,
-    status: task.status,
-    ...task.result?.output ? { summary: summarizeOutput(task.result.output) } : {},
-    ...task.transcriptPath || task.logPath ? { outputRef: task.transcriptPath ?? task.logPath } : {},
-    ...task.error ? { error: { ...task.error } } : {},
-    ...task.startedAt ? { startedAt: task.startedAt } : {},
-    ...task.completedAt ? { completedAt: task.completedAt } : {}
-  };
-}
-function summarizeOutput(output) {
-  const trimmed = output.trim();
-  if (trimmed.length <= DEFAULT_SUMMARY_LENGTH) return trimmed;
-  return `${trimmed.slice(0, DEFAULT_SUMMARY_LENGTH)}...`;
-}
-function summarizeBackgroundJobGroup(group) {
-  const completed = countResults(group, "completed");
-  const failed = countResults(group, "failed");
-  const cancelled = countResults(group, "cancelled");
-  return {
-    groupId: group.id,
-    status: group.status,
-    total: group.taskIds.length,
-    completed,
-    failed,
-    cancelled,
-    pending: Math.max(group.taskIds.length - group.results.length, 0),
-    lines: group.results.map((result) => formatResultLine(result))
-  };
-}
-function countResults(group, status) {
-  return group.results.filter((result) => result.status === status).length;
-}
-function formatResultLine(result) {
-  const detail = normalizeResultDetail(result);
-  const output = result.outputRef && result.summary ? ` (output: ${result.outputRef})` : "";
-  return `[${result.status}] ${result.label} ${result.taskId}: ${detail}${output}`;
-}
-function normalizeResultDetail(result) {
-  const detail = result.error?.message ?? result.summary ?? "";
-  const normalized = detail.replace(/\s+/g, " ").trim();
-  return normalized.length > 0 ? normalized : "(no summary)";
+async function runManagedAgent(args, deps, manager) {
+  if (typeof args.prompt !== "string" || args.prompt.length === 0) {
+    return stringifyAgentError("prompt is required when jobs is omitted");
+  }
+  const singleArgs = { ...args, prompt: args.prompt };
+  const agentType = args.subagent_type ?? "general-purpose";
+  const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
+  if (!agentDef) {
+    return stringifyUnknownAgentType(agentType);
+  }
+  let agentId;
+  try {
+    const state = await manager.spawn(createSpawnRequest(singleArgs, agentType, agentDef, deps));
+    agentId = state.id;
+    const response = await manager.wait(state.id);
+    return stringifyAgentSuccess(response);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return stringifyAgentError(message, agentId);
+  }
 }
-function cloneGroup(group) {
-  return {
-    ...group,
-    taskIds: [...group.taskIds],
-    results: group.results.map((result) => ({
-      ...result,
-      ...result.error ? { error: { ...result.error } } : {}
-    }))
-  };
+function createAgentTool(deps) {
+  const manager = createSubagentManager(deps);
+  return createZodFunctionTool2(
+    "Agent",
+    AGENT_TOOL_DESCRIPTION,
+    asZodSchema2(AgentSchema),
+    async (params) => {
+      const args = params;
+      if (Array.isArray(args.jobs) && args.jobs.length > 0) {
+        return runManagedAgentBatch({
+          jobs: args.jobs,
+          deps,
+          manager,
+          resolveAgentDefinition: resolveAgentDefinition2,
+          createSpawnRequest
+        });
+      }
+      return runManagedAgent(
+        {
+          prompt: args.prompt,
+          ...args.subagent_type !== void 0 ? { subagent_type: args.subagent_type } : {},
+          ...args.model !== void 0 ? { model: args.model } : {},
+          ...args.isolation !== void 0 ? { isolation: args.isolation } : {}
+        },
+        deps,
+        manager
+      );
+    }
+  );
 }
 
-// src/background-tasks/index.ts
-import {
-  getBackgroundTaskTransitions,
-  isTerminalBackgroundTaskStatus as isTerminalBackgroundTaskStatus2,
-  transitionBackgroundTaskStatus,
-  appendPrefixedLogLines,
-  createBackgroundTaskLogPage,
-  createLimitedOutputCapture,
-  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE
-} from "@robota-sdk/agent-runtime";
-import { BackgroundTaskError } from "@robota-sdk/agent-runtime";
-
 // src/background-tasks/session-background-store.ts
 var sessionBackgroundTaskManagers = /* @__PURE__ */ new WeakMap();
 function storeSessionBackgroundTaskManager(key, manager) {
@@ -3424,6 +3737,10 @@ var MarketplaceSourceSchema = z3.object({
 });
 var ExtraKnownMarketplacesSchema = z3.record(MarketplaceSourceSchema).optional().catch(void 0);
 var AutoCompactThresholdSchema = z3.union([z3.number().gt(0).lte(1), z3.literal(false)]).optional();
+var TransportSettingsSchema = z3.object({
+  enabled: z3.boolean().optional(),
+  options: z3.record(UniversalValueSchema).optional()
+});
 var SettingsSchema = z3.object({
   /** Trust level used when no --permission-mode flag is given */
   defaultTrustLevel: z3.enum(["safe", "moderate", "full"]).optional(),
@@ -3443,7 +3760,9 @@ var SettingsSchema = z3.object({
   /** Extra marketplace URLs for BundlePlugin discovery */
   extraKnownMarketplaces: ExtraKnownMarketplacesSchema,
   /** Auto-compact threshold as a 0-1 fraction. Set false to disable automatic compaction. */
-  autoCompactThreshold: AutoCompactThresholdSchema
+  autoCompactThreshold: AutoCompactThresholdSchema,
+  /** Transport enable/disable + options: transport name -> config */
+  transports: z3.record(TransportSettingsSchema).optional()
 });
 
 // src/config/config-loader.ts
@@ -3546,7 +3865,12 @@ function resolveProvider(merged) {
   if (merged.currentProvider !== void 0) {
     return resolveActiveProviderProfile2(merged);
   }
-  return resolveLegacyProvider(merged);
+  if (merged.provider !== void 0) {
+    throw new Error(
+      'Legacy flat "provider" settings are not supported. Migrate to "currentProvider" + "providers" format.'
+    );
+  }
+  return { ...DEFAULTS.provider };
 }
 function resolveActiveProviderProfile2(merged) {
   const currentProvider = merged.currentProvider;
@@ -3569,16 +3893,6 @@ function resolveActiveProviderProfile2(merged) {
     ...profile.options !== void 0 && { options: profile.options }
   };
 }
-function resolveLegacyProvider(merged) {
-  return {
-    name: merged.provider?.name ?? DEFAULTS.provider.name,
-    model: merged.provider?.model ?? DEFAULTS.provider.model,
-    apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey,
-    ...merged.provider?.baseURL !== void 0 && { baseURL: merged.provider.baseURL },
-    ...merged.provider?.timeout !== void 0 && { timeout: merged.provider.timeout },
-    ...merged.provider?.options !== void 0 && { options: merged.provider.options }
-  };
-}
 function toResolvedConfig(merged) {
   return {
     defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
@@ -3622,10 +3936,10 @@ async function loadConfig(cwd) {
       rawEntries.push({ raw, path: filePath });
     }
   }
-  const parsedLayers = rawEntries.map(({ raw, path }) => {
+  const parsedLayers = rawEntries.map(({ raw, path: path3 }) => {
     const result = SettingsSchema.safeParse(raw);
     if (!result.success) {
-      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
+      throw new Error(`Invalid settings in ${path3}: ${result.error.message}`);
     }
     return resolveEnvRefs(result.data);
   });
@@ -3998,7 +4312,8 @@ async function startBackgroundProcess(args, deps) {
       command: args.command,
       stdin: args.stdin,
       timeoutMs: args.timeout ?? DEFAULT_PROCESS_TIMEOUT_MS,
-      outputLimitBytes: args.outputLimitBytes
+      outputLimitBytes: args.outputLimitBytes,
+      metadata: deps.metadata
     });
     return stringifyStarted(state.id, state.status, args.command);
   } catch (error) {
@@ -4541,7 +4856,12 @@ function createSession(options) {
     backgroundProcessToolDeps = {
       backgroundTaskManager,
       cwd,
-      parentSessionId: sessionId
+      parentSessionId: sessionId,
+      metadata: createExecutionOriginMetadata({
+        kind: "tool_call",
+        sessionId,
+        label: "BackgroundProcess"
+      })
     };
     tools.push(createBackgroundProcessTool(backgroundProcessToolDeps));
   }
@@ -4817,7 +5137,7 @@ function formatTaskContext(tasks) {
 }
 function loadTaskContext(cwd, options = {}) {
   const currentBranch = options.currentBranch ?? readCurrentGitBranch(cwd);
-  const tasks = discoverTaskFiles(cwd).map((path) => parseTaskFile(path, cwd));
+  const tasks = discoverTaskFiles(cwd).map((path3) => parseTaskFile(path3, cwd));
   return formatTaskContext(selectRelevantTasks(tasks, { ...options, currentBranch }));
 }
 function updateTaskFileStatus(taskPath, status, options = {}) {
@@ -5164,15 +5484,11 @@ var BundlePluginLoader = class {
     }
     return results;
   }
-  /** Read and validate a plugin.json manifest. Returns null on failure. */
-  readManifest(path) {
-    try {
-      const raw = readFileSync11(path, "utf-8");
-      const data = JSON.parse(raw);
-      return validateManifest(data);
-    } catch {
-      return null;
-    }
+  /** Read and validate a plugin.json manifest. Returns null if the manifest structure is invalid. */
+  readManifest(path3) {
+    const raw = readFileSync11(path3, "utf-8");
+    const data = JSON.parse(raw);
+    return validateManifest(data);
   }
   /**
    * Check if a plugin is explicitly disabled.
@@ -5248,40 +5564,26 @@ var BundlePluginLoader = class {
   loadHooks(pluginDir) {
     const hooksPath = join12(pluginDir, "hooks", "hooks.json");
     if (!existsSync11(hooksPath)) return {};
-    try {
-      const raw = readFileSync11(hooksPath, "utf-8");
-      const data = JSON.parse(raw);
-      if (typeof data === "object" && data !== null) {
-        return data;
-      }
-      return {};
-    } catch {
-      return {};
+    const raw = readFileSync11(hooksPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data === "object" && data !== null) {
+      return data;
     }
+    return {};
   }
-  /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+  /** Load MCP server configuration from `.mcp.json` at the plugin root if present. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = join12(pluginDir, ".mcp.json");
-    const fallbackPath = join12(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = existsSync11(primaryPath) ? primaryPath : fallbackPath;
+    const mcpPath = join12(pluginDir, ".mcp.json");
     if (!existsSync11(mcpPath)) return void 0;
-    try {
-      const raw = readFileSync11(mcpPath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
+    const raw = readFileSync11(mcpPath, "utf-8");
+    return JSON.parse(raw);
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
     const agentsDir = join12(pluginDir, "agents");
     if (!existsSync11(agentsDir)) return [];
-    try {
-      const entries = readdirSync6(agentsDir, { withFileTypes: true });
-      return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
-    } catch {
-      return [];
-    }
+    const entries = readdirSync6(agentsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
   }
 };
 
@@ -5725,8 +6027,8 @@ var MarketplaceClient = class {
     }
   }
   /** Read and parse a marketplace.json from a file path. */
-  readManifestFromPath(path) {
-    const raw = readFileSync14(path, "utf-8");
+  readManifestFromPath(path3) {
+    const raw = readFileSync14(path3, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -5818,18 +6120,18 @@ async function createInteractiveSession(options) {
     options.bare ? Promise.resolve({ agentsMd: "", claudeMd: "" }) : loadContext(cwd),
     options.bare ? Promise.resolve({ type: "unknown", language: "unknown" }) : detectProject(cwd)
   ]);
+  let mergedConfig = options.language ? { ...config, language: options.language } : config;
   const pluginsDir = join17(homedir5(), ".robota", "plugins");
   const pluginLoader = new BundlePluginLoader(pluginsDir);
-  let mergedConfig = config;
   if (!options.bare) {
     try {
       const plugins = pluginLoader.loadPluginsSync();
       if (plugins.length > 0) {
         const pluginHooks = mergePluginHooks(plugins);
         mergedConfig = {
-          ...config,
+          ...mergedConfig,
           hooks: mergeHooksIntoConfig(
-            config.hooks,
+            mergedConfig.hooks,
             pluginHooks
           )
         };
@@ -5997,8 +6299,8 @@ function isRestoredTerminalStatus(status) {
 }
 
 // src/interactive/interactive-session-context-references.ts
-async function addInteractiveContextReference(references, path, cwd) {
-  const result = await resolvePromptFileReferencePaths([path], {
+async function addInteractiveContextReference(references, path3, cwd) {
+  const result = await resolvePromptFileReferencePaths([path3], {
     cwd,
     reason: "manual"
   });
@@ -6091,9 +6393,9 @@ function toInspectionPlan(manifests) {
     fileCount: manifests.reduce((count, manifest) => count + manifest.fileCount, 0)
   };
 }
-function statSafe(path) {
+function statSafe(path3) {
   try {
-    return statSync2(path);
+    return statSync2(path3);
   } catch {
     return void 0;
   }
@@ -6264,10 +6566,10 @@ var EditCheckpointStore = class {
   }
   async writeManifest(dir, manifest) {
     await mkdir(dir, { recursive: true });
-    const path = join19(dir, MANIFEST_FILE);
-    const tmp = `${path}.tmp`;
+    const path3 = join19(dir, MANIFEST_FILE);
+    const tmp = `${path3}.tmp`;
     await writeFile(tmp, JSON.stringify(manifest, null, 2), "utf8");
-    await rename(tmp, path);
+    await rename(tmp, path3);
   }
   sessionDir(sessionId) {
     return join19(this.rootDir, safePathSegment(sessionId));
@@ -6293,9 +6595,9 @@ function isInside(parent, child) {
   const rel = relative3(parent, child);
   return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
 }
-async function pathExists(path) {
+async function pathExists(path3) {
   try {
-    await access(path, constants.F_OK);
+    await access(path3, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -6308,9 +6610,9 @@ function readDirSyncSafe(dir) {
     return [];
   }
 }
-function readJsonManifest(path) {
+function readJsonManifest(path3) {
   try {
-    const raw = readFileSync15(path, "utf8");
+    const raw = readFileSync15(path3, "utf8");
     return JSON.parse(raw);
   } catch {
     return void 0;
@@ -6333,6 +6635,11 @@ function getQualifiedSkillName(rawInput) {
   const firstToken = rawInput.slice(1).trim().split(/\s+/)[0];
   return firstToken && firstToken.length > 0 ? firstToken : void 0;
 }
+function getBackgroundTaskEventEntryId(event) {
+  if ("task" in event) return createBackgroundTaskExecutionEntryId(event.task.id);
+  if ("taskId" in event) return createBackgroundTaskExecutionEntryId(event.taskId);
+  return void 0;
+}
 var InteractiveSession = class {
   session = null;
   commandExecutor;
@@ -6450,6 +6757,7 @@ var InteractiveSession = class {
       bare: options.bare,
       allowedTools: options.allowedTools,
       appendSystemPrompt: options.appendSystemPrompt,
+      language: options.language,
       backgroundTaskRunners: options.backgroundTaskRunners,
       subagentRunnerFactory: options.subagentRunnerFactory,
       ...options.commandModules ? { commandModules: options.commandModules } : {},
@@ -6481,6 +6789,9 @@ var InteractiveSession = class {
       throw new Error("InteractiveSession not initialized. Call submit() or await initialization.");
     return this.session;
   }
+  get sessionId() {
+    return this.session?.getSessionId() ?? "";
+  }
   on(event, handler) {
     if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
     this.listeners.get(event).add(handler);
@@ -6692,6 +7003,9 @@ var InteractiveSession = class {
   getActiveTools() {
     return this.activeTools;
   }
+  get isInitialized() {
+    return this.initialized;
+  }
   getContextState() {
     return this.getSessionOrThrow().getContextState();
   }
@@ -6776,18 +7090,18 @@ var InteractiveSession = class {
   listContextReferences() {
     return [...this.contextReferences];
   }
-  async addContextReference(path) {
+  async addContextReference(path3) {
     const { references, result } = await addInteractiveContextReference(
       this.contextReferences,
-      path,
+      path3,
       this.getCwd()
     );
     this.contextReferences = references;
     this.persistCurrentSession();
     return result;
   }
-  removeContextReference(path) {
-    const result = removeContextReference(this.contextReferences, path);
+  removeContextReference(path3) {
+    const result = removeContextReference(this.contextReferences, path3);
     this.contextReferences = result.references;
     this.persistCurrentSession();
     return result.result;
@@ -6837,6 +7151,53 @@ var InteractiveSession = class {
     await this.ensureInitialized();
     return this.getBackgroundJobOrchestratorOrThrow().waitGroup(groupId);
   }
+  getExecutionWorkspaceSnapshot(options = {}) {
+    const session = this.getSessionOrThrow();
+    const sessionId = session.getSessionId();
+    return createExecutionWorkspaceSnapshot({
+      sessionId,
+      mainThread: {
+        sessionId,
+        isExecuting: this.executing,
+        hasPendingPrompt: this.pendingPrompt !== null,
+        historyLength: this.history.length,
+        updatedAt: this.getMainThreadUpdatedAt(),
+        preview: this.getMainThreadPreview()
+      },
+      tasks: this.getBackgroundTaskSnapshots(),
+      groups: this.getBackgroundJobGroupSnapshots(),
+      selectedEntryId: options.selectedEntryId,
+      filter: options.filter
+    });
+  }
+  listExecutionWorkspaceEntries(filter) {
+    return [...this.getExecutionWorkspaceSnapshot({ filter }).entries];
+  }
+  getExecutionWorkspaceEntry(entryId) {
+    return this.getExecutionWorkspaceSnapshot().entries.find((entry) => entry.id === entryId);
+  }
+  async readExecutionWorkspaceDetail(entryId, cursor) {
+    await this.ensureInitialized();
+    const entryRef = parseExecutionWorkspaceEntryId(entryId);
+    if (!entryRef) throw new Error(`Unknown execution workspace entry: ${entryId}`);
+    if (entryRef.kind === "main_thread") {
+      return createMainThreadDetailPage({ entryId, history: this.history, cursor });
+    }
+    if (entryRef.kind === "background_group") {
+      return this.readBackgroundGroupDetail(entryId, entryRef.sourceId);
+    }
+    return this.readBackgroundTaskDetail(entryId, entryRef.sourceId, cursor);
+  }
+  createExecutionWorkspaceTaskSpawner(origin) {
+    const sessionId = this.getSessionOrThrow().getSessionId();
+    return createExecutionWorkspaceTaskSpawner({
+      manager: this.getBackgroundTaskManagerOrThrow(),
+      groupOrchestrator: this.getBackgroundJobOrchestratorOrThrow(),
+      sessionId,
+      cwd: this.getCwd(),
+      origin: { ...origin, sessionId: origin.sessionId || sessionId }
+    });
+  }
   listAgentDefinitions() {
     const deps = retrieveAgentToolDeps(this.getSessionOrThrow());
     return (deps?.agentDefinitions ?? []).map((agent) => ({
@@ -6851,10 +7212,11 @@ var InteractiveSession = class {
     await this.ensureInitialized();
     const deps = this.getAgentToolDepsOrThrow();
     const definition = this.resolveAgentDefinition(input.agentType, deps);
+    const sessionId = this.getSessionOrThrow().getSessionId();
     return this.getSubagentManagerOrThrow().spawn({
       type: input.agentType,
       label: input.label,
-      parentSessionId: this.getSessionOrThrow().getSessionId(),
+      parentSessionId: sessionId,
       mode: input.mode,
       depth: (deps.subagentDepth ?? 0) + 1,
       cwd: deps.cwd ?? this.cwd ?? process.cwd(),
@@ -6862,7 +7224,13 @@ var InteractiveSession = class {
       model: input.model ?? definition.model,
       isolation: input.isolation,
       allowedTools: definition.tools,
-      disallowedTools: definition.disallowedTools
+      disallowedTools: definition.disallowedTools,
+      metadata: createExecutionOriginMetadata({
+        kind: this.commandInvocationSource === "model" ? "model_command" : "slash_command",
+        sessionId,
+        commandName: "agent",
+        label: input.label
+      })
     });
   }
   async waitAgentJob(jobId) {
@@ -6965,6 +7333,51 @@ var InteractiveSession = class {
       this.finishForkSkillExecution();
     }
   }
+  async readBackgroundTaskDetail(entryId, taskId, cursor) {
+    const task = this.getBackgroundTaskManagerOrThrow().get(taskId);
+    if (!task) throw new Error(`Unknown background task: ${taskId}`);
+    if (task.logPath || task.transcriptPath) {
+      const page = await this.getBackgroundTaskManagerOrThrow().readLog(taskId, cursor);
+      return createLineDetailPage({
+        entryId,
+        lines: page.lines,
+        cursor: page.cursor,
+        nextCursor: page.nextCursor,
+        kind: task.kind === "process" ? "process_output" : "progress"
+      });
+    }
+    const detailKind = task.status === "failed" ? "error" : task.status === "completed" ? "result" : "progress";
+    const text = task.error?.message ?? task.result?.output ?? task.currentAction ?? task.promptPreview ?? task.commandPreview ?? task.status;
+    return createLineDetailPage({ entryId, lines: [text], cursor, kind: detailKind });
+  }
+  readBackgroundGroupDetail(entryId, groupId) {
+    const group = this.getBackgroundJobOrchestratorOrThrow().getGroup(groupId);
+    if (!group) throw new Error(`Unknown background job group: ${groupId}`);
+    const summary = summarizeBackgroundJobGroup(group);
+    return createLineDetailPage({
+      entryId,
+      lines: summary.lines,
+      kind: "group_summary"
+    });
+  }
+  getMainThreadUpdatedAt() {
+    return this.history.at(-1)?.timestamp.toISOString() ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  getMainThreadPreview() {
+    if (this.streamingText.trim().length > 0) return this.streamingText;
+    const latest = this.history.at(-1);
+    if (!latest) return void 0;
+    return latest.type;
+  }
+  emitExecutionWorkspaceUpdated(cause, entryId) {
+    if (!this.session) return;
+    this.emit("execution_workspace_event", {
+      type: "execution_workspace_updated",
+      cause,
+      ...entryId ? { entryId } : {},
+      snapshot: this.getExecutionWorkspaceSnapshot()
+    });
+  }
   getBackgroundTaskManagerOrThrow() {
     const manager = this.getBackgroundTaskManager();
     if (!manager) {
@@ -7030,11 +7443,16 @@ var InteractiveSession = class {
     this.backgroundTasks = this.getBackgroundTaskSnapshots();
     this.backgroundTaskEvents.push(event);
     this.persistCurrentSession();
+    this.emitExecutionWorkspaceUpdated("background_task", getBackgroundTaskEventEntryId(event));
   }
   recordBackgroundJobGroupEvent(event) {
     this.backgroundJobGroups = this.getBackgroundJobGroupSnapshots();
     this.backgroundJobGroupEvents.push(event);
     this.persistCurrentSession();
+    this.emitExecutionWorkspaceUpdated(
+      "background_group",
+      createBackgroundGroupExecutionEntryId(event.group.id)
+    );
   }
   getBackgroundTaskSnapshots() {
     try {
@@ -7098,10 +7516,12 @@ var InteractiveSession = class {
     this.clearStreaming();
     this.emit("thinking", true);
     this.history.push(messageToHistoryEntry(createUserMessage(displayInput)));
+    this.emitExecutionWorkspaceUpdated("main_thread");
   }
   finishForkSkillExecution() {
     this.executing = false;
     this.emit("thinking", false);
+    this.emitExecutionWorkspaceUpdated("main_thread");
     this.persistCurrentSession();
     if (!this.shuttingDown && this.pendingPrompt) {
       const queued = this.pendingPrompt;
@@ -7171,6 +7591,7 @@ var InteractiveSession = class {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
+    this.emitExecutionWorkspaceUpdated("main_thread");
     try {
       const result = await this.commandExecutor.executeCommand(command, this, args);
       this.emit("context_update", this.getContextState());
@@ -7184,6 +7605,7 @@ var InteractiveSession = class {
     } finally {
       this.executing = false;
       this.emit("thinking", false);
+      this.emitExecutionWorkspaceUpdated("main_thread");
       this.persistCurrentSession();
       if (!this.shuttingDown && this.pendingPrompt) {
         const queued = this.pendingPrompt;
@@ -7197,8 +7619,10 @@ var InteractiveSession = class {
   async executePrompt(input, displayInput, rawInput) {
     this.executing = true;
     this.clearStreaming();
+    this.emit("user_message", displayInput ?? input);
     this.emit("thinking", true);
     this.history.push(messageToHistoryEntry(createUserMessage(displayInput ?? input)));
+    this.emitExecutionWorkspaceUpdated("main_thread");
     const historyBefore = this.getSessionOrThrow().getHistory().length;
     this.usedMemoryReferences = [];
     try {
@@ -7260,6 +7684,7 @@ var InteractiveSession = class {
       await this.finalizeEditCheckpointTurn();
       this.executing = false;
       this.emit("thinking", false);
+      this.emitExecutionWorkspaceUpdated("main_thread");
       this.persistCurrentSession();
       if (!this.shuttingDown && this.pendingPrompt) {
         const queued = this.pendingPrompt;
@@ -7558,6 +7983,404 @@ function createQuery(options) {
   };
 }
 
+// src/user-local/storage.ts
+import { promises as fs } from "fs";
+import { homedir as homedir6 } from "os";
+import path from "path";
+var USER_LOCAL_STORAGE_CATEGORIES = [
+  "preferences",
+  "view-state",
+  "memory-projections",
+  "task-associations",
+  "workflow-metadata",
+  "inspection-index"
+];
+var USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS = [
+  {
+    category: "preferences",
+    purpose: "User-local UI and display preferences.",
+    mayExecuteCommands: false
+  },
+  {
+    category: "view-state",
+    purpose: "Last selected panels, filters, and navigation state.",
+    mayExecuteCommands: false
+  },
+  {
+    category: "memory-projections",
+    purpose: "Inspectable local memory item projections and user choices.",
+    mayExecuteCommands: false
+  },
+  {
+    category: "task-associations",
+    purpose: "User-local associations between sessions, tasks, and background items.",
+    mayExecuteCommands: false
+  },
+  {
+    category: "workflow-metadata",
+    purpose: "Transparent workflow metadata that is not repo-owned.",
+    mayExecuteCommands: false
+  },
+  {
+    category: "inspection-index",
+    purpose: "Category and item summaries for user inspection and deletion.",
+    mayExecuteCommands: false
+  }
+];
+function formatIsoDate(date) {
+  return date.toISOString();
+}
+function assertAbsolutePath(name, value) {
+  if (value.trim().length === 0) {
+    throw new Error(`${name} must not be empty.`);
+  }
+  if (!path.isAbsolute(value)) {
+    throw new Error(`${name} must be an absolute path: ${value}`);
+  }
+}
+function resolveDefaultHomeDir() {
+  return process.env.HOME ?? homedir6();
+}
+function isEqualOrInside(parentPath, candidatePath) {
+  const relative4 = path.relative(parentPath, candidatePath);
+  return relative4 === "" || !relative4.startsWith("..") && !path.isAbsolute(relative4);
+}
+async function resolveForComparison(absPath) {
+  let current = absPath;
+  while (path.dirname(current) !== current) {
+    try {
+      const realCurrent = await fs.realpath(current);
+      const relativeMissingPath = path.relative(current, absPath);
+      return path.resolve(realCurrent, relativeMissingPath);
+    } catch {
+      current = path.dirname(current);
+    }
+  }
+  try {
+    return await fs.realpath(current);
+  } catch {
+    return path.resolve(absPath);
+  }
+}
+async function resolveUserLocalStorageRoot(options) {
+  const activeRepositoryRoot = path.resolve(options.activeRepositoryRoot);
+  assertAbsolutePath("activeRepositoryRoot", activeRepositoryRoot);
+  const candidateRoot = options.storageRoot !== void 0 ? options.storageRoot : path.join(options.homeDir ?? resolveDefaultHomeDir(), ".robota");
+  assertAbsolutePath("userLocalStorageRoot", candidateRoot);
+  const resolvedRoot = path.resolve(candidateRoot);
+  const comparableRoot = await resolveForComparison(resolvedRoot);
+  const comparableRepositoryRoot = await resolveForComparison(activeRepositoryRoot);
+  if (isEqualOrInside(comparableRepositoryRoot, comparableRoot)) {
+    throw new Error(
+      `User-local storage root must be outside the active repository: ${resolvedRoot}`
+    );
+  }
+  return resolvedRoot;
+}
+function resolveCategoryLocation(root, category) {
+  return path.join(root, category);
+}
+async function listItemSummaries(root, category) {
+  const storageLocation = resolveCategoryLocation(root, category);
+  let entries;
+  try {
+    entries = await fs.readdir(storageLocation, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const summaries = await Promise.all(
+    entries.map(async (entry) => {
+      const itemLocation = path.join(storageLocation, entry.name);
+      const stats = await fs.stat(itemLocation);
+      const key = entry.name;
+      return {
+        root,
+        category,
+        key,
+        summary: `${category}/${key}`,
+        source: "user-local-storage",
+        scope: "user",
+        storageLocation: itemLocation,
+        createdAt: formatIsoDate(stats.birthtime),
+        lastUsedAt: formatIsoDate(stats.mtime),
+        enabled: true,
+        deleteAvailable: true,
+        disableAvailable: false
+      };
+    })
+  );
+  return summaries.sort((left, right) => left.key.localeCompare(right.key));
+}
+async function inspectUserLocalStorage(options) {
+  const root = await resolveUserLocalStorageRoot(options);
+  const activeRepositoryRoot = path.resolve(options.activeRepositoryRoot);
+  const createDirectories = options.createDirectories ?? true;
+  if (createDirectories) {
+    await fs.mkdir(root, { recursive: true });
+  }
+  const categories = await Promise.all(
+    USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS.map(
+      async (definition) => {
+        const storageLocation = resolveCategoryLocation(root, definition.category);
+        if (createDirectories) {
+          await fs.mkdir(storageLocation, { recursive: true });
+        }
+        const items = await listItemSummaries(root, definition.category);
+        return {
+          category: definition.category,
+          purpose: definition.purpose,
+          mayExecuteCommands: definition.mayExecuteCommands,
+          storageLocation,
+          itemCount: items.length,
+          items
+        };
+      }
+    )
+  );
+  return {
+    root,
+    activeRepositoryRoot,
+    categories,
+    generatedAt: formatIsoDate((options.now ?? (() => /* @__PURE__ */ new Date()))())
+  };
+}
+
+// src/user-local/memory.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+
+// src/user-local/memory-types.ts
+var USER_LOCAL_MEMORY_CATEGORIES = [
+  "view-preference",
+  "last-visible-cwd",
+  "background-selection",
+  "task-association",
+  "display-preference",
+  "inspection-choice"
+];
+
+// src/user-local/memory.ts
+var MEMORY_STORAGE_CATEGORY = "memory-projections";
+var FILE_EXTENSION = ".json";
+var MEMORY_SCHEMA_VERSION = 1;
+var MAX_SEGMENT_LENGTH = 80;
+var MAX_SUMMARY_LENGTH = 240;
+var MAX_SOURCE_LENGTH = 80;
+var MAX_SCOPE_LENGTH = 120;
+var MAX_VALUE_SUMMARY_LENGTH = 240;
+var DEFAULT_SCOPE = "user";
+var SAFE_SEGMENT_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
+var DISPLAY_NAVIGATION_RULES = {
+  "view-preference": "May affect UI panel, filter, density, or sorting display/navigation only.",
+  "last-visible-cwd": "May display or preselect an already visible workspace context only.",
+  "background-selection": "May restore the selected background entry in local UI only.",
+  "task-association": "May group visible tasks by a local association only.",
+  "display-preference": "May affect local text wrapping, compactness, or visibility only.",
+  "inspection-choice": "May affect inspection display choices only."
+};
+function formatIsoDate2(date) {
+  return date.toISOString();
+}
+function isUserLocalMemoryCategory(value) {
+  return USER_LOCAL_MEMORY_CATEGORIES.includes(value);
+}
+function assertUserLocalMemoryCategory(value) {
+  if (!isUserLocalMemoryCategory(value)) {
+    throw new Error(`Unsupported user-local memory category: ${value}`);
+  }
+  return value;
+}
+function assertSafeSegment(name, value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${name} must not be empty.`);
+  }
+  if (trimmed.length > MAX_SEGMENT_LENGTH || !SAFE_SEGMENT_PATTERN.test(trimmed)) {
+    throw new Error(
+      `${name} must use lowercase letters, numbers, dots, underscores, or hyphens: ${value}`
+    );
+  }
+  return trimmed;
+}
+function boundedText(name, value, maxLength) {
+  const normalized = value.trim().replace(/\s+/g, " ");
+  if (normalized.length === 0) {
+    throw new Error(`${name} must not be empty.`);
+  }
+  if (normalized.length > maxLength) {
+    return normalized.slice(0, maxLength);
+  }
+  return normalized;
+}
+function summarizeValue(value) {
+  return boundedText("value", value, MAX_VALUE_SUMMARY_LENGTH);
+}
+function memoryFileName(category, key) {
+  return `${category}__${key}${FILE_EXTENSION}`;
+}
+async function resolveMemoryRoot(options) {
+  const root = await resolveUserLocalStorageRoot(options);
+  return {
+    root,
+    memoryRoot: path2.join(root, MEMORY_STORAGE_CATEGORY)
+  };
+}
+function parseMemoryRecord(raw, storageLocation) {
+  const record = JSON.parse(raw);
+  const category = readString(record, "category");
+  const schemaVersion = record["schemaVersion"];
+  if (schemaVersion !== MEMORY_SCHEMA_VERSION) {
+    throw new Error(`Unsupported user-local memory schema at ${storageLocation}`);
+  }
+  return {
+    schemaVersion: MEMORY_SCHEMA_VERSION,
+    category: assertUserLocalMemoryCategory(category),
+    key: readString(record, "key"),
+    value: readString(record, "value"),
+    summary: readString(record, "summary"),
+    source: readString(record, "source"),
+    scope: readString(record, "scope"),
+    createdAt: readString(record, "createdAt"),
+    lastUsedAt: readString(record, "lastUsedAt"),
+    enabled: readBoolean(record, "enabled")
+  };
+}
+function readString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new Error(`Invalid user-local memory field: ${key}`);
+  }
+  return value;
+}
+function readBoolean(record, key) {
+  const value = record[key];
+  if (typeof value !== "boolean") {
+    throw new Error(`Invalid user-local memory field: ${key}`);
+  }
+  return value;
+}
+function projectMemoryItem(root, storageLocation, item) {
+  return {
+    root,
+    category: item.category,
+    key: item.key,
+    summary: item.summary,
+    valueSummary: summarizeValue(item.value),
+    source: item.source,
+    scope: item.scope,
+    storageLocation,
+    createdAt: item.createdAt,
+    lastUsedAt: item.lastUsedAt,
+    enabled: item.enabled,
+    displayNavigationRule: DISPLAY_NAVIGATION_RULES[item.category],
+    commandExecutionEffect: "none",
+    deleteAvailable: true,
+    disableAvailable: true
+  };
+}
+async function readMemoryFile(root, storageLocation) {
+  return projectMemoryItem(
+    root,
+    storageLocation,
+    parseMemoryRecord(await fs2.readFile(storageLocation, "utf8"), storageLocation)
+  );
+}
+async function resolveMemoryFile(options) {
+  const category = assertUserLocalMemoryCategory(options.category);
+  const key = assertSafeSegment("key", options.key);
+  const { root, memoryRoot: memoryRoot3 } = await resolveMemoryRoot(options);
+  return {
+    root,
+    storageLocation: path2.join(memoryRoot3, memoryFileName(category, key))
+  };
+}
+async function setUserLocalMemoryItem(options) {
+  const category = assertUserLocalMemoryCategory(options.category);
+  const key = assertSafeSegment("key", options.key);
+  const summary = boundedText("summary", options.summary, MAX_SUMMARY_LENGTH);
+  const source = boundedText("source", options.source, MAX_SOURCE_LENGTH);
+  const scope = boundedText("scope", options.scope ?? DEFAULT_SCOPE, MAX_SCOPE_LENGTH);
+  const value = summarizeValue(options.value);
+  const now = formatIsoDate2((options.now ?? (() => /* @__PURE__ */ new Date()))());
+  const { root, memoryRoot: memoryRoot3 } = await resolveMemoryRoot(options);
+  const storageLocation = path2.join(memoryRoot3, memoryFileName(category, key));
+  let createdAt = now;
+  try {
+    const existing = parseMemoryRecord(await fs2.readFile(storageLocation, "utf8"), storageLocation);
+    createdAt = existing.createdAt;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ENOENT")) {
+      createdAt = now;
+    } else {
+      throw error;
+    }
+  }
+  const item = {
+    schemaVersion: MEMORY_SCHEMA_VERSION,
+    category,
+    key,
+    value,
+    summary,
+    source,
+    scope,
+    createdAt,
+    lastUsedAt: now,
+    enabled: true
+  };
+  await fs2.mkdir(memoryRoot3, { recursive: true });
+  await fs2.writeFile(storageLocation, `${JSON.stringify(item, null, 2)}
+`, "utf8");
+  return projectMemoryItem(root, storageLocation, item);
+}
+async function listUserLocalMemoryItems(options) {
+  const { root, memoryRoot: memoryRoot3 } = await resolveMemoryRoot(options);
+  let entries;
+  try {
+    entries = await fs2.readdir(memoryRoot3, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  const items = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(FILE_EXTENSION)).map((entry) => readMemoryFile(root, path2.join(memoryRoot3, entry.name)))
+  );
+  return {
+    root,
+    activeRepositoryRoot: path2.resolve(options.activeRepositoryRoot),
+    items: items.sort(
+      (left, right) => `${left.category}/${left.key}`.localeCompare(`${right.category}/${right.key}`)
+    )
+  };
+}
+async function inspectUserLocalMemoryItem(options) {
+  const { root, storageLocation } = await resolveMemoryFile(options);
+  return readMemoryFile(root, storageLocation);
+}
+async function disableUserLocalMemoryItem(options) {
+  const { root, storageLocation } = await resolveMemoryFile(options);
+  const existing = parseMemoryRecord(await fs2.readFile(storageLocation, "utf8"), storageLocation);
+  const disabled = {
+    ...existing,
+    enabled: false,
+    lastUsedAt: formatIsoDate2((options.now ?? (() => /* @__PURE__ */ new Date()))())
+  };
+  await fs2.writeFile(storageLocation, `${JSON.stringify(disabled, null, 2)}
+`, "utf8");
+  return projectMemoryItem(root, storageLocation, disabled);
+}
+async function deleteUserLocalMemoryItem(options) {
+  const { storageLocation } = await resolveMemoryFile(options);
+  await fs2.rm(storageLocation);
+  return {
+    category: options.category,
+    key: options.key,
+    deleted: true
+  };
+}
+async function readEnabledUserLocalMemoryItem(options) {
+  const item = await inspectUserLocalMemoryItem(options);
+  return item.enabled ? item : null;
+}
+
 // src/self-hosting/self-hosting-verification.ts
 var DEFAULT_BASE_REF = "origin/develop";
 var PACKAGE_VERIFY_COMMANDS = ["test", "typecheck", "build"];
@@ -7776,6 +8599,7 @@ export {
   DEFAULT_AUTO_COMPACT_THRESHOLD,
   DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE,
   DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
+  EXECUTION_ORIGIN_METADATA_KEYS,
   EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore,
   HELP_COMMAND_DESCRIPTION,
@@ -7813,6 +8637,9 @@ export {
   SkillCommandSource,
   SubagentManager3 as SubagentManager,
   SystemCommandExecutor,
+  USER_LOCAL_MEMORY_CATEGORIES,
+  USER_LOCAL_STORAGE_CATEGORIES,
+  USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS,
   VALIDATE_SESSION_COMMAND_DESCRIPTION,
   VALID_PERMISSION_MODES,
   WorktreeSubagentRunner,
@@ -7837,7 +8664,9 @@ export {
   closeCommandBackgroundTask,
   compactCommandContext,
   createAgentTool,
+  createBackgroundGroupExecutionEntryId,
   createBackgroundProcessTool,
+  createBackgroundTaskExecutionEntryId,
   createBackgroundTaskLogPage,
   createBuiltinCommandModule,
   createCommandExecutionTool,
@@ -7846,7 +8675,13 @@ export {
   createCommandProjectMemoryStore,
   createContextReferenceItem,
   createDefaultTools,
+  createExecutionOriginMetadata,
+  createExecutionWorkspaceSnapshot,
+  createExecutionWorkspaceTaskSpawner,
   createLimitedOutputCapture,
+  createLineDetailPage,
+  createMainThreadDetailPage,
+  createMainThreadExecutionEntryId,
   createModelCommandToolProjection,
   createPluginRegistryReloadRequestedEffect,
   createPluginTuiRequestedEffect,
@@ -7864,6 +8699,8 @@ export {
   createSystemCommands,
   createWorktreeSubagentRunner,
   deleteProviderProfile,
+  deleteUserLocalMemoryItem,
+  disableUserLocalMemoryItem,
   discoverTaskFiles,
   evaluateReversibleToolSafety,
   executeSkill,
@@ -7893,12 +8730,14 @@ export {
   hasSensitiveCommandMemoryContent,
   hasUsableSecretReference,
   inspectCommandEditCheckpoint,
+  inspectUserLocalMemoryItem,
+  inspectUserLocalStorage,
   isCommandMemoryType,
   isEnvReference,
   isMemoryType,
   isPermissionMode,
   isStatusLineCommandSettingsPatch,
-  isTerminalBackgroundTaskStatus2 as isTerminalBackgroundTaskStatus,
+  isTerminalBackgroundTaskStatus3 as isTerminalBackgroundTaskStatus,
   listActiveContextReferences,
   listCommandBackgroundTasks,
   listCommandContextReferences,
@@ -7906,10 +8745,12 @@ export {
   listCommandSessionAllowedTools,
   listCommandUsedMemoryReferences,
   listResumableSessionSummaries,
+  listUserLocalMemoryItems,
   loadTaskContext,
   mergeProviderPatch,
   normalizeModelCommandName,
   parseCommandBackgroundLogCursor,
+  parseExecutionWorkspaceEntryId,
   parseFrontmatter,
   parseLanguageArgument,
   parsePermissionModeArgument,
@@ -7929,6 +8770,7 @@ export {
   readCommandPermissionsState,
   readCommandSessionInfo,
   readCurrentGitBranch,
+  readEnabledUserLocalMemoryItem,
   recordCommandMemoryEvent,
   removeCommandContextReference,
   removeContextReference,
@@ -7944,6 +8786,7 @@ export {
   resolveProviderSetupSelection,
   resolveSessionIdByIdOrName,
   resolveSubagentLogDir,
+  resolveUserLocalStorageRoot,
   restoreCommandEditCheckpoint,
   retrieveAgentToolDeps,
   rollbackCommandEditCheckpoint,
@@ -7952,6 +8795,7 @@ export {
   selectRelevantTasks,
   setCommandAutoCompactThreshold,
   setCurrentProvider,
+  setUserLocalMemoryItem,
   storeAgentToolDeps,
   submitProviderSetupValue,
   substituteVariables,