@askexenow/exe-os 0.9.280 → 0.9.281

package/dist/tui-data-ZDB7BLP2.js

@@ -0,0 +1,259 @@
+import {
+  sessionScopeFilter
+} from "./chunk-PWPJK7KB.js";
+import "./chunk-4MRP6EBR.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-F6L33PAQ.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-MYEABW5Z.js";
+import "./chunk-PMVOUPTY.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-AU47B4QY.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-4533HNOG.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-WUKEXVOR.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-ORDHJRWN.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-YMKUXZIG.js";
+import "./chunk-T3B5RK4H.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-XEDHA2PQ.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-XEDHA2PQ.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-XEDHA2PQ.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-XEDHA2PQ.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-HHSIBPF3.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/wiki-acl-O65GZ2ZF.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-27I4GAEZ.js

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

package/dist/worker-gate-DXU4HEPY.js

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

package/dist/workflow-engine-63EOEJ5Q.js

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

package/dist/workflow-engine-C6F2RMPN.js

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

package/dist/worktree-SFKKOMFD.js

@@ -0,0 +1,27 @@
+import {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+} from "./chunk-4MRP6EBR.js";
+import "./chunk-MYEABW5Z.js";
+import "./chunk-WUKEXVOR.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-ORDHJRWN.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+};

package/dist/worktree-SVCE3S7X.js

@@ -0,0 +1,27 @@
+import {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+} from "./chunk-ARUTDXZX.js";
+import "./chunk-FSRKIZGZ.js";
+import "./chunk-52UDAVZE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-YGWFBN5A.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+};

package/dist/worktree-sweep-S3JHJTVP.js

@@ -0,0 +1,20 @@
+import {
+  cleanupAgentWorktree,
+  discoverRepoPaths,
+  sweepWorktrees
+} from "./chunk-M4NPCAIH.js";
+import "./chunk-4MRP6EBR.js";
+import "./chunk-MYEABW5Z.js";
+import "./chunk-WUKEXVOR.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-ORDHJRWN.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupAgentWorktree,
+  discoverRepoPaths,
+  sweepWorktrees
+};

package/dist/worktree-sweep-U3TIQ7WL.js

@@ -0,0 +1,20 @@
+import {
+  cleanupAgentWorktree,
+  discoverRepoPaths,
+  sweepWorktrees
+} from "./chunk-O5GUCDR2.js";
+import "./chunk-ARUTDXZX.js";
+import "./chunk-FSRKIZGZ.js";
+import "./chunk-52UDAVZE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-YGWFBN5A.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-T3B5RK4H.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.280",
+  "version": "0.9.281",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",