@a-company/paradigm 3.46.0 → 5.4.0

package/dist/{chunk-QDXI2DHR.js → chunk-J2JEQRT3.js}

@@ -10,7 +10,7 @@ async function graphCommand(path, options) {
   const shouldOpen = options.open !== false;
   console.log(chalk.cyan("\nStarting Symbol Graph...\n"));
   try {
-    const { startGraphServer } = await import("./graph-server-ZPXRSGCW.js");
+    const { startGraphServer } = await import("./graph-server-YL22VBBN.js");
     console.log(chalk.gray(`Project: ${projectDir}`));
     console.log(chalk.gray(`Port: ${port}`));
     console.log();

package/dist/{chunk-AKIMFN6I.js → chunk-JASGXLK3.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-7COU5S2Z.js";
+} from "./chunk-VL67H5IC.js";
 import {
   getDefaultPremiseContent
 } from "./chunk-ZGUAAVMA.js";
@@ -19,7 +19,7 @@ import {
   detectIDE,
   loadParadigmFiles,
   syncToIDE
-} from "./chunk-KB4XJWE3.js";
+} from "./chunk-6N3JTACN.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{chunk-J4E6K5MG.js → chunk-LSRABQIY.js}

@@ -5,7 +5,7 @@ import {
 import {
   getProvider,
   initializeProviders
-} from "./chunk-FS3WTUHY.js";
+} from "./chunk-TXESEO7Y.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
@@ -614,6 +614,7 @@ var AgentSpawner = class {
       agent: agentName,
       task,
       status: "success",
+      completionVerified: false,
       outputs: {
         artifacts: [],
         symbols: context.symbols,
@@ -681,6 +682,29 @@ var AgentSpawner = class {
       if (this.budgetTracker) {
         this.budgetTracker.recordUsage(agentName, relay.metrics.tokens_used, model);
       }
+      if (relay.status === "success") {
+        const hasArtifacts = relay.outputs.artifacts.length > 0;
+        const hasDecisions = relay.outputs.decisions.length > 0;
+        const hasHandoff = !!relay.handoff;
+        const didFileWork = relay.metrics.files_written > 0;
+        const isArchitect = agentName === "architect";
+        const isBuilder = agentName === "builder";
+        if (isBuilder && !didFileWork && !hasHandoff) {
+          relay.status = "partial";
+        } else if (!hasArtifacts && !hasDecisions && !hasHandoff && !didFileWork) {
+          relay.status = "partial";
+        }
+        relay.completionVerified = true;
+        if (relay.status === "partial" && !isArchitect) {
+          if (options.onMessage) {
+            options.onMessage({
+              type: "text",
+              content: `[completion-check] Agent "${agentName}" downgraded from success \u2192 partial: no meaningful output detected.`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      }
       if (this.auditLogger) {
         const agentLog = {
           name: agentName,

package/dist/chunk-MCMOGQMU.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  __esm,
+  __export
+} from "./chunk-7N7GSU6K.js";
+
+// ../paradigm-mcp/src/utils/journal-loader.ts
+var journal_loader_exports = {};
+__export(journal_loader_exports, {
+  getJournalStats: () => getJournalStats,
+  loadAllJournalEntries: () => loadAllJournalEntries,
+  loadJournalEntries: () => loadJournalEntries,
+  loadJournalEntry: () => loadJournalEntry,
+  recordJournalEntry: () => recordJournalEntry
+});
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+function getJournalDir(agentId) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path.join(home, ".paradigm", "agents", agentId, "journal");
+}
+function generateJournalId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
+  const counter = String(Math.floor(Math.random() * 999) + 1).padStart(3, "0");
+  return `LJ-${date}-${time}-${counter}`;
+}
+function recordJournalEntry(agentId, entry) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generateJournalId();
+  const full = {
+    id,
+    agent: agentId,
+    timestamp: now.toISOString(),
+    ...entry
+  };
+  const dir = getJournalDir(agentId);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${id}.yaml`);
+  fs.writeFileSync(filePath, yaml.dump(full, { lineWidth: 120, noRefs: true }), "utf8");
+  return full;
+}
+function loadJournalEntries(agentId, filter) {
+  const dir = getJournalDir(agentId);
+  if (!fs.existsSync(dir)) return [];
+  const entries = [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(dir, file), "utf8");
+      const entry = yaml.load(content);
+      if (entry && entry.id) {
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  let filtered = entries;
+  if (filter?.trigger) {
+    filtered = filtered.filter((e) => e.trigger === filter.trigger);
+  }
+  if (filter?.project) {
+    filtered = filtered.filter((e) => e.project === filter.project);
+  }
+  if (filter?.transferable !== void 0) {
+    filtered = filtered.filter((e) => e.transferable === filter.transferable);
+  }
+  if (filter?.tag) {
+    filtered = filtered.filter((e) => e.tags?.some((t) => t.startsWith(filter.tag)));
+  }
+  if (filter?.dateFrom) {
+    filtered = filtered.filter((e) => e.timestamp >= filter.dateFrom);
+  }
+  if (filter?.dateTo) {
+    filtered = filtered.filter((e) => e.timestamp <= filter.dateTo);
+  }
+  filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (filter?.limit) {
+    filtered = filtered.slice(0, filter.limit);
+  }
+  return filtered;
+}
+function loadJournalEntry(agentId, id) {
+  const dir = getJournalDir(agentId);
+  const filePath = path.join(dir, `${id}.yaml`);
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8");
+  return yaml.load(content);
+}
+function loadAllJournalEntries(filter) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const agentsDir = path.join(home, ".paradigm", "agents");
+  if (!fs.existsSync(agentsDir)) return [];
+  const entries = [];
+  const agents = fs.readdirSync(agentsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const agentDir of agents) {
+    if (filter?.agent && agentDir.name !== filter.agent) continue;
+    const agentEntries = loadJournalEntries(agentDir.name, filter);
+    entries.push(...agentEntries);
+  }
+  entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (filter?.limit) {
+    return entries.slice(0, filter.limit);
+  }
+  return entries;
+}
+function getJournalStats(agentId) {
+  const entries = loadJournalEntries(agentId);
+  const byTrigger = {};
+  const byProject = {};
+  let transferableCount = 0;
+  for (const e of entries) {
+    byTrigger[e.trigger] = (byTrigger[e.trigger] || 0) + 1;
+    byProject[e.project] = (byProject[e.project] || 0) + 1;
+    if (e.transferable) transferableCount++;
+  }
+  return {
+    total: entries.length,
+    byTrigger,
+    byProject,
+    transferableCount,
+    recentInsights: entries.slice(0, 5).map((e) => ({
+      id: e.id,
+      trigger: e.trigger,
+      insight: e.insight.slice(0, 200),
+      timestamp: e.timestamp
+    }))
+  };
+}
+var init_journal_loader = __esm({
+  "../paradigm-mcp/src/utils/journal-loader.ts"() {
+  }
+});
+
+export {
+  recordJournalEntry,
+  loadJournalEntries,
+  loadJournalEntry,
+  loadAllJournalEntries,
+  getJournalStats,
+  journal_loader_exports,
+  init_journal_loader
+};

package/dist/{chunk-ZXMDA7VB.js → chunk-PDX44BCA.js}

@@ -1,16 +1,11 @@
 #!/usr/bin/env node
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 
 export {
-  __require,
-  __commonJS
+  __require
 };

package/dist/{chunk-2SKXFXIT.js → chunk-S3ORKP3V.js}

@@ -2,7 +2,7 @@
 import {
   detectIDE,
   getAdapter
-} from "./chunk-KB4XJWE3.js";
+} from "./chunk-6N3JTACN.js";
 import {
   parseParadigmConfig
 } from "./chunk-YO6DVTL7.js";
@@ -13,6 +13,7 @@ import {
 // src/commands/doctor/index.ts
 import * as fs from "fs";
 import * as path from "path";
+import * as yaml from "js-yaml";
 import chalk from "chalk";
 async function doctorCommand(options = {}) {
   const cwd = options.rootDir || process.cwd();
@@ -245,8 +246,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(configPath)) {
       try {
         const configContent = fs.readFileSync(configPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const config = parse(configContent);
+        const config = yaml.load(configContent);
         const purposeRequired = config?.["purpose-required"];
         if (purposeRequired && Array.isArray(purposeRequired)) {
           const missingDirs = [];
@@ -314,8 +314,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(portalPath)) {
       try {
         const portalContent = fs.readFileSync(portalPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const portal = parse(portalContent);
+        const portal = yaml.load(portalContent);
         if (portal?.version && portal?.gates) {
           const gateCount = Object.keys(portal.gates || {}).length;
           const routeCount = Object.keys(portal.routes || {}).length;
@@ -343,7 +342,7 @@ async function doctorCommand(options = {}) {
     }
     if (fs.existsSync(portalPath)) {
       try {
-        const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-VU4NIFEN.js");
+        const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-J7DGAPFX.js");
         const complianceReport = await checkPortalCompliance(cwd);
         const summary = getComplianceSummary(complianceReport);
         results.push({
@@ -359,8 +358,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(flowsPath)) {
       try {
         const flowsContent = fs.readFileSync(flowsPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const flows = parse(flowsContent);
+        const flows = yaml.load(flowsContent);
         if (flows?.version && flows?.flows) {
           const flowCount = Object.keys(flows.flows || {}).length;
           const emptyFlows = Object.entries(flows.flows || {}).filter(
@@ -449,8 +447,7 @@ async function doctorCommand(options = {}) {
           if (fs.existsSync(quizDir)) {
             for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
               try {
-                const { parse } = await import("./dist-PSF5CP4I.js");
-                const quiz = parse(fs.readFileSync(path.join(quizDir, file), "utf8"));
+                const quiz = yaml.load(fs.readFileSync(path.join(quizDir, file), "utf8"));
                 if (quiz?.questions) {
                   for (const q of quiz.questions) {
                     if (q.choices && q.correct && !(q.correct in q.choices)) {
@@ -466,8 +463,7 @@ async function doctorCommand(options = {}) {
           if (fs.existsSync(pathDir)) {
             for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
               try {
-                const { parse } = await import("./dist-PSF5CP4I.js");
-                const lp = parse(fs.readFileSync(path.join(pathDir, file), "utf8"));
+                const lp = yaml.load(fs.readFileSync(path.join(pathDir, file), "utf8"));
                 if (lp?.steps) {
                   for (const step of lp.steps) {
                     if (step.content && !step.content.startsWith("plsat:")) {
@@ -551,8 +547,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(habitsPath)) {
       try {
         const habitsContent = fs.readFileSync(habitsPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const habits = parse(habitsContent);
+        const habits = yaml.load(habitsContent);
         if (habits?.version && Array.isArray(habits?.habits)) {
           const enabled = habits.habits.filter((h) => h.enabled !== false).length;
           results.push({
@@ -633,7 +628,7 @@ async function doctorCommand(options = {}) {
       }
     }
   }
-  const { runContextAudit } = await import("./context-audit-557EO6PK.js");
+  const { runContextAudit } = await import("./context-audit-RLO3ETRP.js");
   const contextResults = await runContextAudit(cwd, { quiet });
   let contextErrorCount = 0;
   let contextWarnCount = 0;

package/dist/chunk-TAIJOFOE.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/work-log-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var WORK_LOG_DIR = ".paradigm/work-log";
+function generateWorkLogId(agent) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const sanitized = agent.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 20);
+  const counter = String(Math.floor(Math.random() * 999) + 1).padStart(3, "0");
+  return `WL-${sanitized}-${date}-${counter}`;
+}
+function getDateDir(rootDir, date) {
+  return path.join(rootDir, WORK_LOG_DIR, date);
+}
+function recordWorkLog(rootDir, entry) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const id = generateWorkLogId(entry.agent);
+  const full = {
+    id,
+    timestamp: now.toISOString(),
+    ...entry
+  };
+  const dir = getDateDir(rootDir, date);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${id}.yaml`);
+  fs.writeFileSync(filePath, yaml.dump(full, { lineWidth: 120, noRefs: true }), "utf8");
+  return full;
+}
+function loadWorkLogEntries(rootDir, filter) {
+  const baseDir = path.join(rootDir, WORK_LOG_DIR);
+  if (!fs.existsSync(baseDir)) return [];
+  const entries = [];
+  const dateDirs = fs.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(d.name)).map((d) => d.name).sort().reverse();
+  for (const dateDir of dateDirs) {
+    if (filter?.dateFrom && dateDir < filter.dateFrom) continue;
+    if (filter?.dateTo && dateDir > filter.dateTo) continue;
+    const dirPath = path.join(baseDir, dateDir);
+    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const entry = yaml.load(content);
+        if (entry && entry.id) {
+          entries.push(entry);
+        }
+      } catch {
+      }
+    }
+  }
+  let filtered = entries;
+  if (filter?.agent) {
+    filtered = filtered.filter((e) => e.agent === filter.agent);
+  }
+  if (filter?.outcome) {
+    filtered = filtered.filter((e) => e.outcome === filter.outcome);
+  }
+  if (filter?.task_ref) {
+    filtered = filtered.filter((e) => e.task_ref === filter.task_ref);
+  }
+  if (filter?.symbol) {
+    filtered = filtered.filter((e) => e.symbols_touched?.includes(filter.symbol));
+  }
+  filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (filter?.limit) {
+    filtered = filtered.slice(0, filter.limit);
+  }
+  return filtered;
+}
+function loadWorkLogEntry(rootDir, id) {
+  const baseDir = path.join(rootDir, WORK_LOG_DIR);
+  if (!fs.existsSync(baseDir)) return null;
+  const match = id.match(/WL-[^-]+-(\d{4}-\d{2}-\d{2})-/);
+  if (match) {
+    const filePath = path.join(baseDir, match[1], `${id}.yaml`);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, "utf8");
+      return yaml.load(content);
+    }
+  }
+  const dateDirs = fs.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dateDirs) {
+    const filePath = path.join(baseDir, dir.name, `${id}.yaml`);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, "utf8");
+      return yaml.load(content);
+    }
+  }
+  return null;
+}
+function getWorkLogSummary(rootDir, days = 7) {
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  const dateFrom = cutoff.toISOString().slice(0, 10);
+  const entries = loadWorkLogEntries(rootDir, { dateFrom });
+  const byOutcome = { pass: 0, fail: 0, partial: 0, blocked: 0 };
+  const byAgent = {};
+  for (const e of entries) {
+    byOutcome[e.outcome] = (byOutcome[e.outcome] || 0) + 1;
+    byAgent[e.agent] = (byAgent[e.agent] || 0) + 1;
+  }
+  return {
+    total: entries.length,
+    byOutcome,
+    byAgent,
+    recentEntries: entries.slice(0, 10).map((e) => ({
+      id: e.id,
+      agent: e.agent,
+      summary: e.summary,
+      outcome: e.outcome,
+      timestamp: e.timestamp
+    }))
+  };
+}
+
+export {
+  recordWorkLog,
+  loadWorkLogEntries,
+  loadWorkLogEntry,
+  getWorkLogSummary
+};

