@jay-framework/aiditor 0.17.4 → 0.18.0

package/dist/index.js

@@ -1,10 +1,14 @@
 import { makeJayQuery, makeJayStream, makeJayStackComponent, phaseOutput, RenderPipeline } from "@jay-framework/fullstack-component";
 import { DEV_SERVER_SERVICE } from "@jay-framework/dev-server";
-import fs, { readFile } from "fs/promises";
+import fs, { readFile, readdir } from "fs/promises";
 import path, { extname } from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import fs$1 from "fs";
 import crypto from "crypto";
+import { getLogger } from "@jay-framework/logger";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import { scanRoutes } from "@jay-framework/stack-route-scanner";
 import { setActionCallerOptions } from "@jay-framework/stack-client-runtime";
 const getAiditorBootstrap = makeJayQuery(
   "aiditor.getAiditorBootstrap"
@@ -225,6 +229,48 @@ async function replaceRouteSessionAfterStaleResume(projectDir, routeKey) {
     return { sessionId };
   });
 }
+const AGENT_KIT_PREAMBLE = `You are working in a Jay Stack project. The current working directory is the project root.
+- Read agent-kit/plugins-index.yaml for installed plugins and materialized contract paths.
+- Follow Jay Stack conventions for pages, routing, and headless component binding.
+- Use Read/Glob to consult agent-kit guides when needed; do not guess contract field names.`;
+function loadAgentKitSystemPrompt(projectDir) {
+  const parts = [];
+  const designerPath = path.join(
+    projectDir,
+    "agent-kit",
+    "designer",
+    "INSTRUCTIONS.md"
+  );
+  const developerPath = path.join(
+    projectDir,
+    "agent-kit",
+    "developer",
+    "INSTRUCTIONS.md"
+  );
+  if (fs$1.existsSync(designerPath)) {
+    parts.push(fs$1.readFileSync(designerPath, "utf-8"));
+  }
+  if (fs$1.existsSync(developerPath)) {
+    if (parts.length > 0) parts.push("\n\n---\n\n");
+    parts.push(fs$1.readFileSync(developerPath, "utf-8"));
+  }
+  if (parts.length > 0) parts.push("\n\n");
+  parts.push(AGENT_KIT_PREAMBLE);
+  return parts.join("");
+}
+function buildChatPrompt(config, pageRoute, renderedUrl, userMessage) {
+  const lines = [
+    `Project directory: ${config.projectDir}`,
+    `Current page route: ${pageRoute}`,
+    renderedUrl ? `Rendered preview URL: ${renderedUrl}` : null,
+    "",
+    "The user is continuing a conversation about this Jay project. Answer questions and perform requested edits using agent-kit. Read contract files from agent-kit/plugins-index.yaml when binding UI.",
+    "",
+    "User message:",
+    userMessage
+  ];
+  return lines.filter((l) => l !== null).join("\n");
+}
 function buildNonVisualPrompt(config, notes, imagePath) {
   const lines = [
     `Project directory: ${config.projectDir}`,
@@ -239,6 +285,22 @@ const ANNOTATION_TARGETING_RULES = `Annotation targeting (follow strictly):
 - The only authoritative edit target is the element indicated by the annotation marker (dot, arrow, or highlighted region). Do not choose another element because it is colorful, prominent, or a common control (e.g. buttons, links) unless the marker clearly overlaps that element.
 - If several elements could match, prefer the text or content under/near the marker (e.g. a heading) over unrelated controls elsewhere on the page.
 - If you cannot confidently map the marker to a single target in source, do not change a plausible but unmarked control. Briefly say what is ambiguous and list candidate elements or ask for clarification.`;
+function structuredAnnotationBindings(ann) {
+  if (ann.pluginBindings?.length) return ann.pluginBindings;
+  if (ann.pluginBinding) return [ann.pluginBinding];
+  return [];
+}
+function appendBindingPromptLines(body, bindings, markerId, indent = "") {
+  if (bindings.length === 0) return;
+  body.push(`${indent}Headless bindings:`);
+  for (const b of bindings) {
+    const key = b.componentKey ? ` (key: ${b.componentKey})` : "";
+    body.push(`${indent}- Plugin: ${b.packageName} / ${b.contractName}${key}`);
+    body.push(
+      b.scope === "page" ? `${indent}- Scope: anywhere on page — add or connect this component where it best satisfies the instruction` : `${indent}- Scope: at marker — wire the element indicated by this marker to this contract's refs`
+    );
+  }
+}
 function parseNotesField(notes) {
   const empty = () => ({
     structured: null,
@@ -279,7 +341,7 @@ function parseNotesField(notes) {
         plain: ""
       };
     }
-    if (j.version === 1 && Array.isArray(j.annotations) && j.annotations.length > 0 && j.annotations.every(
+    if ((j.version === 1 || j.version === 1.1) && Array.isArray(j.annotations) && j.annotations.length > 0 && j.annotations.every(
       (a) => a && typeof a === "object" && typeof a.id === "string" && typeof a.instruction === "string" && typeof a.mode === "string"
     )) {
       return {
@@ -320,6 +382,7 @@ function buildVisualPromptDual(config, pageRoute, renderedUrl, dual, parsed, att
       const pin = ann.id;
       const paths = attachmentPathsByAnnotationId.get(pin) ?? [];
       body.push(`Annotation ${pin} (${ann.mode})`);
+      appendBindingPromptLines(body, structuredAnnotationBindings(ann), ann.id);
       body.push(`Instruction: ${ann.instruction.trim()}`);
       if (paths.length > 0) {
         body.push(
@@ -392,6 +455,12 @@ function buildVisualPromptVideo(config, pageRoute, renderedUrl, videoPath, frame
       const pinNum = pinById.get(ann.id) ?? "?";
       const paths = attachmentPathsByPin.get(pinNum) ?? [];
       body.push(`- Pin ${pinNum} (id ${ann.id}) — ${ann.mode}`);
+      appendBindingPromptLines(
+        body,
+        structuredAnnotationBindings(ann),
+        ann.id,
+        "  "
+      );
       body.push(`  Instruction: ${ann.instruction.trim()}`);
       if (ann.previewUrlAtTime) {
         body.push(
@@ -420,7 +489,7 @@ function persistFile(file, destDir, fileName) {
   fs$1.copyFileSync(file.path, dest);
   return dest;
 }
-const submitTaskAction = makeJayStream("aiditor.submitTask").withFiles({ maxFileSize: 2e7, maxFiles: 300 }).withHandler(async function* (input) {
+const submitTaskAction = makeJayStream("aiditor.submitTask").withFiles().withHandler(async function* (input) {
   const projectDir = process.cwd();
   const buildFolder = path.join(projectDir, "build");
   const taskId = Math.random().toString(36).slice(2, 10);
@@ -503,20 +572,18 @@ const submitTaskAction = makeJayStream("aiditor.submitTask").withFiles({ maxFile
       parsed,
       attachmentPathsByAnnotationId
     );
+  } else if (input.messageKind === "chat") {
+    promptContent = buildChatPrompt(
+      config,
+      input.pageRoute ?? "/",
+      input.renderedUrl ?? "",
+      input.notes
+    );
   } else {
     promptContent = buildNonVisualPrompt(config, input.notes);
   }
   yield { type: "status", message: "Running agent..." };
-  let systemPrompt = "";
-  const agentKitPath = path.join(
-    projectDir,
-    "agent-kit",
-    "designer",
-    "INSTRUCTIONS.md"
-  );
-  if (fs$1.existsSync(agentKitPath)) {
-    systemPrompt = fs$1.readFileSync(agentKitPath, "utf-8");
-  }
+  const systemPrompt = loadAgentKitSystemPrompt(projectDir);
   const routeKey = normalizePageRoute(input.pageRoute);
   const sessionPlan = await getOrCreateSessionIdForRoute(
     projectDir,
@@ -592,6 +659,2590 @@ const submitTaskAction = makeJayStream("aiditor.submitTask").withFiles({ maxFile
   }
   yield { type: "done" };
 });
+const CATALOG = [
+  {
+    pluginName: "wix-server-client",
+    packageName: "@jay-framework/wix-server-client",
+    description: "Wix API client and authentication",
+    kind: "service-only",
+    requires: [],
+    showInAddPagePicker: false,
+    configFiles: ["config/.wix.yaml"]
+  },
+  {
+    pluginName: "wix-cart",
+    packageName: "@jay-framework/wix-cart",
+    description: "Shopping cart headless components",
+    kind: "headless",
+    requires: ["wix-server-client"],
+    showInAddPagePicker: true
+  },
+  {
+    pluginName: "wix-stores",
+    packageName: "@jay-framework/wix-stores",
+    description: "Wix Stores product search, product page, categories",
+    kind: "headless",
+    requires: ["wix-server-client", "wix-cart"],
+    showInAddPagePicker: true,
+    configFiles: ["config/.wix-stores.yaml"]
+  },
+  {
+    pluginName: "wix-stores-v1",
+    packageName: "@jay-framework/wix-stores-v1",
+    description: "Wix Stores v1 catalog API",
+    kind: "headless",
+    requires: ["wix-server-client", "wix-cart"],
+    showInAddPagePicker: true
+  },
+  {
+    pluginName: "wix-data",
+    packageName: "@jay-framework/wix-data",
+    description: "Wix Data collections CMS",
+    kind: "headless",
+    requires: ["wix-server-client"],
+    showInAddPagePicker: true,
+    configFiles: ["config/.wix-data.yaml"]
+  },
+  {
+    pluginName: "wix-media",
+    packageName: "@jay-framework/wix-media",
+    description: "Wix media service (no page components)",
+    kind: "service-only",
+    requires: ["wix-server-client"],
+    showInAddPagePicker: true
+  },
+  {
+    pluginName: "ui-kit",
+    packageName: "@jay-framework/ui-kit",
+    description: "Jay UI kit headless components",
+    kind: "headless",
+    requires: [],
+    showInAddPagePicker: true
+  },
+  {
+    pluginName: "gemini-agent",
+    packageName: "@jay-framework/gemini-agent",
+    description: "Gemini AI agent plugin",
+    kind: "headless",
+    requires: [],
+    showInAddPagePicker: true,
+    configFiles: ["config/.gemini-agent.yaml"]
+  },
+  {
+    pluginName: "webmcp",
+    packageName: "@jay-framework/webmcp",
+    description: "Web MCP tooling",
+    kind: "tooling",
+    requires: [],
+    showInAddPagePicker: false
+  },
+  {
+    pluginName: "aiditor",
+    packageName: "@jay-framework/aiditor",
+    description: "AIditor self plugin",
+    kind: "tooling",
+    requires: [],
+    showInAddPagePicker: false
+  }
+];
+function getJayPluginCatalog() {
+  return CATALOG.map((e) => ({ ...e, requires: [...e.requires] }));
+}
+function getCatalogEntry(pluginName) {
+  return CATALOG.find((e) => e.pluginName === pluginName);
+}
+const DEFAULT_COMPONENT_KEYS = {
+  "product-page": "p",
+  "product-search": "search",
+  "cart-indicator": "cart",
+  "cart-page": "cartPage",
+  "category-list": "categories"
+};
+function getDefaultComponentKey(contractName) {
+  if (contractName in DEFAULT_COMPONENT_KEYS) {
+    return DEFAULT_COMPONENT_KEYS[contractName];
+  }
+  return contractName.charAt(0) || "c";
+}
+class AddPagePromptLoadError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AddPagePromptLoadError";
+  }
+}
+function resolveAddPageAgentsRoot(fromModuleUrl = import.meta.url) {
+  const thisDir = path.dirname(fileURLToPath(fromModuleUrl));
+  const candidates = [
+    path.join(thisDir, "add-page-agent"),
+    path.join(thisDir, "..", "add-page-agent"),
+    path.join(thisDir, "..", "..", "add-page-agent"),
+    path.join(thisDir, "..", "..", "..", "add-page-agent")
+  ];
+  for (const root of candidates) {
+    const probe = path.join(root, "system.md");
+    if (fs$1.existsSync(probe)) {
+      return root;
+    }
+  }
+  throw new AddPagePromptLoadError(
+    `add-page-agent root not found (searched from ${thisDir})`
+  );
+}
+async function loadAddPageAgentPrompts(options) {
+  const agentsRoot = resolveAddPageAgentsRoot(import.meta.url);
+  const systemPath = path.join(agentsRoot, "system.md");
+  const skillPath = path.join(agentsRoot, "SKILL.md");
+  let system;
+  let skill;
+  try {
+    system = await readFile(systemPath, "utf-8");
+  } catch {
+    throw new AddPagePromptLoadError(`missing system prompt: ${systemPath}`);
+  }
+  try {
+    skill = await readFile(skillPath, "utf-8");
+  } catch {
+    throw new AddPagePromptLoadError(`missing skill document: ${skillPath}`);
+  }
+  return { system, skill };
+}
+async function listDirFiles(dir, prefix) {
+  try {
+    const names = await readdir(dir);
+    return names.map((n) => `${prefix}/${n}`);
+  } catch {
+    return [];
+  }
+}
+function buildPluginManifestPromptSection(selectedPlugins) {
+  const lines = [
+    "",
+    "## Page plugin manifest (authoritative)",
+    "",
+    "The user selected these headless components for this page. You MUST:",
+    '1. Add `<script type="application/jay-headless" plugin="..." contract="..." key="...">` for each entry',
+    "2. Bind UI using contract ViewState and refs per agent-kit designer guides",
+    "3. Run jay-stack validate",
+    "",
+    "| Plugin | Contract | Key | Notes |",
+    "| --- | --- | --- | --- |"
+  ];
+  for (const plugin of selectedPlugins) {
+    for (const contract of plugin.contracts) {
+      const key = contract.componentKey ?? getDefaultComponentKey(contract.contractName);
+      lines.push(
+        `| ${plugin.packageName} | ${contract.contractName} | ${key} | |`
+      );
+    }
+  }
+  lines.push(
+    "",
+    "If Wix config is incomplete, implement layout and headless imports; live store data may be unavailable until config/.wix.yaml is filled.",
+    ""
+  );
+  return lines.join("\n");
+}
+async function buildAddPagePrompt(input) {
+  const { system, skill } = await loadAddPageAgentPrompts();
+  const contentPath = path.join(input.requestDir, "content.md");
+  const designPath = path.join(input.requestDir, "design.md");
+  const references = await listDirFiles(
+    path.join(input.requestDir, "references"),
+    "references"
+  );
+  const assets = await listDirFiles(
+    path.join(input.requestDir, "assets"),
+    "assets"
+  );
+  const designerGuide = path.join(
+    input.projectDir,
+    "agent-kit",
+    "designer",
+    "INSTRUCTIONS.md"
+  );
+  const developerGuide = path.join(
+    input.projectDir,
+    "agent-kit",
+    "developer",
+    "INSTRUCTIONS.md"
+  );
+  const retryNote = input.isRetry ? `
+## Retry mode
+The page at route \`${input.pageRoute}\` may already have partial files from a previous run. Read existing page files and **fix** validate errors rather than recreating from scratch.
+` : "";
+  const manifestSection = input.selectedPlugins && input.selectedPlugins.length > 0 ? buildPluginManifestPromptSection(input.selectedPlugins) : "";
+  const userMessage = `# Add Page task
+
+Create **one** Jay Stack page at route: \`${input.pageRoute}\` (${input.routeKind}).
+${retryNote}
+## Brief files (read these first)
+
+- Content (behavior, plugins, contracts): \`${contentPath}\`
+- Design (layout, typography, colors): \`${designPath}\`
+
+## Reference attachments
+
+- Inspiration only (do not copy verbatim unless brief says so): ${references.length ? references.join(", ") : "(none)"}
+- Assets to embed (copy into project when cited in brief): ${assets.length ? assets.join(", ") : "(none)"}
+
+Asset files live under the request folder. **Copy** cited assets from \`${input.requestDir}\` into appropriate project paths (\`public/\`, etc.) when implementing.
+
+## Project guides
+
+- Designer: \`${designerGuide}\`
+- Developer: \`${developerGuide}\`
+
+## Output
+
+- Create page files under \`src/pages/\` matching the route per Jay directory routing conventions.
+- Match user intent from content.md and design.md as closely as possible.
+- Reuse existing site patterns (header, footer, styling) from other pages when design.md requests it.
+- Summarize files created and how they cover the brief when done.
+${manifestSection}
+---
+
+${skill}`;
+  return { system, userMessage };
+}
+async function* streamAddPageAgentQuery(input) {
+  const { system, userMessage } = await buildAddPagePrompt(input);
+  const routeKey = normalizePageRoute(input.pageRoute);
+  if (!tryBeginRouteQuery(routeKey)) {
+    yield {
+      type: "error",
+      message: "Another agent task is already running for this page. Wait for it to finish, then try again."
+    };
+    return;
+  }
+  const sessionPlan = await getOrCreateSessionIdForRoute(
+    input.projectDir,
+    routeKey
+  );
+  const sharedOptions = {
+    cwd: input.projectDir,
+    tools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+    allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+    maxTurns: 40,
+    persistSession: true,
+    systemPrompt: system
+  };
+  try {
+    async function* streamQuery(opts) {
+      for await (const message of query({
+        prompt: userMessage,
+        options: { ...sharedOptions, ...opts }
+      })) {
+        for (const chunk of transformSDKMessage(
+          message
+        )) {
+          yield chunk;
+        }
+      }
+    }
+    let didStaleResumeRetry = false;
+    try {
+      if (sessionPlan.useResume) {
+        yield* streamQuery({ resume: sessionPlan.sessionId });
+      } else {
+        yield* streamQuery({
+          sessionId: sessionPlan.sessionId,
+          title: routeKey
+        });
+      }
+    } catch (err) {
+      if (sessionPlan.useResume && !didStaleResumeRetry) {
+        didStaleResumeRetry = true;
+        const fresh = await replaceRouteSessionAfterStaleResume(
+          input.projectDir,
+          routeKey
+        );
+        try {
+          yield* streamQuery({
+            sessionId: fresh.sessionId,
+            title: routeKey
+          });
+        } catch (err2) {
+          yield {
+            type: "error",
+            message: err2 instanceof Error ? err2.message : String(err2)
+          };
+        }
+      } else {
+        yield {
+          type: "error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  } finally {
+    endRouteQuery(routeKey);
+  }
+}
+const PAGE_REQUESTS_DIR_SEGMENT = ".aiditor/page-requests";
+function getPageRequestsRoot(projectRoot) {
+  return path.join(projectRoot, PAGE_REQUESTS_DIR_SEGMENT);
+}
+function getPageRequestDir(projectRoot, requestId) {
+  return path.join(getPageRequestsRoot(projectRoot), requestId);
+}
+function generatePageRequestId() {
+  return crypto.randomUUID();
+}
+function sanitizeAttachmentFilename(name) {
+  const base = path.basename(name).toLowerCase();
+  const sanitized = base.replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-");
+  return sanitized || "file";
+}
+async function ensurePageRequestDir(projectRoot, requestId) {
+  const requestDir = getPageRequestDir(projectRoot, requestId);
+  await fs.mkdir(path.join(requestDir, "assets"), { recursive: true });
+  await fs.mkdir(path.join(requestDir, "references"), { recursive: true });
+  return requestDir;
+}
+async function createPageRequest(projectRoot, input) {
+  const requestId = input.requestId ?? generatePageRequestId();
+  const requestDir = await ensurePageRequestDir(projectRoot, requestId);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const request = {
+    requestId,
+    kind: "add_page",
+    pageRoute: input.pageRoute,
+    routeKind: input.routeKind,
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+    contentMdPath: "content.md",
+    designMdPath: "design.md",
+    references: [],
+    assets: []
+  };
+  await writePageRequest(projectRoot, request);
+  await fs.writeFile(path.join(requestDir, "content.md"), "", "utf-8");
+  await fs.writeFile(path.join(requestDir, "design.md"), "", "utf-8");
+  return { requestDir, request };
+}
+async function readPageRequest(projectRoot, requestId) {
+  const requestPath = path.join(
+    getPageRequestDir(projectRoot, requestId),
+    "request.json"
+  );
+  try {
+    const raw = await fs.readFile(requestPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (e) {
+    const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+    if (code === "ENOENT") return null;
+    throw e;
+  }
+}
+async function writePageRequestAtomic(requestDir, request) {
+  const requestPath = path.join(requestDir, "request.json");
+  const tmp = `${requestPath}.${process.pid}.${Date.now()}.tmp`;
+  await fs.writeFile(tmp, `${JSON.stringify(request, null, 2)}
+`, "utf-8");
+  await fs.rename(tmp, requestPath);
+}
+async function writePageRequest(projectRoot, request) {
+  const requestDir = getPageRequestDir(projectRoot, request.requestId);
+  await writePageRequestAtomic(requestDir, request);
+}
+async function updatePageRequestStatus(projectRoot, requestId, status) {
+  const request = await readPageRequest(projectRoot, requestId);
+  if (!request) {
+    throw new Error(`Page request not found: ${requestId}`);
+  }
+  const updated = {
+    ...request,
+    status,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writePageRequest(projectRoot, updated);
+  return updated;
+}
+async function writePageRequestMarkdown(projectRoot, requestId, input) {
+  const requestDir = getPageRequestDir(projectRoot, requestId);
+  await fs.writeFile(
+    path.join(requestDir, "content.md"),
+    input.contentMd,
+    "utf-8"
+  );
+  await fs.writeFile(
+    path.join(requestDir, "design.md"),
+    input.designMd,
+    "utf-8"
+  );
+  const request = await readPageRequest(projectRoot, requestId);
+  if (request) {
+    await writePageRequest(projectRoot, {
+      ...request,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+}
+async function addPageRequestAttachment(projectRoot, requestId, entry, role) {
+  const request = await readPageRequest(projectRoot, requestId);
+  if (!request) {
+    throw new Error(`Page request not found: ${requestId}`);
+  }
+  const updated = {
+    ...request,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    references: role === "reference" ? [
+      ...request.references.filter((r) => r.id !== entry.id),
+      entry
+    ] : request.references,
+    assets: role === "asset" ? [
+      ...request.assets.filter((a) => a.id !== entry.id),
+      entry
+    ] : request.assets
+  };
+  await writePageRequest(projectRoot, updated);
+  return updated;
+}
+async function reclassifyPageRequestAttachment(projectRoot, requestId, attachmentId, newRole) {
+  const request = await readPageRequest(projectRoot, requestId);
+  if (!request) {
+    throw new Error(`Page request not found: ${requestId}`);
+  }
+  const requestDir = getPageRequestDir(projectRoot, requestId);
+  const refIx = request.references.findIndex((r) => r.id === attachmentId);
+  const assetIx = request.assets.findIndex((a) => a.id === attachmentId);
+  let relPath;
+  let label;
+  if (refIx >= 0) {
+    relPath = request.references[refIx].path;
+    label = request.references[refIx].label;
+  } else if (assetIx >= 0) {
+    relPath = request.assets[assetIx].path;
+  } else {
+    throw new Error(`Attachment not found: ${attachmentId}`);
+  }
+  const filename = path.basename(relPath);
+  const destSubdir = newRole === "asset" ? "assets" : "references";
+  const srcAbs = path.join(requestDir, relPath);
+  const destRel = `${destSubdir}/${filename}`;
+  const destAbs = path.join(requestDir, destRel);
+  await fs.rename(srcAbs, destAbs);
+  const references = request.references.filter((r) => r.id !== attachmentId);
+  const assets = request.assets.filter((a) => a.id !== attachmentId);
+  if (newRole === "reference") {
+    references.push({ id: attachmentId, path: destRel, label });
+  } else {
+    assets.push({
+      id: attachmentId,
+      path: destRel,
+      markdownRef: destRel
+    });
+  }
+  const updated = {
+    ...request,
+    references,
+    assets,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writePageRequest(projectRoot, updated);
+  return updated;
+}
+function inferRouteKind(route) {
+  return /\[[^\]/]+\]/.test(route) ? "dynamic" : "static";
+}
+function validatePageRouteSyntax(route) {
+  const trimmed = route.trim();
+  if (!trimmed) {
+    return { valid: false, error: "Route is required." };
+  }
+  if (!trimmed.startsWith("/")) {
+    return { valid: false, error: "Route must start with /." };
+  }
+  const normalized = normalizePageRoute(trimmed);
+  if (normalized.includes("//")) {
+    return { valid: false, error: "Route contains invalid segments." };
+  }
+  const dynamicSegments = normalized.match(/\[([^\]]*)\]/g) ?? [];
+  for (const seg of dynamicSegments) {
+    const inner = seg.slice(1, -1).trim();
+    if (!inner) {
+      return {
+        valid: false,
+        error: "Dynamic segments must have a param name, e.g. [slug]."
+      };
+    }
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(inner)) {
+      return {
+        valid: false,
+        error: `Invalid dynamic segment ${seg}. Use [paramName] format.`
+      };
+    }
+  }
+  return { valid: true };
+}
+function routeExistsInProject(normalizedRoute, projectRoutes) {
+  return projectRoutes.some(
+    (r) => normalizePageRoute(r.path) === normalizedRoute
+  );
+}
+async function runAddPageValidate(projectDir) {
+  return new Promise((resolve) => {
+    const child = spawn("npx", ["jay-stack-cli", "validate"], {
+      cwd: projectDir,
+      shell: true,
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("close", (code) => {
+      const combined = `${stdout}
+${stderr}`.trim();
+      if (code === 0) {
+        resolve({ ok: true, errors: [], stdout, stderr });
+        return;
+      }
+      const errors = combined.split("\n").map((line) => line.trim()).filter(Boolean);
+      resolve({
+        ok: false,
+        errors: errors.length > 0 ? errors : [`validate exited with code ${code}`],
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        ok: false,
+        errors: [err.message],
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+const PAGES_DIR_CANDIDATES = ["src/pages", "pages"];
+const PAGE_BRIEF_DIR_NAME = "add-page-brief";
+function resolveJayHtmlPath(projectDir, jayHtmlPath) {
+  return path.isAbsolute(jayHtmlPath) ? jayHtmlPath : path.join(projectDir, jayHtmlPath);
+}
+function getPageBriefDirForJayHtml(jayHtmlPath) {
+  return path.join(path.dirname(jayHtmlPath), PAGE_BRIEF_DIR_NAME);
+}
+function getPageBriefContentPath(briefDir) {
+  return path.join(briefDir, "content.md");
+}
+function getPageBriefDesignPath(briefDir) {
+  return path.join(briefDir, "design.md");
+}
+async function resolveJayHtmlPathForPageRoute(projectDir, normalizedRoute, cachedRoutes) {
+  if (cachedRoutes) {
+    const fromCache = cachedRoutes.find(
+      (r) => normalizePageRoute(r.path) === normalizedRoute
+    );
+    if (fromCache?.jayHtmlPath) return fromCache.jayHtmlPath;
+  }
+  for (const rel of PAGES_DIR_CANDIDATES) {
+    const pagesDir = path.join(projectDir, rel);
+    try {
+      await fs.access(pagesDir);
+    } catch {
+      continue;
+    }
+    const routes = await scanRoutes(pagesDir, {
+      jayHtmlFilename: "page.jay-html",
+      compFilename: "page.ts"
+    });
+    const match = routes.find(
+      (r) => normalizePageRoute(r.rawRoute) === normalizedRoute
+    );
+    if (match?.jayHtmlPath) return match.jayHtmlPath;
+  }
+  return null;
+}
+async function tryBackfillPageBriefForRoute(projectDir, jayHtmlPath, pageRoute) {
+  if (await pageBriefExists(projectDir, jayHtmlPath)) {
+    return true;
+  }
+  const normalized = normalizePageRoute(pageRoute);
+  const requestsRoot = getPageRequestsRoot(projectDir);
+  let requestDirs = [];
+  try {
+    requestDirs = await fs.readdir(requestsRoot);
+  } catch {
+    return false;
+  }
+  let best = null;
+  for (const dir of requestDirs) {
+    const request = await readPageRequest(projectDir, dir);
+    if (!request || request.status !== "completed" || normalizePageRoute(request.pageRoute) !== normalized) {
+      continue;
+    }
+    if (!best || new Date(request.updatedAt).getTime() > new Date(best.updatedAt).getTime()) {
+      best = request;
+    }
+  }
+  if (!best) return false;
+  const requestDir = getPageRequestDir(projectDir, best.requestId);
+  let contentMd = "";
+  let designMd = "";
+  try {
+    contentMd = await fs.readFile(path.join(requestDir, "content.md"), "utf-8");
+    designMd = await fs.readFile(path.join(requestDir, "design.md"), "utf-8");
+  } catch {
+    return false;
+  }
+  await savePageBriefFromRequest(projectDir, jayHtmlPath, {
+    requestId: best.requestId,
+    pageRoute: normalized,
+    contentMd,
+    designMd
+  });
+  return true;
+}
+async function pageBriefExists(projectDir, jayHtmlPath) {
+  const absJayHtml = resolveJayHtmlPath(projectDir, jayHtmlPath);
+  const briefDir = getPageBriefDirForJayHtml(absJayHtml);
+  try {
+    await fs.access(getPageBriefContentPath(briefDir));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyDirFiles(srcDir, destDir) {
+  await fs.mkdir(destDir, { recursive: true });
+  let entries = [];
+  try {
+    entries = await fs.readdir(srcDir);
+  } catch (e) {
+    const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+    if (code === "ENOENT") return;
+    throw e;
+  }
+  for (const name of entries) {
+    const src = path.join(srcDir, name);
+    const dest = path.join(destDir, name);
+    const stat = await fs.stat(src);
+    if (stat.isFile()) {
+      await fs.copyFile(src, dest);
+    }
+  }
+}
+async function savePageBriefFromRequest(projectDir, jayHtmlPath, input) {
+  const absJayHtml = resolveJayHtmlPath(projectDir, jayHtmlPath);
+  const briefDir = getPageBriefDirForJayHtml(absJayHtml);
+  const requestDir = getPageRequestDir(projectDir, input.requestId);
+  await fs.mkdir(path.join(briefDir, "assets"), { recursive: true });
+  await fs.mkdir(path.join(briefDir, "references"), { recursive: true });
+  await fs.writeFile(
+    getPageBriefContentPath(briefDir),
+    input.contentMd,
+    "utf-8"
+  );
+  await fs.writeFile(getPageBriefDesignPath(briefDir), input.designMd, "utf-8");
+  await copyDirFiles(
+    path.join(requestDir, "assets"),
+    path.join(briefDir, "assets")
+  );
+  await copyDirFiles(
+    path.join(requestDir, "references"),
+    path.join(briefDir, "references")
+  );
+  const manifest = {
+    sourceRoute: normalizePageRoute(input.pageRoute),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: input.requestId
+  };
+  await fs.writeFile(
+    path.join(briefDir, "brief.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf-8"
+  );
+}
+async function readOptionalJson(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function listBriefAttachments(briefDir) {
+  const attachments = [];
+  for (const role of ["asset", "reference"]) {
+    const subdir = role === "asset" ? "assets" : "references";
+    const dirPath = path.join(briefDir, subdir);
+    let names = [];
+    try {
+      names = await fs.readdir(dirPath);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const abs = path.join(dirPath, name);
+      const stat = await fs.stat(abs);
+      if (!stat.isFile()) continue;
+      attachments.push({
+        id: crypto.randomUUID(),
+        path: `${subdir}/${name}`,
+        role,
+        filename: name
+      });
+    }
+  }
+  return attachments;
+}
+async function readPageBrief(projectDir, jayHtmlPath) {
+  const absJayHtml = resolveJayHtmlPath(projectDir, jayHtmlPath);
+  const briefDir = getPageBriefDirForJayHtml(absJayHtml);
+  const contentPath = getPageBriefContentPath(briefDir);
+  try {
+    await fs.access(contentPath);
+  } catch {
+    return null;
+  }
+  const contentMd = await fs.readFile(contentPath, "utf-8");
+  let designMd = "";
+  try {
+    designMd = await fs.readFile(getPageBriefDesignPath(briefDir), "utf-8");
+  } catch {
+  }
+  const manifest = await readOptionalJson(
+    path.join(briefDir, "brief.json")
+  ) ?? {
+    sourceRoute: "",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ""
+  };
+  const attachments = await listBriefAttachments(briefDir);
+  return { manifest, contentMd, designMd, attachments };
+}
+function isDynamicSegment(segment) {
+  return segment.includes("[");
+}
+function suggestCopyRoute(sourceRoute, existingRoutes) {
+  const normalized = normalizePageRoute(sourceRoute);
+  const existing = new Set(
+    existingRoutes.map((r) => normalizePageRoute(r.path))
+  );
+  const segments = normalized.split("/").filter(Boolean);
+  let lastStaticIdx = -1;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (!isDynamicSegment(segments[i])) {
+      lastStaticIdx = i;
+      break;
+    }
+  }
+  const buildRoute = (suffix) => {
+    if (lastStaticIdx < 0) {
+      return normalizePageRoute(`${normalized}${suffix}`);
+    }
+    const next = [...segments];
+    next[lastStaticIdx] = `${next[lastStaticIdx]}${suffix}`;
+    return normalizePageRoute(`/${next.join("/")}`);
+  };
+  let candidate = buildRoute("-copy");
+  if (!existing.has(candidate)) return candidate;
+  for (let n = 2; n < 100; n++) {
+    candidate = buildRoute(`-copy-${n}`);
+    if (!existing.has(candidate)) return candidate;
+  }
+  return buildRoute(`-copy-${Date.now()}`);
+}
+async function clonePageBriefToRequest(projectDir, jayHtmlPath, input) {
+  const brief = await readPageBrief(projectDir, jayHtmlPath);
+  if (!brief) {
+    throw new Error("No Add Page brief found for this page.");
+  }
+  const pageRoute = normalizePageRoute(input.pageRoute);
+  const routeKind = input.routeKind ?? inferRouteKind(pageRoute);
+  const { request } = await createPageRequest(projectDir, {
+    pageRoute,
+    routeKind
+  });
+  const absJayHtml = resolveJayHtmlPath(projectDir, jayHtmlPath);
+  const briefDir = getPageBriefDirForJayHtml(absJayHtml);
+  const requestDir = getPageRequestDir(projectDir, request.requestId);
+  await fs.writeFile(
+    path.join(requestDir, "content.md"),
+    brief.contentMd,
+    "utf-8"
+  );
+  await fs.writeFile(
+    path.join(requestDir, "design.md"),
+    brief.designMd,
+    "utf-8"
+  );
+  const attachments = [];
+  for (const attachment of brief.attachments) {
+    const src = path.join(briefDir, attachment.path);
+    const dest = path.join(requestDir, attachment.path);
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    await fs.copyFile(src, dest);
+    const id = generatePageRequestId();
+    if (attachment.role === "reference") {
+      const entry = {
+        id,
+        path: attachment.path,
+        label: attachment.filename
+      };
+      await addPageRequestAttachment(
+        projectDir,
+        request.requestId,
+        entry,
+        "reference"
+      );
+      attachments.push({ ...attachment, id });
+    } else {
+      const entry = {
+        id,
+        path: attachment.path,
+        markdownRef: attachment.path
+      };
+      await addPageRequestAttachment(
+        projectDir,
+        request.requestId,
+        entry,
+        "asset"
+      );
+      attachments.push({ ...attachment, id });
+    }
+  }
+  return {
+    requestId: request.requestId,
+    request,
+    contentMd: brief.contentMd,
+    designMd: brief.designMd,
+    attachments
+  };
+}
+const BRIEF_FILL_MAX_IMAGES = 5;
+const BRIEF_FILL_MAX_TURNS = 3;
+const BRIEF_FILL_PROMPT_FILES = {
+  brief: "add-page-figma-brief-prompt.md",
+  designFromImage: "add-page-figma-design-from-image-prompt.md",
+  designDefinitions: "add-page-figma-design-definitions-prompt.md"
+};
+function extractCopyPastePromptBody(markdown) {
+  const parts = markdown.split(/\r?\n---\r?\n/);
+  if (parts.length < 2) return markdown.trim();
+  return parts[1].trim();
+}
+function moduleDirectory() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+function resolveBriefFillPromptsDir() {
+  const candidates = [
+    path.join(moduleDirectory(), "prompts"),
+    path.join(moduleDirectory(), "../../../../../docs")
+  ];
+  for (const dir of candidates) {
+    const briefPath = path.join(dir, BRIEF_FILL_PROMPT_FILES.brief);
+    if (fs$1.existsSync(briefPath)) return dir;
+  }
+  throw new Error(
+    "Brief fill prompt files not found. Run `yarn build` in @jay-framework/aiditor or ensure docs/add-page-figma-*.md exist."
+  );
+}
+function readPromptFile(filename, promptsDir) {
+  const dir = resolveBriefFillPromptsDir();
+  const filePath = path.join(dir, filename);
+  const raw = fs$1.readFileSync(filePath, "utf-8");
+  return extractCopyPastePromptBody(raw);
+}
+const CONTENT_FILL_SUFFIX = `
+
+---
+
+## AIditor — Fill from image (Content field)
+
+You are invoked from AIditor **Fill from image** on the **Content** composer field.
+
+Follow the prompt above. Produce **only**:
+
+- **Section 1** — Suggested page route (when inferable from the screenshot or context notes)
+- **Section 2** — Content brief (use the full structure specified above)
+
+Do **not** output Section 3 (Design brief), Section 4 (Checklist), or any Design markdown. The user fills Design in a separate step.`;
+const DESIGN_FILL_SUFFIX = `
+
+---
+
+## AIditor — Fill from image (Design field)
+
+You are invoked from AIditor **Fill from image** on the **Design** composer field.
+
+Follow the prompt above. Produce **only** the Design markdown document (one block for AIditor → Design).
+
+Do **not** output a Content brief, suggested route, or plugin behavior sections.`;
+const cache = /* @__PURE__ */ new Map();
+function loadCached(key, loader) {
+  const hit = cache.get(key);
+  if (hit !== void 0) return hit;
+  const value = loader();
+  cache.set(key, value);
+  return value;
+}
+function loadBriefFillSystemPrompt(target, promptsDir) {
+  const cacheKey = `${target}:${"default"}`;
+  return loadCached(cacheKey, () => {
+    if (target === "content") {
+      const briefBody = readPromptFile(
+        BRIEF_FILL_PROMPT_FILES.brief
+      );
+      return `${briefBody}${CONTENT_FILL_SUFFIX}`;
+    }
+    const designFromImageBody = readPromptFile(
+      BRIEF_FILL_PROMPT_FILES.designFromImage
+    );
+    const designDefinitionsBody = readPromptFile(
+      BRIEF_FILL_PROMPT_FILES.designDefinitions
+    );
+    return `${designFromImageBody}${DESIGN_FILL_SUFFIX}
+
+---
+
+## Reference — design definitions board (Mode A)
+
+When the image is a formal Figma **design definitions** board, apply these rules in full (in addition to Mode A above):
+
+${designDefinitionsBody}`;
+  });
+}
+const BRIEF_FILL_MODEL = process.env.AIDITOR_BRIEF_FILL_MODEL ?? "claude-sonnet-4-20250514";
+const ALLOWED_IMAGE_MIMES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/jpg",
+  "image/webp",
+  "image/gif"
+]);
+function stripMarkdownFences(text) {
+  const t = text.trim();
+  const fenceMatch = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/i.exec(t);
+  if (fenceMatch) return fenceMatch[1].trim();
+  return t;
+}
+const SUGGESTED_ROUTE_RE = /(?:Suggested route|Route)[^:\n]*:+\s*(?:\*\*\s*)?(?:`(\/[^`]+)`|(\/[^\s(]+(?:\[[^\]]+\])?))\s*(?:\((static|dynamic)\))?/i;
+function parseSuggestedRoute(raw) {
+  const stripped = stripMarkdownFences(raw);
+  const lines = stripped.split("\n");
+  let suggestedRoute;
+  let suggestedRouteKind;
+  const bodyLines = [];
+  for (const line of lines) {
+    const m = SUGGESTED_ROUTE_RE.exec(line);
+    if (m && !suggestedRoute) {
+      suggestedRoute = (m[1] ?? m[2] ?? "").replace(/\/+$/, "") || "/";
+      if (m[3] === "static" || m[3] === "dynamic") {
+        suggestedRouteKind = m[3];
+      }
+      continue;
+    }
+    bodyLines.push(line);
+  }
+  let markdown = bodyLines.join("\n").trim();
+  markdown = markdown.replace(/^---\s*\n+/, "").trim();
+  return { markdown, suggestedRoute, suggestedRouteKind };
+}
+function extractImageFilesFromExtraFiles(extraFiles) {
+  if (!extraFiles) return [];
+  const indexed = [];
+  for (const [key, file] of Object.entries(extraFiles)) {
+    const m = /^image_(\d+)$/.exec(key);
+    if (!m || !file) continue;
+    indexed.push({ index: Number.parseInt(m[1], 10), file });
+  }
+  indexed.sort((a, b) => a.index - b.index);
+  return indexed.map((e) => e.file);
+}
+function normalizeImageMime(mime, filename) {
+  const t = mime.toLowerCase().split(";")[0].trim();
+  if (ALLOWED_IMAGE_MIMES.has(t)) {
+    return t === "image/jpg" ? "image/jpeg" : t;
+  }
+  const ext = filename.toLowerCase().split(".").pop() ?? "";
+  if (ext === "png") return "image/png";
+  if (ext === "jpg" || ext === "jpeg") return "image/jpeg";
+  if (ext === "webp") return "image/webp";
+  if (ext === "gif") return "image/gif";
+  return t;
+}
+function validateBriefFillImages(files) {
+  if (files.length === 0) {
+    return "Add at least one image before generating.";
+  }
+  if (files.length > BRIEF_FILL_MAX_IMAGES) {
+    return `Maximum ${BRIEF_FILL_MAX_IMAGES} images per request.`;
+  }
+  for (const f of files) {
+    const mime = normalizeImageMime(f.type ?? "", f.name);
+    if (!ALLOWED_IMAGE_MIMES.has(mime) && !mime.startsWith("image/")) {
+      return `Unsupported file type: ${f.name}. Use PNG, JPEG, WebP, or GIF.`;
+    }
+  }
+  return null;
+}
+function readImageAsBase64(file) {
+  const buf = fs$1.readFileSync(file.path);
+  const mimeType = normalizeImageMime(file.type ?? "", file.name);
+  return {
+    name: file.name,
+    mimeType,
+    base64: buf.toString("base64")
+  };
+}
+function buildBriefFillUserMessage(target, images, contextNotes, pageRoute) {
+  const parts = [];
+  parts.push(
+    target === "content" ? "Generate the Content brief markdown for AIditor Add Page from the attached screenshot(s)." : "Generate the Design brief markdown for AIditor Add Page from the attached screenshot(s)."
+  );
+  if (pageRoute?.trim()) {
+    parts.push(`User already typed page route: ${pageRoute.trim()}`);
+  }
+  if (contextNotes?.trim()) {
+    parts.push("", "User context notes:", contextNotes.trim());
+  }
+  parts.push("", `Attached images: ${images.length}`);
+  for (let i = 0; i < images.length; i++) {
+    parts.push(`- Image ${i + 1}: ${images[i].name}`);
+  }
+  return parts.join("\n");
+}
+function buildBriefFillMessageContent(images, userText) {
+  return [
+    ...images.flatMap((img, i) => [
+      { type: "text", text: `[Image ${i + 1}: ${img.name}]` },
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: img.mimeType,
+          data: img.base64
+        }
+      }
+    ]),
+    { type: "text", text: userText }
+  ];
+}
+async function* briefFillPromptStream(userText, images) {
+  yield {
+    type: "user",
+    message: {
+      role: "user",
+      content: buildBriefFillMessageContent(images, userText)
+    },
+    parent_tool_use_id: null
+  };
+}
+function extractBriefFillRawText(messages) {
+  let rawText = "";
+  for (const message of messages) {
+    if (message.type === "assistant" && Array.isArray(message.message?.content)) {
+      for (const block of message.message.content) {
+        if (block.type === "text" && block.text?.trim()) {
+          rawText = block.text.trim();
+        }
+      }
+    }
+    if (message.type === "result" && message.subtype === "success" && message.result?.trim() && !rawText) {
+      rawText = message.result.trim();
+    }
+    if (message.type === "result" && message.is_error) {
+      const detail = message.errors?.join("; ") || "Brief generation failed. Try again.";
+      throw new Error(detail);
+    }
+  }
+  return rawText;
+}
+async function runBriefFillAgentQuery(input) {
+  const systemPrompt = loadBriefFillSystemPrompt(input.target);
+  const userText = buildBriefFillUserMessage(
+    input.target,
+    input.images,
+    input.contextNotes,
+    input.pageRoute
+  );
+  const collected = [];
+  for await (const message of query({
+    prompt: briefFillPromptStream(userText, input.images),
+    options: {
+      cwd: input.projectDir,
+      tools: [],
+      maxTurns: BRIEF_FILL_MAX_TURNS,
+      persistSession: false,
+      systemPrompt,
+      model: BRIEF_FILL_MODEL,
+      thinking: { type: "disabled" }
+    }
+  })) {
+    collected.push(message);
+  }
+  const rawText = extractBriefFillRawText(collected);
+  if (!rawText) {
+    throw new Error(
+      "AI returned an empty brief. Try again with a clearer image."
+    );
+  }
+  return rawText;
+}
+async function generateBriefFromImages(input, options) {
+  const rawText = await runBriefFillAgentQuery({
+    projectDir: options.projectDir,
+    ...input
+  });
+  if (input.target === "content") {
+    const parsed = parseSuggestedRoute(rawText);
+    if (!parsed.markdown.trim()) {
+      throw new Error("AI returned an empty Content brief.");
+    }
+    return parsed;
+  }
+  const markdown = stripMarkdownFences(rawText);
+  if (!markdown.trim()) {
+    throw new Error("AI returned an empty Design brief.");
+  }
+  return { markdown };
+}
+function persistUpload(file, destPath) {
+  fs$1.mkdirSync(path.dirname(destPath), { recursive: true });
+  fs$1.copyFileSync(file.path, destPath);
+}
+const checkAddPageRouteAction = makeJayQuery("aiditor.checkAddPageRoute").withServices(DEV_SERVER_SERVICE).withHandler(async (input, devServer) => {
+  const syntax = validatePageRouteSyntax(input.pageRoute);
+  if (!syntax.valid) {
+    return {
+      normalizedRoute: "",
+      routeKind: "static",
+      routeExists: false,
+      valid: false,
+      error: syntax.error
+    };
+  }
+  const normalizedRoute = normalizePageRoute(input.pageRoute);
+  const routeKind = inferRouteKind(normalizedRoute);
+  const routeExists = routeExistsInProject(
+    normalizedRoute,
+    devServer.listRoutes()
+  );
+  return {
+    normalizedRoute,
+    routeKind,
+    routeExists,
+    valid: true
+  };
+});
+const startAddPageRequestAction = makeJayQuery(
+  "aiditor.startAddPageRequest"
+).withServices(DEV_SERVER_SERVICE).withHandler(
+  async (input, devServer) => {
+    const syntax = validatePageRouteSyntax(input.pageRoute);
+    if (!syntax.valid) {
+      return {
+        requestId: "",
+        requestDir: "",
+        routeExists: false,
+        routeExistsMessage: syntax.error
+      };
+    }
+    const normalizedRoute = normalizePageRoute(input.pageRoute);
+    const routeKind = inferRouteKind(normalizedRoute);
+    const routeExists = routeExistsInProject(
+      normalizedRoute,
+      devServer.listRoutes()
+    );
+    if (routeExists) {
+      return {
+        requestId: "",
+        requestDir: "",
+        routeExists: true,
+        routeExistsMessage: "This route already exists."
+      };
+    }
+    const projectDir = process.cwd();
+    const { requestDir, request } = await createPageRequest(projectDir, {
+      pageRoute: normalizedRoute,
+      routeKind
+    });
+    return {
+      requestId: request.requestId,
+      requestDir,
+      routeExists: false
+    };
+  }
+);
+const saveAddPageDraftAction = makeJayQuery(
+  "aiditor.saveAddPageDraft"
+).withHandler(
+  async (input) => {
+    const projectDir = process.cwd();
+    const request = await readPageRequest(projectDir, input.requestId);
+    if (!request) {
+      return { ok: false };
+    }
+    await writePageRequestMarkdown(projectDir, input.requestId, {
+      contentMd: input.contentMd,
+      designMd: input.designMd
+    });
+    return { ok: true };
+  }
+);
+const uploadAddPageAssetAction = makeJayQuery(
+  "aiditor.uploadAddPageAsset"
+).withMethod("POST").withFiles().withHandler(
+  async (input) => {
+    if (!input.file) {
+      throw new Error("No file uploaded.");
+    }
+    const projectDir = process.cwd();
+    const request = await readPageRequest(projectDir, input.requestId);
+    if (!request) {
+      throw new Error(`Page request not found: ${input.requestId}`);
+    }
+    const id = generatePageRequestId();
+    const filename = sanitizeAttachmentFilename(input.file.name);
+    const subdir = input.role === "asset" ? "assets" : "references";
+    const relPath = `${subdir}/${filename}`;
+    const destPath = path.join(
+      getPageRequestDir(projectDir, input.requestId),
+      relPath
+    );
+    persistUpload(input.file, destPath);
+    if (input.role === "asset") {
+      await addPageRequestAttachment(
+        projectDir,
+        input.requestId,
+        { id, path: relPath, markdownRef: relPath },
+        "asset"
+      );
+      const base = path.basename(filename, path.extname(filename));
+      return {
+        id,
+        path: relPath,
+        markdownRef: relPath,
+        markdownSnippet: `![${base}](${relPath})`
+      };
+    }
+    await addPageRequestAttachment(
+      projectDir,
+      input.requestId,
+      { id, path: relPath, label: filename },
+      "reference"
+    );
+    return {
+      id,
+      path: relPath,
+      markdownRef: relPath
+    };
+  }
+);
+const reclassifyAddPageAssetAction = makeJayQuery(
+  "aiditor.reclassifyAddPageAsset"
+).withHandler(
+  async (input) => {
+    const projectDir = process.cwd();
+    const updated = await reclassifyPageRequestAttachment(
+      projectDir,
+      input.requestId,
+      input.attachmentId,
+      input.newRole
+    );
+    const entry = input.newRole === "asset" ? updated.assets.find((a) => a.id === input.attachmentId) : updated.references.find((r) => r.id === input.attachmentId);
+    return {
+      ok: true,
+      path: entry?.path ?? "",
+      markdownRef: entry && "markdownRef" in entry ? entry.markdownRef : entry?.path
+    };
+  }
+);
+const checkPageAddPageBriefAction = makeJayQuery(
+  "aiditor.checkPageAddPageBrief"
+).withHandler(async (input) => {
+  const projectDir = process.cwd();
+  if (await pageBriefExists(projectDir, input.jayHtmlPath)) {
+    return { hasBrief: true };
+  }
+  if (input.pageRoute?.trim()) {
+    const backfilled = await tryBackfillPageBriefForRoute(
+      projectDir,
+      input.jayHtmlPath,
+      input.pageRoute
+    );
+    if (backfilled) {
+      return { hasBrief: true };
+    }
+  }
+  return { hasBrief: false };
+});
+const openAddPageFromBriefAction = makeJayQuery(
+  "aiditor.openAddPageFromBrief"
+).withServices(DEV_SERVER_SERVICE).withHandler(
+  async (input, devServer) => {
+    const projectDir = process.cwd();
+    const syntax = validatePageRouteSyntax(input.sourcePageRoute);
+    if (!syntax.valid) {
+      return { ok: false, error: syntax.error ?? "Invalid source route." };
+    }
+    const sourceRoute = normalizePageRoute(input.sourcePageRoute);
+    const copyRoute = suggestCopyRoute(sourceRoute, devServer.listRoutes());
+    const copySyntax = validatePageRouteSyntax(copyRoute);
+    if (!copySyntax.valid) {
+      return {
+        ok: false,
+        error: copySyntax.error ?? "Could not derive a copy route."
+      };
+    }
+    if (routeExistsInProject(copyRoute, devServer.listRoutes())) {
+      return {
+        ok: false,
+        error: "Could not find a free route for the page copy."
+      };
+    }
+    try {
+      const cloned = await clonePageBriefToRequest(
+        projectDir,
+        input.jayHtmlPath,
+        { pageRoute: copyRoute }
+      );
+      return {
+        ok: true,
+        requestId: cloned.requestId,
+        pageRoute: copyRoute,
+        routeKind: inferRouteKind(copyRoute),
+        contentMd: cloned.contentMd,
+        designMd: cloned.designMd,
+        attachments: cloned.attachments
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+);
+const submitAddPageAction = makeJayStream("aiditor.submitAddPage").withServices(DEV_SERVER_SERVICE).withHandler(async function* (input, devServer) {
+  const projectDir = process.cwd();
+  const syntax = validatePageRouteSyntax(input.pageRoute);
+  if (!syntax.valid) {
+    yield { type: "error", message: syntax.error ?? "Invalid route." };
+    yield { type: "done" };
+    return;
+  }
+  const normalizedRoute = normalizePageRoute(input.pageRoute);
+  const routeKind = inferRouteKind(normalizedRoute);
+  if (routeExistsInProject(normalizedRoute, devServer.listRoutes()) && !input.isRetry) {
+    yield {
+      type: "error",
+      message: "This route already exists."
+    };
+    yield { type: "done" };
+    return;
+  }
+  const request = await readPageRequest(projectDir, input.requestId);
+  if (!request) {
+    yield { type: "error", message: "Page request not found." };
+    yield { type: "done" };
+    return;
+  }
+  await writePageRequestMarkdown(projectDir, input.requestId, {
+    contentMd: input.contentMd,
+    designMd: input.designMd
+  });
+  await updatePageRequestStatus(projectDir, input.requestId, "running");
+  const requestDir = getPageRequestDir(projectDir, input.requestId);
+  yield { type: "status", message: "Running Add Page agent…" };
+  let agentFailed = false;
+  try {
+    for await (const chunk of streamAddPageAgentQuery({
+      projectDir,
+      requestDir,
+      pageRoute: normalizedRoute,
+      routeKind,
+      isRetry: input.isRetry,
+      selectedPlugins: request.selectedPlugins
+    })) {
+      yield chunk;
+      if (chunk.type === "error") {
+        agentFailed = true;
+      }
+    }
+  } catch (err) {
+    agentFailed = true;
+    yield {
+      type: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (agentFailed) {
+    await updatePageRequestStatus(projectDir, input.requestId, "failed");
+    yield { type: "done" };
+    return;
+  }
+  yield { type: "status", message: "Running jay-stack validate…" };
+  const validateResult = await runAddPageValidate(projectDir);
+  if (!validateResult.ok) {
+    await updatePageRequestStatus(projectDir, input.requestId, "failed");
+    yield {
+      type: "error",
+      message: "Validation failed.",
+      text: validateResult.errors.join("\n"),
+      validateErrors: validateResult.errors
+    };
+    yield { type: "done" };
+    return;
+  }
+  await updatePageRequestStatus(projectDir, input.requestId, "completed");
+  await devServer.refreshRoutes();
+  const jayHtmlPath = await resolveJayHtmlPathForPageRoute(
+    projectDir,
+    normalizedRoute,
+    devServer.listRoutes()
+  );
+  if (jayHtmlPath) {
+    try {
+      await savePageBriefFromRequest(projectDir, jayHtmlPath, {
+        requestId: input.requestId,
+        pageRoute: normalizedRoute,
+        contentMd: input.contentMd,
+        designMd: input.designMd
+      });
+    } catch (err) {
+      getLogger().warn(
+        `[Add Page] Failed to save page brief for ${normalizedRoute}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  yield {
+    type: "result",
+    message: `Page created at ${normalizedRoute}.`,
+    text: normalizedRoute
+  };
+  yield { type: "done" };
+});
+const generateAddPageBriefFromImageAction = makeJayQuery(
+  "aiditor.generateAddPageBriefFromImage"
+).withMethod("POST").withFiles().withHandler(
+  async (input) => {
+    const imageFiles = extractImageFilesFromExtraFiles(input.extraFiles);
+    const validationError = validateBriefFillImages(imageFiles);
+    if (validationError) {
+      return { ok: false, error: validationError };
+    }
+    const projectDir = process.cwd();
+    if (input.requestId) {
+      const request = await readPageRequest(projectDir, input.requestId);
+      if (!request) {
+        return {
+          ok: false,
+          error: `Page request not found: ${input.requestId}`
+        };
+      }
+    }
+    try {
+      const images = imageFiles.map(readImageAsBase64);
+      const result = await generateBriefFromImages(
+        {
+          target: input.target,
+          images,
+          contextNotes: input.contextNotes,
+          pageRoute: input.pageRoute
+        },
+        { projectDir }
+      );
+      const referenceAttachments = [];
+      if (input.requestId) {
+        for (const file of imageFiles) {
+          const id = generatePageRequestId();
+          const filename = sanitizeAttachmentFilename(file.name);
+          const relPath = `references/${filename}`;
+          const destPath = path.join(
+            getPageRequestDir(projectDir, input.requestId),
+            relPath
+          );
+          persistUpload(file, destPath);
+          await addPageRequestAttachment(
+            projectDir,
+            input.requestId,
+            { id, path: relPath, label: filename },
+            "reference"
+          );
+          referenceAttachments.push({ id, path: relPath, filename });
+        }
+      }
+      return {
+        ok: true,
+        markdown: result.markdown,
+        suggestedRoute: result.suggestedRoute,
+        suggestedRouteKind: result.suggestedRouteKind,
+        referenceAttachments
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+);
+function parsePluginsIndexYaml(yaml) {
+  const entries = [];
+  let currentPlugin = null;
+  let inContracts = false;
+  for (const line of yaml.split("\n")) {
+    const pluginMatch = line.match(/^  - name:\s*(.+)$/);
+    if (pluginMatch && !line.startsWith("      ")) {
+      currentPlugin = pluginMatch[1].trim();
+      inContracts = false;
+      continue;
+    }
+    if (line.trim() === "contracts:") {
+      inContracts = true;
+      continue;
+    }
+    if (inContracts && currentPlugin) {
+      const contractMatch = line.match(/^      - name:\s*(.+)$/);
+      if (contractMatch) {
+        entries.push({
+          pluginName: currentPlugin,
+          contractName: contractMatch[1].trim()
+        });
+        continue;
+      }
+      const descMatch = line.match(/^        description:\s*(.+)$/);
+      if (descMatch && entries.length > 0) {
+        const last = entries[entries.length - 1];
+        if (last.pluginName === currentPlugin) {
+          last.description = descMatch[1].trim();
+        }
+        continue;
+      }
+      const typeMatch = line.match(/^        type:\s*(.+)$/);
+      if (typeMatch && entries.length > 0) {
+        const last = entries[entries.length - 1];
+        if (last.pluginName === currentPlugin) {
+          last.isDynamic = typeMatch[1].trim() === "dynamic";
+        }
+      }
+    }
+    if (line.match(/^    actions:/) || line.match(/^    routes:/)) {
+      inContracts = false;
+    }
+  }
+  return entries;
+}
+function packageNameToPluginName(packageName) {
+  const prefix = "@jay-framework/";
+  if (packageName.startsWith(prefix)) {
+    return packageName.slice(prefix.length);
+  }
+  return packageName;
+}
+async function readPackageJsonDeps(projectRoot) {
+  const raw = await fs.readFile(
+    path.join(projectRoot, "package.json"),
+    "utf-8"
+  );
+  const pkg = JSON.parse(raw);
+  return { ...pkg.devDependencies, ...pkg.dependencies };
+}
+async function getInstalledPlugins(projectRoot) {
+  const deps = await readPackageJsonDeps(projectRoot);
+  const installed = [];
+  for (const [packageName, spec] of Object.entries(deps)) {
+    if (!packageName.startsWith("@jay-framework/")) continue;
+    installed.push({
+      pluginName: packageNameToPluginName(packageName),
+      packageName,
+      installSpec: spec
+    });
+  }
+  return installed;
+}
+async function isPluginInstalled(projectRoot, pluginName) {
+  const installed = await getInstalledPlugins(projectRoot);
+  return installed.some((p) => p.pluginName === pluginName);
+}
+async function parsePluginsIndexContracts(projectRoot) {
+  const indexPath = path.join(projectRoot, "agent-kit", "plugins-index.yaml");
+  try {
+    const yaml = await fs.readFile(indexPath, "utf-8");
+    return parsePluginsIndexYaml(yaml);
+  } catch (e) {
+    const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+    if (code === "ENOENT") return [];
+    throw e;
+  }
+}
+async function parsePluginYamlContracts(projectRoot, pluginName) {
+  const pluginYamlPath = path.join(
+    projectRoot,
+    "node_modules",
+    "@jay-framework",
+    pluginName,
+    "plugin.yaml"
+  );
+  try {
+    const yaml = await fs.readFile(pluginYamlPath, "utf-8");
+    const entries = [];
+    let inContracts = false;
+    for (const line of yaml.split("\n")) {
+      if (line.trim() === "contracts:") {
+        inContracts = true;
+        continue;
+      }
+      if (inContracts) {
+        const nameMatch = line.match(/^  - name:\s*(.+)$/);
+        if (nameMatch) {
+          entries.push({
+            pluginName,
+            contractName: nameMatch[1].trim()
+          });
+        }
+        if (line.match(/^actions:/) || line.match(/^routes:/)) {
+          break;
+        }
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+const LOCAL_SPEC_PREFIXES = ["portal:", "file:", "workspace:"];
+function isRegistryInstallSpec(installSpec) {
+  if (!installSpec) return true;
+  return !LOCAL_SPEC_PREFIXES.some((p) => installSpec.startsWith(p));
+}
+const VALID_INSTALL_PREFIXES = ["portal:", "file:", "workspace:"];
+function stripYamlScalar(value) {
+  return value.replace(/^["']|["']$/g, "");
+}
+function isValidInstallSpec(spec) {
+  return VALID_INSTALL_PREFIXES.some((p) => spec.startsWith(p));
+}
+function getPluginSourcesPath(projectRoot) {
+  return path.join(projectRoot, ".aiditor", "plugin-sources.yaml");
+}
+function parsePluginSourcesYaml(yaml) {
+  const sources = [];
+  let current = null;
+  for (const line of yaml.split("\n")) {
+    const itemMatch = line.match(/^  - pluginName:\s*(.+)$/);
+    if (itemMatch) {
+      if (current?.pluginName && current.packageName && current.installSpec) {
+        sources.push(current);
+      }
+      current = { pluginName: itemMatch[1].trim() };
+      continue;
+    }
+    if (!current) continue;
+    const pkgMatch = line.match(/^    packageName:\s*(.+)$/);
+    if (pkgMatch) {
+      current.packageName = stripYamlScalar(pkgMatch[1].trim());
+      continue;
+    }
+    const specMatch = line.match(/^    installSpec:\s*(.+)$/);
+    if (specMatch) {
+      current.installSpec = stripYamlScalar(specMatch[1].trim());
+      continue;
+    }
+    const labelMatch = line.match(/^    label:\s*(.+)$/);
+    if (labelMatch) {
+      current.label = stripYamlScalar(labelMatch[1].trim());
+      continue;
+    }
+    const kindMatch = line.match(/^    kind:\s*(.+)$/);
+    if (kindMatch) {
+      current.kind = kindMatch[1].trim();
+      continue;
+    }
+    const descMatch = line.match(/^    description:\s*(.+)$/);
+    if (descMatch) {
+      current.description = descMatch[1].trim();
+    }
+  }
+  if (current?.pluginName && current.packageName && current.installSpec) {
+    sources.push(current);
+  }
+  return { sources };
+}
+function serializePluginSources(file) {
+  const lines = ["# Unpublished or monorepo-local plugins", "sources:"];
+  for (const s of file.sources) {
+    lines.push(`  - pluginName: ${s.pluginName}`);
+    lines.push(`    packageName: ${s.packageName}`);
+    lines.push(`    installSpec: "${s.installSpec}"`);
+    if (s.label) lines.push(`    label: ${s.label}`);
+    if (s.kind) lines.push(`    kind: ${s.kind}`);
+    if (s.description) lines.push(`    description: ${s.description}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function readPluginSources(projectRoot) {
+  const filePath = getPluginSourcesPath(projectRoot);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return parsePluginSourcesYaml(raw);
+  } catch (e) {
+    const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+    if (code === "ENOENT") return { sources: [] };
+    throw e;
+  }
+}
+async function writePluginSource(projectRoot, entry) {
+  if (!isValidInstallSpec(entry.installSpec)) {
+    throw new Error(
+      `installSpec must start with portal:, file:, or workspace:`
+    );
+  }
+  const file = await readPluginSources(projectRoot);
+  const ix = file.sources.findIndex((s) => s.pluginName === entry.pluginName);
+  if (ix >= 0) {
+    file.sources[ix] = entry;
+  } else {
+    file.sources.push(entry);
+  }
+  const dir = path.join(projectRoot, ".aiditor");
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(
+    getPluginSourcesPath(projectRoot),
+    serializePluginSources(file),
+    "utf-8"
+  );
+}
+function mergeCatalogWithSources(catalog, sources) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of catalog) {
+    byName.set(e.pluginName, { ...e, isLocalSource: false });
+  }
+  for (const s of sources) {
+    const existing = byName.get(s.pluginName);
+    byName.set(s.pluginName, {
+      pluginName: s.pluginName,
+      packageName: s.packageName,
+      description: s.description ?? existing?.description ?? s.pluginName,
+      kind: s.kind ?? existing?.kind ?? "headless",
+      requires: existing?.requires ?? [],
+      showInAddPagePicker: existing?.showInAddPagePicker ?? true,
+      configFiles: existing?.configFiles,
+      isLocalSource: true,
+      installSpec: s.installSpec,
+      localLabel: s.label
+    });
+  }
+  return [...byName.values()];
+}
+function readPackageJson(dir) {
+  const pkgPath = path.join(dir, "package.json");
+  if (!fs$1.existsSync(pkgPath)) return void 0;
+  try {
+    return JSON.parse(fs$1.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function hasYarnWorkspaces(pkg) {
+  if (!pkg?.workspaces) return false;
+  return Array.isArray(pkg.workspaces) || typeof pkg.workspaces === "object" && pkg.workspaces !== null;
+}
+function findYarnWorkspaceRoot(startDir) {
+  let dir = path.resolve(startDir);
+  let innermostPkgDir;
+  while (true) {
+    const pkg = readPackageJson(dir);
+    if (pkg) {
+      innermostPkgDir = dir;
+      if (hasYarnWorkspaces(pkg) || pkg.packageManager?.startsWith("yarn@")) {
+        return dir;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return innermostPkgDir;
+}
+function readYarnPathFromRc(workspaceRoot) {
+  const rcPath = path.join(workspaceRoot, ".yarnrc.yml");
+  if (!fs$1.existsSync(rcPath)) return void 0;
+  const content = fs$1.readFileSync(rcPath, "utf-8");
+  const match = content.match(/^yarnPath:\s*["']?([^"'\n]+)["']?\s*$/m);
+  if (!match?.[1]) return void 0;
+  return path.resolve(workspaceRoot, match[1].trim());
+}
+function resolveYarnRunner(workspaceRoot) {
+  const pkg = readPackageJson(workspaceRoot);
+  const yarnPath = readYarnPathFromRc(workspaceRoot);
+  if (yarnPath && fs$1.existsSync(yarnPath)) {
+    return { command: "node", prefixArgs: [yarnPath] };
+  }
+  if (pkg?.packageManager?.startsWith("yarn@")) {
+    return { command: "corepack", prefixArgs: ["yarn"] };
+  }
+  return { command: "yarn", prefixArgs: [] };
+}
+function formatYarnInstallError(raw) {
+  const text = raw.trim();
+  if (!text) {
+    return "Package install failed (Yarn produced no output).";
+  }
+  const lower = text.toLowerCase();
+  if (lower.includes("reading 'manifest'") || lower.includes("missing version in workspace") || lower.includes("yarn add v1.")) {
+    return [
+      "Wrong Yarn version: use Yarn 4 from the monorepo root, not global Yarn 1.x.",
+      "From jay-aiditor root: corepack yarn workspace aiditor-starter add <package>.",
+      "Or click Fix with agent to let Claude install the plugin."
+    ].join(" ");
+  }
+  if (lower.includes("yn0027") || lower.includes("@unknown")) {
+    return [
+      "Yarn could not resolve a version (often because the registry request failed).",
+      "Check network/VPN, retry Install, or use Fix with agent / Add local plugin (portal:)."
+    ].join(" ");
+  }
+  if (lower.includes("requesterror") || lower.includes("ebadf") || lower.includes("enotfound") || lower.includes("econnrefused") || lower.includes("etimedout") || lower.includes("getaddrinfo") || lower.includes("yn0035")) {
+    return [
+      "Could not reach the npm registry (network error during Yarn resolution).",
+      "Check internet, VPN, or corporate proxy, then retry or use Fix with agent.",
+      "For local Wix plugins: Add local plugin → portal:../../../wix/packages/<name>."
+    ].join(" ");
+  }
+  if (lower.includes("isn't listed by your request") || lower.includes("no candidates found") || text.includes("YN0035")) {
+    return [
+      "Package version is not on the npm registry (Wix plugins are published on the 0.16.x line).",
+      "Retry Install, or use “Add local plugin” with portal:../../../wix/packages/<name>."
+    ].join(" ");
+  }
+  const lines = text.split("\n").map((l) => l.trim()).filter(
+    (l) => l.length > 0 && !l.includes("/.cache/node/corepack") && !l.includes("yarn.js:")
+  );
+  const summary = lines.slice(0, 8).join("\n");
+  return summary.length > 600 ? `${summary.slice(0, 600)}…` : summary;
+}
+function resolveYarnAddInvocation(projectDir, spec) {
+  const resolvedProject = path.resolve(projectDir);
+  const workspaceRoot = findYarnWorkspaceRoot(resolvedProject);
+  const root = workspaceRoot ?? resolvedProject;
+  const runner = resolveYarnRunner(root);
+  const projectPkg = readPackageJson(resolvedProject);
+  const rootPkg = readPackageJson(root);
+  const useWorkspaceCommand = workspaceRoot !== void 0 && path.resolve(root) !== resolvedProject && hasYarnWorkspaces(rootPkg) && typeof projectPkg?.name === "string" && projectPkg.name.length > 0;
+  if (useWorkspaceCommand) {
+    return {
+      command: runner.command,
+      args: [...runner.prefixArgs, "workspace", projectPkg.name, "add", spec],
+      cwd: root
+    };
+  }
+  const args = runner.prefixArgs.length > 0 ? [...runner.prefixArgs, "add", spec] : ["add", spec];
+  return {
+    command: runner.command,
+    args,
+    cwd: resolvedProject
+  };
+}
+function parseSemver(version) {
+  const m = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function compareSemver(a, b) {
+  for (let i = 0; i < 3; i++) {
+    const diff = (a[i] ?? 0) - (b[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function isNewerSemver(latest, installed) {
+  const a = parseSemver(latest);
+  const b = parseSemver(installed);
+  if (!a || !b) return false;
+  return compareSemver(a, b) > 0;
+}
+async function spawnCommand(command, args, cwd, options) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd,
+      shell: options?.shell ?? false,
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("close", (code) => {
+      resolve({ code, stdout, stderr });
+    });
+    child.on("error", (err) => {
+      resolve({ code: 1, stdout, stderr: err.message });
+    });
+  });
+}
+async function yarnAdd(projectDir, spec) {
+  const inv = resolveYarnAddInvocation(projectDir, spec);
+  return spawnCommand(inv.command, inv.args, inv.cwd);
+}
+async function npmAdd(projectDir, packageName, version) {
+  const spec = version ? `${packageName}@${version}` : packageName;
+  return spawnCommand("npm", ["install", spec, "--save"], projectDir);
+}
+async function runJayStackSetup(projectDir, pluginName, force) {
+  const args = ["jay-stack-cli", "setup", pluginName];
+  if (force) args.push("--force");
+  return spawnCommand("npx", args, projectDir, { shell: true });
+}
+async function runJayStackAgentKit(projectDir, pluginName) {
+  return spawnCommand(
+    "npx",
+    ["jay-stack-cli", "agent-kit", "--plugin", pluginName],
+    projectDir,
+    { shell: true }
+  );
+}
+function parseSetupOutput(stdout, stderr, exitCode) {
+  const combined = `${stdout}
+${stderr}`.trim();
+  const jsonMatch = combined.match(/\{[\s\S]*"status"[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed.status === "configured") {
+        return {
+          setupStatus: "configured",
+          configCreated: parsed.configCreated,
+          message: parsed.message
+        };
+      }
+      if (parsed.status === "needs-config") {
+        return {
+          setupStatus: "needs-config",
+          configCreated: parsed.configCreated,
+          message: parsed.message
+        };
+      }
+      if (parsed.status === "error") {
+        return {
+          setupStatus: "error",
+          message: parsed.message ?? combined
+        };
+      }
+    } catch {
+    }
+  }
+  if (exitCode === 0) {
+    const lower = combined.toLowerCase();
+    if (lower.includes("needs-config") || lower.includes("needs config") || lower.includes("placeholder")) {
+      return {
+        setupStatus: "needs-config",
+        message: combined || "Plugin needs configuration."
+      };
+    }
+    return { setupStatus: "configured", message: combined || void 0 };
+  }
+  return {
+    setupStatus: "error",
+    message: combined || `setup exited with code ${exitCode}`
+  };
+}
+async function readInstalledPackageVersion(projectRoot, packageName) {
+  const parts = packageName.split("/");
+  const pkgPath = path.join(
+    projectRoot,
+    "node_modules",
+    ...parts,
+    "package.json"
+  );
+  try {
+    const raw = await fs.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function fetchNpmLatestVersion(packageName) {
+  const result = await spawnCommand(
+    "npm",
+    ["view", packageName, "version", "--json"],
+    process.cwd()
+  );
+  if (result.code !== 0) return null;
+  const out = (result.stdout || result.stderr).trim();
+  if (!out) return null;
+  try {
+    const parsed = JSON.parse(out);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return out.replace(/^"|"$/g, "").trim() || null;
+  }
+}
+async function checkPluginUpdate(projectRoot, pluginName, packageName, installSpec) {
+  const base = {
+    pluginName,
+    packageName,
+    installedVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    isLocalSource: false
+  };
+  if (!isRegistryInstallSpec(installSpec)) {
+    return {
+      ...base,
+      isLocalSource: true,
+      message: "Local source — registry updates do not apply."
+    };
+  }
+  const installedVersion = await readInstalledPackageVersion(
+    projectRoot,
+    packageName
+  );
+  const latestVersion = await fetchNpmLatestVersion(packageName);
+  if (!latestVersion) {
+    return {
+      ...base,
+      installedVersion,
+      message: "Could not fetch latest version from npm."
+    };
+  }
+  const updateAvailable = installedVersion != null && isNewerSemver(latestVersion, installedVersion);
+  return {
+    ...base,
+    installedVersion,
+    latestVersion,
+    updateAvailable,
+    message: updateAvailable ? `Update available: ${installedVersion} → ${latestVersion}` : installedVersion ? `Up to date (${installedVersion})` : void 0
+  };
+}
+function getSetupCachePath(projectRoot) {
+  return path.join(projectRoot, ".aiditor", "plugin-setup-status.json");
+}
+async function readSetupCache(projectRoot) {
+  const filePath = getSetupCachePath(projectRoot);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (e) {
+    const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+    if (code === "ENOENT") return {};
+    throw e;
+  }
+}
+async function writeSetupCacheEntry(projectRoot, pluginName, entry) {
+  const cache2 = await readSetupCache(projectRoot);
+  cache2[pluginName] = entry;
+  const dir = path.join(projectRoot, ".aiditor");
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(
+    getSetupCachePath(projectRoot),
+    `${JSON.stringify(cache2, null, 2)}
+`,
+    "utf-8"
+  );
+}
+function getCachedSetupStatus(cache2, pluginName) {
+  return cache2[pluginName];
+}
+function topologicalInstallOrder(target, catalog) {
+  const byName = new Map(catalog.map((e) => [e.pluginName, e]));
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(name) {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const entry = byName.get(name);
+    if (!entry) return;
+    for (const req of entry.requires) visit(req);
+    order.push(entry);
+  }
+  visit(target.pluginName);
+  return order;
+}
+function buildRegistryInstallSpec(packageName) {
+  return packageName;
+}
+async function resolveInstallSpec(projectRoot, entry, overrideSpec) {
+  if (overrideSpec) return overrideSpec;
+  const sources = await readPluginSources(projectRoot);
+  const local = sources.sources.find((s) => s.pluginName === entry.pluginName);
+  if (local?.installSpec) {
+    return `${entry.packageName}@${local.installSpec}`;
+  }
+  const deps = await readPackageJsonDeps(projectRoot);
+  const existing = deps[entry.packageName];
+  if (existing && !isRegistryInstallSpec(existing)) {
+    return `${entry.packageName}@${existing}`;
+  }
+  const latest = await fetchNpmLatestVersion(entry.packageName);
+  if (latest) {
+    return `${entry.packageName}@${latest}`;
+  }
+  return buildRegistryInstallSpec(entry.packageName);
+}
+function isRegistryResolutionFailure(output) {
+  const lower = output.toLowerCase();
+  return lower.includes("requesterror") || lower.includes("ebadf") || lower.includes("yn0027") || lower.includes("yn0035") || lower.includes("@unknown") || lower.includes("enotfound") || lower.includes("econnrefused");
+}
+async function installOnePlugin(projectRoot, entry, installSpec) {
+  const spec = await resolveInstallSpec(projectRoot, entry, installSpec);
+  const yarnResult = await yarnAdd(projectRoot, spec);
+  if (yarnResult.code === 0) {
+    return { ok: true };
+  }
+  const yarnOut = `${yarnResult.stderr}
+${yarnResult.stdout}`.trim();
+  const isRegistryPackageSpec = spec === entry.packageName || spec.startsWith(`${entry.packageName}@`);
+  const useNpmFallback = isRegistryPackageSpec && isRegistryResolutionFailure(yarnOut);
+  if (useNpmFallback) {
+    const latest = await fetchNpmLatestVersion(entry.packageName);
+    const npmResult = await npmAdd(
+      projectRoot,
+      entry.packageName,
+      latest ?? void 0
+    );
+    if (npmResult.code === 0) {
+      return { ok: true };
+    }
+    const npmOut = `${npmResult.stderr}
+${npmResult.stdout}`.trim();
+    return {
+      ok: false,
+      error: `Yarn failed:
+${yarnOut}
+
+npm fallback failed:
+${npmOut}`
+    };
+  }
+  return {
+    ok: false,
+    error: yarnOut || "yarn add failed"
+  };
+}
+async function contractsForPlugin$1(projectRoot, pluginName) {
+  const fromIndex = await parsePluginsIndexContracts(projectRoot);
+  const filtered = fromIndex.filter((c) => c.pluginName === pluginName);
+  if (filtered.length > 0) return filtered;
+  return parsePluginYamlContracts(projectRoot, pluginName);
+}
+async function* ensureProjectPlugin(projectRoot, pluginName, options) {
+  const catalog = getJayPluginCatalog();
+  const entry = getCatalogEntry(pluginName);
+  if (!entry) {
+    yield { type: "error", message: `Unknown plugin: ${pluginName}` };
+    return;
+  }
+  const order = topologicalInstallOrder(entry, catalog);
+  for (const item of order) {
+    const installed = await isPluginInstalled(projectRoot, item.pluginName);
+    if (installed && item.pluginName !== pluginName) continue;
+    const isTarget = item.pluginName === pluginName;
+    const shouldInstall = !installed || isTarget && options?.upgrade === true;
+    if (shouldInstall) {
+      yield {
+        type: "progress",
+        step: isTarget ? "package" : "requires",
+        message: isTarget ? options?.upgrade ? `Updating ${item.packageName} to latest…` : `Installing ${item.packageName}…` : `Installing dependency ${item.pluginName}…`
+      };
+      const spec = isTarget ? options?.installSpec : void 0;
+      const installResult = await installOnePlugin(projectRoot, item, spec);
+      if (!installResult.ok) {
+        const raw = installResult.error ?? "";
+        yield {
+          type: "error",
+          message: `Could not install ${item.pluginName}.`,
+          installError: formatYarnInstallError(raw)
+        };
+        return;
+      }
+    }
+  }
+  yield {
+    type: "progress",
+    step: "setup",
+    message: `Running setup for ${pluginName}…`
+  };
+  const setupResult = await runJayStackSetup(projectRoot, pluginName);
+  const parsed = parseSetupOutput(
+    setupResult.stdout,
+    setupResult.stderr,
+    setupResult.code
+  );
+  const configFiles = entry.configFiles ?? parsed.configCreated ?? [];
+  await writeSetupCacheEntry(projectRoot, pluginName, {
+    setupStatus: parsed.setupStatus,
+    configFiles,
+    message: parsed.message,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  yield {
+    type: "progress",
+    step: "agent-kit",
+    message: `Refreshing contracts for ${pluginName}…`
+  };
+  const agentKitResult = await runJayStackAgentKit(projectRoot, pluginName);
+  if (agentKitResult.code !== 0) {
+    const msg = (agentKitResult.stderr || agentKitResult.stdout).trim();
+    yield {
+      type: "error",
+      message: `agent-kit failed for ${pluginName}: ${msg || "unknown error"}`
+    };
+    return;
+  }
+  const contracts = await contractsForPlugin$1(projectRoot, pluginName);
+  yield {
+    type: "complete",
+    pluginName,
+    setupStatus: parsed.setupStatus,
+    configFiles,
+    contracts,
+    message: parsed.message
+  };
+}
+const PLUGIN_MANIFEST_START = "<!-- aiditor:plugins:start -->";
+const PLUGIN_MANIFEST_END = "<!-- aiditor:plugins:end -->";
+function formatManifestLine(packageName, contractName, componentKey) {
+  const key = componentKey ?? getDefaultComponentKey(contractName);
+  return `- ${packageName} / ${contractName} (key: ${key})`;
+}
+function buildPluginManifestSection(selectedPlugins) {
+  const lines = [
+    PLUGIN_MANIFEST_START,
+    "",
+    "## Plugins & contracts (selected)",
+    ""
+  ];
+  for (const plugin of selectedPlugins) {
+    for (const contract of plugin.contracts) {
+      lines.push(
+        formatManifestLine(
+          plugin.packageName,
+          contract.contractName,
+          contract.componentKey
+        )
+      );
+    }
+  }
+  lines.push(PLUGIN_MANIFEST_END);
+  return lines.join("\n");
+}
+function syncPluginManifestInContentMd(contentMd, selectedPlugins) {
+  const section = buildPluginManifestSection(selectedPlugins);
+  const startIx = contentMd.indexOf(PLUGIN_MANIFEST_START);
+  const endIx = contentMd.indexOf(PLUGIN_MANIFEST_END);
+  if (startIx >= 0 && endIx > startIx) {
+    const before = contentMd.slice(0, startIx).trimEnd();
+    const after = contentMd.slice(endIx + PLUGIN_MANIFEST_END.length).trimStart();
+    const parts = [before, section, after].filter((p) => p.length > 0);
+    return parts.length > 0 ? `${parts.join("\n\n")}
+` : `${section}
+`;
+  }
+  const hasContracts = selectedPlugins.some((p) => p.contracts.length > 0);
+  if (!hasContracts) return contentMd;
+  const trimmed = contentMd.trimEnd();
+  if (trimmed.length === 0) {
+    return `${section}
+`;
+  }
+  return `${trimmed}
+
+${section}
+`;
+}
+async function contractsForPlugin(projectRoot, pluginName) {
+  const fromIndex = await parsePluginsIndexContracts(projectRoot);
+  const filtered = fromIndex.filter((c) => c.pluginName === pluginName);
+  if (filtered.length > 0) {
+    return filtered.map((c) => ({
+      contractName: c.contractName,
+      description: c.description,
+      isDynamic: c.isDynamic
+    }));
+  }
+  const fromYaml = await parsePluginYamlContracts(projectRoot, pluginName);
+  return fromYaml.map((c) => ({
+    contractName: c.contractName,
+    description: c.description
+  }));
+}
+const listJayPluginsAction = makeJayQuery("aiditor.listJayPlugins").withServices(DEV_SERVER_SERVICE).withHandler(async (input, _devServer) => {
+  const projectRoot = process.cwd();
+  const catalog = mergeCatalogWithSources(
+    getJayPluginCatalog(),
+    (await readPluginSources(projectRoot)).sources
+  );
+  const installed = await getInstalledPlugins(projectRoot);
+  const installedByName = new Map(installed.map((p) => [p.pluginName, p]));
+  let cache2 = await readSetupCache(projectRoot);
+  if (input.refreshSetupStatus) {
+    for (const inst of installed) {
+      const entry = getCatalogEntry(inst.pluginName);
+      if (!entry?.configFiles?.length) continue;
+      const setupResult = await runJayStackSetup(
+        projectRoot,
+        inst.pluginName
+      );
+      const parsed = parseSetupOutput(
+        setupResult.stdout,
+        setupResult.stderr,
+        setupResult.code
+      );
+      await writeSetupCacheEntry(projectRoot, inst.pluginName, {
+        setupStatus: parsed.setupStatus,
+        configFiles: entry.configFiles ?? [],
+        message: parsed.message,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    cache2 = await readSetupCache(projectRoot);
+  }
+  const plugins = await Promise.all(
+    catalog.map(async (entry) => {
+      const inst = installedByName.get(entry.pluginName);
+      const cached = getCachedSetupStatus(cache2, entry.pluginName);
+      const contracts = entry.kind === "headless" && inst ? await contractsForPlugin(projectRoot, entry.pluginName) : [];
+      const installedVersion = inst && isRegistryInstallSpec(inst.installSpec) ? await readInstalledPackageVersion(projectRoot, entry.packageName) : null;
+      return {
+        pluginName: entry.pluginName,
+        packageName: entry.packageName,
+        description: entry.description,
+        kind: entry.kind,
+        requires: entry.requires,
+        installed: !!inst,
+        installSpec: inst?.installSpec,
+        installedVersion: installedVersion ?? void 0,
+        isLocalSource: entry.isLocalSource,
+        showInAddPagePicker: entry.showInAddPagePicker,
+        setupStatus: cached?.setupStatus ?? "unknown",
+        configFiles: cached?.configFiles ?? entry.configFiles ?? [],
+        setupMessage: cached?.message,
+        contracts
+      };
+    })
+  );
+  return { plugins };
+});
+const listPluginContractsAction = makeJayQuery(
+  "aiditor.listPluginContracts"
+).withServices(DEV_SERVER_SERVICE).withHandler(async (input) => {
+  const projectRoot = process.cwd();
+  const installed = await getInstalledPlugins(projectRoot);
+  const isInstalled = installed.some(
+    (p) => p.pluginName === input.pluginName
+  );
+  const contracts = isInstalled ? await contractsForPlugin(projectRoot, input.pluginName) : [];
+  const entry = getCatalogEntry(input.pluginName);
+  let setupRequiredMessage;
+  if (isInstalled && contracts.length === 0 && entry?.kind === "headless") {
+    setupRequiredMessage = "Run setup to load contracts (dynamic contracts may require Wix configuration).";
+  }
+  return {
+    pluginName: input.pluginName,
+    installed: isInstalled,
+    contracts,
+    setupRequiredMessage
+  };
+});
+const checkPluginUpdateAction = makeJayQuery("aiditor.checkPluginUpdate").withServices(DEV_SERVER_SERVICE).withHandler(async (input) => {
+  const projectRoot = process.cwd();
+  const entry = getCatalogEntry(input.pluginName);
+  if (!entry) {
+    return {
+      pluginName: input.pluginName,
+      packageName: "",
+      installedVersion: null,
+      latestVersion: null,
+      updateAvailable: false,
+      isLocalSource: false,
+      message: `Unknown plugin: ${input.pluginName}`
+    };
+  }
+  const installed = await getInstalledPlugins(projectRoot);
+  const inst = installed.find((p) => p.pluginName === input.pluginName);
+  if (!inst) {
+    return {
+      pluginName: input.pluginName,
+      packageName: entry.packageName,
+      installedVersion: null,
+      latestVersion: null,
+      updateAvailable: false,
+      isLocalSource: false,
+      message: "Plugin is not installed."
+    };
+  }
+  return checkPluginUpdate(
+    projectRoot,
+    input.pluginName,
+    entry.packageName,
+    inst.installSpec
+  );
+});
+const ensureProjectPluginAction = makeJayStream(
+  "aiditor.ensureProjectPlugin"
+).withServices(DEV_SERVER_SERVICE).withHandler(async function* (input, devServer) {
+  const projectRoot = process.cwd();
+  try {
+    for await (const chunk of ensureProjectPlugin(
+      projectRoot,
+      input.pluginName,
+      { installSpec: input.installSpec, upgrade: input.upgrade }
+    )) {
+      if (chunk.type === "progress") {
+        yield chunk;
+      } else if (chunk.type === "complete") {
+        await devServer.refreshRoutes();
+        yield {
+          type: "complete",
+          pluginName: chunk.pluginName,
+          setupStatus: chunk.setupStatus,
+          configFiles: chunk.configFiles,
+          contracts: chunk.contracts.map((c) => ({
+            contractName: c.contractName,
+            description: c.description,
+            isDynamic: c.isDynamic
+          }))
+        };
+      } else if (chunk.type === "error") {
+        yield {
+          type: "error",
+          message: chunk.message,
+          installError: chunk.installError
+        };
+      }
+    }
+  } catch (err) {
+    yield {
+      type: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+  yield { type: "done" };
+});
+const getPluginSetupStatusAction = makeJayQuery(
+  "aiditor.getPluginSetupStatus"
+).withServices(DEV_SERVER_SERVICE).withHandler(async (input) => {
+  const projectRoot = process.cwd();
+  const installed = await getInstalledPlugins(projectRoot);
+  const targets = input.pluginName ? installed.filter((p) => p.pluginName === input.pluginName) : installed;
+  const plugins = [];
+  for (const inst of targets) {
+    const entry = getCatalogEntry(inst.pluginName);
+    if (input.refresh) {
+      const setupResult = await runJayStackSetup(
+        projectRoot,
+        inst.pluginName
+      );
+      const parsed = parseSetupOutput(
+        setupResult.stdout,
+        setupResult.stderr,
+        setupResult.code
+      );
+      const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeSetupCacheEntry(projectRoot, inst.pluginName, {
+        setupStatus: parsed.setupStatus,
+        configFiles: entry?.configFiles ?? [],
+        message: parsed.message,
+        checkedAt
+      });
+      plugins.push({
+        pluginName: inst.pluginName,
+        setupStatus: parsed.setupStatus,
+        configFiles: entry?.configFiles ?? [],
+        message: parsed.message,
+        checkedAt
+      });
+    } else {
+      const cache2 = await readSetupCache(projectRoot);
+      const cached = getCachedSetupStatus(cache2, inst.pluginName);
+      plugins.push({
+        pluginName: inst.pluginName,
+        setupStatus: cached?.setupStatus ?? "unknown",
+        configFiles: cached?.configFiles ?? entry?.configFiles ?? [],
+        message: cached?.message,
+        checkedAt: cached?.checkedAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
+      });
+    }
+  }
+  return { plugins };
+});
+const rerunPluginSetupAction = makeJayQuery("aiditor.rerunPluginSetup").withServices(DEV_SERVER_SERVICE).withHandler(async (input) => {
+  const projectRoot = process.cwd();
+  const entry = getCatalogEntry(input.pluginName);
+  const setupResult = await runJayStackSetup(
+    projectRoot,
+    input.pluginName,
+    input.force
+  );
+  const parsed = parseSetupOutput(
+    setupResult.stdout,
+    setupResult.stderr,
+    setupResult.code
+  );
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeSetupCacheEntry(projectRoot, input.pluginName, {
+    setupStatus: parsed.setupStatus,
+    configFiles: entry?.configFiles ?? parsed.configCreated ?? [],
+    message: parsed.message,
+    checkedAt
+  });
+  return {
+    pluginName: input.pluginName,
+    setupStatus: parsed.setupStatus,
+    configCreated: parsed.configCreated,
+    message: parsed.message
+  };
+});
+const syncAddPagePluginManifestAction = makeJayQuery(
+  "aiditor.syncAddPagePluginManifest"
+).withServices(DEV_SERVER_SERVICE).withHandler(
+  async (input) => {
+    const projectRoot = process.cwd();
+    const request = await readPageRequest(projectRoot, input.requestId);
+    if (!request) {
+      return { ok: false, contentMd: "", error: "Page request not found." };
+    }
+    const requestDir = path.join(
+      projectRoot,
+      ".aiditor",
+      "page-requests",
+      input.requestId
+    );
+    const contentPath = path.join(requestDir, "content.md");
+    let contentMd = "";
+    try {
+      contentMd = await fs.readFile(contentPath, "utf-8");
+    } catch {
+      contentMd = "";
+    }
+    const nextMd = syncPluginManifestInContentMd(
+      contentMd,
+      input.selectedPlugins
+    );
+    await writePageRequestMarkdown(projectRoot, input.requestId, {
+      contentMd: nextMd,
+      designMd: await fs.readFile(path.join(requestDir, "design.md"), "utf-8").catch(() => "")
+    });
+    await writePageRequest(projectRoot, {
+      ...request,
+      selectedPlugins: input.selectedPlugins,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { ok: true, contentMd: nextMd };
+  }
+);
+const writePluginSourceAction = makeJayQuery("aiditor.writePluginSource").withServices(DEV_SERVER_SERVICE).withHandler(async (input) => {
+  const projectRoot = process.cwd();
+  await writePluginSource(projectRoot, input);
+  return { ok: true };
+});
 setActionCallerOptions({ timeout: 12e4 });
 const page = makeJayStackComponent().withProps();
 const aiditorShell = makeJayStackComponent().withProps().withSlowlyRender(async () => {
@@ -608,10 +3259,27 @@ const aiditorShell = makeJayStackComponent().withProps().withSlowlyRender(async
 export {
   page as aiditorPage,
   aiditorShell,
+  checkAddPageRouteAction,
+  checkPageAddPageBriefAction,
+  checkPluginUpdateAction,
+  ensureProjectPluginAction,
+  generateAddPageBriefFromImageAction,
   getAiditorBootstrap,
   getPageParamsAction,
+  getPluginSetupStatusAction,
   getProjectInfoAction,
   listFreezesAction,
+  listJayPluginsAction,
+  listPluginContractsAction,
+  openAddPageFromBriefAction,
   readFileAction,
-  submitTaskAction
+  reclassifyAddPageAssetAction,
+  rerunPluginSetupAction,
+  saveAddPageDraftAction,
+  startAddPageRequestAction,
+  submitAddPageAction,
+  submitTaskAction,
+  syncAddPagePluginManifestAction,
+  uploadAddPageAssetAction,
+  writePluginSourceAction
 };