@robota-sdk/agent-sdk 3.0.0-beta.56 → 3.0.0-beta.58

package/dist/node/index.js

@@ -103,6 +103,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" },
@@ -139,6 +161,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",
@@ -385,8 +419,509 @@ Next offset: ${page.nextCursor.offset}` : "";
   return { message: `Unknown background action: ${action}`, success: false };
 }
 
+// src/memory/pending-memory-store.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+var PENDING_FILENAME = "pending.json";
+function memoryRoot(cwd) {
+  return join2(cwd, ".robota", "memory");
+}
+function emptyDocument() {
+  return { version: 1, records: [] };
+}
+var PendingMemoryStore = class {
+  path;
+  now;
+  constructor(cwd, now = () => /* @__PURE__ */ new Date()) {
+    this.path = join2(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 (!existsSync2(this.path)) return emptyDocument();
+    try {
+      const parsed = JSON.parse(readFileSync2(this.path, "utf8"));
+      return { version: 1, records: parsed.records ?? [] };
+    } catch {
+      return emptyDocument();
+    }
+  }
+  write(document) {
+    mkdirSync(dirname(this.path), { recursive: true });
+    writeFileSync(this.path, JSON.stringify(document, null, 2), "utf8");
+  }
+};
+
+// src/memory/project-memory-store.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  appendFileSync
+} from "fs";
+import { basename as basename2, join as join3 } from "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 join3(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 join3(memoryRoot2(this.cwd), INDEX_FILENAME);
+  }
+  getTopicsPath() {
+    return join3(memoryRoot2(this.cwd), TOPICS_DIRNAME);
+  }
+  loadStartupMemory() {
+    const path = this.getIndexPath();
+    if (!existsSync3(path)) {
+      return { content: "", path, lineCount: 0, truncated: false };
+    }
+    const raw = readFileSync3(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 = existsSync3(topicsPath) ? readdirSync2(topicsPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TOPIC_EXTENSION)).map((entry) => ({
+      name: basename2(entry.name, TOPIC_EXTENSION),
+      path: join3(topicsPath, entry.name)
+    })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+    return {
+      indexPath: this.getIndexPath(),
+      topicsPath,
+      topics
+    };
+  }
+  readTopic(topic) {
+    const normalized = sanitizeTopic(topic);
+    const path = join3(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
+    if (!existsSync3(path)) return "";
+    return readFileSync3(path, "utf8").trimEnd();
+  }
+  append(input) {
+    const topic = sanitizeTopic(input.topic);
+    const root = memoryRoot2(this.cwd);
+    const topicsPath = this.getTopicsPath();
+    mkdirSync2(topicsPath, { recursive: true });
+    const indexPath = this.getIndexPath();
+    const topicPath = join3(topicsPath, `${topic}${TOPIC_EXTENSION}`);
+    const entry = formatEntry(this.now(), input, topic);
+    const topicHeader = existsSync3(topicPath) ? "" : `# ${topic}
+
+`;
+    const normalizedText = normalizeMemoryText(input.text);
+    if (existsSync3(topicPath) && readFileSync3(topicPath, "utf8").includes(`) ${normalizedText}`)) {
+      return { indexPath, topicPath, topic, deduplicated: true };
+    }
+    if (!existsSync3(indexPath)) {
+      mkdirSync2(root, { recursive: true });
+      writeFileSync2(indexPath, "# Project Memory\n\n", "utf8");
+    }
+    appendFileSync(indexPath, `- ${entry}
+`, "utf8");
+    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 [
     {
@@ -404,6 +939,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",
@@ -546,6 +1083,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",
@@ -588,51 +1140,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
 import { execSync } from "child_process";
@@ -965,11 +1472,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."
@@ -977,11 +1484,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
@@ -991,10 +1498,18 @@ function asZodSchema(schema) {
   return schema;
 }
 var AgentSchema = z.object({
-  prompt: z.string().describe("The task for the subagent to perform"),
+  prompt: z.string().optional().describe("The task for a single subagent to perform. Required when jobs is omitted."),
   subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
   model: z.string().optional().describe("Optional model override"),
-  isolation: z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.')
+  isolation: z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
+  jobs: z.array(
+    z.object({
+      prompt: z.string().describe("The task for this subagent to perform"),
+      subagent_type: z.string().optional().describe("Agent type for this job"),
+      model: z.string().optional().describe("Optional model override for this job"),
+      isolation: z.enum(["none", "worktree"]).optional().describe("Isolation for this job")
+    }).passthrough()
+  ).optional().describe("Batch of subagent jobs to start in one Agent tool call")
 }).passthrough();
 var sessionDepsStore = /* @__PURE__ */ new WeakMap();
 function storeAgentToolDeps(key, deps) {
@@ -1057,7 +1572,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) {
@@ -1065,7 +1595,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);
@@ -1074,21 +1604,93 @@ async function runManagedAgent(args, deps, manager) {
     return stringifyAgentError(message, agentId);
   }
 }
-function createAgentTool(deps) {
-  const manager = createSubagentManager(deps);
-  return createZodFunctionTool(
-    "Agent",
-    AGENT_TOOL_DESCRIPTION,
-    asZodSchema(AgentSchema),
-    async (params) => {
-      const args = params;
-      return runManagedAgent(
-        {
-          prompt: args.prompt,
-          ...args.subagent_type !== void 0 ? { subagent_type: args.subagent_type } : {},
-          ...args.model !== void 0 ? { model: args.model } : {},
-          ...args.isolation !== void 0 ? { isolation: args.isolation } : {}
-        },
+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 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,
+          ...args.subagent_type !== void 0 ? { subagent_type: args.subagent_type } : {},
+          ...args.model !== void 0 ? { model: args.model } : {},
+          ...args.isolation !== void 0 ? { isolation: args.isolation } : {}
+        },
         deps,
         manager
       );
@@ -1174,8 +1776,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 };
   }
@@ -1304,6 +1906,8 @@ function retrieveSessionBackgroundTaskManager(key) {
 }
 
 // src/interactive/interactive-session-execution.ts
+import { randomUUID } from "crypto";
+import { collectAssistantUsageMetadata } from "@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"));
 }
@@ -1321,11 +1925,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) {
@@ -1335,14 +1941,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 persistSession(sessionStore, session, sessionName, cwd, history, backgroundState) {
+function createUsageSummaryEntry(usage3) {
+  return {
+    id: `usage_${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 = 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, memoryState) {
   try {
     const sessionId = session.getSessionId();
     const existing = sessionStore.load(sessionId);
@@ -1361,6 +2004,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 {
@@ -1383,17 +2030,97 @@ var NOOP_TERMINAL = {
 };
 
 // src/interactive/interactive-session-streaming.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFileSync as readFileSync4 } from "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 = readFileSync4(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) => {
@@ -1401,7 +2128,7 @@ function pushToolSummaryToHistory(state) {
     return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
   }).join("\n");
   state.history.push({
-    id: randomUUID(),
+    id: randomUUID2(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-summary",
@@ -1410,7 +2137,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
     }
@@ -1434,7 +2164,7 @@ function applyToolStart(state, event) {
   const toolState = { toolName: event.toolName, firstArg, isRunning: true };
   state.activeTools.push(toolState);
   state.history.push({
-    id: randomUUID(),
+    id: randomUUID2(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-start",
@@ -1446,11 +2176,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: randomUUID(),
+    id: randomUUID2(),
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "tool-end",
@@ -1458,12 +2194,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
+import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/config/config-types.ts
+import { z as z2 } from "zod";
+var UniversalValueSchema = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.null(),
+    z2.undefined(),
+    z2.date(),
+    z2.array(UniversalValueSchema),
+    z2.record(UniversalValueSchema)
+  ])
+);
+var ProviderSchema = z2.object({
+  name: z2.string().optional(),
+  model: z2.string().optional(),
+  apiKey: z2.string().optional(),
+  baseURL: z2.string().optional(),
+  timeout: z2.number().optional(),
+  options: z2.record(UniversalValueSchema).optional()
+});
+var ProviderProfileSchema = z2.object({
+  type: z2.string().optional(),
+  model: z2.string().optional(),
+  apiKey: z2.string().optional(),
+  baseURL: z2.string().optional(),
+  timeout: z2.number().optional(),
+  options: z2.record(UniversalValueSchema).optional()
+});
+var PermissionsSchema = z2.object({
+  /** Patterns that are always approved without prompting */
+  allow: z2.array(z2.string()).optional(),
+  /** Patterns that are always denied */
+  deny: z2.array(z2.string()).optional()
+});
+var EnvSchema = z2.record(z2.string()).optional();
+var CommandHookDefinitionSchema = z2.object({
+  type: z2.literal("command"),
+  command: z2.string(),
+  timeout: z2.number().optional()
+});
+var HttpHookDefinitionSchema = z2.object({
+  type: z2.literal("http"),
+  url: z2.string(),
+  headers: z2.record(z2.string()).optional(),
+  timeout: z2.number().optional()
+});
+var PromptHookDefinitionSchema = z2.object({
+  type: z2.literal("prompt"),
+  prompt: z2.string(),
+  model: z2.string().optional()
+});
+var AgentHookDefinitionSchema = z2.object({
+  type: z2.literal("agent"),
+  agent: z2.string(),
+  maxTurns: z2.number().optional(),
+  timeout: z2.number().optional()
+});
+var HookDefinitionSchema = z2.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
+var HookGroupSchema = z2.object({
+  matcher: z2.string(),
+  hooks: z2.array(HookDefinitionSchema)
+});
+var HooksSchema = z2.object({
+  PreToolUse: z2.array(HookGroupSchema).optional(),
+  PostToolUse: z2.array(HookGroupSchema).optional(),
+  SessionStart: z2.array(HookGroupSchema).optional(),
+  SessionEnd: z2.array(HookGroupSchema).optional(),
+  Stop: z2.array(HookGroupSchema).optional(),
+  StopFailure: z2.array(HookGroupSchema).optional(),
+  PreCompact: z2.array(HookGroupSchema).optional(),
+  PostCompact: z2.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z2.array(HookGroupSchema).optional(),
+  SubagentStart: z2.array(HookGroupSchema).optional(),
+  SubagentStop: z2.array(HookGroupSchema).optional(),
+  WorktreeCreate: z2.array(HookGroupSchema).optional(),
+  WorktreeRemove: z2.array(HookGroupSchema).optional()
+}).optional();
+var EnabledPluginsSchema = z2.record(z2.boolean()).optional();
+var MarketplaceSourceSchema = z2.object({
+  source: z2.object({
+    type: z2.enum(["github", "git", "local", "url"]),
+    repo: z2.string().optional(),
+    url: z2.string().optional(),
+    path: z2.string().optional(),
+    ref: z2.string().optional()
+  })
+});
+var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional().catch(void 0);
+var SettingsSchema = z2.object({
+  /** Trust level used when no --permission-mode flag is given */
+  defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
+  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
+  language: z2.string().optional(),
+  /** Active provider profile key from providers. */
+  currentProvider: z2.string().optional(),
+  /** Provider profiles keyed by user-facing profile name. */
+  providers: z2.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 (!existsSync4(filePath)) {
+    return void 0;
+  }
+  const raw = readFileSync5(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 [
+    join4(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    join4(home, ".claude", "settings.json"),
+    // 1b. user (Claude Code compat)
+    join4(cwd, ".robota", "settings.json"),
+    // 2. project
+    join4(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    join4(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    join4(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);
@@ -1590,6 +2621,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 };
 }
@@ -1640,6 +2673,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(
@@ -1712,6 +2765,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));
@@ -1755,18 +2810,18 @@ function createDefaultTools() {
 }
 
 // src/tools/background-process-tool.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import { createZodFunctionTool as createZodFunctionTool2 } from "@robota-sdk/agent-tools";
 var DEFAULT_PROCESS_TIMEOUT_MS = 12e4;
 function asZodSchema2(schema) {
   return schema;
 }
-var BackgroundProcessSchema = z2.object({
-  command: z2.string().describe("The shell command to start in the background"),
-  timeout: z2.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
-  workingDirectory: z2.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
-  stdin: z2.string().optional().describe("Optional stdin to write after the process starts."),
-  outputLimitBytes: z2.number().optional().describe("Maximum captured output bytes kept in the task result.")
+var BackgroundProcessSchema = z3.object({
+  command: z3.string().describe("The shell command to start in the background"),
+  timeout: z3.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
+  workingDirectory: z3.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
+  stdin: z3.string().optional().describe("Optional stdin to write after the process starts."),
+  outputLimitBytes: z3.number().optional().describe("Maximum captured output bytes kept in the task result.")
 });
 function stringifyStarted(taskId, status, command) {
   return JSON.stringify({
@@ -1815,11 +2870,11 @@ function createBackgroundProcessTool(deps) {
 }
 
 // src/tools/command-execution-tool.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 import { createZodFunctionTool as createZodFunctionTool3 } from "@robota-sdk/agent-tools";
-var CommandExecutionSchema = z3.object({
-  command: z3.string().describe("Command name to execute, with or without a leading slash"),
-  args: z3.string().optional().describe("Arguments to pass to the command")
+var CommandExecutionSchema = z4.object({
+  command: z4.string().describe("Command name to execute, with or without a leading slash"),
+  args: z4.string().optional().describe("Arguments to pass to the command")
 });
 function asZodSchema3(schema) {
   return schema;
@@ -1862,12 +2917,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
 import { BackgroundTaskManager as BackgroundTaskManager2, SubagentManager as SubagentManager2 } from "@robota-sdk/agent-runtime";
 
 // src/agents/agent-definition-loader.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2, basename as basename2 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { join as join5, basename as basename3 } from "path";
 import { homedir as homedir2 } from "os";
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
 var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
@@ -1912,20 +3010,20 @@ function parseFrontmatter2(content) {
   };
 }
 function scanAgentsDir(dir) {
-  if (!existsSync2(dir)) return [];
+  if (!existsSync5(dir)) return [];
   const agents = [];
   let entries;
   try {
-    entries = readdirSync2(dir, { withFileTypes: true });
+    entries = readdirSync3(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join2(dir, entry.name);
-    const content = readFileSync2(filePath, "utf-8");
+    const filePath = join5(dir, entry.name);
+    const content = readFileSync6(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter2(content);
-    const fallbackName = basename2(entry.name, ".md");
+    const fallbackName = basename3(entry.name, ".md");
     const agent = {
       name: frontmatter?.name ?? fallbackName,
       description: frontmatter?.description ?? "",
@@ -1950,11 +3048,11 @@ var AgentDefinitionLoader = class {
   /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
   loadAll() {
     const sources = [
-      scanAgentsDir(join2(this.cwd, ".robota", "agents")),
-      scanAgentsDir(join2(this.cwd, ".agents", "agents")),
-      scanAgentsDir(join2(this.cwd, ".claude", "agents")),
-      scanAgentsDir(join2(this.home, ".robota", "agents")),
-      scanAgentsDir(join2(this.home, ".claude", "agents"))
+      scanAgentsDir(join5(this.cwd, ".robota", "agents")),
+      scanAgentsDir(join5(this.cwd, ".agents", "agents")),
+      scanAgentsDir(join5(this.cwd, ".claude", "agents")),
+      scanAgentsDir(join5(this.home, ".robota", "agents")),
+      scanAgentsDir(join5(this.home, ".claude", "agents"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const customAgents = [];
@@ -2032,7 +3130,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(
@@ -2133,6 +3231,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"
@@ -2186,6 +3286,7 @@ ${options.appendSystemPrompt}` : systemMessage;
     sessionId,
     permissionHandler: options.permissionHandler,
     onTextDelta: options.onTextDelta,
+    onContextUpdate: options.onContextUpdate,
     onToolExecution: options.onToolExecution,
     promptForApproval: options.promptForApproval,
     onCompact: options.onCompact,
@@ -2202,342 +3303,237 @@ ${options.appendSystemPrompt}` : systemMessage;
 function createSessionId() {
   return `session_${Date.now()}_${Math.random().toString(ID_RADIX).substr(2, ID_RANDOM_LENGTH)}`;
 }
-function logBackgroundTaskEvent(logger, sessionId, event) {
-  logger.log(sessionId, "background_task_event", {
-    backgroundEventType: event.type,
-    backgroundEvent: event
-  });
-}
-
-// src/assembly/subagent-logger.ts
-import { mkdirSync } from "fs";
-import { join as join3 } from "path";
-import { FileSessionLogger } from "@robota-sdk/agent-sessions";
-function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
-  const subagentDir = join3(baseLogsDir, parentSessionId, "subagents");
-  mkdirSync(subagentDir, { recursive: true });
-  return new FileSessionLogger(subagentDir);
-}
-function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
-  return join3(baseLogsDir, parentSessionId, "subagents");
-}
-
-// src/interactive/interactive-session-init.ts
-import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
-
-// src/paths.ts
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-function projectPaths(cwd) {
-  const base = join4(cwd, ".robota");
-  return {
-    settings: join4(base, "settings.json"),
-    settingsLocal: join4(base, "settings.local.json"),
-    logs: join4(base, "logs"),
-    sessions: join4(base, "sessions")
-  };
-}
-function userPaths() {
-  const base = join4(homedir3(), ".robota");
-  return {
-    settings: join4(base, "settings.json"),
-    sessions: join4(base, "sessions")
-  };
-}
-
-// src/config/config-loader.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
-
-// src/config/config-types.ts
-import { z as z4 } from "zod";
-var ProviderSchema = z4.object({
-  name: z4.string().optional(),
-  model: z4.string().optional(),
-  apiKey: z4.string().optional(),
-  baseURL: z4.string().optional(),
-  timeout: z4.number().optional()
-});
-var ProviderProfileSchema = z4.object({
-  type: z4.string().optional(),
-  model: z4.string().optional(),
-  apiKey: z4.string().optional(),
-  baseURL: z4.string().optional(),
-  timeout: z4.number().optional()
-});
-var PermissionsSchema = z4.object({
-  /** Patterns that are always approved without prompting */
-  allow: z4.array(z4.string()).optional(),
-  /** Patterns that are always denied */
-  deny: z4.array(z4.string()).optional()
-});
-var EnvSchema = z4.record(z4.string()).optional();
-var CommandHookDefinitionSchema = z4.object({
-  type: z4.literal("command"),
-  command: z4.string(),
-  timeout: z4.number().optional()
-});
-var HttpHookDefinitionSchema = z4.object({
-  type: z4.literal("http"),
-  url: z4.string(),
-  headers: z4.record(z4.string()).optional(),
-  timeout: z4.number().optional()
-});
-var PromptHookDefinitionSchema = z4.object({
-  type: z4.literal("prompt"),
-  prompt: z4.string(),
-  model: z4.string().optional()
-});
-var AgentHookDefinitionSchema = z4.object({
-  type: z4.literal("agent"),
-  agent: z4.string(),
-  maxTurns: z4.number().optional(),
-  timeout: z4.number().optional()
-});
-var HookDefinitionSchema = z4.discriminatedUnion("type", [
-  CommandHookDefinitionSchema,
-  HttpHookDefinitionSchema,
-  PromptHookDefinitionSchema,
-  AgentHookDefinitionSchema
-]);
-var HookGroupSchema = z4.object({
-  matcher: z4.string(),
-  hooks: z4.array(HookDefinitionSchema)
-});
-var HooksSchema = z4.object({
-  PreToolUse: z4.array(HookGroupSchema).optional(),
-  PostToolUse: z4.array(HookGroupSchema).optional(),
-  SessionStart: z4.array(HookGroupSchema).optional(),
-  SessionEnd: z4.array(HookGroupSchema).optional(),
-  Stop: z4.array(HookGroupSchema).optional(),
-  StopFailure: z4.array(HookGroupSchema).optional(),
-  PreCompact: z4.array(HookGroupSchema).optional(),
-  PostCompact: z4.array(HookGroupSchema).optional(),
-  UserPromptSubmit: z4.array(HookGroupSchema).optional(),
-  SubagentStart: z4.array(HookGroupSchema).optional(),
-  SubagentStop: z4.array(HookGroupSchema).optional(),
-  WorktreeCreate: z4.array(HookGroupSchema).optional(),
-  WorktreeRemove: z4.array(HookGroupSchema).optional()
-}).optional();
-var EnabledPluginsSchema = z4.record(z4.boolean()).optional();
-var MarketplaceSourceSchema = z4.object({
-  source: z4.object({
-    type: z4.enum(["github", "git", "local", "url"]),
-    repo: z4.string().optional(),
-    url: z4.string().optional(),
-    path: z4.string().optional(),
-    ref: z4.string().optional()
-  })
-});
-var ExtraKnownMarketplacesSchema = z4.record(MarketplaceSourceSchema).optional().catch(void 0);
-var SettingsSchema = z4.object({
-  /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: z4.enum(["safe", "moderate", "full"]).optional(),
-  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: z4.string().optional(),
-  /** Active provider profile key from providers. */
-  currentProvider: z4.string().optional(),
-  /** Provider profiles keyed by user-facing profile name. */
-  providers: z4.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 (!existsSync3(filePath)) {
-    return void 0;
-  }
-  const raw = readFileSync3(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
-    };
-  }
+function logBackgroundTaskEvent(logger, sessionId, event) {
+  logger.log(sessionId, "background_task_event", {
+    backgroundEventType: event.type,
+    backgroundEvent: event
+  });
+}
+
+// src/assembly/subagent-logger.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
+import { FileSessionLogger } from "@robota-sdk/agent-sessions";
+function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
+  const subagentDir = join6(baseLogsDir, parentSessionId, "subagents");
+  mkdirSync3(subagentDir, { recursive: true });
+  return new FileSessionLogger(subagentDir);
+}
+function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
+  return join6(baseLogsDir, parentSessionId, "subagents");
+}
+
+// src/interactive/interactive-session-init.ts
+import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
+
+// src/paths.ts
+import { join as join7 } from "path";
+import { homedir as homedir3 } from "os";
+function projectPaths(cwd) {
+  const base = join7(cwd, ".robota");
   return {
-    ...settings,
-    provider
+    settings: join7(base, "settings.json"),
+    settingsLocal: join7(base, "settings.local.json"),
+    logs: join7(base, "logs"),
+    sessions: join7(base, "sessions"),
+    memory: join7(base, "memory"),
+    checkpoints: join7(base, "checkpoints")
   };
 }
-function 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 userPaths() {
+  const base = join7(homedir3(), ".robota");
+  return {
+    settings: join7(base, "settings.json"),
+    sessions: join7(base, "sessions")
+  };
 }
-function mergeProviders(base, override) {
-  const result = { ...base ?? {} };
-  for (const [name, profile] of Object.entries(override ?? {})) {
-    result[name] = {
-      ...result[name],
-      ...profile
-    };
+
+// src/context/context-loader.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { join as join9, dirname as dirname3, resolve as resolve2 } from "path";
+
+// src/context/task-context.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename4, dirname as dirname2, isAbsolute, join as join8, relative, resolve } from "path";
+var TASKS_DIR = join8(".agents", "tasks");
+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() || basename4(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;
   }
-  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`);
+  const collected = [];
+  for (const line of lines.slice(startIndex + Number("1"))) {
+    if (/^##\s+/.test(line)) {
+      break;
     }
-    if (profile.type === void 0) {
-      throw new Error(`Provider profile "${merged.currentProvider}" is missing type`);
+    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, "");
+  }
+  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 = resolve(cwd);
+  let reachedRoot = false;
+  while (!reachedRoot) {
+    const gitPath = join8(current, ".git");
+    if (existsSync6(gitPath)) {
+      const stats = statSync(gitPath);
+      if (stats.isDirectory()) return gitPath;
+      const content = readFileSync7(gitPath, "utf8").trim();
+      const gitdir = content.match(/^gitdir:\s*(.+)$/)?.[1];
+      if (gitdir) return isAbsolute(gitdir) ? gitdir : resolve(current, gitdir);
     }
-    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 }
-    };
+    const parent = dirname2(current);
+    reachedRoot = parent === current;
+    current = parent;
   }
-  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 }
-  };
+  return void 0;
 }
-function toResolvedConfig(merged) {
+function readCurrentGitBranch(cwd) {
+  const gitDir = resolveGitDirectory(cwd);
+  if (!gitDir) return void 0;
+  const headPath = join8(gitDir, "HEAD");
+  if (!existsSync6(headPath)) return void 0;
+  const head = readFileSync7(headPath, "utf8").trim();
+  const branch = head.match(/^ref:\s+refs\/heads\/(.+)$/)?.[1];
+  return branch?.trim();
+}
+function discoverTaskFiles(cwd) {
+  const tasksDir = join8(cwd, TASKS_DIR);
+  if (!existsSync6(tasksDir)) {
+    return [];
+  }
+  return readdirSync4(tasksDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name !== README_FILENAME && name.endsWith(MARKDOWN_EXTENSION)).sort((a, b) => a.localeCompare(b)).map((name) => join8(tasksDir, name));
+}
+function parseTaskFile(taskPath, cwd) {
+  const content = readFileSync7(taskPath, "utf8");
   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
+    path: taskPath,
+    relativePath: 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 getSettingsPaths(cwd) {
-  const home = getHomeDir();
-  return [
-    join5(home, ".robota", "settings.json"),
-    // 1. user (lowest)
-    join5(home, ".claude", "settings.json"),
-    // 1b. user (Claude Code compat)
-    join5(cwd, ".robota", "settings.json"),
-    // 2. project
-    join5(cwd, ".robota", "settings.local.json"),
-    // 3. project-local
-    join5(cwd, ".claude", "settings.json"),
-    // 4. project, Claude Code compat
-    join5(cwd, ".claude", "settings.local.json")
-    // 5. project-local (highest)
-  ];
+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);
 }
-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);
+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(readFileSync7(taskPath, "utf8"), status);
+  const withProgress = options.progressMessage ? appendProgressEntry(updated, options.now ?? /* @__PURE__ */ new Date(), options.progressMessage) : updated;
+  writeFileSync3(taskPath, withProgress, "utf8");
 }
 
 // src/context/context-loader.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join6, dirname, resolve } from "path";
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
   const found = [];
-  let current = resolve(startDir);
+  let current = resolve2(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join6(current, filename);
-    if (existsSync4(candidate)) {
+    const candidate = join9(current, filename);
+    if (existsSync7(candidate)) {
       found.push(candidate);
     }
-    const parent = dirname(current);
+    const parent = dirname3(current);
     atRoot = parent === current;
     if (!atRoot) {
       current = parent;
@@ -2572,47 +3568,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) => readFileSync4(p, "utf-8")).join("\n\n");
-  const claudeMd = claudePaths.map((p) => readFileSync4(p, "utf-8")).join("\n\n");
+  const agentsMd = agentsPaths.map((p) => readFileSync8(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => readFileSync8(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
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { join as join10 } from "path";
 function tryReadJson(filePath) {
-  if (!existsSync5(filePath)) return void 0;
+  if (!existsSync8(filePath)) return void 0;
   try {
-    return JSON.parse(readFileSync5(filePath, "utf-8"));
+    return JSON.parse(readFileSync9(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync5(join7(cwd, "pnpm-workspace.yaml")) || existsSync5(join7(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync8(join10(cwd, "pnpm-workspace.yaml")) || existsSync8(join10(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync5(join7(cwd, "yarn.lock"))) {
+  if (existsSync8(join10(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync5(join7(cwd, "bun.lockb"))) {
+  if (existsSync8(join10(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync5(join7(cwd, "package-lock.json"))) {
+  if (existsSync8(join10(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join7(cwd, "package.json");
-  const tsconfigPath = join7(cwd, "tsconfig.json");
-  const pyprojectPath = join7(cwd, "pyproject.toml");
-  const cargoPath = join7(cwd, "Cargo.toml");
-  const goModPath = join7(cwd, "go.mod");
-  if (existsSync5(pkgJsonPath)) {
+  const pkgJsonPath = join10(cwd, "package.json");
+  const tsconfigPath = join10(cwd, "tsconfig.json");
+  const pyprojectPath = join10(cwd, "pyproject.toml");
+  const cargoPath = join10(cwd, "Cargo.toml");
+  const goModPath = join10(cwd, "go.mod");
+  if (existsSync8(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
-    const language = existsSync5(tsconfigPath) ? "typescript" : "javascript";
+    const language = existsSync8(tsconfigPath) ? "typescript" : "javascript";
     const packageManager = detectPackageManager(cwd);
     return {
       type: "node",
@@ -2621,19 +3621,19 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync5(pyprojectPath) || existsSync5(join7(cwd, "setup.py"))) {
+  if (existsSync8(pyprojectPath) || existsSync8(join10(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
     };
   }
-  if (existsSync5(cargoPath)) {
+  if (existsSync8(cargoPath)) {
     return {
       type: "rust",
       language: "rust"
     };
   }
-  if (existsSync5(goModPath)) {
+  if (existsSync8(goModPath)) {
     return {
       type: "go",
       language: "go"
@@ -2646,8 +3646,8 @@ async function detectProject(cwd) {
 }
 
 // src/plugins/plugin-settings-store.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4 } from "path";
 var PluginSettingsStore = class {
   settingsPath;
   constructor(settingsPath) {
@@ -2655,11 +3655,11 @@ var PluginSettingsStore = class {
   }
   /** Read the full settings file from disk. */
   readAll() {
-    if (!existsSync6(this.settingsPath)) {
+    if (!existsSync9(this.settingsPath)) {
       return {};
     }
     try {
-      const raw = readFileSync6(this.settingsPath, "utf-8");
+      const raw = readFileSync10(this.settingsPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -2671,11 +3671,11 @@ var PluginSettingsStore = class {
   }
   /** Write the full settings file to disk. */
   writeAll(settings) {
-    const dir = dirname2(this.settingsPath);
-    if (!existsSync6(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    const dir = dirname4(this.settingsPath);
+    if (!existsSync9(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    writeFileSync4(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
   // --- enabledPlugins ---
   /** Get the enabledPlugins map. */
@@ -2747,11 +3747,11 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join11 } from "path";
 
 // src/plugins/bundle-plugin-utils.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync5 } from "fs";
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -2800,9 +3800,9 @@ function validateManifest(data) {
   };
 }
 function getSortedSubdirs(dirPath) {
-  if (!existsSync7(dirPath)) return [];
+  if (!existsSync10(dirPath)) return [];
   try {
-    const entries = readdirSync3(dirPath, { withFileTypes: true });
+    const entries = readdirSync5(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -2832,23 +3832,23 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = join8(this.pluginsDir, "cache");
-    if (!existsSync8(cacheDir)) {
+    const cacheDir = join11(this.pluginsDir, "cache");
+    if (!existsSync11(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = join8(cacheDir, marketplace);
+      const marketplaceDir = join11(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = join8(marketplaceDir, pluginName);
+        const pluginDir = join11(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = join8(pluginDir, latestVersion);
-        const manifestPath = join8(versionDir, ".claude-plugin", "plugin.json");
-        if (!existsSync8(manifestPath)) continue;
+        const versionDir = join11(pluginDir, latestVersion);
+        const manifestPath = join11(versionDir, ".claude-plugin", "plugin.json");
+        if (!existsSync11(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -2862,7 +3862,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = readFileSync7(path, "utf-8");
+      const raw = readFileSync11(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -2897,15 +3897,15 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = join8(pluginDir, "skills");
-    if (!existsSync8(skillsDir)) return [];
-    const entries = readdirSync4(skillsDir, { withFileTypes: true });
+    const skillsDir = join11(pluginDir, "skills");
+    if (!existsSync11(skillsDir)) return [];
+    const entries = readdirSync6(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = join8(skillsDir, entry.name, "SKILL.md");
-      if (!existsSync8(skillFile)) continue;
-      const raw = readFileSync7(skillFile, "utf-8");
+      const skillFile = join11(skillsDir, entry.name, "SKILL.md");
+      if (!existsSync11(skillFile)) continue;
+      const raw = readFileSync11(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -2920,13 +3920,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = join8(pluginDir, "commands");
-    if (!existsSync8(commandsDir)) return [];
-    const entries = readdirSync4(commandsDir, { withFileTypes: true });
+    const commandsDir = join11(pluginDir, "commands");
+    if (!existsSync11(commandsDir)) return [];
+    const entries = readdirSync6(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = readFileSync7(join8(commandsDir, entry.name), "utf-8");
+      const raw = readFileSync11(join11(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 : "";
@@ -2941,10 +3941,10 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = join8(pluginDir, "hooks", "hooks.json");
-    if (!existsSync8(hooksPath)) return {};
+    const hooksPath = join11(pluginDir, "hooks", "hooks.json");
+    if (!existsSync11(hooksPath)) return {};
     try {
-      const raw = readFileSync7(hooksPath, "utf-8");
+      const raw = readFileSync11(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -2956,12 +3956,12 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = join8(pluginDir, ".mcp.json");
-    const fallbackPath = join8(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = existsSync8(primaryPath) ? primaryPath : fallbackPath;
-    if (!existsSync8(mcpPath)) return void 0;
+    const primaryPath = join11(pluginDir, ".mcp.json");
+    const fallbackPath = join11(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = existsSync11(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync11(mcpPath)) return void 0;
     try {
-      const raw = readFileSync7(mcpPath, "utf-8");
+      const raw = readFileSync11(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -2969,10 +3969,10 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = join8(pluginDir, "agents");
-    if (!existsSync8(agentsDir)) return [];
+    const agentsDir = join11(pluginDir, "agents");
+    if (!existsSync11(agentsDir)) return [];
     try {
-      const entries = readdirSync4(agentsDir, { withFileTypes: true });
+      const entries = readdirSync6(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -2982,8 +3982,8 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 import { execSync as execSync2 } from "child_process";
-import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join9, dirname as dirname3 } from "path";
+import { cpSync, existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync12, rmSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -2994,8 +3994,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = join9(this.pluginsDir, "cache");
-    this.registryPath = join9(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = join12(this.pluginsDir, "cache");
+    this.registryPath = join12(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -3015,8 +4015,8 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = join9(this.cacheDir, marketplaceName, pluginName, version);
-    if (existsSync9(targetDir)) {
+    const targetDir = join12(this.cacheDir, marketplaceName, pluginName, version);
+    if (existsSync12(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -3043,7 +4043,7 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if (existsSync9(record.installPath)) {
+    if (existsSync12(record.installPath)) {
       rmSync(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
@@ -3090,13 +4090,13 @@ var BundlePluginInstaller = class {
   }
   /** Resolve the source and install the plugin. */
   resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
-    mkdirSync3(targetDir, { recursive: true });
+    mkdirSync5(targetDir, { recursive: true });
     const source = this.normalizeSource(rawSource);
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = join9(marketplaceDir, source);
-        if (!existsSync9(sourcePath)) {
+        const sourcePath = join12(marketplaceDir, source);
+        if (!existsSync12(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
@@ -3113,7 +4113,7 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if (existsSync9(targetDir)) {
+      if (existsSync12(targetDir)) {
         rmSync(targetDir, { recursive: true, force: true });
       }
       throw err;
@@ -3132,11 +4132,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!existsSync9(this.registryPath)) {
+    if (!existsSync12(this.registryPath)) {
       return {};
     }
     try {
-      const raw = readFileSync8(this.registryPath, "utf-8");
+      const raw = readFileSync12(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -3148,11 +4148,11 @@ var BundlePluginInstaller = class {
   }
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
-    const dir = dirname3(this.registryPath);
-    if (!existsSync9(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    const dir = dirname5(this.registryPath);
+    if (!existsSync12(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
-    writeFileSync2(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+    writeFileSync5(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
@@ -3162,18 +4162,18 @@ var BundlePluginInstaller = class {
 
 // src/plugins/marketplace-client.ts
 import { execSync as execSync3 } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, renameSync, rmSync as rmSync3 } from "fs";
-import { join as join11 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync14, renameSync, rmSync as rmSync3 } from "fs";
+import { join as join14 } from "path";
 
 // src/plugins/marketplace-registry.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join10, dirname as dirname4 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync13, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 function readRegistry(registryPath) {
-  if (!existsSync10(registryPath)) {
+  if (!existsSync13(registryPath)) {
     return {};
   }
   try {
-    const raw = readFileSync9(registryPath, "utf-8");
+    const raw = readFileSync13(registryPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data === "object" && data !== null) {
       return data;
@@ -3184,18 +4184,18 @@ function readRegistry(registryPath) {
   }
 }
 function writeRegistry(registryPath, registry) {
-  const dir = dirname4(registryPath);
-  if (!existsSync10(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname6(registryPath);
+  if (!existsSync13(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  writeFileSync3(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync6(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
-  const installedPath = join10(pluginsDir, "installed_plugins.json");
-  if (!existsSync10(installedPath)) return;
+  const installedPath = join13(pluginsDir, "installed_plugins.json");
+  if (!existsSync13(installedPath)) return;
   let registry;
   try {
-    const raw = readFileSync9(installedPath, "utf-8");
+    const raw = readFileSync13(installedPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) return;
     registry = data;
@@ -3205,7 +4205,7 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
   let changed = false;
   for (const [pluginId, record] of Object.entries(registry)) {
     if (record.marketplace === marketplaceName) {
-      if (record.installPath && existsSync10(record.installPath)) {
+      if (record.installPath && existsSync13(record.installPath)) {
         rmSync2(record.installPath, { recursive: true, force: true });
       }
       delete registry[pluginId];
@@ -3213,11 +4213,11 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
     }
   }
   if (changed) {
-    const dir = dirname4(installedPath);
-    if (!existsSync10(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    const dir = dirname6(installedPath);
+    if (!existsSync13(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
-    writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+    writeFileSync6(installedPath, JSON.stringify(registry, null, 2), "utf-8");
   }
 }
 
@@ -3231,8 +4231,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = join11(this.pluginsDir, "marketplaces");
-    this.registryPath = join11(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = join14(this.pluginsDir, "marketplaces");
+    this.registryPath = join14(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -3245,10 +4245,10 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = join11(this.marketplacesDir, tempName);
-    mkdirSync5(this.marketplacesDir, { recursive: true });
+    const tempDir = join14(this.marketplacesDir, tempName);
+    mkdirSync7(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!existsSync11(source.path)) {
+      if (!existsSync14(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
       cpSync2(source.path, tempDir, { recursive: true });
@@ -3262,8 +4262,8 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = join11(tempDir, ".claude-plugin", "marketplace.json");
-    if (!existsSync11(manifestPath)) {
+    const manifestPath = join14(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync14(manifestPath)) {
       rmSync3(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"
@@ -3280,7 +4280,7 @@ var MarketplaceClient = class {
       rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = join11(this.marketplacesDir, name);
+    const finalDir = join14(this.marketplacesDir, name);
     renameSync(tempDir, finalDir);
     registry[name] = {
       source,
@@ -3302,7 +4302,7 @@ var MarketplaceClient = class {
       throw new Error(`Marketplace "${name}" not found`);
     }
     removeInstalledPluginsForMarketplace(this.pluginsDir, name);
-    if (existsSync11(entry.installLocation)) {
+    if (existsSync14(entry.installLocation)) {
       rmSync3(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
@@ -3319,12 +4319,12 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!existsSync11(entry.installLocation)) {
+    if (!existsSync14(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!existsSync11(localSource.path)) {
+      if (!existsSync14(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
       rmSync3(entry.installLocation, { recursive: true, force: true });
@@ -3357,8 +4357,8 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = join11(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!existsSync11(manifestPath)) {
+    const manifestPath = join14(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync14(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -3421,7 +4421,7 @@ var MarketplaceClient = class {
   }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = readFileSync10(path, "utf-8");
+    const raw = readFileSync14(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -3439,9 +4439,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-import { join as join12, dirname as dirname5 } from "path";
+import { join as join15, dirname as dirname7 } from "path";
 function buildPluginEnv(plugin) {
-  const dataDir = join12(dirname5(dirname5(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = join15(dirname7(dirname7(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -3504,15 +4504,15 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
 
 // src/interactive/interactive-session-init.ts
 import { homedir as homedir4 } from "os";
-import { join as join13 } from "path";
+import { join as join16 } from "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 = join13(homedir4(), ".robota", "plugins");
+  const pluginsDir = join16(homedir4(), ".robota", "plugins");
   const pluginLoader = new BundlePluginLoader(pluginsDir);
   let mergedConfig = config;
   if (!options.bare) {
@@ -3545,6 +4545,7 @@ async function createInteractiveSession(options) {
     permissionHandler: options.permissionHandler,
     provider: options.provider,
     onTextDelta: options.onTextDelta,
+    onContextUpdate: options.onContextUpdate,
     onToolExecution: options.onToolExecution,
     sessionId,
     allowedTools: options.allowedTools,
@@ -3561,7 +4562,8 @@ async function createInteractiveSession(options) {
       ]
     } : {},
     modelCommandExecutor: options.modelCommandExecutor,
-    isModelCommandInvocable: options.isModelCommandInvocable
+    isModelCommandInvocable: options.isModelCommandInvocable,
+    editCheckpointRecorder: options.editCheckpointRecorder
   });
 }
 function injectSavedMessage(session, msg) {
@@ -3587,7 +4589,9 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
       backgroundTasks: [],
       backgroundTaskEvents: [],
       backgroundJobGroups: [],
-      backgroundJobGroupEvents: []
+      backgroundJobGroupEvents: [],
+      memoryEvents: [],
+      usedMemoryReferences: []
     };
   }
   const history = record.history ?? [];
@@ -3595,6 +4599,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
@@ -3617,7 +4623,9 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
     backgroundTasks,
     backgroundTaskEvents,
     backgroundJobGroups,
-    backgroundJobGroupEvents
+    backgroundJobGroupEvents,
+    memoryEvents,
+    usedMemoryReferences
   };
 }
 function reconcileRestoredBackgroundTasks(tasks, events) {
@@ -3650,6 +4658,189 @@ function isRestoredTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 
+// src/checkpoints/edit-checkpoint-store.ts
+import { access, copyFile, mkdir, rename, rm, writeFile } from "fs/promises";
+import { constants, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname8, join as join17, relative as relative2, resolve as resolve3 } from "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 = resolve3(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 = join17(this.sessionDir(input.sessionId), id);
+    await mkdir(join17(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 = resolve3(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 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 = join17(
+      SNAPSHOT_DIR,
+      `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
+    );
+    await copyFile(originalPath, join17(active.dir, snapshotFile));
+    return {
+      originalPath,
+      existed: true,
+      snapshotFile
+    };
+  }
+  async restoreFile(sessionId, checkpointId, record) {
+    if (!record.existed) {
+      await rm(record.originalPath, { force: true });
+      return;
+    }
+    if (!record.snapshotFile) {
+      throw new Error(`Checkpoint file record is missing a snapshot: ${record.originalPath}`);
+    }
+    await mkdir(dirname8(record.originalPath), { recursive: true });
+    await copyFile(
+      join17(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+      record.originalPath
+    );
+  }
+  loadManifests(sessionId) {
+    const dir = this.sessionDir(sessionId);
+    return readDirSyncSafe(dir).map((entry) => join17(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 mkdir(dir, { recursive: true });
+    const path = join17(dir, MANIFEST_FILE);
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, JSON.stringify(manifest, null, 2), "utf8");
+    await rename(tmp, path);
+  }
+  sessionDir(sessionId) {
+    return join17(this.rootDir, safePathSegment(sessionId));
+  }
+  checkpointDir(sessionId, checkpointId) {
+    return join17(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 = relative2(parent, child);
+  return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
+}
+async function pathExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readDirSyncSafe(dir) {
+  try {
+    return readdirSync7(dir);
+  } catch {
+    return [];
+  }
+}
+function readJsonManifest(path) {
+  try {
+    const raw = readFileSync15(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/interactive/interactive-session.ts
 var InteractiveSession = class {
   session = null;
@@ -3673,6 +4864,9 @@ var InteractiveSession = class {
   backgroundTaskEvents = [];
   backgroundJobGroups = [];
   backgroundJobGroupEvents = [];
+  memoryEvents = [];
+  usedMemoryReferences = [];
+  editCheckpointStore = null;
   resumeSessionId;
   forkSession;
   backgroundTaskUnsubscribe = null;
@@ -3690,6 +4884,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) {
@@ -3712,21 +4909,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,
@@ -3734,6 +4937,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),
@@ -3876,9 +5080,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(
+      messageToHistoryEntry(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);
   }
@@ -4101,6 +5334,10 @@ var InteractiveSession = class {
         events: this.backgroundTaskEvents,
         groups: this.backgroundJobGroups,
         groupEvents: this.backgroundJobGroupEvents
+      },
+      {
+        events: this.memoryEvents,
+        usedReferences: this.usedMemoryReferences
       }
     );
   }
@@ -4182,7 +5419,9 @@ var InteractiveSession = class {
     this.emit("thinking", true);
     this.history.push(messageToHistoryEntry(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 });
@@ -4195,6 +5434,7 @@ var InteractiveSession = class {
         this.getContextState()
       );
       this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
+      if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
       this.emit("complete", result);
       this.emit("context_update", this.getContextState());
     } catch (err) {
@@ -4210,6 +5450,7 @@ var InteractiveSession = class {
         this.clearStreaming();
         if (result.response)
           this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
+        if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
         this.history.push(messageToHistoryEntry(createSystemMessage("Interrupted by user.")));
         this.emit("interrupted", result);
       } else {
@@ -4220,6 +5461,7 @@ var InteractiveSession = class {
         this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
     } finally {
+      await this.finalizeEditCheckpointTurn();
       this.executing = false;
       this.emit("thinking", false);
       this.persistCurrentSession();
@@ -4232,6 +5474,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(
+        messageToHistoryEntry(createSystemMessage(`Checkpoint error: ${err.message}`))
+      );
+      this.emit("error", err);
+    }
+  }
   handleTextDelta(delta) {
     this.streamingText += delta;
     this.emit("text_delta", delta);
@@ -4282,14 +5549,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();
@@ -4322,6 +5589,121 @@ import {
   getMessagesForAPI
 } from "@robota-sdk/agent-core";
 
+// src/self-hosting/self-hosting-verification.ts
+var DEFAULT_BASE_REF = "origin/develop";
+var PACKAGE_VERIFY_COMMANDS = ["test", "typecheck", "build"];
+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
 import { SubagentManager as SubagentManager3 } from "@robota-sdk/agent-runtime";
 import { WorktreeSubagentRunner, createWorktreeSubagentRunner } from "@robota-sdk/agent-runtime";
@@ -4361,10 +5743,14 @@ export {
   BundlePluginInstaller,
   BundlePluginLoader,
   CommandRegistry,
+  EditCheckpointStore,
   InteractiveSession,
+  MEMORY_INDEX_MAX_BYTES,
+  MEMORY_INDEX_MAX_LINES,
   MarketplaceClient,
   PluginCommandSource,
   PluginSettingsStore,
+  ProjectMemoryStore,
   PromptExecutor,
   SkillCommandSource,
   SubagentManager3 as SubagentManager,
@@ -4383,26 +5769,37 @@ export {
   createSubagentSession,
   createSystemCommands,
   createWorktreeSubagentRunner,
+  discoverTaskFiles,
   evaluatePermission,
   executeSkill,
+  formatTaskContext,
   getBackgroundTaskTransitions,
   getBuiltInAgent,
   getForkWorkerSuffix,
   getMessagesForAPI,
   getSubagentSuffix,
   isChatEntry,
+  isMemoryType,
   isTerminalBackgroundTaskStatus2 as isTerminalBackgroundTaskStatus,
+  loadTaskContext,
   messageToHistoryEntry2 as messageToHistoryEntry,
   parseFrontmatter,
+  parseTaskFile,
+  planSelfHostingVerification,
   preprocessShellCommands,
   projectPaths,
   promptForApproval,
+  readCurrentGitBranch,
   resolveSubagentLogDir,
   retrieveAgentToolDeps,
   runHooks2 as runHooks,
+  selectRelevantTasks,
   storeAgentToolDeps,
   substituteVariables,
   summarizeBackgroundJobGroup,
   transitionBackgroundTaskStatus,
-  userPaths
+  transitionSelfHostingLoop,
+  updateTaskFileStatus,
+  userPaths,
+  wrapEditCheckpointTools
 };