@askexenow/exe-os 0.9.270 → 0.9.272

package/dist/tui-data-VXF2RBVM.js

@@ -0,0 +1,258 @@
+import {
+  sessionScopeFilter
+} from "./chunk-57UAFTO2.js";
+import "./chunk-SD6UFZRH.js";
+import "./chunk-5CHYEKMH.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-GQ2XYRG3.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-CX6GL3ZJ.js";
+import "./chunk-JP45GCVR.js";
+import "./chunk-XJUUWHVN.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-7SLLNRR3.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-TN45CTOI.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-UNCGZXPU.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-VGYL7CN2.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-MOZ2YQ54.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/tui-data.ts
+async function loadMemoryDashboard(limit) {
+  const client = getClient();
+  const [countResult, recentResult, agentResult] = await Promise.all([
+    client.execute("SELECT COUNT(*) as cnt FROM memories"),
+    client.execute({
+      sql: "SELECT agent_id, tool_name, project_name, raw_text, timestamp FROM memories ORDER BY timestamp DESC LIMIT ?",
+      args: [limit]
+    }),
+    client.execute("SELECT agent_id, COUNT(*) as cnt FROM memories GROUP BY agent_id ORDER BY cnt DESC")
+  ]);
+  return {
+    total: Number(countResult.rows[0]?.cnt ?? 0),
+    recent: recentResult.rows.map((row) => ({
+      agentId: String(row.agent_id ?? "unknown"),
+      toolName: String(row.tool_name ?? ""),
+      projectName: String(row.project_name ?? ""),
+      rawText: String(row.raw_text ?? ""),
+      timestamp: String(row.timestamp ?? "")
+    })),
+    byAgent: agentResult.rows.map((row) => ({
+      agentId: String(row.agent_id ?? "unknown"),
+      count: Number(row.cnt ?? 0)
+    }))
+  };
+}
+async function loadTeamBadgeCounts() {
+  const client = getClient();
+  const memoryCounts = /* @__PURE__ */ new Map();
+  const memResult = await client.execute("SELECT agent_id, COUNT(*) as cnt FROM memories GROUP BY agent_id");
+  for (const row of memResult.rows) {
+    memoryCounts.set(String(row.agent_id), Number(row.cnt));
+  }
+  return memoryCounts;
+}
+async function loadTeamDetailMetrics(employeeNames) {
+  const client = getClient();
+  const projectsByEmployee = /* @__PURE__ */ new Map();
+  const currentTaskByEmployee = /* @__PURE__ */ new Map();
+  const scope = sessionScopeFilter();
+  for (const employeeName of employeeNames) {
+    const [projectResult, taskResult] = await Promise.all([
+      client.execute({
+        sql: `SELECT DISTINCT project_name,
+                     MAX(CASE WHEN status = 'in_progress' THEN 1 WHEN status = 'open' THEN 2 ELSE 3 END) as urgency
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open','in_progress','done')${scope.sql}
+              GROUP BY project_name
+              ORDER BY urgency ASC
+              LIMIT 5`,
+        args: [employeeName, ...scope.args]
+      }),
+      client.execute({
+        sql: `SELECT title FROM tasks
+              WHERE assigned_to = ? AND status = 'in_progress'${scope.sql}
+              ORDER BY updated_at DESC
+              LIMIT 1`,
+        args: [employeeName, ...scope.args]
+      })
+    ]);
+    const projects = projectResult.rows.map((row) => {
+      const urgency = Number(row.urgency);
+      return {
+        name: String(row.project_name),
+        status: urgency === 1 ? "active" : urgency === 2 ? "has_tasks" : "idle"
+      };
+    });
+    if (projects.length > 0) projectsByEmployee.set(employeeName, projects);
+    if (taskResult.rows.length > 0) {
+      currentTaskByEmployee.set(employeeName, String(taskResult.rows[0].title));
+    }
+  }
+  return { projectsByEmployee, currentTaskByEmployee };
+}
+async function loadTeamMetrics(employeeNames) {
+  const [memoryCounts, { projectsByEmployee, currentTaskByEmployee }] = await Promise.all([
+    loadTeamBadgeCounts(),
+    loadTeamDetailMetrics(employeeNames)
+  ]);
+  return { memoryCounts, projectsByEmployee, currentTaskByEmployee };
+}
+async function loadTaskList() {
+  const client = getClient();
+  const scope = sessionScopeFilter();
+  const result = await client.execute({
+    sql: `SELECT id, title, priority, assigned_to, assigned_by, status, project_name, created_at, result
+          FROM tasks
+          WHERE 1=1${scope.sql}
+          ORDER BY
+            CASE status WHEN 'in_progress' THEN 0 WHEN 'open' THEN 1 WHEN 'blocked' THEN 2 WHEN 'needs_review' THEN 3 WHEN 'done' THEN 4 ELSE 5 END,
+            CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+            created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id ?? ""),
+    title: String(row.title ?? ""),
+    priority: String(row.priority ?? "p2").toUpperCase(),
+    assignedTo: String(row.assigned_to ?? ""),
+    assignedBy: String(row.assigned_by ?? ""),
+    status: String(row.status ?? "open"),
+    projectName: String(row.project_name ?? ""),
+    createdAt: String(row.created_at ?? ""),
+    result: String(row.result ?? "")
+  }));
+}
+async function searchWikiMemoryRows(query) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, timestamp, project_name
+          FROM memories
+          WHERE raw_text LIKE ? AND COALESCE(status, 'active') = 'active'
+          ORDER BY timestamp DESC LIMIT 20`,
+    args: [`%${query}%`]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    rawText: String(row.raw_text),
+    timestamp: String(row.timestamp),
+    projectName: String(row.project_name ?? "")
+  }));
+}
+async function loadEntityProfile(entityName) {
+  const client = getClient();
+  const { getEntityByName, getRelationships, getEntityTimeline } = await import("./graph-query-UTLL5MKN.js");
+  const entity = await getEntityByName(client, entityName);
+  if (!entity) return null;
+  const [relationships, timelineRaw] = await Promise.all([
+    getRelationships(client, entity.id, { direction: "both" }),
+    getEntityTimeline(client, entity.id)
+  ]);
+  const neighbors = relationships.map((r) => {
+    const isOutgoing = r.sourceEntityId === entity.id;
+    return {
+      name: isOutgoing ? r.targetName : r.sourceName,
+      type: isOutgoing ? "target" : "source",
+      relType: r.type,
+      direction: isOutgoing ? "outgoing" : "incoming",
+      weight: r.weight,
+      confidence: r.confidence
+    };
+  });
+  const timeline = timelineRaw.slice(0, 20).map((t) => {
+    const isOutgoing = t.relationship.sourceEntityId === entity.id;
+    return {
+      timestamp: t.timestamp,
+      relType: t.relationship.type,
+      partnerName: isOutgoing ? t.relationship.targetName : t.relationship.sourceName,
+      direction: isOutgoing ? "outgoing" : "incoming"
+    };
+  });
+  const relationshipTypes = {};
+  for (const r of relationships) {
+    relationshipTypes[r.type] = (relationshipTypes[r.type] ?? 0) + 1;
+  }
+  return {
+    entity,
+    neighbors,
+    timeline,
+    stats: {
+      totalRelationships: relationships.length,
+      relationshipTypes
+    }
+  };
+}
+async function searchEntitiesList(query, limit = 20) {
+  const client = getClient();
+  const { searchEntities } = await import("./graph-query-UTLL5MKN.js");
+  const entities = await searchEntities(client, query, limit);
+  if (entities.length === 0) return [];
+  const placeholders = entities.map(() => "?").join(",");
+  const ids = entities.map((e) => e.id);
+  const countResult = await client.execute({
+    sql: `SELECT source_entity_id as eid, COUNT(*) as cnt FROM relationships WHERE source_entity_id IN (${placeholders}) AND valid_until IS NULL GROUP BY source_entity_id
+          UNION ALL
+          SELECT target_entity_id as eid, COUNT(*) as cnt FROM relationships WHERE target_entity_id IN (${placeholders}) AND valid_until IS NULL GROUP BY target_entity_id`,
+    args: [...ids, ...ids]
+  });
+  const countMap = /* @__PURE__ */ new Map();
+  for (const row of countResult.rows) {
+    const eid = String(row.eid);
+    countMap.set(eid, (countMap.get(eid) ?? 0) + Number(row.cnt));
+  }
+  return entities.map((e) => ({
+    id: e.id,
+    name: e.name,
+    type: e.type,
+    lastSeen: e.lastSeen,
+    relationshipCount: countMap.get(e.id) ?? 0
+  }));
+}
+async function loadHotEntities(limit = 15) {
+  const client = getClient();
+  const { getHotEntities } = await import("./graph-query-UTLL5MKN.js");
+  const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+  const hot = await getHotEntities(client, since, limit);
+  return hot.map((h) => ({
+    id: h.entity.id,
+    name: h.entity.name,
+    type: h.entity.type,
+    lastSeen: h.entity.lastSeen,
+    relationshipCount: h.newRelationships
+  }));
+}
+async function loadGraphOverview() {
+  const client = getClient();
+  const { getGraphStats } = await import("./graph-query-UTLL5MKN.js");
+  const stats = await getGraphStats(client);
+  return {
+    totalEntities: stats.entities,
+    totalRelationships: stats.relationships,
+    entityTypes: stats.types
+  };
+}
+export {
+  loadEntityProfile,
+  loadGraphOverview,
+  loadHotEntities,
+  loadMemoryDashboard,
+  loadTaskList,
+  loadTeamBadgeCounts,
+  loadTeamDetailMetrics,
+  loadTeamMetrics,
+  searchEntitiesList,
+  searchWikiMemoryRows
+};

