@askexenow/exe-os 0.9.61 → 0.9.63

package/dist/bin/cli.js

@@ -258,8 +258,8 @@ var init_config = __esm({
         rerankerAutoTrigger: {
           enabled: true,
           broadQueryMinCardinality: 5e4,
-          fetchTopK: 150,
-          returnTopK: 5
+          fetchTopK: 200,
+          returnTopK: 20
         }
       },
       graphRagEnabled: true,
@@ -820,7 +820,7 @@ function isLegacySplitPostToolCommand(command) {
 function textHasLegacySplitPostToolHook(text) {
   return [EXE_HOOK_FILES.ingest, EXE_HOOK_FILES.errorRecall, EXE_HOOK_FILES.ingestWorker].some((file) => text.includes(file));
 }
-var EXE_HOOK_FILES, EXE_HOOKS, LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS;
+var EXE_HOOK_FILES, EXE_HOOKS, EXE_HOOK_MANIFEST, LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS;
 var init_runtime_hook_manifest = __esm({
   "src/adapters/runtime-hook-manifest.ts"() {
     "use strict";
@@ -844,6 +844,116 @@ var init_runtime_hook_manifest = __esm({
       notification: "dist/hooks/notification.js",
       instructionsLoaded: "dist/hooks/instructions-loaded.js"
     };
+    EXE_HOOK_MANIFEST = [
+      {
+        key: "postToolCombined",
+        event: "PostToolUse",
+        commandMarker: EXE_HOOKS.postToolCombined,
+        owner: "exe-os",
+        purpose: "Single PostToolUse entrypoint for ingestion, error recall, summaries, and bug detection.",
+        runtimes: ["claude", "codex", "opencode"],
+        checkpointRole: "none"
+      },
+      {
+        key: "sessionStart",
+        event: "SessionStart",
+        commandMarker: EXE_HOOKS.sessionStart,
+        owner: "exe-os",
+        purpose: "Loads agent identity, procedures, and boot context.",
+        runtimes: ["claude", "codex", "opencode"],
+        checkpointRole: "none"
+      },
+      {
+        key: "promptSubmit",
+        event: "UserPromptSubmit",
+        commandMarker: EXE_HOOKS.promptSubmit,
+        owner: "exe-os",
+        purpose: "Injects current tasks, pending reviews, and local context before each prompt.",
+        runtimes: ["claude", "codex", "opencode"],
+        checkpointRole: "none"
+      },
+      {
+        key: "heartbeat",
+        event: "UserPromptSubmit",
+        commandMarker: EXE_HOOKS.heartbeat,
+        owner: "exe-os",
+        purpose: "Lightweight heartbeat/status sidecar for Claude Code sessions.",
+        runtimes: ["claude"],
+        checkpointRole: "none"
+      },
+      {
+        key: "stop",
+        event: "Stop",
+        commandMarker: EXE_HOOKS.stop,
+        owner: "exe-os",
+        purpose: "Finalizes task state, capacity signals, and emergency checkpointing.",
+        runtimes: ["claude", "codex", "opencode"],
+        checkpointRole: "capacity_checkpoint"
+      },
+      {
+        key: "preToolUse",
+        event: "PreToolUse",
+        commandMarker: EXE_HOOKS.preToolUse,
+        owner: "exe-os",
+        purpose: "Preflight guardrails before shell/tool execution.",
+        runtimes: ["claude", "codex", "opencode"],
+        checkpointRole: "none"
+      },
+      {
+        key: "subagentStop",
+        event: "SubagentStop",
+        commandMarker: EXE_HOOKS.subagentStop,
+        owner: "exe-os",
+        purpose: "Captures subagent completion context.",
+        runtimes: ["claude"],
+        checkpointRole: "none"
+      },
+      {
+        key: "preCompact",
+        event: "PreCompact",
+        commandMarker: EXE_HOOKS.preCompact,
+        owner: "exe-os",
+        purpose: "Writes active-task snapshot and compaction recovery context.",
+        runtimes: ["claude"],
+        checkpointRole: "recovery_context"
+      },
+      {
+        key: "postCompact",
+        event: "PostCompact",
+        commandMarker: EXE_HOOKS.postCompact,
+        owner: "exe-os",
+        purpose: "Rehydrates recovery context after compaction.",
+        runtimes: ["claude"],
+        checkpointRole: "recovery_context"
+      },
+      {
+        key: "sessionEnd",
+        event: "SessionEnd",
+        commandMarker: EXE_HOOKS.sessionEnd,
+        owner: "exe-os",
+        purpose: "Stores session-end checkpoint and triages orphaned in-progress tasks.",
+        runtimes: ["claude"],
+        checkpointRole: "session_summary"
+      },
+      {
+        key: "notification",
+        event: "Notification",
+        commandMarker: EXE_HOOKS.notification,
+        owner: "exe-os",
+        purpose: "Captures runtime notifications and nudges.",
+        runtimes: ["claude"],
+        checkpointRole: "none"
+      },
+      {
+        key: "instructionsLoaded",
+        event: "InstructionsLoaded",
+        commandMarker: EXE_HOOKS.instructionsLoaded,
+        owner: "exe-os",
+        purpose: "Applies runtime instruction post-processing.",
+        runtimes: ["claude"],
+        checkpointRole: "none"
+      }
+    ];
     LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS = [
       "dist/hooks/ingest.js",
       "dist/hooks/error-recall.js",
@@ -4561,6 +4671,51 @@ async function ensureSchema() {
       VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
     END;
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memory_cards (
+      id            TEXT PRIMARY KEY,
+      memory_id     TEXT NOT NULL,
+      agent_id      TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      project_name  TEXT,
+      timestamp     TEXT NOT NULL,
+      card_type     TEXT NOT NULL,
+      subject       TEXT,
+      predicate     TEXT,
+      object        TEXT,
+      content       TEXT NOT NULL,
+      source_ref    TEXT,
+      confidence    REAL DEFAULT 0.6,
+      active        INTEGER DEFAULT 1,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_agent
+      ON memory_cards(agent_id, active, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_memory
+      ON memory_cards(memory_id);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_cards_fts
+      USING fts5(content, subject, predicate, object, content='memory_cards', content_rowid='rowid');
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ai AFTER INSERT ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ad AFTER DELETE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_au AFTER UPDATE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+  `);
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
@@ -7941,6 +8096,164 @@ ${p.content}`).join("\n\n");
   }
 });
 
+// src/lib/memory-cards.ts
+var memory_cards_exports = {};
+__export(memory_cards_exports, {
+  extractMemoryCards: () => extractMemoryCards,
+  insertMemoryCardsForBatch: () => insertMemoryCardsForBatch,
+  searchMemoryCards: () => searchMemoryCards
+});
+import { createHash as createHash3 } from "crypto";
+function stableId(memoryId, type, content) {
+  return createHash3("sha256").update(`${memoryId}:${type}:${content}`).digest("hex").slice(0, 32);
+}
+function cleanText(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function splitSentences(text) {
+  return cleanText(text).split(/(?<=[.!?])\s+|\n+/).map((s) => s.trim()).filter((s) => s.length >= 24 && s.length <= MAX_SENTENCE_CHARS);
+}
+function inferCardType(sentence, toolName) {
+  const lower = sentence.toLowerCase();
+  if (toolName === "store_decision" || /\b(decided|decision|adr|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(prefers|preference|likes|dislikes|wants|doesn't want|does not want)\b/.test(lower)) return "preference";
+  if (/\b(changed|updated|replaced|now|no longer|instead|supersedes)\b/.test(lower)) return "belief_update";
+  if (toolName && ["Read", "Write", "Edit", "Bash"].includes(toolName)) return "code";
+  if (/\b(meeting|deadline|shipped|launched|completed|failed|blocked|assigned|created)\b/.test(lower)) return "event";
+  return "fact";
+}
+function extractSubject(sentence, agentId) {
+  const explicit = sentence.match(/\b([A-Z][a-zA-Z0-9_-]{2,}(?:\s+[A-Z][a-zA-Z0-9_-]{2,})?)\b/);
+  return explicit?.[1] ?? agentId;
+}
+function predicateFor(type) {
+  switch (type) {
+    case "preference":
+      return "prefers";
+    case "belief_update":
+      return "updated";
+    case "decision":
+      return "decided";
+    case "event":
+      return "happened";
+    case "code":
+      return "implemented";
+    default:
+      return "states";
+  }
+}
+function extractMemoryCards(row) {
+  const sentences = splitSentences(row.raw_text);
+  const cards = [];
+  for (const sentence of sentences) {
+    const type = inferCardType(sentence, row.tool_name);
+    const subject = extractSubject(sentence, row.agent_id);
+    const content = sentence.length > MAX_SENTENCE_CHARS ? `${sentence.slice(0, MAX_SENTENCE_CHARS - 1)}\u2026` : sentence;
+    cards.push({
+      id: stableId(row.id, type, content),
+      memory_id: row.id,
+      agent_id: row.agent_id,
+      session_id: row.session_id,
+      project_name: row.project_name ?? null,
+      timestamp: row.timestamp,
+      card_type: type,
+      subject,
+      predicate: predicateFor(type),
+      object: content,
+      content,
+      source_ref: row.id,
+      confidence: type === "fact" ? 0.55 : 0.65
+    });
+    if (cards.length >= MAX_CARDS_PER_MEMORY) break;
+  }
+  return cards;
+}
+async function insertMemoryCardsForBatch(rows) {
+  const cards = rows.flatMap(extractMemoryCards);
+  if (cards.length === 0) return 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const stmts = cards.map((card) => ({
+    sql: `INSERT OR IGNORE INTO memory_cards
+          (id, memory_id, agent_id, session_id, project_name, timestamp, card_type,
+           subject, predicate, object, content, source_ref, confidence, active, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    args: [
+      card.id,
+      card.memory_id,
+      card.agent_id,
+      card.session_id,
+      card.project_name,
+      card.timestamp,
+      card.card_type,
+      card.subject,
+      card.predicate,
+      card.object,
+      card.content,
+      card.source_ref,
+      card.confidence,
+      now
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return cards.length;
+}
+function buildMatchExpr(queryText) {
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3).slice(0, 12);
+  if (terms.length === 0) return null;
+  return terms.map((t) => `${t}*`).join(terms.length >= 3 ? " AND " : " OR ");
+}
+async function searchMemoryCards(queryText, agentId, options) {
+  const limit = options?.limit ?? 10;
+  const matchExpr = buildMatchExpr(queryText);
+  if (!matchExpr) return [];
+  let sql = `SELECT c.id, c.memory_id, c.agent_id, c.session_id, c.project_name,
+                    c.timestamp, c.card_type, c.content, c.source_ref, c.confidence
+             FROM memory_cards c
+             JOIN memory_cards_fts fts ON c.rowid = fts.rowid
+             WHERE memory_cards_fts MATCH ?
+               AND c.agent_id = ?
+               AND COALESCE(c.active, 1) = 1`;
+  const args2 = [matchExpr, agentId];
+  if (options?.projectName) {
+    sql += ` AND c.project_name = ?`;
+    args2.push(options.projectName);
+  }
+  if (options?.since) {
+    sql += ` AND c.timestamp >= ?`;
+    args2.push(options.since);
+  }
+  sql += ` ORDER BY rank LIMIT ?`;
+  args2.push(limit);
+  const result = await getClient().execute({ sql, args: args2 });
+  return result.rows.map((row) => ({
+    id: `card:${String(row.id)}`,
+    agent_id: String(row.agent_id),
+    agent_role: "memory_card",
+    session_id: String(row.session_id),
+    timestamp: String(row.timestamp),
+    tool_name: `memory_card:${String(row.card_type)}`,
+    project_name: row.project_name == null ? "" : String(row.project_name),
+    has_error: false,
+    raw_text: `[${String(row.card_type)}] ${String(row.content)}
+Source memory: ${String(row.source_ref ?? row.memory_id)}`,
+    vector: [],
+    importance: 6,
+    status: "active",
+    confidence: Number(row.confidence ?? 0.6),
+    last_accessed: String(row.timestamp)
+  }));
+}
+var MAX_CARDS_PER_MEMORY, MAX_SENTENCE_CHARS;
+var init_memory_cards = __esm({
+  "src/lib/memory-cards.ts"() {
+    "use strict";
+    init_database();
+    MAX_CARDS_PER_MEMORY = 6;
+    MAX_SENTENCE_CHARS = 360;
+  }
+});
+
 // src/lib/store.ts
 var store_exports = {};
 __export(store_exports, {
@@ -8279,6 +8592,11 @@ async function flushBatch() {
     const globalClient = getClient();
     const globalStmts = batch.map(buildStmt);
     await globalClient.batch(globalStmts, "write");
+    try {
+      const { insertMemoryCardsForBatch: insertMemoryCardsForBatch2 } = await Promise.resolve().then(() => (init_memory_cards(), memory_cards_exports));
+      await insertMemoryCardsForBatch2(batch);
+    } catch {
+    }
     schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
@@ -9537,7 +9855,7 @@ __export(identity_exports, {
 import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
 import { readdirSync as readdirSync4 } from "fs";
 import path17 from "path";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function ensureDir() {
   if (!existsSync16(IDENTITY_DIR2)) {
     mkdirSync9(IDENTITY_DIR2, { recursive: true });
@@ -9584,7 +9902,7 @@ function parseFrontmatter(raw) {
   };
 }
 function contentHash(content) {
-  return createHash3("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(content).digest("hex").slice(0, 16);
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
@@ -15004,7 +15322,7 @@ var init_exe_rename = __esm({
 // src/lib/model-downloader.ts
 import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync26, unlinkSync as unlinkSync12, renameSync as renameSync6 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import path32 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
@@ -15032,7 +15350,7 @@ async function downloadModel(opts) {
         throw new Error(`Download failed: HTTP ${response.status}`);
       }
       const contentLength = Number(response.headers.get("content-length") ?? EXPECTED_SIZE);
-      const hash = createHash4("sha256");
+      const hash = createHash5("sha256");
       const fileStream = createWriteStream(tmpPath);
       const reader = response.body.getReader();
       try {
@@ -15076,7 +15394,7 @@ Download attempt ${attempt} failed, retrying...
 }
 async function fileHash(filePath) {
   return new Promise((resolve, reject) => {
-    const hash = createHash4("sha256");
+    const hash = createHash5("sha256");
     const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -16898,12 +17216,64 @@ var init_update = __esm({
 
 // src/lib/stack-update.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync25, renameSync as renameSync7, writeFileSync as writeFileSync20 } from "fs";
+import { createVerify, verify as verifySignature } from "crypto";
+import { existsSync as existsSync30, mkdirSync as mkdirSync19, readdirSync as readdirSync10, readFileSync as readFileSync25, renameSync as renameSync7, writeFileSync as writeFileSync20 } from "fs";
 import http from "http";
 import https from "https";
 import path37 from "path";
-function parseStackManifest(raw) {
-  const parsed = JSON.parse(raw);
+function isSignedEnvelope(value) {
+  return !!value && typeof value === "object" && "manifest" in value && "signature" in value;
+}
+function canonicalizeStackManifest(manifest) {
+  const clone = JSON.parse(JSON.stringify(manifest));
+  delete clone.signature;
+  return stableJson(clone);
+}
+function verifyStackManifestSignature(manifest, publicKeyPem) {
+  const signature = manifest.signature;
+  if (!signature) throw new Error("Stack manifest signature required but missing");
+  const payload = Buffer.from(canonicalizeStackManifest(manifest));
+  const sig = Buffer.from(signature.signature, "base64");
+  let ok = false;
+  if (signature.alg === "ed25519") {
+    ok = verifySignature(null, payload, publicKeyPem, sig);
+  } else if (signature.alg === "rsa-sha256") {
+    const verifier = createVerify("RSA-SHA256");
+    verifier.update(payload);
+    verifier.end();
+    ok = verifier.verify(publicKeyPem, sig);
+  } else {
+    throw new Error(`Unsupported stack manifest signature alg: ${signature.alg}`);
+  }
+  if (!ok) throw new Error("Stack manifest signature verification failed");
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableJson(obj[key])}`).join(",")}}`;
+}
+function findLatestBackupEnvFile(envFile) {
+  const backupDir = path37.join(path37.dirname(envFile), ".exe-stack-backups");
+  if (!existsSync30(backupDir)) return null;
+  const backups = readdirSync10(backupDir).filter((name) => name.startsWith("env-") && name.endsWith(".bak")).sort();
+  const latest = backups.at(-1);
+  return latest ? path37.join(backupDir, latest) : null;
+}
+async function rollbackStackUpdate(options) {
+  const exec2 = options.exec ?? defaultExec;
+  const backupEnvFile = options.lockFile && existsSync30(options.lockFile) ? JSON.parse(readFileSync25(options.lockFile, "utf8")).backupEnvFile : void 0;
+  const rollbackEnv = backupEnvFile && existsSync30(backupEnvFile) ? backupEnvFile : findLatestBackupEnvFile(options.envFile);
+  if (!rollbackEnv) throw new Error(`No stack backup env found beside ${options.envFile}`);
+  writeFileSync20(options.envFile, readFileSync25(rollbackEnv), { mode: 384 });
+  const composeArgs = ["compose", "--file", options.composeFile, "--env-file", options.envFile];
+  exec2("docker", [...composeArgs, "up", "-d"]);
+  return { status: "rolled_back", targetVersion: "previous", changes: [], backupEnvFile: rollbackEnv, lockFile: options.lockFile ?? path37.join(path37.dirname(options.envFile), ".exe-stack-lock.json") };
+}
+function parseStackManifest(raw, publicKey) {
+  const parsedRaw = JSON.parse(raw);
+  const parsed = isSignedEnvelope(parsedRaw) ? { ...parsedRaw.manifest, signature: parsedRaw.signature } : parsedRaw;
+  if (publicKey) verifyStackManifestSignature(parsed, publicKey);
   if (parsed.schemaVersion !== 1) throw new Error("Unsupported stack manifest schemaVersion");
   if (!parsed.latest || !parsed.stacks || typeof parsed.stacks !== "object") {
     throw new Error("Invalid stack manifest: latest and stacks are required");
@@ -16921,9 +17291,13 @@ function parseStackManifest(raw) {
   }
   return parsed;
 }
-async function loadStackManifest(ref, fetchText = defaultFetchText) {
-  if (/^https?:\/\//.test(ref)) return parseStackManifest(await fetchText(ref));
-  return parseStackManifest(readFileSync25(ref, "utf8"));
+async function loadStackManifest(ref, fetchText = defaultFetchText, publicKey, authToken) {
+  if (/^https?:\/\//.test(ref)) return parseStackManifest(await fetchTextWithAuth(ref, fetchText, authToken), publicKey);
+  return parseStackManifest(readFileSync25(ref, "utf8"), publicKey);
+}
+async function fetchTextWithAuth(ref, fetchText, authToken) {
+  if (!authToken || fetchText !== defaultFetchText) return fetchText(ref);
+  return defaultFetchText(ref, authToken);
 }
 function parseEnv(raw) {
   const env = /* @__PURE__ */ new Map();
@@ -16989,14 +17363,17 @@ Re-run with --allow-breaking ${missing.map((c) => c.id).join(",")}`
 async function runStackUpdate(options) {
   const exec2 = options.exec ?? defaultExec;
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const manifest = await loadStackManifest(options.manifestRef, options.fetchText);
+  if (options.rollback) return rollbackStackUpdate(options);
+  const manifest = await loadStackManifest(options.manifestRef, options.fetchText, options.manifestPublicKey, options.manifestAuthToken);
   const envRaw = readFileSync25(options.envFile, "utf8");
   const plan = createStackUpdatePlan(manifest, envRaw, options.targetVersion);
   assertBreakingChangesAllowed(plan, options.allowedBreakingChangeIds ?? []);
   const lockFile = options.lockFile ?? path37.join(path37.dirname(options.envFile), ".exe-stack-lock.json");
+  const previousVersion = readCurrentStackVersion(lockFile);
   if (options.dryRun || plan.changes.length === 0) {
     return { status: "planned", targetVersion: plan.targetVersion, changes: plan.changes, lockFile };
   }
+  await postDeployAudit(options, "started", plan.targetVersion, previousVersion);
   const backupDir = path37.join(path37.dirname(options.envFile), ".exe-stack-backups");
   mkdirSync19(backupDir, { recursive: true });
   const stamp = now().toISOString().replace(/[:.]/g, "-");
@@ -17012,7 +17389,8 @@ async function runStackUpdate(options) {
     exec2("docker", [...composeArgs, "pull"]);
     exec2("docker", [...composeArgs, "up", "-d"]);
     await verifyReleaseHealth(plan.release, options.healthRetries ?? 12, options.healthDelayMs ?? 5e3);
-    writeFileSync20(lockFile, JSON.stringify({ stackVersion: plan.targetVersion, updatedAt: now().toISOString(), services: plan.release.services }, null, 2) + "\n");
+    writeFileSync20(lockFile, JSON.stringify({ stackVersion: plan.targetVersion, updatedAt: now().toISOString(), backupEnvFile, services: plan.release.services }, null, 2) + "\n");
+    await postDeployAudit(options, "success", plan.targetVersion, previousVersion, void 0, { changes: plan.changes.length });
     return { status: "updated", targetVersion: plan.targetVersion, changes: plan.changes, backupEnvFile, lockFile };
   } catch (err) {
     writeFileSync20(options.envFile, envRaw, { mode: 384 });
@@ -17021,9 +17399,37 @@ async function runStackUpdate(options) {
     } catch {
     }
     const reason = err instanceof Error ? err.message : String(err);
+    await postDeployAudit(options, "failed", plan.targetVersion, previousVersion, reason, { rollbackAttempted: true });
     throw new Error(`Stack update failed and rollback was attempted: ${reason}`);
   }
 }
+function readCurrentStackVersion(lockFile) {
+  if (!existsSync30(lockFile)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync25(lockFile, "utf8"));
+    return parsed.stackVersion;
+  } catch {
+    return void 0;
+  }
+}
+async function postDeployAudit(options, status, stackVersion, previousVersion, error, metadata) {
+  if (!options.auditUrl) return;
+  const postJson = options.postJson ?? defaultPostJson;
+  try {
+    await postJson(options.auditUrl, {
+      stackVersion,
+      previousVersion,
+      status,
+      error,
+      metadata,
+      deviceId: options.deviceId,
+      licenseKey: options.licenseKey
+    }, options.manifestAuthToken);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(`[stack-update] deploy audit failed: ${reason}`);
+  }
+}
 async function verifyReleaseHealth(release, retries, delayMs) {
   for (const [serviceName, service] of Object.entries(release.services)) {
     if (!service.healthUrl) continue;
@@ -17060,20 +17466,43 @@ function httpStatus(urlString) {
 function defaultExec(cmd, args2, opts) {
   execFileSync3(cmd, args2, { stdio: "inherit", cwd: opts?.cwd });
 }
-async function defaultFetchText(ref) {
-  const res = await fetch(ref);
+async function defaultFetchText(ref, authToken) {
+  const res = await fetch(ref, {
+    headers: authToken ? { authorization: `Bearer ${authToken}` } : void 0
+  });
   if (!res.ok) throw new Error(`Failed to fetch ${ref}: HTTP ${res.status}`);
   return res.text();
 }
+async function defaultPostJson(url, body, authToken) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...authToken ? { authorization: `Bearer ${authToken}` } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`Failed to POST ${url}: HTTP ${res.status}`);
+}
 function defaultStackPaths() {
   const cwdCompose = path37.resolve("docker-compose.yml");
   const cwdEnv = path37.resolve(".env");
   return {
     composeFile: process.env.EXE_STACK_COMPOSE_FILE || (existsSync30(cwdCompose) ? cwdCompose : "/opt/exe-stack/docker-compose.yml"),
     envFile: process.env.EXE_STACK_ENV_FILE || (existsSync30(cwdEnv) ? cwdEnv : "/opt/exe-stack/.env"),
-    manifestRef: process.env.EXE_STACK_MANIFEST || "https://updates.askexe.com/stack-manifest.json"
+    manifestRef: process.env.EXE_STACK_MANIFEST || "https://update.askexe.com/stack-manifest.json",
+    auditUrl: process.env.EXE_STACK_AUDIT_URL || "https://update.askexe.com/v1/deploy-audits",
+    manifestAuthToken: process.env.EXE_STACK_UPDATE_TOKEN,
+    manifestPublicKey: loadDefaultPublicKey()
   };
 }
+function loadDefaultPublicKey() {
+  if (process.env.EXE_STACK_PUBLIC_KEY) return process.env.EXE_STACK_PUBLIC_KEY;
+  if (process.env.EXE_STACK_PUBLIC_KEY_FILE && existsSync30(process.env.EXE_STACK_PUBLIC_KEY_FILE)) {
+    return readFileSync25(process.env.EXE_STACK_PUBLIC_KEY_FILE, "utf8");
+  }
+  return void 0;
+}
 var init_stack_update = __esm({
   "src/lib/stack-update.ts"() {
     "use strict";
@@ -17092,8 +17521,14 @@ function parseArgs4(args2) {
     manifestRef: defaults.manifestRef,
     composeFile: defaults.composeFile,
     envFile: defaults.envFile,
+    auditUrl: defaults.auditUrl,
+    manifestAuthToken: defaults.manifestAuthToken,
+    manifestPublicKey: defaults.manifestPublicKey,
+    deviceId: process.env.EXE_DEVICE_ID,
+    licenseKey: process.env.EXE_LICENSE_KEY,
     dryRun: false,
     check: false,
+    rollback: false,
     yes: false,
     allowedBreakingChangeIds: []
   };
@@ -17109,6 +17544,18 @@ function parseArgs4(args2) {
     else if (arg === "--env-file") opts.envFile = next();
     else if (arg.startsWith("--env-file=")) opts.envFile = arg.split("=").slice(1).join("=");
     else if (arg === "--lock-file") opts.lockFile = next();
+    else if (arg === "--public-key") opts.manifestPublicKey = readFileSync26(next(), "utf8");
+    else if (arg.startsWith("--public-key=")) opts.manifestPublicKey = readFileSync26(arg.split("=").slice(1).join("="), "utf8");
+    else if (arg === "--auth-token") opts.manifestAuthToken = next();
+    else if (arg.startsWith("--auth-token=")) opts.manifestAuthToken = arg.split("=").slice(1).join("=");
+    else if (arg === "--auth-token-env") opts.manifestAuthToken = process.env[next()] ?? "";
+    else if (arg === "--audit-url") opts.auditUrl = next();
+    else if (arg.startsWith("--audit-url=")) opts.auditUrl = arg.split("=").slice(1).join("=");
+    else if (arg === "--device-id") opts.deviceId = next();
+    else if (arg.startsWith("--device-id=")) opts.deviceId = arg.split("=").slice(1).join("=");
+    else if (arg === "--license-key") opts.licenseKey = next();
+    else if (arg.startsWith("--license-key=")) opts.licenseKey = arg.split("=").slice(1).join("=");
+    else if (arg === "--rollback") opts.rollback = true;
     else if (arg === "--dry-run") opts.dryRun = true;
     else if (arg === "--check") opts.check = true;
     else if (arg === "--yes" || arg === "-y") opts.yes = true;
@@ -17130,13 +17577,20 @@ Usage:
   exe-os stack-update [--manifest <path-or-url>] [--target <version>] [--yes]
 
 Options:
-  --manifest <ref>           Stack manifest JSON path or URL (default: updates.askexe.com)
+  --manifest <ref>           Stack manifest JSON path or URL (default: update.askexe.com)
   --target <version>         Stack version to install (default: manifest.latest)
   --compose-file <path>      docker-compose.yml path (default: ./docker-compose.yml or /opt/exe-stack/docker-compose.yml)
   --env-file <path>          .env path (default: ./.env or /opt/exe-stack/.env)
   --lock-file <path>         Lock file path (default: beside .env)
   --check                    Print available changes only
   --dry-run                  Plan only; do not run Docker
+  --public-key <path>        PEM public key for signed manifest verification
+  --auth-token <token>       Bearer token for private update manifest/audit API
+  --auth-token-env <name>    Read bearer token from an environment variable
+  --audit-url <url>          Deploy-audit endpoint (default: EXE_STACK_AUDIT_URL/update.askexe.com)
+  --device-id <id>           Device ID to include in deploy audit
+  --license-key <key>        License key to include in deploy audit
+  --rollback                 Restore latest backed-up .env and restart stack
   --allow-breaking <ids>     Confirm breaking changes, comma-separated
   -y, --yes                  Non-interactive confirmation
 `);
@@ -17164,7 +17618,16 @@ function printBreaking(changes) {
 }
 async function main3() {
   const opts = parseArgs4(process.argv.slice(2));
-  const manifest = await loadStackManifest(opts.manifestRef);
+  if (opts.rollback) {
+    if (!opts.yes) {
+      console.error("Refusing to rollback without --yes.");
+      process.exit(2);
+    }
+    const result2 = await runStackUpdate(opts);
+    console.log(`\u2705 Stack rollback attempted using backup: ${result2.backupEnvFile ?? "latest backup"}`);
+    return;
+  }
+  const manifest = await loadStackManifest(opts.manifestRef, void 0, opts.manifestPublicKey, opts.manifestAuthToken);
   const envRaw = readFileSync26(opts.envFile, "utf8");
   const plan = createStackUpdatePlan(manifest, envRaw, opts.targetVersion);
   console.log(`Exe OS stack target: ${plan.targetVersion}`);
@@ -32104,7 +32567,7 @@ var init_mcp_diagnostics = __esm({
 });
 
 // src/bin/cli.ts
-import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync21, readdirSync as readdirSync10, rmSync } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync21, readdirSync as readdirSync11, rmSync } from "fs";
 import path49 from "path";
 import os22 from "os";
 var args = process.argv.slice(2);
@@ -32553,7 +33016,7 @@ async function runClaudeUninstall(flags = []) {
   if (existsSync35(skillsDir)) {
     let skillCount = 0;
     try {
-      const entries = readdirSync10(skillsDir);
+      const entries = readdirSync11(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
           const fullPath = path49.join(skillsDir, entry);
@@ -32586,7 +33049,7 @@ async function runClaudeUninstall(flags = []) {
   if (existsSync35(agentsDir)) {
     let agentCount = 0;
     try {
-      const entries = readdirSync10(agentsDir).filter((f) => f.endsWith(".md"));
+      const entries = readdirSync11(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
       const rosterPath = path49.join(exeOsDir, "exe-employees.json");
       if (existsSync35(rosterPath)) {
@@ -32614,7 +33077,7 @@ async function runClaudeUninstall(flags = []) {
   if (existsSync35(projectsDir)) {
     let projectCount = 0;
     try {
-      const projects = readdirSync10(projectsDir);
+      const projects = readdirSync11(projectsDir);
       for (const proj of projects) {
         const projSettings = path49.join(projectsDir, proj, "settings.json");
         if (!existsSync35(projSettings)) continue;