@robota-sdk/agent-sdk 3.0.0-beta.55 → 3.0.0-beta.57

package/dist/node/index.cjs

@@ -39,19 +39,23 @@ __export(index_exports, {
   BundlePluginInstaller: () => BundlePluginInstaller,
   BundlePluginLoader: () => BundlePluginLoader,
   CommandRegistry: () => CommandRegistry,
+  EditCheckpointStore: () => EditCheckpointStore,
   InteractiveSession: () => InteractiveSession,
+  MEMORY_INDEX_MAX_BYTES: () => MEMORY_INDEX_MAX_BYTES,
+  MEMORY_INDEX_MAX_LINES: () => MEMORY_INDEX_MAX_LINES,
   MarketplaceClient: () => MarketplaceClient,
   PluginCommandSource: () => PluginCommandSource,
   PluginSettingsStore: () => PluginSettingsStore,
+  ProjectMemoryStore: () => ProjectMemoryStore,
   PromptExecutor: () => PromptExecutor,
   SkillCommandSource: () => SkillCommandSource,
   SubagentManager: () => import_agent_runtime7.SubagentManager,
   SystemCommandExecutor: () => SystemCommandExecutor,
-  TRUST_TO_MODE: () => import_agent_core4.TRUST_TO_MODE,
+  TRUST_TO_MODE: () => import_agent_core5.TRUST_TO_MODE,
   WorktreeSubagentRunner: () => import_agent_runtime8.WorktreeSubagentRunner,
   assembleSubagentPrompt: () => assembleSubagentPrompt,
   buildSkillPrompt: () => buildSkillPrompt,
-  chatEntryToMessage: () => import_agent_core5.chatEntryToMessage,
+  chatEntryToMessage: () => import_agent_core6.chatEntryToMessage,
   createAgentTool: () => createAgentTool,
   createBackgroundProcessTool: () => createBackgroundProcessTool,
   createCommandExecutionTool: () => createCommandExecutionTool,
@@ -61,33 +65,44 @@ __export(index_exports, {
   createSubagentSession: () => createSubagentSession,
   createSystemCommands: () => createSystemCommands,
   createWorktreeSubagentRunner: () => import_agent_runtime8.createWorktreeSubagentRunner,
-  evaluatePermission: () => import_agent_core6.evaluatePermission,
+  discoverTaskFiles: () => discoverTaskFiles,
+  evaluatePermission: () => import_agent_core7.evaluatePermission,
   executeSkill: () => executeSkill,
+  formatTaskContext: () => formatTaskContext,
   getBackgroundTaskTransitions: () => import_agent_runtime4.getBackgroundTaskTransitions,
   getBuiltInAgent: () => getBuiltInAgent,
   getForkWorkerSuffix: () => getForkWorkerSuffix,
-  getMessagesForAPI: () => import_agent_core5.getMessagesForAPI,
+  getMessagesForAPI: () => import_agent_core6.getMessagesForAPI,
   getSubagentSuffix: () => getSubagentSuffix,
-  isChatEntry: () => import_agent_core5.isChatEntry,
+  isChatEntry: () => import_agent_core6.isChatEntry,
+  isMemoryType: () => isMemoryType,
   isTerminalBackgroundTaskStatus: () => import_agent_runtime4.isTerminalBackgroundTaskStatus,
-  messageToHistoryEntry: () => import_agent_core5.messageToHistoryEntry,
+  loadTaskContext: () => loadTaskContext,
+  messageToHistoryEntry: () => import_agent_core6.messageToHistoryEntry,
   parseFrontmatter: () => parseFrontmatter,
+  parseTaskFile: () => parseTaskFile,
+  planSelfHostingVerification: () => planSelfHostingVerification,
   preprocessShellCommands: () => preprocessShellCommands,
   projectPaths: () => projectPaths,
   promptForApproval: () => promptForApproval,
+  readCurrentGitBranch: () => readCurrentGitBranch,
   resolveSubagentLogDir: () => resolveSubagentLogDir,
   retrieveAgentToolDeps: () => retrieveAgentToolDeps,
-  runHooks: () => import_agent_core7.runHooks,
+  runHooks: () => import_agent_core8.runHooks,
+  selectRelevantTasks: () => selectRelevantTasks,
   storeAgentToolDeps: () => storeAgentToolDeps,
   substituteVariables: () => substituteVariables,
   summarizeBackgroundJobGroup: () => summarizeBackgroundJobGroup,
   transitionBackgroundTaskStatus: () => import_agent_runtime4.transitionBackgroundTaskStatus,
-  userPaths: () => userPaths
+  transitionSelfHostingLoop: () => transitionSelfHostingLoop,
+  updateTaskFileStatus: () => updateTaskFileStatus,
+  userPaths: () => userPaths,
+  wrapEditCheckpointTools: () => wrapEditCheckpointTools
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/interactive/interactive-session.ts
-var import_agent_core3 = require("@robota-sdk/agent-core");
+var import_agent_core4 = require("@robota-sdk/agent-core");
 
 // src/commands/capability-descriptors.ts
 function inferKind(command) {
@@ -186,6 +201,28 @@ function buildBackgroundSubcommands() {
     { name: "close", description: "Dismiss a terminal background task", source: "builtin" }
   ];
 }
+function buildRewindSubcommands() {
+  return [
+    { name: "list", description: "List edit checkpoints", source: "builtin" },
+    { name: "restore", description: "Restore code to a checkpoint", source: "builtin" },
+    { name: "code", description: "Restore code to a checkpoint", source: "builtin" }
+  ];
+}
+function buildMemorySubcommands() {
+  return [
+    { name: "list", description: "List project memory topics", source: "builtin" },
+    { name: "show", description: "Show project memory index or a topic", source: "builtin" },
+    { name: "add", description: "Save durable project memory", source: "builtin" },
+    { name: "pending", description: "List pending memory candidates", source: "builtin" },
+    { name: "approve", description: "Approve a pending memory candidate", source: "builtin" },
+    { name: "reject", description: "Reject a pending memory candidate", source: "builtin" },
+    {
+      name: "used",
+      description: "Show memory references used in the current turn",
+      source: "builtin"
+    }
+  ];
+}
 function createBuiltinCommands() {
   return [
     { name: "help", description: "Show available commands", source: "builtin" },
@@ -222,6 +259,18 @@ function createBuiltinCommands() {
     { name: "cost", description: "Show session info", source: "builtin" },
     { name: "context", description: "Context window info", source: "builtin" },
     { name: "permissions", description: "Permission rules", source: "builtin" },
+    {
+      name: "memory",
+      description: "Inspect, save, review, and audit project memory",
+      source: "builtin",
+      subcommands: buildMemorySubcommands()
+    },
+    {
+      name: "rewind",
+      description: "List and restore edit checkpoints",
+      source: "builtin",
+      subcommands: buildRewindSubcommands()
+    },
     {
       name: "provider",
       description: "Manage provider profiles",
@@ -468,8 +517,502 @@ Next offset: ${page.nextCursor.offset}` : "";
   return { message: `Unknown background action: ${action}`, success: false };
 }
 
+// src/memory/pending-memory-store.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var PENDING_FILENAME = "pending.json";
+function memoryRoot(cwd) {
+  return (0, import_node_path2.join)(cwd, ".robota", "memory");
+}
+function emptyDocument() {
+  return { version: 1, records: [] };
+}
+var PendingMemoryStore = class {
+  path;
+  now;
+  constructor(cwd, now = () => /* @__PURE__ */ new Date()) {
+    this.path = (0, import_node_path2.join)(memoryRoot(cwd), PENDING_FILENAME);
+    this.now = now;
+  }
+  getPath() {
+    return this.path;
+  }
+  list(status) {
+    const records = this.read().records;
+    return status ? records.filter((record) => record.status === status) : records;
+  }
+  get(id) {
+    return this.read().records.find((record) => record.id === id);
+  }
+  upsert(candidate, status, reason) {
+    const document = this.read();
+    const updatedAt = this.now().toISOString();
+    const existingIndex = document.records.findIndex((record2) => record2.id === candidate.id);
+    const record = {
+      ...candidate,
+      status,
+      updatedAt,
+      decisionReason: reason
+    };
+    if (existingIndex >= 0) {
+      document.records[existingIndex] = { ...document.records[existingIndex], ...record };
+    } else {
+      document.records.push(record);
+    }
+    this.write(document);
+  }
+  mark(id, status, reason) {
+    const document = this.read();
+    const index = document.records.findIndex((record2) => record2.id === id);
+    if (index < 0) throw new Error(`Memory candidate not found: ${id}`);
+    const record = {
+      ...document.records[index],
+      status,
+      updatedAt: this.now().toISOString(),
+      decisionReason: reason
+    };
+    document.records[index] = record;
+    this.write(document);
+    return record;
+  }
+  read() {
+    if (!(0, import_node_fs2.existsSync)(this.path)) return emptyDocument();
+    try {
+      const parsed = JSON.parse((0, import_node_fs2.readFileSync)(this.path, "utf8"));
+      return { version: 1, records: parsed.records ?? [] };
+    } catch {
+      return emptyDocument();
+    }
+  }
+  write(document) {
+    (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(this.path), { recursive: true });
+    (0, import_node_fs2.writeFileSync)(this.path, JSON.stringify(document, null, 2), "utf8");
+  }
+};
+
+// src/memory/project-memory-store.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var MEMORY_INDEX_MAX_LINES = 200;
+var MEMORY_INDEX_MAX_BYTES = Number("25600");
+var INDEX_FILENAME = "MEMORY.md";
+var TOPICS_DIRNAME = "topics";
+var DATE_LENGTH = 10;
+var MAX_TOPIC_LENGTH = 80;
+var DEFAULT_TOPIC = "general";
+var TOPIC_EXTENSION = ".md";
+var VALID_TYPES = ["user", "feedback", "project", "reference"];
+function isMemoryType(value) {
+  return VALID_TYPES.includes(value);
+}
+function memoryRoot2(cwd) {
+  return (0, import_path.join)(cwd, ".robota", "memory");
+}
+function truncateToUtf8Bytes(value, maxBytes) {
+  const buffer = Buffer.from(value, "utf8");
+  if (buffer.byteLength <= maxBytes) return value;
+  return buffer.subarray(0, maxBytes).toString("utf8");
+}
+function limitLines(value, maxLines) {
+  const lines = value.split(/\r?\n/);
+  const limited = lines.slice(0, maxLines);
+  return {
+    content: limited.join("\n").trimEnd(),
+    truncated: lines.length > maxLines
+  };
+}
+function sanitizeTopic(topic) {
+  const normalized = topic.trim().toLowerCase().replace(/[^a-z0-9가-힣_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_TOPIC_LENGTH);
+  return normalized || DEFAULT_TOPIC;
+}
+function formatEntry(date, input, topic) {
+  const day = date.toISOString().slice(0, DATE_LENGTH);
+  const text = input.text.trim().replace(/\s+/g, " ");
+  return `[${day}] (${input.type}/${topic}) ${text}`;
+}
+function normalizeMemoryText(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+var ProjectMemoryStore = class {
+  cwd;
+  now;
+  constructor(cwd, now = () => /* @__PURE__ */ new Date()) {
+    this.cwd = cwd;
+    this.now = now;
+  }
+  getIndexPath() {
+    return (0, import_path.join)(memoryRoot2(this.cwd), INDEX_FILENAME);
+  }
+  getTopicsPath() {
+    return (0, import_path.join)(memoryRoot2(this.cwd), TOPICS_DIRNAME);
+  }
+  loadStartupMemory() {
+    const path = this.getIndexPath();
+    if (!(0, import_fs.existsSync)(path)) {
+      return { content: "", path, lineCount: 0, truncated: false };
+    }
+    const raw = (0, import_fs.readFileSync)(path, "utf8");
+    const byBytes = truncateToUtf8Bytes(raw, MEMORY_INDEX_MAX_BYTES);
+    const byteTruncated = Buffer.byteLength(raw, "utf8") > MEMORY_INDEX_MAX_BYTES;
+    const byLines = limitLines(byBytes, MEMORY_INDEX_MAX_LINES);
+    return {
+      content: byLines.content,
+      path,
+      lineCount: byLines.content.length === 0 ? 0 : byLines.content.split(/\r?\n/).length,
+      truncated: byteTruncated || byLines.truncated
+    };
+  }
+  list() {
+    const topicsPath = this.getTopicsPath();
+    const topics = (0, import_fs.existsSync)(topicsPath) ? (0, import_fs.readdirSync)(topicsPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TOPIC_EXTENSION)).map((entry) => ({
+      name: (0, import_path.basename)(entry.name, TOPIC_EXTENSION),
+      path: (0, import_path.join)(topicsPath, entry.name)
+    })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+    return {
+      indexPath: this.getIndexPath(),
+      topicsPath,
+      topics
+    };
+  }
+  readTopic(topic) {
+    const normalized = sanitizeTopic(topic);
+    const path = (0, import_path.join)(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
+    if (!(0, import_fs.existsSync)(path)) return "";
+    return (0, import_fs.readFileSync)(path, "utf8").trimEnd();
+  }
+  append(input) {
+    const topic = sanitizeTopic(input.topic);
+    const root = memoryRoot2(this.cwd);
+    const topicsPath = this.getTopicsPath();
+    (0, import_fs.mkdirSync)(topicsPath, { recursive: true });
+    const indexPath = this.getIndexPath();
+    const topicPath = (0, import_path.join)(topicsPath, `${topic}${TOPIC_EXTENSION}`);
+    const entry = formatEntry(this.now(), input, topic);
+    const topicHeader = (0, import_fs.existsSync)(topicPath) ? "" : `# ${topic}
+
+`;
+    const normalizedText = normalizeMemoryText(input.text);
+    if ((0, import_fs.existsSync)(topicPath) && (0, import_fs.readFileSync)(topicPath, "utf8").includes(`) ${normalizedText}`)) {
+      return { indexPath, topicPath, topic, deduplicated: true };
+    }
+    if (!(0, import_fs.existsSync)(indexPath)) {
+      (0, import_fs.mkdirSync)(root, { recursive: true });
+      (0, import_fs.writeFileSync)(indexPath, "# Project Memory\n\n", "utf8");
+    }
+    (0, import_fs.appendFileSync)(indexPath, `- ${entry}
+`, "utf8");
+    (0, import_fs.appendFileSync)(topicPath, `${topicHeader}- ${entry}
+`, "utf8");
+    return { indexPath, topicPath, topic, deduplicated: false };
+  }
+};
+
+// src/memory/memory-policy-evaluator.ts
+var SENSITIVE_PATTERNS = [
+  /\b(api[_-]?key|secret|token|password|private key)\b/i,
+  /\b\d{3}-\d{2}-\d{4}\b/,
+  /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/,
+  /주민등록|비밀번호|시크릿|토큰/u
+];
+function containsSensitiveMemoryContent(text) {
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+// src/commands/memory-command.ts
+var SUBCOMMAND_INDEX = 0;
+var TYPE_INDEX = 1;
+var TOPIC_INDEX = 2;
+var TEXT_START_INDEX = 3;
+function usage() {
+  return {
+    message: "Usage: memory list | memory show [topic] | memory add <user|feedback|project|reference> <topic> <text> | memory pending | memory approve <id> | memory reject <id> | memory used",
+    success: false
+  };
+}
+function formatList(store) {
+  const summary = store.list();
+  const topics = summary.topics.length > 0 ? summary.topics.map((topic) => `- ${topic.name}: ${topic.path}`).join("\n") : "(none)";
+  return {
+    message: [
+      `Memory index: ${summary.indexPath}`,
+      `Topics directory: ${summary.topicsPath}`,
+      "Topics:",
+      topics
+    ].join("\n"),
+    success: true,
+    data: {
+      indexPath: summary.indexPath,
+      topicsPath: summary.topicsPath,
+      topicCount: summary.topics.length
+    }
+  };
+}
+function formatShow(store, topic) {
+  if (!topic || topic === "index") {
+    const memory = store.loadStartupMemory();
+    return {
+      message: memory.content || "(empty memory index)",
+      success: true,
+      data: {
+        path: memory.path,
+        lineCount: memory.lineCount,
+        truncated: memory.truncated
+      }
+    };
+  }
+  const content = store.readTopic(topic);
+  return {
+    message: content || `(empty memory topic: ${topic})`,
+    success: true,
+    data: { topic }
+  };
+}
+function parseAdd(args) {
+  const type = args[TYPE_INDEX];
+  const topic = args[TOPIC_INDEX];
+  const text = args.slice(TEXT_START_INDEX).join(" ").trim();
+  if (!type || !isMemoryType(type) || !topic || text.length === 0) return void 0;
+  return { type, topic, text };
+}
+function formatPending(store) {
+  const records = store.list("pending");
+  const lines = records.length > 0 ? records.map(
+    (record) => `- ${record.id} ${record.type}/${record.topic} confidence=${record.confidence}: ${record.text}`
+  ) : ["(no pending memory candidates)"];
+  return {
+    message: ["Pending memory candidates:", ...lines].join("\n"),
+    success: true,
+    data: { count: records.length }
+  };
+}
+function recordEvent(session, event) {
+  session.recordMemoryEvent({
+    ...event,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function approvePending(session, pendingStore, memoryStore, id) {
+  if (!id) return usage();
+  try {
+    const approved = pendingStore.mark(id, "approved", "approved-by-user");
+    const saved = memoryStore.append(approved);
+    const record = pendingStore.mark(id, "saved", "approved-and-saved");
+    recordEvent(session, {
+      type: "memory_candidate_approved",
+      candidateId: record.id,
+      topic: record.topic,
+      reason: "approved-by-user"
+    });
+    recordEvent(session, {
+      type: "memory_candidate_saved",
+      candidateId: record.id,
+      topic: record.topic,
+      reason: saved.deduplicated ? "deduplicated" : "approved-and-saved"
+    });
+    return {
+      message: saved.deduplicated ? `Saved memory candidate ${id} was already present in ${saved.topicPath}` : `Saved memory candidate ${id} to ${saved.topicPath}`,
+      success: true,
+      data: {
+        id,
+        status: record.status,
+        topic: saved.topic,
+        topicPath: saved.topicPath,
+        deduplicated: saved.deduplicated
+      }
+    };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      success: false
+    };
+  }
+}
+function rejectPending(session, pendingStore, id) {
+  if (!id) return usage();
+  try {
+    const record = pendingStore.mark(id, "rejected", "rejected-by-user");
+    recordEvent(session, {
+      type: "memory_candidate_rejected",
+      candidateId: record.id,
+      topic: record.topic,
+      reason: "rejected-by-user"
+    });
+    return {
+      message: `Rejected memory candidate ${id}`,
+      success: true,
+      data: { id, status: record.status }
+    };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      success: false
+    };
+  }
+}
+function formatUsed(session) {
+  const references = session.getUsedMemoryReferences();
+  const lines = references.length > 0 ? references.map((reference) => {
+    const suffix = reference.truncated ? " truncated=true" : "";
+    return `- ${reference.topic} score=${reference.score}${suffix}: ${reference.path}`;
+  }) : ["(no memory used in current turn)"];
+  return {
+    message: ["Used memory references:", ...lines].join("\n"),
+    success: true,
+    data: { count: references.length, references }
+  };
+}
+function executeMemoryCommand(session, rawArgs) {
+  const args = rawArgs.trim().split(/\s+/).filter(Boolean);
+  const subcommand = args[SUBCOMMAND_INDEX] ?? "list";
+  const store = new ProjectMemoryStore(session.getCwd());
+  const pendingStore = new PendingMemoryStore(session.getCwd());
+  if (subcommand === "list") return formatList(store);
+  if (subcommand === "show") return formatShow(store, args[TYPE_INDEX]);
+  if (subcommand === "pending") return formatPending(pendingStore);
+  if (subcommand === "approve")
+    return approvePending(session, pendingStore, store, args[TYPE_INDEX]);
+  if (subcommand === "reject") return rejectPending(session, pendingStore, args[TYPE_INDEX]);
+  if (subcommand === "used") return formatUsed(session);
+  if (subcommand === "add") {
+    const input = parseAdd(args);
+    if (!input) return usage();
+    if (containsSensitiveMemoryContent(input.text)) {
+      return {
+        message: "Refusing to save sensitive memory content.",
+        success: false
+      };
+    }
+    const result = store.append(input);
+    return {
+      message: result.deduplicated ? `${input.type} memory already exists in ${result.topicPath}` : `Saved ${input.type} memory to ${result.topicPath}`,
+      success: true,
+      data: {
+        indexPath: result.indexPath,
+        topicPath: result.topicPath,
+        topic: result.topic,
+        deduplicated: result.deduplicated
+      }
+    };
+  }
+  return usage();
+}
+
+// src/commands/rewind-command.ts
+var SUBCOMMAND_INDEX2 = 0;
+var CHECKPOINT_ID_INDEX = 1;
+var PROMPT_PREVIEW_LENGTH = 120;
+var ELLIPSIS_LENGTH = 3;
+function usage2() {
+  return {
+    message: "Usage: rewind [list] | rewind restore <checkpoint-id> | rewind code <checkpoint-id>",
+    success: false
+  };
+}
+function formatPrompt(prompt) {
+  const compact = prompt.replace(/\s+/g, " ").trim();
+  if (compact.length <= PROMPT_PREVIEW_LENGTH) return compact;
+  return `${compact.slice(0, PROMPT_PREVIEW_LENGTH - ELLIPSIS_LENGTH)}...`;
+}
+function formatList2(checkpoints) {
+  const lines = checkpoints.length > 0 ? checkpoints.map(
+    (checkpoint) => `- ${checkpoint.id} files=${checkpoint.fileCount} ${checkpoint.createdAt} ${formatPrompt(
+      checkpoint.prompt
+    )}`
+  ) : ["(no edit checkpoints)"];
+  return {
+    message: ["Edit checkpoints:", ...lines].join("\n"),
+    success: true,
+    data: { count: checkpoints.length, checkpoints: [...checkpoints] }
+  };
+}
+async function restore(session, checkpointId) {
+  if (!checkpointId) return usage2();
+  try {
+    const result = await session.restoreEditCheckpoint(checkpointId);
+    return {
+      message: [
+        `Restored code to ${result.target.id}.`,
+        `Restored files: ${result.restoredFileCount}`,
+        `Rolled back checkpoints: ${result.restoredCheckpointCount}`
+      ].join("\n"),
+      success: true,
+      data: {
+        target: result.target,
+        restoredCheckpointCount: result.restoredCheckpointCount,
+        restoredFileCount: result.restoredFileCount,
+        removedCheckpointCount: result.removedCheckpointCount
+      }
+    };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      success: false
+    };
+  }
+}
+async function executeRewindCommand(session, rawArgs) {
+  const args = rawArgs.trim().split(/\s+/).filter(Boolean);
+  const subcommand = args[SUBCOMMAND_INDEX2] ?? "list";
+  if (subcommand === "list") {
+    return formatList2(session.listEditCheckpoints());
+  }
+  if (subcommand === "restore" || subcommand === "code") {
+    return restore(session, args[CHECKPOINT_ID_INDEX]);
+  }
+  return usage2();
+}
+
+// src/commands/system-command-executor.ts
+var SystemCommandExecutor = class {
+  commands;
+  constructor(commands) {
+    this.commands = /* @__PURE__ */ new Map();
+    for (const cmd of commands ?? createSystemCommands()) {
+      this.commands.set(cmd.name, cmd);
+    }
+  }
+  /** Register an additional command. */
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  /** Execute a command by name. Returns null if command not found. */
+  async execute(name, session, args) {
+    const cmd = this.commands.get(name);
+    if (!cmd) return null;
+    return await cmd.execute(session, args);
+  }
+  /** List all registered commands. */
+  listCommands() {
+    return [...this.commands.values()];
+  }
+  listModelInvocableCommands() {
+    return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
+      name: `/${command.name}`,
+      kind: "builtin-command",
+      description: command.description,
+      userInvocable: command.userInvocable !== false,
+      modelInvocable: true,
+      ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
+      ...command.safety ? { safety: command.safety } : {}
+    }));
+  }
+  isModelInvocable(name) {
+    return this.commands.get(name)?.modelInvocable === true;
+  }
+  async executeModelInvocable(name, session, args) {
+    if (!this.isModelInvocable(name)) return null;
+    return this.execute(name, session, args);
+  }
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+};
+
 // src/commands/system-command.ts
 var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+var MEMORY_COMMAND_DESCRIPTION = "Project memory command. Use it to inspect project memory when stored context may help, save durable preferences, project conventions, feedback, or references worth reusing across sessions, review pending candidates, and report memory provenance. Do not store secrets, credentials, or transient facts.";
+var MEMORY_COMMAND_ARGUMENT_HINT = "list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | approve <id> | reject <id> | used";
 function createSystemCommands() {
   return [
     {
@@ -487,6 +1030,8 @@ function createSystemCommands() {
           "  cost              \u2014 Show session info",
           "  context           \u2014 Context window info",
           "  permissions       \u2014 Permission rules",
+          "  memory            \u2014 Manage project memory and pending candidates",
+          "  rewind            \u2014 List or restore edit checkpoints",
           "  provider          \u2014 Provider profile status and switching",
           "  resume            \u2014 Resume a previous session",
           "  background        \u2014 List/cancel/close background tasks",
@@ -629,6 +1174,21 @@ Messages: ${messageCount}`,
         };
       }
     },
+    {
+      name: "memory",
+      description: MEMORY_COMMAND_DESCRIPTION,
+      modelInvocable: true,
+      argumentHint: MEMORY_COMMAND_ARGUMENT_HINT,
+      safety: "write",
+      execute: executeMemoryCommand
+    },
+    {
+      name: "rewind",
+      description: "List edit checkpoints or restore code to a previous checkpoint.",
+      argumentHint: "list | restore CHECKPOINT_ID | code CHECKPOINT_ID",
+      safety: "write",
+      execute: executeRewindCommand
+    },
     {
       name: "resume",
       description: "Resume a previous session",
@@ -671,51 +1231,6 @@ Messages: ${messageCount}`,
     }
   ];
 }
-var SystemCommandExecutor = class {
-  commands;
-  constructor(commands) {
-    this.commands = /* @__PURE__ */ new Map();
-    for (const cmd of commands ?? createSystemCommands()) {
-      this.commands.set(cmd.name, cmd);
-    }
-  }
-  /** Register an additional command. */
-  register(command) {
-    this.commands.set(command.name, command);
-  }
-  /** Execute a command by name. Returns null if command not found. */
-  async execute(name, session, args) {
-    const cmd = this.commands.get(name);
-    if (!cmd) return null;
-    return await cmd.execute(session, args);
-  }
-  /** List all registered commands. */
-  listCommands() {
-    return [...this.commands.values()];
-  }
-  listModelInvocableCommands() {
-    return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
-      name: `/${command.name}`,
-      kind: "builtin-command",
-      description: command.description,
-      userInvocable: command.userInvocable !== false,
-      modelInvocable: true,
-      ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
-      ...command.safety ? { safety: command.safety } : {}
-    }));
-  }
-  isModelInvocable(name) {
-    return this.commands.get(name)?.modelInvocable === true;
-  }
-  async executeModelInvocable(name, session, args) {
-    if (!this.isModelInvocable(name)) return null;
-    return this.execute(name, session, args);
-  }
-  /** Check if a command exists. */
-  hasCommand(name) {
-    return this.commands.has(name);
-  }
-};
 
 // src/utils/skill-prompt.ts
 var import_node_child_process = require("child_process");
@@ -1048,11 +1563,11 @@ function createInProcessSubagentRunner(deps) {
 
 // src/tools/agent-tool.ts
 var AGENT_TOOL_DESCRIPTION = [
-  "Creates one subagent job for delegated work in an isolated context.",
-  "One tool call creates one subagent job.",
+  "Creates delegated subagent jobs in isolated contexts.",
+  "Without jobs, one tool call creates one subagent job from prompt.",
+  "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested 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.",
-  "For multiple or parallel agents, create one Agent tool call per requested role in the current turn.",
   "Subagent jobs run as background tasks by default.",
   "The tool waits for a terminal result and returns completed, failed, or timed-out outcome data to the parent conversation.",
   "Execution is represented by a real tool call and runtime background task event."
@@ -1060,11 +1575,11 @@ var AGENT_TOOL_DESCRIPTION = [
 function createAgentToolPromptDescription(agentDefinitions = []) {
   const availableAgents = agentDefinitions.length > 0 ? ` Available agent types: ${agentDefinitions.map((agent) => `${agent.name} (${agent.description})`).join(", ")}.` : "";
   return [
-    "Agent \u2014 creates one isolated subagent job.",
-    "One Agent tool call corresponds to one subagent job.",
+    "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.",
     "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.",
-    "For multiple or parallel agents, create one Agent tool call per requested role in the current turn.",
     "The tool returns terminal result data.",
     "Runtime mode is background.",
     availableAgents
@@ -1074,10 +1589,18 @@ function asZodSchema(schema) {
   return schema;
 }
 var AgentSchema = import_zod.z.object({
-  prompt: import_zod.z.string().describe("The task for the subagent to perform"),
+  prompt: import_zod.z.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
   subagent_type: import_zod.z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
   model: import_zod.z.string().optional().describe("Optional model override"),
-  isolation: import_zod.z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.')
+  isolation: import_zod.z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
+  jobs: import_zod.z.array(
+    import_zod.z.object({
+      prompt: import_zod.z.string().describe("The task for this subagent to perform"),
+      subagent_type: import_zod.z.string().optional().describe("Agent type for this job"),
+      model: import_zod.z.string().optional().describe("Optional model override for this job"),
+      isolation: import_zod.z.enum(["none", "worktree"]).optional().describe("Isolation for this job")
+    }).passthrough()
+  ).optional().describe("Batch of subagent jobs to start in one Agent tool call")
 }).passthrough();
 var sessionDepsStore = /* @__PURE__ */ new WeakMap();
 function storeAgentToolDeps(key, deps) {
@@ -1140,7 +1663,22 @@ function stringifyAgentError(message, agentId) {
     agentId
   });
 }
+function stringifyAgentBatchResult(input) {
+  const successfulJobs = input.jobs.filter((job) => job.success);
+  const agentIds = input.jobs.map((job) => job.agentId).filter((agentId) => typeof agentId === "string" && agentId.length > 0);
+  return JSON.stringify({
+    success: input.jobs.every((job) => job.success),
+    output: successfulJobs.map((job) => job.output ?? "").filter(Boolean).join("\n\n"),
+    groupId: input.groupId,
+    agentIds,
+    jobs: input.jobs
+  });
+}
 async function runManagedAgent(args, deps, manager) {
+  if (typeof args.prompt !== "string" || args.prompt.length === 0) {
+    return stringifyAgentError("prompt is required when jobs is omitted");
+  }
+  const singleArgs = { ...args, prompt: args.prompt };
   const agentType = args.subagent_type ?? "general-purpose";
   const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
   if (!agentDef) {
@@ -1148,7 +1686,7 @@ async function runManagedAgent(args, deps, manager) {
   }
   let agentId;
   try {
-    const state = await manager.spawn(createSpawnRequest(args, agentType, agentDef, deps));
+    const state = await manager.spawn(createSpawnRequest(singleArgs, agentType, agentDef, deps));
     agentId = state.id;
     const response = await manager.wait(state.id);
     return stringifyAgentSuccess(response);
@@ -1157,14 +1695,86 @@ async function runManagedAgent(args, deps, manager) {
     return stringifyAgentError(message, agentId);
   }
 }
-function createAgentTool(deps) {
-  const manager = createSubagentManager(deps);
-  return (0, import_agent_tools.createZodFunctionTool)(
-    "Agent",
-    AGENT_TOOL_DESCRIPTION,
-    asZodSchema(AgentSchema),
-    async (params) => {
-      const args = params;
+function createBatchGroupId() {
+  return `agent_group_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+async function runManagedAgentBatch(jobs, deps, manager) {
+  const groupId = createBatchGroupId();
+  const resolvedJobs = jobs.map((job, index) => {
+    const agentType = job.subagent_type ?? "general-purpose";
+    const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
+    return { index, job, agentType, agentDef };
+  });
+  const invalidJobs = resolvedJobs.filter((job) => job.agentDef === void 0).map((job) => ({
+    index: job.index,
+    success: false,
+    subagent_type: job.agentType,
+    error: `Unknown agent type: ${job.agentType}`
+  }));
+  const validJobs = resolvedJobs.filter(
+    (job) => job.agentDef !== void 0
+  );
+  const startedJobs = await Promise.all(
+    validJobs.map(async (job) => {
+      try {
+        const state = await manager.spawn(
+          createSpawnRequest(job.job, job.agentType, job.agentDef, deps)
+        );
+        return { ...job, agentId: state.id, spawnError: void 0 };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ...job, agentId: void 0, spawnError: message };
+      }
+    })
+  );
+  const terminalJobs = await Promise.all(
+    startedJobs.map(async (job) => {
+      if (job.spawnError || !job.agentId) {
+        return {
+          index: job.index,
+          success: false,
+          subagent_type: job.agentType,
+          error: `Sub-agent error: ${job.spawnError ?? "missing agent id"}`
+        };
+      }
+      try {
+        const result = await manager.wait(job.agentId);
+        return {
+          index: job.index,
+          success: true,
+          agentId: result.jobId,
+          subagent_type: job.agentType,
+          output: result.output,
+          metadata: result.metadata
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          index: job.index,
+          success: false,
+          agentId: job.agentId,
+          subagent_type: job.agentType,
+          error: `Sub-agent error: ${message}`
+        };
+      }
+    })
+  );
+  const batchJobs = [...invalidJobs, ...terminalJobs].sort(
+    (left, right) => left.index - right.index
+  );
+  return stringifyAgentBatchResult({ groupId, jobs: batchJobs });
+}
+function createAgentTool(deps) {
+  const manager = createSubagentManager(deps);
+  return (0, import_agent_tools.createZodFunctionTool)(
+    "Agent",
+    AGENT_TOOL_DESCRIPTION,
+    asZodSchema(AgentSchema),
+    async (params) => {
+      const args = params;
+      if (Array.isArray(args.jobs) && args.jobs.length > 0) {
+        return runManagedAgentBatch(args.jobs, deps, manager);
+      }
       return runManagedAgent(
         {
           prompt: args.prompt,
@@ -1255,8 +1865,8 @@ var BackgroundJobOrchestrator = class {
   createRecord(state) {
     let resolveGroup = () => {
     };
-    const completion = new Promise((resolve2) => {
-      resolveGroup = resolve2;
+    const completion = new Promise((resolve4) => {
+      resolveGroup = resolve4;
     });
     return { state, completion, resolve: resolveGroup };
   }
@@ -1381,6 +1991,8 @@ function retrieveSessionBackgroundTaskManager(key) {
 }
 
 // src/interactive/interactive-session-execution.ts
+var import_node_crypto = require("crypto");
+var import_agent_core2 = require("@robota-sdk/agent-core");
 function isAbortError(err) {
   return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
 }
@@ -1398,11 +2010,13 @@ function extractToolSummaries(history, historyBefore) {
 }
 function buildResult(response, sessionHistory, interactiveHistory, historyBefore, contextState) {
   const toolSummaries = extractToolSummaries(sessionHistory, historyBefore);
+  const usage3 = extractTurnUsage(sessionHistory, historyBefore, contextState);
   return {
     response,
     history: interactiveHistory,
     toolSummaries,
-    contextState
+    contextState,
+    ...usage3 && { usage: usage3 }
   };
 }
 function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefore, contextState) {
@@ -1412,14 +2026,51 @@ function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefor
     const msg = sessionHistory[i];
     if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
   }
+  const usage3 = extractTurnUsage(sessionHistory, historyBefore, contextState);
   return {
     response: parts.join("\n\n"),
     history: interactiveHistory,
     toolSummaries,
-    contextState
+    contextState,
+    ...usage3 && { usage: usage3 }
+  };
+}
+function createUsageSummaryEntry(usage3) {
+  return {
+    id: `usage_${(0, import_node_crypto.randomUUID)()}`,
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "usage-summary",
+    data: usage3
+  };
+}
+function extractTurnUsage(sessionHistory, historyBefore, contextState) {
+  const turnMessages = sessionHistory.slice(historyBefore);
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let foundUsage = false;
+  for (const message of turnMessages) {
+    if (message.role !== "assistant") continue;
+    const usage3 = (0, import_agent_core2.collectAssistantUsageMetadata)(message);
+    if (!usage3) continue;
+    foundUsage = true;
+    promptTokens += usage3.inputTokens;
+    completionTokens += usage3.outputTokens;
+  }
+  if (!foundUsage) return void 0;
+  return {
+    kind: "exact",
+    scope: "turn",
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    contextUsedTokens: contextState.usedTokens,
+    contextMaxTokens: contextState.maxTokens,
+    contextUsedPercentage: contextState.usedPercentage,
+    costStatus: "unknown"
   };
 }
-function persistSession(sessionStore, session, sessionName, cwd, history, backgroundState) {
+function persistSession(sessionStore, session, sessionName, cwd, history, backgroundState, memoryState) {
   try {
     const sessionId = session.getSessionId();
     const existing = sessionStore.load(sessionId);
@@ -1438,6 +2089,10 @@ function persistSession(sessionStore, session, sessionName, cwd, history, backgr
         backgroundTaskEvents: [...backgroundState.events],
         backgroundJobGroups: [...backgroundState.groups ?? []],
         backgroundJobGroupEvents: [...backgroundState.groupEvents ?? []]
+      } : {},
+      ...memoryState ? {
+        memoryEvents: [...memoryState.events],
+        usedMemoryReferences: [...memoryState.usedReferences]
       } : {}
     });
   } catch {
@@ -1460,17 +2115,97 @@ var NOOP_TERMINAL = {
 };
 
 // src/interactive/interactive-session-streaming.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
+var import_node_fs3 = require("fs");
 var TOOL_ARG_DISPLAY_MAX = 80;
 var TAIL_KEEP = 30;
 var MAX_COMPLETED_TOOLS = 50;
 var STREAMING_FLUSH_INTERVAL_MS = 16;
+var DEFAULT_START_LINE = 1;
+var EDIT_DIFF_CONTEXT_LINES = 3;
 function extractFirstArg2(toolArgs) {
   if (!toolArgs) return "";
   const firstVal = Object.values(toolArgs)[0];
   const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
   return raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
 }
+function getStringArg(args, snake, camel) {
+  const value = args?.[snake] ?? args?.[camel];
+  return typeof value === "string" ? value : null;
+}
+function parseStartLine(toolResultData) {
+  if (!toolResultData) return DEFAULT_START_LINE;
+  try {
+    const parsed = JSON.parse(toolResultData);
+    return typeof parsed.startLine === "number" && Number.isFinite(parsed.startLine) ? parsed.startLine : DEFAULT_START_LINE;
+  } catch {
+    return DEFAULT_START_LINE;
+  }
+}
+function buildEditDiffState(event) {
+  if (event.toolName !== "Edit") return {};
+  const filePath = getStringArg(event.toolArgs, "file_path", "filePath");
+  const oldString = getStringArg(event.toolArgs, "old_string", "oldString");
+  const newString = getStringArg(event.toolArgs, "new_string", "newString");
+  if (!filePath || oldString === null || newString === null || oldString === newString) return {};
+  const startLine = parseStartLine(event.toolResultData);
+  return {
+    diffFile: filePath,
+    diffLines: buildEditDiffLinesWithContext(oldString, newString, startLine, filePath)
+  };
+}
+function buildEditDiffLines(oldString, newString, startLine) {
+  return [
+    ...oldString.split("\n").map((text, index) => ({
+      type: "remove",
+      text,
+      lineNumber: startLine + index
+    })),
+    ...newString.split("\n").map((text, index) => ({
+      type: "add",
+      text,
+      lineNumber: startLine + index
+    }))
+  ];
+}
+function buildEditDiffLinesWithContext(oldString, newString, startLine, filePath) {
+  const diffLines = buildEditDiffLines(oldString, newString, startLine);
+  let fileLines;
+  try {
+    fileLines = (0, import_node_fs3.readFileSync)(filePath, "utf8").split("\n");
+  } catch {
+    return diffLines;
+  }
+  const beforeContext = [];
+  const contextStart = Math.max(0, startLine - 1 - EDIT_DIFF_CONTEXT_LINES);
+  for (let index = contextStart; index < startLine - 1; index++) {
+    if (index < fileLines.length) {
+      beforeContext.push({ type: "context", text: fileLines[index], lineNumber: index + 1 });
+    }
+  }
+  const afterContext = [];
+  const afterStart = startLine - 1 + newString.split("\n").length;
+  for (let index = afterStart; index < afterStart + EDIT_DIFF_CONTEXT_LINES; index++) {
+    if (index < fileLines.length) {
+      afterContext.push({ type: "context", text: fileLines[index], lineNumber: index + 1 });
+    }
+  }
+  const hunkStart = beforeContext[0]?.lineNumber ?? diffLines[0]?.lineNumber ?? afterContext[0]?.lineNumber ?? startLine;
+  const oldLineCount = oldString.split("\n").length;
+  const newLineCount = newString.split("\n").length;
+  const oldHunkLineCount = beforeContext.length + oldLineCount + afterContext.length;
+  const newHunkLineCount = beforeContext.length + newLineCount + afterContext.length;
+  return [
+    {
+      type: "hunk",
+      text: `@@ -${hunkStart},${oldHunkLineCount} +${hunkStart},${newHunkLineCount} @@`,
+      lineNumber: hunkStart
+    },
+    ...beforeContext,
+    ...diffLines,
+    ...afterContext
+  ];
+}
 function pushToolSummaryToHistory(state) {
   if (state.activeTools.length === 0) return;
   const summary = state.activeTools.map((t) => {
@@ -1478,7 +2213,7 @@ function pushToolSummaryToHistory(state) {
     return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
   }).join("\n");
   state.history.push({
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-summary",
@@ -1487,7 +2222,10 @@ function pushToolSummaryToHistory(state) {
         toolName: t.toolName,
         firstArg: t.firstArg,
         isRunning: t.isRunning,
-        result: t.result
+        result: t.result,
+        diffFile: t.diffFile,
+        diffLines: t.diffLines,
+        toolResultData: t.toolResultData
       })),
       summary
     }
@@ -1511,7 +2249,7 @@ function applyToolStart(state, event) {
   const toolState = { toolName: event.toolName, firstArg, isRunning: true };
   state.activeTools.push(toolState);
   state.history.push({
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-start",
@@ -1523,11 +2261,17 @@ function applyToolEnd(state, event) {
   const result = event.denied ? "denied" : event.success === false ? "error" : "success";
   const idx = state.activeTools.findIndex((t) => t.toolName === event.toolName && t.isRunning);
   if (idx === -1) return null;
-  const finished = { ...state.activeTools[idx], isRunning: false, result };
+  const finished = {
+    ...state.activeTools[idx],
+    ...buildEditDiffState(event),
+    isRunning: false,
+    result,
+    toolResultData: event.toolResultData
+  };
   state.activeTools[idx] = finished;
   state.activeTools = trimCompletedTools(state.activeTools);
   state.history.push({
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-end",
@@ -1535,12 +2279,307 @@ function applyToolEnd(state, event) {
       toolName: finished.toolName,
       firstArg: finished.firstArg,
       isRunning: false,
-      result
+      result,
+      toolResultData: event.toolResultData
     }
   });
   return finished;
 }
 
+// src/config/config-loader.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/config/config-types.ts
+var import_zod2 = require("zod");
+var UniversalValueSchema = import_zod2.z.lazy(
+  () => import_zod2.z.union([
+    import_zod2.z.string(),
+    import_zod2.z.number(),
+    import_zod2.z.boolean(),
+    import_zod2.z.null(),
+    import_zod2.z.undefined(),
+    import_zod2.z.date(),
+    import_zod2.z.array(UniversalValueSchema),
+    import_zod2.z.record(UniversalValueSchema)
+  ])
+);
+var ProviderSchema = import_zod2.z.object({
+  name: import_zod2.z.string().optional(),
+  model: import_zod2.z.string().optional(),
+  apiKey: import_zod2.z.string().optional(),
+  baseURL: import_zod2.z.string().optional(),
+  timeout: import_zod2.z.number().optional(),
+  options: import_zod2.z.record(UniversalValueSchema).optional()
+});
+var ProviderProfileSchema = import_zod2.z.object({
+  type: import_zod2.z.string().optional(),
+  model: import_zod2.z.string().optional(),
+  apiKey: import_zod2.z.string().optional(),
+  baseURL: import_zod2.z.string().optional(),
+  timeout: import_zod2.z.number().optional(),
+  options: import_zod2.z.record(UniversalValueSchema).optional()
+});
+var PermissionsSchema = import_zod2.z.object({
+  /** Patterns that are always approved without prompting */
+  allow: import_zod2.z.array(import_zod2.z.string()).optional(),
+  /** Patterns that are always denied */
+  deny: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var EnvSchema = import_zod2.z.record(import_zod2.z.string()).optional();
+var CommandHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("command"),
+  command: import_zod2.z.string(),
+  timeout: import_zod2.z.number().optional()
+});
+var HttpHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("http"),
+  url: import_zod2.z.string(),
+  headers: import_zod2.z.record(import_zod2.z.string()).optional(),
+  timeout: import_zod2.z.number().optional()
+});
+var PromptHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("prompt"),
+  prompt: import_zod2.z.string(),
+  model: import_zod2.z.string().optional()
+});
+var AgentHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("agent"),
+  agent: import_zod2.z.string(),
+  maxTurns: import_zod2.z.number().optional(),
+  timeout: import_zod2.z.number().optional()
+});
+var HookDefinitionSchema = import_zod2.z.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
+var HookGroupSchema = import_zod2.z.object({
+  matcher: import_zod2.z.string(),
+  hooks: import_zod2.z.array(HookDefinitionSchema)
+});
+var HooksSchema = import_zod2.z.object({
+  PreToolUse: import_zod2.z.array(HookGroupSchema).optional(),
+  PostToolUse: import_zod2.z.array(HookGroupSchema).optional(),
+  SessionStart: import_zod2.z.array(HookGroupSchema).optional(),
+  SessionEnd: import_zod2.z.array(HookGroupSchema).optional(),
+  Stop: import_zod2.z.array(HookGroupSchema).optional(),
+  StopFailure: import_zod2.z.array(HookGroupSchema).optional(),
+  PreCompact: import_zod2.z.array(HookGroupSchema).optional(),
+  PostCompact: import_zod2.z.array(HookGroupSchema).optional(),
+  UserPromptSubmit: import_zod2.z.array(HookGroupSchema).optional(),
+  SubagentStart: import_zod2.z.array(HookGroupSchema).optional(),
+  SubagentStop: import_zod2.z.array(HookGroupSchema).optional(),
+  WorktreeCreate: import_zod2.z.array(HookGroupSchema).optional(),
+  WorktreeRemove: import_zod2.z.array(HookGroupSchema).optional()
+}).optional();
+var EnabledPluginsSchema = import_zod2.z.record(import_zod2.z.boolean()).optional();
+var MarketplaceSourceSchema = import_zod2.z.object({
+  source: import_zod2.z.object({
+    type: import_zod2.z.enum(["github", "git", "local", "url"]),
+    repo: import_zod2.z.string().optional(),
+    url: import_zod2.z.string().optional(),
+    path: import_zod2.z.string().optional(),
+    ref: import_zod2.z.string().optional()
+  })
+});
+var ExtraKnownMarketplacesSchema = import_zod2.z.record(MarketplaceSourceSchema).optional().catch(void 0);
+var SettingsSchema = import_zod2.z.object({
+  /** Trust level used when no --permission-mode flag is given */
+  defaultTrustLevel: import_zod2.z.enum(["safe", "moderate", "full"]).optional(),
+  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
+  language: import_zod2.z.string().optional(),
+  /** Active provider profile key from providers. */
+  currentProvider: import_zod2.z.string().optional(),
+  /** Provider profiles keyed by user-facing profile name. */
+  providers: import_zod2.z.record(ProviderProfileSchema).optional(),
+  /** Legacy single-provider settings. Prefer currentProvider + providers for new config. */
+  provider: ProviderSchema.optional(),
+  permissions: PermissionsSchema.optional(),
+  env: EnvSchema,
+  hooks: HooksSchema,
+  /** Plugin enablement map: plugin name -> enabled/disabled */
+  enabledPlugins: EnabledPluginsSchema,
+  /** Extra marketplace URLs for BundlePlugin discovery */
+  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
+});
+
+// src/config/config-loader.ts
+function getHomeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "/";
+}
+var DEFAULTS = {
+  defaultTrustLevel: "moderate",
+  provider: {
+    name: "anthropic",
+    model: "claude-opus-4-5",
+    apiKey: void 0
+  },
+  permissions: {
+    allow: [],
+    deny: []
+  },
+  env: {}
+};
+function readJsonFile(filePath) {
+  if (!(0, import_fs2.existsSync)(filePath)) {
+    return void 0;
+  }
+  const raw = (0, import_fs2.readFileSync)(filePath, "utf-8").trim();
+  if (raw.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function resolveEnvRef(value) {
+  const ENV_PREFIX = "$ENV:";
+  if (value.startsWith(ENV_PREFIX)) {
+    const varName = value.slice(ENV_PREFIX.length);
+    return process.env[varName] ?? value;
+  }
+  return value;
+}
+function resolveEnvRefs(settings) {
+  const provider = settings.provider?.apiKey !== void 0 ? {
+    ...settings.provider,
+    apiKey: resolveEnvRef(settings.provider.apiKey)
+  } : 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) }
+        }
+      ])
+    );
+    return {
+      ...settings,
+      provider,
+      providers
+    };
+  }
+  return {
+    ...settings,
+    provider
+  };
+}
+function mergeSettings(layers) {
+  return layers.reduce((merged, layer) => {
+    return {
+      ...merged,
+      ...layer,
+      provider: merged.provider !== void 0 || layer.provider !== void 0 ? { ...merged.provider, ...layer.provider } : void 0,
+      permissions: merged.permissions !== void 0 || layer.permissions !== void 0 ? {
+        allow: layer.permissions?.allow ?? merged.permissions?.allow,
+        deny: layer.permissions?.deny ?? merged.permissions?.deny
+      } : void 0,
+      env: {
+        ...merged.env ?? {},
+        ...layer.env ?? {}
+      },
+      providers: merged.providers !== void 0 || layer.providers !== void 0 ? mergeProviders(merged.providers, layer.providers) : void 0,
+      enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
+      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
+    };
+  }, {});
+}
+function mergeProviders(base, override) {
+  const result = { ...base ?? {} };
+  for (const [name, profile] of Object.entries(override ?? {})) {
+    result[name] = {
+      ...result[name],
+      ...profile
+    };
+  }
+  return result;
+}
+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 {
+    name: merged.provider?.name ?? DEFAULTS.provider.name,
+    model: merged.provider?.model ?? DEFAULTS.provider.model,
+    apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey,
+    ...merged.provider?.baseURL !== void 0 && { baseURL: merged.provider.baseURL },
+    ...merged.provider?.timeout !== void 0 && { timeout: merged.provider.timeout },
+    ...merged.provider?.options !== void 0 && { options: merged.provider.options }
+  };
+}
+function toResolvedConfig(merged) {
+  return {
+    defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
+    language: merged.language,
+    currentProvider: merged.currentProvider,
+    provider: resolveProvider(merged),
+    permissions: {
+      allow: merged.permissions?.allow ?? DEFAULTS.permissions.allow,
+      deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
+    },
+    env: merged.env ?? DEFAULTS.env,
+    hooks: merged.hooks ?? void 0,
+    enabledPlugins: merged.enabledPlugins ?? void 0,
+    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
+  };
+}
+function getSettingsPaths(cwd) {
+  const home = getHomeDir();
+  return [
+    (0, import_path2.join)(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    (0, import_path2.join)(home, ".claude", "settings.json"),
+    // 1b. user (Claude Code compat)
+    (0, import_path2.join)(cwd, ".robota", "settings.json"),
+    // 2. project
+    (0, import_path2.join)(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    (0, import_path2.join)(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    (0, import_path2.join)(cwd, ".claude", "settings.local.json")
+    // 5. project-local (highest)
+  ];
+}
+async function loadConfig(cwd) {
+  const allPaths = getSettingsPaths(cwd);
+  const rawEntries = [];
+  for (const filePath of allPaths) {
+    const raw = readJsonFile(filePath);
+    if (raw !== void 0) {
+      rawEntries.push({ raw, path: filePath });
+    }
+  }
+  const parsedLayers = rawEntries.map(({ raw, path }) => {
+    const result = SettingsSchema.safeParse(raw);
+    if (!result.success) {
+      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
+    }
+    return resolveEnvRefs(result.data);
+  });
+  const merged = mergeSettings(parsedLayers);
+  return toResolvedConfig(merged);
+}
+
 // src/hooks/prompt-executor.ts
 function extractJson(raw) {
   const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
@@ -1667,6 +2706,8 @@ var TRUST_LEVEL_LABELS = {
   moderate: "moderate",
   full: "full"
 };
+var PROJECT_MEMORY_PRIORITY = Number("25");
+var TASK_CONTEXT_PRIORITY = Number("27");
 function createSection(id, title, priority, content, source) {
   return { id, title, priority, content, source };
 }
@@ -1717,6 +2758,26 @@ function createClaudeMdSection(claudeMd) {
   if (claudeMd.trim().length === 0) return void 0;
   return createSection("project-claude-md", "Project Notes", 20, claudeMd, "project-instructions");
 }
+function createProjectMemorySection(memoryMd) {
+  if (memoryMd === void 0 || memoryMd.trim().length === 0) return void 0;
+  return createSection(
+    "project-memory",
+    "Project Memory",
+    PROJECT_MEMORY_PRIORITY,
+    memoryMd,
+    "project-instructions"
+  );
+}
+function createTaskContextSection(taskContext) {
+  if (taskContext === void 0 || taskContext.trim().length === 0) return void 0;
+  return createSection(
+    "active-task-context",
+    "Active Task Context",
+    TASK_CONTEXT_PRIORITY,
+    taskContext,
+    "project-instructions"
+  );
+}
 function createToolDescriptionSection(descriptions) {
   if (descriptions.length === 0) return void 0;
   return createSection(
@@ -1789,6 +2850,8 @@ function buildSystemPrompt(params) {
   const sections = [];
   appendOptionalSection(sections, createAgentsMdSection(params.agentsMd));
   appendOptionalSection(sections, createClaudeMdSection(params.claudeMd));
+  appendOptionalSection(sections, createProjectMemorySection(params.memoryMd));
+  appendOptionalSection(sections, createTaskContextSection(params.taskContext));
   appendOptionalSection(sections, createWorkingDirectorySection(params.cwd));
   sections.push(createProjectSection(params.projectInfo));
   appendOptionalSection(sections, createResponseLanguageSection(params.language));
@@ -1823,18 +2886,18 @@ function createDefaultTools() {
 }
 
 // src/tools/background-process-tool.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_agent_tools3 = require("@robota-sdk/agent-tools");
 var DEFAULT_PROCESS_TIMEOUT_MS = 12e4;
 function asZodSchema2(schema) {
   return schema;
 }
-var BackgroundProcessSchema = import_zod2.z.object({
-  command: import_zod2.z.string().describe("The shell command to start in the background"),
-  timeout: import_zod2.z.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
-  workingDirectory: import_zod2.z.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
-  stdin: import_zod2.z.string().optional().describe("Optional stdin to write after the process starts."),
-  outputLimitBytes: import_zod2.z.number().optional().describe("Maximum captured output bytes kept in the task result.")
+var BackgroundProcessSchema = import_zod3.z.object({
+  command: import_zod3.z.string().describe("The shell command to start in the background"),
+  timeout: import_zod3.z.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
+  workingDirectory: import_zod3.z.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
+  stdin: import_zod3.z.string().optional().describe("Optional stdin to write after the process starts."),
+  outputLimitBytes: import_zod3.z.number().optional().describe("Maximum captured output bytes kept in the task result.")
 });
 function stringifyStarted(taskId, status, command) {
   return JSON.stringify({
@@ -1883,11 +2946,11 @@ function createBackgroundProcessTool(deps) {
 }
 
 // src/tools/command-execution-tool.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var import_agent_tools4 = require("@robota-sdk/agent-tools");
-var CommandExecutionSchema = import_zod3.z.object({
-  command: import_zod3.z.string().describe("Command name to execute, with or without a leading slash"),
-  args: import_zod3.z.string().optional().describe("Arguments to pass to the command")
+var CommandExecutionSchema = import_zod4.z.object({
+  command: import_zod4.z.string().describe("Command name to execute, with or without a leading slash"),
+  args: import_zod4.z.string().optional().describe("Arguments to pass to the command")
 });
 function asZodSchema3(schema) {
   return schema;
@@ -1930,12 +2993,55 @@ function createCommandExecutionTool(deps) {
   );
 }
 
+// src/checkpoints/edit-checkpoint-tools.ts
+var CHECKPOINTED_TOOL_NAMES = /* @__PURE__ */ new Set(["Write", "Edit"]);
+function wrapEditCheckpointTools(tools, recorder) {
+  return tools.map(
+    (tool) => CHECKPOINTED_TOOL_NAMES.has(tool.getName()) ? new EditCheckpointToolWrapper(tool, recorder) : tool
+  );
+}
+var EditCheckpointToolWrapper = class {
+  constructor(delegate, recorder) {
+    this.delegate = delegate;
+    this.recorder = recorder;
+    this.schema = delegate.schema;
+  }
+  schema;
+  setEventService(eventService) {
+    this.delegate.setEventService(eventService);
+  }
+  async execute(parameters, context) {
+    const filePath = extractFilePath(parameters);
+    if (filePath) {
+      await this.recorder.captureFile(filePath);
+    }
+    return this.delegate.execute(parameters, context);
+  }
+  validate(parameters) {
+    return this.delegate.validate(parameters);
+  }
+  validateParameters(parameters) {
+    return this.delegate.validateParameters(parameters);
+  }
+  getDescription() {
+    return this.delegate.getDescription();
+  }
+  getName() {
+    return this.delegate.getName();
+  }
+};
+function extractFilePath(parameters) {
+  if (!parameters || typeof parameters !== "object") return void 0;
+  const value = parameters.filePath;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
 // src/assembly/create-session.ts
 var import_agent_runtime6 = require("@robota-sdk/agent-runtime");
 
 // src/agents/agent-definition-loader.ts
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
 var import_node_os2 = require("os");
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
 var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
@@ -1980,20 +3086,20 @@ function parseFrontmatter2(content) {
   };
 }
 function scanAgentsDir(dir) {
-  if (!(0, import_node_fs2.existsSync)(dir)) return [];
+  if (!(0, import_node_fs4.existsSync)(dir)) return [];
   const agents = [];
   let entries;
   try {
-    entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
+    entries = (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = (0, import_node_path2.join)(dir, entry.name);
-    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    const filePath = (0, import_node_path3.join)(dir, entry.name);
+    const content = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter2(content);
-    const fallbackName = (0, import_node_path2.basename)(entry.name, ".md");
+    const fallbackName = (0, import_node_path3.basename)(entry.name, ".md");
     const agent = {
       name: frontmatter?.name ?? fallbackName,
       description: frontmatter?.description ?? "",
@@ -2018,11 +3124,11 @@ var AgentDefinitionLoader = class {
   /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
   loadAll() {
     const sources = [
-      scanAgentsDir((0, import_node_path2.join)(this.cwd, ".robota", "agents")),
-      scanAgentsDir((0, import_node_path2.join)(this.cwd, ".agents", "agents")),
-      scanAgentsDir((0, import_node_path2.join)(this.cwd, ".claude", "agents")),
-      scanAgentsDir((0, import_node_path2.join)(this.home, ".robota", "agents")),
-      scanAgentsDir((0, import_node_path2.join)(this.home, ".claude", "agents"))
+      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".robota", "agents")),
+      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".agents", "agents")),
+      scanAgentsDir((0, import_node_path3.join)(this.cwd, ".claude", "agents")),
+      scanAgentsDir((0, import_node_path3.join)(this.home, ".robota", "agents")),
+      scanAgentsDir((0, import_node_path3.join)(this.home, ".claude", "agents"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const customAgents = [];
@@ -2049,7 +3155,7 @@ var AgentDefinitionLoader = class {
 };
 
 // src/assembly/background-task-hooks.ts
-var import_agent_core2 = require("@robota-sdk/agent-core");
+var import_agent_core3 = require("@robota-sdk/agent-core");
 function getSubagentHookEvent(event) {
   if (event.type === "background_task_started" && event.task.kind === "agent") {
     return "SubagentStart";
@@ -2084,7 +3190,7 @@ function fireSubagentLifecycleHook(event, cwd, hooks, hookTypeExecutors) {
       ROBOTA_AGENT_TYPE: event.task.agentType ?? event.task.label
     }
   };
-  void (0, import_agent_core2.runHooks)(hooks, hookEventName, input, hookTypeExecutors).catch(() => void 0);
+  void (0, import_agent_core3.runHooks)(hooks, hookEventName, input, hookTypeExecutors).catch(() => void 0);
 }
 
 // src/assembly/create-session.ts
@@ -2100,7 +3206,7 @@ function createSession(options) {
   const provider = options.provider;
   const cwd = options.cwd ?? process.cwd();
   const sessionId = options.sessionId ?? createSessionId();
-  const defaultTools = createDefaultTools();
+  const defaultTools = options.editCheckpointRecorder ? wrapEditCheckpointTools(createDefaultTools(), options.editCheckpointRecorder) : createDefaultTools();
   const tools = [...defaultTools, ...options.additionalTools ?? []];
   if (options.modelCommandExecutor && options.isModelCommandInvocable) {
     tools.push(
@@ -2201,6 +3307,8 @@ function createSession(options) {
   const systemMessage = buildPrompt({
     agentsMd: options.context.agentsMd,
     claudeMd: options.context.claudeMd,
+    memoryMd: options.context.memoryMd,
+    taskContext: options.context.taskContext,
     toolDescriptions: options.toolDescriptions ?? (backgroundProcessToolDeps ? [
       ...defaultToolDescriptions,
       "BackgroundProcess \u2014 start long-running shell commands as managed background tasks"
@@ -2254,6 +3362,7 @@ ${options.appendSystemPrompt}` : systemMessage;
     sessionId,
     permissionHandler: options.permissionHandler,
     onTextDelta: options.onTextDelta,
+    onContextUpdate: options.onContextUpdate,
     onToolExecution: options.onToolExecution,
     promptForApproval: options.promptForApproval,
     onCompact: options.onCompact,
@@ -2278,334 +3387,229 @@ function logBackgroundTaskEvent(logger, sessionId, event) {
 }
 
 // src/assembly/subagent-logger.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path4 = require("path");
 var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
 function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
-  const subagentDir = (0, import_node_path3.join)(baseLogsDir, parentSessionId, "subagents");
-  (0, import_node_fs3.mkdirSync)(subagentDir, { recursive: true });
+  const subagentDir = (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
+  (0, import_node_fs5.mkdirSync)(subagentDir, { recursive: true });
   return new import_agent_sessions3.FileSessionLogger(subagentDir);
 }
-function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
-  return (0, import_node_path3.join)(baseLogsDir, parentSessionId, "subagents");
-}
-
-// src/interactive/interactive-session-init.ts
-var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
-
-// src/paths.ts
-var import_node_path4 = require("path");
-var import_node_os3 = require("os");
-function projectPaths(cwd) {
-  const base = (0, import_node_path4.join)(cwd, ".robota");
-  return {
-    settings: (0, import_node_path4.join)(base, "settings.json"),
-    settingsLocal: (0, import_node_path4.join)(base, "settings.local.json"),
-    logs: (0, import_node_path4.join)(base, "logs"),
-    sessions: (0, import_node_path4.join)(base, "sessions")
-  };
-}
-function userPaths() {
-  const base = (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".robota");
-  return {
-    settings: (0, import_node_path4.join)(base, "settings.json"),
-    sessions: (0, import_node_path4.join)(base, "sessions")
-  };
-}
-
-// src/config/config-loader.ts
-var import_fs = require("fs");
-var import_path = require("path");
-
-// src/config/config-types.ts
-var import_zod4 = require("zod");
-var ProviderSchema = import_zod4.z.object({
-  name: import_zod4.z.string().optional(),
-  model: import_zod4.z.string().optional(),
-  apiKey: import_zod4.z.string().optional(),
-  baseURL: import_zod4.z.string().optional(),
-  timeout: import_zod4.z.number().optional()
-});
-var ProviderProfileSchema = import_zod4.z.object({
-  type: import_zod4.z.string().optional(),
-  model: import_zod4.z.string().optional(),
-  apiKey: import_zod4.z.string().optional(),
-  baseURL: import_zod4.z.string().optional(),
-  timeout: import_zod4.z.number().optional()
-});
-var PermissionsSchema = import_zod4.z.object({
-  /** Patterns that are always approved without prompting */
-  allow: import_zod4.z.array(import_zod4.z.string()).optional(),
-  /** Patterns that are always denied */
-  deny: import_zod4.z.array(import_zod4.z.string()).optional()
-});
-var EnvSchema = import_zod4.z.record(import_zod4.z.string()).optional();
-var CommandHookDefinitionSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("command"),
-  command: import_zod4.z.string(),
-  timeout: import_zod4.z.number().optional()
-});
-var HttpHookDefinitionSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("http"),
-  url: import_zod4.z.string(),
-  headers: import_zod4.z.record(import_zod4.z.string()).optional(),
-  timeout: import_zod4.z.number().optional()
-});
-var PromptHookDefinitionSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("prompt"),
-  prompt: import_zod4.z.string(),
-  model: import_zod4.z.string().optional()
-});
-var AgentHookDefinitionSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("agent"),
-  agent: import_zod4.z.string(),
-  maxTurns: import_zod4.z.number().optional(),
-  timeout: import_zod4.z.number().optional()
-});
-var HookDefinitionSchema = import_zod4.z.discriminatedUnion("type", [
-  CommandHookDefinitionSchema,
-  HttpHookDefinitionSchema,
-  PromptHookDefinitionSchema,
-  AgentHookDefinitionSchema
-]);
-var HookGroupSchema = import_zod4.z.object({
-  matcher: import_zod4.z.string(),
-  hooks: import_zod4.z.array(HookDefinitionSchema)
-});
-var HooksSchema = import_zod4.z.object({
-  PreToolUse: import_zod4.z.array(HookGroupSchema).optional(),
-  PostToolUse: import_zod4.z.array(HookGroupSchema).optional(),
-  SessionStart: import_zod4.z.array(HookGroupSchema).optional(),
-  SessionEnd: import_zod4.z.array(HookGroupSchema).optional(),
-  Stop: import_zod4.z.array(HookGroupSchema).optional(),
-  StopFailure: import_zod4.z.array(HookGroupSchema).optional(),
-  PreCompact: import_zod4.z.array(HookGroupSchema).optional(),
-  PostCompact: import_zod4.z.array(HookGroupSchema).optional(),
-  UserPromptSubmit: import_zod4.z.array(HookGroupSchema).optional(),
-  SubagentStart: import_zod4.z.array(HookGroupSchema).optional(),
-  SubagentStop: import_zod4.z.array(HookGroupSchema).optional(),
-  WorktreeCreate: import_zod4.z.array(HookGroupSchema).optional(),
-  WorktreeRemove: import_zod4.z.array(HookGroupSchema).optional()
-}).optional();
-var EnabledPluginsSchema = import_zod4.z.record(import_zod4.z.boolean()).optional();
-var MarketplaceSourceSchema = import_zod4.z.object({
-  source: import_zod4.z.object({
-    type: import_zod4.z.enum(["github", "git", "local", "url"]),
-    repo: import_zod4.z.string().optional(),
-    url: import_zod4.z.string().optional(),
-    path: import_zod4.z.string().optional(),
-    ref: import_zod4.z.string().optional()
-  })
-});
-var ExtraKnownMarketplacesSchema = import_zod4.z.record(MarketplaceSourceSchema).optional().catch(void 0);
-var SettingsSchema = import_zod4.z.object({
-  /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: import_zod4.z.enum(["safe", "moderate", "full"]).optional(),
-  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: import_zod4.z.string().optional(),
-  /** Active provider profile key from providers. */
-  currentProvider: import_zod4.z.string().optional(),
-  /** Provider profiles keyed by user-facing profile name. */
-  providers: import_zod4.z.record(ProviderProfileSchema).optional(),
-  /** Legacy single-provider settings. Prefer currentProvider + providers for new config. */
-  provider: ProviderSchema.optional(),
-  permissions: PermissionsSchema.optional(),
-  env: EnvSchema,
-  hooks: HooksSchema,
-  /** Plugin enablement map: plugin name -> enabled/disabled */
-  enabledPlugins: EnabledPluginsSchema,
-  /** Extra marketplace URLs for BundlePlugin discovery */
-  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
-});
-
-// src/config/config-loader.ts
-function getHomeDir() {
-  return process.env.HOME ?? process.env.USERPROFILE ?? "/";
-}
-var DEFAULTS = {
-  defaultTrustLevel: "moderate",
-  provider: {
-    name: "anthropic",
-    model: "claude-opus-4-5",
-    apiKey: void 0
-  },
-  permissions: {
-    allow: [],
-    deny: []
-  },
-  env: {}
-};
-function readJsonFile(filePath) {
-  if (!(0, import_fs.existsSync)(filePath)) {
-    return void 0;
-  }
-  const raw = (0, import_fs.readFileSync)(filePath, "utf-8").trim();
-  if (raw.length === 0) {
-    return void 0;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-}
-function resolveEnvRef(value) {
-  const ENV_PREFIX = "$ENV:";
-  if (value.startsWith(ENV_PREFIX)) {
-    const varName = value.slice(ENV_PREFIX.length);
-    return process.env[varName] ?? value;
-  }
-  return value;
-}
-function resolveEnvRefs(settings) {
-  const provider = settings.provider?.apiKey !== void 0 ? {
-    ...settings.provider,
-    apiKey: resolveEnvRef(settings.provider.apiKey)
-  } : 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) }
-        }
-      ])
-    );
-    return {
-      ...settings,
-      provider,
-      providers
-    };
-  }
-  return {
-    ...settings,
-    provider
-  };
-}
-function mergeSettings(layers) {
-  return layers.reduce((merged, layer) => {
-    return {
-      ...merged,
-      ...layer,
-      provider: merged.provider !== void 0 || layer.provider !== void 0 ? { ...merged.provider, ...layer.provider } : void 0,
-      permissions: merged.permissions !== void 0 || layer.permissions !== void 0 ? {
-        allow: layer.permissions?.allow ?? merged.permissions?.allow,
-        deny: layer.permissions?.deny ?? merged.permissions?.deny
-      } : void 0,
-      env: {
-        ...merged.env ?? {},
-        ...layer.env ?? {}
-      },
-      providers: merged.providers !== void 0 || layer.providers !== void 0 ? mergeProviders(merged.providers, layer.providers) : void 0,
-      enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
-      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
-    };
-  }, {});
-}
-function mergeProviders(base, override) {
-  const result = { ...base ?? {} };
-  for (const [name, profile] of Object.entries(override ?? {})) {
-    result[name] = {
-      ...result[name],
-      ...profile
-    };
-  }
-  return result;
+function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
+  return (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
 }
-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 }
-    };
-  }
+
+// src/interactive/interactive-session-init.ts
+var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+
+// src/paths.ts
+var import_node_path5 = require("path");
+var import_node_os3 = require("os");
+function projectPaths(cwd) {
+  const base = (0, import_node_path5.join)(cwd, ".robota");
   return {
-    name: merged.provider?.name ?? DEFAULTS.provider.name,
-    model: merged.provider?.model ?? DEFAULTS.provider.model,
-    apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey,
-    ...merged.provider?.baseURL !== void 0 && { baseURL: merged.provider.baseURL },
-    ...merged.provider?.timeout !== void 0 && { timeout: merged.provider.timeout }
+    settings: (0, import_node_path5.join)(base, "settings.json"),
+    settingsLocal: (0, import_node_path5.join)(base, "settings.local.json"),
+    logs: (0, import_node_path5.join)(base, "logs"),
+    sessions: (0, import_node_path5.join)(base, "sessions"),
+    memory: (0, import_node_path5.join)(base, "memory"),
+    checkpoints: (0, import_node_path5.join)(base, "checkpoints")
   };
 }
-function toResolvedConfig(merged) {
+function userPaths() {
+  const base = (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".robota");
   return {
-    defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
-    language: merged.language,
-    currentProvider: merged.currentProvider,
-    provider: resolveProvider(merged),
-    permissions: {
-      allow: merged.permissions?.allow ?? DEFAULTS.permissions.allow,
-      deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
-    },
-    env: merged.env ?? DEFAULTS.env,
-    hooks: merged.hooks ?? void 0,
-    enabledPlugins: merged.enabledPlugins ?? void 0,
-    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
+    settings: (0, import_node_path5.join)(base, "settings.json"),
+    sessions: (0, import_node_path5.join)(base, "sessions")
   };
 }
-function getSettingsPaths(cwd) {
-  const home = getHomeDir();
-  return [
-    (0, import_path.join)(home, ".robota", "settings.json"),
-    // 1. user (lowest)
-    (0, import_path.join)(home, ".claude", "settings.json"),
-    // 1b. user (Claude Code compat)
-    (0, import_path.join)(cwd, ".robota", "settings.json"),
-    // 2. project
-    (0, import_path.join)(cwd, ".robota", "settings.local.json"),
-    // 3. project-local
-    (0, import_path.join)(cwd, ".claude", "settings.json"),
-    // 4. project, Claude Code compat
-    (0, import_path.join)(cwd, ".claude", "settings.local.json")
-    // 5. project-local (highest)
-  ];
-}
-async function loadConfig(cwd) {
-  const allPaths = getSettingsPaths(cwd);
-  const rawEntries = [];
-  for (const filePath of allPaths) {
-    const raw = readJsonFile(filePath);
-    if (raw !== void 0) {
-      rawEntries.push({ raw, path: filePath });
+
+// src/context/context-loader.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+
+// src/context/task-context.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var TASKS_DIR = (0, import_node_path6.join)(".agents", "tasks");
+var README_FILENAME = "README.md";
+var MARKDOWN_EXTENSION = ".md";
+var DEFAULT_MAX_TASKS = Number("3");
+var STATUS_PRIORITIES = {
+  "in-progress": Number("1"),
+  todo: Number("2"),
+  blocked: Number("3"),
+  unknown: Number("4"),
+  completed: Number("5")
+};
+function normalizeStatus(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "todo" || normalized === "in-progress" || normalized === "blocked" || normalized === "completed") {
+    return normalized;
+  }
+  return "unknown";
+}
+function extractTitle(content, taskPath) {
+  const heading = content.split(/\r?\n/).find((line) => /^#\s+/.test(line));
+  return heading?.replace(/^#\s+/, "").trim() || (0, import_node_path6.basename)(taskPath, MARKDOWN_EXTENSION);
+}
+function extractMetadata(content, key) {
+  const matcher = new RegExp(`^- \\*\\*${key}\\*\\*:\\s*(.+)$`, "im");
+  return matcher.exec(content)?.[1]?.trim();
+}
+function extractSection(content, title) {
+  const lines = content.split(/\r?\n/);
+  const heading = new RegExp(`^(#{2,6})\\s+${title}\\b`, "i");
+  const startIndex = lines.findIndex((line) => heading.test(line));
+  if (startIndex < 0) {
+    return void 0;
+  }
+  const collected = [];
+  for (const line of lines.slice(startIndex + Number("1"))) {
+    if (/^##\s+/.test(line)) {
+      break;
     }
+    collected.push(line);
+  }
+  const result = collected.join("\n").trim();
+  return result.length > 0 ? result : void 0;
+}
+function extractOpenItems(content) {
+  return content.split(/\r?\n/).map((line) => /^- \[ \]\s+(.+)$/.exec(line)?.[1]?.trim()).filter((item) => item !== void 0 && item.length > 0);
+}
+function taskSortScore(task, currentBranch) {
+  if (currentBranch && task.branch === currentBranch) {
+    return Number("0");
+  }
+  return STATUS_PRIORITIES[task.status];
+}
+function formatTask(task) {
+  const lines = [`### ${task.title}`, `- **Path:** \`${task.relativePath}\``];
+  lines.push(`- **Status:** ${task.status}`);
+  if (task.branch) lines.push(`- **Branch:** ${task.branch}`);
+  if (task.scope) lines.push(`- **Scope:** ${task.scope}`);
+  if (task.objective) lines.push(`- **Objective:** ${task.objective}`);
+  if (task.openItems.length > 0) {
+    lines.push("- **Open items:**");
+    lines.push(...task.openItems.map((item) => `  - ${item}`));
+  }
+  return lines.join("\n");
+}
+function formatDate(date) {
+  return date.toISOString().slice(Number("0"), Number("10"));
+}
+function upsertStatusLine(content, status) {
+  const lines = content.split(/\r?\n/);
+  const statusLine = `- **Status**: ${status}`;
+  const statusIndex = lines.findIndex((line) => /^- \*\*Status\*\*:\s*/.test(line));
+  if (statusIndex >= Number("0")) {
+    lines[statusIndex] = statusLine;
+    return lines.join("\n");
+  }
+  const hasTopHeading = lines.length > Number("0") && /^#\s+/.test(lines[Number("0")]);
+  if (hasTopHeading) {
+    lines.splice(Number("1"), Number("0"), "", statusLine);
+  } else {
+    lines.unshift(statusLine, "");
   }
-  const parsedLayers = rawEntries.map(({ raw, path }) => {
-    const result = SettingsSchema.safeParse(raw);
-    if (!result.success) {
-      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
+  return lines.join("\n");
+}
+function appendProgressEntry(content, now, progressMessage) {
+  const entryLines = [`### ${formatDate(now)}`, `- ${progressMessage.trim()}`];
+  const lines = content.replace(/\s+$/u, "").split(/\r?\n/);
+  const progressIndex = lines.findIndex((line) => /^## Progress\s*$/.test(line));
+  if (progressIndex < Number("0")) {
+    return [...lines, "", "## Progress", "", ...entryLines, ""].join("\n");
+  }
+  const nextHeadingIndex = lines.findIndex(
+    (line, index) => index > progressIndex && /^##\s+/.test(line)
+  );
+  if (nextHeadingIndex < Number("0")) {
+    return [...lines, "", ...entryLines, ""].join("\n");
+  }
+  lines.splice(nextHeadingIndex, Number("0"), "", ...entryLines, "");
+  return lines.join("\n");
+}
+function resolveGitDirectory(cwd) {
+  let current = (0, import_node_path6.resolve)(cwd);
+  let reachedRoot = false;
+  while (!reachedRoot) {
+    const gitPath = (0, import_node_path6.join)(current, ".git");
+    if ((0, import_node_fs6.existsSync)(gitPath)) {
+      const stats = (0, import_node_fs6.statSync)(gitPath);
+      if (stats.isDirectory()) return gitPath;
+      const content = (0, import_node_fs6.readFileSync)(gitPath, "utf8").trim();
+      const gitdir = content.match(/^gitdir:\s*(.+)$/)?.[1];
+      if (gitdir) return (0, import_node_path6.isAbsolute)(gitdir) ? gitdir : (0, import_node_path6.resolve)(current, gitdir);
     }
-    return resolveEnvRefs(result.data);
-  });
-  const merged = mergeSettings(parsedLayers);
-  return toResolvedConfig(merged);
+    const parent = (0, import_node_path6.dirname)(current);
+    reachedRoot = parent === current;
+    current = parent;
+  }
+  return void 0;
+}
+function readCurrentGitBranch(cwd) {
+  const gitDir = resolveGitDirectory(cwd);
+  if (!gitDir) return void 0;
+  const headPath = (0, import_node_path6.join)(gitDir, "HEAD");
+  if (!(0, import_node_fs6.existsSync)(headPath)) return void 0;
+  const head = (0, import_node_fs6.readFileSync)(headPath, "utf8").trim();
+  const branch = head.match(/^ref:\s+refs\/heads\/(.+)$/)?.[1];
+  return branch?.trim();
+}
+function discoverTaskFiles(cwd) {
+  const tasksDir = (0, import_node_path6.join)(cwd, TASKS_DIR);
+  if (!(0, import_node_fs6.existsSync)(tasksDir)) {
+    return [];
+  }
+  return (0, import_node_fs6.readdirSync)(tasksDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name !== README_FILENAME && name.endsWith(MARKDOWN_EXTENSION)).sort((a, b) => a.localeCompare(b)).map((name) => (0, import_node_path6.join)(tasksDir, name));
+}
+function parseTaskFile(taskPath, cwd) {
+  const content = (0, import_node_fs6.readFileSync)(taskPath, "utf8");
+  return {
+    path: taskPath,
+    relativePath: (0, import_node_path6.relative)(cwd, taskPath),
+    title: extractTitle(content, taskPath),
+    status: normalizeStatus(extractMetadata(content, "Status")),
+    branch: extractMetadata(content, "Branch"),
+    scope: extractMetadata(content, "Scope"),
+    objective: extractSection(content, "Objective"),
+    openItems: extractOpenItems(content)
+  };
+}
+function selectRelevantTasks(tasks, options = {}) {
+  const maxTasks = options.maxTasks ?? DEFAULT_MAX_TASKS;
+  return [...tasks].filter((task) => task.status !== "completed").sort(
+    (left, right) => taskSortScore(left, options.currentBranch) - taskSortScore(right, options.currentBranch) || left.relativePath.localeCompare(right.relativePath)
+  ).slice(Number("0"), maxTasks);
+}
+function formatTaskContext(tasks) {
+  return tasks.map(formatTask).join("\n\n");
+}
+function loadTaskContext(cwd, options = {}) {
+  const currentBranch = options.currentBranch ?? readCurrentGitBranch(cwd);
+  const tasks = discoverTaskFiles(cwd).map((path) => parseTaskFile(path, cwd));
+  return formatTaskContext(selectRelevantTasks(tasks, { ...options, currentBranch }));
+}
+function updateTaskFileStatus(taskPath, status, options = {}) {
+  const updated = upsertStatusLine((0, import_node_fs6.readFileSync)(taskPath, "utf8"), status);
+  const withProgress = options.progressMessage ? appendProgressEntry(updated, options.now ?? /* @__PURE__ */ new Date(), options.progressMessage) : updated;
+  (0, import_node_fs6.writeFileSync)(taskPath, withProgress, "utf8");
 }
 
 // src/context/context-loader.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
   const found = [];
-  let current = (0, import_path2.resolve)(startDir);
+  let current = (0, import_path3.resolve)(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = (0, import_path2.join)(current, filename);
-    if ((0, import_fs2.existsSync)(candidate)) {
+    const candidate = (0, import_path3.join)(current, filename);
+    if ((0, import_fs3.existsSync)(candidate)) {
       found.push(candidate);
     }
-    const parent = (0, import_path2.dirname)(current);
+    const parent = (0, import_path3.dirname)(current);
     atRoot = parent === current;
     if (!atRoot) {
       current = parent;
@@ -2640,47 +3644,51 @@ function extractCompactInstructions(content) {
 async function loadContext(cwd) {
   const agentsPaths = collectFilesWalkingUp(cwd, AGENTS_FILENAME);
   const claudePaths = collectFilesWalkingUp(cwd, CLAUDE_FILENAME);
-  const agentsMd = agentsPaths.map((p) => (0, import_fs2.readFileSync)(p, "utf-8")).join("\n\n");
-  const claudeMd = claudePaths.map((p) => (0, import_fs2.readFileSync)(p, "utf-8")).join("\n\n");
+  const agentsMd = agentsPaths.map((p) => (0, import_fs3.readFileSync)(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => (0, import_fs3.readFileSync)(p, "utf-8")).join("\n\n");
   const compactInstructions = extractCompactInstructions(claudeMd);
-  return { agentsMd, claudeMd, compactInstructions };
+  const startupMemory = new ProjectMemoryStore(cwd).loadStartupMemory();
+  const memoryMd = startupMemory.content || void 0;
+  const loadedTaskContext = loadTaskContext(cwd);
+  const taskContext = loadedTaskContext.trim().length > 0 ? loadedTaskContext : void 0;
+  return { agentsMd, claudeMd, memoryMd, taskContext, compactInstructions };
 }
 
 // src/context/project-detector.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 function tryReadJson(filePath) {
-  if (!(0, import_fs3.existsSync)(filePath)) return void 0;
+  if (!(0, import_fs4.existsSync)(filePath)) return void 0;
   try {
-    return JSON.parse((0, import_fs3.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_fs4.readFileSync)(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function detectPackageManager(cwd) {
-  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "pnpm-workspace.yaml")) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "pnpm-lock.yaml"))) {
+  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "pnpm-workspace.yaml")) || (0, import_fs4.existsSync)((0, import_path4.join)(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "yarn.lock"))) {
+  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "bun.lockb"))) {
+  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "package-lock.json"))) {
+  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = (0, import_path3.join)(cwd, "package.json");
-  const tsconfigPath = (0, import_path3.join)(cwd, "tsconfig.json");
-  const pyprojectPath = (0, import_path3.join)(cwd, "pyproject.toml");
-  const cargoPath = (0, import_path3.join)(cwd, "Cargo.toml");
-  const goModPath = (0, import_path3.join)(cwd, "go.mod");
-  if ((0, import_fs3.existsSync)(pkgJsonPath)) {
+  const pkgJsonPath = (0, import_path4.join)(cwd, "package.json");
+  const tsconfigPath = (0, import_path4.join)(cwd, "tsconfig.json");
+  const pyprojectPath = (0, import_path4.join)(cwd, "pyproject.toml");
+  const cargoPath = (0, import_path4.join)(cwd, "Cargo.toml");
+  const goModPath = (0, import_path4.join)(cwd, "go.mod");
+  if ((0, import_fs4.existsSync)(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
-    const language = (0, import_fs3.existsSync)(tsconfigPath) ? "typescript" : "javascript";
+    const language = (0, import_fs4.existsSync)(tsconfigPath) ? "typescript" : "javascript";
     const packageManager = detectPackageManager(cwd);
     return {
       type: "node",
@@ -2689,19 +3697,19 @@ async function detectProject(cwd) {
       language
     };
   }
-  if ((0, import_fs3.existsSync)(pyprojectPath) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "setup.py"))) {
+  if ((0, import_fs4.existsSync)(pyprojectPath) || (0, import_fs4.existsSync)((0, import_path4.join)(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
     };
   }
-  if ((0, import_fs3.existsSync)(cargoPath)) {
+  if ((0, import_fs4.existsSync)(cargoPath)) {
     return {
       type: "rust",
       language: "rust"
     };
   }
-  if ((0, import_fs3.existsSync)(goModPath)) {
+  if ((0, import_fs4.existsSync)(goModPath)) {
     return {
       type: "go",
       language: "go"
@@ -2714,8 +3722,8 @@ async function detectProject(cwd) {
 }
 
 // src/plugins/plugin-settings-store.ts
-var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
 var PluginSettingsStore = class {
   settingsPath;
   constructor(settingsPath) {
@@ -2723,11 +3731,11 @@ var PluginSettingsStore = class {
   }
   /** Read the full settings file from disk. */
   readAll() {
-    if (!(0, import_node_fs4.existsSync)(this.settingsPath)) {
+    if (!(0, import_node_fs7.existsSync)(this.settingsPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs4.readFileSync)(this.settingsPath, "utf-8");
+      const raw = (0, import_node_fs7.readFileSync)(this.settingsPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -2739,11 +3747,11 @@ var PluginSettingsStore = class {
   }
   /** Write the full settings file to disk. */
   writeAll(settings) {
-    const dir = (0, import_node_path5.dirname)(this.settingsPath);
-    if (!(0, import_node_fs4.existsSync)(dir)) {
-      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path7.dirname)(this.settingsPath);
+    if (!(0, import_node_fs7.existsSync)(dir)) {
+      (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs4.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    (0, import_node_fs7.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
   // --- enabledPlugins ---
   /** Get the enabledPlugins map. */
@@ -2815,11 +3823,11 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path8 = require("path");
 
 // src/plugins/bundle-plugin-utils.ts
-var import_node_fs5 = require("fs");
+var import_node_fs8 = require("fs");
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -2868,9 +3876,9 @@ function validateManifest(data) {
   };
 }
 function getSortedSubdirs(dirPath) {
-  if (!(0, import_node_fs5.existsSync)(dirPath)) return [];
+  if (!(0, import_node_fs8.existsSync)(dirPath)) return [];
   try {
-    const entries = (0, import_node_fs5.readdirSync)(dirPath, { withFileTypes: true });
+    const entries = (0, import_node_fs8.readdirSync)(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -2900,23 +3908,23 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = (0, import_node_path6.join)(this.pluginsDir, "cache");
-    if (!(0, import_node_fs6.existsSync)(cacheDir)) {
+    const cacheDir = (0, import_node_path8.join)(this.pluginsDir, "cache");
+    if (!(0, import_node_fs9.existsSync)(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = (0, import_node_path6.join)(cacheDir, marketplace);
+      const marketplaceDir = (0, import_node_path8.join)(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = (0, import_node_path6.join)(marketplaceDir, pluginName);
+        const pluginDir = (0, import_node_path8.join)(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = (0, import_node_path6.join)(pluginDir, latestVersion);
-        const manifestPath = (0, import_node_path6.join)(versionDir, ".claude-plugin", "plugin.json");
-        if (!(0, import_node_fs6.existsSync)(manifestPath)) continue;
+        const versionDir = (0, import_node_path8.join)(pluginDir, latestVersion);
+        const manifestPath = (0, import_node_path8.join)(versionDir, ".claude-plugin", "plugin.json");
+        if (!(0, import_node_fs9.existsSync)(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -2930,7 +3938,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = (0, import_node_fs6.readFileSync)(path, "utf-8");
+      const raw = (0, import_node_fs9.readFileSync)(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -2965,15 +3973,15 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = (0, import_node_path6.join)(pluginDir, "skills");
-    if (!(0, import_node_fs6.existsSync)(skillsDir)) return [];
-    const entries = (0, import_node_fs6.readdirSync)(skillsDir, { withFileTypes: true });
+    const skillsDir = (0, import_node_path8.join)(pluginDir, "skills");
+    if (!(0, import_node_fs9.existsSync)(skillsDir)) return [];
+    const entries = (0, import_node_fs9.readdirSync)(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = (0, import_node_path6.join)(skillsDir, entry.name, "SKILL.md");
-      if (!(0, import_node_fs6.existsSync)(skillFile)) continue;
-      const raw = (0, import_node_fs6.readFileSync)(skillFile, "utf-8");
+      const skillFile = (0, import_node_path8.join)(skillsDir, entry.name, "SKILL.md");
+      if (!(0, import_node_fs9.existsSync)(skillFile)) continue;
+      const raw = (0, import_node_fs9.readFileSync)(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -2988,13 +3996,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = (0, import_node_path6.join)(pluginDir, "commands");
-    if (!(0, import_node_fs6.existsSync)(commandsDir)) return [];
-    const entries = (0, import_node_fs6.readdirSync)(commandsDir, { withFileTypes: true });
+    const commandsDir = (0, import_node_path8.join)(pluginDir, "commands");
+    if (!(0, import_node_fs9.existsSync)(commandsDir)) return [];
+    const entries = (0, import_node_fs9.readdirSync)(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = (0, import_node_fs6.readFileSync)((0, import_node_path6.join)(commandsDir, entry.name), "utf-8");
+      const raw = (0, import_node_fs9.readFileSync)((0, import_node_path8.join)(commandsDir, entry.name), "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
       const description = typeof metadata.description === "string" ? metadata.description : "";
@@ -3009,10 +4017,10 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = (0, import_node_path6.join)(pluginDir, "hooks", "hooks.json");
-    if (!(0, import_node_fs6.existsSync)(hooksPath)) return {};
+    const hooksPath = (0, import_node_path8.join)(pluginDir, "hooks", "hooks.json");
+    if (!(0, import_node_fs9.existsSync)(hooksPath)) return {};
     try {
-      const raw = (0, import_node_fs6.readFileSync)(hooksPath, "utf-8");
+      const raw = (0, import_node_fs9.readFileSync)(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -3024,12 +4032,12 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = (0, import_node_path6.join)(pluginDir, ".mcp.json");
-    const fallbackPath = (0, import_node_path6.join)(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = (0, import_node_fs6.existsSync)(primaryPath) ? primaryPath : fallbackPath;
-    if (!(0, import_node_fs6.existsSync)(mcpPath)) return void 0;
+    const primaryPath = (0, import_node_path8.join)(pluginDir, ".mcp.json");
+    const fallbackPath = (0, import_node_path8.join)(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = (0, import_node_fs9.existsSync)(primaryPath) ? primaryPath : fallbackPath;
+    if (!(0, import_node_fs9.existsSync)(mcpPath)) return void 0;
     try {
-      const raw = (0, import_node_fs6.readFileSync)(mcpPath, "utf-8");
+      const raw = (0, import_node_fs9.readFileSync)(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -3037,10 +4045,10 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = (0, import_node_path6.join)(pluginDir, "agents");
-    if (!(0, import_node_fs6.existsSync)(agentsDir)) return [];
+    const agentsDir = (0, import_node_path8.join)(pluginDir, "agents");
+    if (!(0, import_node_fs9.existsSync)(agentsDir)) return [];
     try {
-      const entries = (0, import_node_fs6.readdirSync)(agentsDir, { withFileTypes: true });
+      const entries = (0, import_node_fs9.readdirSync)(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -3050,8 +4058,8 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path9 = require("path");
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -3062,8 +4070,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = (0, import_node_path7.join)(this.pluginsDir, "cache");
-    this.registryPath = (0, import_node_path7.join)(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = (0, import_node_path9.join)(this.pluginsDir, "cache");
+    this.registryPath = (0, import_node_path9.join)(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -3083,8 +4091,8 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = (0, import_node_path7.join)(this.cacheDir, marketplaceName, pluginName, version);
-    if ((0, import_node_fs7.existsSync)(targetDir)) {
+    const targetDir = (0, import_node_path9.join)(this.cacheDir, marketplaceName, pluginName, version);
+    if ((0, import_node_fs10.existsSync)(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -3111,8 +4119,8 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if ((0, import_node_fs7.existsSync)(record.installPath)) {
-      (0, import_node_fs7.rmSync)(record.installPath, { recursive: true, force: true });
+    if ((0, import_node_fs10.existsSync)(record.installPath)) {
+      (0, import_node_fs10.rmSync)(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
     this.writeRegistry(registry);
@@ -3158,18 +4166,18 @@ var BundlePluginInstaller = class {
   }
   /** Resolve the source and install the plugin. */
   resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
-    (0, import_node_fs7.mkdirSync)(targetDir, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(targetDir, { recursive: true });
     const source = this.normalizeSource(rawSource);
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = (0, import_node_path7.join)(marketplaceDir, source);
-        if (!(0, import_node_fs7.existsSync)(sourcePath)) {
+        const sourcePath = (0, import_node_path9.join)(marketplaceDir, source);
+        if (!(0, import_node_fs10.existsSync)(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
         }
-        (0, import_node_fs7.cpSync)(sourcePath, targetDir, { recursive: true });
+        (0, import_node_fs10.cpSync)(sourcePath, targetDir, { recursive: true });
       } else if (source.type === "github") {
         const repoUrl = `https://github.com/${source.repo}.git`;
         this.cloneToDir(repoUrl, targetDir, pluginName);
@@ -3181,15 +4189,15 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if ((0, import_node_fs7.existsSync)(targetDir)) {
-        (0, import_node_fs7.rmSync)(targetDir, { recursive: true, force: true });
+      if ((0, import_node_fs10.existsSync)(targetDir)) {
+        (0, import_node_fs10.rmSync)(targetDir, { recursive: true, force: true });
       }
       throw err;
     }
   }
   /** Clone a git repository to the target directory. */
   cloneToDir(repoUrl, targetDir, pluginName) {
-    (0, import_node_fs7.rmSync)(targetDir, { recursive: true, force: true });
+    (0, import_node_fs10.rmSync)(targetDir, { recursive: true, force: true });
     const command = `git clone --depth 1 ${repoUrl} ${targetDir}`;
     try {
       this.exec(command, { timeout: GIT_CLONE_TIMEOUT_MS, stdio: "pipe" });
@@ -3200,11 +4208,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!(0, import_node_fs7.existsSync)(this.registryPath)) {
+    if (!(0, import_node_fs10.existsSync)(this.registryPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs7.readFileSync)(this.registryPath, "utf-8");
+      const raw = (0, import_node_fs10.readFileSync)(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -3216,11 +4224,11 @@ var BundlePluginInstaller = class {
   }
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
-    const dir = (0, import_node_path7.dirname)(this.registryPath);
-    if (!(0, import_node_fs7.existsSync)(dir)) {
-      (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path9.dirname)(this.registryPath);
+    if (!(0, import_node_fs10.existsSync)(dir)) {
+      (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs7.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+    (0, import_node_fs10.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
@@ -3230,18 +4238,18 @@ var BundlePluginInstaller = class {
 
 // src/plugins/marketplace-client.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs9 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path11 = require("path");
 
 // src/plugins/marketplace-registry.ts
-var import_node_fs8 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path10 = require("path");
 function readRegistry(registryPath) {
-  if (!(0, import_node_fs8.existsSync)(registryPath)) {
+  if (!(0, import_node_fs11.existsSync)(registryPath)) {
     return {};
   }
   try {
-    const raw = (0, import_node_fs8.readFileSync)(registryPath, "utf-8");
+    const raw = (0, import_node_fs11.readFileSync)(registryPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data === "object" && data !== null) {
       return data;
@@ -3252,18 +4260,18 @@ function readRegistry(registryPath) {
   }
 }
 function writeRegistry(registryPath, registry) {
-  const dir = (0, import_node_path8.dirname)(registryPath);
-  if (!(0, import_node_fs8.existsSync)(dir)) {
-    (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path10.dirname)(registryPath);
+  if (!(0, import_node_fs11.existsSync)(dir)) {
+    (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs8.writeFileSync)(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  (0, import_node_fs11.writeFileSync)(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
-  const installedPath = (0, import_node_path8.join)(pluginsDir, "installed_plugins.json");
-  if (!(0, import_node_fs8.existsSync)(installedPath)) return;
+  const installedPath = (0, import_node_path10.join)(pluginsDir, "installed_plugins.json");
+  if (!(0, import_node_fs11.existsSync)(installedPath)) return;
   let registry;
   try {
-    const raw = (0, import_node_fs8.readFileSync)(installedPath, "utf-8");
+    const raw = (0, import_node_fs11.readFileSync)(installedPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) return;
     registry = data;
@@ -3273,19 +4281,19 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
   let changed = false;
   for (const [pluginId, record] of Object.entries(registry)) {
     if (record.marketplace === marketplaceName) {
-      if (record.installPath && (0, import_node_fs8.existsSync)(record.installPath)) {
-        (0, import_node_fs8.rmSync)(record.installPath, { recursive: true, force: true });
+      if (record.installPath && (0, import_node_fs11.existsSync)(record.installPath)) {
+        (0, import_node_fs11.rmSync)(record.installPath, { recursive: true, force: true });
       }
       delete registry[pluginId];
       changed = true;
     }
   }
   if (changed) {
-    const dir = (0, import_node_path8.dirname)(installedPath);
-    if (!(0, import_node_fs8.existsSync)(dir)) {
-      (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path10.dirname)(installedPath);
+    if (!(0, import_node_fs11.existsSync)(dir)) {
+      (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs8.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+    (0, import_node_fs11.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
   }
 }
 
@@ -3299,8 +4307,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = (0, import_node_path9.join)(this.pluginsDir, "marketplaces");
-    this.registryPath = (0, import_node_path9.join)(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = (0, import_node_path11.join)(this.pluginsDir, "marketplaces");
+    this.registryPath = (0, import_node_path11.join)(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -3313,13 +4321,13 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = (0, import_node_path9.join)(this.marketplacesDir, tempName);
-    (0, import_node_fs9.mkdirSync)(this.marketplacesDir, { recursive: true });
+    const tempDir = (0, import_node_path11.join)(this.marketplacesDir, tempName);
+    (0, import_node_fs12.mkdirSync)(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!(0, import_node_fs9.existsSync)(source.path)) {
+      if (!(0, import_node_fs12.existsSync)(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
-      (0, import_node_fs9.cpSync)(source.path, tempDir, { recursive: true });
+      (0, import_node_fs12.cpSync)(source.path, tempDir, { recursive: true });
     } else {
       const cloneUrl = this.resolveCloneUrl(source);
       const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
@@ -3330,9 +4338,9 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = (0, import_node_path9.join)(tempDir, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs9.existsSync)(manifestPath)) {
-      (0, import_node_fs9.rmSync)(tempDir, { recursive: true, force: true });
+    const manifestPath = (0, import_node_path11.join)(tempDir, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs12.existsSync)(manifestPath)) {
+      (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(
         source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
       );
@@ -3340,16 +4348,16 @@ var MarketplaceClient = class {
     const manifest = this.readManifestFromPath(manifestPath);
     const name = manifest.name;
     if (!name) {
-      (0, import_node_fs9.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error('Marketplace manifest does not contain a "name" field');
     }
     const registry = readRegistry(this.registryPath);
     if (registry[name]) {
-      (0, import_node_fs9.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = (0, import_node_path9.join)(this.marketplacesDir, name);
-    (0, import_node_fs9.renameSync)(tempDir, finalDir);
+    const finalDir = (0, import_node_path11.join)(this.marketplacesDir, name);
+    (0, import_node_fs12.renameSync)(tempDir, finalDir);
     registry[name] = {
       source,
       installLocation: finalDir,
@@ -3370,8 +4378,8 @@ var MarketplaceClient = class {
       throw new Error(`Marketplace "${name}" not found`);
     }
     removeInstalledPluginsForMarketplace(this.pluginsDir, name);
-    if ((0, import_node_fs9.existsSync)(entry.installLocation)) {
-      (0, import_node_fs9.rmSync)(entry.installLocation, { recursive: true, force: true });
+    if ((0, import_node_fs12.existsSync)(entry.installLocation)) {
+      (0, import_node_fs12.rmSync)(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
     writeRegistry(this.registryPath, registry);
@@ -3387,16 +4395,16 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!(0, import_node_fs9.existsSync)(entry.installLocation)) {
+    if (!(0, import_node_fs12.existsSync)(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!(0, import_node_fs9.existsSync)(localSource.path)) {
+      if (!(0, import_node_fs12.existsSync)(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
-      (0, import_node_fs9.rmSync)(entry.installLocation, { recursive: true, force: true });
-      (0, import_node_fs9.cpSync)(localSource.path, entry.installLocation, { recursive: true });
+      (0, import_node_fs12.rmSync)(entry.installLocation, { recursive: true, force: true });
+      (0, import_node_fs12.cpSync)(localSource.path, entry.installLocation, { recursive: true });
     } else {
       const command = `git -C ${entry.installLocation} pull`;
       try {
@@ -3425,8 +4433,8 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = (0, import_node_path9.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs9.existsSync)(manifestPath)) {
+    const manifestPath = (0, import_node_path11.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs12.existsSync)(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -3489,7 +4497,7 @@ var MarketplaceClient = class {
   }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = (0, import_node_fs9.readFileSync)(path, "utf-8");
+    const raw = (0, import_node_fs12.readFileSync)(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -3507,9 +4515,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-var import_node_path10 = require("path");
+var import_node_path12 = require("path");
 function buildPluginEnv(plugin) {
-  const dataDir = (0, import_node_path10.join)((0, import_node_path10.dirname)((0, import_node_path10.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = (0, import_node_path12.join)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -3572,15 +4580,15 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
 
 // src/interactive/interactive-session-init.ts
 var import_node_os4 = require("os");
-var import_node_path11 = require("path");
+var import_node_path13 = require("path");
 async function createInteractiveSession(options) {
   const cwd = options.cwd;
   const [config, context, projectInfo] = await Promise.all([
-    loadConfig(cwd),
+    options.config ? Promise.resolve(options.config) : loadConfig(cwd),
     options.bare ? Promise.resolve({ agentsMd: "", claudeMd: "" }) : loadContext(cwd),
     options.bare ? Promise.resolve({ type: "unknown", language: "unknown" }) : detectProject(cwd)
   ]);
-  const pluginsDir = (0, import_node_path11.join)((0, import_node_os4.homedir)(), ".robota", "plugins");
+  const pluginsDir = (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".robota", "plugins");
   const pluginLoader = new BundlePluginLoader(pluginsDir);
   let mergedConfig = config;
   if (!options.bare) {
@@ -3613,6 +4621,7 @@ async function createInteractiveSession(options) {
     permissionHandler: options.permissionHandler,
     provider: options.provider,
     onTextDelta: options.onTextDelta,
+    onContextUpdate: options.onContextUpdate,
     onToolExecution: options.onToolExecution,
     sessionId,
     allowedTools: options.allowedTools,
@@ -3629,7 +4638,8 @@ async function createInteractiveSession(options) {
       ]
     } : {},
     modelCommandExecutor: options.modelCommandExecutor,
-    isModelCommandInvocable: options.isModelCommandInvocable
+    isModelCommandInvocable: options.isModelCommandInvocable,
+    editCheckpointRecorder: options.editCheckpointRecorder
   });
 }
 function injectSavedMessage(session, msg) {
@@ -3655,7 +4665,9 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
       backgroundTasks: [],
       backgroundTaskEvents: [],
       backgroundJobGroups: [],
-      backgroundJobGroupEvents: []
+      backgroundJobGroupEvents: [],
+      memoryEvents: [],
+      usedMemoryReferences: []
     };
   }
   const history = record.history ?? [];
@@ -3663,6 +4675,8 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
   const restoredBackgroundTaskEvents = record.backgroundTaskEvents ?? [];
   const backgroundJobGroups = record.backgroundJobGroups ?? [];
   const backgroundJobGroupEvents = record.backgroundJobGroupEvents ?? [];
+  const memoryEvents = record.memoryEvents ?? [];
+  const usedMemoryReferences = record.usedMemoryReferences ?? [];
   const { backgroundTasks, backgroundTaskEvents } = reconcileRestoredBackgroundTasks(
     restoredBackgroundTasks,
     restoredBackgroundTaskEvents
@@ -3685,7 +4699,9 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
     backgroundTasks,
     backgroundTaskEvents,
     backgroundJobGroups,
-    backgroundJobGroupEvents
+    backgroundJobGroupEvents,
+    memoryEvents,
+    usedMemoryReferences
   };
 }
 function reconcileRestoredBackgroundTasks(tasks, events) {
@@ -3718,6 +4734,189 @@ function isRestoredTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 
+// src/checkpoints/edit-checkpoint-store.ts
+var import_promises = require("fs/promises");
+var import_node_fs13 = require("fs");
+var import_node_path14 = require("path");
+var MANIFEST_FILE = "manifest.json";
+var SNAPSHOT_DIR = "files";
+var ID_PAD = 4;
+var SNAPSHOT_PAD = 6;
+var EditCheckpointStore = class {
+  cwd;
+  rootDir;
+  now;
+  activeTurn = null;
+  constructor(options) {
+    this.cwd = (0, import_node_path14.resolve)(options.cwd);
+    this.rootDir = projectPaths(this.cwd).checkpoints;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async beginTurn(input) {
+    if (this.activeTurn) {
+      await this.finalizeTurn();
+    }
+    const nextSequence = this.nextSequence(input.sessionId);
+    const id = `turn-${String(nextSequence).padStart(ID_PAD, "0")}`;
+    const dir = (0, import_node_path14.join)(this.sessionDir(input.sessionId), id);
+    await (0, import_promises.mkdir)((0, import_node_path14.join)(dir, SNAPSHOT_DIR), { recursive: true });
+    const manifest = {
+      version: 1,
+      id,
+      sessionId: input.sessionId,
+      sequence: nextSequence,
+      prompt: input.prompt,
+      createdAt: this.now().toISOString(),
+      fileCount: 0,
+      files: []
+    };
+    this.activeTurn = {
+      manifest,
+      dir,
+      capturedPaths: /* @__PURE__ */ new Set()
+    };
+    return toSummary(manifest);
+  }
+  async captureFile(filePath) {
+    if (!this.activeTurn) return;
+    const originalPath = (0, import_node_path14.resolve)(this.cwd, filePath);
+    if (this.activeTurn.capturedPaths.has(originalPath)) return;
+    if (isInside(this.rootDir, originalPath)) return;
+    const record = await this.createFileRecord(originalPath, this.activeTurn);
+    this.activeTurn.manifest.files.push(record);
+    this.activeTurn.manifest.fileCount = this.activeTurn.manifest.files.length;
+    this.activeTurn.capturedPaths.add(originalPath);
+  }
+  async finalizeTurn() {
+    if (!this.activeTurn) return void 0;
+    const active = this.activeTurn;
+    this.activeTurn = null;
+    await this.writeManifest(active.dir, active.manifest);
+    return toSummary(active.manifest);
+  }
+  list(sessionId) {
+    return this.loadManifests(sessionId).map(toSummary);
+  }
+  async restoreToCheckpoint(sessionId, checkpointId) {
+    const manifests = this.loadManifests(sessionId);
+    const target = manifests.find((manifest) => manifest.id === checkpointId);
+    if (!target) {
+      throw new Error(`Unknown edit checkpoint: ${checkpointId}`);
+    }
+    const later = manifests.filter((manifest) => manifest.sequence > target.sequence).sort((a, b) => b.sequence - a.sequence);
+    let restoredFileCount = 0;
+    for (const manifest of later) {
+      for (const file of manifest.files) {
+        await this.restoreFile(sessionId, manifest.id, file);
+        restoredFileCount += 1;
+      }
+    }
+    for (const manifest of later) {
+      await (0, import_promises.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
+    }
+    return {
+      target: toSummary(target),
+      restoredCheckpointCount: later.length,
+      restoredFileCount,
+      removedCheckpointCount: later.length
+    };
+  }
+  async createFileRecord(originalPath, active) {
+    const existed = await pathExists(originalPath);
+    if (!existed) {
+      return {
+        originalPath,
+        existed: false
+      };
+    }
+    const snapshotFile = (0, import_node_path14.join)(
+      SNAPSHOT_DIR,
+      `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
+    );
+    await (0, import_promises.copyFile)(originalPath, (0, import_node_path14.join)(active.dir, snapshotFile));
+    return {
+      originalPath,
+      existed: true,
+      snapshotFile
+    };
+  }
+  async restoreFile(sessionId, checkpointId, record) {
+    if (!record.existed) {
+      await (0, import_promises.rm)(record.originalPath, { force: true });
+      return;
+    }
+    if (!record.snapshotFile) {
+      throw new Error(`Checkpoint file record is missing a snapshot: ${record.originalPath}`);
+    }
+    await (0, import_promises.mkdir)((0, import_node_path14.dirname)(record.originalPath), { recursive: true });
+    await (0, import_promises.copyFile)(
+      (0, import_node_path14.join)(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+      record.originalPath
+    );
+  }
+  loadManifests(sessionId) {
+    const dir = this.sessionDir(sessionId);
+    return readDirSyncSafe(dir).map((entry) => (0, import_node_path14.join)(dir, entry, MANIFEST_FILE)).map((manifestPath) => readJsonManifest(manifestPath)).filter((manifest) => manifest !== void 0).sort((a, b) => a.sequence - b.sequence);
+  }
+  nextSequence(sessionId) {
+    const last = this.list(sessionId).at(-1);
+    return (last?.sequence ?? 0) + 1;
+  }
+  async writeManifest(dir, manifest) {
+    await (0, import_promises.mkdir)(dir, { recursive: true });
+    const path = (0, import_node_path14.join)(dir, MANIFEST_FILE);
+    const tmp = `${path}.tmp`;
+    await (0, import_promises.writeFile)(tmp, JSON.stringify(manifest, null, 2), "utf8");
+    await (0, import_promises.rename)(tmp, path);
+  }
+  sessionDir(sessionId) {
+    return (0, import_node_path14.join)(this.rootDir, safePathSegment(sessionId));
+  }
+  checkpointDir(sessionId, checkpointId) {
+    return (0, import_node_path14.join)(this.sessionDir(sessionId), safePathSegment(checkpointId));
+  }
+};
+function toSummary(manifest) {
+  return {
+    id: manifest.id,
+    sessionId: manifest.sessionId,
+    sequence: manifest.sequence,
+    prompt: manifest.prompt,
+    createdAt: manifest.createdAt,
+    fileCount: manifest.fileCount
+  };
+}
+function safePathSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function isInside(parent, child) {
+  const rel = (0, import_node_path14.relative)(parent, child);
+  return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
+}
+async function pathExists(path) {
+  try {
+    await (0, import_promises.access)(path, import_node_fs13.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readDirSyncSafe(dir) {
+  try {
+    return (0, import_node_fs13.readdirSync)(dir);
+  } catch {
+    return [];
+  }
+}
+function readJsonManifest(path) {
+  try {
+    const raw = (0, import_node_fs13.readFileSync)(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/interactive/interactive-session.ts
 var InteractiveSession = class {
   session = null;
@@ -3741,6 +4940,9 @@ var InteractiveSession = class {
   backgroundTaskEvents = [];
   backgroundJobGroups = [];
   backgroundJobGroupEvents = [];
+  memoryEvents = [];
+  usedMemoryReferences = [];
+  editCheckpointStore = null;
   resumeSessionId;
   forkSession;
   backgroundTaskUnsubscribe = null;
@@ -3758,6 +4960,9 @@ var InteractiveSession = class {
     this.sessionStore = options.sessionStore;
     this.sessionName = options.sessionName;
     this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
+    if ("session" in options && options.session && this.cwd) {
+      this.editCheckpointStore = new EditCheckpointStore({ cwd: this.cwd });
+    }
     this.resumeSessionId = options.resumeSessionId;
     this.forkSession = options.forkSession ?? false;
     if ("session" in options && options.session) {
@@ -3780,21 +4985,27 @@ var InteractiveSession = class {
       this.backgroundTaskEvents = restored.backgroundTaskEvents;
       this.backgroundJobGroups = restored.backgroundJobGroups;
       this.backgroundJobGroupEvents = restored.backgroundJobGroupEvents;
+      this.memoryEvents = restored.memoryEvents;
+      this.usedMemoryReferences = restored.usedMemoryReferences;
       this.pendingRestoreMessages = restored.pendingRestoreMessages;
     }
     if (this.initialized) this.subscribeBackgroundTaskEvents();
     if (this.initialized) this.persistCurrentSession();
   }
   async initializeAsync(options) {
+    const config = await loadConfig(options.cwd);
+    this.editCheckpointStore = new EditCheckpointStore({ cwd: options.cwd });
     this.session = await createInteractiveSession({
       cwd: options.cwd,
       provider: options.provider,
+      config,
       permissionMode: options.permissionMode,
       maxTurns: options.maxTurns,
       permissionHandler: options.permissionHandler,
       resumeSessionId: this.resumeSessionId,
       forkSession: this.forkSession,
       onTextDelta: (delta) => this.handleTextDelta(delta),
+      onContextUpdate: (state) => this.emit("context_update", state),
       onToolExecution: (event) => this.handleToolExecution(event),
       bare: options.bare,
       allowedTools: options.allowedTools,
@@ -3802,6 +5013,7 @@ var InteractiveSession = class {
       backgroundTaskRunners: options.backgroundTaskRunners,
       subagentRunnerFactory: options.subagentRunnerFactory,
       ...options.commandModules ? { commandModules: options.commandModules } : {},
+      editCheckpointRecorder: this.editCheckpointStore,
       commandDescriptors: this.commandExecutor.listModelInvocableCommands(),
       ...this.commandExecutor.listModelInvocableCommands().length > 0 ? {
         modelCommandExecutor: (command, args) => this.executeModelCommand(command, args),
@@ -3944,9 +5156,38 @@ var InteractiveSession = class {
   getName() {
     return this.sessionName;
   }
+  getCwd() {
+    return this.cwd ?? process.cwd();
+  }
   getSession() {
     return this.getSessionOrThrow();
   }
+  listEditCheckpoints() {
+    const sessionId = this.getSessionOrThrow().getSessionId();
+    return this.getEditCheckpointStore().list(sessionId);
+  }
+  async restoreEditCheckpoint(checkpointId) {
+    await this.ensureInitialized();
+    if (this.executing) {
+      throw new Error("Cannot restore edit checkpoint while a prompt is running.");
+    }
+    const result = await this.getEditCheckpointStore().restoreToCheckpoint(
+      this.getSessionOrThrow().getSessionId(),
+      checkpointId
+    );
+    this.history.push(
+      (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Restored edit checkpoint: ${checkpointId}`))
+    );
+    this.persistCurrentSession();
+    return result;
+  }
+  getUsedMemoryReferences() {
+    return [...this.usedMemoryReferences];
+  }
+  recordMemoryEvent(event) {
+    this.memoryEvents.push(event);
+    this.persistCurrentSession();
+  }
   listBackgroundTasks(filter) {
     return this.getBackgroundTaskManagerOrThrow().list(filter);
   }
@@ -4169,6 +5410,10 @@ var InteractiveSession = class {
         events: this.backgroundTaskEvents,
         groups: this.backgroundJobGroups,
         groupEvents: this.backgroundJobGroupEvents
+      },
+      {
+        events: this.memoryEvents,
+        usedReferences: this.usedMemoryReferences
       }
     );
   }
@@ -4176,7 +5421,7 @@ var InteractiveSession = class {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
-    this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createUserMessage)(displayInput)));
+    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createUserMessage)(displayInput)));
   }
   finishForkSkillExecution() {
     this.executing = false;
@@ -4191,7 +5436,7 @@ var InteractiveSession = class {
     }
   }
   recordForkSkillError(err) {
-    this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createSystemMessage)(`Error: ${err.message}`)));
+    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Error: ${err.message}`)));
     this.emit("error", err);
   }
   resolveForkAgentDefinition(agentType, options) {
@@ -4240,7 +5485,7 @@ var InteractiveSession = class {
       toolSummaries: [],
       contextState: this.getContextState()
     };
-    this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createAssistantMessage)(result)));
+    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result)));
     this.emit("complete", executionResult);
     this.emit("context_update", this.getContextState());
   }
@@ -4248,9 +5493,11 @@ var InteractiveSession = class {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
-    this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createUserMessage)(displayInput ?? input)));
+    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createUserMessage)(displayInput ?? input)));
     const historyBefore = this.getSessionOrThrow().getHistory().length;
+    this.usedMemoryReferences = [];
     try {
+      await this.beginEditCheckpointTurn(displayInput ?? input);
       const response = await this.getSessionOrThrow().run(input, rawInput);
       this.flushStreaming();
       pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
@@ -4262,7 +5509,8 @@ var InteractiveSession = class {
         historyBefore,
         this.getContextState()
       );
-      this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createAssistantMessage)(result.response)));
+      this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result.response)));
+      if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
       this.emit("complete", result);
       this.emit("context_update", this.getContextState());
     } catch (err) {
@@ -4277,17 +5525,19 @@ var InteractiveSession = class {
         pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
         if (result.response)
-          this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createAssistantMessage)(result.response)));
-        this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createSystemMessage)("Interrupted by user.")));
+          this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result.response)));
+        if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
+        this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Interrupted by user.")));
         this.emit("interrupted", result);
       } else {
         pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
         const errMsg = err instanceof Error ? err.message : String(err);
-        this.history.push((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createSystemMessage)(`Error: ${errMsg}`)));
+        this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Error: ${errMsg}`)));
         this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
     } finally {
+      await this.finalizeEditCheckpointTurn();
       this.executing = false;
       this.emit("thinking", false);
       this.persistCurrentSession();
@@ -4300,6 +5550,31 @@ var InteractiveSession = class {
       }
     }
   }
+  getEditCheckpointStore() {
+    if (!this.editCheckpointStore) {
+      this.editCheckpointStore = new EditCheckpointStore({ cwd: this.getCwd() });
+    }
+    return this.editCheckpointStore;
+  }
+  async beginEditCheckpointTurn(prompt) {
+    if (!this.editCheckpointStore) return;
+    await this.editCheckpointStore.beginTurn({
+      sessionId: this.getSessionOrThrow().getSessionId(),
+      prompt
+    });
+  }
+  async finalizeEditCheckpointTurn() {
+    if (!this.editCheckpointStore) return;
+    try {
+      await this.editCheckpointStore.finalizeTurn();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.history.push(
+        (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Checkpoint error: ${err.message}`))
+      );
+      this.emit("error", err);
+    }
+  }
   handleTextDelta(delta) {
     this.streamingText += delta;
     this.emit("text_delta", delta);
@@ -4350,14 +5625,14 @@ function createQuery(options) {
     session.on("text_delta", options.onTextDelta);
   }
   return async (prompt) => {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const onComplete = (result) => {
         cleanup();
-        resolve2(result.response);
+        resolve4(result.response);
       };
       const onInterrupted = (result) => {
         cleanup();
-        resolve2(result.response);
+        resolve4(result.response);
       };
       const onError = (error) => {
         cleanup();
@@ -4380,17 +5655,132 @@ function createQuery(options) {
 }
 
 // src/types.ts
-var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core5 = require("@robota-sdk/agent-core");
 
 // src/index.ts
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_agent_core6 = require("@robota-sdk/agent-core");
+
+// src/self-hosting/self-hosting-verification.ts
+var DEFAULT_BASE_REF = "origin/develop";
+var PACKAGE_VERIFY_COMMANDS = ["test", "typecheck", "build"];
+var TRANSITIONS = {
+  idle: {
+    checkpoint_created: "checkpointed",
+    cancelled: "cancelled"
+  },
+  checkpointed: {
+    edits_started: "editing",
+    cancelled: "cancelled"
+  },
+  editing: {
+    edits_applied: "verifying",
+    verify_failed: "failed",
+    cancelled: "cancelled"
+  },
+  verifying: {
+    verify_passed: "passed",
+    verify_failed: "failed",
+    cancelled: "cancelled"
+  },
+  passed: {},
+  failed: {
+    rollback_completed: "rolled_back",
+    cancelled: "cancelled"
+  },
+  rolled_back: {},
+  cancelled: {}
+};
+function normalizePackageScopes(packageScopes) {
+  if (!packageScopes) {
+    return [];
+  }
+  return Array.from(new Set(packageScopes.map((scope) => scope.trim()).filter(Boolean)));
+}
+function packageVerificationSteps(packageScopes) {
+  return packageScopes.flatMap(
+    (scope) => PACKAGE_VERIFY_COMMANDS.map(
+      (commandName) => ({
+        id: `package-${commandName}:${scope}`,
+        phase: "verify",
+        description: `Run ${commandName} for ${scope} in a child process against the new on-disk tree.`,
+        required: true,
+        command: `pnpm --filter ${scope} ${commandName}`
+      })
+    )
+  );
+}
+function preVerificationSteps() {
+  return [
+    {
+      id: "checkpoint",
+      phase: "checkpoint",
+      description: "Create a recoverable turn-level checkpoint before the first mutation.",
+      required: true
+    },
+    {
+      id: "atomic-edit",
+      phase: "edit",
+      description: "Apply Write/Edit mutations through same-directory temp files and atomic rename.",
+      required: true
+    },
+    {
+      id: "handoff",
+      phase: "handoff",
+      description: "Keep the current process on already-loaded code and run verification child processes against disk.",
+      required: true
+    }
+  ];
+}
+function harnessVerificationStep(baseRef) {
+  return {
+    id: "harness-verify",
+    phase: "verify",
+    description: "Run Robota harness verification as the local CI-like gate.",
+    required: true,
+    command: `pnpm harness:verify -- --base-ref ${baseRef} --skip-record-check`
+  };
+}
+function rollbackRecoveryStep() {
+  return {
+    id: "rollback-on-failure",
+    phase: "recover",
+    description: "Use the existing edit checkpoint restore path if verification fails.",
+    required: true
+  };
+}
+function planSelfHostingVerification(input) {
+  if (input.changedFiles.length === 0) {
+    throw new Error("Self-hosting verification requires at least one changed file.");
+  }
+  const baseRef = input.baseRef ?? DEFAULT_BASE_REF;
+  const packageScopes = normalizePackageScopes(input.packageScopes);
+  const steps = [
+    ...preVerificationSteps(),
+    ...packageVerificationSteps(packageScopes),
+    harnessVerificationStep(baseRef),
+    rollbackRecoveryStep()
+  ];
+  return {
+    changedFiles: [...input.changedFiles],
+    packageScopes,
+    baseRef,
+    steps
+  };
+}
+function transitionSelfHostingLoop(state, event) {
+  const nextState = TRANSITIONS[state][event];
+  if (!nextState) {
+    throw new Error(`Invalid self-hosting loop transition: ${state} -> ${event}`);
+  }
+  return nextState;
+}
 
 // src/subagents/index.ts
 var import_agent_runtime7 = require("@robota-sdk/agent-runtime");
 var import_agent_runtime8 = require("@robota-sdk/agent-runtime");
 
 // src/index.ts
-var import_agent_core6 = require("@robota-sdk/agent-core");
+var import_agent_core7 = require("@robota-sdk/agent-core");
 
 // src/permissions/permission-prompt.ts
 var import_chalk = __toESM(require("chalk"), 1);
@@ -4413,7 +5803,7 @@ async function promptForApproval(terminal, toolName, toolArgs) {
 }
 
 // src/index.ts
-var import_agent_core7 = require("@robota-sdk/agent-core");
+var import_agent_core8 = require("@robota-sdk/agent-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentExecutor,
@@ -4425,10 +5815,14 @@ var import_agent_core7 = require("@robota-sdk/agent-core");
   BundlePluginInstaller,
   BundlePluginLoader,
   CommandRegistry,
+  EditCheckpointStore,
   InteractiveSession,
+  MEMORY_INDEX_MAX_BYTES,
+  MEMORY_INDEX_MAX_LINES,
   MarketplaceClient,
   PluginCommandSource,
   PluginSettingsStore,
+  ProjectMemoryStore,
   PromptExecutor,
   SkillCommandSource,
   SubagentManager,
@@ -4447,26 +5841,37 @@ var import_agent_core7 = require("@robota-sdk/agent-core");
   createSubagentSession,
   createSystemCommands,
   createWorktreeSubagentRunner,
+  discoverTaskFiles,
   evaluatePermission,
   executeSkill,
+  formatTaskContext,
   getBackgroundTaskTransitions,
   getBuiltInAgent,
   getForkWorkerSuffix,
   getMessagesForAPI,
   getSubagentSuffix,
   isChatEntry,
+  isMemoryType,
   isTerminalBackgroundTaskStatus,
+  loadTaskContext,
   messageToHistoryEntry,
   parseFrontmatter,
+  parseTaskFile,
+  planSelfHostingVerification,
   preprocessShellCommands,
   projectPaths,
   promptForApproval,
+  readCurrentGitBranch,
   resolveSubagentLogDir,
   retrieveAgentToolDeps,
   runHooks,
+  selectRelevantTasks,
   storeAgentToolDeps,
   substituteVariables,
   summarizeBackgroundJobGroup,
   transitionBackgroundTaskStatus,
-  userPaths
+  transitionSelfHostingLoop,
+  updateTaskFileStatus,
+  userPaths,
+  wrapEditCheckpointTools
 });