@a-company/paradigm 3.25.2 → 3.28.0

package/dist/conductor-HLWYWUVH.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/conductor.ts
+import { execSync, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+async function conductorCommand(options) {
+  const cmdLog = log.command("conductor");
+  const conductorDir = findConductorDir();
+  if (!conductorDir) {
+    cmdLog.error("Could not locate packages/conductor/");
+    console.log(chalk.gray("  Ensure the Paradigm monorepo is intact."));
+    process.exit(1);
+  }
+  const buildDir = path.join(conductorDir, ".build", "release");
+  const binaryPath = path.join(buildDir, "conductor");
+  const needsBuild = options.build || !fs.existsSync(binaryPath);
+  if (needsBuild) {
+    cmdLog.info("Building Conductor\u2026");
+    try {
+      const buildCmd = "swift build -c release";
+      execSync(buildCmd, {
+        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);
+    }
+  }
+  cmdLog.info("Launching Conductor\u2026");
+  const child = spawn(binaryPath, [], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  console.log(chalk.cyan("\n  Paradigm Conductor is running."));
+  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/index.js

@@ -747,6 +747,10 @@ sentinelCmd.command("defend [path]", { isDefault: true }).description("Launch th
   const { sentinelCommand } = await import("./sentinel-FUR3QKCJ.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-HLWYWUVH.js");
+  await conductorCommand(options);
+});
 program.command("university").description("Launch Paradigm University - interactive learning platform & PLSAT certification").option("-p, --port <port>", "Port to run on", "3839").option("--no-open", "Don't open browser automatically").action(async (options) => {
   const { universityCommand } = await import("./university-A66BMZ4Z.js");
   await universityCommand(void 0, options);

package/dist/mcp.js

@@ -2026,8 +2026,8 @@ function registerResources(server, getContext2) {
 }
 
 // ../paradigm-mcp/src/tools/index.ts
-import * as os3 from "os";
-import * as path28 from "path";
+import * as os4 from "os";
+import * as path29 from "path";
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema
@@ -2791,7 +2791,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path29]) => sym.toLowerCase().includes(targetLower) || path29.toLowerCase().includes(targetLower)
+      ([sym, path30]) => sym.toLowerCase().includes(targetLower) || path30.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -11289,8 +11289,8 @@ function generateRunId() {
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function interpolate(value, scope) {
   if (typeof value === "string") {
-    return value.replace(TEMPLATE_REGEX, (_match, path29) => {
-      const resolved = resolvePath(path29.trim(), scope);
+    return value.replace(TEMPLATE_REGEX, (_match, path30) => {
+      const resolved = resolvePath(path30.trim(), scope);
       return resolved !== void 0 ? String(resolved) : _match;
     });
   }
@@ -11323,8 +11323,8 @@ function resolvePath(dotPath, scope) {
       return void 0;
   }
 }
-function deepGet(obj, path29) {
-  const parts = path29.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path30) {
+  const parts = path30.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -11560,11 +11560,11 @@ async function runPersonaObject(rootDir, persona, options) {
 }
 async function runChain(rootDir, chainId, options) {
   const start = Date.now();
-  const fs25 = await import("fs");
-  const path29 = await import("path");
+  const fs26 = await import("fs");
+  const path30 = await import("path");
   const yaml15 = await import("js-yaml");
-  const chainPath = path29.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
-  if (!fs25.existsSync(chainPath)) {
+  const chainPath = path30.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
+  if (!fs26.existsSync(chainPath)) {
     return {
       chain_id: chainId,
       status: "error",
@@ -11573,7 +11573,7 @@ async function runChain(rootDir, chainId, options) {
       duration_ms: Date.now() - start
     };
   }
-  const chain = yaml15.load(fs25.readFileSync(chainPath, "utf8"));
+  const chain = yaml15.load(fs26.readFileSync(chainPath, "utf8"));
   let permutation;
   if (options.permutation && chain.permutations) {
     permutation = chain.permutations.find((p) => p.id === options.permutation);
@@ -11677,8 +11677,8 @@ function validateInterpolation(persona) {
     const serialized = JSON.stringify(step);
     const templates = serialized.match(TEMPLATE_REGEX) || [];
     for (const template of templates) {
-      const path29 = template.replace("{{", "").replace("}}", "").trim();
-      const [namespace, ...rest] = path29.split(".");
+      const path30 = template.replace("{{", "").replace("}}", "").trim();
+      const [namespace, ...rest] = path30.split(".");
       const key = rest.join(".");
       switch (namespace) {
         case "fixtures":
@@ -13743,9 +13743,298 @@ async function handlePipelineTool(name, args, ctx) {
   }
 }
 
-// ../paradigm-mcp/src/tools/fallback-grep.ts
+// ../paradigm-mcp/src/tools/conductor.ts
+import { execSync as execSync6 } from "child_process";
+
+// ../paradigm-mcp/src/utils/conductor-loader.ts
+import * as fs25 from "fs";
 import * as path27 from "path";
+import * as os3 from "os";
 import { execSync as execSync5 } from "child_process";
+var CONDUCTOR_DIR = path27.join(os3.homedir(), ".conductor");
+var SESSIONS_DIR = path27.join(CONDUCTOR_DIR, "sessions");
+function ensureSessionsDir() {
+  if (!fs25.existsSync(SESSIONS_DIR)) {
+    fs25.mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+function registerConductorSession(session) {
+  ensureSessionsDir();
+  const entry = {
+    ...session,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filePath = path27.join(SESSIONS_DIR, `${session.pid}.json`);
+  fs25.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
+  return entry;
+}
+function unregisterConductorSession(pid) {
+  const filePath = path27.join(SESSIONS_DIR, `${pid}.json`);
+  if (fs25.existsSync(filePath)) {
+    fs25.unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+function listConductorSessions() {
+  ensureSessionsDir();
+  const files = fs25.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const content = fs25.readFileSync(path27.join(SESSIONS_DIR, file), "utf-8");
+      const session = JSON.parse(content);
+      sessions.push(session);
+    } catch {
+    }
+  }
+  return sessions;
+}
+function cleanStaleSessions() {
+  const sessions = listConductorSessions();
+  let cleaned = 0;
+  for (const session of sessions) {
+    if (!isProcessAlive(session.pid)) {
+      unregisterConductorSession(session.pid);
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectTerminalBundleId() {
+  try {
+    const script = `
+      tell application "System Events"
+        set frontApp to first application process whose frontmost is true
+        return bundle identifier of frontApp
+      end tell
+    `;
+    const result = execSync5(`osascript -e '${script}'`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return result || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectGitBranch(cwd) {
+  try {
+    return execSync5("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function autoRegisterWithConductor(projectDir2) {
+  try {
+    const pid = process.pid;
+    const terminal = detectTerminalBundleId();
+    const branch = detectGitBranch(projectDir2);
+    let parentPid;
+    try {
+      const ppid = execSync5(`ps -o ppid= -p ${pid}`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      parentPid = parseInt(ppid, 10);
+      if (isNaN(parentPid)) parentPid = void 0;
+    } catch {
+    }
+    registerConductorSession({
+      pid,
+      parentPid,
+      projectDir: projectDir2,
+      terminal,
+      branch
+    });
+    const cleanup = () => {
+      try {
+        unregisterConductorSession(pid);
+      } catch {
+      }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    console.error(`[paradigm-mcp] Auto-registered with Conductor (PID ${pid})`);
+  } catch {
+    console.error("[paradigm-mcp] Auto-registration with Conductor skipped (non-fatal)");
+  }
+}
+
+// ../paradigm-mcp/src/tools/conductor.ts
+function getConductorToolsList() {
+  return [
+    {
+      name: "paradigm_conductor_register",
+      description: 'Register this Claude Code session with Paradigm Conductor. Makes the session visible in the Conductor overlay for voice/gesture/gaze dispatch. Call this when the user says "/conduct" or wants to surface a session to Conductor. ~100 tokens.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          label: {
+            type: "string",
+            description: 'Human-readable label for this session (e.g., "backend refactor", "auth feature")'
+          },
+          terminal: {
+            type: "string",
+            description: 'Terminal bundle ID (e.g., "com.mitchellh.ghostty"). Auto-detected if omitted.'
+          }
+        },
+        required: []
+      },
+      annotations: {
+        title: "Register with Conductor",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    {
+      name: "paradigm_conductor_unregister",
+      description: "Unregister this Claude Code session from Paradigm Conductor. Removes it from the Conductor overlay. Call when ending a session or when the user wants to hide from Conductor. ~50 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      annotations: {
+        title: "Unregister from Conductor",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    {
+      name: "paradigm_conductor_list",
+      description: "List all Claude Code sessions currently registered with Paradigm Conductor. Shows PIDs, project dirs, and labels. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          clean: {
+            type: "boolean",
+            description: "If true, clean up stale sessions (dead PIDs) before listing"
+          }
+        },
+        required: []
+      },
+      annotations: {
+        title: "List Conductor sessions",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    }
+  ];
+}
+async function handleConductorTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_conductor_register": {
+      const pid = process.pid;
+      const projectDir2 = ctx.rootDir;
+      const terminal = args.terminal || detectTerminalBundleId();
+      const branch = detectGitBranch(projectDir2);
+      let parentPid;
+      try {
+        const ppid = execSync6(`ps -o ppid= -p ${pid}`, {
+          encoding: "utf-8",
+          timeout: 3e3
+        }).trim();
+        parentPid = parseInt(ppid, 10);
+        if (isNaN(parentPid)) parentPid = void 0;
+      } catch {
+      }
+      const session = registerConductorSession({
+        pid,
+        parentPid,
+        projectDir: projectDir2,
+        terminal,
+        label: args.label,
+        branch
+      });
+      const lines = [
+        `\u2713 Registered with Conductor`,
+        ``,
+        `  PID: ${session.pid}`,
+        `  Project: ${session.projectDir}`
+      ];
+      if (session.branch) lines.push(`  Branch: ${session.branch}`);
+      if (session.label) lines.push(`  Label: ${session.label}`);
+      if (session.terminal) lines.push(`  Terminal: ${session.terminal}`);
+      lines.push(`  File: ~/.conductor/sessions/${session.pid}.json`);
+      lines.push(``);
+      lines.push(`This session is now visible in Paradigm Conductor.`);
+      lines.push(`Conductor will auto-discover it via the registration file.`);
+      return { text: lines.join("\n"), handled: true };
+    }
+    case "paradigm_conductor_unregister": {
+      const pid = process.pid;
+      const removed = unregisterConductorSession(pid);
+      if (removed) {
+        return {
+          text: `\u2713 Unregistered from Conductor (PID ${pid}).
+This session is no longer visible in the Conductor overlay.`,
+          handled: true
+        };
+      } else {
+        return {
+          text: `Session (PID ${pid}) was not registered with Conductor.`,
+          handled: true
+        };
+      }
+    }
+    case "paradigm_conductor_list": {
+      if (args.clean) {
+        const cleaned = cleanStaleSessions();
+        if (cleaned > 0) {
+        }
+      }
+      const sessions = listConductorSessions();
+      if (sessions.length === 0) {
+        return {
+          text: "No sessions registered with Conductor.\nUse paradigm_conductor_register or /conduct to register.",
+          handled: true
+        };
+      }
+      const lines = [`${sessions.length} session(s) registered with Conductor:
+`];
+      for (const s of sessions) {
+        const parts = [`  PID ${s.pid}`];
+        if (s.label) parts.push(`"${s.label}"`);
+        parts.push(`\u2014 ${s.projectDir}`);
+        if (s.branch) parts.push(`(${s.branch})`);
+        lines.push(parts.join(" "));
+      }
+      if (args.clean) {
+        lines.push(`
+(Stale sessions cleaned)`);
+      }
+      return { text: lines.join("\n"), handled: true };
+    }
+    default:
+      return { text: "", handled: false };
+  }
+}
+
+// ../paradigm-mcp/src/tools/fallback-grep.ts
+import * as path28 from "path";
+import { execSync as execSync7 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
   const results = [];
@@ -13759,7 +14048,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
   let output = "";
   for (const cmd of grepCommands) {
     try {
-      output = execSync5(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
+      output = execSync7(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
       if (output.trim()) break;
     } catch {
       continue;
@@ -13773,7 +14062,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path27.relative(rootDir, filePath);
+      const relativePath = path28.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -14042,6 +14331,8 @@ function registerTools(server, getContext2, reloadContext2) {
           ...getHeatmapToolsList(),
           // Pipeline tools
           ...getPipelineToolsList(),
+          // Conductor session registration tools
+          ...getConductorToolsList(),
           // Plugin update check
           {
             name: "paradigm_plugin_check",
@@ -14432,7 +14723,7 @@ function registerTools(server, getContext2, reloadContext2) {
                 const symbols = getSymbolsByType(ctx.index, type);
                 examples[type] = symbols.slice(0, 3).map((s) => s.symbol);
               }
-              const platform2 = os3.platform();
+              const platform2 = os4.platform();
               const isWindows = platform2 === "win32";
               const shell = isWindows ? "PowerShell/CMD" : platform2 === "darwin" ? "zsh/bash" : "bash";
               let protocols;
@@ -14675,7 +14966,7 @@ Update command:
             const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-YG3KIXAK.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
-              const memberAbsPath = path28.resolve(path28.dirname(ctx.workspace.workspacePath), member.path);
+              const memberAbsPath = path29.resolve(path29.dirname(ctx.workspace.workspacePath), member.path);
               try {
                 const result = await rebuildStaticFiles2(memberAbsPath);
                 memberResults.push({
@@ -14890,6 +15181,15 @@ Update command:
                 };
               }
             }
+            if (name.startsWith("paradigm_conductor_")) {
+              const result = await handleConductorTool(name, args, ctx);
+              if (result.handled) {
+                trackToolCall(result.text.length, name);
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
             if (name === "paradigm_reindex") {
               const reload = reloadContext2 || (async () => {
               });
@@ -14941,6 +15241,7 @@ async function main() {
     console.error(`[paradigm-mcp] Error loading project:`, error);
     process.exit(1);
   }
+  autoRegisterWithConductor(projectDir);
   const server = new Server(
     {
       name: "paradigm",