@desplega.ai/agent-swarm 1.83.0 → 1.83.2

package/src/be/migrations/074_user_budget_scope.sql

@@ -0,0 +1,85 @@
+-- 074_user_budget_scope.sql
+-- Add per-user budget enforcement for client-side MCP users.
+--
+-- SQLite cannot widen a CHECK constraint in place, so recreate the affected
+-- tables and preserve their data. The `budgets` table gains scope='user'.
+-- `budget_refusal_notifications` gains cause='user' and optional user
+-- spend/budget audit columns so claim-time user-budget refusals can share the
+-- existing dedup + lead-notification rail.
+
+CREATE TABLE budgets_new (
+  scope TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  daily_budget_usd REAL NOT NULL,
+  createdAt INTEGER NOT NULL,
+  lastUpdatedAt INTEGER NOT NULL,
+  PRIMARY KEY (scope, scope_id),
+  CHECK (scope IN ('global', 'agent', 'user')),
+  CHECK (daily_budget_usd >= 0)
+);
+
+INSERT INTO budgets_new (scope, scope_id, daily_budget_usd, createdAt, lastUpdatedAt)
+SELECT scope, scope_id, daily_budget_usd, createdAt, lastUpdatedAt
+FROM budgets;
+
+DROP TABLE budgets;
+ALTER TABLE budgets_new RENAME TO budgets;
+
+INSERT OR IGNORE INTO budgets (scope, scope_id, daily_budget_usd, createdAt, lastUpdatedAt)
+SELECT
+  'user',
+  id,
+  dailyBudgetUsd,
+  CAST(strftime('%s', 'now') AS INTEGER) * 1000,
+  CAST(strftime('%s', 'now') AS INTEGER) * 1000
+FROM users
+WHERE dailyBudgetUsd IS NOT NULL;
+
+CREATE TABLE budget_refusal_notifications_new (
+  task_id TEXT NOT NULL,
+  date TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  cause TEXT NOT NULL,
+  agent_spend_usd REAL,
+  agent_budget_usd REAL,
+  global_spend_usd REAL,
+  global_budget_usd REAL,
+  user_spend_usd REAL,
+  user_budget_usd REAL,
+  follow_up_task_id TEXT,
+  createdAt INTEGER NOT NULL,
+  PRIMARY KEY (task_id, date),
+  CHECK (cause IN ('agent', 'global', 'user'))
+);
+
+INSERT INTO budget_refusal_notifications_new (
+  task_id,
+  date,
+  agent_id,
+  cause,
+  agent_spend_usd,
+  agent_budget_usd,
+  global_spend_usd,
+  global_budget_usd,
+  user_spend_usd,
+  user_budget_usd,
+  follow_up_task_id,
+  createdAt
+)
+SELECT
+  task_id,
+  date,
+  agent_id,
+  cause,
+  agent_spend_usd,
+  agent_budget_usd,
+  global_spend_usd,
+  global_budget_usd,
+  NULL,
+  NULL,
+  follow_up_task_id,
+  createdAt
+FROM budget_refusal_notifications;
+
+DROP TABLE budget_refusal_notifications;
+ALTER TABLE budget_refusal_notifications_new RENAME TO budget_refusal_notifications;

package/src/be/schedules/validate.ts

@@ -0,0 +1,21 @@
+export type MergedScheduleTiming = { mergedCron: string | null; mergedInterval: number | null };
+export type ScheduleTimingPatch = { cronExpression?: string | null; intervalMs?: number | null };
+
+export function mergeScheduleTiming(
+  existing: { cronExpression: string | null; intervalMs: number | null },
+  patch: ScheduleTimingPatch,
+): MergedScheduleTiming {
+  return {
+    mergedCron: patch.cronExpression !== undefined ? patch.cronExpression : existing.cronExpression,
+    mergedInterval: patch.intervalMs !== undefined ? patch.intervalMs : existing.intervalMs,
+  };
+}
+
+export type RecurringTimingError = { kind: "both-null" } | null;
+
+export function validateRecurringTiming(merged: MergedScheduleTiming): RecurringTimingError {
+  if (merged.mergedCron === null && merged.mergedInterval === null) {
+    return { kind: "both-null" };
+  }
+  return null;
+}

package/src/be/skill-sync.ts

