@massa-ai/tools-api 1.52.0 → 1.53.0

package/dist/index.js

@@ -7836,17 +7836,11 @@ function detectRoute(platform, host) {
   if (route === "file")
     return { kind: "proceed" };
   if (route === "marketplace") {
-    if (host === "claude")
+    if (host === "claude" || host === "codex")
       return { kind: "proceed" };
-    if (host === "codex") {
-      return {
-        kind: "refuse",
-        reason: "codex marketplace-route installs are refused (in-place bundle rewrite would dirty a checkout " + "and break the drift gate) \u2014 use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
-      };
-    }
     return {
       kind: "refuse",
-      reason: "claude/codex marketplace-route installs are refused (in-place bundle rewrite would dirty a checkout " + "and break the drift gate) \u2014 use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
+      reason: "marketplace-route installs need an explicit, supported host before switching " + "(claude and codex proceed; no other host resolves a live write target yet) \u2014 " + "use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
     };
   }
   return {
@@ -8045,6 +8039,61 @@ var init_lock = __esm(() => {
 import fs7 from "fs";
 import os5 from "os";
 import path11 from "path";
+function splitPluginKey(pluginKey) {
+  const at = pluginKey.indexOf("@");
+  if (at === -1)
+    return null;
+  const pluginName = pluginKey.slice(0, at);
+  const marketplaceName = pluginKey.slice(at + 1);
+  if (!pluginName || !marketplaceName)
+    return null;
+  return { pluginName, marketplaceName };
+}
+function isContainedPath(root, candidate) {
+  const rel = path11.relative(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !path11.isAbsolute(rel);
+}
+function resolveDirectorySourceRoot(targetHome, pluginKey) {
+  const split = splitPluginKey(pluginKey);
+  if (!split)
+    return;
+  const { pluginName, marketplaceName } = split;
+  const knownMarketplacesPath = path11.join(targetHome, ".claude", "plugins", "known_marketplaces.json");
+  let known;
+  try {
+    known = JSON.parse(fs7.readFileSync(knownMarketplacesPath, "utf8"));
+  } catch {
+    return;
+  }
+  const entry = known?.[marketplaceName];
+  if (!entry || entry.source?.source !== "directory")
+    return;
+  const installLocation = entry.installLocation;
+  if (!installLocation)
+    return null;
+  const manifestPath = path11.join(installLocation, ".claude-plugin", "marketplace.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+  const plugin2 = manifest.plugins?.find((p) => p?.name === pluginName);
+  const relSource = plugin2?.source;
+  if (!relSource)
+    return null;
+  const resolvedInstallLocation = path11.resolve(installLocation);
+  const composed = path11.resolve(resolvedInstallLocation, relSource);
+  if (!isContainedPath(resolvedInstallLocation, composed))
+    return null;
+  try {
+    if (!fs7.existsSync(composed))
+      return null;
+  } catch {
+    return null;
+  }
+  return composed;
+}
 function selectRecord(records) {
   if (records.length === 0)
     return;
@@ -8064,6 +8113,9 @@ function selectRecord(records) {
 function resolveClaudeMarketplaceRoot(opts = {}) {
   const targetHome = opts.targetHome ?? os5.homedir();
   const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
+  const directoryResult = resolveDirectorySourceRoot(targetHome, pluginKey);
+  if (directoryResult !== undefined)
+    return directoryResult;
   const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
   let records;
   try {
@@ -8095,6 +8147,7 @@ import fs8 from "fs";
 import path12 from "path";
 import os6 from "os";
 import crypto5 from "crypto";
+import { execFileSync as execFileSync2 } from "child_process";
 function namedError3(name, message) {
   const err = new SwitchEngineError(message);
   err.name = name;
@@ -8173,6 +8226,46 @@ function matchesGlob(filename, glob) {
   const suffix = glob.slice(starIdx + 1);
   return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
 }
+function matchingFileNames(dir, glob) {
+  return fs8.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
+}
+function detectGitAvailability(dir) {
+  try {
+    const out = execFileSync2("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.toString().trim() === "true" ? "in-repo" : "not-a-repo";
+  } catch (err) {
+    return err.code === "ENOENT" ? "no-git" : "not-a-repo";
+  }
+}
+function gitTrackedFileNames(dir, filenames) {
+  if (filenames.length === 0)
+    return new Set;
+  try {
+    const out = execFileSync2("git", ["-C", dir, "ls-files", "--", ...filenames], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return new Set(out.toString().split(`
+`).map((line) => line.trim()).filter(Boolean));
+  } catch {
+    return new Set;
+  }
+}
+function checkTrackedPathGuard(activeDir, filenames) {
+  if (filenames.length === 0 || !fs8.existsSync(activeDir))
+    return GUARD_PASS;
+  const availability = detectGitAvailability(activeDir);
+  if (availability === "no-git")
+    return GUARD_UNCHECKED;
+  if (availability === "not-a-repo")
+    return GUARD_PASS;
+  const tracked = gitTrackedFileNames(activeDir, filenames);
+  if (tracked.size === 0)
+    return GUARD_PASS;
+  const offending = filenames.find((name) => tracked.has(name));
+  return { blocked: true, path: path12.join(activeDir, offending), unchecked: false };
+}
 function assertStateWritable(stateFilePath) {
   const dir = path12.dirname(stateFilePath);
   try {
@@ -8302,12 +8395,27 @@ function switchProfile(opts) {
         rows.push({ host: h.host, status: "switched" });
         continue;
       }
+      const candidateNames = matchingFileNames(h.variantDir, h.layout.activeGlob);
+      const guard2 = checkTrackedPathGuard(h.layout.activeDir, candidateNames);
+      if (guard2.blocked) {
+        rows.push({
+          host: h.host,
+          status: "failed",
+          reason: `refusing to write ${guard2.path} \u2014 it is tracked by git and this switch would dirty the checkout`
+        });
+        continue;
+      }
       try {
         const filesChanged = copyVariant(h.host, h.layout, h.variantDir);
         updatePlatform(stateFilePath, h.host, {
           modelProfile: { profile: opts.profile, switchedAt: new Date().toISOString() }
         });
-        rows.push({ host: h.host, status: "switched", filesChanged });
+        rows.push({
+          host: h.host,
+          status: "switched",
+          filesChanged,
+          ...guard2.unchecked ? { reason: "tracked-path guard could not verify (git unavailable) \u2014 proceeded unchecked" } : {}
+        });
       } catch (err) {
         rows.push({ host: h.host, status: "failed", reason: err.message });
       }
@@ -8323,7 +8431,7 @@ function orderRows(universe, rows) {
   const byHost = new Map(rows.map((r2) => [r2.host, r2]));
   return HOSTS.filter((h) => universe.includes(h) && byHost.has(h)).map((h) => byHost.get(h));
 }
-var SwitchEngineError, UnknownProfileError = (profile, known) => namedError3("UnknownProfileError", `unknown profile "${profile}" \u2014 installed: ${known.length > 0 ? known.join(", ") : "none"}`), NoHostsDetectedError = () => namedError3("NoHostsDetectedError", "no installed hosts found");
+var SwitchEngineError, UnknownProfileError = (profile, known) => namedError3("UnknownProfileError", `unknown profile "${profile}" \u2014 installed: ${known.length > 0 ? known.join(", ") : "none"}`), NoHostsDetectedError = () => namedError3("NoHostsDetectedError", "no installed hosts found"), GUARD_PASS, GUARD_UNCHECKED;
 var init_engine = __esm(() => {
   init_hosts();
   init_state();
@@ -8335,6 +8443,8 @@ var init_engine = __esm(() => {
       this.name = "SwitchEngineError";
     }
   };
+  GUARD_PASS = { blocked: false, unchecked: false };
+  GUARD_UNCHECKED = { blocked: false, unchecked: true };
 });
 
 // ../../packages/shared/dist/profile-switch/report.js
@@ -128577,7 +128687,7 @@ var init_git_ref_validation = __esm(() => {
 });
 
 // ../../packages/core/dist/services/symbol/impact-analysis.js
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 function readBfsCteFlag() {
   try {
     return Boolean(config.get("impact")?.bfsCteEnabled);
@@ -128903,19 +129013,19 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
     let diffRange;
     if (since) {
       try {
-        ref = execFileSync2("git", ["-C", projectPath2, "rev-parse", "--verify", `${since}^{commit}`], {
+        ref = execFileSync3("git", ["-C", projectPath2, "rev-parse", "--verify", `${since}^{commit}`], {
           cwd: projectPath2,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
         }).trim();
       } catch {
-        ref = execFileSync2("git", ["-C", projectPath2, "rev-list", "-1", `--before=${since}`, "HEAD"], {
+        ref = execFileSync3("git", ["-C", projectPath2, "rev-list", "-1", `--before=${since}`, "HEAD"], {
           cwd: projectPath2,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
         }).trim();
         if (!ref) {
-          const emptyTree = execFileSync2("git", ["hash-object", "-t", "tree", "--stdin"], {
+          const emptyTree = execFileSync3("git", ["hash-object", "-t", "tree", "--stdin"], {
             cwd: projectPath2,
             encoding: "utf-8",
             input: "",
@@ -128927,7 +129037,7 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
     }
     args.push(diffRange ?? `${ref}...HEAD`);
   }
-  const out = execFileSync2("git", args, {
+  const out = execFileSync3("git", args, {
     cwd: projectPath2,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -128939,7 +129049,7 @@ function defaultDiffRunner(projectPath2, scope, baseBranch, since) {
   let untrackedFiltered = 0;
   const merged = new Set(tracked);
   if (includeUntracked) {
-    const untracked = execFileSync2("git", ["-C", projectPath2, "ls-files", "--others", "--exclude-standard"], {
+    const untracked = execFileSync3("git", ["-C", projectPath2, "ls-files", "--others", "--exclude-standard"], {
       cwd: projectPath2,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -128977,7 +129087,7 @@ var init_impact_analysis = __esm(() => {
 });
 
 // ../../packages/core/dist/services/executor/runtime.js
-import { execFileSync as execFileSync3, execSync } from "child_process";
+import { execFileSync as execFileSync4, execSync } from "child_process";
 function commandExists(cmd) {
   try {
     const check3 = isWindows ? `where ${cmd}` : `command -v ${cmd}`;
@@ -129010,7 +129120,7 @@ function getVersion(cmd, args = ["--version"], deps) {
         timeout: 5000
       }).trim().split(/\r?\n/)[0];
     }
-    return execFileSync3(cmd, args, {
+    return execFileSync4(cmd, args, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -129151,12 +129261,12 @@ var init_runtime = __esm(() => {
 
 // ../../packages/core/dist/services/executor/sandbox.js
 import { realpathSync as realpathSync2 } from "fs";
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 function isDockerAvailable() {
   if (_dockerAvailable !== null)
     return _dockerAvailable;
   try {
-    execFileSync4("docker", ["--version"], { stdio: "pipe", timeout: 5000 });
+    execFileSync5("docker", ["--version"], { stdio: "pipe", timeout: 5000 });
     _dockerAvailable = true;
   } catch {
     _dockerAvailable = false;
@@ -129167,7 +129277,7 @@ function isSeatbeltAvailable() {
   if (_seatbeltAvailable !== null)
     return _seatbeltAvailable;
   try {
-    execFileSync4("sandbox-exec", ["--version"], { stdio: "pipe", timeout: 5000 });
+    execFileSync5("sandbox-exec", ["--version"], { stdio: "pipe", timeout: 5000 });
     _seatbeltAvailable = true;
   } catch {
     _seatbeltAvailable = false;
@@ -129272,7 +129382,7 @@ var init_sandbox = __esm(() => {
 });
 
 // ../../packages/core/dist/services/executor/executor.js
-import { spawn, execSync as execSync2, execFileSync as execFileSync5 } from "child_process";
+import { spawn, execSync as execSync2, execFileSync as execFileSync6 } from "child_process";
 import { mkdtempSync, writeFileSync as writeFileSync2, rmSync, realpathSync as realpathSync3 } from "fs";
 import { join as join3, resolve as resolve5, isAbsolute, relative as relative2 } from "path";
 import { tmpdir } from "os";
@@ -129475,7 +129585,7 @@ ${body}`;
     const binPath = srcPath.replace(/\.rs$/, isWin ? ".exe" : "");
     try {
       try {
-        execFileSync5("rustc", [srcPath, "-o", binPath], {
+        execFileSync6("rustc", [srcPath, "-o", binPath], {
           cwd,
           timeout: Math.min(timeout, 60000),
           encoding: "utf-8",
@@ -132417,23 +132527,94 @@ var init_scheduler = __esm(() => {
   };
 });
 
+// ../../packages/core/dist/data/proposal/proposal-payload-validation.js
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isValidProposalPayload(kind, value) {
+  const rule = PROPOSAL_PAYLOAD_RULES[kind];
+  if (!Object.keys(value).every((key) => rule.allowedKeys.includes(key)))
+    return false;
+  if (rule.requireNonEmpty && Object.keys(value).length === 0)
+    return false;
+  for (const [field3, fieldRule] of Object.entries(rule.fields)) {
+    const present = value[field3] !== undefined;
+    if (!present) {
+      if (!fieldRule.optional)
+        return false;
+      continue;
+    }
+    if (!fieldRule.validate(value[field3]))
+      return false;
+  }
+  return true;
+}
+function assertValidProposalPayload(kind, value) {
+  if (!isRecord(value)) {
+    throw new ProposalPayloadValidationError(kind, `proposal payload must be an object for kind "${kind}"`);
+  }
+  if (!isValidProposalPayload(kind, value)) {
+    throw new ProposalPayloadValidationError(kind, `proposal payload is invalid for kind "${kind}"`);
+  }
+}
+var PROPOSAL_PAYLOAD_RULES, ProposalPayloadValidationError;
+var init_proposal_payload_validation = __esm(() => {
+  PROPOSAL_PAYLOAD_RULES = {
+    "memory.create": {
+      allowedKeys: ["content", "type", "level", "importance", "tags"],
+      fields: {
+        content: { optional: false, validate: isString },
+        type: { optional: true, validate: isString },
+        level: { optional: true, validate: isNumber },
+        importance: { optional: true, validate: isNumber },
+        tags: { optional: true, validate: isStringArray }
+      }
+    },
+    "memory.update": {
+      allowedKeys: ["content", "importance", "tags"],
+      requireNonEmpty: true,
+      fields: {
+        content: { optional: true, validate: isString },
+        importance: { optional: true, validate: isNumber },
+        tags: { optional: true, validate: isStringArray }
+      }
+    },
+    "memory.tag": {
+      allowedKeys: ["tags"],
+      fields: {
+        tags: { optional: false, validate: isStringArray }
+      }
+    }
+  };
+  ProposalPayloadValidationError = class ProposalPayloadValidationError extends Error {
+    kind;
+    statusCode = 400;
+    constructor(kind, message) {
+      super(message);
+      this.kind = kind;
+      this.name = "ProposalPayloadValidationError";
+    }
+  };
+});
+
 // ../../packages/core/dist/data/proposal/proposal-contract.js
 var PROPOSAL_STATUSES, PROPOSAL_KINDS;
 var init_proposal_contract = __esm(() => {
+  init_proposal_payload_validation();
   PROPOSAL_STATUSES = ["pending", "approved", "rejected"];
   PROPOSAL_KINDS = ["memory.create", "memory.update", "memory.tag"];
 });
 
 // ../../packages/core/dist/data/proposal/proposal-repository-pg.js
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function stringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function validKeys(value, allowed) {
-  return Object.keys(value).every((key) => allowed.includes(key));
-}
 function parsePayload(raw2, kind) {
   let value;
   try {
@@ -132444,15 +132625,7 @@ function parsePayload(raw2, kind) {
   if (!isRecord(value)) {
     throw storeCorruption("proposal.payload_json", new TypeError("expected object"));
   }
-  let valid = false;
-  if (kind === "memory.create") {
-    valid = validKeys(value, ["content", "type", "level", "importance", "tags"]) && typeof value.content === "string" && (value.type === undefined || typeof value.type === "string") && (value.level === undefined || typeof value.level === "number") && (value.importance === undefined || typeof value.importance === "number") && (value.tags === undefined || stringArray(value.tags));
-  } else if (kind === "memory.update") {
-    valid = validKeys(value, ["content", "importance", "tags"]) && Object.keys(value).length > 0 && (value.content === undefined || typeof value.content === "string") && (value.importance === undefined || typeof value.importance === "number") && (value.tags === undefined || stringArray(value.tags));
-  } else {
-    valid = validKeys(value, ["tags"]) && stringArray(value.tags);
-  }
-  if (!valid) {
+  if (!isValidProposalPayload(kind, value)) {
     throw storeCorruption("proposal.payload_json", new TypeError("invalid proposal payload"));
   }
   return value;
@@ -132586,6 +132759,65 @@ class PgProposalStore {
     this.mirror.set(id, persisted);
     return structuredClone(persisted);
   }
+  async create(input) {
+    assertValidProposalPayload(input.kind, input.payload);
+    const record2 = {
+      id: input.id,
+      projectId: input.projectId,
+      kind: input.kind,
+      targetMemoryId: input.targetMemoryId ?? null,
+      payload: input.payload,
+      rationale: input.rationale ?? "",
+      status: "pending",
+      createdAt: input.createdAt ?? Date.now(),
+      decidedAt: null
+    };
+    await this.insert(record2);
+    return record2;
+  }
+  async update(id, patch) {
+    await this.ensureHydrated();
+    const current = this.mirror.get(id);
+    if (!current)
+      return null;
+    if (patch.payload !== undefined) {
+      assertValidProposalPayload(current.kind, patch.payload);
+    }
+    const merged = {
+      ...current,
+      ...patch.rationale !== undefined ? { rationale: patch.rationale } : {},
+      ...patch.payload !== undefined ? { payload: patch.payload } : {}
+    };
+    let rows;
+    try {
+      rows = await this.getClient().$queryRaw`
+        UPDATE proposals
+        SET rationale = ${merged.rationale}, payload_json = ${JSON.stringify(merged.payload)}
+        WHERE id = ${id}
+        RETURNING id, project_id, kind, target_memory_id, payload_json,
+                  rationale, status, created_at, decided_at`;
+    } catch (error51) {
+      throw searchBackendUnavailable("proposal_store", error51);
+    }
+    if (!rows[0])
+      return null;
+    const persisted = toRecord(rows[0]);
+    this.mirror.set(id, persisted);
+    return structuredClone(persisted);
+  }
+  async delete(id) {
+    await this.ensureHydrated();
+    let affected;
+    try {
+      affected = await this.getClient().$executeRaw`DELETE FROM proposals WHERE id = ${id}`;
+    } catch (error51) {
+      throw searchBackendUnavailable("proposal_store", error51);
+    }
+    if (affected === 0)
+      return null;
+    this.mirror.delete(id);
+    return id;
+  }
   async journalMode() {
     await this.ensureHydrated();
     return "postgres";
@@ -132602,6 +132834,7 @@ var init_proposal_repository_pg = __esm(() => {
   init_alias_resolver();
   init_search_diagnostics();
   init_proposal_contract();
+  init_proposal_payload_validation();
 });
 
 // ../../packages/core/dist/data/proposal/proposal-repository.js
@@ -179181,6 +179414,53 @@ class PgHandoffStore {
     this.mirror.set(id, persisted);
     return structuredClone(persisted);
   }
+  async update(id, patch) {
+    await this.ensureHydrated();
+    const current = this.mirror.get(id);
+    if (!current)
+      return null;
+    const merged = {
+      ...current,
+      ...patch.targetAgent !== undefined ? { targetAgent: patch.targetAgent } : {},
+      ...patch.summary !== undefined ? { summary: patch.summary } : {},
+      ...patch.openQuestions !== undefined ? { openQuestions: patch.openQuestions } : {},
+      ...patch.nextSteps !== undefined ? { nextSteps: patch.nextSteps } : {},
+      ...patch.files !== undefined ? { files: patch.files } : {}
+    };
+    let rows;
+    try {
+      rows = await this.getClient().$queryRaw`
+        UPDATE handoffs
+        SET target_agent = ${merged.targetAgent}, summary = ${merged.summary},
+            open_questions_json = ${JSON.stringify(merged.openQuestions ?? [])},
+            next_steps_json = ${JSON.stringify(merged.nextSteps ?? [])},
+            files_json = ${JSON.stringify(merged.files ?? [])}
+        WHERE id = ${id}
+        RETURNING id, project_id, source_session_id, target_agent, summary,
+                  open_questions_json, next_steps_json, files_json, status,
+                  created_at, accepted_at`;
+    } catch (error51) {
+      throw searchBackendUnavailable("handoff_store", error51);
+    }
+    if (!rows[0])
+      return null;
+    const persisted = toRecord2(rows[0]);
+    this.mirror.set(id, persisted);
+    return structuredClone(persisted);
+  }
+  async delete(id) {
+    await this.ensureHydrated();
+    let affected;
+    try {
+      affected = await this.getClient().$executeRaw`DELETE FROM handoffs WHERE id = ${id}`;
+    } catch (error51) {
+      throw searchBackendUnavailable("handoff_store", error51);
+    }
+    if (affected === 0)
+      return null;
+    this.mirror.delete(id);
+    return id;
+  }
   async journalMode() {
     await this.ensureHydrated();
     return "postgres";
@@ -179205,7 +179485,6 @@ function newHandoffId() {
 // ../../packages/core/dist/services/handoff/handoff-service.js
 init_zod();
 init_dist();
-import { randomUUID as randomUUID10 } from "crypto";
 init_memory_repository_factory();
 init_event_bus();
 init_llm_client();
@@ -179226,7 +179505,8 @@ class HandoffService {
     this.idFactory = deps.idFactory ?? (() => newHandoffId());
     const injectedRepo = deps.memoryRepo;
     this.memoryRepo = injectedRepo ?? {
-      insert: (i) => getMemoryRepository().insert(i)
+      insert: (i) => getMemoryRepository().insert(i),
+      update: (id, p) => getMemoryRepository().update(id, p)
     };
   }
   async begin(input) {
@@ -179268,7 +179548,7 @@ class HandoffService {
     return { ok: true, id, status: "open", memoryId };
   }
   async dualWrite(record2) {
-    const memId = `handoff-mem-${record2.id}-${randomUUID10().slice(0, 8)}`;
+    const memId = dualWriteMemoryId(record2.id);
     const input = buildHandoffMemoryInput(memId, record2);
     await Promise.resolve(this.memoryRepo.insert(input));
     return memId;
@@ -179312,6 +179592,50 @@ class HandoffService {
   async listPending(projectId, targetAgent) {
     return this.store.listPending(projectId, targetAgent ?? undefined);
   }
+  async update(params) {
+    if (!params || !params.id) {
+      return { ok: false, reason: "missing-id" };
+    }
+    const row = await this.store.getById(params.id);
+    if (!row)
+      return { ok: false, reason: "not-found" };
+    if (params.projectId && row.projectId !== params.projectId) {
+      return { ok: false, reason: "project-mismatch" };
+    }
+    const updated = await this.store.update(params.id, params.patch);
+    if (!updated)
+      return { ok: false, reason: "not-found" };
+    const touchesMemoryContent = params.patch.summary !== undefined || params.patch.openQuestions !== undefined || params.patch.nextSteps !== undefined || params.patch.files !== undefined;
+    if (touchesMemoryContent) {
+      await this.refreshDualWriteMemory(updated);
+    }
+    return { ok: true, handoff: updated };
+  }
+  async refreshDualWriteMemory(record2) {
+    try {
+      const memId = dualWriteMemoryId(record2.id);
+      const content = formatMemoryContent(record2);
+      await Promise.resolve(this.memoryRepo.update(memId, { content }));
+    } catch {}
+  }
+  async delete(params) {
+    if (!params || !params.id) {
+      return { ok: false, reason: "missing-id" };
+    }
+    const row = await this.store.getById(params.id);
+    if (!row)
+      return { ok: false, reason: "not-found" };
+    if (params.projectId && row.projectId !== params.projectId) {
+      return { ok: false, reason: "project-mismatch" };
+    }
+    const deletedId = await this.store.delete(params.id);
+    if (!deletedId)
+      return { ok: false, reason: "not-found" };
+    return { ok: true, id: deletedId };
+  }
+}
+function dualWriteMemoryId(handoffId) {
+  return `handoff-mem-${handoffId}`;
 }
 function buildHandoffMemoryInput(memId, record2) {
   const content = formatMemoryContent(record2);
@@ -179406,6 +179730,7 @@ init_event_bus();
 
 // ../../packages/core/dist/index.js
 init_proposal_repository();
+init_proposal_payload_validation();
 init_auto_improve_job();
 
 // src/routes/search.ts
@@ -180400,12 +180725,35 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
   }
 });
 
+// src/routes/sse-keepalive.ts
+var SSE_HEARTBEAT_MS_DEFAULT = 5000;
+var SSE_MAX_DURATION_MS_DEFAULT = 10 * 60 * 1000;
+var SSE_REQUEST_TIMEOUT_SECONDS = 120;
+function resolveHeartbeatMs() {
+  return Number(process.env.MASSA_AI_SSE_HEARTBEAT_MS) || SSE_HEARTBEAT_MS_DEFAULT;
+}
+function resolveMaxDurationMs() {
+  return Number(process.env.MASSA_AI_SSE_MAX_DURATION_MS) || SSE_MAX_DURATION_MS_DEFAULT;
+}
+var requestTimeoutSource;
+var applyCount = 0;
+function setSseRequestTimeoutSource(source) {
+  requestTimeoutSource = source;
+}
+function applySseRequestTimeout(request) {
+  const source = requestTimeoutSource;
+  if (!source || typeof source.timeout !== "function")
+    return;
+  try {
+    source.timeout(request, SSE_REQUEST_TIMEOUT_SECONDS);
+    applyCount++;
+  } catch {}
+}
+
 // src/routes/events.ts
-var HEARTBEAT_MS_DEFAULT = 15000;
-var MAX_DURATION_MS_DEFAULT = 10 * 60 * 1000;
-var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ query, set: set3 }) => {
-  const HEARTBEAT_MS = Number(process.env.MASSA_AI_SSE_HEARTBEAT_MS) || HEARTBEAT_MS_DEFAULT;
-  const MAX_DURATION_MS = Number(process.env.MASSA_AI_SSE_MAX_DURATION_MS) || MAX_DURATION_MS_DEFAULT;
+var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ query, set: set3, request }) => {
+  const HEARTBEAT_MS = resolveHeartbeatMs();
+  const MAX_DURATION_MS = resolveMaxDurationMs();
   const projectIdFilter = query.projectId;
   const jobIdFilter = query.jobId;
   set3.headers["Content-Type"] = "text/event-stream";
@@ -180419,6 +180767,18 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
   let closeTimer;
   const stream2 = new ReadableStream({
     start(controller) {
+      applySseRequestTimeout(request);
+      const teardown = () => {
+        closed = true;
+        unsubscribers.forEach((u) => u());
+        if (heartbeatTimer)
+          clearInterval(heartbeatTimer);
+        if (closeTimer)
+          clearTimeout(closeTimer);
+        try {
+          controller.close();
+        } catch {}
+      };
       const enqueue = (data) => {
         if (closed)
           return;
@@ -180427,7 +180787,7 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 
 `));
         } catch {
-          closed = true;
+          teardown();
         }
       };
       const events = [
@@ -180455,18 +180815,10 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 
 `));
         } catch {
-          closed = true;
-          clearInterval(heartbeatTimer);
+          teardown();
         }
       }, HEARTBEAT_MS);
-      closeTimer = setTimeout(() => {
-        closed = true;
-        unsubscribers.forEach((u) => u());
-        clearInterval(heartbeatTimer);
-        try {
-          controller.close();
-        } catch {}
-      }, MAX_DURATION_MS);
+      closeTimer = setTimeout(teardown, MAX_DURATION_MS);
       enqueue({
         event: "connected",
         payload: {
@@ -181568,6 +181920,16 @@ function rethrowCanonicalHandoffError(error51) {
 var EVENT_DETAIL3 = {
   tags: ["handoffs"]
 };
+var HANDOFF_PATCH_ALLOWED_FIELDS = [
+  "targetAgent",
+  "summary",
+  "openQuestions",
+  "nextSteps",
+  "files"
+];
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 var handoffRoutes = new Elysia({ prefix: "/api/v1/handoff" }).post("/begin", async ({ body, set: set3 }) => {
   if (handoffsDisabled()) {
     set3.status = 423;
@@ -181708,6 +182070,121 @@ var handoffRoutes = new Elysia({ prefix: "/api/v1/handoff" }).post("/begin", asy
     summary: "List pending (open) handoffs",
     description: "Lists open handoffs for a project, optionally filtered by target agent, ordered oldest-first."
   }
+}).patch("/:id", async ({ params, query, body, set: set3 }) => {
+  if (handoffsDisabled()) {
+    set3.status = 423;
+    return { status: 423, error: "handoffs disabled" };
+  }
+  const raw2 = body ?? {};
+  const keys = Object.keys(raw2);
+  const rejected = keys.filter((k2) => !HANDOFF_PATCH_ALLOWED_FIELDS.includes(k2));
+  if (rejected.length > 0) {
+    set3.status = 400;
+    return { status: 400, error: `field not allowed: ${rejected.join(", ")}` };
+  }
+  const patch = {};
+  if ("targetAgent" in raw2) {
+    const v = raw2.targetAgent;
+    if (v !== null && typeof v !== "string") {
+      set3.status = 400;
+      return { status: 400, error: "targetAgent must be a string or null" };
+    }
+    patch.targetAgent = v;
+  }
+  if ("summary" in raw2) {
+    if (typeof raw2.summary !== "string") {
+      set3.status = 400;
+      return { status: 400, error: "summary must be a string" };
+    }
+    patch.summary = raw2.summary;
+  }
+  if ("openQuestions" in raw2) {
+    if (!isStringArray2(raw2.openQuestions)) {
+      set3.status = 400;
+      return { status: 400, error: "openQuestions must be an array of strings" };
+    }
+    patch.openQuestions = raw2.openQuestions;
+  }
+  if ("nextSteps" in raw2) {
+    if (!isStringArray2(raw2.nextSteps)) {
+      set3.status = 400;
+      return { status: 400, error: "nextSteps must be an array of strings" };
+    }
+    patch.nextSteps = raw2.nextSteps;
+  }
+  if ("files" in raw2) {
+    if (!isStringArray2(raw2.files)) {
+      set3.status = 400;
+      return { status: 400, error: "files must be an array of strings" };
+    }
+    patch.files = raw2.files;
+  }
+  if (Object.keys(patch).length === 0) {
+    set3.status = 400;
+    return { status: 400, error: "no editable field provided" };
+  }
+  try {
+    const result = await service3().update({
+      id: params.id,
+      projectId: query.projectId,
+      patch
+    });
+    if (!result.ok) {
+      set3.status = result.reason === "not-found" || result.reason === "project-mismatch" ? 404 : 400;
+      return { status: set3.status, error: result.reason };
+    }
+    set3.status = 200;
+    return { success: true, data: result.handoff };
+  } catch (e) {
+    rethrowCanonicalHandoffError(e);
+    const err = e;
+    logger.error("handoff update failed", err);
+    set3.status = 500;
+    return { success: false, error: `handoff update failed: ${err.message}` };
+  }
+}, {
+  params: t.Object({ id: t.String({ description: "Handoff id" }) }),
+  query: t.Object({
+    projectId: t.Optional(t.String({ description: "If supplied, must match the row's projectId or the request 404s" }))
+  }),
+  body: t.Record(t.String(), t.Unknown(), {
+    description: "Only targetAgent/summary/openQuestions/nextSteps/files are accepted; any other key is a 400 naming it."
+  }),
+  detail: {
+    ...EVENT_DETAIL3,
+    summary: "Edit a handoff (targetAgent/summary/openQuestions/nextSteps/files only)",
+    description: "Allowlist PATCH: status/acceptedAt/id/projectId/createdAt/sourceSessionId and any unknown key are rejected " + "by name with 400. Refreshes the dual-written memory's content when a content-feeding field changes."
+  }
+}).delete("/:id", async ({ params, query, set: set3 }) => {
+  if (handoffsDisabled()) {
+    set3.status = 423;
+    return { status: 423, error: "handoffs disabled" };
+  }
+  try {
+    const result = await service3().delete({ id: params.id, projectId: query.projectId });
+    if (!result.ok) {
+      set3.status = 404;
+      return { status: 404, error: result.reason };
+    }
+    set3.status = 200;
+    return { success: true, data: { id: result.id } };
+  } catch (e) {
+    rethrowCanonicalHandoffError(e);
+    const err = e;
+    logger.error("handoff delete failed", err);
+    set3.status = 500;
+    return { success: false, error: `handoff delete failed: ${err.message}` };
+  }
+}, {
+  params: t.Object({ id: t.String({ description: "Handoff id" }) }),
+  query: t.Object({
+    projectId: t.Optional(t.String({ description: "If supplied, must match the row's projectId or the request 404s" }))
+  }),
+  detail: {
+    ...EVENT_DETAIL3,
+    summary: "Hard-delete a handoff",
+    description: "Permitted in any status, including open. The dual-written memory row is left intact (dangling metadata.handoffId is accepted)."
+  }
 });
 
 // src/routes/proposals.ts
@@ -181718,6 +182195,12 @@ function job() {
     cachedJob2 = getAutoImproveJob();
   return cachedJob2;
 }
+var cachedStore4 = null;
+function store6() {
+  if (!cachedStore4)
+    cachedStore4 = getProposalStore();
+  return cachedStore4;
+}
 function autoImproveDisabled() {
   try {
     return config.get("memory")?.autoImprove?.enabled === false;
@@ -181728,6 +182211,16 @@ function autoImproveDisabled() {
 var EVENT_DETAIL4 = {
   tags: ["proposals"]
 };
+var PROPOSAL_PATCH_ALLOWED_FIELDS = ["rationale", "payload"];
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isProposalKind(value) {
+  return typeof value === "string" && PROPOSAL_KINDS.includes(value);
+}
+function proposalPayloadValidationStatus(error51) {
+  return error51 instanceof ProposalPayloadValidationError ? error51.statusCode : null;
+}
 var proposalRoutes = new Elysia({ prefix: "/api/v1/proposal" }).post("/list", async ({ body, set: set3 }) => {
   if (autoImproveDisabled()) {
     set3.status = 423;
@@ -181828,6 +182321,191 @@ var proposalRoutes = new Elysia({ prefix: "/api/v1/proposal" }).post("/list", as
     summary: "Reject a pending proposal",
     description: "Flips status pending\u2192rejected (no apply, no event). Same failure semantics as approve on missing/non-pending/project-mismatch."
   }
+}).post("/create", async ({ body, set: set3 }) => {
+  if (autoImproveDisabled()) {
+    set3.status = 423;
+    return { status: 423, error: "auto-improve disabled" };
+  }
+  const raw2 = body ?? {};
+  if (typeof raw2.projectId !== "string" || !raw2.projectId.trim()) {
+    set3.status = 400;
+    return { status: 400, error: "projectId required" };
+  }
+  if (!isProposalKind(raw2.kind)) {
+    set3.status = 400;
+    return { status: 400, error: `kind must be one of ${PROPOSAL_KINDS.join(", ")}` };
+  }
+  if (!isRecord2(raw2.payload)) {
+    set3.status = 400;
+    return { status: 400, error: "payload must be an object" };
+  }
+  if (raw2.rationale !== undefined && typeof raw2.rationale !== "string") {
+    set3.status = 400;
+    return { status: 400, error: "rationale must be a string" };
+  }
+  if (raw2.targetMemoryId !== undefined && raw2.targetMemoryId !== null && typeof raw2.targetMemoryId !== "string") {
+    set3.status = 400;
+    return { status: 400, error: "targetMemoryId must be a string or null" };
+  }
+  const projectId = raw2.projectId;
+  const kind = raw2.kind;
+  const payload = raw2.payload;
+  try {
+    const record2 = await store6().create({
+      id: newProposalId(),
+      projectId,
+      kind,
+      payload,
+      rationale: raw2.rationale,
+      targetMemoryId: raw2.targetMemoryId
+    });
+    set3.status = 200;
+    return { success: true, data: record2 };
+  } catch (e) {
+    if (e instanceof SearchServiceError)
+      throw e;
+    const validationStatus = proposalPayloadValidationStatus(e);
+    if (validationStatus !== null) {
+      set3.status = validationStatus;
+      return { status: validationStatus, error: e.message };
+    }
+    const err = e;
+    logger.error("proposal create failed", err);
+    set3.status = 500;
+    return { success: false, error: `proposal create failed: ${err.message}` };
+  }
+}, {
+  body: t.Record(t.String(), t.Unknown(), {
+    description: "projectId, kind (memory.create|memory.update|memory.tag), payload, rationale?, targetMemoryId?"
+  }),
+  detail: {
+    ...EVENT_DETAIL4,
+    summary: "Create a pending proposal",
+    description: "kind must be memory.create/memory.update/memory.tag; payload is validated against the same per-kind " + "rules the store enforces on read (AC-02.2), so a write the reader would reject is refused here instead."
+  }
+}).patch("/:id", async ({ params, query, body, set: set3 }) => {
+  if (autoImproveDisabled()) {
+    set3.status = 423;
+    return { status: 423, error: "auto-improve disabled" };
+  }
+  const raw2 = body ?? {};
+  const keys = Object.keys(raw2);
+  const rejected = keys.filter((k2) => !PROPOSAL_PATCH_ALLOWED_FIELDS.includes(k2));
+  if (rejected.length > 0) {
+    set3.status = 400;
+    return { status: 400, error: `field not allowed: ${rejected.join(", ")}` };
+  }
+  const patch = {};
+  if ("rationale" in raw2) {
+    if (typeof raw2.rationale !== "string") {
+      set3.status = 400;
+      return { status: 400, error: "rationale must be a string" };
+    }
+    patch.rationale = raw2.rationale;
+  }
+  if ("payload" in raw2) {
+    if (!isRecord2(raw2.payload)) {
+      set3.status = 400;
+      return { status: 400, error: "payload must be an object" };
+    }
+    patch.payload = raw2.payload;
+  }
+  if (Object.keys(patch).length === 0) {
+    set3.status = 400;
+    return { status: 400, error: "no editable field provided" };
+  }
+  try {
+    const current = await store6().getById(params.id);
+    if (!current) {
+      set3.status = 404;
+      return { status: 404, error: "not-found" };
+    }
+    if (query.projectId && current.projectId !== query.projectId) {
+      set3.status = 404;
+      return { status: 404, error: "project-mismatch" };
+    }
+    const updated = await store6().update(params.id, {
+      ...patch.rationale !== undefined ? { rationale: patch.rationale } : {},
+      ...patch.payload !== undefined ? { payload: patch.payload } : {}
+    });
+    if (!updated) {
+      set3.status = 404;
+      return { status: 404, error: "not-found" };
+    }
+    set3.status = 200;
+    return { success: true, data: updated };
+  } catch (e) {
+    if (e instanceof SearchServiceError)
+      throw e;
+    const validationStatus = proposalPayloadValidationStatus(e);
+    if (validationStatus !== null) {
+      set3.status = validationStatus;
+      return { status: validationStatus, error: e.message };
+    }
+    const err = e;
+    logger.error("proposal update failed", err);
+    set3.status = 500;
+    return { success: false, error: `proposal update failed: ${err.message}` };
+  }
+}, {
+  params: t.Object({ id: t.String({ description: "Proposal id" }) }),
+  query: t.Object({
+    projectId: t.Optional(t.String({ description: "If supplied, must match the row's projectId or the request 404s" }))
+  }),
+  body: t.Record(t.String(), t.Unknown(), {
+    description: "Only rationale/payload are accepted; any other key is a 400 naming it."
+  }),
+  detail: {
+    ...EVENT_DETAIL4,
+    summary: "Edit a proposal (rationale/payload only)",
+    description: "Allowlist PATCH: kind/targetMemoryId/status/decidedAt/id/projectId/createdAt and any unknown key are " + "rejected by name with 400. A payload edit re-validates against the row's existing kind (AC-02.3/AC-02.4)."
+  }
+}).delete("/:id", async ({ params, query, set: set3 }) => {
+  if (autoImproveDisabled()) {
+    set3.status = 423;
+    return { status: 423, error: "auto-improve disabled" };
+  }
+  try {
+    const current = await store6().getById(params.id);
+    if (!current) {
+      set3.status = 404;
+      return { status: 404, error: "not-found" };
+    }
+    if (query.projectId && current.projectId !== query.projectId) {
+      set3.status = 404;
+      return { status: 404, error: "project-mismatch" };
+    }
+    const deletedId = await store6().delete(params.id);
+    if (!deletedId) {
+      set3.status = 404;
+      return { status: 404, error: "not-found" };
+    }
+    set3.status = 200;
+    return {
+      success: true,
+      data: {
+        id: deletedId,
+        ...current.status === "approved" ? { note: "approved proposal's applied memory edit was not reversed" } : {}
+      }
+    };
+  } catch (e) {
+    if (e instanceof SearchServiceError)
+      throw e;
+    const err = e;
+    logger.error("proposal delete failed", err);
+    set3.status = 500;
+    return { success: false, error: `proposal delete failed: ${err.message}` };
+  }
+}, {
+  params: t.Object({ id: t.String({ description: "Proposal id" }) }),
+  query: t.Object({
+    projectId: t.Optional(t.String({ description: "If supplied, must match the row's projectId or the request 404s" }))
+  }),
+  detail: {
+    ...EVENT_DETAIL4,
+    summary: "Hard-delete a proposal",
+    description: "Permitted in any status. Deleting an already-approved proposal does not reverse the memory edit it " + "already applied (AC-02.5) \u2014 the response says so explicitly via a `note` field."
+  }
 });
 
 // src/routes/executor.ts
@@ -182710,6 +183388,7 @@ var configRoutes = new Elysia({ prefix: "/api/v1/config" }).get("/", ({ set: set
 // src/routes/model-registry-stream.ts
 init_config();
 init_dist();
+import fs28 from "fs";
 import path42 from "path";
 import { spawn as spawn3 } from "child_process";
 var encoder3 = new TextEncoder;
@@ -182718,6 +183397,58 @@ function sseFrame(data) {
 
 `);
 }
+var KNOWN_GENERATOR_FILENAMES = ["generate-skill-artifacts.ts", "generate-subagent-artifacts.ts"];
+function deriveGeneratorScripts(root2) {
+  const pkgPath = path42.join(root2, "package.json");
+  let raw2;
+  try {
+    raw2 = fs28.readFileSync(pkgPath, "utf-8");
+  } catch (e) {
+    throw new Error(`cannot read ${pkgPath}: ${e.message}`);
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw2);
+  } catch (e) {
+    throw new Error(`${pkgPath} is not valid JSON: ${e.message}`);
+  }
+  const scriptsField = pkg?.scripts;
+  const command = scriptsField?.["generate:artifacts"];
+  if (typeof command !== "string" || command.trim().length === 0) {
+    throw new Error(`${pkgPath}'s scripts."generate:artifacts" is missing or not a string`);
+  }
+  const segments = command.split("&&").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`"generate:artifacts" parsed to zero commands: ${JSON.stringify(command)}`);
+  }
+  return segments.map((segment) => {
+    const match2 = /^bun\s+(\S+\.ts)$/.exec(segment);
+    if (!match2) {
+      throw new Error(`"generate:artifacts" segment does not match the expected "bun <script.ts>" shape: ${JSON.stringify(segment)}`);
+    }
+    const relPath = match2[1];
+    return { relPath, name: path42.basename(relPath) };
+  });
+}
+function assertGeneratorBackstop(scripts) {
+  const names = scripts.map((s) => s.name);
+  const missing = KNOWN_GENERATOR_FILENAMES.filter((f) => !names.includes(f));
+  if (scripts.length < 2 || missing.length > 0) {
+    throw new Error(`generator list ${JSON.stringify(names)} does not contain the known generators ` + `${KNOWN_GENERATOR_FILENAMES.join(", ")} \u2014 refusing to spawn an implausibly short list`);
+  }
+}
+function emitSkillsFrames(controller2, closedRef) {
+  for (const host of HOSTS) {
+    if (closedRef.closed)
+      return;
+    try {
+      controller2.enqueue(sseFrame({ type: "skills", host, status: "generated" }));
+    } catch {
+      closedRef.closed = true;
+      return;
+    }
+  }
+}
 function deriveInstallStatus(report) {
   if (report.hosts.some((h) => h.status === "switched"))
     return "switched";
@@ -182792,17 +183523,15 @@ function createRegenerateStreamHandler() {
           closedRef.closed = true;
           return;
         }
-        const generateScript = path42.join(root2, "scripts", "generate-subagent-artifacts.ts");
+        let generatorScripts;
         try {
-          child = spawn3("bun", [generateScript], {
-            env: { ...process.env },
-            stdio: ["pipe", "pipe", "pipe"]
-          });
+          generatorScripts = deriveGeneratorScripts(root2);
+          assertGeneratorBackstop(generatorScripts);
         } catch (e) {
           controller2.enqueue(sseFrame({
             type: "done",
             exitCode: null,
-            error: `spawn failed: ${e.message}`
+            error: `could not derive the generator list: ${e.message}`
           }));
           controller2.close();
           closedRef.closed = true;
@@ -182825,35 +183554,57 @@ function createRegenerateStreamHandler() {
             }
           }
         };
-        child.stdout?.on("data", (chunk) => emitLine("stdout", chunk));
-        child.stderr?.on("data", (chunk) => emitLine("stderr", chunk));
-        child.on("error", (e) => {
+        const finish = (exitCode, error51) => {
           if (closedRef.closed)
             return;
           closedRef.closed = true;
           try {
-            controller2.enqueue(sseFrame({ type: "done", exitCode: null, error: `spawn error: ${e.message}` }));
+            controller2.enqueue(sseFrame(error51 !== undefined ? { type: "done", exitCode, error: error51 } : { type: "done", exitCode }));
             controller2.close();
           } catch {}
-        });
-        child.on("close", (code) => {
+        };
+        const runGenerator = (index) => {
           if (closedRef.closed)
             return;
-          if (code === 0) {
+          if (index >= generatorScripts.length) {
             try {
               controller2.enqueue(sseFrame({ type: "line", stream: "stdout", text: "Installing regenerated agents to active directories..." }));
             } catch {
               closedRef.closed = true;
               return;
             }
+            emitSkillsFrames(controller2, closedRef);
             installActiveProfiles(controller2, closedRef);
+            finish(0);
+            return;
           }
-          closedRef.closed = true;
+          const generator = generatorScripts[index];
+          const scriptPath = path42.join(root2, generator.relPath);
           try {
-            controller2.enqueue(sseFrame({ type: "done", exitCode: code }));
-            controller2.close();
-          } catch {}
-        });
+            child = spawn3("bun", [scriptPath], {
+              env: { ...process.env },
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+          } catch (e) {
+            finish(null, `spawn failed (${generator.name}): ${e.message}`);
+            return;
+          }
+          child.stdout?.on("data", (chunk) => emitLine("stdout", chunk));
+          child.stderr?.on("data", (chunk) => emitLine("stderr", chunk));
+          child.on("error", (e) => {
+            finish(null, `spawn error (${generator.name}): ${e.message}`);
+          });
+          child.on("close", (code) => {
+            if (closedRef.closed)
+              return;
+            if (code !== 0) {
+              finish(code, `${generator.name} failed with exit code ${code}`);
+              return;
+            }
+            runGenerator(index + 1);
+          });
+        };
+        runGenerator(0);
       },
       cancel() {
         closedRef.closed = true;
@@ -182875,8 +183626,8 @@ function createRegenerateStreamHandler() {
 var modelRegistryStreamRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).post("/regenerate-and-install-stream", createRegenerateStreamHandler(), {
   detail: {
     tags: ["model-registry"],
-    summary: "Regenerate subagent artifacts + auto-install to active dirs (streaming SSE)",
-    description: "Spawns `bun scripts/generate-subagent-artifacts.ts` with child_process.spawn (non-blocking). Pipes stdout/stderr line-by-line as SSE. After the generator succeeds (exit 0), bridges the freshly generated agent-profiles trees into each host's installed variant root (`variant-sync` events per host), then calls switchProfile for every detected host to reinstall the active profile's agents from those synced variant dirs. Emits `install` events per host, then a terminal `done` event with the exit code."
+    summary: "Regenerate skill + subagent artifacts, then auto-install to active dirs (streaming SSE)",
+    description: "Spawns every generator named by package.json's `generate:artifacts` script (today `generate-skill-artifacts.ts` then `generate-subagent-artifacts.ts`), one at a time in that order, with child_process.spawn (non-blocking). Pipes stdout/stderr line-by-line as SSE; the first generator to exit non-zero stops the chain and names itself in the terminal `done` frame. Once every generator exits 0, emits one `skills` event per host, bridges the freshly generated agent-profiles trees into each host's installed variant root (`variant-sync` events per host), then calls switchProfile for every detected host to reinstall the active profile's agents from those synced variant dirs. Emits `install` events per host, then a terminal `done` event with the exit code."
   }
 }).post("/regenerate-stream", createRegenerateStreamHandler(), {
   detail: {
@@ -182986,7 +183737,7 @@ var restartRoutes = new Elysia({ prefix: "/api/v1/system" }).onAfterResponse(()
 
 // src/routes/logs.ts
 init_dist();
-import fs28 from "fs";
+import fs29 from "fs";
 var LOGS_DETAIL = { tags: ["logs"] };
 var MAX_SCAN_BYTES = 64 * 1024 * 1024;
 var MAX_LIMIT = 1000;
@@ -183066,7 +183817,7 @@ function parseLine(line, prevTs) {
 function realReadTail(filePath, maxBytes) {
   let size;
   try {
-    size = fs28.statSync(filePath).size;
+    size = fs29.statSync(filePath).size;
   } catch {
     return { content: "", truncated: false };
   }
@@ -183074,24 +183825,24 @@ function realReadTail(filePath, maxBytes) {
     return { content: "", truncated: false };
   if (size <= maxBytes) {
     try {
-      return { content: fs28.readFileSync(filePath, "utf8"), truncated: false };
+      return { content: fs29.readFileSync(filePath, "utf8"), truncated: false };
     } catch {
       return { content: "", truncated: false };
     }
   }
   try {
-    const fd = fs28.openSync(filePath, "r");
+    const fd = fs29.openSync(filePath, "r");
     try {
       const start = size - maxBytes;
       const buf = Buffer.alloc(maxBytes);
-      fs28.readSync(fd, buf, 0, maxBytes, start);
+      fs29.readSync(fd, buf, 0, maxBytes, start);
       let text3 = buf.toString("utf8");
       const firstNewline = text3.indexOf(`
 `);
       text3 = firstNewline !== -1 ? text3.slice(firstNewline + 1) : "";
       return { content: text3, truncated: true };
     } finally {
-      fs28.closeSync(fd);
+      fs29.closeSync(fd);
     }
   } catch {
     return { content: "", truncated: true };
@@ -183101,7 +183852,7 @@ var realReader = {
   listFiles(filePath, maxFiles) {
     return sinkFiles(filePath, maxFiles).filter((f) => {
       try {
-        fs28.accessSync(f, fs28.constants.R_OK);
+        fs29.accessSync(f, fs29.constants.R_OK);
         return true;
       } catch {
         return false;
@@ -183177,8 +183928,6 @@ function renderTxtLine(entry2) {
   const metaStr = entry2.meta ? ` ${JSON.stringify(entry2.meta)}` : "";
   return `[${entry2.ts}] [${entry2.level.toUpperCase()}] ${entry2.message}${metaStr}`;
 }
-var SSE_HEARTBEAT_MS_DEFAULT = 15000;
-var SSE_MAX_DURATION_MS_DEFAULT = 10 * 60 * 1000;
 var SINK_POLL_MS_DEFAULT = 1000;
 var SINK_POLL_MAX_BYTES = 1024 * 1024;
 function startSinkTail(enqueue) {
@@ -183192,7 +183941,7 @@ function startSinkTail(enqueue) {
   let currentFile = initial[0];
   let offset;
   try {
-    offset = fs28.statSync(currentFile).size;
+    offset = fs29.statSync(currentFile).size;
   } catch {
     return;
   }
@@ -183208,7 +183957,7 @@ function startSinkTail(enqueue) {
         offset = 0;
         carry = "";
       }
-      const size = fs28.statSync(currentFile).size;
+      const size = fs29.statSync(currentFile).size;
       if (size < offset) {
         offset = 0;
         carry = "";
@@ -183217,11 +183966,11 @@ function startSinkTail(enqueue) {
         return;
       const length = Math.min(size - offset, SINK_POLL_MAX_BYTES);
       const buf = Buffer.alloc(length);
-      const fd = fs28.openSync(currentFile, "r");
+      const fd = fs29.openSync(currentFile, "r");
       try {
-        fs28.readSync(fd, buf, 0, length, offset);
+        fs29.readSync(fd, buf, 0, length, offset);
       } finally {
-        fs28.closeSync(fd);
+        fs29.closeSync(fd);
       }
       offset += length;
       const text3 = carry + buf.toString("utf8");
@@ -183284,9 +184033,9 @@ var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set:
     summary: "Download the queried log range as jsonl or txt",
     description: "Same query surface as GET /api/v1/logs (minus limit/offset \u2014 the full matching range is returned) plus format=jsonl|txt. Responds with Content-Disposition: attachment and a filename carrying the range. A range matching zero entries still returns an empty (200) download."
   }
-}).get("/stream", () => {
-  const HEARTBEAT_MS = Number(process.env.MASSA_AI_SSE_HEARTBEAT_MS) || SSE_HEARTBEAT_MS_DEFAULT;
-  const MAX_DURATION_MS = Number(process.env.MASSA_AI_SSE_MAX_DURATION_MS) || SSE_MAX_DURATION_MS_DEFAULT;
+}).get("/stream", ({ request }) => {
+  const HEARTBEAT_MS = resolveHeartbeatMs();
+  const MAX_DURATION_MS = resolveMaxDurationMs();
   const encoder4 = new TextEncoder;
   let closed = false;
   let unsubscribe;
@@ -183294,6 +184043,18 @@ var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set:
   let closeTimer;
   const stream2 = new ReadableStream({
     start(controller2) {
+      applySseRequestTimeout(request);
+      const teardown = () => {
+        closed = true;
+        unsubscribe?.();
+        if (heartbeatTimer)
+          clearInterval(heartbeatTimer);
+        if (closeTimer)
+          clearTimeout(closeTimer);
+        try {
+          controller2.close();
+        } catch {}
+      };
       const enqueue = (data) => {
         if (closed)
           return;
@@ -183302,7 +184063,7 @@ var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set:
 
 `));
         } catch {
-          closed = true;
+          teardown();
         }
       };
       const tail = startSinkTail(enqueue);
@@ -183323,18 +184084,10 @@ var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set:
 
 `));
         } catch {
-          closed = true;
-          clearInterval(heartbeatTimer);
+          teardown();
         }
       }, HEARTBEAT_MS);
-      closeTimer = setTimeout(() => {
-        closed = true;
-        unsubscribe?.();
-        clearInterval(heartbeatTimer);
-        try {
-          controller2.close();
-        } catch {}
-      }, MAX_DURATION_MS);
+      closeTimer = setTimeout(teardown, MAX_DURATION_MS);
     },
     cancel() {
       closed = true;
@@ -183361,6 +184114,104 @@ var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set:
   }
 });
 
+// src/middleware/write-mode-classification.ts
+var READ_ONLY_ROUTES = [
+  {
+    method: "POST",
+    path: "/api/v1/search/project",
+    justification: "WRITES when autoReindex+projectPath are both set. " + "apps/tools-api/src/routes/search.ts:48-106 passes the raw request body to " + "SearchProjectTool.handle(), which forwards it unchanged to " + "SearchController.searchProject " + "(packages/core/src/services/search/search-controller.ts:132-179): autoReindex " + "defaults to false at :140, and at :177-179 `if (autoReindex && projectPath) " + "this.handleAutoReindex(projectId, projectPath)` calls the private helper at " + ":364-389, which calls `this.contextualSearch.ensureFreshIndex(...)` \u2014 a real " + "index write. Kept on the allowlist with a sanitizer (AC-03.3a) instead of being " + "dropped, so read-only mode does not 403 project search entirely.",
+    sanitizeBody: (body) => {
+      body.autoReindex = false;
+    }
+  },
+  {
+    method: "POST",
+    path: "/api/v1/search/code",
+    justification: "Clean. apps/tools-api/src/routes/search.ts:108-126's request schema exposes only " + "{query, projectId, limit} \u2014 no `autoReindex` field exists on this route to flip. " + "packages/core/src/tools/search_code.ts:56-62 delegates to SearchProjectTool.handle " + "with `autoReindex: false` hardcoded at line 61 regardless of caller input, so the " + "write path proven above for /search/project is structurally unreachable from here."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/memory/search",
+    justification: "Clean. apps/tools-api/src/routes/memory.ts:126-138 (`POST /search`) delegates the " + "raw body to SearchMemoriesTool.handle(), which " + "(packages/core/src/tools/search_memories.ts:93-121) only calls " + "`MemoryController.search(...)` and formats the result for the response \u2014 no " + "repository mutation on any code path this handler can reach."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/memory/list",
+    justification: "Clean. apps/tools-api/src/routes/memory.ts:243-268 calls only " + "`getMemoryRepository().search(...)`, then filters/paginates the result in the " + "route handler itself \u2014 no repository write method is reachable from this handler."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/checkpoints/list",
+    justification: "Clean. apps/tools-api/src/routes/checkpoints.ts:56-68 delegates to " + "ListCheckpointsTool.handle(), which " + "(packages/core/src/tools/list_checkpoints.ts:90-99) calls only " + "`checkpointManager.listCheckpoints(...)` and `checkpointManager.getStats()` \u2014 both " + "reads over existing state, never a checkpoint create/delete/restore call."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/handoff/list",
+    justification: "Clean. apps/tools-api/src/routes/handoff.ts:174-213 calls only " + "`service().listPending(...)`, which " + "(packages/core/src/services/handoff/handoff-service.ts:228-229) is a direct " + "pass-through to `this.store.listPending(...)` \u2014 never `begin` (:115), `accept` " + "(:173) or `cancel` (:182), the service's three write entry points."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/proposal/list",
+    justification: "Clean. apps/tools-api/src/routes/proposals.ts:36-73 calls only " + "`job().listPending(...)`, which " + "(packages/core/src/services/jobs/auto-improve-job.ts:113) is a direct pass-through " + "to `this.proposalStore.listPending(...)` \u2014 never `approve` (:111) or `reject` " + "(:112), the job's two write entry points."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/context/compress",
+    justification: "Clean. apps/tools-api/src/routes/context.ts:29-68 delegates to " + "CompressContextTool.handle(), which " + "(packages/core/src/tools/compress_context.ts:67-118) runs `compressWithMetrics` " + "over the request's own `content` string in memory and returns the result \u2014 no " + "repository, index, or filesystem write on any code path."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/context/optimized",
+    justification: "Clean. apps/tools-api/src/routes/context.ts:70-101 delegates to " + "GetOptimizedContextTool.handle(), which " + "(packages/core/src/tools/get_optimized_context.ts:105-110) calls " + "`ContextController.getOptimizedContext(p)`. That controller " + "(packages/core/src/services/context/context-controller.ts:161) hardcodes " + "`autoReindex: false` on its own internal search call, so the write path proven " + "for /search/project is structurally unreachable here even though this route's " + "schema also carries `projectPath`."
+  },
+  {
+    method: "POST",
+    path: "/api/v1/symbol/impact",
+    justification: "Clean. apps/tools-api/src/routes/workspace.ts:542-673 calls " + "`getGraphController().analyzeImpact(...)`, which " + "(packages/core/src/services/symbol/graph-controller.ts:189-232) delegates to " + "`impactAnalysisService.analyze(...)` " + "(packages/core/src/services/symbol/impact-analysis.ts). Every git invocation there " + "runs through `execFileSync` for `rev-parse`/`diff`/`status`-class read commands, " + "plus one `hash-object -t tree --stdin` with no `-w` flag (so nothing is written to " + "the git object database) \u2014 no `git commit`, `git add`, or `-w` flag anywhere in " + "the module."
+  }
+];
+function normalizeRoutePath(path43) {
+  return path43.length > 1 && path43.endsWith("/") ? path43.slice(0, -1) : path43;
+}
+var READ_ONLY_INDEX = new Map(READ_ONLY_ROUTES.map((entry2) => [`${entry2.method} ${entry2.path}`, entry2]));
+function findReadOnlyRoute(method, path43) {
+  return READ_ONLY_INDEX.get(`${method.toUpperCase()} ${normalizeRoutePath(path43)}`);
+}
+
+// src/middleware/write-mode.ts
+function defaultReadOnlyModeAccessor() {
+  return process.env.MASSA_AI_READ_ONLY_MODE === "true";
+}
+var readOnlyModeAccessor = defaultReadOnlyModeAccessor;
+function isReadOnlyModeActive() {
+  try {
+    return readOnlyModeAccessor();
+  } catch {
+    return true;
+  }
+}
+var WRITE_REFUSED = {
+  success: false,
+  error: "Write refused: read-only mode is active"
+};
+var writeModeMiddleware = new Elysia({ name: "write-mode" }).onBeforeHandle({ as: "global" }, ({ request, path: path43, set: set3, body }) => {
+  if (request.method.toUpperCase() === "GET")
+    return;
+  if (isPublicPath(path43))
+    return;
+  if (!isReadOnlyModeActive())
+    return;
+  const entry2 = findReadOnlyRoute(request.method, path43);
+  if (entry2) {
+    if (entry2.sanitizeBody && body && typeof body === "object") {
+      entry2.sanitizeBody(body);
+    }
+    return;
+  }
+  set3.status = 403;
+  return { ...WRITE_REFUSED };
+});
+
 // src/middleware/error.ts
 init_dist();
 var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3, path: path43, request }) => {
@@ -183484,7 +184335,7 @@ var app = new Elysia({ adapter: node() }).use(cors(buildCorsOptions(config.get("
     },
     security: [{ ApiKeyAuth: [] }]
   }
-})).use(errorHandler).use(authMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).use(profileRoutes).use(configRoutes).use(modelRegistryRoutes).use(modelRegistryStreamRoutes).use(restartRoutes).use(logsRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
+})).use(errorHandler).use(authMiddleware).use(writeModeMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).use(profileRoutes).use(configRoutes).use(modelRegistryRoutes).use(modelRegistryStreamRoutes).use(restartRoutes).use(logsRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
 initAuthOrExit();
 warnIfTrustOverrideEnabled();
 await listenAfterParserValidation({
@@ -183493,6 +184344,8 @@ await listenAfterParserValidation({
     try {
       app.listen({ port: Number(PORT), reusePort: false }, (server) => {
         setServerStopper(() => void server.stop());
+        const bunServer = server.bun?.server;
+        setSseRequestTimeoutSource(bunServer);
       });
     } catch (error51) {
       if (error51?.code === "EADDRINUSE") {