@appsforgood/next-supabase-kit 0.1.7 → 0.2.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { existsSync as existsSync23, readFileSync as readFileSync24, writeFileSync as writeFileSync2 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync3, readFileSync as readFileSync26, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join30, relative as relative2, resolve as resolve3 } from "path";
 import { Command } from "commander";
 
 // src/install/add-skill.ts
@@ -10,8 +10,8 @@ import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join3 } from "path";
 
 // src/utils/fs.ts
-import { createHash } from "crypto";
-import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
 function ensureDir(path) {
   mkdirSync(path, { recursive: true });
@@ -22,7 +22,13 @@ function readTextIfExists(path) {
 }
 function writeText(path, content) {
   ensureDir(dirname(path));
-  writeFileSync(path, content);
+  const temporaryPath = join(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temporaryPath, content);
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync(temporaryPath, { force: true });
+  }
 }
 function sha256(content) {
   return createHash("sha256").update(content).digest("hex");
@@ -60,6 +66,36 @@ function listFilesRecursive(root) {
   visit(root);
   return out.sort();
 }
+function writeConflictProposal(targetRoot, targetRelativePath, proposedContent, options = {}) {
+  const proposalHash = sha256(proposedContent);
+  const safeTarget = targetRelativePath.replace(/[^a-zA-Z0-9_.-]/g, "__");
+  const baseName = `${safeTarget}.${proposalHash.slice(0, 12)}`;
+  const conflictRoot = join(targetRoot, ".agent-kit", "conflicts");
+  const proposalPath = join(conflictRoot, `${baseName}.proposed`);
+  const metadataPath = join(conflictRoot, `${baseName}.json`);
+  const normalizedTarget = targetRelativePath.replace(/\\/g, "/");
+  writeText(proposalPath, proposedContent);
+  writeText(
+    metadataPath,
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        target: normalizedTarget,
+        proposedSha256: proposalHash,
+        ...options.currentContent !== void 0 ? { currentSha256: sha256(options.currentContent) } : {},
+        ...options.reason ? { reason: options.reason } : {},
+        ...options.sourceVersion ? { sourceVersion: options.sourceVersion } : {}
+      },
+      null,
+      2
+    )}
+`
+  );
+  return {
+    conflictPath: relative(targetRoot, proposalPath).replace(/\\/g, "/"),
+    metadataPath: relative(targetRoot, metadataPath).replace(/\\/g, "/")
+  };
+}
 function copyTextWithConflict(sourcePath, targetRoot, targetRelativePath, options = {}) {
   const targetPath = resolveInside(targetRoot, targetRelativePath);
   const sourceContent = readFileSync(sourcePath, "utf8");
@@ -75,24 +111,20 @@ function copyTextWithConflict(sourcePath, targetRoot, targetRelativePath, option
     writeText(targetPath, sourceContent);
     return { action: "overwritten", target: targetRelativePath };
   }
-  const conflictRoot = options.conflictRoot ?? join(targetRoot, ".agent-kit", "conflicts");
-  const safeName = `${Date.now()}-${targetRelativePath.replace(/[^a-zA-Z0-9_.-]/g, "_")}`;
-  const conflictPath = join(conflictRoot, safeName);
-  writeText(conflictPath, sourceContent);
+  const defaultConflictRoot = join(targetRoot, ".agent-kit", "conflicts");
+  if (options.conflictRoot && resolve(options.conflictRoot) !== resolve(defaultConflictRoot)) {
+    throw new Error("Custom conflict roots are no longer supported; proposals must stay under .agent-kit/conflicts.");
+  }
+  const proposal = writeConflictProposal(targetRoot, targetRelativePath, sourceContent, {
+    currentContent: existingContent,
+    reason: "Local content differs from the proposed package content."
+  });
   return {
     action: "conflict",
     target: targetRelativePath,
-    conflictPath: relative(targetRoot, conflictPath)
+    conflictPath: proposal.conflictPath
   };
 }
-function copyDirectory(sourceRoot, targetRoot) {
-  ensureDir(dirname(targetRoot));
-  cpSync(sourceRoot, targetRoot, {
-    recursive: true,
-    force: true,
-    filter: (source) => !basename(source).startsWith(".DS_Store")
-  });
-}
 
 // src/utils/package-root.ts
 import { existsSync as existsSync2 } from "fs";
@@ -145,12 +177,12 @@ function addSkill(cwd, skillName, options = {}) {
 }
 
 // src/install/adapter-validate.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { join as join12, normalize } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
+import { join as join14, normalize } from "path";
 
 // src/config/defaults.ts
 var PACKAGE_NAME = "@appsforgood/next-supabase-kit";
-var PACKAGE_VERSION = "0.1.7";
+var PACKAGE_VERSION = "0.2.0";
 var DEFAULT_CONFIG = {
   stack: "next-supabase",
   projectType: "saas",
@@ -210,6 +242,10 @@ var DEFAULT_AGENT_ROSTER_SOURCE = "rosters/next-supabase-default-council.json";
 var DEFAULT_AGENT_ROSTER_TARGET = ".agent-kit/agent-roster.json";
 var DEFAULT_MODEL_ROUTING_SOURCE = "model-routing/default-model-routing.json";
 var DEFAULT_MODEL_ROUTING_TARGET = ".agent-kit/model-routing.json";
+var DEFAULT_ORCHESTRATOR_SOURCE = "templates/next-supabase/.agent-kit/orchestrator.json";
+var DEFAULT_ORCHESTRATOR_TARGET = ".agent-kit/orchestrator.json";
+var DEFAULT_RUNTIME_IGNORE_SOURCE = "templates/next-supabase/.agent-kit/runtime/gitignore.template";
+var DEFAULT_RUNTIME_IGNORE_TARGET = ".agent-kit/runtime/.gitignore";
 var CURSOR_ADAPTER_FILES = [
   {
     source: "assistant-adapters/cursor-agent-kit.mdc",
@@ -268,7 +304,7 @@ var CI_TEMPLATE_FILES = [
 ];
 
 // src/studio/shared.ts
-import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { appendFileSync, closeSync, existsSync as existsSync4, openSync, readFileSync as readFileSync3, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { basename as basename2, dirname as dirname3, join as join4 } from "path";
 var AGENT_KIT_DIR = ".agent-kit";
 var CONTEXT_JSON = ".agent-kit/project-context.json";
@@ -284,8 +320,15 @@ var SECRET_PATTERNS = [
   /gh[pousr]_[A-Za-z0-9_]{12,}/g,
   /github_pat_[A-Za-z0-9_]{20,}/g,
   /sk_(?:live|test)_[A-Za-z0-9_]{8,}/g,
+  /sk-(?:proj-|svcacct-|ant-api\d{2}-)?[A-Za-z0-9_-]{20,}/g,
+  /xai-[A-Za-z0-9_-]{20,}/g,
+  /AIza[0-9A-Za-z_-]{30,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /(?:xox[baprs]-)[A-Za-z0-9-]{10,}/g,
+  /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
+  /\bBearer\s+[A-Za-z0-9._~+/-]{20,}=*/gi,
   /sbp_[A-Za-z0-9_]{12,}/g,
-  /(?:SUPABASE_SERVICE_ROLE_KEY|DATABASE_URL|OPENAI_API_KEY|ANTHROPIC_API_KEY|GITHUB_TOKEN)=(?!\\n|\\r|\\r\\n)["']?[A-Za-z0-9][A-Za-z0-9_./+:-]+/gi,
+  /\b(?:[A-Z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD|PRIVATE_KEY)|DATABASE_URL)\s*=\s*(?!\\n|\\r|\\r\\n)["']?(?!(?:process\.env|import\.meta\.env|env:|keychain:|\$\{|<|replace|example|your|dummy|fake))[^\\\s"'`]{8,}/g,
   /postgres(?:ql)?:\/\/[^\s)]+/gi
 ];
 function nowIso() {
@@ -300,6 +343,20 @@ function containsLikelySecret(text) {
     return pattern.test(text);
   });
 }