package/dist/{chunk-FS3WTUHY.js → chunk-TXESEO7Y.js}

@@ -136,32 +136,32 @@ async function initializeProviders(rootDir) {
   if (initialized) return;
   const dir = rootDir || process.cwd();
   try {
-    const { ClaudeAgentProvider } = await import("./claude-63ISJAZK.js");
+    const { ClaudeAgentProvider } = await import("./claude-FRRWJSTJ.js");
     registerProvider(new ClaudeAgentProvider());
   } catch {
   }
   try {
-    const { ClaudeCodeTeamsProvider } = await import("./claude-code-teams-CAJBEFIZ.js");
+    const { ClaudeCodeTeamsProvider } = await import("./claude-code-teams-T4SP24MD.js");
     registerProvider(new ClaudeCodeTeamsProvider(dir));
   } catch {
   }
   try {
-    const { ClaudeCodeTaskProvider } = await import("./claude-code-JRLMRPTO.js");
+    const { ClaudeCodeTaskProvider } = await import("./claude-code-HTBA4XRB.js");
     registerProvider(new ClaudeCodeTaskProvider(dir));
   } catch {
   }
   try {
-    const { CursorCliProvider } = await import("./cursor-cli-QUOOF2N4.js");
+    const { CursorCliProvider } = await import("./cursor-cli-JVEZGHWQ.js");
     registerProvider(new CursorCliProvider());
   } catch {
   }
   try {
-    const { ClaudeCliProvider } = await import("./claude-cli-ABML5RHX.js");
+    const { ClaudeCliProvider } = await import("./claude-cli-XJLK2X4L.js");
     registerProvider(new ClaudeCliProvider());
   } catch {
   }
   try {
-    const { ManualProvider } = await import("./manual-AFJ2J2V3.js");
+    const { ManualProvider } = await import("./manual-G6FISID5.js");
     registerProvider(new ManualProvider(dir));
   } catch {
   }

package/dist/{chunk-7COU5S2Z.js → chunk-VL67H5IC.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-ZGUAAVMA.js";
 import {
   cliBuildGraphState
-} from "./chunk-QDXI2DHR.js";
+} from "./chunk-J2JEQRT3.js";
 
 // src/commands/scan/navigator.ts
 import * as fs from "fs";

package/dist/{chunk-QWA26UNO.js → chunk-WQITYKHM.js}

@@ -2,7 +2,7 @@
 import {
   AgentSpawner,
   extractSymbols
-} from "./chunk-J4E6K5MG.js";
+} from "./chunk-LSRABQIY.js";
 import {
   AuditLogger
 } from "./chunk-PBHIFAL4.js";
