@desplega.ai/agent-swarm 2.4.1 → 2.4.2

package/src/http/status.ts

@@ -197,7 +197,7 @@ export type AutomationStatus = z.infer<typeof AutomationStatusSchema>;
  * - `broken`  — harness or workers blocking (creds missing, no live workers ever).
  * - `degraded` — at least one optional integration `unverified`/`configured`
  *                 while another is configured, OR harness creds present but
- *                 never tested (`configured`).
+ *                 the latest live test failed or never ran (`configured`).
  * - `ok`       — harness + workers `verified`; no integration left in
  *                 `configured` state.
  */
@@ -237,12 +237,12 @@ export const TestConnectionResponseSchema = z.object({
 /**
  * Read all worker reports for a given harness provider and reduce them to a
  * single milestone-grade rollup. Reports are joined from `agents.cred_status`
- * (migration 055) — no provider-adapter code runs here.
+ * (migration 055) — no provider-adapter code runs here. Offline agents are
+ * excluded: `workers` and `reports` count online agents only.
  *
- * `verified` ⇐ at least one worker has `liveTest.ok === true` and the test
- *   is fresher than `getCredVerifyTtlMs()`.
+ * `verified` ⇐ the provider's most recent live test passed, whatever its age.
  * `configured` ⇐ at least one worker has `ready: true` (presence check
- *   passed) but no fresh passing live test.
+ *   passed) but the latest live test failed or none ever ran.
  * `unverified` ⇐ no worker reported, or all reporting workers have
  *   `ready: false`.
  */
@@ -258,14 +258,6 @@ export interface CredRollup {
   oldestReportAgeMs: number | null;
 }
 
-function getCredVerifyTtlMs(): number {
-  const raw = process.env.SWARM_VERIFY_TTL_MS;
-  if (!raw) return 3_600_000; // 1h default — matches pre-refactor behavior.
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed <= 0) return 3_600_000;
-  return parsed;
-}
-
 /**
  * Compatibility stub. The pre-refactor in-memory test-connection cache is
  * gone — credential state now lives on agent rows. Tests still call this
@@ -276,7 +268,11 @@ export function _resetTestConnectionCache(): void {
 }
 
 export async function rollupCredStatusForProvider(provider: string): Promise<CredRollup> {
-  const agents = await listAgentsWithCredStatusByProvider(provider);
+  // An offline agent keeps its last cred_status after `/close`, so only online
+  // agents decide the rollup; a stale failure must not override a live pass.
+  const agents = (await listAgentsWithCredStatusByProvider(provider)).filter(
+    (a) => a.status !== "offline",
+  );
   const reports = agents.map((a) => a.credStatus).filter((s): s is AgentCredStatus => s != null);
 
   if (reports.length === 0) {
@@ -291,23 +287,19 @@ export async function rollupCredStatusForProvider(provider: string): Promise<Cre
     };
   }
 
-  // Pick the most-recent passing live test, if any, then fall back to
-  // most-recent live test of any kind.
-  const ttl = getCredVerifyTtlMs();
+  // The provider's latest live test decides, whatever its age. Workers run the
+  // test at boot and re-run it only when credentials change, so an old pass is
+  // the normal state of a long-running worker, not a missing check.
   const now = Date.now();
-  const isFreshPassingReport = (report: AgentCredStatus): boolean =>
-    report.liveTest?.ok === true && now - (report.liveTest?.testedAt ?? 0) < ttl;
-  const passing = reports
-    .filter(isFreshPassingReport)
-    .sort((a, b) => (b.liveTest?.testedAt ?? 0) - (a.liveTest?.testedAt ?? 0));
+  const passing = reports.filter((r) => r.liveTest?.ok === true);
   const anyLive = reports
     .filter((r) => r.liveTest != null)
     .sort((a, b) => (b.liveTest?.testedAt ?? 0) - (a.liveTest?.testedAt ?? 0));
-  const latestLiveTest = passing[0]?.liveTest ?? anyLive[0]?.liveTest ?? null;
+  const latestLiveTest = anyLive[0]?.liveTest ?? null;
 
   const anyReady = reports.some((r) => r.ready);
   const state: CredRollupState =
-    passing.length > 0 ? "verified" : anyReady ? "configured" : "unverified";
+    latestLiveTest?.ok === true ? "verified" : anyReady ? "configured" : "unverified";
 
   // For UI hints, pick the most-recent missing[] from a not-ready report.
   const latestNotReady = reports
@@ -349,23 +341,19 @@ function buildIdentity(): StatusIdentity {
 // ─── Setup milestones ────────────────────────────────────────────────────────
 
 /**
- * Compose a one-line, per-provider description for the milestone hint.
- * Examples:
- *   "1 worker · live test ok"
- *   "2 workers · presence ok, awaiting live test"
- *   "missing: OPENAI_API_KEY"
+ * One short phrase for a provider that needs attention, e.g. "live test
+ * failed" or "missing: OPENAI_API_KEY". A verified provider gets none.
  */
-function describeRoll(roll: CredRollup): string {
+function describeRoll(roll: CredRollup): string | null {
+  if (roll.state === "verified") return null;
   if (roll.workers === 0) return "no workers";
-  if (roll.reports === 0) {
-    return `${roll.workers} ${roll.workers === 1 ? "worker" : "workers"}, none reported`;
+  if (roll.reports === 0) return "no credential report";
+  if (roll.state === "configured") {
+    return roll.latestLiveTest?.ok === false ? "live test failed" : "not live-tested";
   }
-  const w = `${roll.workers} ${roll.workers === 1 ? "worker" : "workers"}`;
-  if (roll.state === "verified") return `${w} · live test ok`;
-  if (roll.state === "configured") return `${w} · presence ok, awaiting live test`;
   return roll.latestMissing.length > 0
     ? `missing: ${roll.latestMissing.join(", ")}`
-    : "creds blocked";
+    : "credentials blocked";
 }
 
 /**
@@ -375,7 +363,7 @@ function describeRoll(roll: CredRollup): string {
  * workers via migration 054/055), runs the cred-status rollup per provider,
  * and aggregates:
  *
- *   `verified`  — every provider in the fleet has a fresh passing live test.
+ *   `verified`  — every provider's latest live test passed.
  *   `configured` — every provider has at least `configured`, ≥1 not verified.
  *   `unverified` — any provider has `unverified` (no reports OR all-blocked).
  *
@@ -398,13 +386,25 @@ async function harnessMilestone(): Promise<SetupMilestone> {
   }
 
   const perProvider: { provider: z.infer<typeof ProviderNameSchema>; roll: CredRollup }[] = [];
+  let recognised = 0;
   for (const { provider } of fleet) {
     const parsed = ProviderNameSchema.safeParse(provider);
     if (!parsed.success) continue;
-    perProvider.push({
-      provider: parsed.data,
-      roll: await rollupCredStatusForProvider(parsed.data),
-    });
+    recognised++;
+    const roll = await rollupCredStatusForProvider(parsed.data);
+    // A provider whose agents are all offline has nothing live to judge.
+    if (roll.workers === 0) continue;
+    perProvider.push({ provider: parsed.data, roll });
+  }
+
+  if (recognised > 0 && perProvider.length === 0) {
+    return {
+      id: "harness",
+      label: "Harness configured",
+      state: "unverified",
+      hint: "No agents online. Start a worker to run a live credential test.",
+      action_url: "/agents",
+    };
   }
 
   if (perProvider.length === 0) {
@@ -424,7 +424,13 @@ async function harnessMilestone(): Promise<SetupMilestone> {
       ? "configured"
       : "unverified";
 
-  const hint = perProvider.map((p) => `${p.provider}: ${describeRoll(p.roll)}`).join(" · ");
+  const hint =
+    perProvider
+      .flatMap((p) => {
+        const phrase = describeRoll(p.roll);
+        return phrase ? [`${p.provider}: ${phrase}`] : [];
+      })
+      .join(" · ") || undefined;
   const singleProvider = perProvider.length === 1 ? perProvider[0]?.provider : undefined;
 
   return {
@@ -848,7 +854,7 @@ export async function handleStatus(
     if (roll.workers === 0) {
       json(res, {
         ok: false,
-        error: `No workers registered with HARNESS_PROVIDER=${provider}. Start a worker — its boot loop will run a live test and report it here.`,
+        error: `No online workers with HARNESS_PROVIDER=${provider}. Start a worker — its boot loop will run a live test and report it here.`,
         latency_ms: 0,
       });
       return true;

package/src/http/tasks.ts

@@ -20,6 +20,7 @@ import {
   getSteeringMessagesForTask,
   getTaskAttachments,
   getTaskById,
+  getTaskLineage,
   getTasksCount,
   markSteeringDelivered,
   markSteeringHandled,
@@ -29,6 +30,7 @@ import {
   resumeTask,
   settleSupersededTaskDependents,
   supersedeTask,
+  TASK_LINEAGE_LIMITS,
   updateAgentStatusFromCapacity,
   updateTaskClaudeSessionId,
   updateTaskProgress,
@@ -578,6 +580,33 @@ const getTask = route({
   },
 });
 
+const getTaskLineageRoute = route({
+  method: "get",
+  path: "/api/tasks/{id}/lineage",
+  pattern: ["api", "tasks", null, "lineage"],
+  session: { taskParam: "id" },
+  summary: "Get the tree a task belongs to (ancestors and descendants)",
+  description: `Follows \`parentTaskId\` up to the topmost ancestor, then returns every descendant of that root as slim task rows, the task's own subtree first. Bounded: at most ${TASK_LINEAGE_LIMITS.maxAncestors} hops up, \`maxDepth\` levels down and about twice \`maxNodes\` rows; \`truncated\` is true when any task in the tree is missing from the response.`,
+  tags: ["Tasks"],
+  params: z.object({ id: z.string() }),
+  query: z.object({
+    maxNodes: z.coerce.number().int().min(1).max(TASK_LINEAGE_LIMITS.maxNodes).optional(),
+    maxDepth: z.coerce.number().int().min(1).max(TASK_LINEAGE_LIMITS.maxDepth).optional(),
+  }),
+  responses: {
+    200: {
+      description: "The lineage tree as a flat list linked by `parentTaskId`",
+      schema: z.object({
+        rootTaskId: z.string(),
+        tasks: z.array(AgentTaskSummarySchema.extend({ workflowRunId: z.string().optional() })),
+        truncated: z.boolean(),
+      }),
+    },
+    403: { description: "A user caller cannot read the task's session" },
+    404: { description: "Task not found" },
+  },
+});
+
 const updateTaskProgressRoute = route({
   method: "post",
   path: "/api/tasks/{id}/progress",
@@ -1121,6 +1150,8 @@ export async function handleTasks(
           offeredTo: parsed.body.offeredTo || undefined,
           dir: parsed.body.dir || undefined,
           parentTaskId: parsed.body.parentTaskId || undefined,
+          // Human chat starts a new output contract; agent children keep inheriting.
+          inheritParentOutputSchema: principal.kind === "agent",
           source: parsed.body.source || "api",
           outputSchema: parsed.body.outputSchema || undefined,
           contextKey: parsed.body.contextKey || undefined,
@@ -1615,6 +1646,22 @@ export async function handleTasks(
     return true;
   }
 
+  if (getTaskLineageRoute.match(req.method, pathSegments)) {
+    const parsed = await getTaskLineageRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    // Every task in the tree shares the session root, so the path posture covers them all.
+    const lineage = await getTaskLineage(parsed.params.id, {
+      maxNodes: parsed.query.maxNodes,
+      maxDepth: parsed.query.maxDepth,
+    });
+    if (!lineage) {
+      jsonError(res, "Task not found", 404);
+      return true;
+    }
+    getTaskLineageRoute.respond(res, 200, lineage);
+    return true;
+  }
+
   if (updateTaskProgressRoute.match(req.method, pathSegments)) {
     const parsed = await updateTaskProgressRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/providers/acp-targets.ts

@@ -359,7 +359,7 @@ const copilotTargetProfile: AcpTargetProfile = {
   },
 };
 
-/** Qwen Code's `--auth-type` choices (0.25.2). `qwen-oauth` needs a browser, so it is left out. */
+/** Qwen Code's `--auth-type` choices (0.25.3). `qwen-oauth` needs a browser, so it is left out. */
 const QWEN_AUTH_TYPES = ["openai", "openai-responses", "anthropic", "gemini", "vertex-ai"] as const;
 
 // Qwen Code is a Gemini CLI fork: QWEN_SYSTEM_MD replaces its built-in prompt

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1792368068-g91990d";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792411243-gb8cffc";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";

package/src/telemetry.ts

@@ -3,7 +3,7 @@
  *
  * - Opt-out via ANONYMIZED_TELEMETRY=false
  * - Fire-and-forget: never throws, never blocks
- * - No DB and no external services (global fetch + node:crypto only)
+ * - No DB and no external services (global fetch + built-in APIs only)
  * - Importable from both API server and workers
  * - Every event is schema_version 2: a top-level `context` identity envelope
  *   plus properties typed against the proxy's event catalog
@@ -11,6 +11,7 @@
  *   catalog fails `tsc`, and the proxy rejects it at ingest.
  */
 import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
 import pkg from "../package.json";
 import { isSlackConfigured } from "./slack/config";
 import {
@@ -591,14 +592,24 @@ function isCloudDeployment(): boolean {
   return raw === "true" || raw === "1";
 }
 
-function getTelemetryEnvironment(): string {
+let cachedIsGitCheckout: boolean | undefined;
+
+export function getTelemetryEnvironment(packageRoot = new URL("../", import.meta.url)): string {
   const explicit = process.env.DESPLEGA_TELEMETRY_ENV?.trim();
   if (explicit) return explicit;
 
   // Do not default from NODE_ENV: shipped Bun/npm installs can report
   // "development" even when the operator did not choose a telemetry cohort.
   if (getNodeEnv() === "test") return "test";
-  return "production";
+  // Git checkouts (including worktrees) are development; shipped packages omit .git.
+  if (cachedIsGitCheckout === undefined) {
+    try {
+      cachedIsGitCheckout = existsSync(new URL(".git", packageRoot));
+    } catch {
+      cachedIsGitCheckout = false;
+    }
+  }
+  return cachedIsGitCheckout ? "development" : "production";
 }
 
 /**
@@ -741,6 +752,7 @@ function emit(
  * Do not call from production code.
  */
 export function _resetTelemetryStateForTests(): void {
+  cachedIsGitCheckout = undefined;
   installationId = null;
   installedAt = null;
   ingestObserver = null;

package/src/tests/app-row-tools.test.ts

@@ -217,6 +217,31 @@ test("rejects invalid filters, sorts, values, source projections, join keys, and
   expect((await call("app-rows-list", {}, "")).isError).toBe(true);
 });
 
+test("app-rows-list rejects equals on a json column, like REST filters and named queries", async () => {
+  const jsonApp = await createApp({
+    name: "Row tools json",
+    definition: {
+      ...definition,
+      models: { note: { columns: { title: { kind: "string" }, payload: { kind: "json" } } } },
+    },
+  });
+  const created = await call("app-row-create", {
+    appId: jsonApp.id,
+    values: { title: "json", payload: { x: 1 } },
+  });
+  expect(created.isError).not.toBe(true);
+
+  const listed = await call("app-rows-list", { appId: jsonApp.id, equals: { payload: "x" } });
+  expect(listed.isError).toBe(true);
+  expect(listed.structuredContent).toMatchObject({
+    issues: [{ path: "equals.payload", message: "json columns cannot be filtered" }],
+  });
+  // A scalar column on the same model still filters.
+  const byTitle = await call("app-rows-list", { appId: jsonApp.id, equals: { title: "json" } });
+  expect(byTitle.isError).not.toBe(true);
+  expect(byTitle.structuredContent.total).toBe(1);
+});
+
 test("enforces row, bulk, filter, and limit caps before writing", async () => {
   await expect(
     call("app-rows-create", { rows: Array.from({ length: 501 }, () => ({ title: "too-many" })) }),