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

package/dist/node/index.js

@@ -1,4 +1,5 @@
 // src/interactive/interactive-session.ts
+import { randomUUID as randomUUID4 } from "crypto";
 import {
   createUserMessage,
   createAssistantMessage,
@@ -15,7 +16,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,
@@ -108,7 +109,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,
@@ -171,7 +172,7 @@ function createBuiltinCommandModule() {
 import { findProviderDefinition as findProviderDefinition2 } from "@robota-sdk/agent-core";
 
 // src/command-api/provider/provider-settings.ts
-import { findProviderDefinition } from "@robota-sdk/agent-core";
+import { findProviderDefinition, getProviderCredentialRequirement } from "@robota-sdk/agent-core";
 
 // src/command-api/provider/provider-env-ref.ts
 var ENV_REFERENCE_PREFIX = "$ENV:";
@@ -217,6 +218,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`);
@@ -225,8 +252,11 @@ function validateProviderProfile(profileName, profile, options = {}) {
     throw new Error(`Provider profile "${profileName}" is missing model`);
   }
   const definition = 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 = 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 = {}) {
@@ -246,7 +276,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 }
   };
@@ -262,6 +292,20 @@ function mergeProviderPatch(settings, patch) {
 function getProviderDefaults(type, providerDefinitions) {
   return 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) {
@@ -494,18 +538,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
 import { findProviderDefinition as findProviderDefinition3, formatSupportedProviderTypes } from "@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) {
@@ -566,12 +656,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;
@@ -583,14 +676,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;
@@ -603,13 +707,16 @@ function validateProviderSetupValue(step, value) {
   }
   return void 0;
 }
-function getProviderSetupSteps(type, providerDefinitions) {
+function getProviderSetupDefinition(type, providerDefinitions) {
   const definition = findProviderDefinition3(providerDefinitions, type);
   if (definition === void 0) {
     throw new Error(
       `Unknown provider: ${type}. Currently supported: ${formatSupportedProviderTypes(providerDefinitions)}`
     );
   }
+  return definition;
+}
+function getProviderSetupSteps(definition) {
   if (definition.setupSteps !== void 0) {
     return [...definition.setupSteps];
   }
@@ -639,14 +746,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
   };
 }
 
@@ -732,10 +869,74 @@ function closeCommandBackgroundTask(context, taskId) {
 }
 
 // src/command-api/model/model-command-api.ts
-import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
+import {
+  CLAUDE_MODELS,
+  findProviderDefinition as findProviderDefinition4,
+  formatTokenCount
+} from "@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(CLAUDE_MODELS)) {
@@ -749,6 +950,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} (${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 = findProviderDefinition4(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";
@@ -777,7 +1069,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",
@@ -892,12 +1184,39 @@ function buildPluginCommandSubcommands() {
   ];
 }
 
+// src/command-api/session/session-command-api.ts
+import { join as join3 } from "path";
+import { loadSessionLogEntries, validateSessionReplayLogEntries } from "@robota-sdk/agent-sessions";
+
+// src/paths.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function projectPaths(cwd) {
+  const base = join2(cwd, ".robota");
+  return {
+    settings: join2(base, "settings.json"),
+    settingsLocal: join2(base, "settings.local.json"),
+    logs: join2(base, "logs"),
+    sessions: join2(base, "sessions"),
+    memory: join2(base, "memory"),
+    checkpoints: join2(base, "checkpoints")
+  };
+}
+function userPaths() {
+  const base = join2(homedir2(), ".robota");
+  return {
+    settings: join2(base, "settings.json"),
+    sessions: join2(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) {
@@ -926,6 +1245,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 = join3(projectPaths(context.getCwd()).logs, `${sessionId}.jsonl`);
+  const entries = loadSessionLogEntries(logFile);
+  return {
+    logFile,
+    entryCount: entries.length,
+    validation: 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.";
@@ -968,10 +1326,10 @@ function containsSensitiveMemoryContent(text) {
 
 // src/memory/pending-memory-store.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join4 } from "path";
 var PENDING_FILENAME = "pending.json";
 function memoryRoot(cwd) {
-  return join2(cwd, ".robota", "memory");
+  return join4(cwd, ".robota", "memory");
 }
 function emptyDocument() {
   return { version: 1, records: [] };
@@ -980,7 +1338,7 @@ var PendingMemoryStore = class {
   path;
   now;
   constructor(cwd, now = () => /* @__PURE__ */ new Date()) {
-    this.path = join2(memoryRoot(cwd), PENDING_FILENAME);
+    this.path = join4(memoryRoot(cwd), PENDING_FILENAME);
     this.now = now;
   }
   getPath() {
@@ -1048,7 +1406,7 @@ import {
   writeFileSync as writeFileSync2,
   appendFileSync
 } from "fs";
-import { basename as basename2, join as join3 } from "path";
+import { basename as basename2, join as join5 } from "path";
 var MEMORY_INDEX_MAX_LINES = 200;
 var MEMORY_INDEX_MAX_BYTES = Number("25600");
 var INDEX_FILENAME = "MEMORY.md";
@@ -1062,7 +1420,7 @@ function isMemoryType(value) {
   return VALID_TYPES.includes(value);
 }
 function memoryRoot2(cwd) {
-  return join3(cwd, ".robota", "memory");
+  return join5(cwd, ".robota", "memory");
 }
 function truncateToUtf8Bytes(value, maxBytes) {
   const buffer = Buffer.from(value, "utf8");
@@ -1097,10 +1455,10 @@ var ProjectMemoryStore = class {
     this.now = now;
   }
   getIndexPath() {
-    return join3(memoryRoot2(this.cwd), INDEX_FILENAME);
+    return join5(memoryRoot2(this.cwd), INDEX_FILENAME);
   }
   getTopicsPath() {
-    return join3(memoryRoot2(this.cwd), TOPICS_DIRNAME);
+    return join5(memoryRoot2(this.cwd), TOPICS_DIRNAME);
   }
   loadStartupMemory() {
     const path = this.getIndexPath();
@@ -1122,7 +1480,7 @@ var ProjectMemoryStore = class {
     const topicsPath = this.getTopicsPath();
     const topics = existsSync3(topicsPath) ? readdirSync2(topicsPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TOPIC_EXTENSION)).map((entry) => ({
       name: basename2(entry.name, TOPIC_EXTENSION),
-      path: join3(topicsPath, entry.name)
+      path: join5(topicsPath, entry.name)
     })).sort((a, b) => a.name.localeCompare(b.name)) : [];
     return {
       indexPath: this.getIndexPath(),
@@ -1132,7 +1490,7 @@ var ProjectMemoryStore = class {
   }
   readTopic(topic) {
     const normalized = sanitizeTopic(topic);
-    const path = join3(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
+    const path = join5(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
     if (!existsSync3(path)) return "";
     return readFileSync3(path, "utf8").trimEnd();
   }
@@ -1142,7 +1500,7 @@ var ProjectMemoryStore = class {
     const topicsPath = this.getTopicsPath();
     mkdirSync2(topicsPath, { recursive: true });
     const indexPath = this.getIndexPath();
-    const topicPath = join3(topicsPath, `${topic}${TOPIC_EXTENSION}`);
+    const topicPath = join5(topicsPath, `${topic}${TOPIC_EXTENSION}`);
     const entry = formatEntry(this.now(), input, topic);
     const topicHeader = existsSync3(topicPath) ? "" : `# ${topic}
 
@@ -1254,24 +1612,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) {
@@ -1294,7 +1634,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}`;
@@ -1308,6 +1650,37 @@ 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
 import { Session } from "@robota-sdk/agent-sessions";
 
@@ -1340,12 +1713,147 @@ function assembleSubagentPrompt(options) {
   return parts.join("\n\n");
 }
 
+// src/tools/model-command-tool-projection.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+import { createZodFunctionTool } from "@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 = 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 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 z.object({
+    args: 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;
 }
@@ -1359,7 +1867,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) {
@@ -1454,8 +1964,8 @@ function getBuiltInAgent(name) {
 }
 
 // src/tools/agent-tool.ts
-import { z } from "zod";
-import { createZodFunctionTool } from "@robota-sdk/agent-tools";
+import { z as z2 } from "zod";
+import { createZodFunctionTool as createZodFunctionTool2 } from "@robota-sdk/agent-tools";
 import { SubagentManager } from "@robota-sdk/agent-runtime";
 
 // src/subagents/in-process-subagent-runner.ts
@@ -1685,35 +2195,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 = z.object({
-  prompt: z.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
-  subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
-  model: z.string().optional().describe("Optional model override"),
-  isolation: z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
-  jobs: z.array(
-    z.object({
-      label: z.string().optional().describe("Stable role label for this batch job"),
-      prompt: z.string().describe("The task for this subagent to perform"),
-      subagent_type: z.string().optional().describe("Agent type for this job"),
-      model: z.string().optional().describe("Optional model override for this job"),
-      isolation: z.enum(["none", "worktree"]).optional().describe("Isolation for this job")
+var AgentSchema = z2.object({
+  prompt: z2.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
+  subagent_type: z2.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: z2.string().optional().describe("Optional model override"),
+  isolation: z2.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
+  jobs: z2.array(
+    z2.object({
+      label: z2.string().optional().describe("Stable role label for this batch job"),
+      prompt: z2.string().describe("The task for this subagent to perform"),
+      subagent_type: z2.string().optional().describe("Agent type for this job"),
+      model: z2.string().optional().describe("Optional model override for this job"),
+      isolation: z2.enum(["none", "worktree"]).optional().describe("Isolation for this job")
     }).passthrough()
   ).optional().describe("Batch of subagent jobs to start in one Agent tool call")
 }).passthrough();
@@ -1838,10 +2334,10 @@ async function runManagedAgent(args, deps, manager) {
 }
 function createAgentTool(deps) {
   const manager = createSubagentManager(deps);
-  return createZodFunctionTool(
+  return createZodFunctionTool2(
     "Agent",
     AGENT_TOOL_DESCRIPTION,
-    asZodSchema(AgentSchema),
+    asZodSchema2(AgentSchema),
     async (params) => {
       const args = params;
       if (Array.isArray(args.jobs) && args.jobs.length > 0) {
@@ -1945,8 +2441,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 };
   }
@@ -2061,7 +2557,11 @@ function cloneGroup(group) {
 import {
   getBackgroundTaskTransitions,
   isTerminalBackgroundTaskStatus as isTerminalBackgroundTaskStatus2,
-  transitionBackgroundTaskStatus
+  transitionBackgroundTaskStatus,
+  appendPrefixedLogLines,
+  createBackgroundTaskLogPage,
+  createLimitedOutputCapture,
+  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE
 } from "@robota-sdk/agent-runtime";
 import { BackgroundTaskError } from "@robota-sdk/agent-runtime";
 
@@ -2075,8 +2575,385 @@ function retrieveSessionBackgroundTaskManager(key) {
 }
 
 // src/interactive/interactive-session-execution.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { collectAssistantUsageMetadata } from "@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
+import { randomUUID } from "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_${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
+import { readFile, realpath, stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+
+// src/context/prompt-file-reference-paths.ts
+import { homedir as homedir3 } from "os";
+import { isAbsolute, relative as pathRelative, resolve, sep as pathSeparator } from "path";
+function resolveCandidatePath(referencePath, rootPath) {
+  if (referencePath.startsWith("~/")) {
+    return resolve(homedir3(), referencePath.slice("~/".length));
+  }
+  if (isAbsolute(referencePath)) {
+    return resolve(referencePath);
+  }
+  return resolve(rootPath, referencePath);
+}
+function isPathWithinRoot(candidatePath, rootPath) {
+  const relativePath = pathRelative(rootPath, candidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function normalizeRelativePath(rootPath, sourcePath) {
+  return pathRelative(rootPath, sourcePath).split(pathSeparator).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 realpath(cwd);
+  } catch {
+    return resolve2(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 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 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 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"));
 }
@@ -2092,7 +2969,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 {
@@ -2100,7 +2977,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) {
@@ -2121,13 +2999,50 @@ function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefor
 }
 function createUsageSummaryEntry(usage) {
   return {
-    id: `usage_${randomUUID()}`,
+    id: `usage_${randomUUID2()}`,
     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;
@@ -2154,34 +3069,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: () => {
   },
@@ -2198,8 +3085,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
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { readFileSync as readFileSync4 } from "fs";
 var TOOL_ARG_DISPLAY_MAX = 80;
 var TAIL_KEEP = 30;
@@ -2297,7 +3251,7 @@ function pushToolSummaryToHistory(state) {
     return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
   }).join("\n");
   state.history.push({
-    id: randomUUID2(),
+    id: randomUUID3(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-summary",
@@ -2333,7 +3287,7 @@ function applyToolStart(state, event) {
   const toolState = { toolName: event.toolName, firstArg, isRunning: true };
   state.activeTools.push(toolState);
   state.history.push({
-    id: randomUUID2(),
+    id: randomUUID3(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-start",
@@ -2355,7 +3309,7 @@ function applyToolEnd(state, event) {
   state.activeTools[idx] = finished;
   state.activeTools = trimCompletedTools(state.activeTools);
   state.history.push({
-    id: randomUUID2(),
+    id: randomUUID3(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-end",
@@ -2372,113 +3326,113 @@ function applyToolEnd(state, event) {
 
 // src/config/config-loader.ts
 import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 
 // src/config/config-types.ts
-import { z as z2 } from "zod";
-var UniversalValueSchema = z2.lazy(
-  () => z2.union([
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.null(),
-    z2.undefined(),
-    z2.date(),
-    z2.array(UniversalValueSchema),
-    z2.record(UniversalValueSchema)
+import { z as z3 } from "zod";
+var UniversalValueSchema = z3.lazy(
+  () => z3.union([
+    z3.string(),
+    z3.number(),
+    z3.boolean(),
+    z3.null(),
+    z3.undefined(),
+    z3.date(),
+    z3.array(UniversalValueSchema),
+    z3.record(UniversalValueSchema)
   ])
 );
-var ProviderSchema = z2.object({
-  name: z2.string().optional(),
-  model: z2.string().optional(),
-  apiKey: z2.string().optional(),
-  baseURL: z2.string().optional(),
-  timeout: z2.number().optional(),
-  options: z2.record(UniversalValueSchema).optional()
+var ProviderSchema = z3.object({
+  name: z3.string().optional(),
+  model: z3.string().optional(),
+  apiKey: z3.string().optional(),
+  baseURL: z3.string().optional(),
+  timeout: z3.number().optional(),
+  options: z3.record(UniversalValueSchema).optional()
 });
-var ProviderProfileSchema = z2.object({
-  type: z2.string().optional(),
-  model: z2.string().optional(),
-  apiKey: z2.string().optional(),
-  baseURL: z2.string().optional(),
-  timeout: z2.number().optional(),
-  options: z2.record(UniversalValueSchema).optional()
+var ProviderProfileSchema = z3.object({
+  type: z3.string().optional(),
+  model: z3.string().optional(),
+  apiKey: z3.string().optional(),
+  baseURL: z3.string().optional(),
+  timeout: z3.number().optional(),
+  options: z3.record(UniversalValueSchema).optional()
 });
-var PermissionsSchema = z2.object({
+var PermissionsSchema = z3.object({
   /** Patterns that are always approved without prompting */
-  allow: z2.array(z2.string()).optional(),
+  allow: z3.array(z3.string()).optional(),
   /** Patterns that are always denied */
-  deny: z2.array(z2.string()).optional()
+  deny: z3.array(z3.string()).optional()
 });
-var EnvSchema = z2.record(z2.string()).optional();
-var CommandHookDefinitionSchema = z2.object({
-  type: z2.literal("command"),
-  command: z2.string(),
-  timeout: z2.number().optional()
+var EnvSchema = z3.record(z3.string()).optional();
+var CommandHookDefinitionSchema = z3.object({
+  type: z3.literal("command"),
+  command: z3.string(),
+  timeout: z3.number().optional()
 });
-var HttpHookDefinitionSchema = z2.object({
-  type: z2.literal("http"),
-  url: z2.string(),
-  headers: z2.record(z2.string()).optional(),
-  timeout: z2.number().optional()
+var HttpHookDefinitionSchema = z3.object({
+  type: z3.literal("http"),
+  url: z3.string(),
+  headers: z3.record(z3.string()).optional(),
+  timeout: z3.number().optional()
 });
-var PromptHookDefinitionSchema = z2.object({
-  type: z2.literal("prompt"),
-  prompt: z2.string(),
-  model: z2.string().optional()
+var PromptHookDefinitionSchema = z3.object({
+  type: z3.literal("prompt"),
+  prompt: z3.string(),
+  model: z3.string().optional()
 });
-var AgentHookDefinitionSchema = z2.object({
-  type: z2.literal("agent"),
-  agent: z2.string(),
-  maxTurns: z2.number().optional(),
-  timeout: z2.number().optional()
+var AgentHookDefinitionSchema = z3.object({
+  type: z3.literal("agent"),
+  agent: z3.string(),
+  maxTurns: z3.number().optional(),
+  timeout: z3.number().optional()
 });
-var HookDefinitionSchema = z2.discriminatedUnion("type", [
+var HookDefinitionSchema = z3.discriminatedUnion("type", [
   CommandHookDefinitionSchema,
   HttpHookDefinitionSchema,
   PromptHookDefinitionSchema,
   AgentHookDefinitionSchema
 ]);
-var HookGroupSchema = z2.object({
-  matcher: z2.string(),
-  hooks: z2.array(HookDefinitionSchema)
+var HookGroupSchema = z3.object({
+  matcher: z3.string(),
+  hooks: z3.array(HookDefinitionSchema)
 });
-var HooksSchema = z2.object({
-  PreToolUse: z2.array(HookGroupSchema).optional(),
-  PostToolUse: z2.array(HookGroupSchema).optional(),
-  SessionStart: z2.array(HookGroupSchema).optional(),
-  SessionEnd: z2.array(HookGroupSchema).optional(),
-  Stop: z2.array(HookGroupSchema).optional(),
-  StopFailure: z2.array(HookGroupSchema).optional(),
-  PreCompact: z2.array(HookGroupSchema).optional(),
-  PostCompact: z2.array(HookGroupSchema).optional(),
-  UserPromptSubmit: z2.array(HookGroupSchema).optional(),
-  SubagentStart: z2.array(HookGroupSchema).optional(),
-  SubagentStop: z2.array(HookGroupSchema).optional(),
-  WorktreeCreate: z2.array(HookGroupSchema).optional(),
-  WorktreeRemove: z2.array(HookGroupSchema).optional()
+var HooksSchema = z3.object({
+  PreToolUse: z3.array(HookGroupSchema).optional(),
+  PostToolUse: z3.array(HookGroupSchema).optional(),
+  SessionStart: z3.array(HookGroupSchema).optional(),
+  SessionEnd: z3.array(HookGroupSchema).optional(),
+  Stop: z3.array(HookGroupSchema).optional(),
+  StopFailure: z3.array(HookGroupSchema).optional(),
+  PreCompact: z3.array(HookGroupSchema).optional(),
+  PostCompact: z3.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z3.array(HookGroupSchema).optional(),
+  SubagentStart: z3.array(HookGroupSchema).optional(),
+  SubagentStop: z3.array(HookGroupSchema).optional(),
+  WorktreeCreate: z3.array(HookGroupSchema).optional(),
+  WorktreeRemove: z3.array(HookGroupSchema).optional()
 }).optional();
-var EnabledPluginsSchema = z2.record(z2.boolean()).optional();
-var MarketplaceSourceSchema = z2.object({
-  source: z2.object({
-    type: z2.enum(["github", "git", "local", "url"]),
-    repo: z2.string().optional(),
-    url: z2.string().optional(),
-    path: z2.string().optional(),
-    ref: z2.string().optional()
+var EnabledPluginsSchema = z3.record(z3.boolean()).optional();
+var MarketplaceSourceSchema = z3.object({
+  source: z3.object({
+    type: z3.enum(["github", "git", "local", "url"]),
+    repo: z3.string().optional(),
+    url: z3.string().optional(),
+    path: z3.string().optional(),
+    ref: z3.string().optional()
   })
 });
-var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional().catch(void 0);
-var AutoCompactThresholdSchema = z2.union([z2.number().gt(0).lte(1), z2.literal(false)]).optional();
-var SettingsSchema = z2.object({
+var ExtraKnownMarketplacesSchema = z3.record(MarketplaceSourceSchema).optional().catch(void 0);
+var AutoCompactThresholdSchema = z3.union([z3.number().gt(0).lte(1), z3.literal(false)]).optional();
+var SettingsSchema = z3.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: z3.enum(["safe", "moderate", "full"]).optional(),
   /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: z2.string().optional(),
+  language: z3.string().optional(),
   /** Active provider profile key from providers. */
-  currentProvider: z2.string().optional(),
+  currentProvider: z3.string().optional(),
   /** Provider profiles keyed by user-facing profile name. */
-  providers: z2.record(ProviderProfileSchema).optional(),
+  providers: z3.record(ProviderProfileSchema).optional(),
   /** Legacy single-provider settings. Prefer currentProvider + providers for new config. */
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
@@ -2532,18 +3486,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 {
@@ -2557,6 +3505,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 {
@@ -2590,22 +3544,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,
@@ -2635,17 +3599,17 @@ function toResolvedConfig(merged) {
 function getSettingsPaths(cwd) {
   const home = getHomeDir();
   return [
-    join4(home, ".robota", "settings.json"),
+    join6(home, ".robota", "settings.json"),
     // 1. user (lowest)
-    join4(home, ".claude", "settings.json"),
+    join6(home, ".claude", "settings.json"),
     // 1b. user (Claude Code compat)
-    join4(cwd, ".robota", "settings.json"),
+    join6(cwd, ".robota", "settings.json"),
     // 2. project
-    join4(cwd, ".robota", "settings.local.json"),
+    join6(cwd, ".robota", "settings.local.json"),
     // 3. project-local
-    join4(cwd, ".claude", "settings.json"),
+    join6(cwd, ".claude", "settings.json"),
     // 4. project, Claude Code compat
-    join4(cwd, ".claude", "settings.local.json")
+    join6(cwd, ".claude", "settings.local.json")
     // 5. project-local (highest)
   ];
 }
@@ -2882,9 +3846,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 = [];
@@ -2952,10 +3922,10 @@ function buildSystemPrompt(params) {
 
 // src/assembly/create-tools.ts
 import {
-  bashTool,
-  readTool,
-  writeTool,
-  editTool,
+  createBashTool,
+  createReadTool,
+  createWriteTool,
+  createEditTool,
   globTool,
   grepTool,
   webFetchTool,
@@ -2971,12 +3941,12 @@ 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 [
-    bashTool,
-    readTool,
-    writeTool,
-    editTool,
+    createBashTool(options),
+    createReadTool(options),
+    createWriteTool(options),
+    createEditTool(options),
     globTool,
     grepTool,
     webFetchTool,
@@ -2985,18 +3955,18 @@ function createDefaultTools() {
 }
 
 // src/tools/background-process-tool.ts
-import { z as z3 } from "zod";
-import { createZodFunctionTool as createZodFunctionTool2 } from "@robota-sdk/agent-tools";
+import { z as z4 } from "zod";
+import { createZodFunctionTool as createZodFunctionTool3 } from "@robota-sdk/agent-tools";
 var DEFAULT_PROCESS_TIMEOUT_MS = 12e4;
-function asZodSchema2(schema) {
+function asZodSchema3(schema) {
   return schema;
 }
-var BackgroundProcessSchema = z3.object({
-  command: z3.string().describe("The shell command to start in the background"),
-  timeout: z3.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
-  workingDirectory: z3.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
-  stdin: z3.string().optional().describe("Optional stdin to write after the process starts."),
-  outputLimitBytes: z3.number().optional().describe("Maximum captured output bytes kept in the task result.")
+var BackgroundProcessSchema = z4.object({
+  command: z4.string().describe("The shell command to start in the background"),
+  timeout: z4.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
+  workingDirectory: z4.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
+  stdin: z4.string().optional().describe("Optional stdin to write after the process starts."),
+  outputLimitBytes: z4.number().optional().describe("Maximum captured output bytes kept in the task result.")
 });
 function stringifyStarted(taskId, status, command) {
   return JSON.stringify({
@@ -3027,68 +3997,20 @@ async function startBackgroundProcess(args, deps) {
       cwd: args.workingDirectory ?? deps.cwd ?? process.cwd(),
       command: args.command,
       stdin: args.stdin,
-      timeoutMs: args.timeout ?? DEFAULT_PROCESS_TIMEOUT_MS,
-      outputLimitBytes: args.outputLimitBytes
-    });
-    return stringifyStarted(state.id, state.status, args.command);
-  } catch (error) {
-    return stringifyProcessError(error instanceof Error ? error.message : String(error));
-  }
-}
-function createBackgroundProcessTool(deps) {
-  return createZodFunctionTool2(
-    "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
-import { z as z4 } from "zod";
-import { createZodFunctionTool as createZodFunctionTool3 } from "@robota-sdk/agent-tools";
-var CommandExecutionSchema = z4.object({
-  command: z4.string().describe("Command name to execute, with or without a leading slash"),
-  args: z4.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}`
+      timeoutMs: args.timeout ?? DEFAULT_PROCESS_TIMEOUT_MS,
+      outputLimitBytes: args.outputLimitBytes
     });
