@askexenow/exe-os 0.9.287 → 0.9.289

package/dist/exe-org-VAUMR7TL.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  getOrchestrationPhaseInfo,
+  loadOrchestrationPhase,
+  setOrchestrationPhase
+} from "./chunk-M3VHV2RV.js";
+import "./chunk-5P3HOBZX.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-org.ts
+function printPhase(info) {
+  console.log(`${info.label}`);
+  console.log(`Focus: ${info.focus}`);
+  console.log(`Suggestion: ${info.nextSuggestion}`);
+  console.log("");
+  console.log("This is guidance, not a blocker. You can change phases anytime.");
+}
+function usage() {
+  console.log(`exe-os org \u2014 orchestration maturity settings
+
+Usage:
+  exe-os org phase                 Show current orchestration phase
+  exe-os org phase 1               Set Phase 1: COO / Chief of Staff mode
+  exe-os org phase 2               Set Phase 2: Executive bench
+  exe-os org phase 3               Set Phase 3: Parallel execution org
+  exe-os org unlock executives     Suggest/enable Phase 2
+  exe-os org unlock parallel       Suggest/enable Phase 3
+  exe-os org status                Same as phase
+
+Phases are recommendations, not locks. Exe OS never overwrites your role titles,
+identities, memories, tasks, or custom org design when changing phase.`);
+}
+async function main(argv = process.argv.slice(2)) {
+  const [cmd, arg] = argv;
+  if (!cmd || cmd === "status" || cmd === "phase" && !arg) {
+    const info = await loadOrchestrationPhase();
+    printPhase(info);
+    return;
+  }
+  if (cmd === "phase" && arg) {
+    const info = await setOrchestrationPhase(arg, "cli");
+    console.log("Updated orchestration phase:");
+    printPhase(info);
+    return;
+  }
+  if (cmd === "unlock") {
+    if (arg === "executives" || arg === "executive" || arg === "phase2") {
+      const info = await setOrchestrationPhase("phase_2_executives", "cli");
+      console.log("Phase 2 enabled. Your COO can now lean on the executive bench when useful.");
+      printPhase(info);
+      return;
+    }
+    if (arg === "parallel" || arg === "parallel-org" || arg === "phase3") {
+      const info = await setOrchestrationPhase("phase_3_parallel_org", "cli");
+      console.log("Phase 3 enabled. Parallel execution is available with review/permission gates.");
+      printPhase(info);
+      return;
+    }
+  }
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+    usage();
+    return;
+  }
+  console.error(`Unknown org command: ${argv.join(" ")}`);
+  console.error("");
+  usage();
+  process.exit(1);
+}
+export {
+  getOrchestrationPhaseInfo,
+  main
+};

