@a-company/paradigm 5.6.2 → 5.8.1

package/dist/{chunk-SU3WDCRR.js → chunk-T3YGSZCI.js}

@@ -2277,6 +2277,18 @@ var SessionTracker = class {
     if (checkpoint && Date.now() - checkpoint.timestamp > CHECKPOINT_MAX_AGE_MS) {
       return null;
     }
+    if (checkpoint) {
+      for (const key of ["modifiedFiles", "symbolsTouched", "decisions"]) {
+        const val = checkpoint[key];
+        if (typeof val === "string") {
+          try {
+            checkpoint[key] = JSON.parse(val);
+          } catch {
+            checkpoint[key] = [];
+          }
+        }
+      }
+    }
     return checkpoint;
   }
   /**

package/dist/conductor-CQVGTEQN.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-PDX44BCA.js";
+
+// src/commands/conductor.ts
+import { execSync, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var INSTALLED_BINARY = path.join(os.homedir(), ".paradigm", "conductor", "bin", "conductor");
+async function conductorCommand(options) {
+  const cmdLog = log.command("conductor");
+  if (options.install) {
+    await installConductor(options, cmdLog);
+    return;
+  }
+  const binaryPath = resolveBinary(options, cmdLog);
+  if (!binaryPath) {
+    return;
+  }
+  if (options.build) {
+    const conductorDir = findConductorDir();
+    if (conductorDir) {
+      buildFromSource(conductorDir, options, cmdLog);
+      const devBinary = path.join(conductorDir, ".build", "release", "conductor");
+      launchBinary(devBinary, cmdLog);
+      return;
+    } else {
+      cmdLog.error("--build requires the Paradigm monorepo");
+      console.log(chalk.gray("  Run from inside the a-paradigm repo, or use --install to update the global binary."));
+      process.exit(1);
+    }
+  }
+  launchBinary(binaryPath, cmdLog);
+}
+function resolveBinary(options, cmdLog) {
+  if (fs.existsSync(INSTALLED_BINARY)) {
+    return INSTALLED_BINARY;
+  }
+  const conductorDir = findConductorDir();
+  if (conductorDir) {
+    const devBinary = path.join(conductorDir, ".build", "release", "conductor");
+    if (fs.existsSync(devBinary)) {
+      return devBinary;
+    }
+    cmdLog.info("Dev binary not found, building\u2026");
+    buildFromSource(conductorDir, options, cmdLog);
+    if (fs.existsSync(devBinary)) {
+      return devBinary;
+    }
+  }
+  cmdLog.error("Conductor binary not found");
+  console.log("");
+  console.log(chalk.white("  To install Conductor:"));
+  console.log(chalk.cyan("    cd <paradigm-repo> && paradigm conductor --install"));
+  console.log("");
+  console.log(chalk.gray("  This builds the native binary and installs it to ~/.paradigm/conductor/bin/"));
+  console.log(chalk.gray("  After that, `paradigm conductor` works from any directory."));
+  console.log("");
+  process.exit(1);
+  return null;
+}
+async function installConductor(options, cmdLog) {
+  const conductorDir = findConductorDir();
+  if (!conductorDir) {
+    cmdLog.error("Cannot install \u2014 not in the Paradigm monorepo");
+    console.log(chalk.gray("  Run this command from inside the a-paradigm repository."));
+    process.exit(1);
+  }
+  const devBinary = path.join(conductorDir, ".build", "release", "conductor");
+  if (!fs.existsSync(devBinary) || options.build) {
+    buildFromSource(conductorDir, options, cmdLog);
+  }
+  if (!fs.existsSync(devBinary)) {
+    cmdLog.error("Build did not produce a binary");
+    process.exit(1);
+  }
+  const installDir = path.dirname(INSTALLED_BINARY);
+  fs.mkdirSync(installDir, { recursive: true });
+  fs.copyFileSync(devBinary, INSTALLED_BINARY);
+  fs.chmodSync(INSTALLED_BINARY, 493);
+  const size = (fs.statSync(INSTALLED_BINARY).size / (1024 * 1024)).toFixed(1);
+  cmdLog.success(`Conductor installed (${size} MB)`);
+  console.log("");
+  console.log(chalk.green("  \u2713 ") + chalk.white("Installed to ") + chalk.cyan("~/.paradigm/conductor/bin/conductor"));
+  console.log(chalk.green("  \u2713 ") + chalk.white("Run ") + chalk.cyan("paradigm conductor") + chalk.white(" from any directory"));
+  console.log("");
+}
+function buildFromSource(conductorDir, options, cmdLog) {
+  cmdLog.info("Building Conductor\u2026");
+  try {
+    execSync("swift build -c release", {
+      cwd: conductorDir,
+      stdio: options.verbose ? "inherit" : "pipe"
+    });
+    cmdLog.success("Build complete");
+  } catch (error) {
+    cmdLog.error("Build failed");
+    const errMsg = error.message || "";
+    if (errMsg.includes("xcode-select")) {
+      console.log(chalk.gray("  Xcode Command Line Tools are required."));
+      console.log(chalk.gray("  Install with: xcode-select --install"));
+    } else {
+      console.log(chalk.gray(`  ${errMsg.slice(0, 200)}`));
+    }
+    process.exit(1);
+  }
+}
+function launchBinary(binaryPath, cmdLog) {
+  cmdLog.info("Launching Conductor\u2026");
+  const child = spawn(binaryPath, [], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const isInstalled = binaryPath === INSTALLED_BINARY;
+  console.log(chalk.cyan("\n  Paradigm Conductor is running."));
+  if (isInstalled) {
+    console.log(chalk.gray("  Binary: ~/.paradigm/conductor/bin/conductor"));
+  }
+  console.log(chalk.gray("  Look for the waveform icon in your menu bar."));
+  console.log(chalk.gray("  Quit via the menu bar icon or Cmd+Q.\n"));
+}
+function findConductorDir() {
+  let dir = path.resolve(__dirname, "..");
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "packages", "conductor");
+    if (fs.existsSync(path.join(candidate, "Package.swift"))) {
+      return candidate;
+    }
+    dir = path.dirname(dir);
+  }
+  const cwdCandidate = path.join(process.cwd(), "packages", "conductor");
+  if (fs.existsSync(path.join(cwdCandidate, "Package.swift"))) {
+    return cwdCandidate;
+  }
+  if (fs.existsSync(path.join(process.cwd(), "Package.swift"))) {
+    const basename2 = path.basename(process.cwd());
+    if (basename2 === "conductor") {
+      return process.cwd();
+    }
+  }
+  let cwdDir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    cwdDir = path.dirname(cwdDir);
+    const candidate = path.join(cwdDir, "packages", "conductor");
+    if (fs.existsSync(path.join(candidate, "Package.swift"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+export {
+  conductorCommand
+};

package/dist/{docs-J2BTKRVU.js → docs-AIY6VNF7.js}

@@ -17,7 +17,7 @@ async function docsServeCommand(options) {
   const shouldOpen = options.open !== false;
   console.log(chalk.cyan("\n  Starting Paradigm Docs...\n"));
   try {
-    const { startPlatformServer } = await import("./platform-server-2D6S6YTK.js");
+    const { startPlatformServer } = await import("./platform-server-U5L2G3EU.js");
     await startPlatformServer({
       projectDir,
       port,

package/dist/index.js

@@ -111,7 +111,7 @@ ${chalk2.magenta("\u2569  ")}${chalk2.cyan("\u2534 \u2534\u2534\u2514\u2500\u253
 program.name("paradigm").description("Unified developer tools ecosystem").version(VERSION).addHelpText("before", banner);
 program.command("init").description("Initialize Paradigm in the current project").option("-f, --force", "Overwrite existing files").option("--name <name>", "Project name").option("--ide <ide>", "Target IDE: cursor, copilot, windsurf, claude").option("--stack <stack>", "Stack preset (e.g., nextjs, fastapi, swift-ios). Auto-detected if omitted.").option("--migrate", "Output migration prompt for existing IDE files").option("--quick", "Non-interactive mode with smart defaults").option("--dry-run", "Show what would be created without creating").action(initCommand);
 program.command("shift").description("Full project setup in one command (init + team init + scan + sync all IDEs + doctor)").option("-f, --force", "Reinitialize even if already setup").option("-q, --quick", "Skip slow operations (scan)").option("--verify", "Run health checks after setup").option("--ide <ide>", "Target specific IDE instead of all").option("--configure-models", "Force model configuration prompts for team agents").option("--stack <stack>", "Stack preset (e.g., nextjs, fastapi, swift-ios). Auto-detected if omitted.").option("--workspace <name>", "Create or join a multi-project workspace with this name (creates ../.paradigm-workspace)").option("--workspace-path <path>", "Custom workspace file location (default: ../.paradigm-workspace)").action(async (options) => {
-  const { shiftCommand } = await import("./shift-VFG23DLA.js");
+  const { shiftCommand } = await import("./shift-2NYRFVEZ.js");
   await shiftCommand(options);
 });
 program.command("presets").description("List available stack presets for paradigm init/shift").option("-d, --discipline <discipline>", "Filter by discipline (e.g., fullstack, api, mobile)").action(async (options) => {
@@ -719,7 +719,7 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
   await loreServeCommand(void 0, options);
 });
 program.command("serve").description("Launch Paradigm Platform \u2014 unified development management UI").option("-p, --port <port>", "Port to run on", "3850").option("--no-open", "Don't open browser automatically").option("--sections <list>", "Comma-separated sections to enable (e.g., lore,graph,git)").action(async (options) => {
-  const { serveCommand } = await import("./serve-EFVRS4GA.js");
+  const { serveCommand } = await import("./serve-QWWJP2EW.js");
   await serveCommand(options);
 });
 var graphCmd = program.command("graph").description("Interactive symbol relationship graph").argument("[path]", "Project directory", void 0).option("-p, --port <port>", "Port to run on", "3841").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
@@ -818,8 +818,8 @@ sentinelCmd.command("defend [path]", { isDefault: true }).description("Launch th
   const { sentinelCommand } = await import("./sentinel-4XIG4STA.js");
   await sentinelCommand(path2, options);
 });
-program.command("conductor").description("Launch Paradigm Conductor \u2014 multimodal mission control for Claude Code sessions").option("--build", "Force rebuild the native binary").option("-v, --verbose", "Show build output").action(async (options) => {
-  const { conductorCommand } = await import("./conductor-PGPDVIVE.js");
+program.command("conductor").description("Launch Paradigm Conductor \u2014 multimodal mission control for Claude Code sessions").option("--build", "Force rebuild the native binary").option("--install", "Install Conductor binary to ~/.paradigm/conductor/bin/").option("-v, --verbose", "Show build output").action(async (options) => {
+  const { conductorCommand } = await import("./conductor-CQVGTEQN.js");
   await conductorCommand(options);
 });
 var universityCmd = program.command("university").description("Per-project university - knowledge base, quizzes, learning paths & PLSAT certification");
@@ -857,15 +857,15 @@ universityCmd.option("-p, --port <port>", "Port to run on", "3839").option("--no
 });
 var docsCmd = program.command("docs").description("Auto-generated documentation from the symbol graph");
 docsCmd.command("serve").description("Launch interactive docs viewer in browser").option("-p, --port <port>", "Port number (default: 3850)").option("--no-open", "Do not open browser automatically").action(async (options) => {
-  const { docsServeCommand } = await import("./docs-J2BTKRVU.js");
+  const { docsServeCommand } = await import("./docs-AIY6VNF7.js");
   await docsServeCommand(options);
 });
 docsCmd.command("build").description("Build static documentation site").option("-o, --output <dir>", "Output directory (default: from config or .paradigm/docs-site)").action(async (options) => {
-  const { docsBuildCommand } = await import("./docs-J2BTKRVU.js");
+  const { docsBuildCommand } = await import("./docs-AIY6VNF7.js");
   await docsBuildCommand(options);
 });
 docsCmd.action(async () => {
-  const { docsServeCommand } = await import("./docs-J2BTKRVU.js");
+  const { docsServeCommand } = await import("./docs-AIY6VNF7.js");
   await docsServeCommand({});
 });
 var pipelineCmd = program.command("pipeline").description("Spec pipeline \u2014 structured feature workflow with configurable gates");

package/dist/mcp.js

@@ -79,7 +79,7 @@ import {
   validateProtocol,
   validatePurposeFile,
   validateUniversityContent
-} from "./chunk-SU3WDCRR.js";
+} from "./chunk-T3YGSZCI.js";
 import "./chunk-L27I3CPZ.js";
 import {
   getWorkLogSummary,
@@ -21155,7 +21155,7 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-J5SEDVTT.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-KFUPB3ES.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
               const memberAbsPath = path34.resolve(path34.dirname(ctx.workspace.workspacePath), member.path);

package/dist/{platform-server-2D6S6YTK.js → platform-server-U5L2G3EU.js}

@@ -13,8 +13,8 @@ import "./chunk-PDX44BCA.js";
 // src/platform-server/index.ts
 import express from "express";
 import * as http from "http";
-import * as path4 from "path";
-import * as fs4 from "fs";
+import * as path5 from "path";
+import * as fs5 from "fs";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 
@@ -1097,9 +1097,189 @@ function createTeamRouter(projectDir) {
   return router;
 }
 
+// src/platform-server/routes/canvas.ts
+import { Router as Router5 } from "express";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as yaml4 from "js-yaml";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  "build",
+  ".paradigm",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".output"
+]);
+function findCanvasFiles(dir, rootDir) {
+  const results = [];
+  let entries;
+  try {
+    entries = fs4.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        results.push(...findCanvasFiles(path4.join(dir, entry.name), rootDir));
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".canvas")) {
+      results.push(path4.relative(rootDir, path4.join(dir, entry.name)));
+    }
+  }
+  return results;
+}
+var cachedFiles = null;
+var cacheTimestamp = 0;
+var CACHE_TTL = 5e3;
+function getCanvasFiles(projectDir) {
+  const now = Date.now();
+  if (cachedFiles && now - cacheTimestamp < CACHE_TTL) {
+    return cachedFiles;
+  }
+  const rootFiles = fs4.readdirSync(projectDir).filter((f) => f.endsWith(".canvas")).map((f) => f);
+  const nestedFiles = findCanvasFiles(projectDir, projectDir).filter((f) => !rootFiles.includes(f));
+  cachedFiles = [...rootFiles, ...nestedFiles];
+  cacheTimestamp = now;
+  return cachedFiles;
+}
+function safePath(projectDir, requestedPath) {
+  const resolved = path4.resolve(projectDir, requestedPath);
+  if (!resolved.startsWith(projectDir + path4.sep) && resolved !== projectDir) {
+    return null;
+  }
+  if (!resolved.endsWith(".canvas")) {
+    return null;
+  }
+  return resolved;
+}
+function createCanvasRouter(projectDir) {
+  const router = Router5();
+  router.get("/files", (_req, res) => {
+    try {
+      const relativePaths = getCanvasFiles(projectDir);
+      const files = relativePaths.map((relPath) => {
+        const absPath = path4.join(projectDir, relPath);
+        try {
+          const stat = fs4.statSync(absPath);
+          let name = path4.basename(relPath, ".canvas");
+          let description = "";
+          try {
+            const raw = yaml4.load(fs4.readFileSync(absPath, "utf8"));
+            if (raw && typeof raw.name === "string") name = raw.name;
+            if (raw && typeof raw.description === "string") description = raw.description;
+          } catch {
+          }
+          return {
+            path: relPath,
+            name,
+            description,
+            modified: stat.mtime.toISOString(),
+            size: stat.size
+          };
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      files.sort((a, b) => b.modified.localeCompare(a.modified));
+      res.json({ files });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list canvas files", details: err.message });
+    }
+  });
+  router.get("/files/*", (req, res) => {
+    const requestedPath = req.params[0] || req.params["path"] || "";
+    if (!requestedPath) {
+      res.status(400).json({ error: "File path required" });
+      return;
+    }
+    const absPath = safePath(projectDir, requestedPath);
+    if (!absPath) {
+      res.status(400).json({ error: "Invalid path" });
+      return;
+    }
+    if (!fs4.existsSync(absPath)) {
+      res.status(404).json({ error: `Canvas file not found: ${requestedPath}` });
+      return;
+    }
+    try {
+      const raw = fs4.readFileSync(absPath, "utf8");
+      const parsed = yaml4.load(raw);
+      res.json(parsed);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read canvas file", details: err.message });
+    }
+  });
+  router.put("/files/*", (req, res) => {
+    const requestedPath = req.params[0] || req.params["path"] || "";
+    if (!requestedPath) {
+      res.status(400).json({ error: "File path required" });
+      return;
+    }
+    const absPath = safePath(projectDir, requestedPath);
+    if (!absPath) {
+      res.status(400).json({ error: "Invalid path" });
+      return;
+    }
+    try {
+      const data = req.body;
+      if (!data || typeof data !== "object") {
+        res.status(400).json({ error: "Request body must be a JSON object" });
+        return;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (!data.created) data.created = now;
+      data.updated = now;
+      const dir = path4.dirname(absPath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
+      }
+      const yamlStr = yaml4.dump(data, {
+        lineWidth: -1,
+        noRefs: true,
+        quotingType: '"',
+        forceQuotes: false
+      });
+      fs4.writeFileSync(absPath, yamlStr, "utf8");
+      cachedFiles = null;
+      res.json({ saved: true, path: requestedPath });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to save canvas file", details: err.message });
+    }
+  });
+  router.delete("/files/*", (req, res) => {
+    const requestedPath = req.params[0] || req.params["path"] || "";
+    if (!requestedPath) {
+      res.status(400).json({ error: "File path required" });
+      return;
+    }
+    const absPath = safePath(projectDir, requestedPath);
+    if (!absPath) {
+      res.status(400).json({ error: "Invalid path" });
+      return;
+    }
+    if (!fs4.existsSync(absPath)) {
+      res.status(404).json({ error: `Canvas file not found: ${requestedPath}` });
+      return;
+    }
+    try {
+      fs4.unlinkSync(absPath);
+      cachedFiles = null;
+      res.json({ deleted: true, path: requestedPath });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to delete canvas file", details: err.message });
+    }
+  });
+  return router;
+}
+
 // src/platform-server/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path4.dirname(__filename);
+var __dirname = path5.dirname(__filename);
 var log = {
   component(name) {
     const symbol = chalk.magenta(`#${name}`);
@@ -1124,7 +1304,7 @@ var log = {
   }
 };
 function resolveSections(options) {
-  const always = ["overview", "lore", "graph", "git", "ambient", "team"];
+  const always = ["overview", "lore", "graph", "canvas", "git", "ambient", "team"];
   const requested = options.sections ?? [...always, "sentinel", "university", "symphony", "docs"];
   const enabled = /* @__PURE__ */ new Set();
   for (const section of requested) {
@@ -1133,15 +1313,15 @@ function resolveSections(options) {
       continue;
     }
     if (section === "sentinel") {
-      const sentinelRoutesPath = path4.join(options.projectDir, ".paradigm");
-      if (fs4.existsSync(sentinelRoutesPath)) {
+      const sentinelRoutesPath = path5.join(options.projectDir, ".paradigm");
+      if (fs5.existsSync(sentinelRoutesPath)) {
         enabled.add(section);
       }
     } else if (section === "university") {
       enabled.add(section);
     } else if (section === "symphony") {
-      const mailDir = path4.join(process.env.HOME || "~", ".paradigm", "score");
-      if (fs4.existsSync(mailDir)) {
+      const mailDir = path5.join(process.env.HOME || "~", ".paradigm", "score");
+      if (fs5.existsSync(mailDir)) {
         enabled.add(section);
       }
     } else {
@@ -1170,6 +1350,7 @@ function createPlatformApp(options) {
   app.use("/api/symbols", createSymbolsRouter(options.projectDir));
   app.use("/api/graphs", createGraphsRouter(options.projectDir));
   app.get("/api/platform/overview", createOverviewHandler(options.projectDir));
+  app.use("/api/canvas", createCanvasRouter(options.projectDir));
   app.use("/api/git", createGitRouter(options.projectDir));
   app.get("/api/platform/health", (_req, res) => {
     res.json({
@@ -1185,15 +1366,15 @@ function createPlatformApp(options) {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
   app.set("agentRouterSlot", true);
-  let uiDistPath = path4.join(__dirname, "..", "platform-ui", "dist");
-  if (!fs4.existsSync(uiDistPath)) {
-    uiDistPath = path4.join(__dirname, "..", "..", "platform-ui", "dist");
+  let uiDistPath = path5.join(__dirname, "..", "platform-ui", "dist");
+  if (!fs5.existsSync(uiDistPath)) {
+    uiDistPath = path5.join(__dirname, "..", "..", "platform-ui", "dist");
   }
-  if (fs4.existsSync(uiDistPath)) {
+  if (fs5.existsSync(uiDistPath)) {
     app.use(express.static(uiDistPath));
     app.get("{*path}", (req, res, next) => {
       if (!req.path.startsWith("/api")) {
-        res.sendFile(path4.join(uiDistPath, "index.html"));
+        res.sendFile(path5.join(uiDistPath, "index.html"));
       } else {
         next();
       }
@@ -1258,7 +1439,7 @@ async function startPlatformServer(options) {
       log.component("platform-server").warn("Docs routes failed to mount");
     }
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     httpServer.listen(options.port, () => {
       log.component("platform-server").success("Platform running", { url: `http://localhost:${options.port}` });
       log.component("platform-ws").success("WebSocket ready", { url: `ws://localhost:${options.port}/ws` });
@@ -1276,7 +1457,7 @@ async function startPlatformServer(options) {
           log.component("platform-server").warn("Could not open browser automatically");
         });
       }
-      resolve();
+      resolve2();
     });
     httpServer.on("error", (err) => {
       if (err.code === "EADDRINUSE") {

package/dist/{reindex-J5SEDVTT.js → reindex-KFUPB3ES.js}

@@ -3,7 +3,7 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-SU3WDCRR.js";
+} from "./chunk-T3YGSZCI.js";
 import "./chunk-L27I3CPZ.js";
 import "./chunk-SDDCVUCV.js";
 import "./chunk-5VKJBNJL.js";

package/dist/{serve-EFVRS4GA.js → serve-QWWJP2EW.js}

@@ -10,7 +10,7 @@ async function serveCommand(options) {
   const sections = options.sections ? options.sections.split(",").map((s) => s.trim()) : void 0;
   console.log(chalk.cyan("\n  Starting Paradigm Platform...\n"));
   try {
-    const { startPlatformServer } = await import("./platform-server-2D6S6YTK.js");
+    const { startPlatformServer } = await import("./platform-server-U5L2G3EU.js");
     await startPlatformServer({ port, projectDir, open: shouldOpen, sections });
     console.log(chalk.green(`  Platform running at ${chalk.bold(`http://localhost:${port}`)}`));
     console.log(chalk.gray("  Press Ctrl+C to stop\n"));

package/dist/{shift-VFG23DLA.js → shift-2NYRFVEZ.js}

@@ -278,6 +278,11 @@ workspace: "${relPath}"
       }
     }
   }
+  const portalPath = path.join(cwd, "portal.yaml");
+  if (!fs.existsSync(portalPath)) {
+    const defaultPortal = { version: "1.0.0", gates: {}, routes: {} };
+    fs.writeFileSync(portalPath, yaml.dump(defaultPortal, { lineWidth: -1, noRefs: true }), "utf8");
+  }
   const lorePath = path.join(cwd, ".paradigm", "lore");
   if (!fs.existsSync(lorePath)) {
     fs.mkdirSync(lorePath, { recursive: true });
@@ -385,7 +390,7 @@ workspace: "${relPath}"
     { path: ".paradigm/agents.yaml", desc: "Team agent configuration" },
     { path: ".purpose", desc: "Root feature definitions" },
     { path: ".paradigm/lore/", desc: "Project lore timeline", isDir: true },
-    { path: "portal.yaml", desc: "Authorization gates", optional: true },
+    { path: "portal.yaml", desc: "Authorization gates" },
     { path: "CLAUDE.md", desc: "Claude Code AI instructions" },
     { path: "AGENTS.md", desc: "Universal AI agent instructions" },
     { path: ".cursor/rules/", desc: "Cursor AI instructions", isDir: true },
@@ -429,7 +434,6 @@ workspace: "${relPath}"
     console.log(chalk.white(`  ${nextStep++}. `) + chalk.gray("Run ") + chalk.cyan(`paradigm shift --workspace "${options.workspace}"`) + chalk.gray(" in sibling projects"));
   }
   console.log(chalk.white(`  ${nextStep++}. `) + chalk.gray("Edit ") + chalk.cyan(".purpose") + chalk.gray(" to define your features"));
-  console.log(chalk.white(`  ${nextStep++}. `) + chalk.gray("Create ") + chalk.cyan("portal.yaml") + chalk.gray(" if you have authorization"));
   console.log(chalk.white(`  ${nextStep++}. `) + chalk.gray("Add ") + chalk.cyan(".purpose") + chalk.gray(" files to feature directories"));
   console.log(chalk.white(`  ${nextStep++}. `) + chalk.gray("Run ") + chalk.cyan("paradigm shift --verify") + chalk.gray(" to check health"));
   console.log("");