+    return stringifyStarted(state.id, state.status, args.command);
+  } catch (error) {
+    return stringifyProcessError(error instanceof Error ? error.message : String(error));
   }
-  return JSON.stringify({
-    success: result.success,
-    command,
-    message: result.message,
-    data: result.data
-  });
 }
-function createCommandExecutionTool(deps) {
+function createBackgroundProcessTool(deps) {
   return createZodFunctionTool3(
-    "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)
   );
 }
 
@@ -3152,6 +4074,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,
@@ -3334,8 +4259,8 @@ import { BackgroundTaskManager as BackgroundTaskManager2, SubagentManager as Sub
 
 // src/agents/agent-definition-loader.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
-import { join as join5, basename as basename3 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join7, basename as basename3 } from "path";
+import { homedir as homedir4 } from "os";
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
 var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
 function parseListValue2(rawValue) {
@@ -3389,7 +4314,7 @@ function scanAgentsDir(dir) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join5(dir, entry.name);
+    const filePath = join7(dir, entry.name);
     const content = readFileSync6(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter2(content);
     const fallbackName = basename3(entry.name, ".md");
@@ -3412,16 +4337,16 @@ var AgentDefinitionLoader = class {
   home;
   constructor(cwd, home) {
     this.cwd = cwd;
-    this.home = home ?? homedir2();
+    this.home = home ?? homedir4();
   }
   /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
   loadAll() {
     const sources = [
-      scanAgentsDir(join5(this.cwd, ".robota", "agents")),
-      scanAgentsDir(join5(this.cwd, ".agents", "agents")),
-      scanAgentsDir(join5(this.cwd, ".claude", "agents")),
-      scanAgentsDir(join5(this.home, ".robota", "agents")),
-      scanAgentsDir(join5(this.home, ".claude", "agents"))
+      scanAgentsDir(join7(this.cwd, ".robota", "agents")),
+      scanAgentsDir(join7(this.cwd, ".agents", "agents")),
+      scanAgentsDir(join7(this.cwd, ".claude", "agents")),
+      scanAgentsDir(join7(this.home, ".robota", "agents")),
+      scanAgentsDir(join7(this.home, ".claude", "agents"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const customAgents = [];
@@ -3490,6 +4415,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(
@@ -3499,17 +4435,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
       })
     );
   }
@@ -3592,14 +4545,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,
@@ -3614,7 +4565,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
@@ -3688,50 +4639,28 @@ function logBackgroundTaskEvent(logger, sessionId, event) {
 
 // src/assembly/subagent-logger.ts
 import { mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { FileSessionLogger } from "@robota-sdk/agent-sessions";
 function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
-  const subagentDir = join6(baseLogsDir, parentSessionId, "subagents");
+  const subagentDir = join8(baseLogsDir, parentSessionId, "subagents");
   mkdirSync3(subagentDir, { recursive: true });
   return new FileSessionLogger(subagentDir);
 }
 function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
-  return join6(baseLogsDir, parentSessionId, "subagents");
+  return join8(baseLogsDir, parentSessionId, "subagents");
 }
 
 // src/interactive/interactive-session-init.ts
 import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
 
-// src/paths.ts
-import { join as join7 } from "path";
-import { homedir as homedir3 } from "os";
-function projectPaths(cwd) {
-  const base = join7(cwd, ".robota");
-  return {
-    settings: join7(base, "settings.json"),
-    settingsLocal: join7(base, "settings.local.json"),
-    logs: join7(base, "logs"),
-    sessions: join7(base, "sessions"),
-    memory: join7(base, "memory"),
-    checkpoints: join7(base, "checkpoints")
-  };
-}
-function userPaths() {
-  const base = join7(homedir3(), ".robota");
-  return {
-    settings: join7(base, "settings.json"),
-    sessions: join7(base, "sessions")
-  };
-}
-
 // src/context/context-loader.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-import { join as join9, dirname as dirname3, resolve as resolve2 } from "path";
+import { join as join10, dirname as dirname3, resolve as resolve4 } from "path";
 
 // src/context/task-context.ts
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { basename as basename4, dirname as dirname2, isAbsolute, join as join8, relative, resolve } from "path";
-var TASKS_DIR = join8(".agents", "tasks");
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute2, join as join9, relative, resolve as resolve3 } from "path";
+var TASKS_DIR = join9(".agents", "tasks");
 var README_FILENAME = "README.md";
 var MARKDOWN_EXTENSION = ".md";
 var DEFAULT_MAX_TASKS = Number("3");
@@ -3831,16 +4760,16 @@ function appendProgressEntry(content, now, progressMessage) {
   return lines.join("\n");
 }
 function resolveGitDirectory(cwd) {
-  let current = resolve(cwd);
+  let current = resolve3(cwd);
   let reachedRoot = false;
   while (!reachedRoot) {
-    const gitPath = join8(current, ".git");
+    const gitPath = join9(current, ".git");
     if (existsSync6(gitPath)) {
       const stats = statSync(gitPath);
       if (stats.isDirectory()) return gitPath;
       const content = readFileSync7(gitPath, "utf8").trim();
       const gitdir = content.match(/^gitdir:\s*(.+)$/)?.[1];
-      if (gitdir) return isAbsolute(gitdir) ? gitdir : resolve(current, gitdir);
+      if (gitdir) return isAbsolute2(gitdir) ? gitdir : resolve3(current, gitdir);
     }
     const parent = dirname2(current);
     reachedRoot = parent === current;
@@ -3851,18 +4780,18 @@ function resolveGitDirectory(cwd) {
 function readCurrentGitBranch(cwd) {
   const gitDir = resolveGitDirectory(cwd);
   if (!gitDir) return void 0;
-  const headPath = join8(gitDir, "HEAD");
+  const headPath = join9(gitDir, "HEAD");
   if (!existsSync6(headPath)) return void 0;
   const head = readFileSync7(headPath, "utf8").trim();
   const branch = head.match(/^ref:\s+refs\/heads\/(.+)$/)?.[1];
   return branch?.trim();
 }
 function discoverTaskFiles(cwd) {
-  const tasksDir = join8(cwd, TASKS_DIR);
+  const tasksDir = join9(cwd, TASKS_DIR);
   if (!existsSync6(tasksDir)) {
     return [];
   }
-  return readdirSync4(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) => join8(tasksDir, name));
+  return readdirSync4(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) => join9(tasksDir, name));
 }
 function parseTaskFile(taskPath, cwd) {
   const content = readFileSync7(taskPath, "utf8");
@@ -3902,10 +4831,10 @@ var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
   const found = [];
-  let current = resolve2(startDir);
+  let current = resolve4(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join9(current, filename);
+    const candidate = join10(current, filename);
     if (existsSync7(candidate)) {
       found.push(candidate);
     }
@@ -3956,7 +4885,7 @@ async function loadContext(cwd) {
 
 // src/context/project-detector.ts
 import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function tryReadJson(filePath) {
   if (!existsSync8(filePath)) return void 0;
   try {
@@ -3966,26 +4895,26 @@ function tryReadJson(filePath) {
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync8(join10(cwd, "pnpm-workspace.yaml")) || existsSync8(join10(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync8(join11(cwd, "pnpm-workspace.yaml")) || existsSync8(join11(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync8(join10(cwd, "yarn.lock"))) {
+  if (existsSync8(join11(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync8(join10(cwd, "bun.lockb"))) {
+  if (existsSync8(join11(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync8(join10(cwd, "package-lock.json"))) {
+  if (existsSync8(join11(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join10(cwd, "package.json");
-  const tsconfigPath = join10(cwd, "tsconfig.json");
-  const pyprojectPath = join10(cwd, "pyproject.toml");
-  const cargoPath = join10(cwd, "Cargo.toml");
-  const goModPath = join10(cwd, "go.mod");
+  const pkgJsonPath = join11(cwd, "package.json");
+  const tsconfigPath = join11(cwd, "tsconfig.json");
+  const pyprojectPath = join11(cwd, "pyproject.toml");
+  const cargoPath = join11(cwd, "Cargo.toml");
+  const goModPath = join11(cwd, "go.mod");
   if (existsSync8(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
     const language = existsSync8(tsconfigPath) ? "typescript" : "javascript";
@@ -3997,7 +4926,7 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync8(pyprojectPath) || existsSync8(join10(cwd, "setup.py"))) {
+  if (existsSync8(pyprojectPath) || existsSync8(join11(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
@@ -4124,7 +5053,7 @@ var PluginSettingsStore = class {
 
 // src/plugins/bundle-plugin-loader.ts
 import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/plugins/bundle-plugin-utils.ts
 import { existsSync as existsSync10, readdirSync as readdirSync5 } from "fs";
@@ -4208,22 +5137,22 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = join11(this.pluginsDir, "cache");
+    const cacheDir = join12(this.pluginsDir, "cache");
     if (!existsSync11(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = join11(cacheDir, marketplace);
+      const marketplaceDir = join12(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = join11(marketplaceDir, pluginName);
+        const pluginDir = join12(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = join11(pluginDir, latestVersion);
-        const manifestPath = join11(versionDir, ".claude-plugin", "plugin.json");
+        const versionDir = join12(pluginDir, latestVersion);
+        const manifestPath = join12(versionDir, ".claude-plugin", "plugin.json");
         if (!existsSync11(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
@@ -4273,13 +5202,13 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = join11(pluginDir, "skills");
+    const skillsDir = join12(pluginDir, "skills");
     if (!existsSync11(skillsDir)) return [];
     const entries = readdirSync6(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = join11(skillsDir, entry.name, "SKILL.md");
+      const skillFile = join12(skillsDir, entry.name, "SKILL.md");
       if (!existsSync11(skillFile)) continue;
       const raw = readFileSync11(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
@@ -4296,13 +5225,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = join11(pluginDir, "commands");
+    const commandsDir = join12(pluginDir, "commands");
     if (!existsSync11(commandsDir)) return [];
     const entries = readdirSync6(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = readFileSync11(join11(commandsDir, entry.name), "utf-8");
+      const raw = readFileSync11(join12(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 : "";
@@ -4317,7 +5246,7 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = join11(pluginDir, "hooks", "hooks.json");
+    const hooksPath = join12(pluginDir, "hooks", "hooks.json");
     if (!existsSync11(hooksPath)) return {};
     try {
       const raw = readFileSync11(hooksPath, "utf-8");
@@ -4332,8 +5261,8 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = join11(pluginDir, ".mcp.json");
-    const fallbackPath = join11(pluginDir, ".claude-plugin", "mcp.json");
+    const primaryPath = join12(pluginDir, ".mcp.json");
+    const fallbackPath = join12(pluginDir, ".claude-plugin", "mcp.json");
     const mcpPath = existsSync11(primaryPath) ? primaryPath : fallbackPath;
     if (!existsSync11(mcpPath)) return void 0;
     try {
@@ -4345,7 +5274,7 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = join11(pluginDir, "agents");
+    const agentsDir = join12(pluginDir, "agents");
     if (!existsSync11(agentsDir)) return [];
     try {
       const entries = readdirSync6(agentsDir, { withFileTypes: true });
@@ -4359,7 +5288,7 @@ var BundlePluginLoader = class {
 // src/plugins/bundle-plugin-installer.ts
 import { execSync as execSync2 } from "child_process";
 import { cpSync, existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync12, rmSync, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
+import { join as join13, dirname as dirname5 } from "path";
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -4370,8 +5299,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = join12(this.pluginsDir, "cache");
-    this.registryPath = join12(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = join13(this.pluginsDir, "cache");
+    this.registryPath = join13(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -4391,7 +5320,7 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = join12(this.cacheDir, marketplaceName, pluginName, version);
+    const targetDir = join13(this.cacheDir, marketplaceName, pluginName, version);
     if (existsSync12(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
@@ -4471,7 +5400,7 @@ var BundlePluginInstaller = class {
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = join12(marketplaceDir, source);
+        const sourcePath = join13(marketplaceDir, source);
         if (!existsSync12(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
@@ -4539,11 +5468,11 @@ var BundlePluginInstaller = class {
 // src/plugins/marketplace-client.ts
 import { execSync as execSync3 } from "child_process";
 import { cpSync as cpSync2, existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync14, renameSync, rmSync as rmSync3 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/plugins/marketplace-registry.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync13, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13, dirname as dirname6 } from "path";
+import { join as join14, dirname as dirname6 } from "path";
 function readRegistry(registryPath) {
   if (!existsSync13(registryPath)) {
     return {};
@@ -4567,7 +5496,7 @@ function writeRegistry(registryPath, registry) {
   writeFileSync6(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
-  const installedPath = join13(pluginsDir, "installed_plugins.json");
+  const installedPath = join14(pluginsDir, "installed_plugins.json");
   if (!existsSync13(installedPath)) return;
   let registry;
   try {
@@ -4607,8 +5536,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = join14(this.pluginsDir, "marketplaces");
-    this.registryPath = join14(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = join15(this.pluginsDir, "marketplaces");
+    this.registryPath = join15(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -4621,7 +5550,7 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = join14(this.marketplacesDir, tempName);
+    const tempDir = join15(this.marketplacesDir, tempName);
     mkdirSync7(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
       if (!existsSync14(source.path)) {
@@ -4638,7 +5567,7 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = join14(tempDir, ".claude-plugin", "marketplace.json");
+    const manifestPath = join15(tempDir, ".claude-plugin", "marketplace.json");
     if (!existsSync14(manifestPath)) {
       rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(
@@ -4656,7 +5585,7 @@ var MarketplaceClient = class {
       rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = join14(this.marketplacesDir, name);
+    const finalDir = join15(this.marketplacesDir, name);
     renameSync(tempDir, finalDir);
     registry[name] = {
       source,
@@ -4733,7 +5662,7 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = join14(entry.installLocation, ".claude-plugin", "marketplace.json");
+    const manifestPath = join15(entry.installLocation, ".claude-plugin", "marketplace.json");
     if (!existsSync14(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
@@ -4815,9 +5744,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-import { join as join15, dirname as dirname7 } from "path";
+import { join as join16, dirname as dirname7 } from "path";
 function buildPluginEnv(plugin) {
-  const dataDir = join15(dirname7(dirname7(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = join16(dirname7(dirname7(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -4879,8 +5808,9 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
 }
 
 // src/interactive/interactive-session-init.ts
-import { homedir as homedir4 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join17 } from "path";
+import { applyWorkspaceManifest } from "@robota-sdk/agent-tools";
 async function createInteractiveSession(options) {
   const cwd = options.cwd;
   const [config, context, projectInfo] = await Promise.all([
@@ -4888,7 +5818,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 = join16(homedir4(), ".robota", "plugins");
+  const pluginsDir = join17(homedir5(), ".robota", "plugins");
   const pluginLoader = new BundlePluginLoader(pluginsDir);
   let mergedConfig = config;
   if (!options.bare) {
@@ -4908,6 +5838,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,
@@ -4941,20 +5875,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 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) {
@@ -4968,8 +5919,11 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
       backgroundTaskEvents: [],
       backgroundJobGroups: [],
       backgroundJobGroupEvents: [],
+      skillActivationEvents: [],
       memoryEvents: [],
-      usedMemoryReferences: []
+      usedMemoryReferences: [],
+      contextReferences: [],
+      sandboxSnapshotId: void 0
     };
   }
   const history = record.history ?? [];
@@ -4977,8 +5931,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
@@ -5002,8 +5959,11 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
     backgroundTaskEvents,
     backgroundJobGroups,
     backgroundJobGroupEvents,
+    skillActivationEvents,
     memoryEvents,
-    usedMemoryReferences
+    usedMemoryReferences,
+    contextReferences,
+    sandboxSnapshotId
   };
 }
 function reconcileRestoredBackgroundTasks(tasks, events) {
@@ -5036,14 +5996,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
 import { access, copyFile, mkdir, rename, rm, writeFile } from "fs/promises";
 import { constants, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname8, join as join18, relative as relative3, resolve as resolve3 } from "path";
+import { dirname as dirname8, join as join19, relative as relative3, resolve as resolve5 } from "path";
 
 // src/checkpoints/edit-checkpoint-inspection.ts
 import { statSync as statSync2 } from "fs";
-import { join as join17, relative as relative2 } from "path";
+import { join as join18, relative as relative2 } from "path";
 function buildEditCheckpointInspection(input) {
   const later = input.manifests.filter((manifest) => manifest.sequence > input.target.sequence);
   const rollbackRange = input.manifests.filter(
@@ -5052,7 +6060,7 @@ function buildEditCheckpointInspection(input) {
   return {
     target: toSummary(input.target),
     capturedFiles: input.target.files.map((file) => {
-      const snapshotPath = file.snapshotFile ? join17(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
+      const snapshotPath = file.snapshotFile ? join18(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
       const snapshotStats = snapshotPath ? statSafe(snapshotPath) : void 0;
       return {
         originalPath: file.originalPath,
@@ -5102,7 +6110,7 @@ var EditCheckpointStore = class {
   now;
   activeTurn = null;
   constructor(options) {
-    this.cwd = resolve3(options.cwd);
+    this.cwd = resolve5(options.cwd);
     this.rootDir = projectPaths(this.cwd).checkpoints;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
   }
@@ -5112,8 +6120,8 @@ var EditCheckpointStore = class {
     }
     const nextSequence = this.nextSequence(input.sessionId);
     const id = `turn-${String(nextSequence).padStart(ID_PAD, "0")}`;
-    const dir = join18(this.sessionDir(input.sessionId), id);
-    await mkdir(join18(dir, SNAPSHOT_DIR), { recursive: true });
+    const dir = join19(this.sessionDir(input.sessionId), id);
+    await mkdir(join19(dir, SNAPSHOT_DIR), { recursive: true });
     const manifest = {
       version: 1,
       id,
@@ -5133,7 +6141,7 @@ var EditCheckpointStore = class {
   }
   async captureFile(filePath) {
     if (!this.activeTurn) return;
-    const originalPath = resolve3(this.cwd, filePath);
+    const originalPath = resolve5(this.cwd, filePath);
     if (this.activeTurn.capturedPaths.has(originalPath)) return;
     if (isInside(this.rootDir, originalPath)) return;
     const record = await this.createFileRecord(originalPath, this.activeTurn);
@@ -5221,11 +6229,11 @@ var EditCheckpointStore = class {
         existed: false
       };
     }
-    const snapshotFile = join18(
+    const snapshotFile = join19(
       SNAPSHOT_DIR,
       `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
     );
-    await copyFile(originalPath, join18(active.dir, snapshotFile));
+    await copyFile(originalPath, join19(active.dir, snapshotFile));
     return {
       originalPath,
       existed: true,
@@ -5242,13 +6250,13 @@ var EditCheckpointStore = class {
     }
     await mkdir(dirname8(record.originalPath), { recursive: true });
     await copyFile(
-      join18(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+      join19(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
       record.originalPath
     );
   }
   loadManifests(sessionId) {
     const dir = this.sessionDir(sessionId);
-    return readDirSyncSafe(dir).map((entry) => join18(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) => join19(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);
@@ -5256,16 +6264,16 @@ var EditCheckpointStore = class {
   }
   async writeManifest(dir, manifest) {
     await mkdir(dir, { recursive: true });
-    const path = join18(dir, MANIFEST_FILE);
+    const path = join19(dir, MANIFEST_FILE);
     const tmp = `${path}.tmp`;
     await writeFile(tmp, JSON.stringify(manifest, null, 2), "utf8");
     await rename(tmp, path);
   }
   sessionDir(sessionId) {
-    return join18(this.rootDir, safePathSegment(sessionId));
+    return join19(this.rootDir, safePathSegment(sessionId));
   }
   checkpointDir(sessionId, checkpointId) {
-    return join18(this.sessionDir(sessionId), safePathSegment(checkpointId));
+    return join19(this.sessionDir(sessionId), safePathSegment(checkpointId));
   }
 };
 function toSummary2(manifest) {
@@ -5310,6 +6318,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;
@@ -5334,6 +6357,7 @@ var InteractiveSession = class {
   backgroundJobGroupEvents = [];
   memoryEvents = [];
   usedMemoryReferences = [];
+  contextReferences = [];
   editCheckpointStore = null;
   resumeSessionId;
   forkSession;
@@ -5342,15 +6366,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((module) => module.systemCommands ?? [])
     );
@@ -5363,34 +6388,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";
@@ -5416,6 +6455,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),
@@ -5462,36 +6505,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);
@@ -5507,12 +6616,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();
@@ -5532,6 +6660,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" });
     })();
@@ -5644,6 +6773,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);
   }
@@ -5745,18 +6899,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: randomUUID4(),
+        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) {
@@ -5870,9 +7069,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(
+        messageToHistoryEntry(createSystemMessage(`Sandbox snapshot error: ${err.message}`))
+      );
+      this.emit("error", err);
+    }
+  }
   startForkSkillExecution(displayInput) {
     this.executing = true;
     this.clearStreaming();
@@ -5888,7 +7108,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) {
@@ -5910,7 +7130,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);
@@ -5968,7 +7190,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);
       }
     }
   }
@@ -5980,8 +7202,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();
@@ -5990,7 +7226,8 @@ var InteractiveSession = class {
         this.getSessionOrThrow().getHistory(),
         this.history,
         historyBefore,
-        this.getContextState()
+        this.getContextState(),
+        preparedPrompt.promptFileReferenceRecords
       );
       this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
       if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
@@ -6029,10 +7266,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() });
@@ -6108,6 +7359,163 @@ var InteractiveSession = class {
   }
 };
 
+// src/interactive/session-persistence.ts
+import {
+  loadSessionLogEntries as loadSessionLogEntries2,
+  replaySessionLogEntries,
+  SessionStore
+} from "@robota-sdk/agent-sessions";
+import { existsSync as existsSync15, readdirSync as readdirSync8 } from "fs";
+import { join as join20 } from "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 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 = replaySessionLogEntries(
+      loadSessionLogEntries2(join20(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 || !existsSync15(this.logsDir)) {
+      return [];
+    }
+    return readdirSync8(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({
@@ -6121,14 +7529,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();
@@ -6150,17 +7558,6 @@ function createQuery(options) {
   };
 }
 
-// src/types.ts
-import { TRUST_TO_MODE } from "@robota-sdk/agent-core";
-
-// src/index.ts
-import {
-  isChatEntry,
-  chatEntryToMessage,
-  messageToHistoryEntry as messageToHistoryEntry2,
-  getMessagesForAPI
-} from "@robota-sdk/agent-core";
-
 // src/self-hosting/self-hosting-verification.ts
 var DEFAULT_BASE_REF = "origin/develop";
 var PACKAGE_VERIFY_COMMANDS = ["test", "typecheck", "build"];
@@ -6276,13 +7673,72 @@ function transitionSelfHostingLoop(state, event) {
   return nextState;
 }
 
+// src/tools/command-execution-tool.ts
+import { z as z5 } from "zod";
+import { createZodFunctionTool as createZodFunctionTool4 } from "@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 ? z5.enum(validCommandNames).describe("Registered model-invocable command name to execute") : z5.string().describe("Registered model-invocable command name to execute");
+  return z5.object({
+    command: commandSchema,
+    args: z5.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 createZodFunctionTool4(
+    "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
 import { SubagentManager as SubagentManager3 } from "@robota-sdk/agent-runtime";
 import { WorktreeSubagentRunner, createWorktreeSubagentRunner } from "@robota-sdk/agent-runtime";
 
-// src/index.ts
-import { evaluatePermission } from "@robota-sdk/agent-core";
-
 // src/permissions/permission-prompt.ts
 import chalk from "chalk";
 var PERMISSION_OPTIONS = ["Allow", "Deny"];
@@ -6302,9 +7758,6 @@ async function promptForApproval(terminal, toolName, toolArgs) {
   const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
   return selected === ALLOW_INDEX;
 }
-
-// src/index.ts
-import { runHooks as runHooks2 } from "@robota-sdk/agent-core";
 export {
   AUTO_COMPACT_THRESHOLD_SETTINGS_KEY,
   AgentExecutor,
@@ -6321,6 +7774,7 @@ export {
   COST_COMMAND_DESCRIPTION,
   CommandRegistry,
   DEFAULT_AUTO_COMPACT_THRESHOLD,
+  DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE,
   DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
   EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore,
@@ -6335,12 +7789,14 @@ export {
   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,
@@ -6357,9 +7813,11 @@ export {
   SkillCommandSource,
   SubagentManager3 as SubagentManager,
   SystemCommandExecutor,
-  TRUST_TO_MODE,
+  VALIDATE_SESSION_COMMAND_DESCRIPTION,
   VALID_PERMISSION_MODES,
   WorktreeSubagentRunner,
+  addCommandContextReference,
+  appendPrefixedLogLines,
   assembleSubagentPrompt,
   buildBackgroundCommandSubcommands,
   buildLanguageCommandSubcommands,
@@ -6367,26 +7825,35 @@ export {
   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,
@@ -6396,48 +7863,57 @@ export {
   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,
   isTerminalBackgroundTaskStatus2 as isTerminalBackgroundTaskStatus,
+  listActiveContextReferences,
   listCommandBackgroundTasks,
+  listCommandContextReferences,
   listCommandEditCheckpoints,
   listCommandSessionAllowedTools,
   listCommandUsedMemoryReferences,
+  listResumableSessionSummaries,
   loadTaskContext,
   mergeProviderPatch,
-  messageToHistoryEntry2 as messageToHistoryEntry,
+  normalizeModelCommandName,
   parseCommandBackgroundLogCursor,
   parseFrontmatter,
   parseLanguageArgument,
   parsePermissionModeArgument,
+  parsePromptFileReferences,
   parseSessionNameArgument,
   parseTaskFile,
   planSelfHostingVerification,
@@ -6454,30 +7930,43 @@ export {
   readCommandSessionInfo,
   readCurrentGitBranch,
   recordCommandMemoryEvent,
+  removeCommandContextReference,
+  removeContextReference,
   resetAutoCompactThresholdSetting,
+  resolveActiveProviderModelCatalog,
+  resolveActiveProviderModelCatalogState,
   resolveEnvReference,
+  resolveLatestSessionId,
   resolvePermissionModeAdapter,
   resolvePluginCommandAdapter,
+  resolvePromptFileReferencePaths,
+  resolvePromptFileReferences,
   resolveProviderSetupSelection,
+  resolveSessionIdByIdOrName,
   resolveSubagentLogDir,
   restoreCommandEditCheckpoint,
   retrieveAgentToolDeps,
   rollbackCommandEditCheckpoint,
-  runHooks2 as runHooks,
   runProviderSetupPromptFlow,
+  sanitizeProviderProfileName,
   selectRelevantTasks,
   setCommandAutoCompactThreshold,
   setCurrentProvider,
   storeAgentToolDeps,
   submitProviderSetupValue,
   substituteVariables,
+  suggestProviderProfileName,
   summarizeBackgroundJobGroup,
   testProviderProfileCommand,
+  toContextReferenceRecords,
+  toPromptFileReferenceRecords,
   transitionBackgroundTaskStatus,
   transitionSelfHostingLoop,
   updateTaskFileStatus,
+  upsertContextReference,
   upsertProviderProfile,
   userPaths,
+  validateCommandSessionReplayLog,
   validateProviderProfile,
   validateProviderSetupValue,
   wrapEditCheckpointTools,