@@ -1,9 +1,9 @@
 /**
  * Filesystem sync for skills.
  *
- * Writes installed skills to ~/.claude/skills/<name>/SKILL.md (and optionally
- * ~/.pi/agent/skills/<name>/SKILL.md) so Claude Code and Pi discover them
- * natively.
+ * Writes installed skills to ~/.claude/skills/<name>/SKILL.md,
+ * ~/.pi/agent/skills/<name>/SKILL.md, and ~/.codex/skills/<name>/SKILL.md
+ * so Claude Code, Pi, and Codex discover them natively.
  *
  * This runs on the API side — workers call it via POST /api/skills/sync-filesystem.
  */
@@ -19,6 +19,16 @@ export interface SkillSyncResult {
   errors: string[];
 }
 
+/**
+ * Marker file written into every swarm-managed skill directory. Cleanup
+ * only ever removes directories that contain this marker, so unrelated
+ * personal skills the user installed via the harness's own tooling (e.g.
+ * `codex skills add ...` writing into `~/.codex/skills/<name>/`) are left
+ * untouched even when the API server shares a HOME with the worker (local
+ * dev). See `~/.codex/skills` blast-radius note in PR #555.
+ */
+const SWARM_MARKER_FILE = ".swarm-managed";
+
 /**
  * Sync agent's installed skills to the filesystem.
  *
@@ -27,7 +37,7 @@ export interface SkillSyncResult {
  */
 export function syncSkillsToFilesystem(
   agentId: string,
-  harnessType: "claude" | "pi" | "both" = "both",
+  harnessType: "claude" | "pi" | "codex" | "all" = "all",
   homeOverride?: string,
 ): SkillSyncResult {
   const skills = getAgentSkills(agentId);
@@ -37,12 +47,15 @@ export function syncSkillsToFilesystem(
 
   // Directories to write to
   const skillDirs: string[] = [];
-  if (harnessType === "claude" || harnessType === "both") {
+  if (harnessType === "claude" || harnessType === "all") {
     skillDirs.push(join(home, ".claude", "skills"));
   }
-  if (harnessType === "pi" || harnessType === "both") {
+  if (harnessType === "pi" || harnessType === "all") {
     skillDirs.push(join(home, ".pi", "agent", "skills"));
   }
+  if (harnessType === "codex" || harnessType === "all") {
+    skillDirs.push(join(home, ".codex", "skills"));
+  }
 
   // Ensure base dirs exist
   for (const dir of skillDirs) {
@@ -66,10 +79,12 @@ export function syncSkillsToFilesystem(
     for (const baseDir of skillDirs) {
       const skillDir = join(baseDir, safeName);
       const skillFile = join(skillDir, "SKILL.md");
+      const markerFile = join(skillDir, SWARM_MARKER_FILE);
 
       try {
         mkdirSync(skillDir, { recursive: true });
         writeFileSync(skillFile, skill.content, "utf-8");
+        writeFileSync(markerFile, "", "utf-8");
         synced++;
       } catch (err) {
         errors.push(
@@ -79,7 +94,10 @@ export function syncSkillsToFilesystem(
     }
   }
 
-  // Cleanup: remove skill directories that are no longer installed
+  // Cleanup: only remove directories WE previously created (marker file
+  // present). Leaves user-installed personal skills alone — important on
+  // local dev where ~/.codex/skills holds skills the user installed
+  // outside the swarm.
   let removed = 0;
   for (const baseDir of skillDirs) {
     if (!existsSync(baseDir)) continue;
@@ -87,14 +105,15 @@ export function syncSkillsToFilesystem(
     try {
       const existing = readdirSync(baseDir, { withFileTypes: true });
       for (const entry of existing) {
-        if (entry.isDirectory() && !writtenNames.has(entry.name)) {
-          const skillDir = join(baseDir, entry.name);
-          try {
-            rmSync(skillDir, { recursive: true, force: true });
-            removed++;
-          } catch {
-            // Non-fatal — skip cleanup errors
-          }
+        if (!entry.isDirectory()) continue;
+        if (writtenNames.has(entry.name)) continue;
+        const skillDir = join(baseDir, entry.name);
+        if (!existsSync(join(skillDir, SWARM_MARKER_FILE))) continue;
+        try {
+          rmSync(skillDir, { recursive: true, force: true });
+          removed++;
+        } catch {
+          // Non-fatal — skip cleanup errors
         }
       }
     } catch {
@@ -104,3 +123,34 @@ export function syncSkillsToFilesystem(
 
   return { synced, removed, errors };
 }
+
+export interface SkillsSignature {
+  hash: string;
+  count: number;
+}
+
+/**
+ * Compute a stable signature over an agent's installed-and-enabled skill set.
+ *
+ * Hash inputs are the per-row mutation-tracking fields — any install,
+ * uninstall, toggle, or skill-update mutates at least one of them. Output is
+ * deterministic and contains no timestamps beyond per-row mutation fields.
+ */
+export function computeAgentSkillsSignature(agentId: string): SkillsSignature {
+  const skills = getAgentSkills(agentId);
+  const sorted = [...skills].sort((a, b) => a.id.localeCompare(b.id));
+  const canonical = JSON.stringify(
+    sorted.map((s) => [
+      s.id,
+      s.name,
+      s.version,
+      s.isEnabled,
+      s.isActive,
+      s.lastUpdatedAt,
+      s.sourceHash ?? "",
+      s.installedAt,
+    ]),
+  );
+  const hash = new Bun.CryptoHasher("sha256").update(canonical).digest("hex");
+  return { hash, count: sorted.length };
+}

package/src/commands/resume-session.ts

@@ -0,0 +1,118 @@
+import type { ProviderName } from "../types";
+
+export type ResumeSessionSource = "task" | "parent";
+
+export interface ResumeSessionCandidate {
+  source: ResumeSessionSource;
+  sessionId?: string | null;
+  taskId?: string;
+  provider?: ProviderName;
+  providerMeta?: Record<string, unknown>;
+}
+
+export interface ResumeSessionSkip {
+  source: ResumeSessionSource;
+  sessionId: string;
+  provider?: ProviderName;
+  reason: string;
+}
+
+export interface ResumeSessionResolution {
+  resumeSessionId?: string;
+  source?: ResumeSessionSource;
+  provider?: ProviderName;
+  skipped: ResumeSessionSkip[];
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const RESUMABLE_PROVIDERS = new Set<ProviderName>(["claude", "claude-managed", "codex"]);
+
+export function isClaudeCliSessionId(sessionId: string): boolean {
+  return UUID_RE.test(sessionId);
+}
+
+function normalizeStoredProvider(candidate: ResumeSessionCandidate): ProviderName | undefined {
+  if (candidate.provider === "claude" && candidate.providerMeta?.managed === true) {
+    return "claude-managed";
+  }
+  return candidate.provider;
+}
+
+function providerSupportsResume(provider: ProviderName): boolean {
+  return RESUMABLE_PROVIDERS.has(provider);
+}
+
+export function resolveResumeSession(
+  currentProvider: ProviderName,
+  candidates: ResumeSessionCandidate[],
+): ResumeSessionResolution {
+  const skipped: ResumeSessionSkip[] = [];
+
+  for (const candidate of candidates) {
+    const sessionId = candidate.sessionId?.trim();
+    if (!sessionId) continue;
+
+    const storedProvider = normalizeStoredProvider(candidate);
+
+    if (!storedProvider) {
+      if (currentProvider === "claude" && isClaudeCliSessionId(sessionId)) {
+        return {
+          resumeSessionId: sessionId,
+          source: candidate.source,
+          provider: "claude",
+          skipped,
+        };
+      }
+
+      skipped.push({
+        source: candidate.source,
+        sessionId,
+        reason:
+          currentProvider === "claude"
+            ? "legacy Claude resume requires a UUID session id"
+            : "stored session provider is unknown",
+      });
+      continue;
+    }
+
+    if (storedProvider !== currentProvider) {
+      skipped.push({
+        source: candidate.source,
+        sessionId,
+        provider: storedProvider,
+        reason: `stored session provider ${storedProvider} does not match current provider ${currentProvider}`,
+      });
+      continue;
+    }
+
+    if (!providerSupportsResume(currentProvider)) {
+      skipped.push({
+        source: candidate.source,
+        sessionId,
+        provider: storedProvider,
+        reason: `provider ${currentProvider} does not support runner resume`,
+      });
+      continue;
+    }
+
+    if (currentProvider === "claude" && !isClaudeCliSessionId(sessionId)) {
+      skipped.push({
+        source: candidate.source,
+        sessionId,
+        provider: storedProvider,
+        reason: "Claude CLI --resume requires a UUID session id",
+      });
+      continue;
+    }
+
+    return {
+      resumeSessionId: sessionId,
+      source: candidate.source,
+      provider: storedProvider,
+      skipped,
+    };
+  }
+
+  return { skipped };
+}