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

package/dist/node/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   COST_COMMAND_DESCRIPTION: () => COST_COMMAND_DESCRIPTION,
   CommandRegistry: () => CommandRegistry,
   DEFAULT_AUTO_COMPACT_THRESHOLD: () => DEFAULT_AUTO_COMPACT_THRESHOLD,
+  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE: () => import_agent_runtime4.DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE,
   DEFAULT_STATUS_LINE_COMMAND_SETTINGS: () => DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
   EXIT_COMMAND_DESCRIPTION: () => EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore: () => EditCheckpointStore,
@@ -59,12 +60,14 @@ __export(index_exports, {
   MEMORY_INDEX_MAX_LINES: () => MEMORY_INDEX_MAX_LINES,
   MODEL_COMMAND_ARGUMENT_HINT: () => MODEL_COMMAND_ARGUMENT_HINT,
   MODEL_COMMAND_DESCRIPTION: () => MODEL_COMMAND_DESCRIPTION,
+  MODEL_COMMAND_TOOL_PREFIX: () => MODEL_COMMAND_TOOL_PREFIX,
   MarketplaceClient: () => MarketplaceClient,
   PERMISSIONS_COMMAND_DESCRIPTION: () => PERMISSIONS_COMMAND_DESCRIPTION,
   PERMISSION_MODE_ARGUMENT_HINT: () => PERMISSION_MODE_ARGUMENT_HINT,
   PERMISSION_MODE_COMMAND_DESCRIPTION: () => PERMISSION_MODE_COMMAND_DESCRIPTION,
   PLUGIN_COMMAND_ARGUMENT_HINT: () => PLUGIN_COMMAND_ARGUMENT_HINT,
   PLUGIN_COMMAND_DESCRIPTION: () => PLUGIN_COMMAND_DESCRIPTION,
+  PROVIDER_SAFE_TOOL_NAME_PATTERN: () => PROVIDER_SAFE_TOOL_NAME_PATTERN,
   PluginCommandSource: () => PluginCommandSource,
   PluginSettingsStore: () => PluginSettingsStore,
   ProjectMemoryStore: () => ProjectMemoryStore,
@@ -81,9 +84,11 @@ __export(index_exports, {
   SkillCommandSource: () => SkillCommandSource,
   SubagentManager: () => import_agent_runtime7.SubagentManager,
   SystemCommandExecutor: () => SystemCommandExecutor,
-  TRUST_TO_MODE: () => import_agent_core8.TRUST_TO_MODE,
+  VALIDATE_SESSION_COMMAND_DESCRIPTION: () => VALIDATE_SESSION_COMMAND_DESCRIPTION,
   VALID_PERMISSION_MODES: () => VALID_PERMISSION_MODES,
   WorktreeSubagentRunner: () => import_agent_runtime8.WorktreeSubagentRunner,
+  addCommandContextReference: () => addCommandContextReference,
+  appendPrefixedLogLines: () => import_agent_runtime4.appendPrefixedLogLines,
   assembleSubagentPrompt: () => assembleSubagentPrompt,
   buildBackgroundCommandSubcommands: () => buildBackgroundCommandSubcommands,
   buildLanguageCommandSubcommands: () => buildLanguageCommandSubcommands,
@@ -91,26 +96,35 @@ __export(index_exports, {
   buildModelCommandSubcommands: () => buildModelCommandSubcommands,
   buildPermissionModeSubcommands: () => buildPermissionModeSubcommands,
   buildPluginCommandSubcommands: () => buildPluginCommandSubcommands,
+  buildPromptWithFileReferences: () => buildPromptWithFileReferences,
   buildProviderProfile: () => buildProviderProfile,
   buildProviderSetupPatch: () => buildProviderSetupPatch,
   buildRewindCommandSubcommands: () => buildRewindCommandSubcommands,
-  buildSkillPrompt: () => buildSkillPrompt,
   buildStatusLineCommandSubcommands: () => buildStatusLineCommandSubcommands,
   cancelCommandBackgroundTask: () => cancelCommandBackgroundTask,
-  chatEntryToMessage: () => import_agent_core9.chatEntryToMessage,
+  clearCommandContextReferences: () => clearCommandContextReferences,
+  clearContextReferences: () => clearContextReferences,
   clearConversationHistory: () => clearConversationHistory,
   closeCommandBackgroundTask: () => closeCommandBackgroundTask,
   compactCommandContext: () => compactCommandContext,
   createAgentTool: () => createAgentTool,
   createBackgroundProcessTool: () => createBackgroundProcessTool,
+  createBackgroundTaskLogPage: () => import_agent_runtime4.createBackgroundTaskLogPage,
   createBuiltinCommandModule: () => createBuiltinCommandModule,
   createCommandExecutionTool: () => createCommandExecutionTool,
   createCommandMemoryStores: () => createCommandMemoryStores,
   createCommandPendingMemoryStore: () => createCommandPendingMemoryStore,
   createCommandProjectMemoryStore: () => createCommandProjectMemoryStore,
+  createContextReferenceItem: () => createContextReferenceItem,
   createDefaultTools: () => createDefaultTools,
+  createLimitedOutputCapture: () => import_agent_runtime4.createLimitedOutputCapture,
+  createModelCommandToolProjection: () => createModelCommandToolProjection,
   createPluginRegistryReloadRequestedEffect: () => createPluginRegistryReloadRequestedEffect,
   createPluginTuiRequestedEffect: () => createPluginTuiRequestedEffect,
+  createProjectSessionStore: () => createProjectSessionStore,
+  createProjectedCommandExecutionTools: () => createProjectedCommandExecutionTools,
+  createPromptFileReferenceHistoryEntry: () => createPromptFileReferenceHistoryEntry,
+  createProviderSafeModelCommandToolName: () => createProviderSafeModelCommandToolName,
   createProviderSetupFlow: () => createProviderSetupFlow,
   createQuery: () => createQuery,
   createSessionExitRequestedEffect: () => createSessionExitRequestedEffect,
@@ -120,48 +134,57 @@ __export(index_exports, {
   createSubagentSession: () => createSubagentSession,
   createSystemCommands: () => createSystemCommands,
   createWorktreeSubagentRunner: () => import_agent_runtime8.createWorktreeSubagentRunner,
+  deleteProviderProfile: () => deleteProviderProfile,
   discoverTaskFiles: () => discoverTaskFiles,
-  evaluatePermission: () => import_agent_core10.evaluatePermission,
   evaluateReversibleToolSafety: () => evaluateReversibleToolSafety,
   executeSkill: () => executeSkill,
   formatCommandBackgroundTask: () => formatCommandBackgroundTask,
   formatCommandBackgroundTaskList: () => formatCommandBackgroundTaskList,
   formatCommandHelpMessage: () => formatCommandHelpMessage,
   formatCommandPermissionsMessage: () => formatCommandPermissionsMessage,
+  formatCommandSessionReplayValidationReport: () => formatCommandSessionReplayValidationReport,
   formatEnvReference: () => formatEnvReference,
   formatInvalidPermissionModeMessage: () => formatInvalidPermissionModeMessage,
   formatLanguageUsageMessage: () => formatLanguageUsageMessage,
+  formatModelCommandUsageMessage: () => formatModelCommandUsageMessage,
+  formatModelCommandUsageMessageAsync: () => formatModelCommandUsageMessageAsync,
+  formatProjectedModelCommandToolPromptDescription: () => formatProjectedModelCommandToolPromptDescription,
+  formatPromptFileReferenceDiagnostics: () => formatPromptFileReferenceDiagnostics,
   formatProviderSetupChoiceLabel: () => formatProviderSetupChoiceLabel,
+  formatProviderSetupHelpLinks: () => formatProviderSetupHelpLinks,
   formatProviderSetupPromptLabel: () => formatProviderSetupPromptLabel,
   formatProviderSetupSelectionPrompt: () => formatProviderSetupSelectionPrompt,
   formatTaskContext: () => formatTaskContext,
   getBackgroundTaskTransitions: () => import_agent_runtime4.getBackgroundTaskTransitions,
   getBuiltInAgent: () => getBuiltInAgent,
   getForkWorkerSuffix: () => getForkWorkerSuffix,
-  getMessagesForAPI: () => import_agent_core9.getMessagesForAPI,
   getProviderSetupStep: () => getProviderSetupStep,
   getSubagentSuffix: () => getSubagentSuffix,
+  hasBlockingPromptFileReferenceDiagnostics: () => hasBlockingPromptFileReferenceDiagnostics,
   hasSensitiveCommandMemoryContent: () => hasSensitiveCommandMemoryContent,
   hasUsableSecretReference: () => hasUsableSecretReference,
   inspectCommandEditCheckpoint: () => inspectCommandEditCheckpoint,
-  isChatEntry: () => import_agent_core9.isChatEntry,
   isCommandMemoryType: () => isCommandMemoryType,
   isEnvReference: () => isEnvReference,
   isMemoryType: () => isMemoryType,
   isPermissionMode: () => isPermissionMode,
   isStatusLineCommandSettingsPatch: () => isStatusLineCommandSettingsPatch,
   isTerminalBackgroundTaskStatus: () => import_agent_runtime4.isTerminalBackgroundTaskStatus,
+  listActiveContextReferences: () => listActiveContextReferences,
   listCommandBackgroundTasks: () => listCommandBackgroundTasks,
+  listCommandContextReferences: () => listCommandContextReferences,
   listCommandEditCheckpoints: () => listCommandEditCheckpoints,
   listCommandSessionAllowedTools: () => listCommandSessionAllowedTools,
   listCommandUsedMemoryReferences: () => listCommandUsedMemoryReferences,
+  listResumableSessionSummaries: () => listResumableSessionSummaries,
   loadTaskContext: () => loadTaskContext,
   mergeProviderPatch: () => mergeProviderPatch,
-  messageToHistoryEntry: () => import_agent_core9.messageToHistoryEntry,
+  normalizeModelCommandName: () => normalizeModelCommandName,
   parseCommandBackgroundLogCursor: () => parseCommandBackgroundLogCursor,
   parseFrontmatter: () => parseFrontmatter,
   parseLanguageArgument: () => parseLanguageArgument,
   parsePermissionModeArgument: () => parsePermissionModeArgument,
+  parsePromptFileReferences: () => parsePromptFileReferences,
   parseSessionNameArgument: () => parseSessionNameArgument,
   parseTaskFile: () => parseTaskFile,
   planSelfHostingVerification: () => planSelfHostingVerification,
@@ -178,30 +201,43 @@ __export(index_exports, {
   readCommandSessionInfo: () => readCommandSessionInfo,
   readCurrentGitBranch: () => readCurrentGitBranch,
   recordCommandMemoryEvent: () => recordCommandMemoryEvent,
+  removeCommandContextReference: () => removeCommandContextReference,
+  removeContextReference: () => removeContextReference,
   resetAutoCompactThresholdSetting: () => resetAutoCompactThresholdSetting,
+  resolveActiveProviderModelCatalog: () => resolveActiveProviderModelCatalog,
+  resolveActiveProviderModelCatalogState: () => resolveActiveProviderModelCatalogState,
   resolveEnvReference: () => resolveEnvReference,
+  resolveLatestSessionId: () => resolveLatestSessionId,
   resolvePermissionModeAdapter: () => resolvePermissionModeAdapter,
   resolvePluginCommandAdapter: () => resolvePluginCommandAdapter,
+  resolvePromptFileReferencePaths: () => resolvePromptFileReferencePaths,
+  resolvePromptFileReferences: () => resolvePromptFileReferences,
   resolveProviderSetupSelection: () => resolveProviderSetupSelection,
+  resolveSessionIdByIdOrName: () => resolveSessionIdByIdOrName,
   resolveSubagentLogDir: () => resolveSubagentLogDir,
   restoreCommandEditCheckpoint: () => restoreCommandEditCheckpoint,
   retrieveAgentToolDeps: () => retrieveAgentToolDeps,
   rollbackCommandEditCheckpoint: () => rollbackCommandEditCheckpoint,
-  runHooks: () => import_agent_core11.runHooks,
   runProviderSetupPromptFlow: () => runProviderSetupPromptFlow,
+  sanitizeProviderProfileName: () => sanitizeProviderProfileName,
   selectRelevantTasks: () => selectRelevantTasks,
   setCommandAutoCompactThreshold: () => setCommandAutoCompactThreshold,
   setCurrentProvider: () => setCurrentProvider,
   storeAgentToolDeps: () => storeAgentToolDeps,
   submitProviderSetupValue: () => submitProviderSetupValue,
   substituteVariables: () => substituteVariables,
+  suggestProviderProfileName: () => suggestProviderProfileName,
   summarizeBackgroundJobGroup: () => summarizeBackgroundJobGroup,
   testProviderProfileCommand: () => testProviderProfileCommand,
+  toContextReferenceRecords: () => toContextReferenceRecords,
+  toPromptFileReferenceRecords: () => toPromptFileReferenceRecords,
   transitionBackgroundTaskStatus: () => import_agent_runtime4.transitionBackgroundTaskStatus,
   transitionSelfHostingLoop: () => transitionSelfHostingLoop,
   updateTaskFileStatus: () => updateTaskFileStatus,
+  upsertContextReference: () => upsertContextReference,
   upsertProviderProfile: () => upsertProviderProfile,
   userPaths: () => userPaths,
+  validateCommandSessionReplayLog: () => validateCommandSessionReplayLog,
   validateProviderProfile: () => validateProviderProfile,
   validateProviderSetupValue: () => validateProviderSetupValue,
   wrapEditCheckpointTools: () => wrapEditCheckpointTools,
@@ -212,6 +248,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/interactive/interactive-session.ts
+var import_node_crypto5 = require("crypto");
 var import_agent_core7 = require("@robota-sdk/agent-core");
 
 // src/commands/capability-descriptors.ts
@@ -223,7 +260,7 @@ function inferKind(command) {
 function commandToCapabilityDescriptor(command) {
   const skillLike = command.source === "skill" || command.source === "plugin" && Boolean(command.skillContent);
   return {
-    name: `/${command.name}`,
+    name: command.name,
     kind: inferKind(command),
     description: command.description,
     userInvocable: command.userInvocable !== false,
@@ -316,7 +353,7 @@ var SystemCommandExecutor = class {
   }
   listModelInvocableCommands() {
     return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
-      name: `/${command.name}`,
+      name: command.name,
       kind: "builtin-command",
       description: command.description,
       userInvocable: command.userInvocable !== false,
@@ -425,6 +462,32 @@ function setCurrentProvider(settings, profileName) {
     currentProvider: profileName
   };
 }
+function deleteProviderProfile(settings, profileName, options = {}) {
+  if (!settings.providers?.[profileName]) {
+    throw new Error(`Provider profile "${profileName}" was not found`);
+  }
+  const providers = { ...settings.providers };
+  delete providers[profileName];
+  if (options.replacementCurrentProvider !== void 0 && providers[options.replacementCurrentProvider] === void 0) {
+    throw new Error(`Provider profile "${options.replacementCurrentProvider}" was not found`);
+  }
+  const next = {
+    ...settings,
+    providers
+  };
+  if (settings.currentProvider !== profileName) {
+    return next;
+  }
+  if (options.replacementCurrentProvider !== void 0) {
+    return {
+      ...next,
+      currentProvider: options.replacementCurrentProvider
+    };
+  }
+  const withoutCurrentProvider = { ...next };
+  delete withoutCurrentProvider.currentProvider;
+  return withoutCurrentProvider;
+}
 function validateProviderProfile(profileName, profile, options = {}) {
   if (!profile.type) {
     throw new Error(`Provider profile "${profileName}" is missing type`);
@@ -433,8 +496,11 @@ function validateProviderProfile(profileName, profile, options = {}) {
     throw new Error(`Provider profile "${profileName}" is missing model`);
   }
   const definition = (0, import_agent_core.findProviderDefinition)(options.providerDefinitions ?? [], profile.type);
-  if (definition?.requiresApiKey === true && !hasUsableSecretReference(profile.apiKey ?? definition.defaults?.apiKey)) {
-    throw new Error(`Provider profile "${profileName}" is missing apiKey`);
+  const credentialRequirement = (0, import_agent_core.getProviderCredentialRequirement)(definition);
+  if (credentialRequirement !== void 0 && !hasUsableRequiredProviderCredential(profile, definition?.defaults, credentialRequirement)) {
+    throw new Error(
+      `Provider profile "${profileName}" is missing ${formatCredentialRequirement(credentialRequirement)}`
+    );
   }
 }
 function buildProviderSetupPatch(input, options = {}) {
@@ -454,7 +520,7 @@ function buildProviderProfile(input, options = {}) {
   return {
     type: input.type,
     model: input.model ?? defaults.model,
-    ...apiKey !== void 0 && { apiKey },
+    ...isNonEmptyString(apiKey) && { apiKey },
     ...baseURL !== void 0 && { baseURL },
     ...input.timeout !== void 0 && { timeout: input.timeout }
   };
@@ -470,6 +536,20 @@ function mergeProviderPatch(settings, patch) {
 function getProviderDefaults(type, providerDefinitions) {
   return (0, import_agent_core.findProviderDefinition)(providerDefinitions, type)?.defaults ?? {};
 }
+function hasUsableRequiredProviderCredential(profile, defaults, requirement) {
+  return requirement.anyOf.some(
+    (field) => hasUsableSecretReference(resolveProviderCredentialValue(field, profile, defaults))
+  );
+}
+function resolveProviderCredentialValue(field, profile, defaults) {
+  return profile[field] ?? defaults?.[field];
+}
+function formatCredentialRequirement(requirement) {
+  return requirement.anyOf.join(" or ");
+}
+function isNonEmptyString(value) {
+  return value !== void 0 && value.length > 0;
+}
 
 // src/command-api/provider/provider-command-probe.ts
 async function testProviderProfileCommand(currentProvider, providers, profileArg, options) {
@@ -702,18 +782,64 @@ async function compactCommandContext(context, instructions) {
   const after = readCommandContextState(context);
   return { before, after };
 }
+function listCommandContextReferences(context) {
+  return context.listContextReferences?.() ?? [];
+}
+async function addCommandContextReference(context, path) {
+  if (!context.addContextReference) {
+    return {
+      evicted: [],
+      diagnostics: ["Command host does not support context reference additions."]
+    };
+  }
+  return context.addContextReference(path);
+}
+function removeCommandContextReference(context, path) {
+  return context.removeContextReference?.(path) ?? {};
+}
+function clearCommandContextReferences(context) {
+  return context.clearContextReferences?.() ?? { removed: [] };
+}
 function getSettingsAdapter(context) {
   return context.getCommandHostAdapters?.().settings;
 }
 
+// src/command-api/provider/provider-profile-names.ts
+var FALLBACK_PROFILE_NAME = "provider";
+var FIRST_DUPLICATE_SUFFIX = 2;
+function suggestProviderProfileName(input, options = {}) {
+  const baseName = sanitizeProviderProfileName(input.model) ?? sanitizeProviderProfileName(input.type) ?? FALLBACK_PROFILE_NAME;
+  const existing = new Set(options.existingProfileNames ?? []);
+  if (!existing.has(baseName)) {
+    return baseName;
+  }
+  let suffix = FIRST_DUPLICATE_SUFFIX;
+  while (existing.has(`${baseName}-${suffix}`)) {
+    suffix += 1;
+  }
+  return `${baseName}-${suffix}`;
+}
+function sanitizeProviderProfileName(value) {
+  const normalized = value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized !== void 0 && normalized.length > 0 ? normalized : void 0;
+}
+
 // src/command-api/provider/provider-setup-flow.ts
 var import_agent_core3 = require("@robota-sdk/agent-core");
-function createProviderSetupFlow(type, providerDefinitions) {
+function createProviderSetupFlow(type, providerDefinitions, options = {}) {
+  const definition = getProviderSetupDefinition(type, providerDefinitions);
   return {
     type,
-    steps: getProviderSetupSteps(type, providerDefinitions),
+    steps: applyProviderSetupInitialValues(
+      getProviderSetupSteps(definition),
+      options.initialValues
+    ),
+    setupHelpLinks: definition.setupHelpLinks ?? [],
     stepIndex: 0,
-    values: {}
+    values: {},
+    existingProfileNames: options.existingProfileNames ?? [],
+    ...options.profileName !== void 0 ? { profileName: options.profileName } : {},
+    ...options.setCurrent !== void 0 ? { setCurrent: options.setCurrent } : {}
   };
 }
 function formatProviderSetupSelectionPrompt(providerDefinitions) {
@@ -774,12 +900,15 @@ function submitProviderSetupValue(state, rawValue) {
   }
   return { status: "complete", input: buildProviderSetupInput(nextState) };
 }
-async function runProviderSetupPromptFlow(type, promptInput, providerDefinitions) {
-  let state = createProviderSetupFlow(type, providerDefinitions);
+async function runProviderSetupPromptFlow(type, promptInput, providerDefinitions, options = {}) {
+  let state = createProviderSetupFlow(type, providerDefinitions, options);
   const stepCount = state.steps.length;
   while (state.stepIndex < stepCount) {
     const step = getProviderSetupStep(state);
-    const value = await promptInput(formatProviderSetupPromptLabel(step), step.masked === true);
+    const value = await promptInput(
+      formatProviderSetupPromptLabel(step, state.setupHelpLinks),
+      step.masked === true
+    );
     const result = submitProviderSetupValue(state, value);
     if (result.status === "complete") {
       return result.input;
@@ -791,14 +920,25 @@ async function runProviderSetupPromptFlow(type, promptInput, providerDefinitions
   }
   throw new Error("Provider setup flow ended without completion");
 }
-function formatProviderSetupPromptLabel(step) {
+function formatProviderSetupPromptLabel(step, setupHelpLinks = []) {
   const suffix = step.defaultValue !== void 0 ? ` (default: ${step.defaultValue})` : "";
-  return `  ${step.title}${suffix}: `;
+  const setupHelp = formatProviderSetupHelpLinks(setupHelpLinks);
+  const prefix = setupHelp.length > 0 ? `${setupHelp}
+` : "";
+  return `${prefix}  ${step.title}${suffix}: `;
 }
 function formatProviderSetupChoiceLabel(definition) {
   const label = definition.displayName !== void 0 ? `${definition.displayName} (${definition.type})` : definition.type;
   return definition.description !== void 0 ? `${label} - ${definition.description}` : label;
 }
+function formatProviderSetupHelpLinks(setupHelpLinks = []) {
+  if (setupHelpLinks.length === 0) {
+    return "";
+  }
+  return setupHelpLinks.map(
+    (link) => `  Setup help: ${formatProviderSetupHelpLinkKind(link.kind)}: ${link.label} - ${link.url}`
+  ).join("\n");
+}
 function parseProviderSelectionIndex(value) {
   if (!/^\d+$/.test(value)) {
     return void 0;
@@ -811,13 +951,16 @@ function validateProviderSetupValue(step, value) {
   }
   return void 0;
 }
-function getProviderSetupSteps(type, providerDefinitions) {
+function getProviderSetupDefinition(type, providerDefinitions) {
   const definition = (0, import_agent_core3.findProviderDefinition)(providerDefinitions, type);
   if (definition === void 0) {
     throw new Error(
       `Unknown provider: ${type}. Currently supported: ${(0, import_agent_core3.formatSupportedProviderTypes)(providerDefinitions)}`
     );
   }
+  return definition;
+}
+function getProviderSetupSteps(definition) {
   if (definition.setupSteps !== void 0) {
     return [...definition.setupSteps];
   }
@@ -847,14 +990,44 @@ function getProviderSetupSteps(type, providerDefinitions) {
   }
   return steps;
 }
+function formatProviderSetupHelpLinkKind(kind) {
+  if (kind === "api-key") {
+    return "API key";
+  }
+  if (kind === "console") {
+    return "Console";
+  }
+  return "Official";
+}
+function applyProviderSetupInitialValues(steps, initialValues) {
+  if (initialValues === void 0) {
+    return [...steps];
+  }
+  return steps.map((step) => {
+    const initialValue = initialValues[step.key];
+    if (initialValue === void 0) {
+      return step;
+    }
+    return {
+      ...step,
+      defaultValue: initialValue,
+      required: false
+    };
+  });
+}
 function buildProviderSetupInput(state) {
+  const profile = state.profileName ?? suggestProviderProfileName(
+    { type: state.type, model: state.values.model },
+    { existingProfileNames: state.existingProfileNames }
+  );
+  const apiKey = state.values.apiKey;
   return {
-    profile: state.type,
+    profile,
     type: state.type,
     model: state.values.model,
-    apiKey: state.values.apiKey,
+    ...apiKey !== void 0 && apiKey.length > 0 && { apiKey },
     ...state.values.baseURL !== void 0 && { baseURL: state.values.baseURL },
-    setCurrent: true
+    setCurrent: state.setCurrent ?? true
   };
 }
 
@@ -943,7 +1116,67 @@ function closeCommandBackgroundTask(context, taskId) {
 var import_agent_core4 = require("@robota-sdk/agent-core");
 var MODEL_COMMAND_DESCRIPTION = "Change AI model";
 var MODEL_COMMAND_ARGUMENT_HINT = "<model-id>";
-function buildModelCommandSubcommands(source = "model") {
+function buildModelCommandSubcommands(sourceOrOptions = "model") {
+  const options = typeof sourceOrOptions === "string" ? { source: sourceOrOptions } : sourceOrOptions;
+  const source = options.source ?? "model";
+  const catalog = resolveActiveProviderModelCatalog(options.settings, options.providerDefinitions);
+  if (catalog !== void 0) {
+    return buildCatalogSubcommands(catalog, source);
+  }
+  if (options.settings !== void 0) {
+    return [];
+  }
+  return buildClaudeModelSubcommands(source);
+}
+function formatModelCommandUsageMessage(options = {}) {
+  const snapshot = resolveActiveProviderModelCatalogSnapshot(
+    options.settings,
+    options.providerDefinitions
+  );
+  return formatModelUsageMessage(snapshot === void 0 ? void 0 : toCatalogState(snapshot));
+}
+async function formatModelCommandUsageMessageAsync(options = {}) {
+  return formatModelUsageMessage(await resolveActiveProviderModelCatalogState(options));
+}
+function resolveActiveProviderModelCatalog(settings, providerDefinitions = []) {
+  return resolveActiveProviderModelCatalogSnapshot(settings, providerDefinitions)?.catalog;
+}
+async function resolveActiveProviderModelCatalogState(options) {
+  const snapshot = resolveActiveProviderModelCatalogSnapshot(
+    options.settings,
+    options.providerDefinitions
+  );
+  if (snapshot === void 0) return void 0;
+  if (options.refresh !== true || snapshot.definition?.refreshModelCatalog === void 0) {
+    return toCatalogState(snapshot);
+  }
+  try {
+    const refreshed = await snapshot.definition.refreshModelCatalog({
+      profile: resolveRefreshProfile(snapshot)
+    });
+    if (refreshed.status !== "unavailable") {
+      return {
+        providerType: snapshot.providerType,
+        catalog: refreshed,
+        refreshAttempted: true
+      };
+    }
+    return {
+      providerType: snapshot.providerType,
+      catalog: snapshot.catalog ?? refreshed,
+      refreshAttempted: true,
+      ...refreshed.message !== void 0 ? { refreshMessage: refreshed.message } : {}
+    };
+  } catch (error) {
+    return {
+      providerType: snapshot.providerType,
+      ...snapshot.catalog !== void 0 ? { catalog: snapshot.catalog } : {},
+      refreshAttempted: true,
+      refreshMessage: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function buildClaudeModelSubcommands(source) {
   const seen = /* @__PURE__ */ new Set();
   const commands = [];
   for (const model of Object.values(import_agent_core4.CLAUDE_MODELS)) {
@@ -957,6 +1190,97 @@ function buildModelCommandSubcommands(source = "model") {
   }
   return commands;
 }
+function buildCatalogSubcommands(catalog, source) {
+  return (catalog.entries ?? []).filter((entry) => entry.lifecycle !== "unavailable").map((entry) => ({
+    name: entry.id,
+    description: formatCatalogEntryDescription(entry),
+    source
+  }));
+}
+function formatCatalogEntryDescription(entry) {
+  if (entry.contextWindow === void 0) {
+    return entry.displayName;
+  }
+  return `${entry.displayName} (${(0, import_agent_core4.formatTokenCount)(entry.contextWindow).toUpperCase()})`;
+}
+function resolveActiveProviderModelCatalogSnapshot(settings, providerDefinitions = []) {
+  const profile = resolveActiveProviderProfile(settings);
+  const providerType = profile?.type ?? profile?.name;
+  if (providerType === void 0) {
+    return void 0;
+  }
+  const definition = (0, import_agent_core4.findProviderDefinition)(providerDefinitions, providerType);
+  return {
+    providerType,
+    ...profile !== void 0 ? { profile } : {},
+    ...definition !== void 0 ? { definition } : {},
+    ...definition?.modelCatalog !== void 0 ? { catalog: definition.modelCatalog } : {}
+  };
+}
+function resolveActiveProviderProfile(settings) {
+  if (settings?.currentProvider !== void 0) {
+    return settings.providers?.[settings.currentProvider];
+  }
+  return settings?.provider;
+}
+function toCatalogState(snapshot) {
+  return {
+    providerType: snapshot.providerType,
+    ...snapshot.catalog !== void 0 ? { catalog: snapshot.catalog } : {},
+    refreshAttempted: false
+  };
+}
+function resolveRefreshProfile(snapshot) {
+  const profile = snapshot.profile;
+  const defaults = snapshot.definition?.defaults;
+  const apiKey = resolveOptionalEnvReference(profile?.apiKey ?? defaults?.apiKey);
+  const model = resolveProfileValue(profile?.model, defaults?.model);
+  const baseURL = resolveProfileValue(profile?.baseURL, defaults?.baseURL);
+  const timeout = resolveProfileValue(profile?.timeout, defaults?.timeout);
+  const options = resolveProfileValue(profile?.options, defaults?.options);
+  const refreshProfile = {
+    type: profile?.type ?? snapshot.providerType
+  };
+  if (model !== void 0) refreshProfile.model = model;
+  if (apiKey !== void 0) refreshProfile.apiKey = apiKey;
+  if (baseURL !== void 0) refreshProfile.baseURL = baseURL;
+  if (timeout !== void 0) refreshProfile.timeout = timeout;
+  if (options !== void 0) refreshProfile.options = options;
+  return refreshProfile;
+}
+function resolveProfileValue(profileValue, defaultValue) {
+  return profileValue ?? defaultValue;
+}
+function resolveOptionalEnvReference(value) {
+  return value === void 0 ? void 0 : resolveEnvReference(value);
+}
+function formatModelUsageMessage(active) {
+  const base = active?.providerType !== void 0 && (active.catalog?.entries === void 0 || active.catalog.entries.length === 0) ? `No model catalog available for provider ${active.providerType}. Usage: model <model-id>` : "Usage: model <model-id>";
+  const freshness = formatCatalogFreshness(active);
+  return freshness === void 0 ? base : `${base}
+${freshness}`;
+}
+function formatCatalogFreshness(active) {
+  const catalog = active?.catalog;
+  if (catalog === void 0) return void 0;
+  const parts = [`Catalog: ${catalog.status}`];
+  if (catalog.entries !== void 0) {
+    parts.push(`${catalog.entries.length} model(s)`);
+  }
+  if (catalog.lastVerifiedAt !== void 0) {
+    parts.push(`verified ${catalog.lastVerifiedAt}`);
+  }
+  if (catalog.sourceUrl !== void 0) {
+    parts.push(`source ${catalog.sourceUrl}`);
+  }
+  const refreshMessage = active?.refreshMessage;
+  if (refreshMessage !== void 0) {
+    parts.push(`refresh ${refreshMessage}`);
+  } else if (catalog.message !== void 0) {
+    parts.push(catalog.message);
+  }
+  return parts.join("; ");
+}
 
 // src/command-api/language/language-command-api.ts
 var LANGUAGE_COMMAND_DESCRIPTION = "Set response language";
@@ -985,7 +1309,7 @@ function formatLanguageUsageMessage(commandName = "language") {
 // src/command-api/permissions/permission-mode-command-api.ts
 var PERMISSION_MODE_COMMAND_DESCRIPTION = "Show/change permission mode";
 var PERMISSION_MODE_ARGUMENT_HINT = "plan | default | acceptEdits | bypassPermissions";
-var PERMISSIONS_COMMAND_DESCRIPTION = "Show permission rules";
+var PERMISSIONS_COMMAND_DESCRIPTION = "Show/change permission mode and permission rules";
 var VALID_PERMISSION_MODES = [
   "plan",
   "default",
@@ -1100,12 +1424,39 @@ function buildPluginCommandSubcommands() {
   ];
 }
 
+// src/command-api/session/session-command-api.ts
+var import_node_path3 = require("path");
+var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
+
+// src/paths.ts
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
+function projectPaths(cwd) {
+  const base = (0, import_node_path2.join)(cwd, ".robota");
+  return {
+    settings: (0, import_node_path2.join)(base, "settings.json"),
+    settingsLocal: (0, import_node_path2.join)(base, "settings.local.json"),
+    logs: (0, import_node_path2.join)(base, "logs"),
+    sessions: (0, import_node_path2.join)(base, "sessions"),
+    memory: (0, import_node_path2.join)(base, "memory"),
+    checkpoints: (0, import_node_path2.join)(base, "checkpoints")
+  };
+}
+function userPaths() {
+  const base = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".robota");
+  return {
+    settings: (0, import_node_path2.join)(base, "settings.json"),
+    sessions: (0, import_node_path2.join)(base, "sessions")
+  };
+}
+
 // src/command-api/session/session-command-api.ts
 var CLEAR_COMMAND_DESCRIPTION = "Clear conversation history";
 var RENAME_COMMAND_DESCRIPTION = "Rename the current session";
 var RENAME_COMMAND_USAGE = "Usage: rename <name>";
 var RESUME_COMMAND_DESCRIPTION = "Resume a previous session";
 var COST_COMMAND_DESCRIPTION = "Show session info";
+var VALIDATE_SESSION_COMMAND_DESCRIPTION = "Validate current session replay log";
 var EXIT_COMMAND_DESCRIPTION = "Exit CLI";
 function clearConversationHistory(context) {
   if (context.clearConversationHistory !== void 0) {
@@ -1134,6 +1485,45 @@ function readCommandSessionInfo(context) {
     messageCount: session.getMessageCount()
   };
 }
+function validateCommandSessionReplayLog(context) {
+  const hostReport = context.validateCurrentSessionReplayLog?.();
+  if (hostReport !== void 0) {
+    return hostReport;
+  }
+  const sessionId = context.getSession().getSessionId();
+  const logFile = (0, import_node_path3.join)(projectPaths(context.getCwd()).logs, `${sessionId}.jsonl`);
+  const entries = (0, import_agent_sessions2.loadSessionLogEntries)(logFile);
+  return {
+    logFile,
+    entryCount: entries.length,
+    validation: (0, import_agent_sessions2.validateSessionReplayLogEntries)(entries)
+  };
+}
+function formatCommandSessionReplayValidationReport(report) {
+  const header = report.validation.ok ? "Session replay log is valid." : `Session replay log has ${report.validation.issues.length} issue(s).`;
+  const details = [`Log: ${report.logFile}`, `Entries: ${report.entryCount}`];
+  if (report.validation.ok) {
+    return [header, ...details].join("\n");
+  }
+  const issueLines = report.validation.issues.map((issue, index) => {
+    const location = formatReplayValidationIssueLocation(issue);
+    return `${index + 1}. ${issue.code}${location}: ${issue.message}`;
+  });
+  return [header, ...details, "", ...issueLines].join("\n");
+}
+function formatReplayValidationIssueLocation(issue) {
+  const parts = [];
+  if (issue.executionId !== void 0) {
+    parts.push(`execution=${issue.executionId}`);
+  }
+  if (issue.round !== void 0) {
+    parts.push(`round=${issue.round}`);
+  }
+  if (issue.toolCallId !== void 0) {
+    parts.push(`tool=${issue.toolCallId}`);
+  }
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
 
 // src/command-api/checkpoint/rewind-command-api.ts
 var REWIND_COMMAND_DESCRIPTION = "List, inspect, restore, or rollback edit checkpoints.";
@@ -1176,10 +1566,10 @@ function containsSensitiveMemoryContent(text) {
 
 // src/memory/pending-memory-store.ts
 var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
+var import_node_path4 = require("path");
 var PENDING_FILENAME = "pending.json";
 function memoryRoot(cwd) {
-  return (0, import_node_path2.join)(cwd, ".robota", "memory");
+  return (0, import_node_path4.join)(cwd, ".robota", "memory");
 }
 function emptyDocument() {
   return { version: 1, records: [] };
@@ -1188,7 +1578,7 @@ var PendingMemoryStore = class {
   path;
   now;
   constructor(cwd, now = () => /* @__PURE__ */ new Date()) {
-    this.path = (0, import_node_path2.join)(memoryRoot(cwd), PENDING_FILENAME);
+    this.path = (0, import_node_path4.join)(memoryRoot(cwd), PENDING_FILENAME);
     this.now = now;
   }
   getPath() {
@@ -1242,7 +1632,7 @@ var PendingMemoryStore = class {
     }
   }
   write(document) {
-    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(this.path), { recursive: true });
+    (0, import_node_fs2.mkdirSync)((0, import_node_path4.dirname)(this.path), { recursive: true });
     (0, import_node_fs2.writeFileSync)(this.path, JSON.stringify(document, null, 2), "utf8");
   }
 };
@@ -1455,24 +1845,6 @@ async function preprocessShellCommands(content) {
   }
   return result;
 }
-async function buildSkillPrompt(input, registry, context) {
-  const parts = input.slice(1).split(/\s+/);
-  const cmd = parts[0]?.toLowerCase() ?? "";
-  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-  if (!skillCmd) return null;
-  const args = parts.slice(1).join(" ").trim();
-  const userInstruction = args || skillCmd.description;
-  if (skillCmd.skillContent) {
-    let processed = await preprocessShellCommands(skillCmd.skillContent);
-    processed = substituteVariables(processed, args, context);
-    return `<skill name="${cmd}">
-${processed}
-</skill>
-
-Execute the "${cmd}" skill: ${userInstruction}`;
-  }
-  return `Use the "${cmd}" skill: ${userInstruction}`;
-}
 
 // src/commands/skill-executor.ts
 async function buildProcessedContent(skill, args, context) {
@@ -1495,7 +1867,9 @@ Execute the "${skill.name}" skill: ${userInstruction}`;
 async function executeSkill(skill, args, callbacks, context) {
   if (skill.context === "fork") {
     if (!callbacks.runInFork) {
-      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
+      throw new Error(
+        "Fork execution is not available. Agent runtime deps may not be initialized."
+      );
     }
     const content = await buildProcessedContent(skill, args, context);
     const prompt2 = content ?? `Use the "${skill.name}" skill: ${args || skill.description}`;
@@ -1509,8 +1883,39 @@ async function executeSkill(skill, args, callbacks, context) {
   return { mode: "inject", prompt };
 }
 
+// src/commands/skill-activation-events.ts
+function getSkillActivationSource(skill) {
+  return skill.source === "plugin" ? "plugin" : "skill";
+}
+function getSkillActivationMode(skill) {
+  return skill.context === "fork" ? "fork" : "inject";
+}
+function createSkillActivationEvent(input) {
+  return {
+    type: "skill-activation",
+    skillName: input.skill.name,
+    source: getSkillActivationSource(input.skill),
+    invocation: input.invocation,
+    mode: getSkillActivationMode(input.skill),
+    status: input.status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input.qualifiedName !== void 0 ? { qualifiedName: input.qualifiedName } : {},
+    ...input.error !== void 0 ? { error: input.error } : {}
+  };
+}
+function formatSkillActivationMessage(event) {
+  const sourceLabel = event.source === "plugin" ? "plugin skill" : "skill";
+  if (event.status === "failed") {
+    return `Skill failed: ${event.skillName}${event.error ? ` (${event.error})` : ""}`;
+  }
+  if (event.status === "completed") {
+    return `Skill completed: ${event.skillName}`;
+  }
+  return `Invoking ${sourceLabel}: ${event.skillName}`;
+}
+
 // src/assembly/create-subagent-session.ts
-var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
 
 // src/assembly/subagent-prompts.ts
 function getSubagentSuffix() {
@@ -1541,12 +1946,147 @@ function assembleSubagentPrompt(options) {
   return parts.join("\n\n");
 }
 
+// src/tools/model-command-tool-projection.ts
+var import_node_crypto = require("crypto");
+var import_zod = require("zod");
+var import_agent_tools = require("@robota-sdk/agent-tools");
+var MODEL_COMMAND_TOOL_PREFIX = "robota_command_";
+var PROVIDER_SAFE_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var MAX_PROVIDER_TOOL_NAME_LENGTH = 64;
+var HASH_LENGTH = 8;
+var HASH_SEPARATOR_LENGTH = 1;
+function asZodSchema(schema) {
+  return schema;
+}
+function normalizeModelCommandName(command) {
+  return command.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
+}
+function createProviderSafeModelCommandToolName(commandName) {
+  const normalizedCommandName = normalizeModelCommandName(commandName);
+  if (!normalizedCommandName) {
+    throw new Error("Model command descriptor name must not be empty.");
+  }
+  const safeBody = normalizedCommandName.replace(/[^A-Za-z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  if (!safeBody) {
+    throw new Error(`Model command descriptor name cannot be projected safely: ${commandName}`);
+  }
+  const rawToolName = `${MODEL_COMMAND_TOOL_PREFIX}${safeBody}`;
+  if (PROVIDER_SAFE_TOOL_NAME_PATTERN.test(rawToolName)) {
+    return rawToolName;
+  }
+  const hash = (0, import_node_crypto.createHash)("sha256").update(normalizedCommandName).digest("hex").slice(0, HASH_LENGTH);
+  const maxBodyLength = MAX_PROVIDER_TOOL_NAME_LENGTH - MODEL_COMMAND_TOOL_PREFIX.length - HASH_SEPARATOR_LENGTH - HASH_LENGTH;
+  if (maxBodyLength < 1) {
+    throw new Error("Model command tool prefix leaves no room for command names.");
+  }
+  const truncatedBody = safeBody.slice(0, maxBodyLength).replace(/[_-]+$/g, "") || "command";
+  const toolName = `${MODEL_COMMAND_TOOL_PREFIX}${truncatedBody}_${hash}`;
+  if (!PROVIDER_SAFE_TOOL_NAME_PATTERN.test(toolName)) {
+    throw new Error(`Projected model command tool name is not provider-safe: ${toolName}`);
+  }
+  return toolName;
+}
+function createModelCommandToolProjection(commandDescriptors) {
+  const commandNames = /* @__PURE__ */ new Set();
+  const toolNameToCommandName = /* @__PURE__ */ new Map();
+  const commandNameToToolName = /* @__PURE__ */ new Map();
+  const commandTools = [];
+  for (const descriptor of commandDescriptors) {
+    const commandName = normalizeModelCommandName(descriptor.name);
+    if (!commandName) {
+      throw new Error("Model command descriptor name must not be empty.");
+    }
+    if (commandNames.has(commandName)) {
+      throw new Error(`Duplicate model command descriptor: ${commandName}`);
+    }
+    commandNames.add(commandName);
+    const toolName = createProviderSafeModelCommandToolName(commandName);
+    const existingCommandName = toolNameToCommandName.get(toolName);
+    if (existingCommandName !== void 0) {
+      throw new Error(
+        `Model command projection collision: ${existingCommandName} and ${commandName} both map to ${toolName}`
+      );
+    }
+    toolNameToCommandName.set(toolName, commandName);
+    commandNameToToolName.set(commandName, toolName);
+    commandTools.push({
+      commandName,
+      toolName,
+      description: formatProjectedModelCommandToolDescription(commandName, descriptor),
+      descriptor
+    });
+  }
+  return {
+    commandTools,
+    toolNameToCommandName,
+    commandNameToToolName
+  };
+}
+function formatProjectedModelCommandToolPromptDescription(projection) {
+  return `${projection.toolName} \u2014 ${projection.descriptor.description}`;
+}
+function stringifyModelCommandResult(command, result) {
+  if (!result) {
+    return JSON.stringify({
+      success: false,
+      command,
+      error: `Unknown command: ${command}`
+    });
+  }
+  return JSON.stringify({
+    success: result.success,
+    command,
+    message: result.message,
+    data: result.data
+  });
+}
+function createProjectedCommandExecutionTools(deps) {
+  const projection = createModelCommandToolProjection(deps.commandDescriptors);
+  return projection.commandTools.map((projectedTool) => {
+    const schema = createProjectedCommandArgsSchema(projectedTool.descriptor);
+    return (0, import_agent_tools.createZodFunctionTool)(
+      projectedTool.toolName,
+      projectedTool.description,
+      asZodSchema(schema),
+      async (params) => {
+        const parsedParams = schema.parse(params);
+        if (!deps.isModelInvocable(projectedTool.commandName)) {
+          return JSON.stringify({
+            success: false,
+            command: projectedTool.commandName,
+            error: `Command is not model-invocable: ${projectedTool.commandName}`
+          });
+        }
+        return stringifyModelCommandResult(
+          projectedTool.commandName,
+          await deps.execute(projectedTool.commandName, parsedParams.args ?? "")
+        );
+      }
+    );
+  });
+}
+function createProjectedCommandArgsSchema(descriptor) {
+  const argsDescription = descriptor.argumentHint ? `Arguments for the command. Expected grammar: ${descriptor.argumentHint}` : "Arguments for the command as a single string.";
+  return import_zod.z.object({
+    args: import_zod.z.string().optional().describe(argsDescription)
+  });
+}
+function formatProjectedModelCommandToolDescription(commandName, descriptor) {
+  const lines = [descriptor.description.trim(), `Robota command id: ${commandName}.`];
+  if (descriptor.argumentHint) {
+    lines.push(`Argument grammar: ${descriptor.argumentHint}`);
+  }
+  return lines.filter((line) => line.length > 0).join("\n\n");
+}
+
 // src/assembly/create-subagent-session.ts
 var MODEL_SHORTCUTS = {
   sonnet: "claude-sonnet-4-6",
   haiku: "claude-haiku-4-5",
   opus: "claude-opus-4-6"
 };
+var LEGACY_AGENT_TOOL_NAME = "Agent";
+var PROJECTED_AGENT_COMMAND_TOOL_NAME = createProviderSafeModelCommandToolName("agent");
 function resolveModelId(shortName, _parentModel) {
   return MODEL_SHORTCUTS[shortName] ?? shortName;
 }
@@ -1560,7 +2100,9 @@ function filterTools(parentTools, agentDefinition) {
     const allowSet = new Set(agentDefinition.tools);
     tools = tools.filter((t) => allowSet.has(t.getName()));
   }
-  tools = tools.filter((t) => t.getName() !== "Agent");
+  tools = tools.filter(
+    (t) => t.getName() !== LEGACY_AGENT_TOOL_NAME && t.getName() !== PROJECTED_AGENT_COMMAND_TOOL_NAME
+  );
   return tools;
 }
 function createSubagentSession(options) {
@@ -1574,7 +2116,7 @@ function createSubagentSession(options) {
     isForkWorker: options.isForkWorker ?? false
   });
   const provider = options.provider;
-  return new import_agent_sessions2.Session({
+  return new import_agent_sessions3.Session({
     tools,
     provider,
     systemMessage,
@@ -1655,8 +2197,8 @@ function getBuiltInAgent(name) {
 }
 
 // src/tools/agent-tool.ts
-var import_zod = require("zod");
-var import_agent_tools = require("@robota-sdk/agent-tools");
+var import_zod2 = require("zod");
+var import_agent_tools2 = require("@robota-sdk/agent-tools");
 var import_agent_runtime = require("@robota-sdk/agent-runtime");
 
 // src/subagents/in-process-subagent-runner.ts
@@ -1886,35 +2428,21 @@ var AGENT_TOOL_DESCRIPTION = [
   "After the tool returns, base user-facing claims on returned mode and counts; do not say parallel or multiple jobs started unless the result proves those jobs started.",
   "Execution is represented by a real tool call and runtime background task event."
 ].join(" ");
-function createAgentToolPromptDescription(agentDefinitions = []) {
-  const availableAgents = agentDefinitions.length > 0 ? ` Available agent types: ${agentDefinitions.map((agent) => `${agent.name} (${agent.description})`).join(", ")}.` : "";
-  return [
-    "Agent \u2014 creates isolated subagent jobs.",
-    "Without jobs, one Agent tool call corresponds to one subagent job.",
-    "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested role and a stable label for each role.",
-    "When the user explicitly asks to create, run, spawn, delegate to, or use agents/subagents, start the requested subagent job immediately.",
-    "Do not ask a follow-up question unless execution is impossible or unsafe.",
-    "The tool returns terminal result data with mode, requestedJobCount, startedJobCount, failedJobCount, and provenance.",
-    "After the tool returns, base user-facing claims on returned mode and counts; do not say parallel or multiple jobs started unless the result proves those jobs started.",
-    "Runtime mode is background.",
-    availableAgents
-  ].join(" ").replace(/\s+/g, " ").trim();
-}
-function asZodSchema(schema) {
+function asZodSchema2(schema) {
   return schema;
 }
-var AgentSchema = import_zod.z.object({
-  prompt: import_zod.z.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
-  subagent_type: import_zod.z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
-  model: import_zod.z.string().optional().describe("Optional model override"),
-  isolation: import_zod.z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
-  jobs: import_zod.z.array(
-    import_zod.z.object({
-      label: import_zod.z.string().optional().describe("Stable role label for this batch job"),
-      prompt: import_zod.z.string().describe("The task for this subagent to perform"),
-      subagent_type: import_zod.z.string().optional().describe("Agent type for this job"),
-      model: import_zod.z.string().optional().describe("Optional model override for this job"),
-      isolation: import_zod.z.enum(["none", "worktree"]).optional().describe("Isolation for this job")
+var AgentSchema = import_zod2.z.object({
+  prompt: import_zod2.z.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
+  subagent_type: import_zod2.z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: import_zod2.z.string().optional().describe("Optional model override"),
+  isolation: import_zod2.z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
+  jobs: import_zod2.z.array(
+    import_zod2.z.object({
+      label: import_zod2.z.string().optional().describe("Stable role label for this batch job"),
+      prompt: import_zod2.z.string().describe("The task for this subagent to perform"),
+      subagent_type: import_zod2.z.string().optional().describe("Agent type for this job"),
+      model: import_zod2.z.string().optional().describe("Optional model override for this job"),
+      isolation: import_zod2.z.enum(["none", "worktree"]).optional().describe("Isolation for this job")
     }).passthrough()
   ).optional().describe("Batch of subagent jobs to start in one Agent tool call")
 }).passthrough();
@@ -2039,10 +2567,10 @@ async function runManagedAgent(args, deps, manager) {
 }
 function createAgentTool(deps) {
   const manager = createSubagentManager(deps);
-  return (0, import_agent_tools.createZodFunctionTool)(
+  return (0, import_agent_tools2.createZodFunctionTool)(
     "Agent",
     AGENT_TOOL_DESCRIPTION,
-    asZodSchema(AgentSchema),
+    asZodSchema2(AgentSchema),
     async (params) => {
       const args = params;
       if (Array.isArray(args.jobs) && args.jobs.length > 0) {
@@ -2144,8 +2672,8 @@ var BackgroundJobOrchestrator = class {
   createRecord(state) {
     let resolveGroup = () => {
     };
-    const completion = new Promise((resolve4) => {
-      resolveGroup = resolve4;
+    const completion = new Promise((resolve6) => {
+      resolveGroup = resolve6;
     });
     return { state, completion, resolve: resolveGroup };
   }
@@ -2270,8 +2798,385 @@ function retrieveSessionBackgroundTaskManager(key) {
 }
 
 // src/interactive/interactive-session-execution.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_agent_core5 = require("@robota-sdk/agent-core");
+
+// src/context/context-reference-inventory.ts
+var DEFAULT_MAX_ACTIVE_REFERENCES = Number("8");
+var BYTES_PER_KIB = Number("1024");
+var DEFAULT_MAX_ACTIVE_BYTES = Number("256") * BYTES_PER_KIB;
+var DEFAULT_MAX_OBSERVED_REFERENCES = Number("32");
+function createContextReferenceItem(record, loadType, status, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    id: `${loadType}:${record.relativePath}`,
+    sourcePath: record.sourcePath,
+    relativePath: record.relativePath,
+    originalReference: record.originalReference,
+    loadType,
+    status,
+    byteLength: record.byteLength,
+    loadedAt: timestamp,
+    lastUsedAt: timestamp
+  };
+}
+function upsertContextReference(references, item, limits) {
+  const existing = references.find((reference) => reference.sourcePath === item.sourcePath);
+  const retained = references.filter((reference) => reference.sourcePath !== item.sourcePath);
+  const nextItem = existing ? mergeContextReference(existing, item) : item;
+  return enforceContextReferenceLimits([...retained, nextItem], limits);
+}
+function removeContextReference(references, query) {
+  const normalized = normalizeReferenceQuery(query);
+  const removed = references.find((reference) => matchesContextReference(reference, normalized));
+  if (!removed) return { references: [...references], result: {} };
+  return {
+    references: references.filter((reference) => reference.sourcePath !== removed.sourcePath),
+    result: { removed }
+  };
+}
+function clearContextReferences(references) {
+  return { removed: [...references] };
+}
+function listActiveContextReferences(references) {
+  return references.filter((reference) => reference.status === "active");
+}
+function toContextReferenceRecords(references) {
+  return references.map((reference) => ({
+    originalReference: reference.originalReference,
+    sourcePath: reference.sourcePath,
+    relativePath: reference.relativePath,
+    reason: reference.loadType,
+    depth: 0,
+    byteLength: reference.byteLength
+  }));
+}
+function mergeContextReference(existing, incoming) {
+  if (incoming.status === "active") return { ...incoming, loadedAt: existing.loadedAt };
+  return {
+    ...existing,
+    byteLength: incoming.byteLength,
+    originalReference: incoming.originalReference,
+    lastUsedAt: incoming.lastUsedAt
+  };
+}
+function enforceContextReferenceLimits(references, limits) {
+  const maxActiveReferences = limits?.maxActiveReferences ?? DEFAULT_MAX_ACTIVE_REFERENCES;
+  const maxActiveBytes = limits?.maxActiveBytes ?? DEFAULT_MAX_ACTIVE_BYTES;
+  const maxObservedReferences = limits?.maxObservedReferences ?? DEFAULT_MAX_OBSERVED_REFERENCES;
+  const evicted = [];
+  let next = [...references];
+  while (countActiveReferences(next) > maxActiveReferences || countActiveBytes(next) > maxActiveBytes) {
+    const candidate = next.find((reference) => reference.status === "active");
+    if (!candidate) break;
+    evicted.push(candidate);
+    next = next.filter((reference) => reference.sourcePath !== candidate.sourcePath);
+  }
+  const observed = next.filter((reference) => reference.status === "observed");
+  if (observed.length > maxObservedReferences) {
+    const overflow = observed.slice(0, observed.length - maxObservedReferences);
+    evicted.push(...overflow);
+    next = next.filter(
+      (reference) => reference.status !== "observed" || !overflow.some((removed) => removed.sourcePath === reference.sourcePath)
+    );
+  }
+  return { references: next, evicted };
+}
+function countActiveReferences(references) {
+  return references.filter((reference) => reference.status === "active").length;
+}
+function countActiveBytes(references) {
+  return references.reduce(
+    (total, reference) => total + (reference.status === "active" ? reference.byteLength : 0),
+    0
+  );
+}
+function normalizeReferenceQuery(query) {
+  return query.startsWith("@") ? query.slice(1) : query;
+}
+function matchesContextReference(reference, query) {
+  return reference.relativePath === query || reference.sourcePath === query || reference.originalReference === query || reference.originalReference === `@${query}`;
+}
+
+// src/context/prompt-file-reference-format.ts
+var import_node_crypto2 = require("crypto");
+function buildPromptWithFileReferences(input, references) {
+  if (references.length === 0) return input;
+  const blocks = references.map((reference) => {
+    const content = reference.content.replaceAll("</file>", "<\\/file>");
+    return [
+      `<file path="${escapeAttribute(reference.relativePath)}" bytes="${reference.byteLength}" reason="${reference.reason}">`,
+      content,
+      "</file>"
+    ].join("\n");
+  });
+  return [input, "<robota_file_references>", ...blocks, "</robota_file_references>"].join("\n\n");
+}
+function hasBlockingPromptFileReferenceDiagnostics(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+function formatPromptFileReferenceDiagnostics(diagnostics) {
+  if (diagnostics.length === 0) return "";
+  return [
+    "File reference error:",
+    ...diagnostics.map((diagnostic) => `- ${diagnostic.reference}: ${diagnostic.message}`)
+  ].join("\n");
+}
+function toPromptFileReferenceRecords(references) {
+  return references.map(({ content: _content, ...record }) => record);
+}
+function createPromptFileReferenceHistoryEntry(references) {
+  const records = toPromptFileReferenceRecords(references);
+  return {
+    id: `prompt_file_reference_${(0, import_node_crypto2.randomUUID)()}`,
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "prompt-file-reference",
+    data: {
+      message: formatLoadedPromptFileReferencesMessage(records),
+      references: records
+    }
+  };
+}
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function formatLoadedPromptFileReferencesMessage(references) {
+  const list = references.map((reference) => `${reference.relativePath} (${reference.byteLength} B)`).join(", ");
+  return `Loaded file references: ${list}`;
+}
+
+// src/context/prompt-file-reference-parser.ts
+var REFERENCE_PATTERN = /(^|[\s([{])@([^\s)\]}>,;"'`]+)/g;
+function parsePromptFileReferences(input) {
+  const references = [];
+  for (const match of input.matchAll(REFERENCE_PATTERN)) {
+    const token = stripTrailingPunctuation(match[2] ?? "");
+    if (!isPathLikeReference(token)) continue;
+    references.push({
+      original: `@${token}`,
+      path: token,
+      index: match.index ?? 0
+    });
+  }
+  return references;
+}
+function stripTrailingPunctuation(token) {
+  let end = token.length;
+  while (end > 0 && /[.,:;!?]/.test(token[end - 1] ?? "")) {
+    end -= 1;
+  }
+  return token.slice(0, end);
+}
+function isPathLikeReference(referencePath) {
+  if (referencePath.length === 0) return false;
+  if (referencePath.includes("://")) return false;
+  return referencePath.startsWith("./") || referencePath.startsWith("../") || referencePath.startsWith("/") || referencePath.startsWith("~/") || referencePath.startsWith(".") || referencePath.includes(".");
+}
+
+// src/context/prompt-file-reference-resolver.ts
+var import_promises = require("fs/promises");
+var import_node_path6 = require("path");
+
+// src/context/prompt-file-reference-paths.ts
+var import_node_os3 = require("os");
+var import_node_path5 = require("path");
+function resolveCandidatePath(referencePath, rootPath) {
+  if (referencePath.startsWith("~/")) {
+    return (0, import_node_path5.resolve)((0, import_node_os3.homedir)(), referencePath.slice("~/".length));
+  }
+  if ((0, import_node_path5.isAbsolute)(referencePath)) {
+    return (0, import_node_path5.resolve)(referencePath);
+  }
+  return (0, import_node_path5.resolve)(rootPath, referencePath);
+}
+function isPathWithinRoot(candidatePath, rootPath) {
+  const relativePath = (0, import_node_path5.relative)(rootPath, candidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !(0, import_node_path5.isAbsolute)(relativePath);
+}
+function normalizeRelativePath(rootPath, sourcePath) {
+  return (0, import_node_path5.relative)(rootPath, sourcePath).split(import_node_path5.sep).join("/");
+}
+
+// src/context/prompt-file-reference-resolver.ts
+var DEFAULT_MAX_DEPTH = Number("2");
+var DEFAULT_MAX_REFERENCES = Number("8");
+var BYTES_PER_KIB2 = Number("1024");
+var DEFAULT_MAX_FILE_BYTES = Number("64") * BYTES_PER_KIB2;
+var DEFAULT_MAX_TOTAL_BYTES = Number("256") * BYTES_PER_KIB2;
+async function resolvePromptFileReferences(input, options) {
+  const state = await createResolveState(options);
+  for (const reference of parsePromptFileReferences(input)) {
+    await resolveReference(reference, 0, [], state);
+  }
+  return toResolvedReferences(state);
+}
+async function resolvePromptFileReferencePaths(referencePaths, options) {
+  const state = await createResolveState(options);
+  for (const referencePath of referencePaths) {
+    await resolveReference(
+      { original: `@${referencePath}`, path: referencePath, index: 0 },
+      0,
+      [],
+      state
+    );
+  }
+  return toResolvedReferences(state);
+}
+async function createResolveState(options) {
+  return {
+    rootPath: await resolveWorkspaceRoot(options.cwd),
+    limits: resolveLimits(options.limits),
+    reason: options.reason ?? "prompt-reference",
+    references: [],
+    diagnostics: [],
+    loadedPaths: /* @__PURE__ */ new Set(),
+    totalBytes: 0
+  };
+}
+function toResolvedReferences(state) {
+  return {
+    references: state.references,
+    diagnostics: state.diagnostics
+  };
+}
+function resolveLimits(limits) {
+  return {
+    maxDepth: limits?.maxDepth ?? DEFAULT_MAX_DEPTH,
+    maxReferences: limits?.maxReferences ?? DEFAULT_MAX_REFERENCES,
+    maxFileBytes: limits?.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES,
+    maxTotalBytes: limits?.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES
+  };
+}
+async function resolveWorkspaceRoot(cwd) {
+  try {
+    return await (0, import_promises.realpath)(cwd);
+  } catch {
+    return (0, import_node_path6.resolve)(cwd);
+  }
+}
+async function resolveReference(reference, depth, activePaths, state) {
+  if (!checkReferenceBudget(reference, depth, state)) return;
+  const sourcePath = await resolveReferencePath(reference, state);
+  if (sourcePath === void 0) return;
+  if (!checkReferenceCycleAndDuplicate(reference, sourcePath, activePaths, state)) return;
+  const fileInfo = await inspectReferenceFile(reference, sourcePath, state);
+  if (fileInfo === void 0) return;
+  const content = await readReferenceFile(reference, sourcePath, state);
+  if (content === void 0) return;
+  state.loadedPaths.add(sourcePath);
+  state.totalBytes += fileInfo.byteLength;
+  state.references.push(buildResolvedReference(reference, fileInfo, depth, content, state));
+  await resolveNestedReferences(content, depth, [...activePaths, sourcePath], state);
+}
+function checkReferenceBudget(reference, depth, state) {
+  if (state.references.length >= state.limits.maxReferences) {
+    pushDiagnostic(state, "too-many-references", reference, "Too many file references.");
+    return false;
+  }
+  if (depth > state.limits.maxDepth) {
+    pushDiagnostic(state, "max-depth", reference, "File reference nesting is too deep.");
+    return false;
+  }
+  return true;
+}
+async function resolveReferencePath(reference, state) {
+  const candidatePath = resolveCandidatePath(reference.path, state.rootPath);
+  if (!isPathWithinRoot(candidatePath, state.rootPath)) {
+    pushDiagnostic(state, "outside-root", reference, "Referenced path is outside the workspace.");
+    return void 0;
+  }
+  try {
+    const sourcePath = await (0, import_promises.realpath)(candidatePath);
+    if (isPathWithinRoot(sourcePath, state.rootPath)) return sourcePath;
+    pushDiagnostic(
+      state,
+      "outside-root",
+      reference,
+      "Referenced path resolves outside the workspace."
+    );
+  } catch {
+    pushDiagnostic(state, "not-found", reference, "Referenced file was not found.");
+  }
+  return void 0;
+}
+function checkReferenceCycleAndDuplicate(reference, sourcePath, activePaths, state) {
+  if (activePaths.includes(sourcePath)) {
+    pushDiagnostic(state, "circular-reference", reference, "Circular file reference detected.");
+    return false;
+  }
+  return !state.loadedPaths.has(sourcePath);
+}
+async function inspectReferenceFile(reference, sourcePath, state) {
+  try {
+    const fileStat = await (0, import_promises.stat)(sourcePath);
+    if (fileStat.isDirectory()) {
+      pushDiagnostic(
+        state,
+        "directory-not-supported",
+        reference,
+        "Directory references are not supported."
+      );
+      return void 0;
+    }
+    if (fileStat.size > state.limits.maxFileBytes) {
+      pushDiagnostic(
+        state,
+        "file-too-large",
+        reference,
+        "Referenced file exceeds the per-file size limit."
+      );
+      return void 0;
+    }
+    if (state.totalBytes + fileStat.size > state.limits.maxTotalBytes) {
+      pushDiagnostic(
+        state,
+        "total-too-large",
+        reference,
+        "Referenced files exceed the total size limit."
+      );
+      return void 0;
+    }
+    return { sourcePath, byteLength: fileStat.size };
+  } catch {
+    pushDiagnostic(state, "unreadable", reference, "Referenced file could not be inspected.");
+    return void 0;
+  }
+}
+async function readReferenceFile(reference, sourcePath, state) {
+  try {
+    return await (0, import_promises.readFile)(sourcePath, "utf8");
+  } catch {
+    pushDiagnostic(state, "unreadable", reference, "Referenced file could not be read.");
+    return void 0;
+  }
+}
+function buildResolvedReference(reference, fileInfo, depth, content, state) {
+  return {
+    originalReference: reference.original,
+    sourcePath: fileInfo.sourcePath,
+    relativePath: normalizeRelativePath(state.rootPath, fileInfo.sourcePath),
+    reason: state.reason,
+    depth,
+    byteLength: fileInfo.byteLength,
+    content
+  };
+}
+async function resolveNestedReferences(content, depth, activePaths, state) {
+  for (const nestedReference of parsePromptFileReferences(content)) {
+    await resolveReference(nestedReference, depth + 1, activePaths, state);
+  }
+}
+function pushDiagnostic(state, code, reference, message) {
+  state.diagnostics.push({
+    code,
+    severity: "error",
+    reference: reference.original,
+    message,
+    path: reference.path
+  });
+}
+
+// src/interactive/interactive-session-execution.ts
 function isAbortError(err) {
   return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
 }
@@ -2287,7 +3192,7 @@ function extractToolSummaries(history, historyBefore) {
   }
   return summaries;
 }
-function buildResult(response, sessionHistory, interactiveHistory, historyBefore, contextState) {
+function buildResult(response, sessionHistory, interactiveHistory, historyBefore, contextState, promptFileReferences) {
   const toolSummaries = extractToolSummaries(sessionHistory, historyBefore);
   const usage = extractTurnUsage(sessionHistory, historyBefore, contextState);
   return {
@@ -2295,7 +3200,8 @@ function buildResult(response, sessionHistory, interactiveHistory, historyBefore
     history: interactiveHistory,
     toolSummaries,
     contextState,
-    ...usage && { usage }
+    ...usage && { usage },
+    ...promptFileReferences && promptFileReferences.length > 0 ? { promptFileReferences: [...promptFileReferences] } : {}
   };
 }
 function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefore, contextState) {
@@ -2316,13 +3222,50 @@ function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefor
 }
 function createUsageSummaryEntry(usage) {
   return {
-    id: `usage_${(0, import_node_crypto.randomUUID)()}`,
+    id: `usage_${(0, import_node_crypto3.randomUUID)()}`,
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "usage-summary",
     data: usage
   };
 }
+async function preparePromptInput(input, cwd, rawInput, contextReferences = []) {
+  const activeReferenceResult = await resolvePromptFileReferencePaths(
+    listActiveContextReferences(contextReferences).map((reference) => reference.sourcePath),
+    { cwd, reason: "manual" }
+  );
+  const promptFileReferenceResult = await resolvePromptFileReferences(input, { cwd });
+  const diagnostics = [
+    ...activeReferenceResult.diagnostics,
+    ...promptFileReferenceResult.diagnostics
+  ];
+  if (hasBlockingPromptFileReferenceDiagnostics(diagnostics)) {
+    throw new Error(formatPromptFileReferenceDiagnostics(diagnostics));
+  }
+  const resolvedReferences = dedupeResolvedReferences([
+    ...activeReferenceResult.references,
+    ...promptFileReferenceResult.references
+  ]);
+  const modelInput = buildPromptWithFileReferences(input, resolvedReferences);
+  const hookInput = rawInput ?? (modelInput === input ? void 0 : input);
+  const activeContextReferenceRecords = toPromptFileReferenceRecords(
+    activeReferenceResult.references
+  );
+  const promptFileReferenceRecords = toPromptFileReferenceRecords(
+    promptFileReferenceResult.references
+  );
+  const promptFileReferenceEntry = promptFileReferenceResult.references.length > 0 ? createPromptFileReferenceHistoryEntry(promptFileReferenceResult.references) : void 0;
+  return {
+    modelInput,
+    ...hookInput !== void 0 ? { hookInput } : {},
+    activeContextReferenceRecords,
+    promptFileReferenceRecords,
+    ...promptFileReferenceEntry !== void 0 ? { promptFileReferenceEntry } : {}
+  };
+}
+function dedupeResolvedReferences(references) {
+  return [...new Map(references.map((reference) => [reference.sourcePath, reference])).values()];
+}
 function extractTurnUsage(sessionHistory, historyBefore, contextState) {
   const turnMessages = sessionHistory.slice(historyBefore);
   let promptTokens = 0;
@@ -2349,34 +3292,6 @@ function extractTurnUsage(sessionHistory, historyBefore, contextState) {
     costStatus: "unknown"
   };
 }
-function persistSession(sessionStore, session, sessionName, cwd, history, backgroundState, memoryState) {
-  try {
-    const sessionId = session.getSessionId();
-    const existing = sessionStore.load(sessionId);
-    sessionStore.save({
-      id: sessionId,
-      name: sessionName ?? existing?.name,
-      cwd,
-      createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      messages: session.getHistory(),
-      history,
-      systemPrompt: session.getSystemMessage(),
-      toolSchemas: session.getToolSchemas(),
-      ...backgroundState ? {
-        backgroundTasks: [...backgroundState.tasks],
-        backgroundTaskEvents: [...backgroundState.events],
-        backgroundJobGroups: [...backgroundState.groups ?? []],
-        backgroundJobGroupEvents: [...backgroundState.groupEvents ?? []]
-      } : {},
-      ...memoryState ? {
-        memoryEvents: [...memoryState.events],
-        usedMemoryReferences: [...memoryState.usedReferences]
-      } : {}
-    });
-  } catch {
-  }
-}
 var NOOP_TERMINAL = {
   write: () => {
   },
@@ -2393,8 +3308,75 @@ var NOOP_TERMINAL = {
   } })
 };
 
+// src/interactive/interactive-session-persistence.ts
+function persistSession(sessionStore, session, sessionName, cwd, history, backgroundState, memoryState, skillActivationState, contextReferenceState, sandboxState) {
+  try {
+    const sessionId = session.getSessionId();
+    const existing = sessionStore.load(sessionId);
+    const sandboxSnapshotId = sandboxState?.snapshotId ?? existing?.sandboxSnapshotId;
+    sessionStore.save(
+      buildInteractiveSessionRecord({
+        session,
+        sessionId,
+        sessionName: sessionName ?? existing?.name,
+        cwd,
+        history,
+        createdAt: existing?.createdAt,
+        backgroundState,
+        memoryState,
+        skillActivationState,
+        contextReferenceState,
+        ...sandboxSnapshotId !== void 0 ? { sandboxSnapshotId } : {}
+      })
+    );
+  } catch {
+  }
+}
+function buildInteractiveSessionRecord(input) {
+  return {
+    id: input.sessionId,
+    ...input.sessionName !== void 0 ? { name: input.sessionName } : {},
+    cwd: input.cwd,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    messages: input.session.getHistory(),
+    history: input.history,
+    systemPrompt: input.session.getSystemMessage(),
+    toolSchemas: input.session.getToolSchemas(),
+    ...input.sandboxSnapshotId !== void 0 ? { sandboxSnapshotId: input.sandboxSnapshotId } : {},
+    ...buildBackgroundRecordFields(input.backgroundState),
+    ...buildMemoryRecordFields(input.memoryState),
+    ...buildSkillActivationRecordFields(input.skillActivationState),
+    ...buildContextReferenceRecordFields(input.contextReferenceState)
+  };
+}
+function buildBackgroundRecordFields(state) {
+  if (!state) return {};
+  return {
+    backgroundTasks: [...state.tasks],
+    backgroundTaskEvents: [...state.events],
+    backgroundJobGroups: [...state.groups ?? []],
+    backgroundJobGroupEvents: [...state.groupEvents ?? []]
+  };
+}
+function buildMemoryRecordFields(state) {
+  if (!state) return {};
+  return {
+    memoryEvents: [...state.events],
+    usedMemoryReferences: [...state.usedReferences]
+  };
+}
+function buildSkillActivationRecordFields(state) {
+  if (!state) return {};
+  return { skillActivationEvents: [...state.events] };
+}
+function buildContextReferenceRecordFields(state) {
+  if (!state) return {};
+  return { contextReferences: [...state.references] };
+}
+
 // src/interactive/interactive-session-streaming.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var import_node_fs3 = require("fs");
 var TOOL_ARG_DISPLAY_MAX = 80;
 var TAIL_KEEP = 30;
@@ -2492,7 +3474,7 @@ function pushToolSummaryToHistory(state) {
     return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
   }).join("\n");
   state.history.push({
-    id: (0, import_node_crypto2.randomUUID)(),
+    id: (0, import_node_crypto4.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-summary",
@@ -2528,7 +3510,7 @@ function applyToolStart(state, event) {
   const toolState = { toolName: event.toolName, firstArg, isRunning: true };
   state.activeTools.push(toolState);
   state.history.push({
-    id: (0, import_node_crypto2.randomUUID)(),
+    id: (0, import_node_crypto4.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-start",
@@ -2550,7 +3532,7 @@ function applyToolEnd(state, event) {
   state.activeTools[idx] = finished;
   state.activeTools = trimCompletedTools(state.activeTools);
   state.history.push({
-    id: (0, import_node_crypto2.randomUUID)(),
+    id: (0, import_node_crypto4.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-end",
@@ -2570,110 +3552,110 @@ var import_fs2 = require("fs");
 var import_path2 = require("path");
 
 // src/config/config-types.ts
-var import_zod2 = require("zod");
-var UniversalValueSchema = import_zod2.z.lazy(
-  () => import_zod2.z.union([
-    import_zod2.z.string(),
-    import_zod2.z.number(),
-    import_zod2.z.boolean(),
-    import_zod2.z.null(),
-    import_zod2.z.undefined(),
-    import_zod2.z.date(),
-    import_zod2.z.array(UniversalValueSchema),
-    import_zod2.z.record(UniversalValueSchema)
+var import_zod3 = require("zod");
+var UniversalValueSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    import_zod3.z.string(),
+    import_zod3.z.number(),
+    import_zod3.z.boolean(),
+    import_zod3.z.null(),
+    import_zod3.z.undefined(),
+    import_zod3.z.date(),
+    import_zod3.z.array(UniversalValueSchema),
+    import_zod3.z.record(UniversalValueSchema)
   ])
 );
-var ProviderSchema = import_zod2.z.object({
-  name: import_zod2.z.string().optional(),
-  model: import_zod2.z.string().optional(),
-  apiKey: import_zod2.z.string().optional(),
-  baseURL: import_zod2.z.string().optional(),
-  timeout: import_zod2.z.number().optional(),
-  options: import_zod2.z.record(UniversalValueSchema).optional()
+var ProviderSchema = import_zod3.z.object({
+  name: import_zod3.z.string().optional(),
+  model: import_zod3.z.string().optional(),
+  apiKey: import_zod3.z.string().optional(),
+  baseURL: import_zod3.z.string().optional(),
+  timeout: import_zod3.z.number().optional(),
+  options: import_zod3.z.record(UniversalValueSchema).optional()
 });
-var ProviderProfileSchema = import_zod2.z.object({
-  type: import_zod2.z.string().optional(),
-  model: import_zod2.z.string().optional(),
-  apiKey: import_zod2.z.string().optional(),
-  baseURL: import_zod2.z.string().optional(),
-  timeout: import_zod2.z.number().optional(),
-  options: import_zod2.z.record(UniversalValueSchema).optional()
+var ProviderProfileSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  model: import_zod3.z.string().optional(),
+  apiKey: import_zod3.z.string().optional(),
+  baseURL: import_zod3.z.string().optional(),
+  timeout: import_zod3.z.number().optional(),
+  options: import_zod3.z.record(UniversalValueSchema).optional()
 });
-var PermissionsSchema = import_zod2.z.object({
+var PermissionsSchema = import_zod3.z.object({
   /** Patterns that are always approved without prompting */
-  allow: import_zod2.z.array(import_zod2.z.string()).optional(),
+  allow: import_zod3.z.array(import_zod3.z.string()).optional(),
   /** Patterns that are always denied */
-  deny: import_zod2.z.array(import_zod2.z.string()).optional()
+  deny: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var EnvSchema = import_zod2.z.record(import_zod2.z.string()).optional();
-var CommandHookDefinitionSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("command"),
-  command: import_zod2.z.string(),
-  timeout: import_zod2.z.number().optional()
+var EnvSchema = import_zod3.z.record(import_zod3.z.string()).optional();
+var CommandHookDefinitionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("command"),
+  command: import_zod3.z.string(),
+  timeout: import_zod3.z.number().optional()
 });
-var HttpHookDefinitionSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("http"),
-  url: import_zod2.z.string(),
-  headers: import_zod2.z.record(import_zod2.z.string()).optional(),
-  timeout: import_zod2.z.number().optional()
+var HttpHookDefinitionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("http"),
+  url: import_zod3.z.string(),
+  headers: import_zod3.z.record(import_zod3.z.string()).optional(),
+  timeout: import_zod3.z.number().optional()
 });
-var PromptHookDefinitionSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("prompt"),
-  prompt: import_zod2.z.string(),
-  model: import_zod2.z.string().optional()
+var PromptHookDefinitionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("prompt"),
+  prompt: import_zod3.z.string(),
+  model: import_zod3.z.string().optional()
 });
-var AgentHookDefinitionSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("agent"),
-  agent: import_zod2.z.string(),
-  maxTurns: import_zod2.z.number().optional(),
-  timeout: import_zod2.z.number().optional()
+var AgentHookDefinitionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("agent"),
+  agent: import_zod3.z.string(),
+  maxTurns: import_zod3.z.number().optional(),
+  timeout: import_zod3.z.number().optional()
 });
-var HookDefinitionSchema = import_zod2.z.discriminatedUnion("type", [
+var HookDefinitionSchema = import_zod3.z.discriminatedUnion("type", [
   CommandHookDefinitionSchema,
   HttpHookDefinitionSchema,
   PromptHookDefinitionSchema,
   AgentHookDefinitionSchema
 ]);
-var HookGroupSchema = import_zod2.z.object({
-  matcher: import_zod2.z.string(),
-  hooks: import_zod2.z.array(HookDefinitionSchema)
+var HookGroupSchema = import_zod3.z.object({
+  matcher: import_zod3.z.string(),
+  hooks: import_zod3.z.array(HookDefinitionSchema)
 });
-var HooksSchema = import_zod2.z.object({
-  PreToolUse: import_zod2.z.array(HookGroupSchema).optional(),
-  PostToolUse: import_zod2.z.array(HookGroupSchema).optional(),
-  SessionStart: import_zod2.z.array(HookGroupSchema).optional(),
-  SessionEnd: import_zod2.z.array(HookGroupSchema).optional(),
-  Stop: import_zod2.z.array(HookGroupSchema).optional(),
-  StopFailure: import_zod2.z.array(HookGroupSchema).optional(),
-  PreCompact: import_zod2.z.array(HookGroupSchema).optional(),
-  PostCompact: import_zod2.z.array(HookGroupSchema).optional(),
-  UserPromptSubmit: import_zod2.z.array(HookGroupSchema).optional(),
-  SubagentStart: import_zod2.z.array(HookGroupSchema).optional(),
-  SubagentStop: import_zod2.z.array(HookGroupSchema).optional(),
-  WorktreeCreate: import_zod2.z.array(HookGroupSchema).optional(),
-  WorktreeRemove: import_zod2.z.array(HookGroupSchema).optional()
+var HooksSchema = import_zod3.z.object({
+  PreToolUse: import_zod3.z.array(HookGroupSchema).optional(),
+  PostToolUse: import_zod3.z.array(HookGroupSchema).optional(),
+  SessionStart: import_zod3.z.array(HookGroupSchema).optional(),
+  SessionEnd: import_zod3.z.array(HookGroupSchema).optional(),
+  Stop: import_zod3.z.array(HookGroupSchema).optional(),
+  StopFailure: import_zod3.z.array(HookGroupSchema).optional(),
+  PreCompact: import_zod3.z.array(HookGroupSchema).optional(),
+  PostCompact: import_zod3.z.array(HookGroupSchema).optional(),
+  UserPromptSubmit: import_zod3.z.array(HookGroupSchema).optional(),
+  SubagentStart: import_zod3.z.array(HookGroupSchema).optional(),
+  SubagentStop: import_zod3.z.array(HookGroupSchema).optional(),
+  WorktreeCreate: import_zod3.z.array(HookGroupSchema).optional(),
+  WorktreeRemove: import_zod3.z.array(HookGroupSchema).optional()
 }).optional();
-var EnabledPluginsSchema = import_zod2.z.record(import_zod2.z.boolean()).optional();
-var MarketplaceSourceSchema = import_zod2.z.object({
-  source: import_zod2.z.object({
-    type: import_zod2.z.enum(["github", "git", "local", "url"]),
-    repo: import_zod2.z.string().optional(),
-    url: import_zod2.z.string().optional(),
-    path: import_zod2.z.string().optional(),
-    ref: import_zod2.z.string().optional()
+var EnabledPluginsSchema = import_zod3.z.record(import_zod3.z.boolean()).optional();
+var MarketplaceSourceSchema = import_zod3.z.object({
+  source: import_zod3.z.object({
+    type: import_zod3.z.enum(["github", "git", "local", "url"]),
+    repo: import_zod3.z.string().optional(),
+    url: import_zod3.z.string().optional(),
+    path: import_zod3.z.string().optional(),
+    ref: import_zod3.z.string().optional()
   })
 });
-var ExtraKnownMarketplacesSchema = import_zod2.z.record(MarketplaceSourceSchema).optional().catch(void 0);
-var AutoCompactThresholdSchema = import_zod2.z.union([import_zod2.z.number().gt(0).lte(1), import_zod2.z.literal(false)]).optional();
-var SettingsSchema = import_zod2.z.object({
+var ExtraKnownMarketplacesSchema = import_zod3.z.record(MarketplaceSourceSchema).optional().catch(void 0);
+var AutoCompactThresholdSchema = import_zod3.z.union([import_zod3.z.number().gt(0).lte(1), import_zod3.z.literal(false)]).optional();
+var SettingsSchema = import_zod3.z.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: import_zod2.z.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: import_zod3.z.enum(["safe", "moderate", "full"]).optional(),
   /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: import_zod2.z.string().optional(),
+  language: import_zod3.z.string().optional(),
   /** Active provider profile key from providers. */
-  currentProvider: import_zod2.z.string().optional(),
+  currentProvider: import_zod3.z.string().optional(),
   /** Provider profiles keyed by user-facing profile name. */
-  providers: import_zod2.z.record(ProviderProfileSchema).optional(),
+  providers: import_zod3.z.record(ProviderProfileSchema).optional(),
   /** Legacy single-provider settings. Prefer currentProvider + providers for new config. */
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
@@ -2727,18 +3709,12 @@ function resolveEnvRef(value) {
   return value;
 }
 function resolveEnvRefs(settings) {
-  const provider = settings.provider?.apiKey !== void 0 ? {
-    ...settings.provider,
-    apiKey: resolveEnvRef(settings.provider.apiKey)
-  } : settings.provider;
+  const provider = settings.provider?.apiKey !== void 0 ? resolveProviderCredentialEnvRefs(settings.provider) : settings.provider;
   if (settings.providers !== void 0) {
     const providers = Object.fromEntries(
       Object.entries(settings.providers).map(([name, profile]) => [
         name,
-        {
-          ...profile,
-          ...profile.apiKey !== void 0 && { apiKey: resolveEnvRef(profile.apiKey) }
-        }
+        resolveProviderCredentialEnvRefs(profile)
       ])
     );
     return {
@@ -2752,6 +3728,12 @@ function resolveEnvRefs(settings) {
     provider
   };
 }
+function resolveProviderCredentialEnvRefs(provider) {
+  return {
+    ...provider,
+    ...provider.apiKey !== void 0 && { apiKey: resolveEnvRef(provider.apiKey) }
+  };
+}
 function mergeSettings(layers) {
   return layers.reduce((merged, layer) => {
     return {
@@ -2785,22 +3767,32 @@ function mergeProviders(base, override) {
 }
 function resolveProvider(merged) {
   if (merged.currentProvider !== void 0) {
-    const profile = merged.providers?.[merged.currentProvider];
-    if (profile === void 0) {
-      throw new Error(`currentProvider "${merged.currentProvider}" was not found in providers`);
-    }
-    if (profile.type === void 0) {
-      throw new Error(`Provider profile "${merged.currentProvider}" is missing type`);
-    }
-    return {
-      name: profile.type,
-      model: profile.model ?? DEFAULTS.provider.model,
-      apiKey: profile.apiKey ?? DEFAULTS.provider.apiKey,
-      ...profile.baseURL !== void 0 && { baseURL: profile.baseURL },
-      ...profile.timeout !== void 0 && { timeout: profile.timeout },
-      ...profile.options !== void 0 && { options: profile.options }
-    };
+    return resolveActiveProviderProfile2(merged);
+  }
+  return resolveLegacyProvider(merged);
+}
+function resolveActiveProviderProfile2(merged) {
+  const currentProvider = merged.currentProvider;
+  if (currentProvider === void 0) {
+    throw new Error("currentProvider is required");
   }
+  const profile = merged.providers?.[currentProvider];
+  if (profile === void 0) {
+    throw new Error(`currentProvider "${currentProvider}" was not found in providers`);
+  }
+  if (profile.type === void 0) {
+    throw new Error(`Provider profile "${currentProvider}" is missing type`);
+  }
+  return {
+    name: profile.type,
+    model: profile.model ?? DEFAULTS.provider.model,
+    apiKey: profile.apiKey ?? DEFAULTS.provider.apiKey,
+    ...profile.baseURL !== void 0 && { baseURL: profile.baseURL },
+    ...profile.timeout !== void 0 && { timeout: profile.timeout },
+    ...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,
@@ -2972,7 +3964,7 @@ Respond with JSON: { "ok": boolean, "reason"?: string }`;
 };
 
 // src/assembly/create-session.ts
-var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
 
 // src/context/system-prompt-composer.ts
 function renderSection(section) {
@@ -3077,9 +4069,15 @@ function formatCapability(descriptor) {
   return `- ${descriptor.name}${arg}: ${descriptor.description}`;
 }
 function createCapabilityKindSection(kind, title, priority, source, descriptors) {
-  const content = descriptors.filter((descriptor) => descriptor.modelInvocable && descriptor.kind === kind).map(formatCapability).join("\n");
-  if (content.trim().length === 0) return void 0;
-  return createSection(`capability-${kind}`, title, priority, content, source);
+  const formattedDescriptors = descriptors.filter((descriptor) => descriptor.modelInvocable && descriptor.kind === kind).map(formatCapability);
+  if (formattedDescriptors.length === 0) return void 0;
+  return createSection(
+    `capability-${kind}`,
+    title,
+    priority,
+    formattedDescriptors.join("\n"),
+    source
+  );
 }
 function createCapabilitySections(descriptors) {
   const sections = [];
@@ -3146,7 +4144,7 @@ function buildSystemPrompt(params) {
 }
 
 // src/assembly/create-tools.ts
-var import_agent_tools2 = require("@robota-sdk/agent-tools");
+var import_agent_tools3 = require("@robota-sdk/agent-tools");
 var DEFAULT_TOOL_DESCRIPTIONS = [
   "Bash \u2014 execute shell commands",
   "Read \u2014 read file contents with line numbers",
@@ -3157,32 +4155,32 @@ var DEFAULT_TOOL_DESCRIPTIONS = [
   "WebFetch \u2014 fetch URL content as text",
   "WebSearch \u2014 search the internet through the configured local tool"
 ];
-function createDefaultTools() {
+function createDefaultTools(options = {}) {
   return [
-    import_agent_tools2.bashTool,
-    import_agent_tools2.readTool,
-    import_agent_tools2.writeTool,
-    import_agent_tools2.editTool,
-    import_agent_tools2.globTool,
-    import_agent_tools2.grepTool,
-    import_agent_tools2.webFetchTool,
-    import_agent_tools2.webSearchTool
+    (0, import_agent_tools3.createBashTool)(options),
+    (0, import_agent_tools3.createReadTool)(options),
+    (0, import_agent_tools3.createWriteTool)(options),
+    (0, import_agent_tools3.createEditTool)(options),
+    import_agent_tools3.globTool,
+    import_agent_tools3.grepTool,
+    import_agent_tools3.webFetchTool,
+    import_agent_tools3.webSearchTool
   ];
 }
 
 // src/tools/background-process-tool.ts
-var import_zod3 = require("zod");
-var import_agent_tools3 = require("@robota-sdk/agent-tools");
+var import_zod4 = require("zod");
+var import_agent_tools4 = require("@robota-sdk/agent-tools");
 var DEFAULT_PROCESS_TIMEOUT_MS = 12e4;
-function asZodSchema2(schema) {
+function asZodSchema3(schema) {
   return schema;
 }
-var BackgroundProcessSchema = import_zod3.z.object({
-  command: import_zod3.z.string().describe("The shell command to start in the background"),
-  timeout: import_zod3.z.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
-  workingDirectory: import_zod3.z.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
-  stdin: import_zod3.z.string().optional().describe("Optional stdin to write after the process starts."),
-  outputLimitBytes: import_zod3.z.number().optional().describe("Maximum captured output bytes kept in the task result.")
+var BackgroundProcessSchema = import_zod4.z.object({
+  command: import_zod4.z.string().describe("The shell command to start in the background"),
+  timeout: import_zod4.z.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
+  workingDirectory: import_zod4.z.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
+  stdin: import_zod4.z.string().optional().describe("Optional stdin to write after the process starts."),
+  outputLimitBytes: import_zod4.z.number().optional().describe("Maximum captured output bytes kept in the task result.")
 });
 function stringifyStarted(taskId, status, command) {
   return JSON.stringify({
@@ -3222,59 +4220,11 @@ async function startBackgroundProcess(args, deps) {
   }
 }
 function createBackgroundProcessTool(deps) {
-  return (0, import_agent_tools3.createZodFunctionTool)(
-    "BackgroundProcess",
-    "Start a shell command as a managed background task. Use this for long-running commands that should not block the current conversation. Use /background list, /background read <taskId>, /background cancel <taskId>, or /background close <taskId> to inspect or control it.",
-    asZodSchema2(BackgroundProcessSchema),
-    async (params) => startBackgroundProcess(params, deps)
-  );
-}
-
-// src/tools/command-execution-tool.ts
-var import_zod4 = require("zod");
-var import_agent_tools4 = require("@robota-sdk/agent-tools");
-var CommandExecutionSchema = import_zod4.z.object({
-  command: import_zod4.z.string().describe("Command name to execute, with or without a leading slash"),
-  args: import_zod4.z.string().optional().describe("Arguments to pass to the command")
-});
-function asZodSchema3(schema) {
-  return schema;
-}
-function normalizeCommand(command) {
-  return command.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
-}
-function stringifyCommandResult(command, result) {
-  if (!result) {
-    return JSON.stringify({
-      success: false,
-      command,
-      error: `Unknown command: ${command}`
-    });
-  }
-  return JSON.stringify({
-    success: result.success,
-    command,
-    message: result.message,
-    data: result.data
-  });
-}
-function createCommandExecutionTool(deps) {
   return (0, import_agent_tools4.createZodFunctionTool)(
-    "ExecuteCommand",
-    "Executes a registered model-invocable Robota command through the command registry. Accepted command names and argument grammar come from registered command descriptors.",
-    asZodSchema3(CommandExecutionSchema),
-    async (params) => {
-      const args = CommandExecutionSchema.parse(params);
-      const command = normalizeCommand(args.command);
-      if (!deps.isModelInvocable(command)) {
-        return JSON.stringify({
-          success: false,
-          command,
-          error: `Command is not model-invocable: ${command}`
-        });
-      }
-      return stringifyCommandResult(command, await deps.execute(command, args.args ?? ""));
-    }
+    "BackgroundProcess",
+    "Start a shell command as a managed background task. Use this for long-running commands that should not block the current conversation. Use /background list, /background read <taskId>, /background cancel <taskId>, or /background close <taskId> to inspect or control it.",
+    asZodSchema3(BackgroundProcessSchema),
+    async (params) => startBackgroundProcess(params, deps)
   );
 }
 
@@ -3338,6 +4288,9 @@ function evaluateReversibleToolSafety(input) {
     };
   }
   if (FILE_MUTATION_TOOLS.has(toolName)) {
+    if (input.context.isolation === "worktree" || input.context.isolation === "provider-sandbox") {
+      return evaluateIsolatedSideEffect(toolName, "file-mutation", input.context);
+    }
     if (input.context.checkpointAvailable) {
       return {
         toolName,
@@ -3520,8 +4473,8 @@ var import_agent_runtime6 = require("@robota-sdk/agent-runtime");
 
 // src/agents/agent-definition-loader.ts
 var import_node_fs4 = require("fs");
-var import_node_path3 = require("path");
-var import_node_os2 = require("os");
+var import_node_path7 = require("path");
+var import_node_os4 = require("os");
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
 var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
 function parseListValue2(rawValue) {
@@ -3575,10 +4528,10 @@ function scanAgentsDir(dir) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = (0, import_node_path3.join)(dir, entry.name);
+    const filePath = (0, import_node_path7.join)(dir, entry.name);
     const content = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter2(content);
-    const fallbackName = (0, import_node_path3.basename)(entry.name, ".md");
+    const fallbackName = (0, import_node_path7.basename)(entry.name, ".md");
     const agent = {
       name: frontmatter?.name ?? fallbackName,
       description: frontmatter?.description ?? "",
@@ -3598,16 +4551,16 @@ var AgentDefinitionLoader = class {
   home;
   constructor(cwd, home) {
     this.cwd = cwd;
-    this.home = home ?? (0, import_node_os2.homedir)();
+    this.home = home ?? (0, import_node_os4.homedir)();
   }
   /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
   loadAll() {
     const sources = [
-      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".robota", "agents")),
-      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".agents", "agents")),
-      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".claude", "agents")),
-      scanAgentsDir((0, import_node_path3.join)(this.home, ".robota", "agents")),
-      scanAgentsDir((0, import_node_path3.join)(this.home, ".claude", "agents"))
+      scanAgentsDir((0, import_node_path7.join)(this.cwd, ".robota", "agents")),
+      scanAgentsDir((0, import_node_path7.join)(this.cwd, ".agents", "agents")),
+      scanAgentsDir((0, import_node_path7.join)(this.cwd, ".claude", "agents")),
+      scanAgentsDir((0, import_node_path7.join)(this.home, ".robota", "agents")),
+      scanAgentsDir((0, import_node_path7.join)(this.home, ".claude", "agents"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const customAgents = [];
@@ -3676,6 +4629,17 @@ function fireSubagentLifecycleHook(event, cwd, hooks, hookTypeExecutors) {
 var ID_RADIX = 36;
 var ID_RANDOM_LENGTH = 9;
 var DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 12e4;
+function getModelInvocableCommandDescriptors(descriptors) {
+  return (descriptors ?? []).filter(
+    (descriptor) => descriptor.modelInvocable && descriptor.kind === "builtin-command"
+  );
+}
+function normalizeCommandDescriptorName(name) {
+  return name.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
+}
+function hasModelInvocableCommandDescriptor(descriptors, name) {
+  return descriptors.some((descriptor) => normalizeCommandDescriptorName(descriptor.name) === name);
+}
 function createSession(options) {
   if (!options.provider) {
     throw new Error(
@@ -3685,17 +4649,34 @@ function createSession(options) {
   const provider = options.provider;
   const cwd = options.cwd ?? process.cwd();
   const sessionId = options.sessionId ?? createSessionId();
-  const defaultTools = options.editCheckpointRecorder ? wrapEditCheckpointTools(createDefaultTools(), options.editCheckpointRecorder) : createDefaultTools();
+  const skillCommandSource = new SkillCommandSource(cwd);
+  const modelInvocableCommandDescriptors = getModelInvocableCommandDescriptors(
+    options.commandDescriptors
+  );
+  const modelCommandToolsEnabled = modelInvocableCommandDescriptors.length > 0 && options.modelCommandExecutor !== void 0 && options.isModelCommandInvocable !== void 0;
+  const modelCommandToolProjection = modelCommandToolsEnabled ? createModelCommandToolProjection(modelInvocableCommandDescriptors) : void 0;
+  const modelVisibleSkills = hasModelInvocableCommandDescriptor(
+    modelInvocableCommandDescriptors,
+    "skills"
+  ) ? skillCommandSource.getModelInvocableSkills() : [];
+  const baseDefaultTools = createDefaultTools({ sandboxClient: options.sandboxClient });
+  const shouldWrapHostEditCheckpoints = options.editCheckpointRecorder !== void 0 && options.sandboxClient === void 0;
+  const defaultTools = shouldWrapHostEditCheckpoints && options.editCheckpointRecorder ? wrapEditCheckpointTools(baseDefaultTools, options.editCheckpointRecorder) : baseDefaultTools;
   const assembledTools = [...defaultTools, ...options.additionalTools ?? []];
-  const tools = options.reversibleExecution ? wrapReversibleExecutionTools(assembledTools, {
+  const reversibleExecution = options.reversibleExecution ? {
     ...options.reversibleExecution,
-    checkpointAvailable: options.editCheckpointRecorder !== void 0
+    isolation: options.reversibleExecution.isolation ?? (options.sandboxClient ? "provider-sandbox" : void 0)
+  } : void 0;
+  const tools = reversibleExecution ? wrapReversibleExecutionTools(assembledTools, {
+    ...reversibleExecution,
+    checkpointAvailable: shouldWrapHostEditCheckpoints
   }) : assembledTools;
-  if (options.modelCommandExecutor && options.isModelCommandInvocable) {
+  if (modelCommandToolsEnabled && options.modelCommandExecutor !== void 0 && options.isModelCommandInvocable !== void 0) {
     tools.push(
-      createCommandExecutionTool({
+      ...createProjectedCommandExecutionTools({
         execute: options.modelCommandExecutor,
-        isModelInvocable: options.isModelCommandInvocable
+        isModelInvocable: options.isModelCommandInvocable,
+        commandDescriptors: modelInvocableCommandDescriptors
       })
     );
   }
@@ -3778,14 +4759,12 @@ function createSession(options) {
     };
     tools.push(createBackgroundProcessTool(backgroundProcessToolDeps));
   }
-  if (agentToolDeps) {
-    tools.push(createAgentTool(agentToolDeps));
-  }
   const buildPrompt = options.systemPromptBuilder ?? buildSystemPrompt;
   const defaultToolDescriptions = [
     ...DEFAULT_TOOL_DESCRIPTIONS,
-    ...agentToolDeps ? [createAgentToolPromptDescription(agentDefinitions)] : [],
-    ...options.modelCommandExecutor ? ["ExecuteCommand \u2014 execute model-invocable Robota commands"] : []
+    ...modelCommandToolProjection ? modelCommandToolProjection.commandTools.map(
+      formatProjectedModelCommandToolPromptDescription
+    ) : []
   ];
   const systemMessage = buildPrompt({
     agentsMd: options.context.agentsMd,
@@ -3800,7 +4779,7 @@ function createSession(options) {
     projectInfo: options.projectInfo ?? { type: "unknown", language: "unknown" },
     cwd,
     language: options.config.language,
-    skills: new SkillCommandSource(cwd).getModelInvocableSkills().map((skill) => ({
+    skills: modelVisibleSkills.map((skill) => ({
       name: skill.name,
       description: skill.description,
       disableModelInvocation: skill.disableModelInvocation
@@ -3829,7 +4808,7 @@ ${options.appendSystemPrompt}` : systemMessage;
     allow: [...defaultAllow, ...options.config.permissions.allow ?? [], ...allowedToolPatterns],
     deny: options.config.permissions.deny ?? []
   };
-  const SessionWithAutoCompact = import_agent_sessions3.Session;
+  const SessionWithAutoCompact = import_agent_sessions4.Session;
   const session = new SessionWithAutoCompact({
     tools,
     provider,
@@ -3874,41 +4853,19 @@ function logBackgroundTaskEvent(logger, sessionId, event) {
 
 // src/assembly/subagent-logger.ts
 var import_node_fs5 = require("fs");
-var import_node_path4 = require("path");
-var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+var import_node_path8 = require("path");
+var import_agent_sessions5 = require("@robota-sdk/agent-sessions");
 function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
-  const subagentDir = (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
+  const subagentDir = (0, import_node_path8.join)(baseLogsDir, parentSessionId, "subagents");
   (0, import_node_fs5.mkdirSync)(subagentDir, { recursive: true });
-  return new import_agent_sessions4.FileSessionLogger(subagentDir);
+  return new import_agent_sessions5.FileSessionLogger(subagentDir);
 }
 function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
-  return (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
+  return (0, import_node_path8.join)(baseLogsDir, parentSessionId, "subagents");
 }
 
 // src/interactive/interactive-session-init.ts
-var import_agent_sessions5 = require("@robota-sdk/agent-sessions");
-
-// src/paths.ts
-var import_node_path5 = require("path");
-var import_node_os3 = require("os");
-function projectPaths(cwd) {
-  const base = (0, import_node_path5.join)(cwd, ".robota");
-  return {
-    settings: (0, import_node_path5.join)(base, "settings.json"),
-    settingsLocal: (0, import_node_path5.join)(base, "settings.local.json"),
-    logs: (0, import_node_path5.join)(base, "logs"),
-    sessions: (0, import_node_path5.join)(base, "sessions"),
-    memory: (0, import_node_path5.join)(base, "memory"),
-    checkpoints: (0, import_node_path5.join)(base, "checkpoints")
-  };
-}
-function userPaths() {
-  const base = (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".robota");
-  return {
-    settings: (0, import_node_path5.join)(base, "settings.json"),
-    sessions: (0, import_node_path5.join)(base, "sessions")
-  };
-}
+var import_agent_sessions6 = require("@robota-sdk/agent-sessions");
 
 // src/context/context-loader.ts
 var import_fs3 = require("fs");
@@ -3916,8 +4873,8 @@ var import_path3 = require("path");
 
 // src/context/task-context.ts
 var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
-var TASKS_DIR = (0, import_node_path6.join)(".agents", "tasks");
+var import_node_path9 = require("path");
+var TASKS_DIR = (0, import_node_path9.join)(".agents", "tasks");
 var README_FILENAME = "README.md";
 var MARKDOWN_EXTENSION = ".md";
 var DEFAULT_MAX_TASKS = Number("3");
@@ -3937,7 +4894,7 @@ function normalizeStatus(value) {
 }
 function extractTitle(content, taskPath) {
   const heading = content.split(/\r?\n/).find((line) => /^#\s+/.test(line));
-  return heading?.replace(/^#\s+/, "").trim() || (0, import_node_path6.basename)(taskPath, MARKDOWN_EXTENSION);
+  return heading?.replace(/^#\s+/, "").trim() || (0, import_node_path9.basename)(taskPath, MARKDOWN_EXTENSION);
 }
 function extractMetadata(content, key) {
   const matcher = new RegExp(`^- \\*\\*${key}\\*\\*:\\s*(.+)$`, "im");
@@ -4017,18 +4974,18 @@ function appendProgressEntry(content, now, progressMessage) {
   return lines.join("\n");
 }
 function resolveGitDirectory(cwd) {
-  let current = (0, import_node_path6.resolve)(cwd);
+  let current = (0, import_node_path9.resolve)(cwd);
   let reachedRoot = false;
   while (!reachedRoot) {
-    const gitPath = (0, import_node_path6.join)(current, ".git");
+    const gitPath = (0, import_node_path9.join)(current, ".git");
     if ((0, import_node_fs6.existsSync)(gitPath)) {
       const stats = (0, import_node_fs6.statSync)(gitPath);
       if (stats.isDirectory()) return gitPath;
       const content = (0, import_node_fs6.readFileSync)(gitPath, "utf8").trim();
       const gitdir = content.match(/^gitdir:\s*(.+)$/)?.[1];
-      if (gitdir) return (0, import_node_path6.isAbsolute)(gitdir) ? gitdir : (0, import_node_path6.resolve)(current, gitdir);
+      if (gitdir) return (0, import_node_path9.isAbsolute)(gitdir) ? gitdir : (0, import_node_path9.resolve)(current, gitdir);
     }
-    const parent = (0, import_node_path6.dirname)(current);
+    const parent = (0, import_node_path9.dirname)(current);
     reachedRoot = parent === current;
     current = parent;
   }
@@ -4037,24 +4994,24 @@ function resolveGitDirectory(cwd) {
 function readCurrentGitBranch(cwd) {
   const gitDir = resolveGitDirectory(cwd);
   if (!gitDir) return void 0;
-  const headPath = (0, import_node_path6.join)(gitDir, "HEAD");
+  const headPath = (0, import_node_path9.join)(gitDir, "HEAD");
   if (!(0, import_node_fs6.existsSync)(headPath)) return void 0;
   const head = (0, import_node_fs6.readFileSync)(headPath, "utf8").trim();
   const branch = head.match(/^ref:\s+refs\/heads\/(.+)$/)?.[1];
   return branch?.trim();
 }
 function discoverTaskFiles(cwd) {
-  const tasksDir = (0, import_node_path6.join)(cwd, TASKS_DIR);
+  const tasksDir = (0, import_node_path9.join)(cwd, TASKS_DIR);
   if (!(0, import_node_fs6.existsSync)(tasksDir)) {
     return [];
   }
-  return (0, import_node_fs6.readdirSync)(tasksDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name !== README_FILENAME && name.endsWith(MARKDOWN_EXTENSION)).sort((a, b) => a.localeCompare(b)).map((name) => (0, import_node_path6.join)(tasksDir, name));
+  return (0, import_node_fs6.readdirSync)(tasksDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name !== README_FILENAME && name.endsWith(MARKDOWN_EXTENSION)).sort((a, b) => a.localeCompare(b)).map((name) => (0, import_node_path9.join)(tasksDir, name));
 }
 function parseTaskFile(taskPath, cwd) {
   const content = (0, import_node_fs6.readFileSync)(taskPath, "utf8");
   return {
     path: taskPath,
-    relativePath: (0, import_node_path6.relative)(cwd, taskPath),
+    relativePath: (0, import_node_path9.relative)(cwd, taskPath),
     title: extractTitle(content, taskPath),
     status: normalizeStatus(extractMetadata(content, "Status")),
     branch: extractMetadata(content, "Branch"),
@@ -4209,7 +5166,7 @@ async function detectProject(cwd) {
 
 // src/plugins/plugin-settings-store.ts
 var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_path10 = require("path");
 var PluginSettingsStore = class {
   settingsPath;
   constructor(settingsPath) {
@@ -4233,7 +5190,7 @@ var PluginSettingsStore = class {
   }
   /** Write the full settings file to disk. */
   writeAll(settings) {
-    const dir = (0, import_node_path7.dirname)(this.settingsPath);
+    const dir = (0, import_node_path10.dirname)(this.settingsPath);
     if (!(0, import_node_fs7.existsSync)(dir)) {
       (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
     }
@@ -4310,7 +5267,7 @@ var PluginSettingsStore = class {
 
 // src/plugins/bundle-plugin-loader.ts
 var import_node_fs9 = require("fs");
-var import_node_path8 = require("path");
+var import_node_path11 = require("path");
 
 // src/plugins/bundle-plugin-utils.ts
 var import_node_fs8 = require("fs");
@@ -4394,22 +5351,22 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = (0, import_node_path8.join)(this.pluginsDir, "cache");
+    const cacheDir = (0, import_node_path11.join)(this.pluginsDir, "cache");
     if (!(0, import_node_fs9.existsSync)(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = (0, import_node_path8.join)(cacheDir, marketplace);
+      const marketplaceDir = (0, import_node_path11.join)(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = (0, import_node_path8.join)(marketplaceDir, pluginName);
+        const pluginDir = (0, import_node_path11.join)(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = (0, import_node_path8.join)(pluginDir, latestVersion);
-        const manifestPath = (0, import_node_path8.join)(versionDir, ".claude-plugin", "plugin.json");
+        const versionDir = (0, import_node_path11.join)(pluginDir, latestVersion);
+        const manifestPath = (0, import_node_path11.join)(versionDir, ".claude-plugin", "plugin.json");
         if (!(0, import_node_fs9.existsSync)(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
@@ -4459,13 +5416,13 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = (0, import_node_path8.join)(pluginDir, "skills");
+    const skillsDir = (0, import_node_path11.join)(pluginDir, "skills");
     if (!(0, import_node_fs9.existsSync)(skillsDir)) return [];
     const entries = (0, import_node_fs9.readdirSync)(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = (0, import_node_path8.join)(skillsDir, entry.name, "SKILL.md");
+      const skillFile = (0, import_node_path11.join)(skillsDir, entry.name, "SKILL.md");
       if (!(0, import_node_fs9.existsSync)(skillFile)) continue;
       const raw = (0, import_node_fs9.readFileSync)(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
@@ -4482,13 +5439,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = (0, import_node_path8.join)(pluginDir, "commands");
+    const commandsDir = (0, import_node_path11.join)(pluginDir, "commands");
     if (!(0, import_node_fs9.existsSync)(commandsDir)) return [];
     const entries = (0, import_node_fs9.readdirSync)(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = (0, import_node_fs9.readFileSync)((0, import_node_path8.join)(commandsDir, entry.name), "utf-8");
+      const raw = (0, import_node_fs9.readFileSync)((0, import_node_path11.join)(commandsDir, entry.name), "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
       const description = typeof metadata.description === "string" ? metadata.description : "";
@@ -4503,7 +5460,7 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = (0, import_node_path8.join)(pluginDir, "hooks", "hooks.json");
+    const hooksPath = (0, import_node_path11.join)(pluginDir, "hooks", "hooks.json");
     if (!(0, import_node_fs9.existsSync)(hooksPath)) return {};
     try {
       const raw = (0, import_node_fs9.readFileSync)(hooksPath, "utf-8");
@@ -4518,8 +5475,8 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = (0, import_node_path8.join)(pluginDir, ".mcp.json");
-    const fallbackPath = (0, import_node_path8.join)(pluginDir, ".claude-plugin", "mcp.json");
+    const primaryPath = (0, import_node_path11.join)(pluginDir, ".mcp.json");
+    const fallbackPath = (0, import_node_path11.join)(pluginDir, ".claude-plugin", "mcp.json");
     const mcpPath = (0, import_node_fs9.existsSync)(primaryPath) ? primaryPath : fallbackPath;
     if (!(0, import_node_fs9.existsSync)(mcpPath)) return void 0;
     try {
@@ -4531,7 +5488,7 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = (0, import_node_path8.join)(pluginDir, "agents");
+    const agentsDir = (0, import_node_path11.join)(pluginDir, "agents");
     if (!(0, import_node_fs9.existsSync)(agentsDir)) return [];
     try {
       const entries = (0, import_node_fs9.readdirSync)(agentsDir, { withFileTypes: true });
@@ -4545,7 +5502,7 @@ var BundlePluginLoader = class {
 // src/plugins/bundle-plugin-installer.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs10 = require("fs");
-var import_node_path9 = require("path");
+var import_node_path12 = require("path");
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -4556,8 +5513,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = (0, import_node_path9.join)(this.pluginsDir, "cache");
-    this.registryPath = (0, import_node_path9.join)(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = (0, import_node_path12.join)(this.pluginsDir, "cache");
+    this.registryPath = (0, import_node_path12.join)(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -4577,7 +5534,7 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = (0, import_node_path9.join)(this.cacheDir, marketplaceName, pluginName, version);
+    const targetDir = (0, import_node_path12.join)(this.cacheDir, marketplaceName, pluginName, version);
     if ((0, import_node_fs10.existsSync)(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
@@ -4657,7 +5614,7 @@ var BundlePluginInstaller = class {
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = (0, import_node_path9.join)(marketplaceDir, source);
+        const sourcePath = (0, import_node_path12.join)(marketplaceDir, source);
         if (!(0, import_node_fs10.existsSync)(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
@@ -4710,7 +5667,7 @@ var BundlePluginInstaller = class {
   }
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
-    const dir = (0, import_node_path9.dirname)(this.registryPath);
+    const dir = (0, import_node_path12.dirname)(this.registryPath);
     if (!(0, import_node_fs10.existsSync)(dir)) {
       (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
     }
@@ -4725,11 +5682,11 @@ var BundlePluginInstaller = class {
 // src/plugins/marketplace-client.ts
 var import_node_child_process3 = require("child_process");
 var import_node_fs12 = require("fs");
-var import_node_path11 = require("path");
+var import_node_path14 = require("path");
 
 // src/plugins/marketplace-registry.ts
 var import_node_fs11 = require("fs");
-var import_node_path10 = require("path");
+var import_node_path13 = require("path");
 function readRegistry(registryPath) {
   if (!(0, import_node_fs11.existsSync)(registryPath)) {
     return {};
@@ -4746,14 +5703,14 @@ function readRegistry(registryPath) {
   }
 }
 function writeRegistry(registryPath, registry) {
-  const dir = (0, import_node_path10.dirname)(registryPath);
+  const dir = (0, import_node_path13.dirname)(registryPath);
   if (!(0, import_node_fs11.existsSync)(dir)) {
     (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
   }
   (0, import_node_fs11.writeFileSync)(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
-  const installedPath = (0, import_node_path10.join)(pluginsDir, "installed_plugins.json");
+  const installedPath = (0, import_node_path13.join)(pluginsDir, "installed_plugins.json");
   if (!(0, import_node_fs11.existsSync)(installedPath)) return;
   let registry;
   try {
@@ -4775,7 +5732,7 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
     }
   }
   if (changed) {
-    const dir = (0, import_node_path10.dirname)(installedPath);
+    const dir = (0, import_node_path13.dirname)(installedPath);
     if (!(0, import_node_fs11.existsSync)(dir)) {
       (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
     }
@@ -4793,8 +5750,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = (0, import_node_path11.join)(this.pluginsDir, "marketplaces");
-    this.registryPath = (0, import_node_path11.join)(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = (0, import_node_path14.join)(this.pluginsDir, "marketplaces");
+    this.registryPath = (0, import_node_path14.join)(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -4807,7 +5764,7 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = (0, import_node_path11.join)(this.marketplacesDir, tempName);
+    const tempDir = (0, import_node_path14.join)(this.marketplacesDir, tempName);
     (0, import_node_fs12.mkdirSync)(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
       if (!(0, import_node_fs12.existsSync)(source.path)) {
@@ -4824,7 +5781,7 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = (0, import_node_path11.join)(tempDir, ".claude-plugin", "marketplace.json");
+    const manifestPath = (0, import_node_path14.join)(tempDir, ".claude-plugin", "marketplace.json");
     if (!(0, import_node_fs12.existsSync)(manifestPath)) {
       (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(
@@ -4842,7 +5799,7 @@ var MarketplaceClient = class {
       (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = (0, import_node_path11.join)(this.marketplacesDir, name);
+    const finalDir = (0, import_node_path14.join)(this.marketplacesDir, name);
     (0, import_node_fs12.renameSync)(tempDir, finalDir);
     registry[name] = {
       source,
@@ -4919,7 +5876,7 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = (0, import_node_path11.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
+    const manifestPath = (0, import_node_path14.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
     if (!(0, import_node_fs12.existsSync)(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
@@ -5001,9 +5958,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-var import_node_path12 = require("path");
+var import_node_path15 = require("path");
 function buildPluginEnv(plugin) {
-  const dataDir = (0, import_node_path12.join)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = (0, import_node_path15.join)((0, import_node_path15.dirname)((0, import_node_path15.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -5065,8 +6022,9 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
 }
 
 // src/interactive/interactive-session-init.ts
-var import_node_os4 = require("os");
-var import_node_path13 = require("path");
+var import_node_os5 = require("os");
+var import_node_path16 = require("path");
+var import_agent_tools5 = require("@robota-sdk/agent-tools");
 async function createInteractiveSession(options) {
   const cwd = options.cwd;
   const [config, context, projectInfo] = await Promise.all([
@@ -5074,7 +6032,7 @@ async function createInteractiveSession(options) {
     options.bare ? Promise.resolve({ agentsMd: "", claudeMd: "" }) : loadContext(cwd),
     options.bare ? Promise.resolve({ type: "unknown", language: "unknown" }) : detectProject(cwd)
   ]);
-  const pluginsDir = (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".robota", "plugins");
+  const pluginsDir = (0, import_node_path16.join)((0, import_node_os5.homedir)(), ".robota", "plugins");
   const pluginLoader = new BundlePluginLoader(pluginsDir);
   let mergedConfig = config;
   if (!options.bare) {
@@ -5094,6 +6052,10 @@ async function createInteractiveSession(options) {
     }
   }
   const paths = projectPaths(cwd);
+  const sandboxRestored = await restoreInteractiveSandboxSnapshot(options);
+  if (!sandboxRestored) {
+    await applyInteractiveWorkspaceManifest(options, cwd);
+  }
   const sessionId = options.resumeSessionId && !options.forkSession ? options.resumeSessionId : void 0;
   return createSession({
     config: mergedConfig,
@@ -5103,7 +6065,7 @@ async function createInteractiveSession(options) {
     permissionMode: options.permissionMode,
     maxTurns: options.maxTurns,
     terminal: NOOP_TERMINAL,
-    sessionLogger: new import_agent_sessions5.FileSessionLogger(paths.logs),
+    sessionLogger: new import_agent_sessions6.FileSessionLogger(paths.logs),
     permissionHandler: options.permissionHandler,
     provider: options.provider,
     onTextDelta: options.onTextDelta,
@@ -5127,20 +6089,37 @@ async function createInteractiveSession(options) {
     modelCommandExecutor: options.modelCommandExecutor,
     isModelCommandInvocable: options.isModelCommandInvocable,
     editCheckpointRecorder: options.editCheckpointRecorder,
-    reversibleExecution: options.reversibleExecution
+    reversibleExecution: options.reversibleExecution,
+    sandboxClient: options.sandboxClient
   });
 }
+async function applyInteractiveWorkspaceManifest(options, cwd) {
+  if (!options.workspaceManifest) return;
+  if (!options.sandboxClient) {
+    throw new Error("workspaceManifest requires sandboxClient.");
+  }
+  await (0, import_agent_tools5.applyWorkspaceManifest)(options.sandboxClient, options.workspaceManifest, {
+    hostRoot: cwd,
+    ...options.sandboxWorkspaceRoot ? { targetRoot: options.sandboxWorkspaceRoot } : {}
+  });
+}
+async function restoreInteractiveSandboxSnapshot(options) {
+  if (!options.sandboxSnapshotId) return false;
+  if (!options.sandboxClient?.restore) {
+    throw new Error("sandboxSnapshotId requires sandboxClient with restore().");
+  }
+  await options.sandboxClient.restore(options.sandboxSnapshotId);
+  return true;
+}
 function injectSavedMessage(session, msg) {
-  if (!msg || typeof msg !== "object") return;
-  const m = msg;
-  if (!m.role || !m.content) return;
-  const role = m.role;
-  if (role === "tool") {
-    const toolCallId = m.toolCallId ?? "";
-    const name = m.name ?? void 0;
-    session.injectMessage("tool", m.content, { toolCallId, name });
-  } else if (role === "user" || role === "assistant" || role === "system") {
-    session.injectMessage(role, m.content);
+  if (typeof msg.content !== "string") return;
+  if (msg.role === "tool") {
+    session.injectMessage("tool", msg.content, {
+      toolCallId: msg.toolCallId,
+      ...msg.name !== void 0 ? { name: msg.name } : {}
+    });
+  } else {
+    session.injectMessage(msg.role, msg.content);
   }
 }
 function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingSession) {
@@ -5154,8 +6133,11 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
       backgroundTaskEvents: [],
       backgroundJobGroups: [],
       backgroundJobGroupEvents: [],
+      skillActivationEvents: [],
       memoryEvents: [],
-      usedMemoryReferences: []
+      usedMemoryReferences: [],
+      contextReferences: [],
+      sandboxSnapshotId: void 0
     };
   }
   const history = record.history ?? [];
@@ -5163,8 +6145,11 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
   const restoredBackgroundTaskEvents = record.backgroundTaskEvents ?? [];
   const backgroundJobGroups = record.backgroundJobGroups ?? [];
   const backgroundJobGroupEvents = record.backgroundJobGroupEvents ?? [];
+  const skillActivationEvents = record.skillActivationEvents ?? [];
   const memoryEvents = record.memoryEvents ?? [];
   const usedMemoryReferences = record.usedMemoryReferences ?? [];
+  const contextReferences = record.contextReferences ?? [];
+  const sandboxSnapshotId = record.sandboxSnapshotId;
   const { backgroundTasks, backgroundTaskEvents } = reconcileRestoredBackgroundTasks(
     restoredBackgroundTasks,
     restoredBackgroundTaskEvents
@@ -5188,8 +6173,11 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
     backgroundTaskEvents,
     backgroundJobGroups,
     backgroundJobGroupEvents,
+    skillActivationEvents,
     memoryEvents,
-    usedMemoryReferences
+    usedMemoryReferences,
+    contextReferences,
+    sandboxSnapshotId
   };
 }
 function reconcileRestoredBackgroundTasks(tasks, events) {
@@ -5222,14 +6210,62 @@ function isRestoredTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 
+// src/interactive/interactive-session-context-references.ts
+async function addInteractiveContextReference(references, path, cwd) {
+  const result = await resolvePromptFileReferencePaths([path], {
+    cwd,
+    reason: "manual"
+  });
+  if (hasBlockingPromptFileReferenceDiagnostics(result.diagnostics)) {
+    return {
+      references: [...references],
+      result: {
+        evicted: [],
+        diagnostics: [formatPromptFileReferenceDiagnostics(result.diagnostics)]
+      }
+    };
+  }
+  const reference = result.references[0];
+  if (!reference) {
+    return {
+      references: [...references],
+      result: { evicted: [], diagnostics: ["No context reference was resolved."] }
+    };
+  }
+  const item = createContextReferenceItem(
+    toPromptFileReferenceRecords([reference])[0],
+    "manual",
+    "active"
+  );
+  const upserted = upsertContextReference(references, item);
+  return {
+    references: upserted.references,
+    result: {
+      reference: item,
+      evicted: upserted.evicted,
+      diagnostics: []
+    }
+  };
+}
+function recordInteractiveContextReferences(references, records, options) {
+  if (records.length === 0) return [...references];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let next = [...references];
+  for (const record of records) {
+    const item = createContextReferenceItem(record, options.loadType, options.status, now);
+    next = upsertContextReference(next, item).references;
+  }
+  return next;
+}
+
 // src/checkpoints/edit-checkpoint-store.ts
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_fs14 = require("fs");
-var import_node_path15 = require("path");
+var import_node_path18 = require("path");
 
 // src/checkpoints/edit-checkpoint-inspection.ts
 var import_node_fs13 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path17 = require("path");
 function buildEditCheckpointInspection(input) {
   const later = input.manifests.filter((manifest) => manifest.sequence > input.target.sequence);
   const rollbackRange = input.manifests.filter(
@@ -5238,11 +6274,11 @@ function buildEditCheckpointInspection(input) {
   return {
     target: toSummary(input.target),
     capturedFiles: input.target.files.map((file) => {
-      const snapshotPath = file.snapshotFile ? (0, import_node_path14.join)(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
+      const snapshotPath = file.snapshotFile ? (0, import_node_path17.join)(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
       const snapshotStats = snapshotPath ? statSafe(snapshotPath) : void 0;
       return {
         originalPath: file.originalPath,
-        relativePath: (0, import_node_path14.relative)(input.cwd, file.originalPath),
+        relativePath: (0, import_node_path17.relative)(input.cwd, file.originalPath),
         existed: file.existed,
         restoreAction: file.existed ? "restore-preimage" : "delete-created-file",
         snapshotAvailable: file.existed ? snapshotStats !== void 0 : false,
@@ -5288,7 +6324,7 @@ var EditCheckpointStore = class {
   now;
   activeTurn = null;
   constructor(options) {
-    this.cwd = (0, import_node_path15.resolve)(options.cwd);
+    this.cwd = (0, import_node_path18.resolve)(options.cwd);
     this.rootDir = projectPaths(this.cwd).checkpoints;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
   }
@@ -5298,8 +6334,8 @@ var EditCheckpointStore = class {
     }
     const nextSequence = this.nextSequence(input.sessionId);
     const id = `turn-${String(nextSequence).padStart(ID_PAD, "0")}`;
-    const dir = (0, import_node_path15.join)(this.sessionDir(input.sessionId), id);
-    await (0, import_promises.mkdir)((0, import_node_path15.join)(dir, SNAPSHOT_DIR), { recursive: true });
+    const dir = (0, import_node_path18.join)(this.sessionDir(input.sessionId), id);
+    await (0, import_promises2.mkdir)((0, import_node_path18.join)(dir, SNAPSHOT_DIR), { recursive: true });
     const manifest = {
       version: 1,
       id,
@@ -5319,7 +6355,7 @@ var EditCheckpointStore = class {
   }
   async captureFile(filePath) {
     if (!this.activeTurn) return;
-    const originalPath = (0, import_node_path15.resolve)(this.cwd, filePath);
+    const originalPath = (0, import_node_path18.resolve)(this.cwd, filePath);
     if (this.activeTurn.capturedPaths.has(originalPath)) return;
     if (isInside(this.rootDir, originalPath)) return;
     const record = await this.createFileRecord(originalPath, this.activeTurn);
@@ -5366,7 +6402,7 @@ var EditCheckpointStore = class {
       }
     }
     for (const manifest of later) {
-      await (0, import_promises.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
+      await (0, import_promises2.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
     }
     return {
       target: toSummary2(target),
@@ -5390,7 +6426,7 @@ var EditCheckpointStore = class {
       }
     }
     for (const manifest of rollbackRange) {
-      await (0, import_promises.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
+      await (0, import_promises2.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
     }
     return {
       target: toSummary2(target),
@@ -5407,11 +6443,11 @@ var EditCheckpointStore = class {
         existed: false
       };
     }
-    const snapshotFile = (0, import_node_path15.join)(
+    const snapshotFile = (0, import_node_path18.join)(
       SNAPSHOT_DIR,
       `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
     );
-    await (0, import_promises.copyFile)(originalPath, (0, import_node_path15.join)(active.dir, snapshotFile));
+    await (0, import_promises2.copyFile)(originalPath, (0, import_node_path18.join)(active.dir, snapshotFile));
     return {
       originalPath,
       existed: true,
@@ -5420,38 +6456,38 @@ var EditCheckpointStore = class {
   }
   async restoreFile(sessionId, checkpointId, record) {
     if (!record.existed) {
-      await (0, import_promises.rm)(record.originalPath, { force: true });
+      await (0, import_promises2.rm)(record.originalPath, { force: true });
       return;
     }
     if (!record.snapshotFile) {
       throw new Error(`Checkpoint file record is missing a snapshot: ${record.originalPath}`);
     }
-    await (0, import_promises.mkdir)((0, import_node_path15.dirname)(record.originalPath), { recursive: true });
-    await (0, import_promises.copyFile)(
-      (0, import_node_path15.join)(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+    await (0, import_promises2.mkdir)((0, import_node_path18.dirname)(record.originalPath), { recursive: true });
+    await (0, import_promises2.copyFile)(
+      (0, import_node_path18.join)(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
       record.originalPath
     );
   }
   loadManifests(sessionId) {
     const dir = this.sessionDir(sessionId);
-    return readDirSyncSafe(dir).map((entry) => (0, import_node_path15.join)(dir, entry, MANIFEST_FILE)).map((manifestPath) => readJsonManifest(manifestPath)).filter((manifest) => manifest !== void 0).sort((a, b) => a.sequence - b.sequence);
+    return readDirSyncSafe(dir).map((entry) => (0, import_node_path18.join)(dir, entry, MANIFEST_FILE)).map((manifestPath) => readJsonManifest(manifestPath)).filter((manifest) => manifest !== void 0).sort((a, b) => a.sequence - b.sequence);
   }
   nextSequence(sessionId) {
     const last = this.list(sessionId).at(-1);
     return (last?.sequence ?? 0) + 1;
   }
   async writeManifest(dir, manifest) {
-    await (0, import_promises.mkdir)(dir, { recursive: true });
-    const path = (0, import_node_path15.join)(dir, MANIFEST_FILE);
+    await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const path = (0, import_node_path18.join)(dir, MANIFEST_FILE);
     const tmp = `${path}.tmp`;
-    await (0, import_promises.writeFile)(tmp, JSON.stringify(manifest, null, 2), "utf8");
-    await (0, import_promises.rename)(tmp, path);
+    await (0, import_promises2.writeFile)(tmp, JSON.stringify(manifest, null, 2), "utf8");
+    await (0, import_promises2.rename)(tmp, path);
   }
   sessionDir(sessionId) {
-    return (0, import_node_path15.join)(this.rootDir, safePathSegment(sessionId));
+    return (0, import_node_path18.join)(this.rootDir, safePathSegment(sessionId));
   }
   checkpointDir(sessionId, checkpointId) {
-    return (0, import_node_path15.join)(this.sessionDir(sessionId), safePathSegment(checkpointId));
+    return (0, import_node_path18.join)(this.sessionDir(sessionId), safePathSegment(checkpointId));
   }
 };
 function toSummary2(manifest) {
@@ -5468,12 +6504,12 @@ function safePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function isInside(parent, child) {
-  const rel = (0, import_node_path15.relative)(parent, child);
+  const rel = (0, import_node_path18.relative)(parent, child);
   return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
 }
 async function pathExists(path) {
   try {
-    await (0, import_promises.access)(path, import_node_fs14.constants.F_OK);
+    await (0, import_promises2.access)(path, import_node_fs14.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -5496,6 +6532,21 @@ function readJsonManifest(path) {
 }
 
 // src/interactive/interactive-session.ts
+function normalizeSkillName(name) {
+  return name.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
+}
+function normalizeCommandName(name) {
+  return name.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
+}
+function formatSkillCommandArgs(skillName, args) {
+  const trimmedArgs = args.trim();
+  return trimmedArgs.length > 0 ? `${skillName} ${trimmedArgs}` : skillName;
+}
+function getQualifiedSkillName(rawInput) {
+  if (!rawInput?.startsWith("/")) return void 0;
+  const firstToken = rawInput.slice(1).trim().split(/\s+/)[0];
+  return firstToken && firstToken.length > 0 ? firstToken : void 0;
+}
 var InteractiveSession = class {
   session = null;
   commandExecutor;
@@ -5520,6 +6571,7 @@ var InteractiveSession = class {
   backgroundJobGroupEvents = [];
   memoryEvents = [];
   usedMemoryReferences = [];
+  contextReferences = [];
   editCheckpointStore = null;
   resumeSessionId;
   forkSession;
@@ -5528,15 +6580,16 @@ var InteractiveSession = class {
   backgroundJobOrchestrator = null;
   commandModules;
   commandHostAdapters;
+  skillCommandSource;
+  skillActivationEvents = [];
   autoCompactThresholdSource = "default";
   shuttingDown = false;
   shutdownPromise = null;
+  sandboxClient;
+  sandboxSnapshotId;
+  commandInvocationSource = "user";
   constructor(options) {
-    const sdkBuiltinModule = createBuiltinCommandModule();
-    this.commandModules = [
-      sdkBuiltinModule,
-      ..."commandModules" in options ? options.commandModules ?? [] : []
-    ];
+    this.commandModules = [..."commandModules" in options ? options.commandModules ?? [] : []];
     this.commandExecutor = new SystemCommandExecutor(
       this.commandModules.flatMap((module2) => module2.systemCommands ?? [])
     );
@@ -5549,34 +6602,48 @@ var InteractiveSession = class {
     this.resumeSessionId = options.resumeSessionId;
     this.forkSession = options.forkSession ?? false;
     this.commandHostAdapters = "commandHostAdapters" in options ? options.commandHostAdapters : void 0;
-    if ("session" in options && options.session) {
-      this.session = options.session;
-      this.autoCompactThresholdSource = "session";
-      this.initialized = true;
-    } else {
-      const stdOpts = options;
-      this.initPromise = this.initializeAsync(stdOpts);
-    }
-    if (options.resumeSessionId && this.sessionStore) {
-      const restored = loadSessionRecord(
-        this.sessionStore,
-        options.resumeSessionId,
-        this.forkSession,
-        this.session
-      );
-      if (restored.history.length > 0) this.history = restored.history;
-      if (restored.sessionName) this.sessionName = restored.sessionName;
-      this.backgroundTasks = restored.backgroundTasks;
-      this.backgroundTaskEvents = restored.backgroundTaskEvents;
-      this.backgroundJobGroups = restored.backgroundJobGroups;
-      this.backgroundJobGroupEvents = restored.backgroundJobGroupEvents;
-      this.memoryEvents = restored.memoryEvents;
-      this.usedMemoryReferences = restored.usedMemoryReferences;
-      this.pendingRestoreMessages = restored.pendingRestoreMessages;
-    }
+    this.sandboxClient = "sandboxClient" in options ? options.sandboxClient : void 0;
+    this.sandboxSnapshotId = "sandboxSnapshotId" in options ? options.sandboxSnapshotId : void 0;
+    this.skillCommandSource = new SkillCommandSource(this.cwd || process.cwd());
+    const hasInjectedSession = this.configureInjectedSession(options);
+    this.restoreSessionRecordIfNeeded(options);
+    this.startAsyncInitializationIfNeeded(options, hasInjectedSession);
     if (this.initialized) this.subscribeBackgroundTaskEvents();
     if (this.initialized) this.persistCurrentSession();
   }
+  configureInjectedSession(options) {
+    if (!("session" in options && options.session)) return false;
+    this.session = options.session;
+    this.autoCompactThresholdSource = "session";
+    this.initialized = true;
+    return true;
+  }
+  restoreSessionRecordIfNeeded(options) {
+    if (!options.resumeSessionId || !this.sessionStore) return;
+    const restored = loadSessionRecord(
+      this.sessionStore,
+      options.resumeSessionId,
+      this.forkSession,
+      this.session
+    );
+    if (restored.history.length > 0) this.history = restored.history;
+    if (restored.sessionName) this.sessionName = restored.sessionName;
+    this.backgroundTasks = restored.backgroundTasks;
+    this.backgroundTaskEvents = restored.backgroundTaskEvents;
+    this.backgroundJobGroups = restored.backgroundJobGroups;
+    this.backgroundJobGroupEvents = restored.backgroundJobGroupEvents;
+    this.skillActivationEvents = restored.skillActivationEvents;
+    this.memoryEvents = restored.memoryEvents;
+    this.usedMemoryReferences = restored.usedMemoryReferences;
+    this.contextReferences = restored.contextReferences;
+    this.pendingRestoreMessages = restored.pendingRestoreMessages;
+    this.sandboxSnapshotId = this.forkSession ? void 0 : restored.sandboxSnapshotId;
+  }
+  startAsyncInitializationIfNeeded(options, hasInjectedSession) {
+    if (hasInjectedSession) return;
+    const stdOpts = options;
+    this.initPromise = this.initializeAsync(stdOpts);
+  }
   async initializeAsync(options) {
     const config = options.config ?? await loadConfig(options.cwd);
     this.autoCompactThresholdSource = config.autoCompactThreshold === void 0 ? "default" : "settings";
@@ -5602,6 +6669,10 @@ var InteractiveSession = class {
       ...options.commandModules ? { commandModules: options.commandModules } : {},
       editCheckpointRecorder: this.editCheckpointStore,
       ...options.reversibleExecution ? { reversibleExecution: options.reversibleExecution } : {},
+      ...options.sandboxClient ? { sandboxClient: options.sandboxClient } : {},
+      ...options.workspaceManifest ? { workspaceManifest: options.workspaceManifest } : {},
+      ...options.sandboxWorkspaceRoot ? { sandboxWorkspaceRoot: options.sandboxWorkspaceRoot } : {},
+      ...this.sandboxSnapshotId ? { sandboxSnapshotId: this.sandboxSnapshotId } : {},
       commandDescriptors: this.commandExecutor.listModelInvocableCommands(),
       ...this.commandExecutor.listModelInvocableCommands().length > 0 ? {
         modelCommandExecutor: (command, args) => this.executeModelCommand(command, args),
@@ -5648,36 +6719,102 @@ var InteractiveSession = class {
   }
   async executeCommand(name, args) {
     await this.ensureInitialized();
-    const command = this.commandExecutor.getCommand(name);
-    if (!command) return null;
+    const normalizedName = normalizeCommandName(name);
+    const command = this.commandExecutor.getCommand(normalizedName);
+    const commandArgs = args.trim();
+    if (!command) {
+      const skill = this.findSkillCommand(normalizedName);
+      const skillsCommand = this.commandExecutor.getCommand("skills");
+      if (!skill || !skillsCommand) return null;
+      return this.executeCommandWithInvocationSource(
+        "user",
+        skillsCommand,
+        formatSkillCommandArgs(skill.name, commandArgs)
+      );
+    }
+    return this.executeCommandWithInvocationSource("user", command, commandArgs);
+  }
+  async executeCommandWithInvocationSource(source, command, args) {
     if (this.executing) {
       return {
         success: false,
         message: "Another prompt or command is already running. Wait for it to finish."
       };
     }
-    if (command.lifecycle === "blocking") {
-      return this.executeForegroundCommand(command, args);
+    const previousSource = this.commandInvocationSource;
+    this.commandInvocationSource = source;
+    try {
+      if (command.lifecycle === "blocking") {
+        return this.executeForegroundCommand(command, args);
+      }
+      return await this.commandExecutor.executeCommand(command, this, args);
+    } finally {
+      this.commandInvocationSource = previousSource;
     }
-    return this.commandExecutor.executeCommand(command, this, args);
   }
   async executeModelCommand(name, args) {
     await this.ensureInitialized();
-    return this.commandExecutor.executeModelInvocable(name, this, args);
+    const previousSource = this.commandInvocationSource;
+    this.commandInvocationSource = "model";
+    try {
+      return await this.commandExecutor.executeModelInvocable(name, this, args);
+    } finally {
+      this.commandInvocationSource = previousSource;
+    }
   }
-  async executeSkillCommand(skill, args, displayInput, rawInput) {
+  getCommandInvocationSource() {
+    return this.commandInvocationSource;
+  }
+  async executeSkillCommandByName(name, args, request) {
     await this.ensureInitialized();
-    if (skill.context === "fork") {
-      return this.executeForkSkillCommand(skill, args, displayInput);
+    const skill = this.findSkillCommand(name);
+    if (!skill) return null;
+    if (request.invocationSource === "model") {
+      if (skill.disableModelInvocation === true) {
+        return {
+          success: false,
+          message: `Skill is not model-invocable: ${skill.name}`
+        };
+      }
+      const result = await this.executeSkillWithActivation(skill, args, "model-tool");
+      return {
+        success: true,
+        message: `Skill activated: ${skill.name}`,
+        data: {
+          skill: skill.name,
+          mode: result.mode,
+          ...result.prompt !== void 0 ? { prompt: result.prompt } : {},
+          ...result.result !== void 0 ? { result: result.result } : {}
+        }
+      };
     }
-    const result = await executeSkill(
+    await this.executeUserResolvedSkillCommand(
       skill,
       args,
-      {
-        runInFork: (content, options) => this.runSkillInFork(content, options)
-      },
-      { sessionId: this.getSessionOrThrow().getSessionId() }
+      request.displayInput,
+      request.rawInput,
+      "user-slash"
     );
+    return {
+      success: true,
+      message: "",
+      data: {
+        skill: skill.name,
+        sessionExecution: true
+      },
+      effects: [{ type: "session-execution-started" }]
+    };
+  }
+  async executeUserResolvedSkillCommand(skill, args, displayInput, rawInput, invocation) {
+    await this.ensureInitialized();
+    if (skill.userInvocable === false) {
+      throw new Error(`Skill is not user-invocable: ${skill.name}`);
+    }
+    const qualifiedName = getQualifiedSkillName(rawInput);
+    if (skill.context === "fork") {
+      return this.executeForkSkillCommand(skill, args, displayInput, qualifiedName, invocation);
+    }
+    const result = await this.executeSkillWithActivation(skill, args, invocation, qualifiedName);
     if (result.mode === "inject") {
       if (result.prompt) {
         await this.submit(result.prompt, displayInput, rawInput);
@@ -5693,12 +6830,31 @@ var InteractiveSession = class {
       description: cmd.description
     }));
   }
+  listSkills() {
+    return this.skillCommandSource.getCommands().map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      source: skill.source,
+      modelInvocable: skill.disableModelInvocation !== true,
+      userInvocable: skill.userInvocable !== false,
+      ...skill.argumentHint !== void 0 ? { argumentHint: skill.argumentHint } : {},
+      ...skill.context !== void 0 ? { context: skill.context } : {},
+      ...skill.agent !== void 0 ? { agent: skill.agent } : {}
+    }));
+  }
   listModelInvocableCommands() {
     return this.commandExecutor.listModelInvocableCommands().map((cmd) => ({
       name: cmd.name,
       description: cmd.description
     }));
   }
+  getSkillActivationEvents() {
+    return [...this.skillActivationEvents];
+  }
+  findSkillCommand(name) {
+    const normalizedName = normalizeSkillName(name);
+    return this.skillCommandSource.getCommands().find((skill) => skill.name.toLowerCase() === normalizedName.toLowerCase());
+  }
   abort() {
     this.clearPendingQueue();
     this.session?.abort();
@@ -5718,6 +6874,7 @@ var InteractiveSession = class {
       this.backgroundJobUnsubscribe = null;
       this.backgroundJobOrchestrator?.dispose();
       this.backgroundJobOrchestrator = null;
+      await this.captureSandboxSnapshot();
       this.persistCurrentSession();
       await session?.shutdown({ reason: options.reason ?? "other" });
     })();
@@ -5830,6 +6987,31 @@ var InteractiveSession = class {
     this.memoryEvents.push(event);
     this.persistCurrentSession();
   }
+  listContextReferences() {
+    return [...this.contextReferences];
+  }
+  async addContextReference(path) {
+    const { references, result } = await addInteractiveContextReference(
+      this.contextReferences,
+      path,
+      this.getCwd()
+    );
+    this.contextReferences = references;
+    this.persistCurrentSession();
+    return result;
+  }
+  removeContextReference(path) {
+    const result = removeContextReference(this.contextReferences, path);
+    this.contextReferences = result.references;
+    this.persistCurrentSession();
+    return result.result;
+  }
+  clearContextReferences() {
+    const result = clearContextReferences(this.contextReferences);
+    this.contextReferences = [];
+    this.persistCurrentSession();
+    return result;
+  }
   listBackgroundTasks(filter) {
     return this.getBackgroundTaskManagerOrThrow().list(filter);
   }
@@ -5931,18 +7113,63 @@ var InteractiveSession = class {
   attachTransport(transport) {
     transport.attach(this);
   }
-  async executeForkSkillCommand(skill, args, displayInput) {
-    if (this.executing) {
-      throw new Error("Cannot execute fork skill while another prompt is running.");
-    }
-    this.startForkSkillExecution(displayInput ?? `/${skill.name}`);
+  async executeSkillWithActivation(skill, args, invocation, qualifiedName) {
+    this.recordSkillActivation(skill, invocation, "started", qualifiedName);
     try {
       const result = await executeSkill(
         skill,
         args,
-        { runInFork: (content, options) => this.runSkillInFork(content, options) },
+        {
+          runInFork: (content, options) => this.runSkillInFork(content, options)
+        },
         { sessionId: this.getSessionOrThrow().getSessionId() }
       );
+      this.recordSkillActivation(skill, invocation, "completed", qualifiedName, {
+        appendHistory: false
+      });
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.recordSkillActivation(skill, invocation, "failed", qualifiedName, {
+        error: error.message
+      });
+      throw error;
+    }
+  }
+  recordSkillActivation(skill, invocation, status, qualifiedName, options = {}) {
+    const event = createSkillActivationEvent({
+      skill,
+      invocation,
+      status,
+      ...qualifiedName !== void 0 ? { qualifiedName } : {},
+      ...options.error !== void 0 ? { error: options.error } : {}
+    });
+    this.recordSkillActivationEvent(event, options.appendHistory ?? status !== "completed");
+  }
+  recordSkillActivationEvent(event, appendHistory) {
+    this.skillActivationEvents.push(event);
+    if (appendHistory) {
+      this.history.push({
+        id: (0, import_node_crypto5.randomUUID)(),
+        timestamp: new Date(event.timestamp),
+        category: "event",
+        type: "skill-activation",
+        data: {
+          ...event,
+          message: formatSkillActivationMessage(event)
+        }
+      });
+    }
+    this.emit("skill_activation", event);
+    this.persistCurrentSession();
+  }
+  async executeForkSkillCommand(skill, args, displayInput, qualifiedName, invocation = "user-slash") {
+    if (this.executing) {
+      throw new Error("Cannot execute fork skill while another prompt is running.");
+    }
+    this.startForkSkillExecution(displayInput ?? `/${skill.name}`);
+    try {
+      const result = await this.executeSkillWithActivation(skill, args, invocation, qualifiedName);
       await this.applyForkSkillResult(result.result ?? "(empty response)");
       return result;
     } catch (err) {
@@ -6056,9 +7283,30 @@ var InteractiveSession = class {
       {
         events: this.memoryEvents,
         usedReferences: this.usedMemoryReferences
+      },
+      {
+        events: this.skillActivationEvents
+      },
+      {
+        references: this.contextReferences
+      },
+      {
+        snapshotId: this.sandboxSnapshotId
       }
     );
   }
+  async captureSandboxSnapshot() {
+    if (!this.sandboxClient?.snapshot) return;
+    try {
+      this.sandboxSnapshotId = await this.sandboxClient.snapshot();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.history.push(
+        (0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Sandbox snapshot error: ${err.message}`))
+      );
+      this.emit("error", err);
+    }
+  }
   startForkSkillExecution(displayInput) {
     this.executing = true;
     this.clearStreaming();
@@ -6074,7 +7322,7 @@ var InteractiveSession = class {
       const queuedDisplay = this.pendingDisplayInput;
       const queuedRaw = this.pendingRawInput;
       this.clearPendingQueue();
-      setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
+      setTimeout(() => void this.submit(queued, queuedDisplay, queuedRaw), 0);
     }
   }
   recordForkSkillError(err) {
@@ -6096,7 +7344,9 @@ var InteractiveSession = class {
     const parentSession = this.getSessionOrThrow();
     const deps = retrieveAgentToolDeps(parentSession);
     if (!deps) {
-      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
+      throw new Error(
+        "Fork execution is not available. Agent runtime deps may not be initialized."
+      );
     }
     const agentType = options.agent ?? "general-purpose";
     const agentDefinition = this.resolveForkAgentDefinition(agentType, options);
@@ -6154,7 +7404,7 @@ var InteractiveSession = class {
         const queuedDisplay = this.pendingDisplayInput;
         const queuedRaw = this.pendingRawInput;
         this.clearPendingQueue();
-        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
+        setTimeout(() => void this.submit(queued, queuedDisplay, queuedRaw), 0);
       }
     }
   }
@@ -6166,8 +7416,22 @@ var InteractiveSession = class {
     const historyBefore = this.getSessionOrThrow().getHistory().length;
     this.usedMemoryReferences = [];
     try {
+      const preparedPrompt = await preparePromptInput(
+        input,
+        this.getCwd(),
+        rawInput,
+        this.contextReferences
+      );
+      if (preparedPrompt.promptFileReferenceEntry) {
+        this.history.push(preparedPrompt.promptFileReferenceEntry);
+      }
+      this.recordContextReferenceUsage(preparedPrompt.activeContextReferenceRecords);
+      this.recordPromptContextReferences(preparedPrompt.promptFileReferenceRecords);
       await this.beginEditCheckpointTurn(displayInput ?? input);
-      const response = await this.getSessionOrThrow().run(input, rawInput);
+      const response = await this.getSessionOrThrow().run(
+        preparedPrompt.modelInput,
+        preparedPrompt.hookInput
+      );
       this.flushStreaming();
       pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
       this.clearStreaming();
@@ -6176,7 +7440,8 @@ var InteractiveSession = class {
         this.getSessionOrThrow().getHistory(),
         this.history,
         historyBefore,
-        this.getContextState()
+        this.getContextState(),
+        preparedPrompt.promptFileReferenceRecords
       );
       this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createAssistantMessage)(result.response)));
       if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
@@ -6215,10 +7480,24 @@ var InteractiveSession = class {
         const queuedDisplay = this.pendingDisplayInput;
         const queuedRaw = this.pendingRawInput;
         this.clearPendingQueue();
-        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
+        setTimeout(() => void this.submit(queued, queuedDisplay, queuedRaw), 0);
       }
     }
   }
+  recordContextReferenceUsage(records) {
+    this.contextReferences = recordInteractiveContextReferences(this.contextReferences, records, {
+      loadType: "manual",
+      status: "active"
+    });
+    this.persistCurrentSession();
+  }
+  recordPromptContextReferences(records) {
+    this.contextReferences = recordInteractiveContextReferences(this.contextReferences, records, {
+      loadType: "prompt-reference",
+      status: "observed"
+    });
+    this.persistCurrentSession();
+  }
   getEditCheckpointStore() {
     if (!this.editCheckpointStore) {
       this.editCheckpointStore = new EditCheckpointStore({ cwd: this.getCwd() });
@@ -6294,6 +7573,159 @@ var InteractiveSession = class {
   }
 };
 
+// src/interactive/session-persistence.ts
+var import_agent_sessions7 = require("@robota-sdk/agent-sessions");
+var import_node_fs15 = require("fs");
+var import_node_path19 = require("path");
+function createProjectSessionStore(cwd) {
+  const paths = projectPaths(cwd);
+  return new ProjectSessionStoreFacade(paths.sessions, paths.logs);
+}
+function listResumableSessionSummaries(sessionStore, cwd) {
+  return (sessionStore?.list() ?? []).filter((session) => session.cwd === cwd).sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()).map((session) => ({
+    id: session.id,
+    ...session.name !== void 0 ? { name: session.name } : {},
+    cwd: session.cwd,
+    updatedAt: session.updatedAt,
+    messageCount: session.messages.length,
+    preview: getLastAssistantPreview(session.messages)
+  }));
+}
+function resolveLatestSessionId(sessionStore, cwd) {
+  return listResumableSessionSummaries(sessionStore, cwd)[0]?.id;
+}
+function resolveSessionIdByIdOrName(sessionStore, idOrName) {
+  const match = (sessionStore?.list() ?? []).find(
+    (session) => session.id === idOrName || session.name === idOrName
+  );
+  return match?.id;
+}
+var ProjectSessionStoreFacade = class {
+  store;
+  logsDir;
+  constructor(baseDir, logsDir) {
+    this.store = new import_agent_sessions7.SessionStore(baseDir);
+    this.logsDir = logsDir;
+  }
+  save(session) {
+    this.store.save(toSessionRecord(session));
+  }
+  load(id) {
+    const session = this.store.load(id);
+    if (session !== void 0) {
+      return fromSessionRecord(session);
+    }
+    return this.loadFromReplayLog(id);
+  }
+  list() {
+    const records = this.store.list().map(fromSessionRecord);
+    const seen = new Set(records.map((record) => record.id));
+    for (const replayRecord of this.listReplayLogRecords()) {
+      if (!seen.has(replayRecord.id)) {
+        records.push(replayRecord);
+      }
+    }
+    return records.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  delete(id) {
+    this.store.delete(id);
+  }
+  loadFromReplayLog(id) {
+    if (!this.logsDir) return void 0;
+    const replay = (0, import_agent_sessions7.replaySessionLogEntries)(
+      (0, import_agent_sessions7.loadSessionLogEntries)((0, import_node_path19.join)(this.logsDir, `${id}.jsonl`))
+    );
+    if (!replay.sessionId || replay.messages.length === 0) {
+      return void 0;
+    }
+    const backgroundTaskEvents = replay.backgroundTaskEvents;
+    const backgroundJobGroupEvents = replay.backgroundJobGroupEvents;
+    return {
+      id: replay.sessionId,
+      cwd: replay.cwd ?? "",
+      createdAt: replay.createdAt ?? replay.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      updatedAt: replay.updatedAt ?? replay.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      messages: replay.messages,
+      history: replay.history,
+      backgroundTasks: deriveBackgroundTasks(backgroundTaskEvents),
+      backgroundTaskEvents,
+      backgroundJobGroups: deriveBackgroundJobGroups(backgroundJobGroupEvents),
+      backgroundJobGroupEvents,
+      skillActivationEvents: [],
+      memoryEvents: replay.memoryEvents
+    };
+  }
+  listReplayLogRecords() {
+    if (!this.logsDir || !(0, import_node_fs15.existsSync)(this.logsDir)) {
+      return [];
+    }
+    return (0, import_node_fs15.readdirSync)(this.logsDir).filter((file) => file.endsWith(".jsonl")).map((file) => this.loadFromReplayLog(file.slice(0, -".jsonl".length))).filter((record) => record !== void 0);
+  }
+};
+function getLastAssistantPreview(messages) {
+  for (const message of [...messages].reverse()) {
+    if (message.role !== "assistant") continue;
+    if (typeof message.content !== "string") continue;
+    return message.content.replace(/[\n\r]+/g, " ").trim();
+  }
+  return "";
+}
+function toSessionRecord(session) {
+  return { ...session };
+}
+function fromSessionRecord(session) {
+  return {
+    id: session.id,
+    ...session.name !== void 0 ? { name: session.name } : {},
+    cwd: session.cwd,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    messages: session.messages,
+    ...session.history !== void 0 ? { history: session.history } : {},
+    ...session.systemPrompt !== void 0 ? { systemPrompt: session.systemPrompt } : {},
+    ...session.toolSchemas !== void 0 ? { toolSchemas: session.toolSchemas } : {},
+    ...session.backgroundTasks !== void 0 ? { backgroundTasks: session.backgroundTasks } : {},
+    ...session.backgroundTaskEvents !== void 0 ? { backgroundTaskEvents: session.backgroundTaskEvents } : {},
+    ...session.backgroundJobGroups !== void 0 ? { backgroundJobGroups: session.backgroundJobGroups } : {},
+    ...session.backgroundJobGroupEvents !== void 0 ? { backgroundJobGroupEvents: session.backgroundJobGroupEvents } : {},
+    ...session.skillActivationEvents !== void 0 ? { skillActivationEvents: session.skillActivationEvents } : {},
+    ...session.memoryEvents !== void 0 ? { memoryEvents: session.memoryEvents } : {},
+    ...session.usedMemoryReferences !== void 0 ? { usedMemoryReferences: session.usedMemoryReferences } : {},
+    ...session.contextReferences !== void 0 ? { contextReferences: session.contextReferences } : {},
+    ...session.sandboxSnapshotId !== void 0 ? { sandboxSnapshotId: session.sandboxSnapshotId } : {}
+  };
+}
+function deriveBackgroundTasks(events) {
+  const tasks = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const task = getBackgroundTaskSnapshot(event);
+    if (task) tasks.set(task.id, task);
+  }
+  return [...tasks.values()];
+}
+function getBackgroundTaskSnapshot(event) {
+  switch (event.type) {
+    case "background_task_created":
+    case "background_task_started":
+    case "background_task_updated":
+    case "background_task_completed":
+    case "background_task_failed":
+    case "background_task_cancelled":
+      return event.task;
+    default:
+      return void 0;
+  }
+}
+function deriveBackgroundJobGroups(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    groups.set(event.group.id, event.group);
+  }
+  return [...groups.values()];
+}
+
 // src/query.ts
 function createQuery(options) {
   const session = new InteractiveSession({
@@ -6307,14 +7739,14 @@ function createQuery(options) {
     session.on("text_delta", options.onTextDelta);
   }
   return async (prompt) => {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       const onComplete = (result) => {
         cleanup();
-        resolve4(result.response);
+        resolve6(result.response);
       };
       const onInterrupted = (result) => {
         cleanup();
-        resolve4(result.response);
+        resolve6(result.response);
       };
       const onError = (error) => {
         cleanup();
@@ -6336,12 +7768,6 @@ function createQuery(options) {
   };
 }
 
-// src/types.ts
-var import_agent_core8 = require("@robota-sdk/agent-core");
-
-// src/index.ts
-var import_agent_core9 = require("@robota-sdk/agent-core");
-
 // src/self-hosting/self-hosting-verification.ts
 var DEFAULT_BASE_REF = "origin/develop";
 var PACKAGE_VERIFY_COMMANDS = ["test", "typecheck", "build"];
@@ -6457,13 +7883,72 @@ function transitionSelfHostingLoop(state, event) {
   return nextState;
 }
 
+// src/tools/command-execution-tool.ts
+var import_zod5 = require("zod");
+var import_agent_tools6 = require("@robota-sdk/agent-tools");
+function asZodSchema4(schema) {
+  return schema;
+}
+function toNonEmptyCommandNames(commandNames) {
+  if (!commandNames || commandNames.length === 0) return void 0;
+  const [first, ...rest] = commandNames;
+  if (first === void 0) return void 0;
+  return [first, ...rest];
+}
+function createCommandExecutionSchema(commandNames) {
+  const validCommandNames = toNonEmptyCommandNames(commandNames);
+  const commandSchema = validCommandNames !== void 0 ? import_zod5.z.enum(validCommandNames).describe("Registered model-invocable command name to execute") : import_zod5.z.string().describe("Registered model-invocable command name to execute");
+  return import_zod5.z.object({
+    command: commandSchema,
+    args: import_zod5.z.string().optional().describe("Arguments to pass to the command")
+  });
+}
+function getCommandNames(deps) {
+  if (deps.commandNames !== void 0) return deps.commandNames;
+  if (deps.commandDescriptors === void 0) return void 0;
+  return deps.commandDescriptors.map((descriptor) => normalizeModelCommandName(descriptor.name));
+}
+function formatCommandDescriptor(descriptor) {
+  const commandName = normalizeModelCommandName(descriptor.name);
+  const argumentHint = descriptor.argumentHint ? ` ${descriptor.argumentHint}` : "";
+  return `- ${commandName}${argumentHint}: ${descriptor.description}`;
+}
+function createToolDescription(commandDescriptors) {
+  const base = "Executes a registered model-invocable Robota command through the command registry. Accepted command names and argument grammar come from registered command descriptors.";
+  if (commandDescriptors === void 0 || commandDescriptors.length === 0) return base;
+  return [
+    base,
+    "Use the registered command descriptors below as the authority for when to call this tool.",
+    "",
+    "Registered model-invocable commands:",
+    ...commandDescriptors.map(formatCommandDescriptor)
+  ].join("\n");
+}
+function createCommandExecutionTool(deps) {
+  const commandExecutionSchema = createCommandExecutionSchema(getCommandNames(deps));
+  return (0, import_agent_tools6.createZodFunctionTool)(
+    "ExecuteCommand",
+    createToolDescription(deps.commandDescriptors),
+    asZodSchema4(commandExecutionSchema),
+    async (params) => {
+      const args = commandExecutionSchema.parse(params);
+      const command = normalizeModelCommandName(args.command);
+      if (!deps.isModelInvocable(command)) {
+        return JSON.stringify({
+          success: false,
+          command,
+          error: `Command is not model-invocable: ${command}`
+        });
+      }
+      return stringifyModelCommandResult(command, await deps.execute(command, args.args ?? ""));
+    }
+  );
+}
+
 // src/subagents/index.ts
 var import_agent_runtime7 = require("@robota-sdk/agent-runtime");
 var import_agent_runtime8 = require("@robota-sdk/agent-runtime");
 
-// src/index.ts
-var import_agent_core10 = require("@robota-sdk/agent-core");
-
 // src/permissions/permission-prompt.ts
 var import_chalk = __toESM(require("chalk"), 1);
 var PERMISSION_OPTIONS = ["Allow", "Deny"];
@@ -6483,9 +7968,6 @@ async function promptForApproval(terminal, toolName, toolArgs) {
   const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
   return selected === ALLOW_INDEX;
 }
-
-// src/index.ts
-var import_agent_core11 = require("@robota-sdk/agent-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AUTO_COMPACT_THRESHOLD_SETTINGS_KEY,
@@ -6503,6 +7985,7 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   COST_COMMAND_DESCRIPTION,
   CommandRegistry,
   DEFAULT_AUTO_COMPACT_THRESHOLD,
+  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE,
   DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
   EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore,
@@ -6517,12 +8000,14 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   MEMORY_INDEX_MAX_LINES,
   MODEL_COMMAND_ARGUMENT_HINT,
   MODEL_COMMAND_DESCRIPTION,
+  MODEL_COMMAND_TOOL_PREFIX,
   MarketplaceClient,
   PERMISSIONS_COMMAND_DESCRIPTION,
   PERMISSION_MODE_ARGUMENT_HINT,
   PERMISSION_MODE_COMMAND_DESCRIPTION,
   PLUGIN_COMMAND_ARGUMENT_HINT,
   PLUGIN_COMMAND_DESCRIPTION,
+  PROVIDER_SAFE_TOOL_NAME_PATTERN,
   PluginCommandSource,
   PluginSettingsStore,
   ProjectMemoryStore,
@@ -6539,9 +8024,11 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   SkillCommandSource,
   SubagentManager,
   SystemCommandExecutor,
-  TRUST_TO_MODE,
+  VALIDATE_SESSION_COMMAND_DESCRIPTION,
   VALID_PERMISSION_MODES,
   WorktreeSubagentRunner,
+  addCommandContextReference,
+  appendPrefixedLogLines,
   assembleSubagentPrompt,
   buildBackgroundCommandSubcommands,
   buildLanguageCommandSubcommands,
@@ -6549,26 +8036,35 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   buildModelCommandSubcommands,
   buildPermissionModeSubcommands,
   buildPluginCommandSubcommands,
+  buildPromptWithFileReferences,
   buildProviderProfile,
   buildProviderSetupPatch,
   buildRewindCommandSubcommands,
-  buildSkillPrompt,
   buildStatusLineCommandSubcommands,
   cancelCommandBackgroundTask,
-  chatEntryToMessage,
+  clearCommandContextReferences,
+  clearContextReferences,
   clearConversationHistory,
   closeCommandBackgroundTask,
   compactCommandContext,
   createAgentTool,
   createBackgroundProcessTool,
+  createBackgroundTaskLogPage,
   createBuiltinCommandModule,
   createCommandExecutionTool,
   createCommandMemoryStores,
   createCommandPendingMemoryStore,
   createCommandProjectMemoryStore,
+  createContextReferenceItem,
   createDefaultTools,
+  createLimitedOutputCapture,
+  createModelCommandToolProjection,
   createPluginRegistryReloadRequestedEffect,
   createPluginTuiRequestedEffect,
+  createProjectSessionStore,
+  createProjectedCommandExecutionTools,
+  createPromptFileReferenceHistoryEntry,
+  createProviderSafeModelCommandToolName,
   createProviderSetupFlow,
   createQuery,
   createSessionExitRequestedEffect,
@@ -6578,48 +8074,57 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   createSubagentSession,
   createSystemCommands,
   createWorktreeSubagentRunner,
+  deleteProviderProfile,
   discoverTaskFiles,
-  evaluatePermission,
   evaluateReversibleToolSafety,
   executeSkill,
   formatCommandBackgroundTask,
   formatCommandBackgroundTaskList,
   formatCommandHelpMessage,
   formatCommandPermissionsMessage,
+  formatCommandSessionReplayValidationReport,
   formatEnvReference,
   formatInvalidPermissionModeMessage,
   formatLanguageUsageMessage,
+  formatModelCommandUsageMessage,
+  formatModelCommandUsageMessageAsync,
+  formatProjectedModelCommandToolPromptDescription,
+  formatPromptFileReferenceDiagnostics,
   formatProviderSetupChoiceLabel,
+  formatProviderSetupHelpLinks,
   formatProviderSetupPromptLabel,
   formatProviderSetupSelectionPrompt,
   formatTaskContext,
   getBackgroundTaskTransitions,
   getBuiltInAgent,
   getForkWorkerSuffix,
-  getMessagesForAPI,
   getProviderSetupStep,
   getSubagentSuffix,
+  hasBlockingPromptFileReferenceDiagnostics,
   hasSensitiveCommandMemoryContent,
   hasUsableSecretReference,
   inspectCommandEditCheckpoint,
-  isChatEntry,
   isCommandMemoryType,
   isEnvReference,
   isMemoryType,
   isPermissionMode,
   isStatusLineCommandSettingsPatch,
   isTerminalBackgroundTaskStatus,
+  listActiveContextReferences,
   listCommandBackgroundTasks,
+  listCommandContextReferences,
   listCommandEditCheckpoints,
   listCommandSessionAllowedTools,
   listCommandUsedMemoryReferences,
+  listResumableSessionSummaries,
   loadTaskContext,
   mergeProviderPatch,
-  messageToHistoryEntry,
+  normalizeModelCommandName,
   parseCommandBackgroundLogCursor,
   parseFrontmatter,
   parseLanguageArgument,
   parsePermissionModeArgument,
+  parsePromptFileReferences,
   parseSessionNameArgument,
   parseTaskFile,
   planSelfHostingVerification,
@@ -6636,30 +8141,43 @@ var import_agent_core11 = require("@robota-sdk/agent-core");
   readCommandSessionInfo,
   readCurrentGitBranch,
   recordCommandMemoryEvent,
+  removeCommandContextReference,
+  removeContextReference,
   resetAutoCompactThresholdSetting,
+  resolveActiveProviderModelCatalog,
+  resolveActiveProviderModelCatalogState,
   resolveEnvReference,
+  resolveLatestSessionId,
   resolvePermissionModeAdapter,
   resolvePluginCommandAdapter,
+  resolvePromptFileReferencePaths,
+  resolvePromptFileReferences,
   resolveProviderSetupSelection,
+  resolveSessionIdByIdOrName,
   resolveSubagentLogDir,
   restoreCommandEditCheckpoint,
   retrieveAgentToolDeps,
   rollbackCommandEditCheckpoint,
-  runHooks,
   runProviderSetupPromptFlow,
+  sanitizeProviderProfileName,
   selectRelevantTasks,
   setCommandAutoCompactThreshold,
   setCurrentProvider,
   storeAgentToolDeps,
   submitProviderSetupValue,
   substituteVariables,
+  suggestProviderProfileName,
   summarizeBackgroundJobGroup,
   testProviderProfileCommand,
+  toContextReferenceRecords,
+  toPromptFileReferenceRecords,
   transitionBackgroundTaskStatus,
   transitionSelfHostingLoop,
   updateTaskFileStatus,
+  upsertContextReference,
   upsertProviderProfile,
   userPaths,
+  validateCommandSessionReplayLog,
   validateProviderProfile,
   validateProviderSetupValue,
   wrapEditCheckpointTools,