package/dist/wiki-acl-MJIMXRQV.js

@@ -0,0 +1,111 @@
+import "./chunk-MLKGABMK.js";
+
+// src/lib/wiki-acl.ts
+async function checkWikiAccess(userId, workspace, requiredLevel = "read") {
+  if (!userId) {
+    return {
+      allowed: requiredLevel === "read",
+      actualLevel: "read"
+    };
+  }
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT access_level FROM wiki_acl WHERE user_id = ? AND workspace = ?`,
+      args: [userId, workspace]
+    });
+    if (result.rows.length > 0) {
+      const actualLevel = String(result.rows[0].access_level);
+      return {
+        allowed: accessLevelSatisfies(actualLevel, requiredLevel),
+        actualLevel
+      };
+    }
+    const wildcardResult = await client.execute({
+      sql: `SELECT access_level FROM wiki_acl WHERE user_id = ? AND workspace = '*'`,
+      args: [userId]
+    });
+    if (wildcardResult.rows.length > 0) {
+      const actualLevel = String(wildcardResult.rows[0].access_level);
+      return {
+        allowed: accessLevelSatisfies(actualLevel, requiredLevel),
+        actualLevel
+      };
+    }
+    return {
+      allowed: requiredLevel === "read",
+      actualLevel: "read"
+    };
+  } catch {
+    return {
+      allowed: requiredLevel === "read",
+      actualLevel: "read"
+    };
+  }
+}
+async function grantWikiAccess(userId, workspace, accessLevel, grantedBy) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT OR REPLACE INTO wiki_acl (user_id, workspace, access_level, granted_by, created_at)
+          VALUES (?, ?, ?, ?, ?)`,
+    args: [userId, workspace, accessLevel, grantedBy, (/* @__PURE__ */ new Date()).toISOString()]
+  });
+}
+async function revokeWikiAccess(userId, workspace) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const result = await client.execute({
+    sql: `DELETE FROM wiki_acl WHERE user_id = ? AND workspace = ?`,
+    args: [userId, workspace]
+  });
+  return (result.rowsAffected ?? 0) > 0;
+}
+async function listUserWikiAccess(userId) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT user_id, workspace, access_level, granted_by, created_at
+          FROM wiki_acl WHERE user_id = ? ORDER BY workspace`,
+    args: [userId]
+  });
+  return result.rows.map((r) => ({
+    userId: String(r.user_id),
+    workspace: String(r.workspace),
+    accessLevel: String(r.access_level),
+    grantedBy: String(r.granted_by),
+    createdAt: String(r.created_at)
+  }));
+}
+async function listWorkspaceUsers(workspace) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT user_id, workspace, access_level, granted_by, created_at
+          FROM wiki_acl WHERE workspace = ? OR workspace = '*' ORDER BY user_id`,
+    args: [workspace]
+  });
+  return result.rows.map((r) => ({
+    userId: String(r.user_id),
+    workspace: String(r.workspace),
+    accessLevel: String(r.access_level),
+    grantedBy: String(r.granted_by),
+    createdAt: String(r.created_at)
+  }));
+}
+var ACCESS_HIERARCHY = {
+  read: 1,
+  write: 2,
+  admin: 3
+};
+function accessLevelSatisfies(actual, required) {
+  return (ACCESS_HIERARCHY[actual] ?? 0) >= (ACCESS_HIERARCHY[required] ?? 0);
+}
+export {
+  checkWikiAccess,
+  grantWikiAccess,
+  listUserWikiAccess,
+  listWorkspaceUsers,
+  revokeWikiAccess
+};