package/dist/exe-snapshot-KF3HPOWJ.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import {
+  DreamingEngine
+} from "./chunk-NS5G36TN.js";
+import {
+  storeBehavior
+} from "./chunk-7G52QPUX.js";
+import {
+  disposeStore,
+  flushBatch,
+  initStore,
+  writeMemory
+} from "./chunk-YEHV3FN5.js";
+import {
+  extractKeywords,
+  keywordsToString
+} from "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-2CO47E5Q.js";
+import "./chunk-Y25OJWOQ.js";
+import "./chunk-5XOAYMSU.js";
+import "./chunk-Z5P7AUFM.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-WO2SPDUE.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-JMR2X5FJ.js";
+import "./chunk-PMVOUPTY.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-MUDH7ZLR.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-VWZZF3YB.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-WLDBPKRL.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-R5LCP56X.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-YMKUXZIG.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-snapshot.ts
+import crypto from "crypto";
+import path from "path";
+import { execSync } from "child_process";
+
+// src/lib/session-snapshot.ts
+var FILE_RE = /(?:[\w@.-]+\/)+[\w@.-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|py|go|rs|sh|css|html|toml)/g;
+var BACKTICK_RE = /`([^`\n]{2,90})`/g;
+var DECISION_LINE_RE = /(?:^|\n)\s*(?:[-*]\s*)?(?:decision|decided|chose|choose|dropped|drop|keep|use|ship|migrate|move)\b[:\-]?\s*(.{12,180})/gi;
+var ENTITY_STOP_WORDS = /* @__PURE__ */ new Set([
+  "session",
+  "snapshot",
+  "period",
+  "memories",
+  "reviewed",
+  "tasks",
+  "patterns",
+  "found",
+  "behaviors",
+  "promoted",
+  "drift",
+  "score",
+  "healthy",
+  "warning",
+  "critical",
+  "current",
+  "state",
+  "historical",
+  "context",
+  "project",
+  "agent"
+]);
+function pushUnique(target, value, max) {
+  if (!value) return;
+  const trimmed = value.trim().replace(/[.,;:)]+$/g, "");
+  if (trimmed.length < 2 || trimmed.length > 180) return;
+  if (!target.some((v) => v.toLowerCase() === trimmed.toLowerCase())) {
+    target.push(trimmed);
+  }
+  if (target.length > max) target.length = max;
+}
+function collectText(result) {
+  const parts = [];
+  for (const mem of result.review.memories) {
+    parts.push(mem.text);
+  }
+  for (const task of result.review.tasks) {
+    parts.push(task.title);
+    if (task.result) parts.push(task.result);
+  }
+  for (const pattern of result.patterns) {
+    parts.push(pattern.description, ...pattern.evidence);
+  }
+  parts.push(result.drift.narrative);
+  return parts.join("\n");
+}
+function extractSnapshotFiles(result) {
+  const files = [];
+  const text = collectText(result);
+  for (const match of text.matchAll(FILE_RE)) {
+    pushUnique(files, match[0], 25);
+  }
+  return files;
+}
+function extractSnapshotDecisions(result) {
+  const decisions = [];
+  for (const mem of result.review.memories) {
+    const type = mem.memory_type.toLowerCase();
+    if (type.includes("decision") || type === "adr") {
+      pushUnique(decisions, mem.text.split("\n")[0], 12);
+    }
+  }
+  const text = collectText(result);
+  for (const match of text.matchAll(DECISION_LINE_RE)) {
+    pushUnique(decisions, match[1], 12);
+  }
+  return decisions;
+}
+function extractSnapshotEntities(result, projectName) {
+  const entities = [];
+  pushUnique(entities, projectName, 30);
+  for (const task of result.review.tasks) {
+    if (task.project_name) pushUnique(entities, task.project_name, 30);
+  }
+  for (const mem of result.review.memories) {
+    if (mem.project_name) pushUnique(entities, mem.project_name, 30);
+  }
+  const text = collectText(result);
+  for (const match of text.matchAll(BACKTICK_RE)) {
+    const term = match[1];
+    if (term && !term.includes("/") && !term.match(/\.(ts|js|json|md|sql)$/)) {
+      pushUnique(entities, term, 30);
+    }
+  }
+  for (const keyword of extractKeywords(text)) {
+    const normalized = keyword.toLowerCase();
+    const looksSpecific = keyword.includes("-") || keyword.includes("_") || /[A-Z]/.test(keyword.slice(1)) || /^[A-Z0-9_]{3,}$/.test(keyword);
+    if (looksSpecific && !keyword.includes("/") && !ENTITY_STOP_WORDS.has(normalized)) {
+      pushUnique(entities, keyword, 30);
+    }
+  }
+  return entities;
+}
+function buildSessionSnapshotMetadata(result, agentId, projectName, sessionId) {
+  return {
+    sessionId,
+    agentId,
+    projectName,
+    periodStart: result.review.period.start,
+    periodEnd: result.review.period.end,
+    keyEntities: extractSnapshotEntities(result, projectName),
+    files: extractSnapshotFiles(result),
+    decisions: extractSnapshotDecisions(result)
+  };
+}
+function formatSessionSnapshotText(result, promoted, metadata, patternBreakdown, driftLabel) {
+  const lines = [
+    `SESSION SNAPSHOT for ${metadata.agentId} (${metadata.projectName})`,
+    `Snapshot ID: ${metadata.sessionId}`,
+    `Date range: ${metadata.periodStart} -> ${metadata.periodEnd}`,
+    `Project: ${metadata.projectName}`,
+    `Agent: ${metadata.agentId}`,
+    `Memories reviewed: ${result.review.memories.length}`,
+    `Tasks reviewed: ${result.review.tasks.length}`,
+    `Patterns found: ${result.patterns.length} (${patternBreakdown})`,
+    `Behaviors promoted to p0: ${promoted.length}`,
+    `Drift score: ${result.drift.score.toFixed(2)} (${driftLabel})`,
+    result.drift.narrative,
+    metadata.keyEntities.length > 0 ? `Key entities: ${metadata.keyEntities.join(", ")}` : "",
+    metadata.files.length > 0 ? `Files changed: ${metadata.files.join(", ")}` : "",
+    metadata.decisions.length > 0 ? `Decisions:
+${metadata.decisions.map((d) => `- ${d}`).join("\n")}` : "",
+    result.patterns.length > 0 ? `
+Patterns:
+${result.patterns.map((p) => `- [${p.type}] ${p.description} (confidence: ${p.confidence.toFixed(2)})`).join("\n")}` : "",
+    promoted.length > 0 ? `
+Promoted behaviors:
+${promoted.map((p) => `- [p0/${p.domain}] ${p.text}`).join("\n")}` : ""
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function buildSessionSnapshotMemory(input) {
+  const metadata = buildSessionSnapshotMetadata(
+    input.result,
+    input.agentId,
+    input.projectName,
+    input.sessionId
+  );
+  const rawText = formatSessionSnapshotText(
+    input.result,
+    input.promoted,
+    metadata,
+    input.patternBreakdown,
+    input.driftLabel
+  );
+  const keywordText = keywordsToString(extractKeywords([
+    rawText,
+    metadata.sessionId,
+    metadata.periodStart,
+    metadata.periodEnd,
+    ...metadata.keyEntities,
+    ...metadata.files,
+    ...metadata.decisions
+  ].join("\n")));
+  return {
+    id: input.id,
+    agent_id: input.agentId,
+    agent_role: "system",
+    session_id: input.sessionId,
+    timestamp: input.timestamp,
+    tool_name: "exe-snapshot",
+    project_name: input.projectName,
+    has_error: false,
+    raw_text: rawText,
+    vector: null,
+    importance: 9,
+    memory_type: "session_snapshot",
+    tier: 1,
+    valid_from: metadata.periodStart,
+    source_type: "session_snapshot",
+    source_path: `session:${metadata.sessionId}`,
+    intent: "report",
+    outcome: "success",
+    domain: "operations",
+    referenced_entities: JSON.stringify(metadata.keyEntities),
+    file_paths: JSON.stringify(metadata.files),
+    keywords: keywordText
+  };
+}
+
+// src/bin/exe-snapshot.ts
+async function main(_args = []) {
+  const agentId = process.env.AGENT_ID || "default";
+  let projectName = process.env.EXE_PROJECT;
+  if (!projectName) {
+    try {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      projectName = path.basename(gitRoot);
+    } catch {
+      projectName = "unknown";
+    }
+  }
+  try {
+    await initStore();
+  } catch (err) {
+    console.error(
+      `Failed to initialize database. Is exe-os set up?
+Run: exe-os setup
+
+Error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+  try {
+    const engine = new DreamingEngine();
+    const result = await engine.runDreamCycle(agentId);
+    const promoted = [];
+    for (const proposal of result.proposals) {
+      if (proposal.source_pattern.confidence > 0.9) {
+        await storeBehavior({
+          agentId,
+          content: proposal.text,
+          domain: proposal.domain,
+          projectName,
+          priority: "p0"
+        });
+        promoted.push(proposal);
+      }
+    }
+    const patternBreakdown = buildPatternBreakdown(result);
+    const driftLabel = driftStatus(result.drift.score);
+    const snapshotSessionId = process.env.CLAUDE_SESSION_ID || process.env.SESSION_ID || "snapshot-cli";
+    await writeMemory(buildSessionSnapshotMemory({
+      id: crypto.randomUUID(),
+      agentId,
+      projectName,
+      sessionId: snapshotSessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      result,
+      promoted,
+      patternBreakdown,
+      driftLabel
+    }));
+    await flushBatch();
+    console.log(formatReport(result, promoted.length, patternBreakdown));
+  } finally {
+    await disposeStore();
+  }
+}
+function buildPatternBreakdown(result) {
+  if (result.patterns.length === 0) return "none";
+  const counts = {};
+  for (const p of result.patterns) {
+    counts[p.type] = (counts[p.type] || 0) + 1;
+  }
+  return Object.entries(counts).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`).join(", ");
+}
+function driftStatus(score) {
+  if (score > 0.8) return "critical";
+  if (score > 0.5) return "warning";
+  return "healthy";
+}
+function formatReport(result, promotedCount, patternBreakdown) {
+  const driftLabel = driftStatus(result.drift.score);
+  return [
+    "\u{1F4F8} Snapshot saved.",
+    `\u251C\u2500\u2500 Memories reviewed: ${result.review.memories.length}`,
+    `\u251C\u2500\u2500 Patterns found: ${result.patterns.length} (${patternBreakdown})`,
+    `\u251C\u2500\u2500 Behaviors promoted: ${promotedCount} \u2192 p0`,
+    `\u251C\u2500\u2500 Drift score: ${result.drift.score.toFixed(2)} (${driftLabel})`,
+    `\u251C\u2500\u2500 Summary committed to long-term memory`,
+    `\u2514\u2500\u2500 Tomorrow\u2019s session boots with full context.`
+  ].join("\n");
+}
+var isDirectRun = typeof process !== "undefined" && process.argv[1] && (process.argv[1].endsWith("exe-snapshot.js") || process.argv[1].endsWith("exe-snapshot.ts"));
+if (isDirectRun) {
+  main(process.argv.slice(2)).catch((err) => {
+    console.error(`Snapshot failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+}
+export {
+  formatReport,
+  main
+};