+function assertNoLikelySecret(value, label = "Persisted value") {
+  const serialized = typeof value === "string" ? value : JSON.stringify(value);
+  if (containsLikelySecret(serialized)) {
+    throw new Error(`${label} appears to contain a secret. Store credentials in an environment variable or OS keychain reference instead.`);
+  }
+}
+function redactValue(value) {
+  if (typeof value === "string") return redactSensitive(value);
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item)]));
+  }
+  return value;
+}
 function safeSlug(input) {
   const lowered = input.trim().toLowerCase();
   if (!lowered) throw new Error("A non-empty title or id is required.");
@@ -322,23 +379,73 @@ function readJsonFile(cwd, relativePath) {
   return JSON.parse(readFileSync3(path, "utf8"));
 }
 function writeJsonFile(cwd, relativePath, value) {
+  assertNoLikelySecret(value, relativePath);
   writeText(resolveInside(cwd, relativePath), `${JSON.stringify(value, null, 2)}
 `);
 }
 function appendJsonLine(cwd, relativePath, value) {
   const path = resolveInside(cwd, relativePath);
   ensureDir(dirname3(path));
-  appendFileSync(path, `${JSON.stringify(value)}
+  appendFileSync(path, `${JSON.stringify(redactValue(value))}
 `);
 }
 function readJsonLines(cwd, relativePath) {
   const text = readTextIfExists(resolveInside(cwd, relativePath));
   if (!text) return [];
-  return text.split(/\r?\n/).filter((line2) => line2.trim().length > 0).map((line2) => JSON.parse(line2));
+  const lines = text.split(/\r?\n/);
+  let lastContentIndex = -1;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (lines[index]?.trim()) {
+      lastContentIndex = index;
+      break;
+    }
+  }
+  return lines.flatMap((line2, index) => {
+    if (!line2.trim()) return [];
+    try {
+      return [JSON.parse(line2)];
+    } catch (error) {
+      if (index === lastContentIndex && !text.endsWith("\n") && !text.endsWith("\r")) return [];
+      throw error;
+    }
+  });
 }
 function writeTextFile(cwd, relativePath, content) {
+  assertNoLikelySecret(content, relativePath);
   writeText(resolveInside(cwd, relativePath), content);
 }
+var LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
+function withFileLock(cwd, relativeLockPath, operation) {
+  const lockPath = resolveInside(cwd, relativeLockPath);
+  ensureDir(dirname3(lockPath));
+  const deadline = Date.now() + 5e3;
+  let descriptor;
+  while (descriptor === void 0) {
+    try {
+      descriptor = openSync(lockPath, "wx", 384);
+      writeFileSync2(descriptor, `${process.pid} ${Date.now()}
+`);
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? error.code : void 0;
+      if (code !== "EEXIST") throw error;
+      try {
+        if (Date.now() - statSync(lockPath).mtimeMs > 3e4) unlinkSync(lockPath);
+      } catch {
+      }
+      if (Date.now() >= deadline) throw new Error(`Timed out waiting for local file lock: ${relativeLockPath}`);
+      Atomics.wait(LOCK_SLEEP, 0, 0, 15);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    closeSync(descriptor);
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
 function readTextFile(cwd, relativePath) {
   return readTextIfExists(resolveInside(cwd, relativePath));
 }
@@ -362,10 +469,38 @@ function listMarkdown(items) {
 function unique(values) {
   return [...new Set(values.filter(Boolean))].sort();
 }
+function readJsonBody(request) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    let bodyTooLarge = false;
+    request.on("data", (chunk) => {
+      if (bodyTooLarge) return;
+      chunks.push(chunk);
+      if (chunks.reduce((total, item) => total + item.length, 0) > 256e3) {
+        bodyTooLarge = true;
+        reject(new Error("Request body too large."));
+      }
+    });
+    request.on("end", () => {
+      if (bodyTooLarge) return;
+      const raw = Buffer.concat(chunks).toString("utf8").trim();
+      if (!raw) {
+        resolve4({});
+        return;
+      }
+      try {
+        resolve4(JSON.parse(raw));
+      } catch {
+        reject(new Error("Request body must be valid JSON."));
+      }
+    });
+    request.on("error", reject);
+  });
+}
 
 // src/install/audit.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, statSync } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
+import { join as join13 } from "path";
 
 // src/config/contracts.ts
 import { z } from "zod";
@@ -580,6 +715,8 @@ var StudioSessionContract = z.object({
   renderedAt: z.string().datetime().optional()
 }).strict();
 var SessionEventContract = z.object({
+  eventId: z.string().uuid().optional(),
+  sequence: z.number().int().positive().optional(),
   type: z.enum([
     "session_started",
     "project_context_loaded",
@@ -1141,8 +1278,8 @@ function onboardingStateExists(cwd) {
 }
 
 // src/install/install.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join11 } from "path";
 
 // src/install/ide-activate.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
@@ -1314,10 +1451,11 @@ function writeGeneratedAgentFile(cwd, relativePath, content, force, result) {
       result.unchanged.push(relativePath);
       return;
     }
-    const conflictPath = join8(cwd, ".agent-kit", "conflicts", relativePath.replace(/\//g, "__"));
-    ensureDir(join8(cwd, ".agent-kit", "conflicts"));
-    writeText(conflictPath, existing);
-    result.conflicts.push(`${relativePath} -> ${conflictPath}`);
+    const proposal = writeConflictProposal(cwd, relativePath, content, {
+      currentContent: existing,
+      reason: "Generated agent content changed while the local target is customized."
+    });
+    result.conflicts.push(`${relativePath} -> ${proposal.conflictPath}`);
     return;
   }
   ensureDir(join8(cwd, relativePath.split("/").slice(0, -1).join("/")));
@@ -1585,17 +1723,57 @@ function ideSurfaceToActivateTarget(ideSurface) {
   return null;
 }
 
+// src/install/managed-assets.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
+function listManagedAssets(packageRoot, stack) {
+  const assets = [];
+  const templateRoot = join10(packageRoot, "templates", stack);
+  for (const target of ROOT_DOCS) {
+    assets.push({ target, sourcePath: join10(templateRoot, target), category: "root-doc" });
+  }
+  for (const adapter2 of CURSOR_ADAPTER_FILES) {
+    assets.push({ target: adapter2.target, sourcePath: join10(packageRoot, adapter2.source), category: "adapter" });
+  }
+  assets.push(
+    { target: DEFAULT_AGENT_ROSTER_TARGET, sourcePath: join10(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE), category: "roster" },
+    { target: DEFAULT_MODEL_ROUTING_TARGET, sourcePath: join10(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE), category: "model-routing" },
+    { target: DEFAULT_ORCHESTRATOR_TARGET, sourcePath: join10(packageRoot, DEFAULT_ORCHESTRATOR_SOURCE), category: "orchestrator" },
+    { target: DEFAULT_RUNTIME_IGNORE_TARGET, sourcePath: join10(packageRoot, DEFAULT_RUNTIME_IGNORE_SOURCE), category: "orchestrator" }
+  );
+  for (const template of CI_TEMPLATE_FILES) {
+    assets.push({ target: template.target, sourcePath: join10(packageRoot, template.source), category: "ci" });
+  }
+  for (const folder of LIBRARY_FOLDERS) {
+    for (const relativePath of listFilesRecursive(join10(packageRoot, folder))) {
+      assets.push({
+        target: `.agent-kit/${folder}/${relativePath}`.replace(/\\/g, "/"),
+        sourcePath: join10(packageRoot, folder, relativePath),
+        category: "library",
+        libraryFolder: folder
+      });
+    }
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const asset of assets) byTarget.set(asset.target, asset);
+  return [...byTarget.values()].sort((left, right) => left.target.localeCompare(right.target));
+}
+function hashManagedAssets(assets) {
+  return Object.fromEntries(assets.map((asset) => [asset.target, sha256(readFileSync8(asset.sourcePath, "utf8"))]));
+}
+
 // src/install/install.ts
 function initProject(options) {
   const cwd = options.cwd;
   const stack = options.stack ?? DEFAULT_CONFIG.stack;
   const packageRoot = findPackageRoot();
-  const templateRoot = join10(packageRoot, "templates", stack);
+  const templateRoot = join11(packageRoot, "templates", stack);
+  const managedAssets = listManagedAssets(packageRoot, stack);
   if (!existsSync10(templateRoot)) {
     throw new Error(`Unsupported stack profile: ${stack}`);
   }
-  ensureDir(join10(cwd, ".agent-kit"));
-  ensureDir(join10(cwd, ".agent-kit", "conflicts"));
+  ensureDir(join11(cwd, ".agent-kit"));
+  ensureDir(join11(cwd, ".agent-kit", "conflicts"));
   const result = {
     copied: [],
     unchanged: [],
@@ -1605,11 +1783,11 @@ function initProject(options) {
   };
   const templateHashes = {};
   for (const doc of ROOT_DOCS) {
-    const templatePath = join10(templateRoot, doc);
-    templateHashes[doc] = sha256(readFileSync8(templatePath, "utf8"));
+    const templatePath = join11(templateRoot, doc);
+    templateHashes[doc] = sha256(readFileSync9(templatePath, "utf8"));
     const copyResult = copyTextWithConflict(templatePath, cwd, doc, {
       force: Boolean(options.force),
-      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join11(cwd, ".agent-kit", "conflicts")
     });
     if (copyResult.action === "created") result.copied.push(copyResult.target);
     if (copyResult.action === "unchanged") result.unchanged.push(copyResult.target);
@@ -1618,13 +1796,18 @@ function initProject(options) {
       result.conflicts.push(`${copyResult.target} -> ${copyResult.conflictPath}`);
     }
   }
-  for (const folder of LIBRARY_FOLDERS) {
-    copyDirectory(join10(packageRoot, folder), join10(cwd, ".agent-kit", folder));
+  for (const asset of managedAssets.filter((item) => item.category === "library")) {
+    const libraryCopy = copyTextWithConflict(asset.sourcePath, cwd, asset.target, {
+      force: Boolean(options.force),
+      conflictRoot: join11(cwd, ".agent-kit", "conflicts")
+    });
+    if (libraryCopy.action === "overwritten") result.overwritten.push(libraryCopy.target);
+    if (libraryCopy.action === "conflict") result.conflicts.push(`${libraryCopy.target} -> ${libraryCopy.conflictPath}`);
   }
   for (const adapter2 of CURSOR_ADAPTER_FILES) {
-    const adapterCopy = copyTextWithConflict(join10(packageRoot, adapter2.source), cwd, adapter2.target, {
+    const adapterCopy = copyTextWithConflict(join11(packageRoot, adapter2.source), cwd, adapter2.target, {
       force: Boolean(options.force),
-      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join11(cwd, ".agent-kit", "conflicts")
     });
     if (adapterCopy.action === "created") result.copied.push(adapterCopy.target);
     if (adapterCopy.action === "unchanged") result.unchanged.push(adapterCopy.target);
@@ -1633,23 +1816,40 @@ function initProject(options) {
       result.conflicts.push(`${adapterCopy.target} -> ${adapterCopy.conflictPath}`);
     }
   }
-  const rosterCopy = copyTextWithConflict(join10(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE), cwd, DEFAULT_AGENT_ROSTER_TARGET, {
+  const rosterCopy = copyTextWithConflict(join11(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE), cwd, DEFAULT_AGENT_ROSTER_TARGET, {
     force: Boolean(options.force),
-    conflictRoot: join10(cwd, ".agent-kit", "conflicts")
+    conflictRoot: join11(cwd, ".agent-kit", "conflicts")
   });
   if (rosterCopy.action === "created") result.copied.push(rosterCopy.target);
   if (rosterCopy.action === "unchanged") result.unchanged.push(rosterCopy.target);
   if (rosterCopy.action === "overwritten") result.overwritten.push(rosterCopy.target);
   if (rosterCopy.action === "conflict") result.conflicts.push(`${rosterCopy.target} -> ${rosterCopy.conflictPath}`);
-  const modelRoutingCopy = copyTextWithConflict(join10(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE), cwd, DEFAULT_MODEL_ROUTING_TARGET, {
+  const modelRoutingCopy = copyTextWithConflict(join11(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE), cwd, DEFAULT_MODEL_ROUTING_TARGET, {
     force: Boolean(options.force),
-    conflictRoot: join10(cwd, ".agent-kit", "conflicts")
+    conflictRoot: join11(cwd, ".agent-kit", "conflicts")
   });
   if (modelRoutingCopy.action === "created") result.copied.push(modelRoutingCopy.target);
   if (modelRoutingCopy.action === "unchanged") result.unchanged.push(modelRoutingCopy.target);
   if (modelRoutingCopy.action === "overwritten") result.overwritten.push(modelRoutingCopy.target);
   if (modelRoutingCopy.action === "conflict") result.conflicts.push(`${modelRoutingCopy.target} -> ${modelRoutingCopy.conflictPath}`);
+  const orchestratorCopy = copyTextWithConflict(join11(packageRoot, DEFAULT_ORCHESTRATOR_SOURCE), cwd, DEFAULT_ORCHESTRATOR_TARGET, {
+    force: Boolean(options.force),
+    conflictRoot: join11(cwd, ".agent-kit", "conflicts")
+  });
+  if (orchestratorCopy.action === "created") result.copied.push(orchestratorCopy.target);
+  if (orchestratorCopy.action === "unchanged") result.unchanged.push(orchestratorCopy.target);
+  if (orchestratorCopy.action === "overwritten") result.overwritten.push(orchestratorCopy.target);
+  if (orchestratorCopy.action === "conflict") result.conflicts.push(`${orchestratorCopy.target} -> ${orchestratorCopy.conflictPath}`);
+  const runtimeIgnoreCopy = copyTextWithConflict(join11(packageRoot, DEFAULT_RUNTIME_IGNORE_SOURCE), cwd, DEFAULT_RUNTIME_IGNORE_TARGET, {
+    force: Boolean(options.force),
+    conflictRoot: join11(cwd, ".agent-kit", "conflicts")
+  });
+  if (runtimeIgnoreCopy.action === "created") result.copied.push(runtimeIgnoreCopy.target);
+  if (runtimeIgnoreCopy.action === "unchanged") result.unchanged.push(runtimeIgnoreCopy.target);
+  if (runtimeIgnoreCopy.action === "overwritten") result.overwritten.push(runtimeIgnoreCopy.target);
+  if (runtimeIgnoreCopy.action === "conflict") result.conflicts.push(`${runtimeIgnoreCopy.target} -> ${runtimeIgnoreCopy.conflictPath}`);
   const manifest = {
+    schemaVersion: 2,
     packageName: PACKAGE_NAME,
     packageVersion: PACKAGE_VERSION,
     stack,
@@ -1658,19 +1858,20 @@ function initProject(options) {
     libraryFolders: [...LIBRARY_FOLDERS],
     agentRoster: DEFAULT_AGENT_ROSTER_TARGET,
     modelRouting: DEFAULT_MODEL_ROUTING_TARGET,
-    templateHashes
+    templateHashes,
+    assetHashes: hashManagedAssets(managedAssets)
   };
-  writeText(join10(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  writeText(join11(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-  writeText(join10(cwd, ".agent-kit", "config.json"), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+  writeText(join11(cwd, ".agent-kit", "config.json"), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
 `);
-  const overridesPath = join10(cwd, ".agent-kit", "overrides.json");
+  const overridesPath = join11(cwd, ".agent-kit", "overrides.json");
   if (!existsSync10(overridesPath)) writeText(overridesPath, `${JSON.stringify({ templates: {} }, null, 2)}
 `);
   for (const template of CI_TEMPLATE_FILES) {
-    const ciCopy = copyTextWithConflict(join10(packageRoot, template.source), cwd, template.target, {
+    const ciCopy = copyTextWithConflict(join11(packageRoot, template.source), cwd, template.target, {
       force: Boolean(options.force),
-      conflictRoot: join10(cwd, ".agent-kit", "conflicts")
+      conflictRoot: join11(cwd, ".agent-kit", "conflicts")
     });
     if (ciCopy.action === "created") result.copied.push(ciCopy.target);
     if (ciCopy.action === "unchanged") result.unchanged.push(ciCopy.target);
@@ -1694,10 +1895,278 @@ function initProject(options) {
   return result;
 }
 function readManifest(cwd) {
-  const manifestPath = join10(cwd, ".agent-kit", "manifest.json");
+  const manifestPath = join11(cwd, ".agent-kit", "manifest.json");
   if (!existsSync10(manifestPath)) return null;
-  return JSON.parse(readFileSync8(manifestPath, "utf8"));
+  return JSON.parse(readFileSync9(manifestPath, "utf8"));
+}
+
+// src/install/audit-rules/project-reality.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import { join as join12 } from "path";
+
+// src/install/audit-rules/types.ts
+var AuditRuleRegistry = class {
+  rules = /* @__PURE__ */ new Map();
+  register(rule) {
+    if (this.rules.has(rule.id)) throw new Error(`Duplicate audit rule id: ${rule.id}`);
+    this.rules.set(rule.id, rule);
+    return this;
+  }
+  evaluate(context2) {
+    return [...this.rules.values()].flatMap((rule) => {
+      const result = rule.evaluate(context2);
+      if (!result) return [];
+      const findings = Array.isArray(result) ? result : [result];
+      return findings.map((finding) => ({
+        ...finding,
+        area: finding.area || rule.area,
+        ruleId: rule.id,
+        ruleVersion: rule.version,
+        ...rule.helpUri ? { helpUri: rule.helpUri } : {}
+      }));
+    });
+  }
+};
+
+// src/install/audit-rules/project-reality.ts
+function relativeFilesFromGit(cwd) {
+  try {
+    const output = execFileSync("git", ["ls-files", "-z", "--cached"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return { files: output.split("\0").filter(Boolean), tracked: true };
+  } catch {
+    return { files: listFilesRecursive(cwd), tracked: false };
+  }
+}
+function readPackageJson2(cwd) {
+  const path = join12(cwd, "package.json");
+  if (!existsSync11(path)) return null;
+  try {
+    return JSON.parse(readFileSync10(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function testScriptLooksExecutable(script) {
+  if (/\b(?:echo|printf)\b.*\b(?:no|skip|todo|placeholder)\b.*\btests?\b/i.test(script)) return false;
+  if (/^(?:true|exit\s+0|:)(?:\s|$)/i.test(script.trim())) return false;
+  return /\b(?:vitest|jest|playwright|node\s+--test|tsx?\s+--test|pytest|cargo\s+test|go\s+test|flutter\s+test|dart\s+test|mvn\s+test|gradle\w*\s+test)\b/i.test(
+    script
+  );
+}
+function normalizeSqlIdentifier(identifier) {
+  return identifier.split(".").map((part) => part.replace(/^"|"$/g, "").toLowerCase()).join(".");
+}
+function collectSqlIdentifiers(sql, expression) {
+  const values = /* @__PURE__ */ new Set();
+  for (const match of sql.matchAll(expression)) {
+    if (match[1]) values.add(normalizeSqlIdentifier(match[1]));
+  }
+  return values;
+}
+function containsLikelySecretForAudit(relativeFile, content) {
+  const normalized = relativeFile.replace(/\\/g, "/");
+  const testSecretFixture = ["sk", "test", "fake", "secret", "value"].join("_");
+  let candidate = content.replace(/gh[pousr]_(?:replace|example|fake|dummy)[A-Za-z0-9_]*/gi, "x").replaceAll(testSecretFixture, "x").replaceAll("sk-proj-this-is-a-resolved-secret-value", "x").replace(/sk-testsecret[A-Za-z0-9_-]*/g, "x");
+  if (normalized.startsWith("tests/") && content.includes("not.toContain(fakeSecret)")) candidate = candidate.replaceAll("top-secret-value", "x");
+  return containsLikelySecret(candidate);
+}
+function evaluateRls(context2) {
+  const migrationsDir = join12(context2.cwd, "supabase", "migrations");
+  if (!existsSync11(migrationsDir)) return null;
+  const sqlFiles = listFilesRecursive(migrationsDir).filter((file) => file.endsWith(".sql"));
+  if (sqlFiles.length === 0) {
+    return {
+      level: "warn",
+      area: "project-reality",
+      message: "supabase/migrations exists but contains no SQL migration files.",
+      remediation: "Add versioned SQL migrations or remove the empty migrations directory if Supabase is not in use.",
+      confidence: "high",
+      evidence: [{ kind: "file", path: "supabase/migrations", summary: "Migration directory is empty.", observedAt: context2.observedAt }]
+    };
+  }
+  const created = /* @__PURE__ */ new Set();
+  const rlsEnabled = /* @__PURE__ */ new Set();
+  const policyTables = /* @__PURE__ */ new Set();
+  for (const file of sqlFiles) {
+    const sql = readFileSync10(join12(migrationsDir, file), "utf8");
+    for (const table of collectSqlIdentifiers(sql, /create\s+table\s+(?:if\s+not\s+exists\s+)?((?:"?[a-zA-Z_][\w$-]*"?\.)?"?[a-zA-Z_][\w$-]*"?)/gi))
+      created.add(table);
+    for (const table of collectSqlIdentifiers(
+      sql,
+      /alter\s+table\s+(?:only\s+)?((?:"?[a-zA-Z_][\w$-]*"?\.)?"?[a-zA-Z_][\w$-]*"?)\s+enable\s+row\s+level\s+security/gi
+    ))
+      rlsEnabled.add(table);
+    for (const table of collectSqlIdentifiers(sql, /create\s+policy\s+[\s\S]*?\s+on\s+((?:"?[a-zA-Z_][\w$-]*"?\.)?"?[a-zA-Z_][\w$-]*"?)/gi))
+      policyTables.add(table);
+  }
+  const missingRls = [...created].filter((table) => !rlsEnabled.has(table)).sort();
+  if (missingRls.length > 0 || rlsEnabled.size === 0) {
+    return {
+      level: "fail",
+      area: "project-reality",
+      message: missingRls.length > 0 ? `Migration-created tables missing explicit row level security (RLS) enablement: ${missingRls.join(", ")}.` : "No Supabase migration enables row level security.",
+      remediation: "Enable RLS explicitly for every application table and add intentional policies before shipping user data.",
+      confidence: "high",
+      evidence: sqlFiles.map((file) => ({
+        kind: "file",
+        path: `supabase/migrations/${file}`,
+        summary: "Parsed SQL migration.",
+        observedAt: context2.observedAt
+      }))
+    };
+  }
+  const withoutPolicies = [...rlsEnabled].filter((table) => created.has(table) && !policyTables.has(table)).sort();
+  const findings = [
+    {
+      level: "pass",
+      area: "project-reality",
+      message: `Supabase migrations explicitly enable RLS for ${rlsEnabled.size} table(s).`,
+      confidence: "high",
+      evidence: sqlFiles.map((file) => ({
+        kind: "file",
+        path: `supabase/migrations/${file}`,
+        summary: "Parsed SQL migration.",
+        observedAt: context2.observedAt
+      }))
+    }
+  ];
+  if (withoutPolicies.length > 0) {
+    findings.push({
+      level: "warn",
+      area: "project-reality",
+      message: `RLS-enabled tables without a policy in the scanned migrations: ${withoutPolicies.join(", ")}.`,
+      remediation: "Add explicit policies or document why access should remain denied by default.",
+      confidence: "medium",
+      evidence: []
+    });
+  }
+  return findings;
+}
+function evaluateTests(context2) {
+  const packageJson = readPackageJson2(context2.cwd);
+  if (!packageJson) {
+    return {
+      level: "warn",
+      area: "project-reality",
+      message: "No package.json found to verify test scripts.",
+      remediation: "Add package.json with executable test, lint, and build scripts appropriate to the stack.",
+      confidence: "high",
+      evidence: []
+    };
+  }
+  const scripts = packageJson.scripts ?? {};
+  const entry = ["test", "test:unit", "test:ci"].find((name) => scripts[name]);
+  if (!entry) {
+    return {
+      level: "warn",
+      area: "project-reality",
+      message: "package.json has no test script (test, test:unit, or test:ci).",
+      remediation: "Add an executable test command and document it in TESTING.md.",
+      confidence: "high",
+      evidence: [{ kind: "file", path: "package.json", summary: "No supported test script key was found.", observedAt: context2.observedAt }]
+    };
+  }
+  const script = scripts[entry] ?? "";
+  const files = listFilesRecursive(context2.cwd);
+  const hasTests = files.some((file) => /(^|\/)(?:tests?|__tests__)(\/|$)|\.(?:test|spec)\.[cm]?[jt]sx?$/i.test(file));
+  if (!testScriptLooksExecutable(script) || !hasTests) {
+    return {
+      level: "warn",
+      area: "project-reality",
+      message: `package.json script ${entry} does not provide credible executable test evidence.`,
+      remediation: "Use a recognized test runner and keep at least one discoverable test file in the repository.",
+      confidence: "high",
+      evidence: [{ kind: "configuration", path: "package.json", summary: `${entry}: ${script}`, observedAt: context2.observedAt }]
+    };
+  }
+  return {
+    level: "pass",
+    area: "project-reality",
+    message: `package.json defines executable test script ${entry} and discoverable test files exist.`,
+    confidence: "high",
+    evidence: [{ kind: "configuration", path: "package.json", summary: `${entry}: ${script}`, observedAt: context2.observedAt }]
+  };
+}
+function evaluateSecrets(context2) {
+  const inventory = relativeFilesFromGit(context2.cwd);
+  const candidates = inventory.files.filter((file) => {
+    const normalized = file.replace(/\\/g, "/");
+    if (normalized.includes("node_modules/") || normalized.includes(".agent-kit/")) return false;
+    const path = join12(context2.cwd, file);
+    try {
+      return statSync2(path).isFile() && statSync2(path).size <= 1e6;
+    } catch {
+      return false;
+    }
+  });
+  const hits = candidates.flatMap((file) => {
+    try {
+      const content = readFileSync10(join12(context2.cwd, file), "utf8");
+      if (content.includes("\0")) return [];
+      return containsLikelySecretForAudit(file, content) ? [file.replace(/\\/g, "/")] : [];
+    } catch {
+      return [];
+    }
+  });
+  if (hits.length > 0) {
+    return {
+      level: "fail",
+      area: "project-reality",
+      message: `Possible ${inventory.tracked ? "committed" : "workspace"} secret patterns detected in: ${hits.slice(0, 5).join(", ")}.`,
+      remediation: "Remove secrets, rotate exposed credentials, and store only credential references in project files.",
+      confidence: inventory.tracked ? "high" : "medium",
+      evidence: hits.slice(0, 20).map((path) => ({ kind: "file", path, summary: "Secret-like pattern detected; value omitted.", observedAt: context2.observedAt }))
+    };
+  }
+  if (candidates.length === 0) return null;
+  return {
+    level: "pass",
+    area: "project-reality",
+    message: `No obvious secret patterns detected in ${inventory.tracked ? "Git-tracked" : "workspace"} files.`,
+    confidence: inventory.tracked ? "high" : "medium",
+    evidence: [{ kind: "command", summary: inventory.tracked ? "git ls-files --cached" : "Recursive workspace fallback", observedAt: context2.observedAt }]
+  };
+}
+function evaluateContext(context2) {
+  if (context2.packageRepository) {
+    return {
+      level: "pass",
+      area: "project-reality",
+      message: "Package source repository mode does not require installed-project context files.",
+      confidence: "high",
+      evidence: []
+    };
+  }
+  if (!existsSync11(join12(context2.cwd, CONTEXT_JSON))) {
+    return {
+      level: "warn",
+      area: "project-reality",
+      message: ".agent-kit/project-context.json is missing.",
+      remediation: "Run agent-kit init or agent-kit context init to create project context.",
+      confidence: "high",
+      evidence: []
+    };
+  }
+  return {
+    level: "pass",
+    area: "project-reality",
+    message: ".agent-kit/project-context.json exists.",
+    confidence: "high",
+    evidence: [{ kind: "file", path: CONTEXT_JSON, summary: "Project context file exists.", observedAt: context2.observedAt }]
+  };
 }
+var projectRealityRules = new AuditRuleRegistry().register({
+  id: "project-reality.supabase.rls-per-table",
+  version: "1.0.0",
+  area: "project-reality",
+  helpUri: "https://supabase.com/docs/guides/database/postgres/row-level-security",
+  evaluate: evaluateRls
+}).register({ id: "project-reality.tests.executable-script", version: "1.0.0", area: "project-reality", evaluate: evaluateTests }).register({ id: "project-reality.secrets.git-tracked", version: "1.0.0", area: "project-reality", evaluate: evaluateSecrets }).register({ id: "project-reality.context.present", version: "1.0.0", area: "project-reality", evaluate: evaluateContext });
 
 // src/install/audit.ts
 var REQUIRED_AGENT_IDS = [
@@ -1742,13 +2211,17 @@ var REQUIRED_SCHEMA_FILES = [
   "agent-roster.schema.json",
   "council-session.schema.json",
   "audit-report.schema.json",
+  "audit-report-v2.schema.json",
   "model-routing.schema.json",
   "project-context.schema.json",
   "correction-rules.schema.json",
   "session-event.schema.json",
   "studio-session.schema.json",
   "onboarding-state.schema.json",
-  "agentic-level.schema.json"
+  "agentic-level.schema.json",
+  "orchestrator.schema.json",
+  "runtime-run.schema.json",
+  "runtime-event.schema.json"
 ];
 var COUNCIL_SESSION_DIR = ".agent-kit/council-sessions";
 var READINESS_ORDER = ["needs-setup", "baseline-setup", "needs-improvement", "best-practice-candidate"];
@@ -1767,24 +2240,24 @@ function includesAll(text, values) {
   return values.every((value) => lower.includes(value.toLowerCase()));
 }
 function readDoc(cwd, file) {
-  const path = join11(cwd, file);
-  return existsSync11(path) ? readFileSync9(path, "utf8") : "";
+  const path = join13(cwd, file);
+  return existsSync12(path) ? readFileSync11(path, "utf8") : "";
 }
 function isPackageRepository(cwd) {
-  const packagePath = join11(cwd, "package.json");
-  if (!existsSync11(packagePath)) return false;
+  const packagePath = join13(cwd, "package.json");
+  if (!existsSync12(packagePath)) return false;
   try {
-    const packageJson = JSON.parse(readFileSync9(packagePath, "utf8"));
-    return packageJson.name === "@appsforgood/next-supabase-kit" && existsSync11(join11(cwd, "src", "cli", "index.ts")) && existsSync11(join11(cwd, "templates", "next-supabase")) && existsSync11(join11(cwd, "rosters", "next-supabase-default-council.json"));
+    const packageJson = JSON.parse(readFileSync11(packagePath, "utf8"));
+    return packageJson.name === "@appsforgood/next-supabase-kit" && existsSync12(join13(cwd, "src", "cli", "index.ts")) && existsSync12(join13(cwd, "templates", "next-supabase")) && existsSync12(join13(cwd, "rosters", "next-supabase-default-council.json"));
   } catch {
     return false;
   }
 }
 function readOverrides(cwd) {
-  const path = join11(cwd, ".agent-kit", "overrides.json");
-  if (!existsSync11(path)) return {};
+  const path = join13(cwd, ".agent-kit", "overrides.json");
+  if (!existsSync12(path)) return {};
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     const templates = parsed.templates ?? {};
     return Object.fromEntries(
       Object.entries(templates).map(([file, override]) => [
@@ -1797,8 +2270,8 @@ function readOverrides(cwd) {
   }
 }
 function readTemplate(stack, file) {
-  const path = join11(findPackageRoot(), "templates", stack, file);
-  return existsSync11(path) ? readFileSync9(path, "utf8") : null;
+  const path = join13(findPackageRoot(), "templates", stack, file);
+  return existsSync12(path) ? readFileSync11(path, "utf8") : null;
 }
 function asStringArray(value) {
   if (!Array.isArray(value)) return [];
@@ -1808,8 +2281,8 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGENT_ROSTER_TARGET) {
-  const rosterPath = join11(cwd, rosterRelativePath);
-  if (!existsSync11(rosterPath)) {
+  const rosterPath = join13(cwd, rosterRelativePath);
+  if (!existsSync12(rosterPath)) {
     findings.push({
       level: "fail",
       area: "agents",
@@ -1820,7 +2293,7 @@ function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGEN
   }
   let roster;
   try {
-    const parsed = JSON.parse(readFileSync9(rosterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync11(rosterPath, "utf8"));
     if (!isRecord(parsed)) throw new Error("Roster must be a JSON object.");
     const contractResult = AgentRosterContract.safeParse(parsed);
     if (!contractResult.success) {
@@ -2007,15 +2480,15 @@ function addAgentRosterFindings(cwd, findings, rosterRelativePath = DEFAULT_AGEN
   }
 }
 function addCouncilSessionRecordFindings(cwd, findings) {
-  const sessionsRoot = join11(cwd, COUNCIL_SESSION_DIR);
-  if (!existsSync11(sessionsRoot)) return;
+  const sessionsRoot = join13(cwd, COUNCIL_SESSION_DIR);
+  if (!existsSync12(sessionsRoot)) return;
   const sessionFiles = listFilesRecursive(sessionsRoot).filter((file) => file.endsWith(".json") && !/[\\/]/.test(file));
   if (sessionFiles.length === 0) return;
   let invalidCount = 0;
   for (const sessionFile of sessionFiles) {
     const displayPath = `${COUNCIL_SESSION_DIR}/${sessionFile}`;
     try {
-      const parsed = JSON.parse(readFileSync9(join11(sessionsRoot, sessionFile), "utf8"));
+      const parsed = JSON.parse(readFileSync11(join13(sessionsRoot, sessionFile), "utf8"));
       const contractResult = CouncilSessionContract.safeParse(parsed);
       if (!contractResult.success) {
         invalidCount += 1;
@@ -2046,8 +2519,8 @@ function addCouncilSessionRecordFindings(cwd, findings) {
 }
 function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/schemas") {
   for (const schemaFile of REQUIRED_SCHEMA_FILES) {
-    const schemaPath = join11(cwd, schemaRootRelativePath, schemaFile);
-    if (!existsSync11(schemaPath)) {
+    const schemaPath = join13(cwd, schemaRootRelativePath, schemaFile);
+    if (!existsSync12(schemaPath)) {
       findings.push({
         level: "warn",
         area: "agents",
@@ -2057,7 +2530,7 @@ function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/s
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync9(schemaPath, "utf8"));
+      const parsed = JSON.parse(readFileSync11(schemaPath, "utf8"));
       if (!isRecord(parsed) || typeof parsed.$schema !== "string" || !isRecord(parsed.properties)) {
         throw new Error("Schema file is missing JSON Schema metadata.");
       }
@@ -2076,9 +2549,54 @@ function addSchemaFindings(cwd, findings, schemaRootRelativePath = ".agent-kit/s
     }
   }
 }
+function addOrchestratorFindings(cwd, findings, relativePath = DEFAULT_ORCHESTRATOR_TARGET) {
+  const path = join13(cwd, relativePath);
+  if (!existsSync12(path)) {
+    findings.push({
+      level: "warn",
+      area: "orchestrator",
+      message: `${relativePath} is missing.`,
+      remediation: "Run agent-kit update to install the disabled-by-default optional runtime policy."
+    });
+    return;
+  }
+  const text = readFileSync11(path, "utf8");
+  if (containsLikelySecret(text)) {
+    findings.push({
+      level: "fail",
+      area: "orchestrator",
+      message: `${relativePath} appears to contain a resolved credential.`,
+      remediation: "Replace credential values with env:NAME or keychain:account references and rotate exposed secrets."
+    });
+    return;
+  }
+  try {
+    const config = JSON.parse(text);
+    if (config.schemaVersion !== 1 || typeof config.enabled !== "boolean") throw new Error("schemaVersion must be 1 and enabled must be boolean");
+    if (!config.providers || typeof config.providers !== "object" || Array.isArray(config.providers)) throw new Error("providers must be an object");
+    if (!config.modelAliases || typeof config.modelAliases !== "object" || Array.isArray(config.modelAliases))
+      throw new Error("modelAliases must be an object");
+    if (config.enabled) {
+      if (typeof config.defaultAlias !== "string" || !config.defaultAlias) throw new Error("enabled runtime requires defaultAlias");
+      if (!Object.hasOwn(config.modelAliases, config.defaultAlias)) throw new Error("enabled runtime defaultAlias is not configured");
+    }
+    findings.push({
+      level: "pass",
+      area: "orchestrator",
+      message: `${relativePath} is valid and ${config.enabled ? "enabled" : "disabled by default"}.`
+    });
+  } catch (error) {
+    findings.push({
+      level: "fail",
+      area: "orchestrator",
+      message: `${relativePath} is invalid: ${error instanceof Error ? error.message : String(error)}.`,
+      remediation: "Restore it from the current template and run agent-kit orchestrate validate before enabling execution."
+    });
+  }
+}
 function addAgentStudioFindings(cwd, findings) {
-  const contextPath = join11(cwd, CONTEXT_JSON);
-  if (!existsSync11(contextPath)) {
+  const contextPath = join13(cwd, CONTEXT_JSON);
+  if (!existsSync12(contextPath)) {
     findings.push({
       level: "warn",
       area: "studio",
@@ -2087,7 +2605,7 @@ function addAgentStudioFindings(cwd, findings) {
     });
   } else {
     try {
-      const parsed = JSON.parse(readFileSync9(contextPath, "utf8"));
+      const parsed = JSON.parse(readFileSync11(contextPath, "utf8"));
       const result = ProjectContextContract.safeParse(parsed);
       if (!result.success) {
         findings.push({
@@ -2151,8 +2669,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const contextMdPath = join11(cwd, CONTEXT_MD);
-  if (existsSync11(contextPath) && !existsSync11(contextMdPath)) {
+  const contextMdPath = join13(cwd, CONTEXT_MD);
+  if (existsSync12(contextPath) && !existsSync12(contextMdPath)) {
     findings.push({
       level: "warn",
       area: "studio",
@@ -2161,10 +2679,10 @@ function addAgentStudioFindings(cwd, findings) {
     });
   }
   for (const relativePath of [PROJECT_RULES_JSON, AGENT_RULES_JSON]) {
-    const path = join11(cwd, relativePath);
-    if (!existsSync11(path)) continue;
+    const path = join13(cwd, relativePath);
+    if (!existsSync12(path)) continue;
     try {
-      const parsed = JSON.parse(readFileSync9(path, "utf8"));
+      const parsed = JSON.parse(readFileSync11(path, "utf8"));
       const result = CorrectionRulesContract.safeParse(parsed);
       if (!result.success) {
         findings.push({
@@ -2189,9 +2707,9 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const studioExportPath = join11(cwd, STUDIO_EXPORT_HTML);
-  if (existsSync11(studioExportPath)) {
-    const exportHtml = readFileSync9(studioExportPath, "utf8");
+  const studioExportPath = join13(cwd, STUDIO_EXPORT_HTML);
+  if (existsSync12(studioExportPath)) {
+    const exportHtml = readFileSync11(studioExportPath, "utf8");
     if (containsLikelySecret(exportHtml)) {
       findings.push({
         level: "fail",
@@ -2214,8 +2732,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
     }
   }
-  const sessionsRoot = join11(cwd, COUNCIL_SESSION_DIR);
-  if (!existsSync11(sessionsRoot)) return;
+  const sessionsRoot = join13(cwd, COUNCIL_SESSION_DIR);
+  if (!existsSync12(sessionsRoot)) return;
   const files = listFilesRecursive(sessionsRoot);
   const studioSessionFiles = files.filter((file) => /[\\/]session\.json$/.test(file));
   for (const sessionFile of studioSessionFiles) {
@@ -2224,10 +2742,10 @@ function addAgentStudioFindings(cwd, findings) {
     const sessionDir2 = sessionFile.replace(/[\\/]session\.json$/, "");
     const normalizedSessionDir = sessionDir2.replace(/\\/g, "/");
     const eventsRelative = `${COUNCIL_SESSION_DIR}/${normalizedSessionDir}/events.jsonl`;
-    const sessionDirPath = join11(sessionsRoot, sessionDir2);
+    const sessionDirPath = join13(sessionsRoot, sessionDir2);
     let sessionResult = null;
     try {
-      sessionResult = StudioSessionContract.safeParse(JSON.parse(readFileSync9(join11(sessionDirPath, "session.json"), "utf8")));
+      sessionResult = StudioSessionContract.safeParse(JSON.parse(readFileSync11(join13(sessionDirPath, "session.json"), "utf8")));
       if (!sessionResult.success) {
         findings.push({
           level: "fail",
@@ -2246,8 +2764,8 @@ function addAgentStudioFindings(cwd, findings) {
       });
       continue;
     }
-    const eventsPath2 = join11(sessionDirPath, "events.jsonl");
-    if (!existsSync11(eventsPath2)) {
+    const eventsPath2 = join13(sessionDirPath, "events.jsonl");
+    if (!existsSync12(eventsPath2)) {
       findings.push({
         level: "fail",
         area: "studio",
@@ -2256,7 +2774,7 @@ function addAgentStudioFindings(cwd, findings) {
       });
       continue;
     }
-    const eventText = readFileSync9(eventsPath2, "utf8");
+    const eventText = readFileSync11(eventsPath2, "utf8");
     if (containsLikelySecret(eventText)) {
       findings.push({
         level: "fail",
@@ -2291,7 +2809,7 @@ function addAgentStudioFindings(cwd, findings) {
         });
       }
     }
-    if (!existsSync11(join11(sessionDirPath, "index.md")) || !existsSync11(join11(sessionDirPath, "transcript.md"))) {
+    if (!existsSync12(join13(sessionDirPath, "index.md")) || !existsSync12(join13(sessionDirPath, "transcript.md"))) {
       findings.push({
         level: "warn",
         area: "studio",
@@ -2299,8 +2817,8 @@ function addAgentStudioFindings(cwd, findings) {
         remediation: "Run agent-kit session render so humans can inspect the current agent transcript and handoffs."
       });
     } else {
-      const indexText = readFileSync9(join11(sessionDirPath, "index.md"), "utf8");
-      const transcriptText = readFileSync9(join11(sessionDirPath, "transcript.md"), "utf8");
+      const indexText = readFileSync11(join13(sessionDirPath, "index.md"), "utf8");
+      const transcriptText = readFileSync11(join13(sessionDirPath, "transcript.md"), "utf8");
       if (containsLikelySecret(indexText) || containsLikelySecret(transcriptText)) {
         findings.push({
           level: "fail",
@@ -2309,7 +2827,7 @@ function addAgentStudioFindings(cwd, findings) {
           remediation: "Regenerate Markdown after redacting sensitive values from the event log."
         });
       }
-      if (statSync(eventsPath2).mtimeMs > statSync(join11(sessionDirPath, "index.md")).mtimeMs) {
+      if (statSync3(eventsPath2).mtimeMs > statSync3(join13(sessionDirPath, "index.md")).mtimeMs) {
         findings.push({
           level: "warn",
           area: "studio",
@@ -2359,8 +2877,8 @@ function addCouncilDocFindings(cwd, findings) {
 }
 function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".agent-kit/assistant-adapters", docsCwd = cwd) {
   const adaptersDoc = readDoc(docsCwd, "ASSISTANT_ADAPTERS.md");
-  const adapterRoot = join11(cwd, adapterRootRelativePath);
-  if (!existsSync11(adapterRoot)) {
+  const adapterRoot = join13(cwd, adapterRootRelativePath);
+  if (!existsSync12(adapterRoot)) {
     findings.push({
       level: "warn",
       area: "agents",
@@ -2389,7 +2907,7 @@ function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".
       message: "ASSISTANT_ADAPTERS.md maps the council roster to tool-specific instruction surfaces."
     });
   }
-  if (assistantAdapterRowIsActive(adaptersDoc, "Cursor") && !existsSync11(join11(cwd, ".cursor/agents/planner.md"))) {
+  if (assistantAdapterRowIsActive(adaptersDoc, "Cursor") && !existsSync12(join13(cwd, ".cursor/agents/planner.md"))) {
     findings.push({
       level: "warn",
       area: "agents",
@@ -2397,7 +2915,7 @@ function addAssistantAdapterFindings(cwd, findings, adapterRootRelativePath = ".
       remediation: "Run agent-kit init --activate cursor to generate council subagents from the roster."
     });
   }
-  if (assistantAdapterRowIsActive(adaptersDoc, "Codex / AGENTS.md-compatible tools") && !existsSync11(join11(cwd, ".codex/agents/planner.toml"))) {
+  if (assistantAdapterRowIsActive(adaptersDoc, "Codex / AGENTS.md-compatible tools") && !existsSync12(join13(cwd, ".codex/agents/planner.toml"))) {
     findings.push({
       level: "warn",
       area: "agents",
@@ -2445,8 +2963,8 @@ function addModelRoutingFindings(cwd, findings, routingRelativePath = DEFAULT_MO
       message: "MODEL_ROUTING.md documents agent model profiles and IDE enforcement limits."
     });
   }
-  const routingPath = join11(cwd, routingRelativePath);
-  if (!existsSync11(routingPath)) {
+  const routingPath = join13(cwd, routingRelativePath);
+  if (!existsSync12(routingPath)) {
     findings.push({
       level: "warn",
       area: "models",
@@ -2457,7 +2975,7 @@ function addModelRoutingFindings(cwd, findings, routingRelativePath = DEFAULT_MO
   }
   let routing;
   try {
-    routing = JSON.parse(readFileSync9(routingPath, "utf8"));
+    routing = JSON.parse(readFileSync11(routingPath, "utf8"));
   } catch {
     findings.push({
       level: "warn",
@@ -2515,11 +3033,11 @@ function addTemplateHashFindings(cwd, findings) {
   if (!manifest) return;
   const overrides = readOverrides(cwd);
   for (const doc of ROOT_DOCS) {
-    const targetPath = join11(cwd, doc);
-    if (!existsSync11(targetPath)) continue;
+    const targetPath = join13(cwd, doc);
+    if (!existsSync12(targetPath)) continue;
     const currentTemplate = readTemplate(manifest.stack, doc);
     if (!currentTemplate) continue;
-    const targetHash = sha256(readFileSync9(targetPath, "utf8"));
+    const targetHash = sha256(readFileSync11(targetPath, "utf8"));
     const currentTemplateHash = sha256(currentTemplate);
     const installedTemplateHash = manifest.templateHashes?.[doc];
     const override = overrides[doc];
@@ -2811,27 +3329,25 @@ function addMessagingFindings(cwd, findings) {
     });
   }
 }
-function auditProject(cwd) {
+function auditProject(cwd, options = {}) {
   const findings = [];
   const manifest = readManifest(cwd);
   const packageRepository = isPackageRepository(cwd);
-  const packageSourceMode = packageRepository && !manifest;
-  const docsCwd = packageSourceMode ? join11(cwd, "templates", "next-supabase") : cwd;
-  if (!manifest) {
-    if (packageRepository) {
-      findings.push({
-        level: "pass",
-        area: "install",
-        message: "Package source repository mode detected; installed-project manifest is not required."
-      });
-    } else {
-      findings.push({
-        level: "fail",
-        area: "install",
-        message: "Project has no .agent-kit/manifest.json.",
-        remediation: "Run agent-kit init --stack next-supabase."
-      });
-    }
+  const packageSourceMode = options.packageSource === true || packageRepository && !manifest;
+  const docsCwd = packageSourceMode ? join13(cwd, "templates", "next-supabase") : cwd;
+  if (packageSourceMode) {
+    findings.push({
+      level: "pass",
+      area: "install",
+      message: "Package source repository mode detected; installed-project manifest is not required."
+    });
+  } else if (!manifest) {
+    findings.push({
+      level: "fail",
+      area: "install",
+      message: "Project has no .agent-kit/manifest.json.",
+      remediation: "Run agent-kit init --stack next-supabase."
+    });
   } else {
     findings.push({
       level: "pass",
@@ -2839,17 +3355,20 @@ function auditProject(cwd) {
       message: `Agent kit installed at version ${manifest.packageVersion}.`
     });
   }
-  addTemplateHashFindings(cwd, findings);
+  if (!packageSourceMode) addTemplateHashFindings(cwd, findings);
   addAgentRosterFindings(cwd, findings, packageSourceMode ? "rosters/next-supabase-default-council.json" : DEFAULT_AGENT_ROSTER_TARGET);
   addSchemaFindings(cwd, findings, packageSourceMode ? "schemas" : ".agent-kit/schemas");
-  addCouncilSessionRecordFindings(cwd, findings);
-  if (!packageRepository || existsSync11(join11(cwd, CONTEXT_JSON)) || existsSync11(join11(cwd, COUNCIL_SESSION_DIR))) {
-    addAgentStudioFindings(cwd, findings);
+  addOrchestratorFindings(cwd, findings, packageSourceMode ? "templates/next-supabase/.agent-kit/orchestrator.json" : DEFAULT_ORCHESTRATOR_TARGET);
+  if (!packageSourceMode) {
+    addCouncilSessionRecordFindings(cwd, findings);
+    if (!packageRepository || existsSync12(join13(cwd, CONTEXT_JSON)) || existsSync12(join13(cwd, COUNCIL_SESSION_DIR))) {
+      addAgentStudioFindings(cwd, findings);
+    }
   }
   for (const doc of ROOT_DOCS) {
-    const docPath = join11(docsCwd, doc);
+    const docPath = join13(docsCwd, doc);
     const displayPath = packageSourceMode ? `templates/next-supabase/${doc}` : doc;
-    if (existsSync11(docPath)) {
+    if (existsSync12(docPath)) {
       findings.push({ level: "pass", area: "docs", message: `${displayPath} exists.` });
     } else {
       findings.push({
@@ -2867,7 +3386,7 @@ function auditProject(cwd) {
   addQualityGateFindings(docsCwd, findings);
   addUpgradeFindings(docsCwd, findings);
   addProjectEvidenceFindings(docsCwd, findings);
-  addProjectRealityFindings(cwd, findings, { packageRepository });
+  findings.push(...projectRealityRules.evaluate({ cwd, packageRepository, observedAt: (/* @__PURE__ */ new Date()).toISOString() }));
   const security = readDoc(docsCwd, "SECURITY.md");
   if (!includesAny(security, ["OWASP", "Top 10"])) {
     findings.push({
@@ -2913,132 +3432,14 @@ function auditProject(cwd) {
   }
   return findings;
 }
-function readPackageJson2(cwd) {
-  const path = join11(cwd, "package.json");
-  if (!existsSync11(path)) return null;
-  try {
-    return JSON.parse(readFileSync9(path, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function containsLikelySecretForAudit(relativeFile, content) {
-  const normalized = relativeFile.replace(/\\/g, "/");
-  const testSecretFixture = ["sk", "test", "fake", "secret", "value"].join("_");
-  if (normalized.startsWith("tests/") && content.includes(`const fakeSecret = "${testSecretFixture}"`) && content.includes("not.toContain(fakeSecret)")) {
-    return containsLikelySecret(content.split(testSecretFixture).join("[TEST_SECRET_FIXTURE]"));
-  }
-  return containsLikelySecret(content);
-}
-function addProjectRealityFindings(cwd, findings, options = {}) {
-  const migrationsDir = join11(cwd, "supabase", "migrations");
-  if (existsSync11(migrationsDir)) {
-    const sqlFiles = listFilesRecursive(migrationsDir).filter((file) => file.endsWith(".sql"));
-    if (sqlFiles.length === 0) {
-      findings.push({
-        level: "warn",
-        area: "project-reality",
-        message: "supabase/migrations exists but contains no SQL migration files.",
-        remediation: "Add versioned SQL migrations or remove the empty migrations directory if Supabase is not in use."
-      });
-    } else {
-      const rlsFiles = sqlFiles.filter((file) => {
-        const content = readFileSync9(join11(migrationsDir, file), "utf8");
-        return /enable\s+row\s+level\s+security/i.test(content);
-      });
-      if (rlsFiles.length === 0) {
-        findings.push({
-          level: "fail",
-          area: "project-reality",
-          message: "No Supabase migration enables row level security.",
-          remediation: "Add `ALTER TABLE ... ENABLE ROW LEVEL SECURITY` (or equivalent) in supabase/migrations before shipping user data."
-        });
-      } else {
-        findings.push({
-          level: "pass",
-          area: "project-reality",
-          message: `Supabase migrations enable RLS in ${rlsFiles.length} file(s).`
-        });
-      }
-    }
-  }
-  const packageJson = readPackageJson2(cwd);
-  if (!packageJson) {
-    findings.push({
-      level: "warn",
-      area: "project-reality",
-      message: "No package.json found to verify test scripts.",
-      remediation: "Add package.json with test, lint, and build scripts appropriate to the stack."
-    });
-  } else {
-    const scripts = packageJson.scripts ?? {};
-    const testScript = scripts.test ?? scripts["test:unit"] ?? scripts["test:ci"];
-    if (!testScript) {
-      findings.push({
-        level: "warn",
-        area: "project-reality",
-        message: "package.json has no test script (test, test:unit, or test:ci).",
-        remediation: "Add a test script and document it in TESTING.md."
-      });
-    } else {
-      findings.push({
-        level: "pass",
-        area: "project-reality",
-        message: "package.json defines a test script."
-      });
-    }
-  }
-  const trackedSourceFiles = listFilesRecursive(cwd).filter((file) => {
-    if (file.includes("node_modules/") || file.includes(".agent-kit/")) return false;
-    return /\.(ts|tsx|js|jsx|env|json)$/.test(file);
-  });
-  const secretHits = trackedSourceFiles.map((file) => {
-    const content = readFileSync9(join11(cwd, file), "utf8");
-    return containsLikelySecretForAudit(file, content) ? file : null;
-  }).filter((file) => file !== null).slice(0, 5);
-  if (secretHits.length > 0) {
-    findings.push({
-      level: "fail",
-      area: "project-reality",
-      message: `Possible committed secret patterns detected in: ${secretHits.join(", ")}.`,
-      remediation: "Remove secrets from tracked files, rotate exposed credentials, and use environment variables."
-    });
-  } else if (trackedSourceFiles.length > 0) {
-    findings.push({
-      level: "pass",
-      area: "project-reality",
-      message: "No obvious committed secret patterns detected in tracked source files."
-    });
-  }
-  if (options.packageRepository) {
-    findings.push({
-      level: "pass",
-      area: "project-reality",
-      message: "Package source repository mode does not require installed-project context files."
-    });
-  } else if (!existsSync11(join11(cwd, CONTEXT_JSON))) {
-    findings.push({
-      level: "warn",
-      area: "project-reality",
-      message: ".agent-kit/project-context.json is missing.",
-      remediation: "Run agent-kit init or agent-kit context init to create project context."
-    });
-  } else {
-    findings.push({
-      level: "pass",
-      area: "project-reality",
-      message: ".agent-kit/project-context.json exists."
-    });
-  }
-}
-function createReadiness(findings, summary2) {
-  const nextActions = findings.filter((finding) => finding.level === "fail" || finding.level === "warn").map((finding) => finding.remediation ?? finding.message).filter((value, index, values) => values.indexOf(value) === index).slice(0, 5);
-  if (summary2.fail > 0) {
-    return {
-      level: "needs-setup",
-      summary: "Required setup or contract checks are failing.",
-      nextActions
-    };
+function createAuditReadiness(findings, summary2) {
+  const nextActions = findings.filter((finding) => finding.level === "fail" || finding.level === "warn").map((finding) => finding.remediation ?? finding.message).filter((value, index, values) => values.indexOf(value) === index).slice(0, 5);
+  if (summary2.fail > 0) {
+    return {
+      level: "needs-setup",
+      summary: "Required setup or contract checks are failing.",
+      nextActions
+    };
   }
   if (findings.some((finding) => finding.level === "warn" && finding.area === "evidence")) {
     return {
@@ -3060,11 +3461,16 @@ function createReadiness(findings, summary2) {
     nextActions
   };
 }
-function createAuditReport(cwd) {
-  const findings = auditProject(cwd);
+function createAuditReport(cwd, options = {}) {
+  const findings = auditProject(cwd, options).map((finding) => ({
+    level: finding.level,
+    area: finding.area,
+    message: finding.message,
+    ...finding.remediation ? { remediation: finding.remediation } : {}
+  }));
   const summary2 = { pass: 0, warn: 0, fail: 0 };
   for (const finding of findings) summary2[finding.level] += 1;
-  return { summary: summary2, readiness: createReadiness(findings, summary2), findings };
+  return { summary: summary2, readiness: createAuditReadiness(findings, summary2), findings };
 }
 
 // src/install/adapter-validate.ts
@@ -3103,7 +3509,7 @@ function report(target, findings) {
 }
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync10(path, "utf8"));
+    return JSON.parse(readFileSync12(path, "utf8"));
   } catch {
     return null;
   }
@@ -3117,24 +3523,24 @@ function isSafeRelativePath(path) {
   return !normalized.startsWith("/") && !normalized.startsWith("../") && !normalized.includes("/../");
 }
 function findAntigravityLayout(cwd) {
-  const sourcePlugin = join12(cwd, "antigravity", "plugin.json");
-  if (existsSync12(sourcePlugin)) {
+  const sourcePlugin = join14(cwd, "antigravity", "plugin.json");
+  if (existsSync13(sourcePlugin)) {
     return {
       mode: "source",
-      pluginRoot: join12(cwd, "antigravity"),
-      commandsRoot: join12(cwd, ANTIGRAVITY_COMMANDS_SOURCE_DIR),
-      runtimeSkillsRoot: join12(cwd, RUNTIME_SKILLS_SOURCE_DIR),
-      adapterDocPath: join12(cwd, "assistant-adapters", "antigravity.md")
+      pluginRoot: join14(cwd, "antigravity"),
+      commandsRoot: join14(cwd, ANTIGRAVITY_COMMANDS_SOURCE_DIR),
+      runtimeSkillsRoot: join14(cwd, RUNTIME_SKILLS_SOURCE_DIR),
+      adapterDocPath: join14(cwd, "assistant-adapters", "antigravity.md")
     };
   }
-  const installedPlugin = join12(cwd, ".antigravity", "agent-kit", "plugin.json");
-  if (existsSync12(installedPlugin)) {
+  const installedPlugin = join14(cwd, ".antigravity", "agent-kit", "plugin.json");
+  if (existsSync13(installedPlugin)) {
     return {
       mode: "installed",
-      pluginRoot: join12(cwd, ".antigravity", "agent-kit"),
-      commandsRoot: join12(cwd, ANTIGRAVITY_COMMANDS_TARGET_DIR),
-      runtimeSkillsRoot: join12(cwd, ANTIGRAVITY_RUNTIME_SKILLS_TARGET_DIR),
-      adapterDocPath: join12(cwd, ".antigravity", "agent-kit", "README.md")
+      pluginRoot: join14(cwd, ".antigravity", "agent-kit"),
+      commandsRoot: join14(cwd, ANTIGRAVITY_COMMANDS_TARGET_DIR),
+      runtimeSkillsRoot: join14(cwd, ANTIGRAVITY_RUNTIME_SKILLS_TARGET_DIR),
+      adapterDocPath: join14(cwd, ".antigravity", "agent-kit", "README.md")
     };
   }
   return null;
@@ -3158,8 +3564,8 @@ function validateAntigravityCommands(layout, findings) {
   const commandNames = /* @__PURE__ */ new Set();
   for (const command of REQUIRED_COMMANDS) {
     const relativePath = `${command}.toml`;
-    const path = join12(layout.commandsRoot, relativePath);
-    if (!existsSync12(path)) {
+    const path = join14(layout.commandsRoot, relativePath);
+    if (!existsSync13(path)) {
       findings.push({
         level: "fail",
         area: "commands",
@@ -3168,7 +3574,7 @@ function validateAntigravityCommands(layout, findings) {
       });
       continue;
     }
-    const text = readFileSync10(path, "utf8");
+    const text = readFileSync12(path, "utf8");
     addSecretFinding(relativePath, text, findings);
     const name = commandField(text, "name");
     const description = commandField(text, "description");
@@ -3225,7 +3631,7 @@ function validateAntigravityCommands(layout, findings) {
   }
 }
 function validateAntigravityPlugin(layout, findings) {
-  const pluginPath = join12(layout.pluginRoot, "plugin.json");
+  const pluginPath = join14(layout.pluginRoot, "plugin.json");
   const plugin = readJson(pluginPath);
   if (!plugin || !isRecord2(plugin)) {
     findings.push({
@@ -3266,8 +3672,8 @@ function validateAntigravityPlugin(layout, findings) {
       });
       continue;
     }
-    const resolved = join12(layout.pluginRoot, path);
-    if (!existsSync12(resolved)) {
+    const resolved = join14(layout.pluginRoot, path);
+    if (!existsSync13(resolved)) {
       findings.push({
         level: "fail",
         area: "manifest",
@@ -3276,7 +3682,7 @@ function validateAntigravityPlugin(layout, findings) {
       });
     }
   }
-  const pluginText = readFileSync10(pluginPath, "utf8");
+  const pluginText = readFileSync12(pluginPath, "utf8");
   addSecretFinding("plugin.json", pluginText, findings);
   if (Array.isArray(plugin.sourceOfTruth) && plugin.sourceOfTruth.includes("AGENTS.md") && plugin.sourceOfTruth.includes(".agent-kit/agent-roster.json")) {
     findings.push({
@@ -3294,13 +3700,13 @@ function validateAntigravityPlugin(layout, findings) {
   }
 }
 function validateRuntimeSkills(cwd, layout, findings) {
-  const canonicalSkillsRoot = existsSync12(join12(cwd, "skills")) ? join12(cwd, "skills") : join12(cwd, ".agent-kit", "skills");
+  const canonicalSkillsRoot = existsSync13(join14(cwd, "skills")) ? join14(cwd, "skills") : join14(cwd, ".agent-kit", "skills");
   const canonicalSkillNames = listFilesRecursive(canonicalSkillsRoot).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, ""));
   const runtimeSkillFiles = listFilesRecursive(layout.runtimeSkillsRoot).filter((file) => file.endsWith("/SKILL.md") || file === "SKILL.md");
   const runtimeSkillNames = runtimeSkillFiles.map((file) => file.split(/[\\/]/)[0]).filter((value) => typeof value === "string" && value.length > 0).filter((value, index, values) => values.indexOf(value) === index);
   for (const skillName of canonicalSkillNames) {
-    const runtimePath = join12(layout.runtimeSkillsRoot, skillName, "SKILL.md");
-    if (!existsSync12(runtimePath)) {
+    const runtimePath = join14(layout.runtimeSkillsRoot, skillName, "SKILL.md");
+    if (!existsSync13(runtimePath)) {
       findings.push({
         level: "fail",
         area: "runtime-skills",
@@ -3309,7 +3715,7 @@ function validateRuntimeSkills(cwd, layout, findings) {
       });
       continue;
     }
-    const text = readFileSync10(runtimePath, "utf8");
+    const text = readFileSync12(runtimePath, "utf8");
     addSecretFinding(`${skillName}/SKILL.md`, text, findings);
     if (!/^---\nname: .+\ndescription: .+\n---/m.test(text)) {
       findings.push({
@@ -3337,7 +3743,7 @@ function validateRuntimeSkills(cwd, layout, findings) {
       remediation: "Add canonical skills or remove orphan runtime wrappers."
     });
   }
-  if (canonicalSkillNames.length > 0 && canonicalSkillNames.every((skillName) => existsSync12(join12(layout.runtimeSkillsRoot, skillName, "SKILL.md")))) {
+  if (canonicalSkillNames.length > 0 && canonicalSkillNames.every((skillName) => existsSync13(join14(layout.runtimeSkillsRoot, skillName, "SKILL.md")))) {
     findings.push({
       level: "pass",
       area: "runtime-skills",
@@ -3358,7 +3764,7 @@ function validateAntigravity(cwd) {
       }
     ]);
   }
-  const adapterDoc = existsSync12(layout.adapterDocPath) ? readFileSync10(layout.adapterDocPath, "utf8") : "";
+  const adapterDoc = existsSync13(layout.adapterDocPath) ? readFileSync12(layout.adapterDocPath, "utf8") : "";
   if (!adapterDoc) {
     findings.push({
       level: "fail",
@@ -3387,7 +3793,7 @@ function validateAntigravity(cwd) {
   validateAntigravityCommands(layout, findings);
   validateRuntimeSkills(cwd, layout, findings);
   if (layout.mode === "source") {
-    const packageJson = readJson(join12(cwd, "package.json"));
+    const packageJson = readJson(join14(cwd, "package.json"));
     const files = isRecord2(packageJson) && Array.isArray(packageJson.files) ? packageJson.files : [];
     for (const requiredFile of ["antigravity", "runtime-skills", "assistant-adapters"]) {
       if (!files.includes(requiredFile)) {
@@ -3411,7 +3817,7 @@ function validateAntigravity(cwd) {
 }
 function validateBasicAdapter(cwd, target) {
   const findings = [];
-  const isPackageSource = existsSync12(join12(cwd, "package.json")) && existsSync12(join12(cwd, "src")) && existsSync12(join12(cwd, "templates"));
+  const isPackageSource = existsSync13(join14(cwd, "package.json")) && existsSync13(join14(cwd, "src")) && existsSync13(join14(cwd, "templates"));
   if (isPackageSource) {
     const sourcePaths = {
       cursor: [
@@ -3424,8 +3830,8 @@ function validateBasicAdapter(cwd, target) {
       copilot: ["assistant-adapters/github-copilot-instructions.md", "assistant-adapters/github-next-supabase.instructions.md"]
     };
     for (const relativePath of sourcePaths[target]) {
-      const path = join12(cwd, relativePath);
-      if (!existsSync12(path)) {
+      const path = join14(cwd, relativePath);
+      if (!existsSync13(path)) {
         findings.push({
           level: "fail",
           area: "adapter",
@@ -3434,7 +3840,7 @@ function validateBasicAdapter(cwd, target) {
         });
         continue;
       }
-      const text = readFileSync10(path, "utf8");
+      const text = readFileSync12(path, "utf8");
       addSecretFinding(relativePath, text, findings);
       if (!text.includes("AGENTS.md") && !text.includes("MODEL_ROUTING.md")) {
         findings.push({
@@ -3458,8 +3864,8 @@ function validateBasicAdapter(cwd, target) {
   return report(target, findings);
 }
 function readAssistantAdaptersDoc(cwd) {
-  const path = join12(cwd, "ASSISTANT_ADAPTERS.md");
-  return existsSync12(path) ? readFileSync10(path, "utf8") : "";
+  const path = join14(cwd, "ASSISTANT_ADAPTERS.md");
+  return existsSync13(path) ? readFileSync12(path, "utf8") : "";
 }
 function adaptersRowIsActive(doc, toolLabel) {
   return assistantAdapterRowIsActive(doc, toolLabel);
@@ -3468,8 +3874,8 @@ function validateInstalledIdeAdapter(cwd, target) {
   const findings = [];
   const adaptersDoc = readAssistantAdaptersDoc(cwd);
   if (target === "cursor") {
-    const rulesPath = join12(cwd, ".cursor/rules/cursor-agent-kit.mdc");
-    if (!existsSync12(rulesPath)) {
+    const rulesPath = join14(cwd, ".cursor/rules/cursor-agent-kit.mdc");
+    if (!existsSync13(rulesPath)) {
       findings.push({
         level: "fail",
         area: "adapter",
@@ -3477,10 +3883,10 @@ function validateInstalledIdeAdapter(cwd, target) {
         remediation: "Run agent-kit init or agent-kit init --activate cursor."
       });
     } else {
-      addSecretFinding(".cursor/rules/cursor-agent-kit.mdc", readFileSync10(rulesPath, "utf8"), findings);
+      addSecretFinding(".cursor/rules/cursor-agent-kit.mdc", readFileSync12(rulesPath, "utf8"), findings);
     }
-    const plannerAgent = join12(cwd, ".cursor/agents/planner.md");
-    if (existsSync12(plannerAgent)) {
+    const plannerAgent = join14(cwd, ".cursor/agents/planner.md");
+    if (existsSync13(plannerAgent)) {
       findings.push({
         level: "pass",
         area: "adapter",
@@ -3494,8 +3900,8 @@ function validateInstalledIdeAdapter(cwd, target) {
         remediation: "Run agent-kit init --activate cursor to generate council subagents from the roster."
       });
     }
-    const skillSample = join12(cwd, ".cursor/skills/planning-council/SKILL.md");
-    if (existsSync12(skillSample)) {
+    const skillSample = join14(cwd, ".cursor/skills/planning-council/SKILL.md");
+    if (existsSync13(skillSample)) {
       findings.push({
         level: "pass",
         area: "adapter",
@@ -3504,8 +3910,8 @@ function validateInstalledIdeAdapter(cwd, target) {
     }
   }
   if (target === "claude") {
-    const plannerAgent = join12(cwd, ".claude/agents/planner.md");
-    if (!existsSync12(plannerAgent)) {
+    const plannerAgent = join14(cwd, ".claude/agents/planner.md");
+    if (!existsSync13(plannerAgent)) {
       findings.push({
         level: "fail",
         area: "adapter",
@@ -3515,8 +3921,8 @@ function validateInstalledIdeAdapter(cwd, target) {
     }
   }
   if (target === "codex") {
-    const configPath = join12(cwd, ".codex/config.toml");
-    if (!existsSync12(configPath)) {
+    const configPath = join14(cwd, ".codex/config.toml");
+    if (!existsSync13(configPath)) {
       findings.push({
         level: "fail",
         area: "adapter",
@@ -3524,8 +3930,8 @@ function validateInstalledIdeAdapter(cwd, target) {
         remediation: "Run agent-kit init --activate codex."
       });
     }
-    const plannerAgent = join12(cwd, ".codex/agents/planner.toml");
-    if (existsSync12(plannerAgent)) {
+    const plannerAgent = join14(cwd, ".codex/agents/planner.toml");
+    if (existsSync13(plannerAgent)) {
       findings.push({
         level: "pass",
         area: "adapter",
@@ -3541,8 +3947,8 @@ function validateInstalledIdeAdapter(cwd, target) {
     }
   }
   if (target === "copilot") {
-    const instructions = join12(cwd, ".github/copilot-instructions.md");
-    if (!existsSync12(instructions)) {
+    const instructions = join14(cwd, ".github/copilot-instructions.md");
+    if (!existsSync13(instructions)) {
       findings.push({
         level: "fail",
         area: "adapter",
@@ -3566,7 +3972,7 @@ function validateAdapter(cwd, target = "antigravity") {
 }
 function validatePackage(cwd) {
   const findings = [];
-  const sourceMode = existsSync12(join12(cwd, "package.json")) && existsSync12(join12(cwd, "src")) && existsSync12(join12(cwd, "templates"));
+  const sourceMode = existsSync13(join14(cwd, "package.json")) && existsSync13(join14(cwd, "src")) && existsSync13(join14(cwd, "templates"));
   if (!sourceMode) {
     return report("package", [
       {
@@ -3578,9 +3984,40 @@ function validatePackage(cwd) {
     ]);
   }
   findings.push(...validateAntigravity(cwd).findings);
+  const runtimeRequired = [
+    "packages/runtime/package.json",
+    "packages/runtime/README.md",
+    "packages/runtime/CHANGELOG.md",
+    "packages/runtime/LICENSE",
+    "packages/runtime/src/index.ts"
+  ];
+  for (const target of runtimeRequired) {
+    if (!existsSync13(join14(cwd, target))) {
+      findings.push({ level: "fail", area: "runtime-package", message: `${target} is missing.` });
+    }
+  }
+  const runtimeManifest = readJson(join14(cwd, "packages", "runtime", "package.json"));
+  if (!isRecord2(runtimeManifest) || runtimeManifest.name !== "@appsforgood/agent-kit-runtime") {
+    findings.push({ level: "fail", area: "runtime-package", message: "Runtime package name is missing or invalid." });
+  } else {
+    const publishConfig = isRecord2(runtimeManifest.publishConfig) ? runtimeManifest.publishConfig : {};
+    const files = Array.isArray(runtimeManifest.files) ? runtimeManifest.files : [];
+    if (runtimeManifest.license !== "MIT") {
+      findings.push({ level: "fail", area: "runtime-package", message: "Runtime package must declare the MIT license." });
+    }
+    if (publishConfig.access !== "public" || publishConfig.provenance !== true) {
+      findings.push({ level: "fail", area: "runtime-package", message: "Runtime package must require public provenance publishing." });
+    }
+    for (const required of ["dist", "README.md", "CHANGELOG.md", "LICENSE"]) {
+      if (!files.includes(required)) findings.push({ level: "fail", area: "runtime-package", message: `Runtime package files omits ${required}.` });
+    }
+    if (findings.every((finding) => finding.area !== "runtime-package" || finding.level !== "fail")) {
+      findings.push({ level: "pass", area: "runtime-package", message: "Runtime package metadata and public artifacts are complete." });
+    }
+  }
   for (const doc of ["README.md", "DOCS.md", "SPEC.md", "DECISIONS.md", "QUALITY_GATES.md", "TESTING.md", "UPGRADE.md"]) {
-    const path = join12(cwd, doc);
-    const text = existsSync12(path) ? readFileSync10(path, "utf8") : "";
+    const path = join14(cwd, doc);
+    const text = existsSync13(path) ? readFileSync12(path, "utf8") : "";
     const lower = text.toLowerCase();
     if (!lower.includes("antigravity") && !lower.includes("runtime command") && !lower.includes("runtime adapter")) {
       findings.push({
@@ -3597,7 +4034,7 @@ function validatePackage(cwd) {
     "examples/next-supabase-installed/.agent-kit/manifest.json",
     "examples/next-supabase-installed/audit-output.json"
   ]) {
-    if (!existsSync12(join12(cwd, examplePath))) {
+    if (!existsSync13(join14(cwd, examplePath))) {
       findings.push({
         level: "fail",
         area: "examples",
@@ -3606,7 +4043,7 @@ function validatePackage(cwd) {
       });
     }
   }
-  const auditReport = createAuditReport(cwd);
+  const auditReport = createAuditReport(cwd, { packageSource: true });
   if (auditReport.summary.fail > 0) {
     findings.push({
       level: "fail",
@@ -3631,118 +4068,227 @@ function validatePackage(cwd) {
   return report("package", findings);
 }
 
-// src/install/diff.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { join as join13 } from "path";
-function statusForTextFile(target, template) {
-  if (!existsSync13(target)) return "missing";
-  const targetHash = sha256(readFileSync11(target, "utf8"));
-  const templateHash = sha256(readFileSync11(template, "utf8"));
-  return targetHash === templateHash ? "unchanged" : "changed";
+// src/install/audit-v2.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { join as join15 } from "path";
+function fallbackRuleId(finding) {
+  const area = finding.area.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "general";
+  const digest = createHash2("sha256").update(`${finding.area}\0${finding.message}`).digest("hex").slice(0, 12);
+  return `legacy.${area}.${digest}`;
+}
+function loadSuppressions(cwd) {
+  const path = join15(cwd, ".agent-kit", "overrides.json");
+  if (!existsSync14(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    return parsed.auditRules ?? {};
+  } catch {
+    return {};
+  }
 }
-function diffProject(cwd, stack = "next-supabase") {
-  const packageRoot = findPackageRoot();
-  const templateRoot = join13(packageRoot, "templates", stack);
-  const libraryFolders = {
-    missing: [],
-    present: [],
-    willRefresh: [...LIBRARY_FOLDERS]
+function validSuppression(suppression, now) {
+  if (!suppression?.reason?.trim() || !suppression.owner?.trim() || !suppression.reviewedAt?.trim()) return false;
+  if (suppression.expiresAt && Date.parse(suppression.expiresAt) <= now) return false;
+  return true;
+}
+function createAuditReportV2(cwd) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const suppressions = loadSuppressions(cwd);
+  const findings = auditProject(cwd).map((finding) => {
+    const ruleId = finding.ruleId ?? fallbackRuleId(finding);
+    const suppression = suppressions[ruleId];
+    const suppressed = finding.level !== "pass" && validSuppression(suppression, Date.now());
+    return {
+      ...finding,
+      ruleId,
+      ruleVersion: finding.ruleVersion ?? "1.0.0",
+      confidence: finding.confidence ?? "low",
+      evidence: finding.evidence ?? [],
+      ...suppressed ? { suppressed: true, suppressionReason: suppression.reason } : {}
+    };
+  });
+  const activeFindings = findings.filter((finding) => !finding.suppressed);
+  const summary2 = { pass: 0, warn: 0, fail: 0, suppressed: findings.length - activeFindings.length };
+  for (const finding of activeFindings) summary2[finding.level] += 1;
+  return {
+    schemaVersion: 2,
+    generatedAt,
+    tool: { name: "agent-kit", version: PACKAGE_VERSION },
+    root: ".",
+    summary: summary2,
+    readiness: createAuditReadiness(activeFindings, summary2),
+    findings
   };
-  const result = {
-    missing: [],
-    unchanged: [],
-    changed: [],
-    agentRoster: "missing",
-    modelRouting: "missing",
-    libraryFolders,
-    preview: {
-      wouldCreate: [],
-      wouldWriteConflicts: [],
-      wouldRefreshLibraryFolders: [...LIBRARY_FOLDERS],
-      wouldCreateAgentRoster: false,
-      wouldWriteAgentRosterConflict: false,
-      wouldCreateModelRouting: false,
-      wouldWriteModelRoutingConflict: false
-    }
+}
+function auditReportToSarif(report2) {
+  const rules = [...new Map(report2.findings.map((finding) => [finding.ruleId, finding])).values()].map((finding) => ({
+    id: finding.ruleId,
+    name: finding.ruleId,
+    shortDescription: { text: finding.message },
+    ...finding.helpUri ? { helpUri: finding.helpUri } : {},
+    properties: { area: finding.area, ruleVersion: finding.ruleVersion, confidence: finding.confidence, fixable: Boolean(finding.fixable) }
+  }));
+  const results = report2.findings.filter((finding) => finding.level !== "pass").map((finding) => {
+    const evidence = finding.evidence.find((item) => item.path);
+    const locations = evidence?.path ? [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: evidence.path.replace(/\\/g, "/") },
+          ...evidence.line ? { region: { startLine: evidence.line, ...evidence.column ? { startColumn: evidence.column } : {} } } : {}
+        }
+      }
+    ] : [];
+    return {
+      ruleId: finding.ruleId,
+      level: finding.level === "fail" ? "error" : "warning",
+      message: { text: finding.message },
+      ...locations.length > 0 ? { locations } : {},
+      ...finding.suppressed ? { suppressions: [{ kind: "external", justification: finding.suppressionReason }] } : {},
+      properties: { area: finding.area, confidence: finding.confidence, remediation: finding.remediation ?? "" }
+    };
+  });
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "agent-kit",
+            version: report2.tool.version,
+            informationUri: "https://github.com/lukey662/agentsandskills",
+            rules
+          }
+        },
+        results
+      }
+    ]
   };
-  for (const doc of ROOT_DOCS) {
-    const target = join13(cwd, doc);
-    const template = join13(templateRoot, doc);
-    const status = statusForTextFile(target, template);
-    if (status === "missing") {
-      result.missing.push(doc);
-      result.preview.wouldCreate.push(doc);
-      continue;
-    }
-    if (status === "unchanged") result.unchanged.push(doc);
-    else {
-      result.changed.push(doc);
-      result.preview.wouldWriteConflicts.push(doc);
-    }
-  }
-  result.agentRoster = statusForTextFile(join13(cwd, DEFAULT_AGENT_ROSTER_TARGET), join13(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE));
-  if (result.agentRoster === "missing") {
-    result.preview.wouldCreate.push(DEFAULT_AGENT_ROSTER_TARGET);
-    result.preview.wouldCreateAgentRoster = true;
-  }
-  if (result.agentRoster === "changed") {
-    result.preview.wouldWriteConflicts.push(DEFAULT_AGENT_ROSTER_TARGET);
-    result.preview.wouldWriteAgentRosterConflict = true;
-  }
-  result.modelRouting = statusForTextFile(join13(cwd, DEFAULT_MODEL_ROUTING_TARGET), join13(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE));
-  if (result.modelRouting === "missing") {
-    result.preview.wouldCreate.push(DEFAULT_MODEL_ROUTING_TARGET);
-    result.preview.wouldCreateModelRouting = true;
-  }
-  if (result.modelRouting === "changed") {
-    result.preview.wouldWriteConflicts.push(DEFAULT_MODEL_ROUTING_TARGET);
-    result.preview.wouldWriteModelRoutingConflict = true;
-  }
-  for (const folder of LIBRARY_FOLDERS) {
-    const target = join13(cwd, ".agent-kit", folder);
-    if (existsSync13(target)) libraryFolders.present.push(folder);
-    else libraryFolders.missing.push(folder);
-  }
-  return result;
 }
 
-// src/install/update.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
-import { join as join14, relative as relative2 } from "path";
-function planFileUpdate(cwd, input) {
-  const sourceContent = readFileSync12(input.sourcePath, "utf8");
+// src/install/diff.ts
+import { existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
+
+// src/install/file-update-plan.ts
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+function planFileUpdate(input) {
+  const sourceContent = readFileSync14(input.sourcePath, "utf8");
   const sourceHash = sha256(sourceContent);
-  const targetPath = resolveInside(cwd, input.target);
-  if (!existsSync14(targetPath)) {
-    return { target: input.target, action: "created", reason: "File is missing locally.", sourceContent };
+  if (!existsSync15(input.targetPath)) {
+    return { target: input.target, action: "created", reason: "File is missing locally.", sourceContent, sourceHash };
   }
-  const localHash = sha256(readFileSync12(targetPath, "utf8"));
+  const localContent = readFileSync14(input.targetPath, "utf8");
+  const localHash = sha256(localContent);
   if (localHash === sourceHash) {
-    return { target: input.target, action: "unchanged", reason: "File already matches the current template.", sourceContent };
+    return {
+      target: input.target,
+      action: "unchanged",
+      reason: "File already matches the current package asset.",
+      sourceContent,
+      sourceHash,
+      localContent
+    };
   }
   if (input.installedHash && localHash === input.installedHash) {
-    return { target: input.target, action: "updated", reason: "File was unmodified since install; applied the newer template.", sourceContent };
+    return {
+      target: input.target,
+      action: "updated",
+      reason: "File was unmodified since install; applied the newer package asset.",
+      sourceContent,
+      sourceHash,
+      localContent
+    };
   }
   if (input.force) {
-    return { target: input.target, action: "overwritten", reason: "Local changes overwritten because --force was used.", sourceContent };
+    return {
+      target: input.target,
+      action: "overwritten",
+      reason: "Local changes will be overwritten because --force was used.",
+      sourceContent,
+      sourceHash,
+      localContent
+    };
   }
   if (input.installedHash && input.installedHash === sourceHash) {
-    return { target: input.target, action: "kept-local", reason: "File is locally customized and the template has not changed.", sourceContent };
+    return {
+      target: input.target,
+      action: "kept-local",
+      reason: "File is locally customized and the package asset has not changed.",
+      sourceContent,
+      sourceHash,
+      localContent
+    };
   }
   return {
     target: input.target,
     action: "conflict",
-    reason: "File is locally customized and the bundled template changed; review the conflict copy.",
-    sourceContent
+    reason: "File is locally customized and the package asset changed; review the proposed content.",
+    sourceContent,
+    sourceHash,
+    localContent
   };
 }
-function writeConflictCopy(cwd, target, content) {
-  const conflictRoot = join14(cwd, ".agent-kit", "conflicts");
-  const safeName = `${Date.now()}-${target.replace(/[^a-zA-Z0-9_.-]/g, "_")}`;
-  const conflictPath = join14(conflictRoot, safeName);
-  writeText(conflictPath, content);
-  return relative2(cwd, conflictPath).replace(/\\/g, "/");
+
+// src/install/diff.ts
+function diffStatus(plan) {
+  if (plan.action === "created") return "missing";
+  if (plan.action === "unchanged") return "unchanged";
+  return "changed";
+}
+function diffProject(cwd, stack = "next-supabase") {
+  const packageRoot = findPackageRoot();
+  const manifest = readManifest(cwd);
+  const assets = listManagedAssets(packageRoot, stack);
+  const plans = assets.map((asset) => ({
+    asset,
+    plan: planFileUpdate({
+      target: asset.target,
+      sourcePath: asset.sourcePath,
+      targetPath: resolveInside(cwd, asset.target),
+      installedHash: manifest?.assetHashes?.[asset.target] ?? manifest?.templateHashes?.[asset.target],
+      force: false
+    })
+  }));
+  const byTarget = new Map(plans.map(({ asset, plan }) => [asset.target, { asset, plan }]));
+  const rootPlans = ROOT_DOCS.map((target) => byTarget.get(target)?.plan).filter((plan) => Boolean(plan));
+  const agentPlan = byTarget.get(DEFAULT_AGENT_ROSTER_TARGET)?.plan;
+  const modelPlan = byTarget.get(DEFAULT_MODEL_ROUTING_TARGET)?.plan;
+  const mutatingActions = /* @__PURE__ */ new Set(["created", "updated", "overwritten"]);
+  const refreshedFolders = [
+    ...new Set(plans.filter(({ asset, plan }) => asset.libraryFolder && mutatingActions.has(plan.action)).map(({ asset }) => asset.libraryFolder))
+  ].sort();
+  const missingFolders = LIBRARY_FOLDERS.filter((folder) => !existsSync16(join16(cwd, ".agent-kit", folder)));
+  const presentFolders = LIBRARY_FOLDERS.filter((folder) => !missingFolders.includes(folder));
+  const wouldCreate = plans.filter(({ plan }) => plan.action === "created").map(({ plan }) => plan.target);
+  const wouldWriteConflicts = plans.filter(({ plan }) => plan.action === "conflict").map(({ plan }) => plan.target);
+  return {
+    missing: rootPlans.filter((plan) => plan.action === "created").map((plan) => plan.target),
+    unchanged: rootPlans.filter((plan) => plan.action === "unchanged").map((plan) => plan.target),
+    changed: rootPlans.filter((plan) => plan.action !== "created" && plan.action !== "unchanged").map((plan) => plan.target),
+    agentRoster: agentPlan ? diffStatus(agentPlan) : "missing",
+    modelRouting: modelPlan ? diffStatus(modelPlan) : "missing",
+    libraryFolders: {
+      missing: missingFolders,
+      present: presentFolders,
+      willRefresh: refreshedFolders
+    },
+    preview: {
+      wouldCreate,
+      wouldWriteConflicts,
+      wouldRefreshLibraryFolders: refreshedFolders,
+      wouldCreateAgentRoster: agentPlan?.action === "created",
+      wouldWriteAgentRosterConflict: agentPlan?.action === "conflict",
+      wouldCreateModelRouting: modelPlan?.action === "created",
+      wouldWriteModelRoutingConflict: modelPlan?.action === "conflict"
+    }
+  };
 }
+
+// src/install/update.ts
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
 function updateProject(options) {
   const cwd = options.cwd;
   const force = Boolean(options.force);
@@ -3755,14 +4301,14 @@ function updateProject(options) {
     const initResult = initProject({ cwd, force });
     const files2 = [
       ...initResult.copied.map((target) => ({ target, action: "created", reason: "Installed by init fallback." })),
-      ...initResult.unchanged.map((target) => ({ target, action: "unchanged", reason: "Already matched the template." })),
+      ...initResult.unchanged.map((target) => ({ target, action: "unchanged", reason: "Already matched the package asset." })),
       ...initResult.overwritten.map((target) => ({ target, action: "overwritten", reason: "Overwritten by init --force fallback." })),
       ...initResult.conflicts.map((entry) => {
         const [target, conflictPath] = entry.split(" -> ");
         return {
           target: target ?? entry,
           action: "conflict",
-          reason: "Local file differed from the template during init fallback.",
+          reason: "Local file differed from the package asset during init fallback.",
           ...conflictPath ? { conflictPath } : {}
         };
       })
@@ -3777,66 +4323,53 @@ function updateProject(options) {
   }
   const packageRoot = findPackageRoot();
   const stack = manifest.stack ?? "next-supabase";
-  const templateRoot = join14(packageRoot, "templates", stack);
-  if (!existsSync14(templateRoot)) {
-    throw new Error(`Unsupported stack profile in manifest: ${stack}`);
-  }
-  const files = [];
-  const templateHashes = {};
-  const plans = [];
-  for (const doc of ROOT_DOCS) {
-    const sourcePath = join14(templateRoot, doc);
-    templateHashes[doc] = sha256(readFileSync12(sourcePath, "utf8"));
-    plans.push(
-      planFileUpdate(cwd, {
-        target: doc,
-        sourcePath,
-        installedHash: manifest.templateHashes?.[doc],
-        force
-      })
-    );
-  }
-  for (const adapter2 of CURSOR_ADAPTER_FILES) {
-    plans.push(
-      planFileUpdate(cwd, {
-        target: adapter2.target,
-        sourcePath: join14(packageRoot, adapter2.source),
-        installedHash: void 0,
-        force
-      })
-    );
-  }
-  plans.push(
-    planFileUpdate(cwd, {
-      target: DEFAULT_AGENT_ROSTER_TARGET,
-      sourcePath: join14(packageRoot, DEFAULT_AGENT_ROSTER_SOURCE),
-      installedHash: void 0,
-      force
-    }),
-    planFileUpdate(cwd, {
-      target: DEFAULT_MODEL_ROUTING_TARGET,
-      sourcePath: join14(packageRoot, DEFAULT_MODEL_ROUTING_SOURCE),
-      installedHash: void 0,
+  const templateRoot = join17(packageRoot, "templates", stack);
+  if (!existsSync17(templateRoot)) throw new Error(`Unsupported stack profile in manifest: ${stack}`);
+  const assets = listManagedAssets(packageRoot, stack);
+  const plans = assets.map(
+    (asset) => planFileUpdate({
+      target: asset.target,
+      sourcePath: asset.sourcePath,
+      targetPath: resolveInside(cwd, asset.target),
+      installedHash: manifest.assetHashes?.[asset.target] ?? manifest.templateHashes?.[asset.target],
       force
     })
   );
+  const files = [];
   for (const plan of plans) {
-    const { sourceContent, ...fileResult } = plan;
+    const result = { target: plan.target, action: plan.action, reason: plan.reason };
     if (!dryRun) {
       if (plan.action === "created" || plan.action === "updated" || plan.action === "overwritten") {
-        writeText(resolveInside(cwd, plan.target), sourceContent);
+        writeText(resolveInside(cwd, plan.target), plan.sourceContent);
       } else if (plan.action === "conflict") {
-        fileResult.conflictPath = writeConflictCopy(cwd, plan.target, sourceContent);
+        const proposal = writeConflictProposal(cwd, plan.target, plan.sourceContent, {
+          currentContent: plan.localContent,
+          reason: plan.reason,
+          sourceVersion: PACKAGE_VERSION
+        });
+        result.conflictPath = proposal.conflictPath;
       }
     }
-    files.push(fileResult);
+    files.push(result);
+  }
+  const currentTargets = new Set(assets.map((asset) => asset.target));
+  for (const staleTarget of Object.keys(manifest.assetHashes ?? {}).filter((target) => !currentTargets.has(target)).sort()) {
+    if (!existsSync17(resolveInside(cwd, staleTarget))) continue;
+    files.push({
+      target: staleTarget,
+      action: "kept-local",
+      reason: "The asset is no longer shipped; it was retained for explicit manual removal."
+    });
   }
+  const refreshedFolders = [
+    ...new Set(
+      assets.filter((asset, index) => asset.libraryFolder && ["created", "updated", "overwritten"].includes(plans[index]?.action ?? "")).map((asset) => asset.libraryFolder)
+    )
+  ].sort();
   if (!dryRun) {
-    ensureDir(join14(cwd, ".agent-kit"));
-    for (const folder of LIBRARY_FOLDERS) {
-      copyDirectory(join14(packageRoot, folder), join14(cwd, ".agent-kit", folder));
-    }
+    const assetHashes = hashManagedAssets(assets);
     const updatedManifest = {
+      schemaVersion: 2,
       packageName: PACKAGE_NAME,
       packageVersion: PACKAGE_VERSION,
       stack,
@@ -3844,17 +4377,18 @@ function updateProject(options) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       docs: [...ROOT_DOCS],
       libraryFolders: [...LIBRARY_FOLDERS],
-      agentRoster: DEFAULT_AGENT_ROSTER_TARGET,
-      modelRouting: DEFAULT_MODEL_ROUTING_TARGET,
-      templateHashes
+      agentRoster: manifest.agentRoster ?? DEFAULT_AGENT_ROSTER_TARGET,
+      modelRouting: manifest.modelRouting ?? DEFAULT_MODEL_ROUTING_TARGET,
+      templateHashes: Object.fromEntries(ROOT_DOCS.map((doc) => [doc, assetHashes[doc] ?? ""])),
+      assetHashes
     };
-    writeText(join14(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(updatedManifest, null, 2)}
+    writeText(join17(cwd, ".agent-kit", "manifest.json"), `${JSON.stringify(updatedManifest, null, 2)}
 `);
   }
   return {
     dryRun,
     files,
-    libraryFoldersRefreshed: [...LIBRARY_FOLDERS],
+    libraryFoldersRefreshed: refreshedFolders,
     manifestPath: ".agent-kit/manifest.json",
     summary: summarize(files)
   };
@@ -3874,8 +4408,8 @@ function summarize(files) {
 
 // src/research/discover.ts
 import { Octokit } from "@octokit/rest";
-import { readFileSync as readFileSync13 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
 
 // src/research/config.ts
 import { z as z2 } from "zod";
@@ -3900,8 +4434,8 @@ var researchConfigSchema = z2.object({
 // src/research/discover.ts
 async function discoverRepos(options) {
   const packageRoot = findPackageRoot();
-  const configPath = join15(packageRoot, "research", "scan-config.json");
-  const config = researchConfigSchema.parse(JSON.parse(readFileSync13(configPath, "utf8")));
+  const configPath = join18(packageRoot, "research", "scan-config.json");
+  const config = researchConfigSchema.parse(JSON.parse(readFileSync15(configPath, "utf8")));
   const token = options.token ?? process.env.GITHUB_TOKEN;
   if (!token) {
     throw new Error("GITHUB_TOKEN is required for GitHub API research discovery.");
@@ -3962,20 +4496,20 @@ async function discoverRepos(options) {
     }
   }
   const candidates = [...deduped.values()].slice(0, maxRepos);
-  const output = options.output ?? join15(options.cwd, "research", "repo-candidates.json");
+  const output = options.output ?? join18(options.cwd, "research", "repo-candidates.json");
   writeText(output, `${JSON.stringify(candidates, null, 2)}
 `);
   return candidates;
 }
 
 // src/research/scan.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync2, readFileSync as readFileSync15, rmSync } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync2, readFileSync as readFileSync17, rmSync as rmSync2 } from "fs";
+import { join as join20 } from "path";
 import { simpleGit } from "simple-git";
 
 // src/research/analyze.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
+import { join as join19 } from "path";
 function normalizeRelativePath(file) {
   return file.replace(/\\/g, "/");
 }
@@ -3983,8 +4517,8 @@ function hasFile(files, matcher) {
   return files.some((file) => matcher.test(normalizeRelativePath(file)));
 }
 function fileText(root, file) {
-  const path = join16(root, file);
-  return existsSync15(path) ? readFileSync14(path, "utf8") : "";
+  const path = join19(root, file);
+  return existsSync18(path) ? readFileSync16(path, "utf8") : "";
 }
 function textIncludes(root, files, matcher, terms) {
   const lowerTerms = terms.map((term) => term.toLowerCase());
@@ -4115,34 +4649,34 @@ ${finding.impactOnKit.map((item) => `- ${item}`).join("\n")}
 `;
 }
 async function scanRepos(options) {
-  const candidatesPath = options.candidatesPath ?? join17(options.cwd, "research", "repo-candidates.json");
-  if (!existsSync16(candidatesPath)) {
+  const candidatesPath = options.candidatesPath ?? join20(options.cwd, "research", "repo-candidates.json");
+  if (!existsSync19(candidatesPath)) {
     throw new Error(`Candidates file not found: ${candidatesPath}`);
   }
-  const candidates = JSON.parse(readFileSync15(candidatesPath, "utf8"));
-  const workdir = options.workdir ?? join17(options.cwd, "research", "workdir");
+  const candidates = JSON.parse(readFileSync17(candidatesPath, "utf8"));
+  const workdir = options.workdir ?? join20(options.cwd, "research", "workdir");
   mkdirSync2(workdir, { recursive: true });
-  mkdirSync2(join17(options.cwd, "research", "findings"), { recursive: true });
+  mkdirSync2(join20(options.cwd, "research", "findings"), { recursive: true });
   const findings = [];
   const git = simpleGit();
   for (const candidate of candidates) {
     const repoSlug = candidate.fullName.replace("/", "__");
-    const repoPath = join17(workdir, repoSlug);
-    if (existsSync16(repoPath)) rmSync(repoPath, { recursive: true, force: true });
+    const repoPath = join20(workdir, repoSlug);
+    if (existsSync19(repoPath)) rmSync2(repoPath, { recursive: true, force: true });
     await git.raw(["clone", "--depth", "1", candidate.htmlUrl, repoPath]);
     const finding = analyzeRepository(candidate, repoPath);
     findings.push(finding);
-    writeText(join17(options.cwd, "research", "findings", `${repoSlug}.md`), findingToMarkdown(finding));
+    writeText(join20(options.cwd, "research", "findings", `${repoSlug}.md`), findingToMarkdown(finding));
     if (!options.keepClones) {
-      rmSync(repoPath, { recursive: true, force: true });
+      rmSync2(repoPath, { recursive: true, force: true });
     }
   }
   return findings;
 }
 
 // src/research/summarize.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16, readdirSync as readdirSync3 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync3 } from "fs";
+import { join as join21 } from "path";
 var SUMMARY_TARGETS = {
   "nextjs-patterns": {
     title: "Next.js Patterns",
@@ -4245,12 +4779,12 @@ function renderRepoList(findings, scoreKeys) {
   return findings.slice().sort((a, b) => scoreFor(b, scoreKeys) - scoreFor(a, scoreKeys) || b.totalScore - a.totalScore || b.stars - a.stars).slice(0, 12).map((finding) => `- ${finding.fullName} (${finding.category}) - focus score ${scoreFor(finding, scoreKeys)}, total ${finding.totalScore}/${maxTotalScore}`).join("\n");
 }
 function summarizeFindings(cwd) {
-  const findingsDir = join18(cwd, "research", "findings");
-  if (!existsSync17(findingsDir)) {
+  const findingsDir = join21(cwd, "research", "findings");
+  if (!existsSync20(findingsDir)) {
     throw new Error("No research/findings directory exists. Run agent-kit research scan first.");
   }
   const findingFiles = readdirSync3(findingsDir).filter((file) => file.endsWith(".md"));
-  const findings = findingFiles.map((file) => parseFinding(file, readFileSync16(join18(findingsDir, file), "utf8"))).filter((finding) => finding !== null);
+  const findings = findingFiles.map((file) => parseFinding(file, readFileSync18(join21(findingsDir, file), "utf8"))).filter((finding) => finding !== null);
   const categoryCounts = countBy(findings.map((finding) => finding.category));
   const outputs = [];
   const overview = `# Research Scan Overview
@@ -4269,13 +4803,13 @@ ${countBy(findings.flatMap((finding) => finding.strongPractices)).slice(0, 12).m
 ## Most Repeated Gaps
 ${countBy(findings.flatMap((finding) => finding.weakPractices)).slice(0, 12).map(([practice, count]) => `- ${practice} (${count})`).join("\n")}
 `;
-  const overviewPath = join18(cwd, "research", "summaries", "scan-overview.md");
+  const overviewPath = join21(cwd, "research", "summaries", "scan-overview.md");
   writeText(overviewPath, overview);
   outputs.push(overviewPath);
   for (const [target, config] of Object.entries(SUMMARY_TARGETS)) {
     const categories = config.categories;
     const scopedFindings = findings.filter((finding) => categories.includes(finding.category));
-    const path = join18(cwd, "research", "summaries", `${target}.md`);
+    const path = join21(cwd, "research", "summaries", `${target}.md`);
     const summary2 = `# ${config.title}
 
 Generated from ${scopedFindings.length} relevant repository findings.
@@ -4316,7 +4850,7 @@ Review the generated research summaries, then convert repeated best practices in
 
 Do not copy source code from scanned repositories. Adopt only generalized practices with clear rationale.
 `;
-  const path = join18(cwd, "research", "proposed-updates.md");
+  const path = join21(cwd, "research", "proposed-updates.md");
   writeText(path, output);
   return path;
 }
@@ -4433,8 +4967,9 @@ function proposeCorrectionUpstream(cwd, id) {
 }
 
 // src/studio/session.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join19 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync21, readFileSync as readFileSync19, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join22 } from "path";
 function sessionDir(sessionId) {
   return `${COUNCIL_SESSIONS_DIR}/${safeSlug(sessionId)}`;
 }
@@ -4450,6 +4985,9 @@ function indexPath(sessionId) {
 function transcriptPath(sessionId) {
   return `${sessionDir(sessionId)}/transcript.md`;
 }
+function sessionLockPath(sessionId) {
+  return `${sessionDir(sessionId)}/.session.lock`;
+}
 function readDefaultWorkflowOutputs(cwd, workflowId) {
   const roster = readJsonFile(cwd, DEFAULT_AGENT_ROSTER_TARGET);
   const workflow = roster?.workflows?.find((item) => item.id === workflowId);
@@ -4461,7 +4999,7 @@ function readDefaultWorkflowOutputs(cwd, workflowId) {
 function startSession(cwd, options) {
   ensureStudioDirs(cwd);
   const datePrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const sessionId = safeSlug(`${datePrefix}-${options.title}`);
+  const sessionId = safeSlug(`${datePrefix}-${options.title}-${randomUUID2().slice(0, 8)}`);
   const now = nowIso();
   const workflowId = options.workflowId ?? "planning";
   const session2 = {
@@ -4491,9 +5029,9 @@ function startSession(cwd, options) {
   return { sessionId, sessionPath: sessionDir(sessionId) };
 }
 function listSessions(cwd) {
-  const root = join19(cwd, COUNCIL_SESSIONS_DIR);
-  if (!existsSync18(root)) return [];
-  return readdirSync4(root).filter((entry) => entry !== "active").map((entry) => join19(root, entry, "session.json")).filter((path) => existsSync18(path) && statSync2(path).isFile()).map((path) => StudioSessionContract.parse(JSON.parse(readFileSync17(path, "utf8")))).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const root = join22(cwd, COUNCIL_SESSIONS_DIR);
+  if (!existsSync21(root)) return [];
+  return readdirSync4(root).filter((entry) => entry !== "active").map((entry) => join22(root, entry, "session.json")).filter((path) => existsSync21(path) && statSync4(path).isFile()).map((path) => StudioSessionContract.parse(JSON.parse(readFileSync19(path, "utf8")))).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 function getActiveSessionId(cwd) {
   const active = readTextFile(cwd, ACTIVE_SESSION_FILE)?.trim();
@@ -4519,7 +5057,18 @@ function writeSession(cwd, session2) {
   writeJsonFile(cwd, sessionJsonPath(session2.sessionId), StudioSessionContract.parse(session2));
 }
 function appendSessionEvent(cwd, sessionId, event) {
-  const parsed = SessionEventContract.parse(redactEvent(event));
+  return withFileLock(cwd, sessionLockPath(sessionId), () => appendSessionEventUnlocked(cwd, sessionId, event));
+}
+function appendSessionEventUnlocked(cwd, sessionId, event) {
+  const existingEvents = readSessionEvents(cwd, sessionId);
+  const sequence = existingEvents.reduce((highest, item) => Math.max(highest, item.sequence ?? 0), 0) + 1;
+  const parsed = SessionEventContract.parse(
+    redactEvent({
+      ...event,
+      eventId: event.eventId ?? randomUUID2(),
+      sequence: event.sequence ?? sequence
+    })
+  );
   appendJsonLine(cwd, eventsPath(sessionId), parsed);
   const session2 = readSession(cwd, sessionId);
   const updated = {
@@ -4548,7 +5097,10 @@ function redactEvent(event) {
   };
 }
 function recordNote(cwd, agentId, text) {
-  return appendSessionEvent(cwd, getActiveSessionId(cwd), { type: "agent_message", createdAt: nowIso(), agentId, text });
+  return recordSessionNote(cwd, getActiveSessionId(cwd), agentId, text);
+}
+function recordSessionNote(cwd, sessionId, agentId, text) {
+  return appendSessionEvent(cwd, sessionId, { type: "agent_message", createdAt: nowIso(), agentId, text });
 }
 function recordDecision(cwd, agentId, decision, risk) {
   return appendSessionEvent(cwd, getActiveSessionId(cwd), {
@@ -4609,22 +5161,24 @@ function recordRequiredOutput(cwd, name, status, evidence) {
   const trimmedName = name.trim();
   if (!trimmedName) throw new Error("Required output name is required.");
   const sessionId = getActiveSessionId(cwd);
-  const session2 = readSession(cwd, sessionId);
-  const now = nowIso();
-  const output = {
-    name: trimmedName,
-    status,
-    ...evidence ? { evidence: redactSensitive(evidence) } : {}
-  };
-  const outputIndex = session2.requiredOutputs.findIndex((item) => item.name === trimmedName);
-  const requiredOutputs = outputIndex === -1 ? [...session2.requiredOutputs, output] : session2.requiredOutputs.map((item, index) => index === outputIndex ? { ...item, ...output } : item);
-  writeSession(cwd, { ...session2, requiredOutputs, updatedAt: now });
-  return appendSessionEvent(cwd, sessionId, {
-    type: "required_output_updated",
-    createdAt: now,
-    outputName: trimmedName,
-    outputStatus: status,
-    ...evidence ? { evidence: [evidence] } : {}
+  return withFileLock(cwd, sessionLockPath(sessionId), () => {
+    const session2 = readSession(cwd, sessionId);
+    const now = nowIso();
+    const output = {
+      name: trimmedName,
+      status,
+      ...evidence ? { evidence: redactSensitive(evidence) } : {}
+    };
+    const outputIndex = session2.requiredOutputs.findIndex((item) => item.name === trimmedName);
+    const requiredOutputs = outputIndex === -1 ? [...session2.requiredOutputs, output] : session2.requiredOutputs.map((item, index) => index === outputIndex ? { ...item, ...output } : item);
+    writeSession(cwd, { ...session2, requiredOutputs, updatedAt: now });
+    return appendSessionEventUnlocked(cwd, sessionId, {
+      type: "required_output_updated",
+      createdAt: now,
+      outputName: trimmedName,
+      outputStatus: status,
+      ...evidence ? { evidence: [evidence] } : {}
+    });
   });
 }
 function closeSession(cwd, status) {
@@ -4641,14 +5195,16 @@ function renderActiveSession(cwd) {
   return renderSession(cwd, getActiveSessionId(cwd));
 }
 function renderSession(cwd, sessionId) {
-  const session2 = readSession(cwd, sessionId);
-  const events = readSessionEvents(cwd, sessionId);
-  const renderedAt = nowIso();
-  const updated = { ...session2, renderedAt, updatedAt: renderedAt };
-  writeTextFile(cwd, indexPath(sessionId), renderSessionIndex(updated, events));
-  writeTextFile(cwd, transcriptPath(sessionId), renderSessionTranscript(updated, events));
-  writeSession(cwd, updated);
-  return { sessionId, sessionPath: sessionDir(sessionId) };
+  return withFileLock(cwd, sessionLockPath(sessionId), () => {
+    const session2 = readSession(cwd, sessionId);
+    const events = readSessionEvents(cwd, sessionId);
+    const renderedAt = nowIso();
+    const updated = { ...session2, renderedAt, updatedAt: renderedAt };
+    writeTextFile(cwd, indexPath(sessionId), renderSessionIndex(updated, events));
+    writeTextFile(cwd, transcriptPath(sessionId), renderSessionTranscript(updated, events));
+    writeSession(cwd, updated);
+    return { sessionId, sessionPath: sessionDir(sessionId) };
+  });
 }
 function renderSessionIndex(session2, events) {
   const handoffs = events.filter((event) => event.type === "handoff");
@@ -4707,7 +5263,7 @@ ${verification.map((event) => `| ${escapeMarkdownTableCell(event.command)} | ${e
 ## Next Actions
 
 ${renderNextActions(session2, verification)}
-`;
+`.trimEnd() + "\n";
 }
 function renderDecisionRow(event) {
   if (event.type === "handoff") {
@@ -4762,7 +5318,7 @@ ${rows.join("\n")}`;
 Generated from \`${sessionDir(session2.sessionId)}/events.jsonl\`.
 
 ${sections || "No events recorded."}
-`;
+`.trimEnd() + "\n";
 }
 
 // src/studio/export.ts
@@ -5025,19 +5581,19 @@ function safeJsonForHtml(value) {
 }
 
 // src/studio/setup-browser.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function openBrowser(url) {
   const platform = process.platform;
   try {
     if (platform === "darwin") {
-      execFileSync("open", [url], { stdio: "ignore" });
+      execFileSync2("open", [url], { stdio: "ignore" });
       return;
     }
     if (platform === "win32") {
-      execFileSync("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+      execFileSync2("cmd", ["/c", "start", "", url], { stdio: "ignore" });
       return;
     }
-    execFileSync("xdg-open", [url], { stdio: "ignore" });
+    execFileSync2("xdg-open", [url], { stdio: "ignore" });
   } catch {
     console.log(`Open this URL in your browser: ${url}`);
   }
@@ -5049,10 +5605,10 @@ async function promptStartSetup(defaultYes = true) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const question = defaultYes ? "Start setup wizard now? [Y/n] " : "Start setup wizard now? [y/N] ";
-  const answer = await new Promise((resolve3) => {
+  const answer = await new Promise((resolve4) => {
     rl.question(question, (value) => {
       rl.close();
-      resolve3(value.trim().toLowerCase());
+      resolve4(value.trim().toLowerCase());
     });
   });
   if (!answer) return defaultYes;
@@ -5171,8 +5727,8 @@ function parseSetupFormPayload(raw) {
 }
 
 // src/studio/wizard/checklist.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { join as join23 } from "path";
 var IDE_PATHS = {
   cursor: ".cursor/agents/planner.md",
   copilot: ".github/copilot-instructions.md",
@@ -5193,12 +5749,12 @@ function saveIdeChecklist(cwd, ideSurface) {
 function detectIdeRulePresent(cwd, ideSurface) {
   const rel = IDE_PATHS[ideSurface];
   if (ideSurface === "cursor") {
-    return existsSync19(join20(cwd, rel)) || existsSync19(join20(cwd, ".cursor/rules/cursor-agent-kit.mdc"));
+    return existsSync22(join23(cwd, rel)) || existsSync22(join23(cwd, ".cursor/rules/cursor-agent-kit.mdc"));
   }
   if (rel.endsWith("/")) {
-    return existsSync19(join20(cwd, rel));
+    return existsSync22(join23(cwd, rel));
   }
-  return existsSync19(join20(cwd, rel));
+  return existsSync22(join23(cwd, rel));
 }
 var VISUAL_QA_MARKER = "## Visual QA Tier";
 var VISUAL_QA_BLOCKS = {
@@ -5226,11 +5782,11 @@ This project uses the **Mature** visual QA tier.
 };
 function writeVisualQaTier(cwd, tier) {
   const path = "TESTING.md";
-  const fullPath = join20(cwd, path);
-  if (!existsSync19(fullPath)) {
+  const fullPath = join23(cwd, path);
+  if (!existsSync22(fullPath)) {
     return { updated: false, path, reason: "TESTING.md not found in project root." };
   }
-  const current = readFileSync18(fullPath, "utf8");
+  const current = readFileSync20(fullPath, "utf8");
   if (current.includes(VISUAL_QA_MARKER)) {
     return {
       updated: false,
@@ -5296,7 +5852,7 @@ function renderAgentBriefsMarkdown(cwd, file) {
     const text = file.briefs[agent.id]?.trim();
     if (!text) continue;
     wroteAny = true;
-    lines.push(`## ${agent.name}`, "", `**Role:** ${agent.roleSummary}`, "", text, "");
+    lines.push(`## ${escapeMarkdownText(agent.name)}`, "", `**Role:** ${escapeMarkdownText(agent.roleSummary)}`, "", escapeMarkdownText(text), "");
   }
   if (!wroteAny) {
     lines.push("_No agent briefs recorded yet. Run `agent-kit setup` to brief your team._", "");
@@ -5406,8 +5962,8 @@ function extractSetupFormFromWizardForm(form) {
 }
 
 // src/studio/wizard/drafts.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { join as join24 } from "path";
 var DESIGN_DRAFT_JSON = ".agent-kit/onboarding/design-draft.json";
 var MESSAGING_DRAFT_JSON = ".agent-kit/onboarding/messaging-draft.json";
 function loadDesignDraft(cwd) {
@@ -5433,12 +5989,12 @@ function previewDesignMarkdown(draft) {
 
 | Area | Wizard draft |
 | --- | --- |
-| Primary audience | ${draft.audience.trim() || "TBD"} |
-| Content inventory | ${draft.contentInventory.trim() || "TBD"} |
+| Primary audience | ${escapeMarkdownTableCell(draft.audience.trim() || "TBD")} |
+| Content inventory | ${escapeMarkdownTableCell(draft.contentInventory.trim() || "TBD")} |
 
 ## Anti-References (wizard draft)
 
-${draft.antiReferences.trim() || "- TBD: pattern to avoid."}
+${escapeMarkdownText(draft.antiReferences.trim() || "- TBD: pattern to avoid.")}
 `;
 }
 function previewMessagingMarkdown(draft) {
@@ -5446,24 +6002,29 @@ function previewMessagingMarkdown(draft) {
 
 | Question | Current Answer |
 | --- | --- |
-| Who is the primary audience? | ${draft.audience.trim() || "TBD"} |
-| What painful problem do they need solved? | ${draft.pain.trim() || "TBD"} |
-| What outcome do they want? | ${draft.outcome.trim() || "TBD"} |
+| Who is the primary audience? | ${escapeMarkdownTableCell(draft.audience.trim() || "TBD")} |
+| What painful problem do they need solved? | ${escapeMarkdownTableCell(draft.pain.trim() || "TBD")} |
+| What outcome do they want? | ${escapeMarkdownTableCell(draft.outcome.trim() || "TBD")} |
 `;
 }
 function appendSectionToDoc(cwd, doc, sectionMarkdown) {
-  const fullPath = join21(cwd, doc);
-  if (!existsSync20(fullPath)) {
+  const fullPath = join24(cwd, doc);
+  if (!existsSync23(fullPath)) {
     return { target: doc, action: "missing" };
   }
-  const current = readFileSync19(fullPath, "utf8");
-  if (current.includes("(wizard draft)")) {
-    return { target: doc, action: "conflict", conflictPath: `.agent-kit/conflicts/wizard-${doc}` };
-  }
-  writeTextFile(cwd, doc, `${current.trimEnd()}
+  const current = readFileSync21(fullPath, "utf8");
+  const proposed = `${current.trimEnd()}
 
 ${sectionMarkdown.trim()}
-`);
+`;
+  if (current.includes("(wizard draft)")) {
+    const conflict = writeConflictProposal(cwd, doc, proposed, {
+      currentContent: current,
+      reason: "The target already contains an applied wizard draft."
+    });
+    return { target: doc, action: "conflict", conflictPath: conflict.conflictPath };
+  }
+  writeTextFile(cwd, doc, proposed);
   return { target: doc, action: "appended" };
 }
 function applyDesignDraft(cwd) {
@@ -5495,8 +6056,8 @@ function applyDrafts(cwd) {
 }
 
 // src/studio/office/render.ts
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join25 } from "path";
 
 // src/studio/office/map.ts
 var MAP_WIDTH = 28;
@@ -5618,12 +6179,12 @@ var PRODUCT_CATEGORIES = ["content-app", "saas", "admin", "marketplace", "tool",
 var TENANT_MODELS = ["single-user", "team", "tenant", "marketplace", "admin", "public-content"];
 function readOfficeAsset(name) {
   const root = findPackageRoot();
-  const distPath = join22(root, "dist", "studio", "office", "assets", name);
-  const srcPath = join22(root, "src", "studio", "office", "assets", name);
+  const distPath = join25(root, "dist", "studio", "office", "assets", name);
+  const srcPath = join25(root, "src", "studio", "office", "assets", name);
   try {
-    return readFileSync20(distPath, "utf8");
+    return readFileSync22(distPath, "utf8");
   } catch {
-    return readFileSync20(srcPath, "utf8");
+    return readFileSync22(srcPath, "utf8");
   }
 }
 function buildOfficeBootConfig(cwd, viewModel) {
@@ -5668,6 +6229,51 @@ function renderOfficeHtml(boot, mode) {
   const isStudio = mode === "studio";
   const title = isStudio ? "Agent Kit \u2014 Live Studio" : "Agent Kit \u2014 Setup Office";
   const dataView = isStudio ? "studio-v1" : "office-v1";
+  const studioAside = `<aside class="transcript-panel" id="transcript-panel" aria-label="Agent Studio activity">
+      <div class="studio-tabs" role="tablist" aria-label="Studio view">
+        <button type="button" class="studio-tab active" id="studio-council-tab" role="tab" aria-selected="true" aria-controls="studio-council-view">Council</button>
+        <button type="button" class="studio-tab" id="studio-runtime-tab" role="tab" aria-selected="false" aria-controls="studio-runtime-view">Runs</button>
+      </div>
+      <section id="studio-council-view" role="tabpanel" aria-labelledby="studio-council-tab">
+        <div class="studio-controls" id="studio-controls">
+          <label class="studio-label" for="session-picker">Session</label>
+          <select id="session-picker" aria-label="Council session"></select>
+          <form id="studio-note-form" class="studio-note-form">
+            <select id="studio-note-agent" aria-label="Agent for note"></select>
+            <input id="studio-note-text" type="text" maxlength="3999" placeholder="Add council note\u2026" />
+            <button type="submit" class="btn secondary">Add note</button>
+          </form>
+          <button type="button" class="btn primary" id="studio-render-btn">Render markdown</button>
+        </div>
+        <h2>Transcript</h2>
+        <ol id="transcript-list"></ol>
+      </section>
+      <section id="studio-runtime-view" role="tabpanel" aria-labelledby="studio-runtime-tab" hidden>
+        <form id="runtime-start-form" class="runtime-start-form">
+          <label class="studio-label" for="runtime-goal">Goal</label>
+          <textarea id="runtime-goal" maxlength="20000" rows="4" required></textarea>
+          <label class="runtime-check"><input id="runtime-dirty-base" type="checkbox" /> Exclude current local changes</label>
+          <button type="submit" class="btn primary" id="runtime-start-btn" disabled>Start run</button>
+        </form>
+        <div class="runtime-toolbar">
+          <label class="studio-label" for="runtime-picker">Run</label>
+          <select id="runtime-picker" aria-label="Runtime run"></select>
+          <button type="button" class="btn secondary" id="runtime-refresh-btn">Refresh</button>
+        </div>
+        <dl class="runtime-summary" id="runtime-summary"></dl>
+        <div class="runtime-approval" id="runtime-approval" hidden>
+          <strong id="runtime-approval-title"></strong>
+          <p id="runtime-approval-detail"></p>
+          <div class="runtime-actions">
+            <button type="button" class="btn primary" id="runtime-approve-btn">Approve</button>
+            <button type="button" class="btn secondary" id="runtime-reject-btn">Reject</button>
+          </div>
+        </div>
+        <button type="button" class="btn secondary runtime-cancel" id="runtime-cancel-btn" hidden>Cancel run</button>
+        <h2>Run events</h2>
+        <ol id="runtime-event-list"></ol>
+      </section>
+    </aside>`;
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -5709,7 +6315,7 @@ function renderOfficeHtml(boot, mode) {
       <div id="nameplate-layer" class="nameplate-layer" aria-hidden="true"></div>
       <div id="office-hint" class="office-hint hidden" role="status">${isStudio ? "Watching council session events\u2026" : "Click a desk or zone to brief your agent team."}</div>
     </div>
-    ${isStudio ? '<aside class="transcript-panel" id="transcript-panel" aria-label="Session transcript"><h2>Transcript</h2><ol id="transcript-list"></ol></aside>' : ""}
+    ${isStudio ? studioAside : ""}
   </main>
   <div id="status" class="status" role="status" aria-live="polite"></div>
   <div id="depth-modal" class="modal modal-blur" hidden>
@@ -5795,18 +6401,18 @@ function allAgentBriefsComplete(form, agentIds) {
 }
 
 // src/studio/wizard/render.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join26 } from "path";
 var PRODUCT_CATEGORIES2 = ["content-app", "saas", "admin", "marketplace", "tool", "ecommerce", "portfolio", "education", "community", "ai-workflow", "other"];
 var TENANT_MODELS2 = ["single-user", "team", "tenant", "marketplace", "admin", "public-content"];
 function readWizardAsset(name) {
   const root = findPackageRoot();
-  const distPath = join23(root, "dist", "studio", "wizard", "assets", name);
-  const srcPath = join23(root, "src", "studio", "wizard", "assets", name);
+  const distPath = join26(root, "dist", "studio", "wizard", "assets", name);
+  const srcPath = join26(root, "src", "studio", "wizard", "assets", name);
   try {
-    return readFileSync21(distPath, "utf8");
+    return readFileSync23(distPath, "utf8");
   } catch {
-    return readFileSync21(srcPath, "utf8");
+    return readFileSync23(srcPath, "utf8");
   }
 }
 function mergeWizardSteps(cwd) {
@@ -5896,12 +6502,12 @@ function renderSetupWizardHtmlWithContext(cwd) {
 }
 
 // src/studio/agentic-level.ts
-import { existsSync as existsSync21, readFileSync as readFileSync22 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
+import { join as join27 } from "path";
 var CACHE_TTL_MS = 3e4;
 var cache = /* @__PURE__ */ new Map();
 function isMaintainerSourceRepo(cwd) {
-  return existsSync21(join24(cwd, "package.json")) && existsSync21(join24(cwd, "src")) && existsSync21(join24(cwd, "templates"));
+  return existsSync24(join27(cwd, "package.json")) && existsSync24(join27(cwd, "src")) && existsSync24(join27(cwd, "templates"));
 }
 function signal(id, level, label, pass, evidence, remediation) {
   return { id, level, label, pass, evidence, remediation };
@@ -5917,23 +6523,23 @@ function detectIdePresent(cwd) {
       return { pass: true, evidence: `${surface} adapter files detected` };
     }
   }
-  if (existsSync21(join24(cwd, ".cursor/rules/cursor-agent-kit.mdc"))) {
+  if (existsSync24(join27(cwd, ".cursor/rules/cursor-agent-kit.mdc"))) {
     return { pass: true, evidence: "Cursor council rules from init" };
   }
   return { pass: false, evidence: "No IDE adapter rules or subagents detected" };
 }
 function detectTierBSubagents(cwd) {
   const paths = [".cursor/agents/planner.md", ".codex/agents/planner.toml", ".claude/agents/planner.md", ".github/copilot-instructions.md"];
-  const found = paths.filter((rel) => existsSync21(join24(cwd, rel)));
+  const found = paths.filter((rel) => existsSync24(join27(cwd, rel)));
   if (found.length > 0) {
     return { pass: true, evidence: `Specialist surface: ${found[0]}` };
   }
   return { pass: false, evidence: "No council subagents or Copilot instructions installed" };
 }
 function readDocSnippet(cwd, name, needles) {
-  const path = join24(cwd, name);
-  if (!existsSync21(path)) return false;
-  const lower = readFileSync22(path, "utf8").toLowerCase();
+  const path = join27(cwd, name);
+  if (!existsSync24(path)) return false;
+  const lower = readFileSync24(path, "utf8").toLowerCase();
   return needles.every((needle) => lower.includes(needle.toLowerCase()));
 }
 function adapterTargetForIde(ide) {
@@ -5961,8 +6567,8 @@ function buildSignals(cwd, maintainerProfile) {
       "l4-agents-md",
       4,
       "Council contract (AGENTS.md)",
-      existsSync21(join24(cwd, "AGENTS.md")),
-      existsSync21(join24(cwd, "AGENTS.md")) ? "AGENTS.md installed" : "AGENTS.md missing",
+      existsSync24(join27(cwd, "AGENTS.md")),
+      existsSync24(join27(cwd, "AGENTS.md")) ? "AGENTS.md installed" : "AGENTS.md missing",
       "Run agent-kit init --stack next-supabase"
     )
   );
@@ -5971,8 +6577,8 @@ function buildSignals(cwd, maintainerProfile) {
       "l4-adapters-doc",
       4,
       "Assistant activation doc",
-      existsSync21(join24(cwd, "ASSISTANT_ADAPTERS.md")),
-      existsSync21(join24(cwd, "ASSISTANT_ADAPTERS.md")) ? "ASSISTANT_ADAPTERS.md installed" : "ASSISTANT_ADAPTERS.md missing",
+      existsSync24(join27(cwd, "ASSISTANT_ADAPTERS.md")),
+      existsSync24(join27(cwd, "ASSISTANT_ADAPTERS.md")) ? "ASSISTANT_ADAPTERS.md installed" : "ASSISTANT_ADAPTERS.md missing",
       "Run agent-kit init or agent-kit update"
     )
   );
@@ -5981,8 +6587,8 @@ function buildSignals(cwd, maintainerProfile) {
       "l4-roster",
       4,
       "Machine-readable council roster",
-      existsSync21(join24(cwd, ".agent-kit/agent-roster.json")),
-      existsSync21(join24(cwd, ".agent-kit/agent-roster.json")) ? ".agent-kit/agent-roster.json present" : "Roster missing",
+      existsSync24(join27(cwd, ".agent-kit/agent-roster.json")),
+      existsSync24(join27(cwd, ".agent-kit/agent-roster.json")) ? ".agent-kit/agent-roster.json present" : "Roster missing",
       "Run agent-kit init or agent-kit update"
     )
   );
@@ -6000,7 +6606,7 @@ function buildSignals(cwd, maintainerProfile) {
   signals.push(
     signal("l5-subagents", 5, "Tier-B specialist activation", tierB.pass, tierB.evidence, "Run agent-kit init --activate cursor|codex|claude|copilot")
   );
-  const loopCoding = existsSync21(join24(cwd, "LOOP_CODING.md"));
+  const loopCoding = existsSync24(join27(cwd, "LOOP_CODING.md"));
   signals.push(
     signal(
       "l6-loop-coding",
@@ -6031,12 +6637,12 @@ function buildSignals(cwd, maintainerProfile) {
     )
   );
   if (maintainerProfile) {
-    const pkgPath = join24(cwd, "package.json");
+    const pkgPath = join27(cwd, "package.json");
     let releaseCheck = false;
-    if (existsSync21(pkgPath)) {
+    if (existsSync24(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
-        releaseCheck = Boolean(pkg.scripts?.["release:check"]) && existsSync21(join24(cwd, "scripts/release-check.mjs"));
+        const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
+        releaseCheck = Boolean(pkg.scripts?.["release:check"]) && existsSync24(join27(cwd, "scripts/release-check.mjs"));
       } catch {
         releaseCheck = false;
       }
@@ -6051,7 +6657,7 @@ function buildSignals(cwd, maintainerProfile) {
         "Use npm run release:check before merge; see MAINTAINER_RELEASE.md"
       )
     );
-    const maintainerDocs = existsSync21(join24(cwd, "MAINTAINER_RELEASE.md")) || readDocSnippet(cwd, "DOCS.md", ["maintainer dogfood", "dogfood:init"]);
+    const maintainerDocs = existsSync24(join27(cwd, "MAINTAINER_RELEASE.md")) || readDocSnippet(cwd, "DOCS.md", ["maintainer dogfood", "dogfood:init"]);
     signals.push(
       signal(
         "l6-maintainer-docs",
@@ -6079,8 +6685,8 @@ function buildSignals(cwd, maintainerProfile) {
     signals.push(
       signal("l6-adapter-validate", 6, "Adapter validate for active IDE", adapterPass, adapterEvidence, "Run agent-kit adapter validate cursor|codex|all")
     );
-    const ciWorkflow = existsSync21(join24(cwd, ".github/workflows/agent-kit-audit.yml"));
-    const testingEval = existsSync21(join24(cwd, "TESTING.md")) && readDocSnippet(cwd, "TESTING.md", ["agent-kit audit", "eval"]);
+    const ciWorkflow = existsSync24(join27(cwd, ".github/workflows/agent-kit-audit.yml"));
+    const testingEval = existsSync24(join27(cwd, "TESTING.md")) && readDocSnippet(cwd, "TESTING.md", ["agent-kit audit", "eval"]);
     const evalLoop = ciWorkflow || testingEval;
     signals.push(
       signal(
@@ -6161,48 +6767,138 @@ function invalidateAgenticLevelCache(cwd) {
   cache.delete(cwd);
 }
 
+// src/studio/local-http-security.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
+var LocalHttpRequestError = class extends Error {
+  statusCode;
+  constructor(statusCode, message) {
+    super(message);
+    this.name = "LocalHttpRequestError";
+    this.statusCode = statusCode;
+  }
+};
+function isLoopbackHost(host) {
+  return LOOPBACK_HOSTS.has(
+    host.trim().toLowerCase().replace(/^\[|\]$/g, "")
+  );
+}
+function createLocalHttpSecurity(host) {
+  if (!isLoopbackHost(host)) {
+    throw new Error(`Agent Studio only accepts loopback hosts (127.0.0.1, ::1, or localhost); received ${host}.`);
+  }
+  return {
+    csrfToken: randomBytes(32).toString("base64url"),
+    host,
+    port: 0
+  };
+}
+function formatLocalUrl(host, port) {
+  const normalized = host.trim().replace(/^\[|\]$/g, "");
+  return `http://${normalized.includes(":") ? `[${normalized}]` : normalized}:${port}`;
+}
+function parseAuthority(authority) {
+  try {
+    return new URL(`http://${authority}`);
+  } catch {
+    throw new LocalHttpRequestError(400, "Invalid Host header.");
+  }
+}
+function safeTokenEqual(actual, expected) {
+  const actualBuffer = Buffer.from(actual);
+  const expectedBuffer = Buffer.from(expected);
+  return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer);
+}
+function assertSecureLocalRequest(request, security) {
+  const hostHeader = request.headers.host;
+  if (!hostHeader) throw new LocalHttpRequestError(400, "Host header is required.");
+  const authority = parseAuthority(hostHeader);
+  if (!isLoopbackHost(authority.hostname)) {
+    throw new LocalHttpRequestError(403, "Host must resolve to a loopback address.");
+  }
+  const requestedPort = authority.port ? Number(authority.port) : 80;
+  if (security.port > 0 && requestedPort !== security.port) {
+    throw new LocalHttpRequestError(403, "Host port does not match the local server.");
+  }
+  const method = (request.method ?? "GET").toUpperCase();
+  if (!MUTATING_METHODS.has(method)) return;
+  const contentType = request.headers["content-type"] ?? "";
+  if (!contentType.toLowerCase().startsWith("application/json")) {
+    throw new LocalHttpRequestError(415, "Mutating requests require Content-Type: application/json.");
+  }
+  const token = request.headers["x-agent-kit-csrf"];
+  if (typeof token !== "string" || !safeTokenEqual(token, security.csrfToken)) {
+    throw new LocalHttpRequestError(403, "Missing or invalid local request token.");
+  }
+  const fetchSite = request.headers["sec-fetch-site"];
+  if (typeof fetchSite === "string" && fetchSite !== "same-origin" && fetchSite !== "none") {
+    throw new LocalHttpRequestError(403, "Cross-site requests are not allowed.");
+  }
+  const origin = request.headers.origin;
+  if (typeof origin === "string") {
+    let parsedOrigin;
+    try {
+      parsedOrigin = new URL(origin);
+    } catch {
+      throw new LocalHttpRequestError(403, "Invalid Origin header.");
+    }
+    const originPort = parsedOrigin.port ? Number(parsedOrigin.port) : parsedOrigin.protocol === "https:" ? 443 : 80;
+    if (parsedOrigin.protocol !== "http:" || !isLoopbackHost(parsedOrigin.hostname) || originPort !== security.port) {
+      throw new LocalHttpRequestError(403, "Origin does not match the local server.");
+    }
+  }
+}
+function baseSecurityHeaders() {
+  return {
+    "Cache-Control": "no-store",
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Resource-Policy": "same-origin",
+    "Permissions-Policy": "camera=(), microphone=(), geolocation=(), payment=()",
+    "Referrer-Policy": "no-referrer",
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY"
+  };
+}
+function secureLocalHtml(html, security) {
+  const nonce = randomBytes(18).toString("base64url");
+  const meta = `<meta name="agent-kit-csrf-token" content="${security.csrfToken}">`;
+  const body = html.replace("</head>", `  ${meta}
+</head>`).replace(/<style>/g, `<style nonce="${nonce}">`).replace(/<script>/g, `<script nonce="${nonce}">`);
+  const csp = [
+    "default-src 'none'",
+    "base-uri 'none'",
+    "connect-src 'self'",
+    "form-action 'self'",
+    "frame-ancestors 'none'",
+    "img-src data:",
+    "object-src 'none'",
+    `script-src 'nonce-${nonce}'`,
+    `style-src 'nonce-${nonce}'`,
+    "style-src-attr 'unsafe-inline'"
+  ].join("; ");
+  return { body, csp };
+}
+
 // src/studio/setup-server.ts
 var DEFAULT_PORT = 9321;
 var DEFAULT_HOST = "127.0.0.1";
-function readJsonBody(request) {
-  return new Promise((resolve3, reject) => {
-    const chunks = [];
-    request.on("data", (chunk) => {
-      chunks.push(chunk);
-      if (chunks.reduce((total, item) => total + item.length, 0) > 256e3) {
-        reject(new Error("Request body too large."));
-        request.destroy();
-      }
-    });
-    request.on("end", () => {
-      const raw = Buffer.concat(chunks).toString("utf8").trim();
-      if (!raw) {
-        resolve3({});
-        return;
-      }
-      try {
-        resolve3(JSON.parse(raw));
-      } catch {
-        reject(new Error("Request body must be valid JSON."));
-      }
-    });
-    request.on("error", reject);
-  });
-}
 function sendJson(response, statusCode, payload) {
   response.writeHead(statusCode, {
+    ...baseSecurityHeaders(),
     "Content-Type": "application/json; charset=utf-8",
-    "Cache-Control": "no-store"
+    "Content-Security-Policy": "default-src 'none'; frame-ancestors 'none'"
   });
   response.end(JSON.stringify(payload));
 }
-function sendHtml(response, html) {
+function sendHtml(response, html, security) {
+  const secured = secureLocalHtml(html, security);
   response.writeHead(200, {
+    ...baseSecurityHeaders(),
     "Content-Type": "text/html; charset=utf-8",
-    "Cache-Control": "no-store",
-    "Content-Security-Policy": "default-src 'none'; connect-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'self'"
+    "Content-Security-Policy": secured.csp
   });
-  response.end(html);
+  response.end(secured.body);
 }
 function buildStatePayload(cwd, options = {}) {
   ensureProjectContextForSetup(cwd);
@@ -6231,7 +6927,7 @@ function buildStatePayload(cwd, options = {}) {
   };
 }
 function sendRedirect(response, location) {
-  response.writeHead(302, { Location: location, "Cache-Control": "no-store" });
+  response.writeHead(302, { ...baseSecurityHeaders(), Location: location });
   response.end();
 }
 function findOfficeStation(cwd, stationId) {
@@ -6250,18 +6946,27 @@ function markOfficeSectionComplete(cwd, stationId, form) {
   }
   markSectionComplete(cwd, section);
 }
-async function handleRequest(cwd, request, response) {
+async function handleRequest(cwd, request, response, security) {
+  try {
+    assertSecureLocalRequest(request, security);
+  } catch (error) {
+    if (error instanceof LocalHttpRequestError) {
+      sendJson(response, error.statusCode, { error: error.message });
+      return;
+    }
+    throw error;
+  }
   const url = new URL(request.url ?? "/", "http://127.0.0.1");
   if (request.method === "GET" && url.pathname === "/setup/wizard") {
     sendRedirect(response, "/wizard");
     return;
   }
   if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/office" || url.pathname === "/setup")) {
-    sendHtml(response, renderSetupOfficeHtmlWithContext(cwd));
+    sendHtml(response, renderSetupOfficeHtmlWithContext(cwd), security);
     return;
   }
   if (request.method === "GET" && url.pathname === "/wizard") {
-    sendHtml(response, renderSetupWizardHtmlWithContext(cwd));
+    sendHtml(response, renderSetupWizardHtmlWithContext(cwd), security);
     return;
   }
   if (request.method === "GET" && url.pathname === "/api/state") {
@@ -6276,6 +6981,9 @@ async function handleRequest(cwd, request, response) {
     try {
       const body = await readJsonBody(request);
       if (typeof body.completeSection === "string") {
+        if (!(body.completeSection in SECTION_LABELS)) {
+          throw new Error("Invalid section id.");
+        }
         markSectionComplete(cwd, body.completeSection);
       }
       const patch = {};
@@ -6427,7 +7135,7 @@ async function handleRequest(cwd, request, response) {
   sendJson(response, 404, { error: "Not found." });
 }
 function listen(server, host, port) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     server.once("error", reject);
     server.listen(port, host, () => {
       const address = server.address();
@@ -6435,17 +7143,18 @@ function listen(server, host, port) {
         reject(new Error("Could not determine setup server port."));
         return;
       }
-      resolve3(address.port);
+      resolve4(address.port);
     });
   });
 }
 async function startSetupServer(options) {
   const host = options.host ?? DEFAULT_HOST;
+  const security = createLocalHttpSecurity(host);
   const requestedPort = options.port ?? DEFAULT_PORT;
   ensureProjectContextForSetup(options.cwd);
   loadOnboardingState(options.cwd);
   const server = createServer((request, response) => {
-    handleRequest(options.cwd, request, response).catch((error) => {
+    handleRequest(options.cwd, request, response, security).catch((error) => {
       sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
     });
   });
@@ -6461,16 +7170,18 @@ async function startSetupServer(options) {
       throw error;
     }
   }
+  security.port = port;
   return {
-    url: `http://${host}:${port}`,
+    url: formatLocalUrl(host, port),
     port,
     requestedPort,
     portFallback,
     defaultView: "office",
-    close: () => new Promise((resolve3, reject) => {
+    csrfToken: security.csrfToken,
+    close: () => new Promise((resolve4, reject) => {
       server.close((closeError) => {
         if (closeError) reject(closeError);
-        else resolve3();
+        else resolve4();
       });
     })
   };
@@ -6479,74 +7190,135 @@ async function startSetupServer(options) {
 // src/studio/studio-server.ts
 import { watch } from "fs";
 import { createServer as createServer2 } from "http";
-import { join as join25 } from "path";
+import { join as join28 } from "path";
 var DEFAULT_PORT2 = 9331;
 var DEFAULT_HOST2 = "127.0.0.1";
-var sseClients = /* @__PURE__ */ new Set();
-var activeWatcher = null;
-var watchedEventsPath = null;
+var StudioEventHub = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  streams = /* @__PURE__ */ new Map();
+  subscribe(sessionId, response) {
+    const stream = this.getOrCreate(sessionId);
+    stream.clients.add(response);
+    this.watch(sessionId, stream);
+    return () => {
+      stream.clients.delete(response);
+      if (stream.clients.size === 0) {
+        stream.watcher?.close();
+        this.streams.delete(sessionId);
+      }
+    };
+  }
+  broadcast(sessionId, event, total) {
+    const stream = this.streams.get(sessionId);
+    if (!stream) return;
+    const eventRecord = event && typeof event === "object" ? event : {};
+    const eventKey = eventRecord.eventId ?? eventRecord.sequence;
+    stream.lastEventKey = typeof eventKey === "string" || typeof eventKey === "number" ? String(eventKey) : String(total);
+    const payload = `event: event
+data: ${JSON.stringify({ sessionId, event, total })}
+
+`;
+    for (const client of stream.clients) {
+      try {
+        client.write(payload);
+      } catch {
+        stream.clients.delete(client);
+      }
+    }
+  }
+  close() {
+    for (const stream of this.streams.values()) {
+      stream.watcher?.close();
+      for (const client of stream.clients) {
+        try {
+          client.end();
+        } catch {
+        }
+      }
+    }
+    this.streams.clear();
+  }
+  getOrCreate(sessionId) {
+    const existing = this.streams.get(sessionId);
+    if (existing) return existing;
+    const stream = { clients: /* @__PURE__ */ new Set(), watcher: null, lastEventKey: "" };
+    this.streams.set(sessionId, stream);
+    return stream;
+  }
+  watch(sessionId, stream) {
+    if (stream.watcher) return;
+    const eventsPath2 = join28(this.cwd, COUNCIL_SESSIONS_DIR, sessionId, "events.jsonl");
+    try {
+      stream.watcher = watch(eventsPath2, () => {
+        try {
+          const events = readSessionEvents(this.cwd, sessionId);
+          const latest = events.at(-1);
+          if (!latest) return;
+          const eventKey = String(latest.eventId ?? latest.sequence ?? events.length);
+          if (eventKey === stream.lastEventKey) return;
+          this.broadcast(sessionId, latest, events.length);
+        } catch {
+        }
+      });
+    } catch {
+      stream.watcher = null;
+    }
+  }
+};
 function sendJson2(response, statusCode, payload) {
   response.writeHead(statusCode, {
+    ...baseSecurityHeaders(),
     "Content-Type": "application/json; charset=utf-8",
-    "Cache-Control": "no-store"
+    "Content-Security-Policy": "default-src 'none'; frame-ancestors 'none'"
   });
   response.end(JSON.stringify(payload));
 }
-function sendHtml2(response, html) {
+function sendHtml2(response, html, security) {
+  const secured = secureLocalHtml(html, security);
   response.writeHead(200, {
+    ...baseSecurityHeaders(),
     "Content-Type": "text/html; charset=utf-8",
-    "Cache-Control": "no-store",
-    "Content-Security-Policy": "default-src 'none'; connect-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'self'"
+    "Content-Security-Policy": secured.csp
   });
-  response.end(html);
+  response.end(secured.body);
 }
-function broadcastSse(event, data) {
-  const payload = `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
-  for (const client of sseClients) {
-    try {
-      client.write(payload);
-    } catch {
-      sseClients.delete(client);
+function safeSessionId(raw) {
+  if (!/^[a-z0-9-]+$/i.test(raw)) return null;
+  return raw;
+}
+async function loadRuntimeService(cwd) {
+  try {
+    const { AgentKitRuntimeService } = await import("@appsforgood/agent-kit-runtime");
+    return new AgentKitRuntimeService(cwd);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("@appsforgood/agent-kit-runtime") || message.includes("Cannot find package")) {
+      throw new Error("The optional orchestrator runtime is not installed.");
     }
+    throw error;
   }
 }
-function stopWatcher() {
-  if (activeWatcher) {
-    activeWatcher.close();
-    activeWatcher = null;
-    watchedEventsPath = null;
-  }
+function handleRequest2(cwd, request, response, security, eventHub) {
+  handleRequestAsync(cwd, request, response, security, eventHub).catch((error) => {
+    sendJson2(response, 500, { error: error instanceof Error ? error.message : String(error) });
+  });
 }
-function watchSessionEvents(cwd, sessionId) {
-  const eventsPath2 = join25(cwd, COUNCIL_SESSIONS_DIR, sessionId, "events.jsonl");
-  if (watchedEventsPath === eventsPath2 && activeWatcher) return;
-  stopWatcher();
-  watchedEventsPath = eventsPath2;
+async function handleRequestAsync(cwd, request, response, security, eventHub) {
   try {
-    activeWatcher = watch(eventsPath2, () => {
-      try {
-        const events = readSessionEvents(cwd, sessionId);
-        const latest = events.at(-1);
-        if (latest) broadcastSse("event", { sessionId, event: latest, total: events.length });
-      } catch {
-      }
-    });
-  } catch {
-    watchedEventsPath = null;
-    activeWatcher = null;
+    assertSecureLocalRequest(request, security);
+  } catch (error) {
+    if (error instanceof LocalHttpRequestError) {
+      sendJson2(response, error.statusCode, { error: error.message });
+      return;
+    }
+    throw error;
   }
-}
-function safeSessionId(raw) {
-  if (!/^[a-z0-9-]+$/i.test(raw)) return null;
-  return raw;
-}
-function handleRequest2(cwd, request, response) {
   const url = new URL(request.url ?? "/", "http://127.0.0.1");
   if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/office")) {
-    sendHtml2(response, renderLiveStudioHtmlWithContext(cwd));
+    sendHtml2(response, renderLiveStudioHtmlWithContext(cwd), security);
     return;
   }
   if (request.method === "GET" && url.pathname === "/api/sessions") {
@@ -6561,6 +7333,121 @@ function handleRequest2(cwd, request, response) {
     sendJson2(response, 200, { activeSessionId, sessions });
     return;
   }
+  if (request.method === "GET" && url.pathname === "/api/runtime/runs") {
+    try {
+      const runtime = await loadRuntimeService(cwd);
+      const validation = runtime.validate();
+      sendJson2(response, 200, { runs: runtime.status(), enabled: validation.enabled, warnings: validation.warnings });
+    } catch (error) {
+      sendJson2(response, 503, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/runtime/plan") {
+    try {
+      const body = await readJsonBody(request);
+      const goal = typeof body.goal === "string" ? body.goal.trim() : "";
+      const workflowId = typeof body.workflowId === "string" && body.workflowId.trim() ? body.workflowId.trim() : void 0;
+      if (!goal || goal.length > 2e4) {
+        sendJson2(response, 400, { error: "goal must be between 1 and 20000 characters." });
+        return;
+      }
+      const runtime = await loadRuntimeService(cwd);
+      sendJson2(response, 200, { plan: runtime.plan(goal, workflowId) });
+    } catch (error) {
+      sendJson2(response, 400, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/runtime/runs") {
+    try {
+      const body = await readJsonBody(request);
+      const goal = typeof body.goal === "string" ? body.goal.trim() : "";
+      const workflowId = typeof body.workflowId === "string" && body.workflowId.trim() ? body.workflowId.trim() : void 0;
+      if (!goal || goal.length > 2e4) {
+        sendJson2(response, 400, { error: "goal must be between 1 and 20000 characters." });
+        return;
+      }
+      if (body.acknowledgeDirtyBase !== void 0 && typeof body.acknowledgeDirtyBase !== "boolean") {
+        sendJson2(response, 400, { error: "acknowledgeDirtyBase must be boolean." });
+        return;
+      }
+      const runtime = await loadRuntimeService(cwd);
+      const run = await runtime.run(goal, {
+        ...workflowId ? { workflowId } : {},
+        ...body.acknowledgeDirtyBase === true ? { acknowledgeDirtyBase: true } : {}
+      });
+      sendJson2(response, 201, { run, events: runtime.events.events(run.runId) });
+    } catch (error) {
+      sendJson2(response, 400, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  const runtimeRunMatch = url.pathname.match(/^\/api\/runtime\/runs\/([^/]+)$/);
+  if (request.method === "GET" && runtimeRunMatch) {
+    const runId = safeSessionId(runtimeRunMatch[1] ?? "");
+    if (!runId) {
+      sendJson2(response, 400, { error: "Invalid run id." });
+      return;
+    }
+    try {
+      const runtime = await loadRuntimeService(cwd);
+      const run = runtime.status(runId);
+      sendJson2(response, 200, { run, events: runtime.events.events(runId) });
+    } catch (error) {
+      sendJson2(response, 404, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  const runtimeDecisionMatch = url.pathname.match(/^\/api\/runtime\/runs\/([^/]+)\/decision$/);
+  if (request.method === "POST" && runtimeDecisionMatch) {
+    const runId = safeSessionId(runtimeDecisionMatch[1] ?? "");
+    if (!runId) {
+      sendJson2(response, 400, { error: "Invalid run id." });
+      return;
+    }
+    try {
+      const body = await readJsonBody(request);
+      if (body.decision !== "approve" && body.decision !== "reject") {
+        sendJson2(response, 400, { error: "decision must be approve or reject." });
+        return;
+      }
+      const actor = typeof body.actor === "string" && body.actor.trim() ? body.actor.trim().slice(0, 200) : "studio-operator";
+      const note = typeof body.note === "string" && body.note.trim() ? body.note.trim().slice(0, 2e3) : void 0;
+      const runtime = await loadRuntimeService(cwd);
+      const current = runtime.status(runId);
+      if (Array.isArray(current) || !current.pendingApproval) {
+        sendJson2(response, 409, { error: `Run ${runId} has no pending approval.` });
+        return;
+      }
+      const run = await runtime.resume(runId, {
+        approvalId: current.pendingApproval.approvalId,
+        decision: body.decision,
+        actor,
+        ...note ? { note } : {}
+      });
+      sendJson2(response, 200, { run, events: runtime.events.events(runId) });
+    } catch (error) {
+      sendJson2(response, 400, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  const runtimeCancelMatch = url.pathname.match(/^\/api\/runtime\/runs\/([^/]+)\/cancel$/);
+  if (request.method === "POST" && runtimeCancelMatch) {
+    const runId = safeSessionId(runtimeCancelMatch[1] ?? "");
+    if (!runId) {
+      sendJson2(response, 400, { error: "Invalid run id." });
+      return;
+    }
+    try {
+      const runtime = await loadRuntimeService(cwd);
+      const run = runtime.cancel(runId);
+      sendJson2(response, 200, { run, events: runtime.events.events(runId) });
+    } catch (error) {
+      sendJson2(response, 400, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
   const eventsMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/events$/);
   if (request.method === "GET" && eventsMatch) {
     const sessionId = safeSessionId(eventsMatch[1] ?? "");
@@ -6593,13 +7480,14 @@ function handleRequest2(cwd, request, response) {
       return;
     }
     response.writeHead(200, {
+      ...baseSecurityHeaders(),
       "Content-Type": "text/event-stream; charset=utf-8",
-      "Cache-Control": "no-store",
-      Connection: "keep-alive"
+      "Content-Security-Policy": "default-src 'none'; frame-ancestors 'none'",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
     });
     response.write(": connected\n\n");
-    sseClients.add(response);
-    watchSessionEvents(cwd, activeId);
+    const unsubscribe = eventHub.subscribe(activeId, response);
     try {
       const events = readSessionEvents(cwd, activeId);
       response.write(`event: snapshot
@@ -6613,15 +7501,65 @@ data: ${JSON.stringify({ sessionId: activeId, events: [] })}
 `);
     }
     request.on("close", () => {
-      sseClients.delete(response);
-      if (sseClients.size === 0) stopWatcher();
+      unsubscribe();
     });
     return;
   }
+  const noteMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/note$/);
+  if (request.method === "POST" && noteMatch) {
+    const sessionId = safeSessionId(noteMatch[1] ?? "");
+    if (!sessionId) {
+      sendJson2(response, 400, { error: "Invalid session id." });
+      return;
+    }
+    try {
+      const body = await readJsonBody(request);
+      const agent = typeof body.agent === "string" ? body.agent.trim() : "";
+      const text = typeof body.text === "string" ? body.text.trim() : "";
+      if (!agent) {
+        sendJson2(response, 400, { error: "agent is required." });
+        return;
+      }
+      if (!text) {
+        sendJson2(response, 400, { error: "text is required." });
+        return;
+      }
+      if (text.length >= 4e3) {
+        sendJson2(response, 400, { error: "text must be under 4000 characters." });
+        return;
+      }
+      const event = recordSessionNote(cwd, sessionId, agent, text);
+      eventHub.broadcast(sessionId, event, readSessionEvents(cwd, sessionId).length);
+      sendJson2(response, 200, { event });
+    } catch (error) {
+      sendJson2(response, 404, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  const renderMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/render$/);
+  if (request.method === "POST" && renderMatch) {
+    const sessionId = safeSessionId(renderMatch[1] ?? "");
+    if (!sessionId) {
+      sendJson2(response, 400, { error: "Invalid session id." });
+      return;
+    }
+    try {
+      const result = renderSession(cwd, sessionId);
+      sendJson2(response, 200, {
+        rendered: true,
+        sessionId: result.sessionId,
+        sessionPath: result.sessionPath,
+        files: [`${result.sessionPath}/index.md`, `${result.sessionPath}/transcript.md`]
+      });
+    } catch (error) {
+      sendJson2(response, 404, { error: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
   sendJson2(response, 404, { error: "Not found." });
 }
 function listen2(server, host, port) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     server.once("error", reject);
     server.listen(port, host, () => {
       const address = server.address();
@@ -6629,17 +7567,19 @@ function listen2(server, host, port) {
         reject(new Error("Could not determine studio server port."));
         return;
       }
-      resolve3(address.port);
+      resolve4(address.port);
     });
   });
 }
 async function startStudioServer(options) {
   const host = options.host ?? DEFAULT_HOST2;
+  const security = createLocalHttpSecurity(host);
   const requestedPort = options.port ?? DEFAULT_PORT2;
   ensureStudioDirs(options.cwd);
+  const eventHub = new StudioEventHub(options.cwd);
   const server = createServer2((request, response) => {
     try {
-      handleRequest2(options.cwd, request, response);
+      handleRequest2(options.cwd, request, response, security, eventHub);
     } catch (error) {
       sendJson2(response, 500, { error: error instanceof Error ? error.message : String(error) });
     }
@@ -6656,31 +7596,26 @@ async function startStudioServer(options) {
       throw error;
     }
   }
+  security.port = port;
   return {
-    url: `http://${host}:${port}`,
+    url: formatLocalUrl(host, port),
     port,
     requestedPort,
     portFallback,
-    close: () => new Promise((resolve3, reject) => {
-      stopWatcher();
-      for (const client of sseClients) {
-        try {
-          client.end();
-        } catch {
-        }
-      }
-      sseClients.clear();
+    csrfToken: security.csrfToken,
+    close: () => new Promise((resolve4, reject) => {
+      eventHub.close();
       server.close((closeError) => {
         if (closeError) reject(closeError);
-        else resolve3();
+        else resolve4();
       });
     })
   };
 }
 
 // src/studio/session-checkpoint.ts
-import { existsSync as existsSync22, readFileSync as readFileSync23 } from "fs";
-import { extname, join as join26 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync25 } from "fs";
+import { extname, join as join29 } from "path";
 function parseCheckpointMarkdown(content) {
   const payload = { notes: [], decisions: [], handoffs: [], outputs: [] };
   const sections = content.split(/^## /m).slice(1);
@@ -6736,7 +7671,7 @@ function parseCheckpointMarkdown(content) {
   return payload;
 }
 function parseCheckpointFile(filePath) {
-  const content = readFileSync23(filePath, "utf8");
+  const content = readFileSync25(filePath, "utf8");
   const ext = extname(filePath).toLowerCase();
   if (ext === ".json") {
     const parsed = JSON.parse(content);
@@ -6812,8 +7747,8 @@ function applySessionCheckpoint(cwd, payload) {
   };
 }
 function checkpointSessionFromFile(cwd, filePath) {
-  const absolute = join26(cwd, filePath);
-  if (!existsSync22(absolute)) throw new Error(`Checkpoint file not found: ${filePath}`);
+  const absolute = join29(cwd, filePath);
+  if (!existsSync25(absolute)) throw new Error(`Checkpoint file not found: ${filePath}`);
   return applySessionCheckpoint(cwd, parseCheckpointFile(absolute));
 }
 
@@ -6867,6 +7802,41 @@ var requiredOutputStatuses = ["missing", "partial", "complete", "not-applicable"
 function isRequiredOutputStatus(value) {
   return requiredOutputStatuses.includes(value);
 }
+async function loadRuntimeService2() {
+  try {
+    const { AgentKitRuntimeService } = await import("@appsforgood/agent-kit-runtime");
+    return new AgentKitRuntimeService(process.cwd());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("@appsforgood/agent-kit-runtime") || message.includes("Cannot find package")) {
+      throw new Error("The optional orchestrator runtime is not installed. Run: npm install --save-dev @appsforgood/agent-kit-runtime");
+    }
+    throw error;
+  }
+}
+function printRuntimeRecord(record) {
+  line(`${style.bold(record.runId)} ${record.status}`);
+  line(`workflow: ${record.workflowId}`);
+  if (record.branchName) line(`branch: ${record.branchName}`);
+  if (record.commit) line(`commit: ${record.commit}`);
+  if (record.pendingApproval) {
+    line(`approval: ${record.pendingApproval.approvalId} (${record.pendingApproval.risk})`);
+    detail(record.pendingApproval.title);
+  }
+  if (record.error) line(style.fail(`failure: ${record.error}`));
+}
+async function readCredentialValue() {
+  if (!process.stdin.isTTY) {
+    const value2 = readFileSync26(0, "utf8").replace(/[\r\n]+$/, "");
+    if (!value2) throw new Error("Credential value was empty.");
+    return value2;
+  }
+  const clack = await import("@clack/prompts");
+  const value = await clack.password({ message: "Credential value" });
+  if (clack.isCancel(value)) throw new Error("Credential entry cancelled.");
+  if (typeof value !== "string" || !value) throw new Error("Credential value was empty.");
+  return value;
+}
 program.name("agent-kit").description("Next.js + Supabase agent, skill, docs, design, and research kit.").version(PACKAGE_VERSION);
 async function runGuidedContextPrompts(cwd) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) return;
@@ -6888,11 +7858,11 @@ async function runGuidedContextPrompts(cwd) {
     if (typeof answer === "string" && answer.trim()) answers[question.key] = answer.trim();
   }
   if (Object.keys(answers).length > 0) {
-    const contextPath = join27(cwd, ".agent-kit", "project-context.json");
-    if (existsSync23(contextPath)) {
-      const context2 = JSON.parse(readFileSync24(contextPath, "utf8"));
+    const contextPath = join30(cwd, ".agent-kit", "project-context.json");
+    if (existsSync26(contextPath)) {
+      const context2 = JSON.parse(readFileSync26(contextPath, "utf8"));
       Object.assign(context2, answers);
-      writeFileSync2(contextPath, `${JSON.stringify(context2, null, 2)}
+      writeFileSync3(contextPath, `${JSON.stringify(context2, null, 2)}
 `);
       renderProjectContext(cwd);
     }
@@ -6913,9 +7883,9 @@ async function runSetupServer(options) {
   console.log(`Pixel office (default): ${handle.url}/  |  Form fallback: ${handle.url}/wizard`);
   console.log("Pick Quick, Standard, or Complete on first visit. Press Ctrl+C to stop.");
   if (options.open) void openBrowser(`${handle.url}/`);
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     const shutdown = () => {
-      void handle.close().finally(resolve3);
+      void handle.close().finally(resolve4);
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -6980,8 +7950,20 @@ program.command("init").description("Install agent-kit docs and library files in
     await runSetupServer({ port: 9321, host: "127.0.0.1", open: Boolean(options.open) });
   }
 });
-program.command("audit").description("Audit an existing project for agent-kit coverage gaps.").option("--json", "Print machine-readable JSON output.").option("--min-readiness <level>", `Exit non-zero unless readiness is at least this level: ${READINESS_ORDER.join(", ")}.`).action((options) => {
-  const report2 = createAuditReport(process.cwd());
+program.command("audit").description("Audit an existing project for agent-kit coverage gaps.").option("--json", "Print machine-readable JSON output.").option("--schema-version <version>", "JSON audit schema version: 1 or 2.", "1").option("--format <format>", "Output format: human, json, or sarif.").option("--min-readiness <level>", `Exit non-zero unless readiness is at least this level: ${READINESS_ORDER.join(", ")}.`).action((options) => {
+  if (options.schemaVersion !== "1" && options.schemaVersion !== "2") {
+    fail(`Invalid --schema-version value "${options.schemaVersion}". Expected 1 or 2.`);
+    process.exitCode = 1;
+    return;
+  }
+  const format = options.format ?? (options.json ? "json" : "human");
+  if (!(/* @__PURE__ */ new Set(["human", "json", "sarif"])).has(format)) {
+    fail(`Invalid --format value "${format}". Expected human, json, or sarif.`);
+    process.exitCode = 1;
+    return;
+  }
+  const reportV2 = options.schemaVersion === "2" || format === "sarif" ? createAuditReportV2(process.cwd()) : void 0;
+  const report2 = reportV2 ?? createAuditReport(process.cwd());
   let minimumReadiness;
   if (options.minReadiness) {
     if (!isAuditReadinessLevel(options.minReadiness)) {
@@ -6991,7 +7973,9 @@ program.command("audit").description("Audit an existing project for agent-kit co
     }
     minimumReadiness = options.minReadiness;
   }
-  if (options.json) {
+  if (format === "sarif") {
+    printJson(auditReportToSarif(reportV2));
+  } else if (format === "json") {
     printJson(report2);
   } else {
     const readinessStyle = report2.summary.fail > 0 ? style.fail : report2.summary.warn > 0 ? style.warn : style.pass;
@@ -7343,6 +8327,122 @@ correction.command("propose-upstream <id>").description("Create an upstream prop
   if (options.json) printJson(result);
   else line(`Created upstream proposal from correction ${id}.`);
 });
+var orchestrate = program.command("orchestrate").description("Run checkpointed council workflows with the optional local runtime.");
+orchestrate.command("validate").description("Validate orchestrator config, roster references, bounds, and credential references without calling providers.").option("--json", "Print machine-readable JSON output.").action(async (options) => {
+  const result = (await loadRuntimeService2()).validate();
+  if (options.json) printJson(result);
+  else {
+    heading("agent-kit orchestrator");
+    line(`status: ${result.valid ? "valid" : "invalid"}`);
+    line(`enabled: ${result.enabled}`);
+    line(`roster: ${result.rosterId}`);
+    line(`workflows: ${result.workflows.join(", ")}`);
+    line(`providers: ${result.providers.join(", ") || "none"}`);
+    for (const warning of result.warnings) detail(`warning: ${warning}`);
+  }
+});
+orchestrate.command("plan <goal...>").description("Compile a deterministic offline workflow plan from the installed roster.").option("--workflow <workflow>", "Use an explicit roster workflow id.").option("--json", "Print machine-readable JSON output.").action(async (goalParts, options) => {
+  const result = (await loadRuntimeService2()).plan(goalParts.join(" "), options.workflow);
+  if (options.json) printJson(result);
+  else {
+    heading(`Workflow: ${result.workflowId}`);
+    line(`sequence: ${result.sequence.join(" -> ")}`);
+    line(`council: ${result.council.join(", ")}`);
+    line(`approvals: ${result.approvals.join(", ") || "none"}`);
+    line(`model aliases: ${result.modelAliases.join(", ") || "none"}`);
+    line(`MCP servers: ${result.mcpServers.join(", ") || "none"}`);
+  }
+});
+orchestrate.command("run <goal...>").description("Start a foreground checkpointed workflow in an isolated Git worktree.").option("--workflow <workflow>", "Use an explicit roster workflow id.").option("--acknowledge-dirty-base", "Acknowledge that current uncommitted changes will be excluded from the worktree.").option("--json", "Print machine-readable JSON output.").action(async (goalParts, options) => {
+  const result = await (await loadRuntimeService2()).run(goalParts.join(" "), {
+    ...options.workflow ? { workflowId: options.workflow } : {},
+    ...options.acknowledgeDirtyBase ? { acknowledgeDirtyBase: true } : {}
+  });
+  if (options.json) printJson(result);
+  else printRuntimeRecord(result);
+});
+orchestrate.command("status [run-id]").description("Show one runtime run or list recent runs.").option("--json", "Print machine-readable JSON output.").action(async (runId, options) => {
+  const result = (await loadRuntimeService2()).status(runId);
+  if (options.json) printJson(result);
+  else if (Array.isArray(result)) {
+    if (result.length === 0) line("No runtime runs found.");
+    for (const record of result) printRuntimeRecord(record);
+  } else {
+    printRuntimeRecord(result);
+  }
+});
+orchestrate.command("approve <run-id>").description("Approve the pending gate and resume the checkpointed workflow.").option("--actor <actor>", "Decision actor.", process.env.USER ?? "operator").option("--note <note>", "Decision note.").option("--json", "Print machine-readable JSON output.").action(async (runId, options) => {
+  const runtime = await loadRuntimeService2();
+  const record = runtime.status(runId);
+  if (Array.isArray(record) || !record.pendingApproval) throw new Error(`Run ${runId} has no pending approval.`);
+  const result = await runtime.resume(runId, {
+    approvalId: record.pendingApproval.approvalId,
+    decision: "approve",
+    actor: options.actor,
+    ...options.note ? { note: options.note } : {}
+  });
+  if (options.json) printJson(result);
+  else printRuntimeRecord(result);
+});
+orchestrate.command("resume <run-id>").description("Resume a pending gate with an explicit approve or reject decision.").requiredOption("--decision <decision>", "approve or reject.").option("--actor <actor>", "Decision actor.", process.env.USER ?? "operator").option("--note <note>", "Decision note.").option("--json", "Print machine-readable JSON output.").action(async (runId, options) => {
+  if (options.decision !== "approve" && options.decision !== "reject") throw new Error("--decision must be approve or reject.");
+  const runtime = await loadRuntimeService2();
+  const record = runtime.status(runId);
+  if (Array.isArray(record) || !record.pendingApproval) throw new Error(`Run ${runId} has no pending approval.`);
+  const result = await runtime.resume(runId, {
+    approvalId: record.pendingApproval.approvalId,
+    decision: options.decision,
+    actor: options.actor,
+    ...options.note ? { note: options.note } : {}
+  });
+  if (options.json) printJson(result);
+  else printRuntimeRecord(result);
+});
+orchestrate.command("cancel <run-id>").description("Cancel a planned or approval-paused run.").option("--json", "Print machine-readable JSON output.").action(async (runId, options) => {
+  const result = (await loadRuntimeService2()).cancel(runId);
+  if (options.json) printJson(result);
+  else printRuntimeRecord(result);
+});
+orchestrate.command("export <run-id>").description("Export redacted JSONL-backed runtime evidence as Markdown.").option("--output <path>", "Project-relative output path.").option("--json", "Print machine-readable JSON output.").action(async (runId, options) => {
+  const evidence = (await loadRuntimeService2()).exportEvidence(runId);
+  if (!options.output) {
+    line(evidence.trimEnd());
+    return;
+  }
+  if (isAbsolute2(options.output)) throw new Error("--output must be project-relative.");
+  const root = resolve3(process.cwd());
+  const output = resolve3(root, options.output);
+  const relationship = relative2(root, output);
+  if (relationship.startsWith("..") || isAbsolute2(relationship)) throw new Error("--output must remain inside the project.");
+  mkdirSync3(dirname4(output), { recursive: true });
+  writeFileSync3(output, evidence, { mode: 384 });
+  if (options.json) printJson({ runId, output: relationship.replace(/\\/g, "/") });
+  else line(`Exported ${runId} evidence to ${relationship}.`);
+});
+var provider = program.command("provider").description("Probe configured orchestrator model providers.");
+provider.command("probe [provider-id]").description("Probe one provider or all configured providers.").option("--json", "Print machine-readable JSON output.").action(async (providerId, options) => {
+  const result = await (await loadRuntimeService2()).probeProvider(providerId);
+  if (options.json) printJson(result);
+  else
+    for (const probe of result) line(`${probe.available ? "PASS" : "FAIL"} ${probe.providerId} ${probe.latencyMs}ms${probe.error ? `: ${probe.error}` : ""}`);
+});
+var credential = program.command("credential").description("Manage orchestrator credentials in the OS keychain.");
+credential.command("set <reference>").description("Read a credential from a masked prompt or stdin and store a keychain: reference.").action(async (reference) => {
+  const value = await readCredentialValue();
+  await (await loadRuntimeService2()).setCredential(reference, value);
+  line(`Stored ${reference} in the OS keychain.`);
+});
+credential.command("delete <reference>").description("Delete a keychain credential reference.").option("--json", "Print machine-readable JSON output.").action(async (reference, options) => {
+  const deleted = await (await loadRuntimeService2()).deleteCredential(reference);
+  if (options.json) printJson({ reference, deleted });
+  else line(deleted ? `Deleted ${reference}.` : `No credential existed for ${reference}.`);
+});
+var mcp = program.command("mcp").description("Probe explicitly configured MCP servers.");
+mcp.command("probe <server>").description("Connect, ping, and list allowlisted tools for one MCP server.").option("--json", "Print machine-readable JSON output.").action(async (server, options) => {
+  const result = await (await loadRuntimeService2()).probeMcp(server);
+  if (options.json) printJson(result);
+  else printJson(result);
+});
 var studio = program.command("studio").description("Export and serve local Agent Studio views.");
 async function runStudioServer(options) {
   const handle = await startStudioServer({
@@ -7356,9 +8456,9 @@ async function runStudioServer(options) {
   console.log(`Agent Kit v${PACKAGE_VERSION} \u2014 live studio at ${handle.url}/`);
   console.log("SSE: GET /api/events/stream  |  Press Ctrl+C to stop.");
   if (options.open) void openBrowser(`${handle.url}/`);
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     const shutdown = () => {
-      void handle.close().finally(resolve3);
+      void handle.close().finally(resolve4);
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);