package/dist/worker-gate-WQGTZOSM.js

@@ -0,0 +1,21 @@
+import {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  getTaskAwareCapacity,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+} from "./chunk-KOBIB6WG.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  getTaskAwareCapacity,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+};

package/dist/worker-gate-X2YDTKTL.js

@@ -0,0 +1,21 @@
+import {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  getTaskAwareCapacity,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+} from "./chunk-G2S2UMU4.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  getTaskAwareCapacity,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+};

package/dist/workflow-engine-CYXRZXBM.js

@@ -0,0 +1,28 @@
+import {
+  advanceWorkflow,
+  approveWorkflowStep,
+  createWorkflowDefinition,
+  getWorkflowDefinition,
+  getWorkflowInstance,
+  listWorkflowDefinitions,
+  listWorkflowInstances,
+  loadWorkflows,
+  persistWorkflows,
+  runWorkflow,
+  startWorkflow
+} from "./chunk-6OD7PVMC.js";
+import "./chunk-J6V2DCZK.js";
+import "./chunk-MLKGABMK.js";
+export {
+  advanceWorkflow,
+  approveWorkflowStep,
+  createWorkflowDefinition,
+  getWorkflowDefinition,
+  getWorkflowInstance,
+  listWorkflowDefinitions,
+  listWorkflowInstances,
+  loadWorkflows,
+  persistWorkflows,
+  runWorkflow,
+  startWorkflow
+};

