@askexenow/exe-os 0.9.279 → 0.9.280

package/dist/chunk-MZV4HV2T.js

@@ -0,0 +1,363 @@
+import {
+  PLATFORM_PROCEDURE_TITLES
+} from "./chunk-VUH67PT4.js";
+import {
+  getClient,
+  getIdentity,
+  listIdentities,
+  updateIdentity
+} from "./chunk-ZJP3ZONM.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/orchestration-package.ts
+import { randomUUID } from "crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import os from "os";
+import path from "path";
+var PACKAGE_VERSION = "1.0";
+var ROSTER_FILENAME = "exe-employees.json";
+var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
+var EXE_OS_DIRNAME = ".exe-os";
+var DEFAULT_BEHAVIOR_PRIORITY = "p1";
+var DEFAULT_PROCEDURE_PRIORITY = "p0";
+var DEFAULT_IDENTITY_UPDATED_BY = "orchestration-import";
+function ensureObject(value, label) {
+  if (value == null || Array.isArray(value) || typeof value !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureOptionalString(value, label) {
+  if (value == null) return void 0;
+  return ensureString(value, label);
+}
+function ensureNullableString(value, label) {
+  if (value == null) return null;
+  return ensureString(value, label);
+}
+function ensurePriority(value, label, fallback) {
+  if (value == null) return fallback;
+  if (value === "p0" || value === "p1" || value === "p2") {
+    return value;
+  }
+  throw new Error(`${label} must be one of: p0, p1, p2`);
+}
+function validateRosterEntry(value, index) {
+  const record = ensureObject(value, `roster[${index}]`);
+  return {
+    name: ensureString(record.name, `roster[${index}].name`),
+    role: ensureString(record.role, `roster[${index}].role`),
+    systemPrompt: ensureString(record.systemPrompt, `roster[${index}].systemPrompt`),
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    templateName: ensureOptionalString(record.templateName, `roster[${index}].templateName`),
+    templateVersion: typeof record.templateVersion === "number" ? record.templateVersion : void 0
+  };
+}
+function validateBehaviorEntry(value, index) {
+  const record = ensureObject(value, `behaviors[${index}]`);
+  return {
+    agent_id: ensureString(record.agent_id, `behaviors[${index}].agent_id`),
+    project_name: ensureNullableString(record.project_name, `behaviors[${index}].project_name`),
+    domain: ensureNullableString(record.domain, `behaviors[${index}].domain`),
+    content: ensureString(record.content, `behaviors[${index}].content`),
+    priority: ensurePriority(record.priority, `behaviors[${index}].priority`, DEFAULT_BEHAVIOR_PRIORITY)
+  };
+}
+function validateProcedureEntry(value, index) {
+  const record = ensureObject(value, `procedures[${index}]`);
+  return {
+    title: ensureString(record.title, `procedures[${index}].title`),
+    content: ensureString(record.content, `procedures[${index}].content`),
+    priority: ensurePriority(record.priority, `procedures[${index}].priority`, DEFAULT_PROCEDURE_PRIORITY),
+    domain: ensureNullableString(record.domain, `procedures[${index}].domain`)
+  };
+}
+function getRosterPath() {
+  return path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync(rosterPath)) return [];
+  const raw = readFileSync(rosterPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Roster file must contain a JSON array");
+  }
+  return parsed.map((entry, index) => validateRosterEntry(entry, index));
+}
+function writeRosterFile(roster) {
+  if (roster.length === 0) {
+    throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
+  }
+  const rosterPath = getRosterPath();
+  mkdirSync(path.dirname(rosterPath), { recursive: true });
+  if (existsSync(rosterPath)) {
+    const currentRoster = readRosterFile();
+    if (roster.length < currentRoster.length) {
+      throw new Error(
+        `Refusing to write roster with ${roster.length} entries \u2014 current roster has ${currentRoster.length}. Import would delete ${currentRoster.length - roster.length} employee(s). Use merge strategy instead, or add the missing entries to the package.`
+      );
+    }
+    copyFileSync(rosterPath, getBackupPath());
+  }
+  atomicWriteJsonSync(rosterPath, roster);
+}
+function buildImportedRosterEntries(roster, timestamp) {
+  return roster.map((entry) => ({
+    name: entry.name,
+    role: entry.role,
+    systemPrompt: entry.systemPrompt,
+    createdAt: timestamp,
+    ...entry.templateName != null ? { templateName: entry.templateName } : {},
+    ...entry.templateVersion != null ? { templateVersion: entry.templateVersion } : {}
+  }));
+}
+async function insertBehaviors(behaviors, timestamp) {
+  const client = getClient();
+  for (const behavior of behaviors) {
+    await client.execute({
+      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        behavior.agent_id,
+        behavior.project_name,
+        behavior.domain,
+        behavior.priority,
+        behavior.content,
+        timestamp,
+        timestamp
+      ]
+    });
+  }
+  return behaviors.length;
+}
+async function insertProcedures(procedures, timestamp, options) {
+  const client = getClient();
+  const skipTitles = options?.skipTitles ?? /* @__PURE__ */ new Set();
+  let inserted = 0;
+  for (const procedure of procedures) {
+    if (skipTitles.has(procedure.title) || PLATFORM_PROCEDURE_TITLES.has(procedure.title)) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO company_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        procedure.title,
+        procedure.content,
+        procedure.priority,
+        procedure.domain,
+        timestamp,
+        timestamp
+      ]
+    });
+    skipTitles.add(procedure.title);
+    inserted += 1;
+  }
+  return inserted;
+}
+async function replaceBehaviorsAndProcedures(behaviors, procedures, timestamp) {
+  const client = getClient();
+  const existingBehaviors = await client.execute({
+    sql: "SELECT agent_id, content FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const existingBehaviorKeys = new Set(
+    existingBehaviors.rows.map((row) => `${String(row.agent_id)}::${String(row.content)}`)
+  );
+  const newBehaviors = behaviors.filter(
+    (b) => !existingBehaviorKeys.has(`${b.agent_id}::${b.content}`)
+  );
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  return {
+    behaviors: await insertBehaviors(newBehaviors, timestamp),
+    procedures: await insertProcedures(procedures, timestamp, { skipTitles: existingProcedureTitles })
+  };
+}
+async function mergeRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const existingNames = new Set(currentRoster.map((entry) => entry.name.toLowerCase()));
+  const additions = buildImportedRosterEntries(
+    importedRoster.filter((entry) => !existingNames.has(entry.name.toLowerCase())),
+    timestamp
+  );
+  if (additions.length > 0) {
+    writeRosterFile([...currentRoster, ...additions]);
+  }
+  return additions.length;
+}
+async function replaceRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const importedByName = new Map(
+    buildImportedRosterEntries(importedRoster, timestamp).map((entry) => [entry.name.toLowerCase(), entry])
+  );
+  const merged = currentRoster.map((existing) => {
+    const imported = importedByName.get(existing.name.toLowerCase());
+    if (imported) {
+      importedByName.delete(existing.name.toLowerCase());
+      return imported;
+    }
+    return existing;
+  });
+  for (const newEntry of importedByName.values()) {
+    merged.push(newEntry);
+  }
+  writeRosterFile(merged);
+  return importedRoster.length;
+}
+async function importIdentities(identities, updatedBy) {
+  const entries = Object.entries(identities);
+  let imported = 0;
+  for (const [agentId, content] of entries) {
+    const existing = getIdentity(agentId);
+    if (existing?.raw) {
+      continue;
+    }
+    await updateIdentity(agentId, content, updatedBy);
+    imported += 1;
+  }
+  return imported;
+}
+async function getActiveProcedureTitles() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT title FROM company_procedures WHERE active = 1",
+    args: []
+  });
+  return new Set(result.rows.map((row) => String(row.title)));
+}
+async function exportOrchestration(createdBy) {
+  const client = getClient();
+  const roster = readRosterFile().map((entry) => ({
+    ...entry,
+    createdAt: ""
+  }));
+  const identities = {};
+  for (const identitySummary of listIdentities()) {
+    const identity = getIdentity(identitySummary.agentId);
+    if (identity?.raw) {
+      identities[identitySummary.agentId] = identity.raw;
+    }
+  }
+  const behaviorResult = await client.execute({
+    sql: "SELECT agent_id, project_name, domain, content, priority FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const procedureResult = await client.execute({
+    sql: "SELECT title, content, priority, domain FROM company_procedures WHERE active = 1",
+    args: []
+  });
+  const behaviors = behaviorResult.rows.map((row) => ({
+    agent_id: String(row.agent_id),
+    project_name: row.project_name == null ? null : String(row.project_name),
+    domain: row.domain == null ? null : String(row.domain),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "behaviors.priority", DEFAULT_BEHAVIOR_PRIORITY)
+  }));
+  const procedures = procedureResult.rows.map((row) => ({
+    title: String(row.title),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "procedures.priority", DEFAULT_PROCEDURE_PRIORITY),
+    domain: row.domain == null ? null : String(row.domain)
+  })).filter((procedure) => !PLATFORM_PROCEDURE_TITLES.has(procedure.title));
+  return {
+    version: PACKAGE_VERSION,
+    created_by: createdBy,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    roster,
+    identities,
+    behaviors,
+    procedures
+  };
+}
+async function importOrchestration(pkg, strategy) {
+  const validated = validatePackage(pkg);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedBy = validated.created_by || DEFAULT_IDENTITY_UPDATED_BY;
+  const rosterCount = strategy === "replace" ? await replaceRosterEntries(validated.roster, timestamp) : await mergeRosterEntries(validated.roster, timestamp);
+  const identityCount = await importIdentities(validated.identities, updatedBy);
+  if (strategy === "replace") {
+    const replaced = await replaceBehaviorsAndProcedures(
+      validated.behaviors,
+      validated.procedures,
+      timestamp
+    );
+    return {
+      imported: {
+        roster: rosterCount,
+        identities: identityCount,
+        behaviors: replaced.behaviors,
+        procedures: replaced.procedures
+      }
+    };
+  }
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  const behaviorCount = await insertBehaviors(validated.behaviors, timestamp);
+  const procedureCount = await insertProcedures(
+    validated.procedures,
+    timestamp,
+    { skipTitles: existingProcedureTitles }
+  );
+  return {
+    imported: {
+      roster: rosterCount,
+      identities: identityCount,
+      behaviors: behaviorCount,
+      procedures: procedureCount
+    }
+  };
+}
+function validatePackage(data) {
+  const record = ensureObject(data, "package");
+  const version = ensureString(record.version, "version");
+  if (version !== PACKAGE_VERSION) {
+    throw new Error(`Unsupported orchestration package version: ${version}`);
+  }
+  if (!Array.isArray(record.roster)) {
+    throw new Error("roster is required and must be an array");
+  }
+  if (record.identities == null || Array.isArray(record.identities) || typeof record.identities !== "object") {
+    throw new Error("identities is required and must be an object");
+  }
+  if (!Array.isArray(record.behaviors)) {
+    throw new Error("behaviors is required and must be an array");
+  }
+  if (!Array.isArray(record.procedures)) {
+    throw new Error("procedures is required and must be an array");
+  }
+  const identities = Object.entries(record.identities).reduce(
+    (acc, [agentId, content]) => {
+      acc[agentId] = ensureString(content, `identities.${agentId}`);
+      return acc;
+    },
+    {}
+  );
+  return {
+    version: PACKAGE_VERSION,
+    created_by: ensureString(record.created_by, "created_by"),
+    created_at: ensureString(record.created_at, "created_at"),
+    roster: record.roster.map((entry, index) => validateRosterEntry(entry, index)),
+    identities,
+    behaviors: record.behaviors.map((entry, index) => validateBehaviorEntry(entry, index)),
+    procedures: record.procedures.map((entry, index) => validateProcedureEntry(entry, index))
+  };
+}
+
+export {
+  exportOrchestration,
+  importOrchestration,
+  validatePackage
+};

