@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/be/events.ts

@@ -266,6 +266,7 @@ export function getEventsFiltered(filters: {
   agentId?: string;
   taskId?: string;
   sessionId?: string;
+  dataField?: string;
   since?: string;
   until?: string;
   limit?: number;
@@ -301,6 +302,10 @@ export function getEventsFiltered(filters: {
     conditions.push("sessionId = ?");
     params.push(filters.sessionId);
   }
+  if (filters.dataField) {
+    conditions.push("json_extract(data, '$.field') = ?");
+    params.push(filters.dataField);
+  }
   if (filters.since) {
     conditions.push("createdAt >= ?");
     params.push(filters.since);

package/src/be/migrations/131_session_logs_created_at_index.sql

@@ -0,0 +1,2 @@
+-- Support chronological session log scans without walking the full table.
+CREATE INDEX IF NOT EXISTS idx_session_logs_createdAt ON session_logs(createdAt);

package/src/be/migrations/132_multi_runtime_instances.sql

@@ -0,0 +1,44 @@
+-- Multi-runtime support: one logical agent may be served by several worker
+-- processes at once.
+--
+-- `runtime_instances` holds one row per worker process serving an agent. The
+-- `agents` row stays the durable identity; these rows carry only
+-- process-scoped state (self-reported capacity and liveness) and are written
+-- exclusively while MULTI_RUNTIME_ENABLED is set, so the table stays empty in
+-- the default configuration. Rows are retired and pruned through the runtime
+-- lifecycle rather than kept as history.
+--
+-- `status` values live in Zod (RuntimeInstanceStatusSchema, src/types.ts)
+-- rather than a SQL CHECK, so adding a lifecycle state later needs no table
+-- rebuild — the convention agent_tasks.source adopted in migration 056.
+--
+-- No FK from agent_tasks: task history must survive the disappearance of
+-- whatever ran it.
+CREATE TABLE runtime_instances (
+  id             TEXT PRIMARY KEY,
+  agent_id       TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  status         TEXT NOT NULL DEFAULT 'active',
+  -- This runtime's own concurrent task capacity, self-reported at
+  -- registration. Composes with, but is never an alias for, agents.maxTasks.
+  reported_slots INTEGER NOT NULL DEFAULT 1,
+  -- Credential readiness is process-local: one runtime waiting on credentials
+  -- must not disable a ready sibling. NULL means "never reported" (e.g.
+  -- CRED_CHECK_DISABLE), which counts as ready so those workers stay usable.
+  credential_ready INTEGER,
+  metadata       TEXT,
+  last_seen_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  created_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  updated_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  created_by     TEXT,
+  updated_by     TEXT
+);
+
+CREATE INDEX idx_runtime_instances_agent ON runtime_instances(agent_id);
+
+-- Record which runtime owns each session so a starting worker clears only its
+-- own leftovers instead of deleting a sibling's live session (which would
+-- requeue a task another process is still executing). Nullable: pre-existing
+-- rows and single-runtime deployments keep the agent-wide semantics.
+ALTER TABLE active_sessions ADD COLUMN runtimeInstanceId TEXT;
+
+CREATE INDEX idx_active_sessions_runtime ON active_sessions(runtimeInstanceId);

package/src/be/migrations/133_workflow_run_trigger_type.sql

@@ -0,0 +1,12 @@
+-- Persist workflow trigger provenance outside caller-controlled triggerData.
+-- `created_by` already snapshots the human requester; together these columns
+-- distinguish a creatorless scheduled run from a requester-less manual run.
+ALTER TABLE workflow_runs
+  ADD COLUMN triggerType TEXT NOT NULL DEFAULT 'manual'
+  CHECK(triggerType IN ('schedule', 'manual', 'event', 'api'));
+
+-- Historical triggerData is caller-controlled for manual/API runs, so it
+-- cannot be promoted into trusted provenance. Existing rows keep the safe
+-- `manual` default; all future engine writes populate the server-owned value.
+
+CREATE INDEX idx_workflow_runs_trigger_type ON workflow_runs(triggerType);

package/src/be/migrations/135_backfill_task_pull_request_attachments.sql

@@ -0,0 +1,228 @@
+-- Migration 135: backfill canonical GitHub pull-request attachments from historical task output.
+--
+-- Runtime task completion and VCS detection now write these rows directly. This
+-- migration repairs the legacy history without deleting or rewriting any
+-- caller-authored attachment. Re-running is safe: the NOT EXISTS guard treats
+-- task + canonical URL as the identity regardless of display name.
+
+WITH RECURSIVE
+candidate_sources(task_id, agent_id, source_text) AS (
+  SELECT id, agentId, output
+  FROM agent_tasks
+  WHERE output IS NOT NULL
+    AND instr(lower(output), 'github.com/') > 0
+
+  UNION ALL
+
+  SELECT id, agentId, vcsUrl
+  FROM agent_tasks
+  WHERE lower(vcsProvider) = 'github'
+    AND vcsUrl IS NOT NULL
+    AND instr(lower(vcsUrl), 'github.com/') > 0
+),
+whitespace_delimiters(position, code_point) AS (
+  VALUES
+    (1, 9), (2, 10), (3, 11), (4, 12), (5, 13), (6, 32), (7, 160), (8, 5760),
+    (9, 8192), (10, 8193), (11, 8194), (12, 8195), (13, 8196), (14, 8197),
+    (15, 8198), (16, 8199), (17, 8200), (18, 8201), (19, 8202), (20, 8232),
+    (21, 8233), (22, 8239), (23, 8287), (24, 12288), (25, 65279)
+),
+token_delimiters(position, code_point) AS (
+  SELECT position, code_point FROM whitespace_delimiters
+  UNION ALL SELECT 26, 40
+  UNION ALL SELECT 27, 41
+  UNION ALL SELECT 28, 91
+  UNION ALL SELECT 29, 93
+  UNION ALL SELECT 30, 123
+  UNION ALL SELECT 31, 125
+  UNION ALL SELECT 32, 60
+  UNION ALL SELECT 33, 62
+  UNION ALL SELECT 34, 34
+  UNION ALL SELECT 35, 39
+  UNION ALL SELECT 36, 96
+),
+whitespace_characters(value, position) AS (
+  SELECT '', 0
+
+  UNION ALL
+
+  SELECT value || char(code_point), whitespace_characters.position + 1
+  FROM whitespace_characters
+  JOIN whitespace_delimiters
+    ON whitespace_delimiters.position = whitespace_characters.position + 1
+),
+normalized(task_id, agent_id, value, position) AS (
+  SELECT
+    task_id,
+    agent_id,
+    source_text,
+    0
+  FROM candidate_sources
+
+  UNION ALL
+
+  SELECT
+    task_id,
+    agent_id,
+    replace(value, char(code_point), ' '),
+    normalized.position + 1
+  FROM normalized
+  JOIN token_delimiters ON token_delimiters.position = normalized.position + 1
+),
+tokens(task_id, agent_id, remaining, token) AS (
+  SELECT
+    task_id,
+    agent_id,
+    trim(value) || ' ',
+    NULL
+  FROM normalized
+  WHERE position = (SELECT max(position) FROM token_delimiters)
+
+  UNION ALL
+
+  SELECT
+    task_id,
+    agent_id,
+    ltrim(substr(remaining, instr(remaining, ' ') + 1)),
+    substr(remaining, 1, instr(remaining, ' ') - 1)
+  FROM tokens
+  WHERE remaining <> ''
+),
+token_paths(task_id, agent_id, token, path) AS (
+  SELECT
+    task_id,
+    agent_id,
+    token,
+    CASE
+      WHEN lower(token) GLOB 'https://github.com/*'
+        THEN substr(token, length('https://github.com/') + 1)
+      WHEN lower(token) GLOB 'http://github.com/*'
+        THEN substr(token, length('http://github.com/') + 1)
+      ELSE substr(token, length('github.com/') + 1)
+    END
+  FROM tokens
+  WHERE lower(token) GLOB 'https://github.com/*'
+     OR lower(token) GLOB 'http://github.com/*'
+     OR lower(token) GLOB 'github.com/*'
+),
+token_segments(task_id, agent_id, token, owner, repo, remainder) AS (
+  SELECT
+    task_id,
+    agent_id,
+    token,
+    substr(path, 1, instr(path, '/') - 1),
+    substr(
+      substr(path, instr(path, '/') + 1),
+      1,
+      instr(substr(path, instr(path, '/') + 1), '/') - 1
+    ),
+    substr(
+      substr(path, instr(path, '/') + 1),
+      instr(substr(path, instr(path, '/') + 1), '/') + 1
+    )
+  FROM token_paths
+  WHERE instr(path, '/') > 1
+    AND instr(substr(path, instr(path, '/') + 1), '/') > 1
+),
+digit_scan(task_id, agent_id, token, position) AS (
+  SELECT
+    task_id,
+    agent_id,
+    'https://github.com/' || owner || '/' || repo || '/' || remainder,
+    instr(
+      lower('https://github.com/' || owner || '/' || repo || '/' || remainder),
+      '/pull/'
+    ) + length('/pull/')
+  FROM token_segments
+  WHERE owner NOT GLOB '*[^A-Za-z0-9._-]*'
+    AND repo NOT GLOB '*[^A-Za-z0-9._-]*'
+    AND owner NOT IN ('.', '..')
+    AND repo NOT IN ('.', '..')
+    AND lower(remainder) GLOB 'pull/[0-9]*'
+
+  UNION ALL
+
+  SELECT task_id, agent_id, token, position + 1
+  FROM digit_scan
+  WHERE substr(token, position, 1) GLOB '[0-9]'
+),
+canonical_pull_requests(task_id, agent_id, url) AS (
+  SELECT
+    task_id,
+    agent_id,
+    substr(token, 1, max(position) - 1)
+  FROM digit_scan
+  GROUP BY task_id, agent_id, token
+  HAVING substr(token, max(position), 1) = ''
+    OR substr(token, max(position), 1) IN ('/', '?', '#')
+    OR trim(substr(token, max(position)), ')]},.;:!') = ''
+)
+INSERT INTO task_attachments (
+  id,
+  task_id,
+  agent_id,
+  name,
+  kind,
+  url,
+  provider_id,
+  provider_key,
+  capabilities,
+  intent,
+  description,
+  is_primary
+)
+SELECT
+  lower(hex(randomblob(4))) || '-' ||
+    lower(hex(randomblob(2))) || '-4' ||
+    substr(lower(hex(randomblob(2))), 2) || '-' ||
+    substr('89ab', abs(random()) % 4 + 1, 1) ||
+    substr(lower(hex(randomblob(2))), 2) || '-' ||
+    lower(hex(randomblob(6))),
+  candidate.task_id,
+  candidate.agent_id,
+  'GitHub pull request #' || substr(candidate.url, instr(lower(candidate.url), '/pull/') + 6),
+  'url',
+  candidate.url,
+  'github',
+  candidate.url,
+  json_object('_agentSwarmGeneratedBy', 'task-pull-request-recorder'),
+  'task-deliverable',
+  'Pull request shipped by this task',
+  0
+FROM canonical_pull_requests candidate
+WHERE NOT EXISTS (
+    SELECT 1
+    FROM task_attachments existing
+    WHERE existing.task_id = candidate.task_id
+      AND existing.kind = 'url'
+      AND EXISTS (
+        SELECT 1
+        FROM (
+          SELECT substr(lower(candidate.url), 9) AS base_url
+          UNION ALL
+          SELECT lower(candidate.url)
+          UNION ALL
+          SELECT 'http://' || substr(lower(candidate.url), 9)
+        ) forms
+        WHERE lower(trim(
+                existing.url,
+                (SELECT value FROM whitespace_characters
+                 WHERE position = (SELECT max(position) FROM whitespace_delimiters))
+              )) = forms.base_url
+          OR (
+            substr(lower(trim(
+              existing.url,
+              (SELECT value FROM whitespace_characters
+               WHERE position = (SELECT max(position) FROM whitespace_delimiters))
+            )), 1, length(forms.base_url)) = forms.base_url
+            AND unicode(substr(lower(trim(
+              existing.url,
+              (SELECT value FROM whitespace_characters
+               WHERE position = (SELECT max(position) FROM whitespace_delimiters))
+            )), length(forms.base_url) + 1, 1)) IN (
+              9, 10, 13, 32, 33, 34, 35, 39, 41, 44, 46, 47, 58, 59, 62, 63, 93, 96, 125
+            )
+          )
+      )
+  )
+GROUP BY candidate.task_id, lower(candidate.url);

package/src/be/migrations/136_task_requester_provenance.sql

@@ -0,0 +1,37 @@
+-- Record whether requester attribution was copied from a parent task. This is
+-- server-owned provenance: callers may set requestedByUserId, but never this
+-- marker.
+ALTER TABLE agent_tasks
+ADD COLUMN requestedByUserIdInherited INTEGER NOT NULL DEFAULT 0
+CHECK (requestedByUserIdInherited IN (0, 1));
+
+-- Migration 127 copied requester ids through task trees before provenance was
+-- stored. Reconstruct only the historical case that affects human-free
+-- attribution: stale requesters propagated below heartbeat roots. An audited
+-- `created_by` is durable evidence of an original human handoff and stops the
+-- reconstruction. Legacy unaudited same-user handoffs are indistinguishable,
+-- so this deliberately avoids guessing across ordinary human task trees.
+WITH RECURSIVE inherited_from_heartbeat(id, requester, depth) AS (
+  SELECT id, requestedByUserId, 0
+  FROM agent_tasks
+  WHERE requestedByUserId IS NOT NULL
+    AND (
+      IFNULL(taskType, '') IN ('heartbeat', 'heartbeat-checklist', 'boot-triage')
+      OR IFNULL(tags, '[]') LIKE '%"heartbeat"%'
+    )
+
+  UNION ALL
+
+  SELECT child.id, lineage.requester, lineage.depth + 1
+  FROM agent_tasks AS child
+  JOIN inherited_from_heartbeat AS lineage ON child.parentTaskId = lineage.id
+  WHERE child.requestedByUserId = lineage.requester
+    AND child.created_by IS NULL
+)
+UPDATE agent_tasks
+SET requestedByUserIdInherited = 1
+WHERE id IN (
+  SELECT id
+  FROM inherited_from_heartbeat
+  WHERE depth > 0
+);

package/src/be/migrations/137_memory_retrieval_composite_index.sql

@@ -0,0 +1 @@
+CREATE INDEX IF NOT EXISTS idx_memret_memory_agent_retrieved_at ON memory_retrieval(memoryId, agentId, retrievedAt);

package/src/be/migrations/runner.ts

@@ -226,21 +226,27 @@ export function runMigrations(db: Database): void {
     }
 
     // Apply migration in a transaction
-    console.debug(`[migrations] Applying: ${migration.name}`);
+    console.log(`[migrations] Applying: ${migration.name}`);
     const start = performance.now();
 
-    db.transaction(() => {
-      db.exec(migration.sql);
-      db.run("INSERT INTO _migrations (version, name, applied_at, checksum) VALUES (?, ?, ?, ?)", [
-        migration.version,
-        migration.name,
-        new Date().toISOString(),
-        migration.checksum,
-      ]);
-    })();
+    try {
+      db.transaction(() => {
+        db.exec(migration.sql);
+        db.run(
+          "INSERT INTO _migrations (version, name, applied_at, checksum) VALUES (?, ?, ?, ?)",
+          [migration.version, migration.name, new Date().toISOString(), migration.checksum],
+        );
+      })();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `[migrations] Migration ${migration.version} (${migration.name}) failed: ${detail}`,
+        { cause: error },
+      );
+    }
 
     const elapsed = (performance.now() - start).toFixed(1);
-    console.debug(`[migrations] Applied: ${migration.name} (${elapsed}ms)`);
+    console.log(`[migrations] Applied: ${migration.name} (${elapsed}ms)`);
   }
 
   db.run("PRAGMA foreign_keys = ON");