package/dist/workflow-engine-KMLAXVA4.js

@@ -0,0 +1,28 @@
+import {
+  advanceWorkflow,
+  approveWorkflowStep,
+  createWorkflowDefinition,
+  getWorkflowDefinition,
+  getWorkflowInstance,
+  listWorkflowDefinitions,
+  listWorkflowInstances,
+  loadWorkflows,
+  persistWorkflows,
+  runWorkflow,
+  startWorkflow
+} from "./chunk-SVFNKSZV.js";
+import "./chunk-7ET5CYTD.js";
+import "./chunk-MLKGABMK.js";
+export {
+  advanceWorkflow,
+  approveWorkflowStep,
+  createWorkflowDefinition,
+  getWorkflowDefinition,
+  getWorkflowInstance,
+  listWorkflowDefinitions,
+  listWorkflowInstances,
+  loadWorkflows,
+  persistWorkflows,
+  runWorkflow,
+  startWorkflow
+};

package/dist/worktree-NLSKVRNC.js

@@ -0,0 +1,26 @@
+import {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+} from "./chunk-KZNSOHCB.js";
+import "./chunk-2NQQP3FF.js";
+import "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+};

package/dist/worktree-sweep-44TMEPLE.js

@@ -0,0 +1,19 @@
+import {
+  cleanupAgentWorktree,
+  discoverRepoPaths,
+  sweepWorktrees
+} from "./chunk-62DEE65H.js";
+import "./chunk-KZNSOHCB.js";
+import "./chunk-2NQQP3FF.js";
+import "./chunk-CHBHR5W6.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-C6OYEJJI.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupAgentWorktree,
+  discoverRepoPaths,
+  sweepWorktrees
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.270",
+  "version": "0.9.272",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",