package/dist/chunk-N663LPHD.js

@@ -0,0 +1,97 @@
+import {
+  listBehaviors
+} from "./chunk-74YEBPGM.js";
+import {
+  loadConfigSync
+} from "./chunk-T3B5RK4H.js";
+
+// src/lib/behaviors-export.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+var BEHAVIORS_EXPORT_DIR = path.join(
+  os.homedir(),
+  ".exe-os",
+  "behaviors-export"
+);
+var STALE_EXPORT_AGE_MS = 60 * 60 * 1e3;
+var DEFAULT_BEHAVIOR_LIMIT = 30;
+function getBehaviorLimit() {
+  try {
+    const cfg = loadConfigSync();
+    return cfg.behaviorExportLimit ?? DEFAULT_BEHAVIOR_LIMIT;
+  } catch {
+    return DEFAULT_BEHAVIOR_LIMIT;
+  }
+}
+function sweepStaleBehaviorExports(now = Date.now()) {
+  if (!existsSync(BEHAVIORS_EXPORT_DIR)) return;
+  let entries;
+  try {
+    entries = readdirSync(BEHAVIORS_EXPORT_DIR);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const filePath = path.join(BEHAVIORS_EXPORT_DIR, entry);
+    try {
+      const stat = statSync(filePath);
+      if (now - stat.mtimeMs > STALE_EXPORT_AGE_MS) {
+        unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+}
+function renderBehaviorLine(row) {
+  const tag = row.domain ? `[${row.domain}] ` : "";
+  const scope = row.project_name ? ` (${row.project_name})` : "";
+  return `- ${tag}${row.content}${scope}`;
+}
+function renderBehaviorExport(behaviors) {
+  if (behaviors.length === 0) {
+    return "";
+  }
+  const lines = behaviors.map(renderBehaviorLine);
+  return [
+    "<system-reminder>",
+    "## Your Behavioral Memory",
+    "Validated patterns and corrections for this session. Follow them.",
+    "Sourced from exe-os Layer 2 (Expertise). Changes apply on next spawn.",
+    "",
+    ...lines,
+    "</system-reminder>",
+    ""
+  ].join("\n");
+}
+function exportFilePath(agentId, projectName, sessionKey) {
+  if (!sessionKey) {
+    return path.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
+  }
+  const safeProject = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path.join(
+    BEHAVIORS_EXPORT_DIR,
+    `${agentId}-${safeProject}-${sessionKey}.md`
+  );
+}
+async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
+  mkdirSync(BEHAVIORS_EXPORT_DIR, { recursive: true });
+  sweepStaleBehaviorExports();
+  const behaviors = await listBehaviors(agentId, projectName, getBehaviorLimit());
+  if (behaviors.length === 0) return null;
+  const body = renderBehaviorExport(behaviors);
+  const target = exportFilePath(agentId, projectName, sessionKey);
+  writeFileSync(target, body, "utf-8");
+  return target;
+}
+
+export {
+  exportBehaviorsForAgent
+};

package/dist/chunk-NDG4GHYH.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-U76CXW3D.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};