@@ -12,10 +12,6 @@ import {
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
-import {
-  extractDeclaredGates,
-  loadPortalConfig
-} from "./chunk-MW5DMGBB.js";
 import {
   calculateCost
 } from "./chunk-5JGJACDU.js";
@@ -24,6 +20,10 @@ import {
   getReferencesTo,
   searchSymbols
 } from "./chunk-ZGUAAVMA.js";
+import {
+  extractDeclaredGates,
+  loadPortalConfig
+} from "./chunk-YMDLDELF.js";
 
 // src/core/orchestrator.ts
 import { minimatch } from "minimatch";
@@ -566,7 +566,7 @@ var Orchestrator = class {
       let preflightResult;
       if (options.pmGovernance?.enabled) {
         try {
-          const { aggregateFromDirectory } = await import("./dist-UXWV4OKX.js");
+          const { aggregateFromDirectory } = await import("./dist-34NA5RS5.js");
           const aggregation = await aggregateFromDirectory(this.rootDir);
           const index = buildSymbolIndex(aggregation);
           preflightResult = runPreflight(task, this.rootDir, index);
@@ -593,7 +593,7 @@ var Orchestrator = class {
       }
       if (options.pmGovernance?.enabled && preflightResult) {
         try {
-          const { aggregateFromDirectory } = await import("./dist-UXWV4OKX.js");
+          const { aggregateFromDirectory } = await import("./dist-34NA5RS5.js");
           const aggregation = await aggregateFromDirectory(this.rootDir);
           const index = buildSymbolIndex(aggregation);
           const filesModified = [];