package/release-notes.json

@@ -1,35 +1,36 @@
 {
-  "current": "0.9.270",
+  "current": "0.9.272",
   "notes": {
-    "0.9.270": {
-      "version": "0.9.270",
+    "0.9.272": {
+      "version": "0.9.272",
       "date": "2026-06-11",
-      "features": [],
+      "features": [
+        "support service scoped resume"
+      ],
       "fixes": [
-        "harden MCP zombie gate + stale init-db.sql staging + CRM_GRAPHQL_URL default",
-        "exe-start PATH resolution + conservative MCP zombie/session recovery",
-        "stack-update rollback migrations, image pull verification, cloudflared healthcheck",
-        "Fix remaining exe-os support bugs",
-        "widen gateway-client waitFor to 15s for loaded 4-core runner",
-        "bind gateway-client mock WS server to 127.0.0.1 explicitly",
-        "ephemeral WS port + registry-host-agnostic parity assert",
-        "make tests robust on persistent self-hosted runner",
-        "Fix shard founder scope and MCP session TTL",
-        "Fix session-scoped notifications and RSS smoke gate",
-        "Fix degraded daemon boot bug paths",
-        "resource-triggered daemon restarts exit non-zero so launchd relaunches"
+        "GHCR verify base64 token, release skips missing repos, claude --model override reaches spawn"
       ],
-      "security": [
-        "Enforce cross-stack UX and security contracts"
+      "security": [],
+      "other": [
+        "Publish Claude Fable model support as 0.9.272",
+        "Add Claude Fable model whitelist",
+        "Publish stack-update service resume as 0.9.271"
+      ],
+      "migration_notes": []
+    },
+    "0.9.271": {
+      "version": "0.9.271",
+      "date": "2026-06-11",
+      "features": [
+        "Add stack-update --service for targeted single-service updates",
+        "Add stack-update --resume for retrying incomplete service updates"
+      ],
+      "fixes": [
+        "Track per-service stack update status for safer resume and scoped rollback flows"
       ],
+      "security": [],
       "other": [
-        "Update memory score history for 0.9.267 publish",
-        "quarantine gateway-client suite in CI with loud warning — tracked bug",
-        "retry budget (2) for gateway-client on the shared runner",
-        "separate vitest invocations for serial files — perf-stress fake timers poison a shared fork",
-        "daemon-perf-stress joins the serial pass — timing comparisons need a quiet box",
-        "run gateway-client serially after the parallel suite",
-        "retrigger"
+        "Merge HYGO stack-update service-scoped update feature PR #93"
       ],
       "migration_notes": []
     },
@@ -107,21 +108,6 @@
       ],
       "other": [],
       "migration_notes": []
-    },
-    "0.9.266": {
-      "version": "0.9.266",
-      "date": "2026-06-10",
-      "features": [],
-      "fixes": [
-        "Fix session-scoped notifications and RSS smoke gate",
-        "Fix degraded daemon boot bug paths",
-        "resource-triggered daemon restarts exit non-zero so launchd relaunches"
-      ],
-      "security": [
-        "Enforce cross-stack UX and security contracts"
-      ],
-      "other": [],
-      "migration_notes": []
     }
   }
 }