@humwick/server 0.130.1 → 0.130.2

package/src/db/orchestrators.ts

@@ -1,9 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
-import { randomUUID } from "node:crypto";
-import { isRecord, stringValue, isMechanicalMessageKind, orchestratorAgentId } from "@humwick/sdk";
-import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
+import { stringValue, orchestratorAgentId } from "@humwick/sdk";
+import { VERSION } from "../config.ts";
 import { parseJson } from "../utils";
-import { isLiveIsolatedWorkspace } from "../workspace-phase";
 import {
   CONTRACT_REQUIREMENTS,
   contractCompatibility,
@@ -12,77 +10,13 @@ import {
   parseRuntimePackage,
   type RuntimeContracts,
 } from "../contracts";
-import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
-import { matchAgents } from "../agent-ref";
+import { STALE_TTL_MS } from "../config";
 import { deleteAgent, heartbeat, upsertAgent, upsertAgentInternal, type UpsertAgentTxResult } from "./agents.ts";
 import { evictPendingPresence } from "./presence-buffer.ts";
 import { getDb, writeTransaction } from "./connection.ts";
 import { fencedColumnSql, nextLifecycleSeq } from "./lifecycle-seq.ts";
 import { electWorkspaceStewards, emitWorkspaceUpsert, getWorkspace, upsertWorkspaceFromManagedAgentRow, type WorkspaceUpsertResult } from "./workspaces.ts";
-import type {
-  AgentCard,
-  ActivityEvent,
-  ActivityEventInput,
-  AgentKind,
-  AgentSessionGuard,
-  Artifact,
-  ArtifactBlob,
-  ArtifactKind,
-  ArtifactLink,
-  ArtifactSensitivity,
-  ArtifactVisibility,
-  AttachmentRef,
-  ChannelBinding,
-  ChannelBindingMode,
-  ChannelRouteTarget,
-  ChatHistoryImport,
-  ChatHistoryImportEntry,
-  ChannelSummary,
-  ChannelTargetHealth,
-  CreatePairInput,
-  HealthCheck,
-  HealthReport,
-  ManagedAgent,
-  ManagedSessionExitDiagnostics,
-  Message,
-  MessageDeliveryAttempt,
-  MessageDeliveryStatus,
-  HostDaemonSample,
-  Orchestrator,
-  OrchestratorHealth,
-  OrchestratorRuntimeInput,
-  OrchestratorStatus,
-  OrchestratorUpgradeState,
-  PairActionInput,
-  PairMessageInput,
-  PairSession,
-  PairStatus,
-  RegisterAgentInput,
-  ReplyObligation,
-  RegisterOrchestratorInput,
-  SendMessageInput,
-  PollQuery,
-  SpawnApprovalMode,
-  SpawnProvider,
-  Task,
-  TaskEvent,
-  TaskSeverity,
-  TaskStatus,
-  IntegrationEventInput,
-  IntegrationSummary,
-  IntegrationTaskStats,
-  InboxDraft,
-  InboxState,
-  InboxThreadState,
-  ContextSnapshot,
-  ContextState,
-  ProviderCapabilities,
-  QueuedSpawn,
-  TaskStatusInput,
-  WorkspaceMetadata,
-  WorkspaceRecord,
-  WorkspaceStatus,
-} from "../types";
+import type { ManagedAgent, HostDaemonSample, Orchestrator, OrchestratorHealth, OrchestratorRuntimeInput, OrchestratorStatus, OrchestratorUpgradeState, RegisterAgentInput, RegisterOrchestratorInput, SpawnProvider, QueuedSpawn } from "../types";
 
 // --- Orchestrators ---
 
@@ -185,7 +119,6 @@ export function setOrchestratorUpgradeState(id: string, state: OrchestratorUpgra
   return getOrchestrator(id);
 }
 
-
 function orchestratorHealth(version: string | undefined, compatibility: ReturnType<typeof contractCompatibility>): OrchestratorHealth {
   const issues: OrchestratorHealth["issues"] = [];
   if (!version) {
@@ -452,7 +385,6 @@ export function reportOrchestratorRosterRow(id: string, agents: ManagedAgent[],
   return { orchestrator: getOrchestrator(id), rosterChanged: true, workspaces };
 }
 
-
 export function deleteOrchestrator(id: string): boolean {
   const orch = getOrchestrator(id);
   if (!orch) return false;

package/src/db/pairs.ts

@@ -1,17 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { isRecord, stringValue, isMechanicalMessageKind } from "@humwick/sdk";
-import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
-import { parseJson } from "../utils";
-import { isLiveIsolatedWorkspace } from "../workspace-phase";
-import {
-  CONTRACT_REQUIREMENTS,
-  contractCompatibility,
-  parseRuntimeCapabilities,
-  parseRuntimeContracts,
-  parseRuntimePackage,
-  type RuntimeContracts,
-} from "../contracts";
-import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
+import { DAY_MS } from "../config";
 import { matchAgents } from "../agent-ref";
 import { getAgent, listAgents } from "./agents.ts";
 import { getDb } from "./connection.ts";

package/src/db/project-profile-instructions.ts

@@ -0,0 +1,50 @@
+import type { ProjectProfileInstructions } from "../types";
+import { getDb, ValidationError } from "./connection";
+import { promptHistory, writePromptVersion } from "./prompt-versions";
+import type { WriterOpContext, WriterOpSpec } from "./write-ops";
+
+export const PROJECT_PROFILE_INSTRUCTIONS_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS project_profile_instructions (
+    project_id TEXT NOT NULL REFERENCES projects(id), profile TEXT NOT NULL,
+    slug TEXT NOT NULL UNIQUE, PRIMARY KEY (project_id, profile)
+  );
+  CREATE INDEX IF NOT EXISTS project_profile_instructions_profile ON project_profile_instructions(profile);
+`;
+
+export interface ProjectProfileKey { projectId: string; profile: string }
+const columns = `p.project_id AS projectId, p.profile, coalesce(h.template, '') AS template,
+  coalesce(h.version, 0) AS version, coalesce(h.updated_at, 0) AS updatedAt`;
+
+export function getProjectProfileInstructions(key: ProjectProfileKey): ProjectProfileInstructions {
+  return getDb().query(`SELECT ${columns} FROM project_profile_instructions p
+    LEFT JOIN prompt_heads h ON h.slug = p.slug WHERE p.project_id = ? AND p.profile = ?`)
+    .get(key.projectId, key.profile) as ProjectProfileInstructions | null
+    ?? { ...key, template: "", version: 0, updatedAt: 0 };
+}
+
+function instructionSlug(key: ProjectProfileKey): string {
+  return `project-profile:${JSON.stringify([key.projectId, key.profile])}`;
+}
+
+export function writeProjectProfileInstructions(args: ProjectProfileKey & {
+  template?: string; expectedVersion: number; actor: string; reason?: string; restoreVersion?: number;
+}, now: number): ProjectProfileInstructions {
+  if (!getDb().query("SELECT 1 FROM projects WHERE id = ?").get(args.projectId)) throw new ValidationError("project not found");
+  getDb().query("INSERT OR IGNORE INTO project_profile_instructions VALUES (?, ?, ?)").run(args.projectId, args.profile, instructionSlug(args));
+  writePromptVersion({ ...args, slug: instructionSlug(args), action: args.restoreVersion === undefined ? undefined : "restore" }, now);
+  return getProjectProfileInstructions(args);
+}
+
+export const PROJECT_PROFILE_INSTRUCTION_READ_OPS = {
+  "projectProfileInstructions.get": getProjectProfileInstructions,
+  "projectProfileInstructions.history": (key: ProjectProfileKey) => promptHistory(instructionSlug(key)),
+  "projectProfileInstructions.list": (key: { projectId?: string; profile?: string }) => getDb().query(`SELECT ${columns}
+    FROM project_profile_instructions p LEFT JOIN prompt_heads h ON h.slug = p.slug
+    WHERE (?1 IS NULL OR p.project_id = ?1) AND (?2 IS NULL OR p.profile = ?2)`)
+    .all(key.projectId ?? null, key.profile ?? null) as ProjectProfileInstructions[],
+};
+
+export const PROJECT_PROFILE_INSTRUCTION_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
+  "projectProfileInstructions.write": { offLoop: true, idempotent: false,
+    fn: (args: Parameters<typeof writeProjectProfileInstructions>[0], ctx: WriterOpContext) => writeProjectProfileInstructions(args, ctx.now) },
+};

package/src/db/prompt-versions.ts

@@ -5,6 +5,7 @@ import { PROFILE_PROMPT_SCHEMA_SQL } from "./prompt-version-migration";
 export { migratePromptVersions, promptLegacyHistory } from "./prompt-version-migration";
 import { bundledPrompt, hasBundledPrompt, BUNDLED_PROMPT_MANIFEST, profilePromptSlug, versionedPromptsEnabled } from "../versioned-prompts";
 import { getDb, ValidationError } from "./connection";
+import { validateProjectProfileInstructionText } from "../project-profile-instruction-text";
 
 export const PROMPT_VERSIONS_SCHEMA_SQL = PROFILE_PROMPT_SCHEMA_SQL + `
   CREATE TABLE IF NOT EXISTS prompt_heads (
@@ -32,7 +33,10 @@ export function promptVersionMetadata(slug: string): Partial<PromptTemplate> | u
   if (!versionedPromptsEnabled()) return;
   const current = head(slug);
   const bundle = hasBundledPrompt(slug) ? bundledPrompt(slug) : undefined;
-  if (!current && !bundle) return;
+  if (!current && !bundle) {
+    if (getDb().query("SELECT 1 FROM project_profile_instructions WHERE slug = ?").get(slug)) return { template: "", version: 0, updatedAt: 0, source: "canonical" };
+    return;
+  }
   return {
     template: current?.template ?? bundle!.template,
     version: current?.version ?? 0, seedHash: current?.seed_hash ?? null,
@@ -50,7 +54,8 @@ export function promptHistory(slug: string): PromptRevision[] {
 function checkedPromptHead(args: Pick<PromptWrite, "slug" | "expectedVersion">, current = head(args.slug)): Head | null {
   if (!versionedPromptsEnabled()) throw new ValidationError("versioned prompt not found");
   const mapped = !current && !hasBundledPrompt(args.slug) ? getDb().query(`SELECT 1 FROM prompt_profile_slots
-    WHERE system_slug = ?1 OR EXISTS (SELECT 1 FROM json_each(append_slugs) WHERE value = ?1) LIMIT 1`).get(args.slug) : true;
+    WHERE system_slug = ?1 OR EXISTS (SELECT 1 FROM json_each(append_slugs) WHERE value = ?1)
+    UNION ALL SELECT 1 FROM project_profile_instructions WHERE slug = ?1 LIMIT 1`).get(args.slug) : true;
   if (!mapped) throw new ValidationError("versioned prompt not found");
   if (!Number.isSafeInteger(args.expectedVersion) || args.expectedVersion! < 0) throw new ValidationError(`expectedVersion for ${args.slug} must be a non-negative integer`);
   if (args.expectedVersion !== (current?.version ?? 0)) throw new PromptVersionConflictError(JSON.stringify({ slug: args.slug, ...promptVersionMetadata(args.slug), version: current?.version ?? 0 }));
@@ -70,6 +75,8 @@ function appendPromptVersion(args: PromptWrite, current: Head | null, now: numbe
   if (args.action === "restore" && !restored) throw new ValidationError("prompt revision not found");
   const template = args.action === "adopt" ? bundle!.template : restored?.template ?? args.template;
   if (template === undefined) throw new ValidationError("template required");
+  const projectProfile = getDb().query("SELECT project_id, profile FROM project_profile_instructions WHERE slug = ?").get(args.slug) as { project_id: string; profile: string } | null;
+  if (projectProfile) validateProjectProfileInstructionText(template, `project ${projectProfile.project_id} profile ${projectProfile.profile} instructions`);
   const seedHash = args.action === "adopt" ? bundle!.hash : restored ? restored.seedHash ?? null : current?.seed_hash ?? null;
   const version = (current?.version ?? 0) + 1;
   getDb().query("INSERT INTO prompt_revisions VALUES (?, ?, ?, ?, ?, ?, ?)")

package/src/db/provider-config-history.ts

@@ -13,11 +13,16 @@ function redactionPatch(env: unknown, nextEnv?: Record<string, unknown>): Record
   ).map(([key]) => [key, SECRET_VALUE_MASK]));
 }
 
-/** Update and delete archive through the same seam so neither persists credentials (#3540). */
-export function recordConfigHistory(entry: ConfigEntry, changedAt: string, changedBy?: string, nextValue?: unknown): void {
-  const value = entry.namespace === "provider-config" && isRecord(entry.value) && isRecord(entry.value.env)
+/** A config value with its provider credentials masked: what any copy outside the live row stores (#3540). */
+export function credentialFreeConfigValue(entry: ConfigEntry, nextValue?: unknown): unknown {
+  return entry.namespace === "provider-config" && isRecord(entry.value) && isRecord(entry.value.env)
     ? { ...entry.value, env: { ...entry.value.env, ...redactionPatch(entry.value.env, isRecord(nextValue) && isRecord(nextValue.env) ? nextValue.env : undefined) } }
     : entry.value;
+}
+
+/** Update and delete archive through the same seam so neither persists credentials (#3540). */
+export function recordConfigHistory(entry: ConfigEntry, changedAt: string, changedBy?: string, nextValue?: unknown): void {
+  const value = credentialFreeConfigValue(entry, nextValue);
   getDb().query(`
     INSERT INTO config_history (namespace, key, value, version, changed_at, changed_by)
     VALUES (?, ?, ?, ?, ?, ?)

package/src/db/provider-model-seed.ts

@@ -0,0 +1,34 @@
+import { providerCatalogList } from "@humwick/sdk/provider-catalog";
+import { getDb } from "./connection";
+
+const SEED_KEY = "provider-model-db-catalog-v1";
+
+/** One migration backfills missing rows; later boots and releases leave the database alone. */
+export function reconcileProviderModelSeed(): void {
+  const db = getDb();
+  if (db.query("SELECT 1 FROM config WHERE namespace = 'system' AND key = ?").get(SEED_KEY)) return;
+  db.transaction(() => {
+    seedProviderModelOverrides("seed:db-catalog-v1");
+    db.query("INSERT INTO config (namespace, key, value, version, updated_at, updated_by) VALUES ('system', ?, 'true', 1, ?, 'server-startup')")
+      .run(SEED_KEY, Date.now());
+  })();
+}
+
+/** Insert-only migration: operator edits, disabled entries and tombstones always win. */
+export function seedProviderModelOverrides(stamp: string, now = Date.now()): { inserted: number } {
+  const db = getDb();
+  const insert = db.query(`INSERT INTO provider_model_overrides (provider, alias, entry, deleted, disabled, updated_at, updated_by)
+    VALUES (?, ?, ?, 0, ?, ?, ?) ON CONFLICT(provider, alias) DO NOTHING`);
+  const defaultModel = db.query(`INSERT INTO provider_model_defaults (provider, alias, updated_at, updated_by)
+    VALUES (?, ?, ?, ?) ON CONFLICT(provider) DO NOTHING`);
+  return db.transaction(() => {
+    let inserted = 0;
+    for (const provider of providerCatalogList()) {
+      for (const model of provider.models) {
+        inserted += insert.run(provider.provider, model.alias, JSON.stringify(model), model.disabled ? 1 : 0, now, stamp).changes;
+      }
+      if (provider.defaultModel) defaultModel.run(provider.provider, provider.defaultModel, now, stamp);
+    }
+    return { inserted };
+  })();
+}

package/src/db/read-op-marshaling-fixtures.ts

@@ -101,6 +101,9 @@ export const KERNEL_ENTITY_CATALOG = {
 } as const;
 
 export const READ_OP_MARSHALING_FIXTURES: ReadOpFixtures = {
+  "projectProfileInstructions.get": { args: { projectId: "missing", profile: "worker" } },
+  "projectProfileInstructions.history": { args: { projectId: "missing", profile: "worker" } },
+  "projectProfileInstructions.list": { args: { projectId: "missing" } },
   "planGraph.import.preview": { args: { scope: "import-fixture", actor: "system", expectedVersion: 0, requestKey: "preview", documentHash: "h", requestHash: "h", newPlanId: "plan-fixture", executions: { a: { workflow: "build-review" } }, document: { version: 1, key: "fixture", revision: "r1", title: "Fixture", acceptance: [{ id: "works", text: "Works" }], tasks: [{ key: "a", title: "A", intent: "Build A" }] } } },
   "guides.search": { args: { query: "violet", guides: [{ id: "workflows", title: "Workflows", summary: "Build and review", tags: ["review"], body: "A violet checksum", revision: "fixture-revision" }] } },
   "commands.latestByCorrelation": { args: { type: "scheduler.cancel", correlationId: "fixture" } },
@@ -164,6 +167,7 @@ export const READ_OP_MARSHALING_FIXTURES: ReadOpFixtures = {
 
   // --- channels / projects / teams / hosts --------------------------------------------------------
   "channels.bindingOwner": { args: { id: "binding-t9" } },
+  "integrations.taskStats": { args: undefined },
   "channels.snapshot": { args: undefined },
   "channels.bindings": { args: {} },
   "channels.routes": { args: { channelId: "channel-t9" } },
@@ -216,6 +220,7 @@ export const READ_OP_MARSHALING_FIXTURES: ReadOpFixtures = {
   "ciIncidents.sha.hasExpired": { args: { now: FIXTURE_NOW } },
   "ciIncidents.lease.hasExpired": { args: { now: FIXTURE_NOW } },
   "deployEvents.get": { args: { id: "dep-t9" } },
+  "deployEvents.forCommit": { args: { commitSha: "a".repeat(40) } },
   // #2189 P7 — restart-epoch reads. Every one is a point/keyset read against ids that do not exist in
   // the fixture DB, which is the point: marshaling has to survive the empty answer too.
   "restartEpoch.openAll": { args: undefined },

package/src/db/read-ops.ts

@@ -1,4 +1,6 @@
+import { INTEGRATIONS_READ_OPS } from "./integrations-ops.ts";
 import { PROMPT_VERSION_READ_OPS } from "./prompt-versions-ops";
+import { PROJECT_PROFILE_INSTRUCTION_READ_OPS } from "./project-profile-instructions";
 import { VAULT_READ_OPS } from "./secrets-vault";
 import { GUIDE_READ_OPS } from "./guides-search";
 import { ROUTING_POLICY_READ_OPS } from "./routing-policy";
@@ -129,6 +131,7 @@ const SPIN_MAX_MS = 2_000;
 export const readOps = {
   ...GUIDE_READ_OPS,
   ...PROMPT_VERSION_READ_OPS,
+  ...PROJECT_PROFILE_INSTRUCTION_READ_OPS,
   ...SERVICE_ACCESS_READ_OPS,
   ...VAULT_TOKEN_READ_OPS,
   ...VAULT_HEALTH_READ_OPS,
@@ -254,6 +257,7 @@ export const readOps = {
   ...PROJECTS_READ_OPS,
   ...PROJECT_ENTRIES_READ_OPS,
   ...CHANNELS_READ_OPS,
+  ...INTEGRATIONS_READ_OPS,
 } satisfies Record<string, ReadOpFn>;
 
 /** The registered read-op names. */

package/src/db/routing-policy.ts

@@ -3,7 +3,6 @@ import { isRecord, ValidationError, type RoutingPolicy, type RoutingPolicyEnvelo
 import { getConfig, setConfigInternal } from "../config-store";
 import { getDb } from "./connection";
 import { DEFAULT_ROUTING_POLICY, normalizeRoutingPolicy, ROUTING_POLICY_NAMESPACE as NS, ROUTING_POLICY_KEY as KEY } from "../routing-policy-normalize";
-import { currentRoutingModels } from "../routing-model-aliases";
 
 export function readRoutingPolicy(): RoutingPolicyEnvelope {
   const entry = getConfig(NS, KEY);
@@ -19,7 +18,7 @@ export function readRoutingPolicy(): RoutingPolicyEnvelope {
       policy.migration = { sourceSchemaVersion: 1, notes: stored.migration.notes.filter((note): note is string => typeof note === "string") };
     }
   }
-  return { policy: currentRoutingModels(policy), revision: entry?.version ?? 0, diagnostics: policy.migration ?? null };
+  return { policy, revision: entry?.version ?? 0, diagnostics: policy.migration ?? null };
 }
 
 export interface RoutingPolicyWrite {
@@ -53,7 +52,7 @@ export function writeRoutingPolicy(args: RoutingPolicyWrite, now: number) {
     }
   }
   const policy: RoutingPolicy = { ...parsed, ...(migration ? { migration } : {}), ...(sourceRevision ? { migrationSourceRevision: sourceRevision } : {}) };
-  const changed = (isRecord(stored?.value) && stored.value.schemaVersion === 1) || JSON.stringify(currentRoutingModels(policy)) !== JSON.stringify(current.policy);
+  const changed = (isRecord(stored?.value) && stored.value.schemaVersion === 1) || JSON.stringify(policy) !== JSON.stringify(current.policy);
   if (changed) setConfigInternal(NS, KEY, policy, args.updatedBy, now);
   return { envelope: readRoutingPolicy(), previous: current.policy, changed };
 }

package/src/db/schema.ts

@@ -25,7 +25,8 @@ import { resetLifecycleSeqSeed } from "./lifecycle-seq.ts";
 import { resetFannedSeq } from "../sse-outbox-cursor";
 import { dropLegacyContinuationArchiveIndex } from "./continuation-archive-search.ts";
 import { applyMigrations } from "./migrations.ts";
-import { PROMPT_TEMPLATES_SCHEMA_SQL, seedPromptTemplatesIfNeeded } from "./prompt-templates-schema";
+import { reconcileProviderModelSeed } from "./provider-model-seed"; import { PROMPT_TEMPLATES_SCHEMA_SQL, seedPromptTemplatesIfNeeded } from "./prompt-templates-schema";
+import { PROJECT_PROFILE_INSTRUCTIONS_SCHEMA_SQL } from "./project-profile-instructions";
 import { ensureLandingPhaseOneSchema } from "./landing-schema.ts";
 import { beginStartupPhase, timeStartupPhase } from "../startup-timing";
 import { resetMainConnectionWrites } from "./main-connection-writes";
@@ -552,6 +553,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_config_history_key ON config_history(namespace, key, version);
 
     ${PROMPT_TEMPLATES_SCHEMA_SQL}
+    ${PROJECT_PROFILE_INSTRUCTIONS_SCHEMA_SQL}
 
     -- Per-user settings (#391, epic #388). The user dimension the global \`config\` table lacks:
     -- the same \`(namespace, key)\` descriptor address resolves to a per-user value, keyed by the
@@ -844,6 +846,8 @@ export function initDb(path: string = "agent-relay.db"): Database {
       -- distinct from severity). Both optional; absent on claim-kind rows.
       tags TEXT,
       priority TEXT,
+      -- #3736 — paths[] (JSON array of repo-relative paths) a project spawn policy matches.
+      paths TEXT,
       -- #1535 WS1 — parent/epic tree edge: a task has at most one parent. Cycle-guarded
       -- in application code (src/db/task-entity.ts setTaskParent), the same way as the
       -- depends-on DAG below (#834 finding 7) — SQLite CHECK can't express acyclicity.
@@ -858,7 +862,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       -- gate-validated but does NOT arm a land (no ingress); the coordinator's clear (CAS on
       -- the held delivery's host-probed HEAD) promotes that exact delivery. Distinct from the
       -- permanent workspace landBlocked. Default 0 keeps every pre-#2518 Task unheld.
-      validation_items TEXT, terminal_stage TEXT, completed_at INTEGER,
+      validation_items TEXT, terminal_stage TEXT, completed_at INTEGER, on_deploy TEXT,
       review_hold INTEGER NOT NULL DEFAULT 0 CHECK (review_hold IN (0, 1)),
       -- #2862 durable owner: a coordinator role (coordinator:TEAM) or a human id, never an agent id.
       owner TEXT
@@ -867,6 +871,8 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
     CREATE INDEX IF NOT EXISTS idx_tasks_target ON tasks(target);
     CREATE INDEX IF NOT EXISTS idx_tasks_updated ON tasks(updated_at);
+    -- #3740: cover the integration aggregation without fetching task bodies/metadata.
+    CREATE INDEX IF NOT EXISTS idx_tasks_integration_stats ON tasks(coalesce(json_extract(metadata, '$.relayIntegrationName'), source), status, claimed_by, last_seen_at, updated_at, source);
     CREATE INDEX IF NOT EXISTS idx_tasks_message_status
       ON tasks(message_id, status)
       WHERE message_id IS NOT NULL;
@@ -1456,7 +1462,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
   ensureLandingPhaseOneSchema();
   // Vault catalog, environments and metadata upgrades share applyMigrations (#3561, #3562).
   timeStartupPhase("db.migrations", applyMigrations);
-  timeStartupPhase("db.prompt-seed", seedPromptTemplatesIfNeeded);
+  timeStartupPhase("db.prompt-seed", seedPromptTemplatesIfNeeded); timeStartupPhase("db.model-seed", reconcileProviderModelSeed);
   timeStartupPhase("db.token-profile-seed", seedBuiltInTokenProfiles);
 
   timeStartupPhase("db.planner-statistics", () => refreshPlannerStats(getDb()));

package/src/db/spawn-delegation-state.ts

@@ -77,13 +77,20 @@ export function spawnDelegationState(agentId: string, launchProfile?: string) {
     participating: Boolean((ancestors?.length !== 1 || launchProfile === "sub-coordinator")
       && (grant || ownTeam?.parentTeamId || (rootTeam && hasPrivateTeams(rootTeam.id)))), enabled: grant?.enabled === true,
     grant, projectId: ancestors && ancestors.length > 1 ? delegatedProjectId(agentId) ?? projectIdForAgent(agent) : rootTeam?.projectId,
-    displaced: (ancestors ?? [agentId]).some(id => {
-      const ancestor = getAgent(id);
-      return isDisplacedSeat(id, ancestor?.teamId ?? seatTeam(id)?.id);
-    }),
+    displaced: displacedThroughDelegation(ancestors ?? [agentId]),
   };
 }
 
+/** The agent's own seat was claimed, or that of an ancestor it reaches only through delegated launches. An
+ * ordinary child is inherited by the claimant and keeps its standing (#3773). */
+function displacedThroughDelegation(ancestors: readonly string[]): boolean {
+  for (const id of ancestors) {
+    if (isDisplacedSeat(id, getAgent(id)?.teamId ?? seatTeam(id)?.id)) return true;
+    if (!delegatedLaunch(id)) return false;
+  }
+  return false;
+}
+
 /** Ordinary tokens avoid ancestry reads; private-team linkage survives grant removal. */
 export function participatesInSpawnDelegation(agentId: string): boolean {
   return Boolean(getDb().query(`WITH RECURSIVE lineage(id, depth) AS (

package/src/db/stats-async.ts

@@ -1,4 +1,4 @@
-import { mainConnectionWrites } from "./main-connection-writes";
+import { mainConnectionBootWrites, mainConnectionWrites } from "./main-connection-writes";
 import { allWriterOps } from "./write-ops";
 import { assertMainThreadState } from "./main-thread-state";
 // Async reader-pool facades for DB-only stats. Health is a deliberate documented deferral: its
@@ -105,7 +105,7 @@ async function probeDatabaseLiveness(): Promise<HealthCheck> {
  * `readerBackend`/`writerBackend` plus reader-pool depth/in-flight/shed counts unconditionally (the
  * in-process backend's zeroed pool numbers ARE the "report that plainly" answer, not a special case).
  */
-function buildDbGatewayCheck(stats: DbGatewayStats): HealthCheck {
+export function buildDbGatewayCheck(stats: DbGatewayStats): HealthCheck {
   const reader = stats.reader;
   const readerActive = reader.backend !== "uninitialized";
   const wedged = stats.writer.wedged;
@@ -119,7 +119,7 @@ function buildDbGatewayCheck(stats: DbGatewayStats): HealthCheck {
     `reader=${stats.readerBackend}`,
     `onLoopOps=${specs.length - offLoop}; writerThreadOps=${offLoop}`,
     `mainConnectionWrites1h=${JSON.stringify(writes)}`,
-    ...(wedged ? ["writer wedged"] : []),
+    ...(wedged ? [`writer wedged: op ${wedged.op} running ${Math.round(wedged.runningMs / 1000)}s`] : []),
     ...(shedCount > 0 ? [`${shedCount} reader shed(s)`] : []),
   ].join("; ");
   return {
@@ -131,6 +131,7 @@ function buildDbGatewayCheck(stats: DbGatewayStats): HealthCheck {
       onLoopOps: specs.length - offLoop,
       writerThreadOps: offLoop,
       mainConnectionWrites1h: Object.values(writes).reduce((sum, count) => sum + count, 0),
+      mainConnectionBootWrites: mainConnectionBootWrites(),
       writerQueued: stats.writer.queued,
       writerBusy: stats.writer.busy,
       writerHighWater: stats.writer.highWater,

package/src/db/task-entity.ts

@@ -37,6 +37,7 @@ import {
   type TaskStatus,
 } from "../types";
 import { parseJson } from "../utils";
+import { repoRelativePath } from "@humwick/sdk/spawn-policy";
 import { cleanEnum, cleanStringArray, optionalEnum } from "../validation";
 import { getDb, writeTransaction, ValidationError } from "./connection.ts";
 import { ownerForNewTask } from "./task-owner.ts";
@@ -108,6 +109,16 @@ function cleanTags(value: unknown, field = "tags"): string[] | undefined {
   return cleanStringArray(value, field, { itemMax: 60, maxItems: 30 });
 }
 
+/** #3736 — repo-relative, normalized; a path that leaves the repo is refused. Stored null when empty. */
+function taskPathsColumn(value: unknown): string | null {
+  const paths = (cleanStringArray(value, "paths", { itemMax: 300, maxItems: 50 }) ?? []).map((path, i) => {
+    const rel = repoRelativePath(path);
+    if (rel === undefined) throw new ValidationError(`paths[${i}] must be a repo-relative path inside the repo`);
+    return rel;
+  });
+  return paths.length ? JSON.stringify([...new Set(paths)]) : null;
+}
+
 // #1535 WS3 — backlog lifecycle state. Optional (like priority): absent stays undefined so a
 // non-backlog task's column is NULL; a present-but-invalid value throws rather than silently
 // dropping. The backlog→promoted flip is a distinct writer (setTaskBacklogState in db/backlog.ts).
@@ -196,6 +207,7 @@ export interface CreateDeliverableTaskInput {
   complexity?: TaskComplexity;
   context?: string;
   terminalStage?: Task["terminalStage"];
+  onDeploy?: string;
   doneWhen?: string; branch?: string;
   teamId?: string;
   projectId?: string;
@@ -206,6 +218,7 @@ export interface CreateDeliverableTaskInput {
   latestSteer?: string;
   dispatch?: TaskDispatch;
   tags?: string[];
+  paths?: string[];
   priority?: TaskPriority;
   /** #1535 WS3 — seed the task directly into the backlog (`backlog`) so it shows up in the
    * prioritized backlog query until promoted. Absent ⇒ not backlog-managed. */
@@ -225,6 +238,7 @@ export function createDeliverableTaskBody(input: CreateDeliverableTaskInput, now
   const intent = requireText(input.intent, "intent", 1_000_000);
   const dispatch = cleanTaskDispatch(input.dispatch);
   const complexity = cleanTaskComplexity(input.complexity ?? dispatch?.complexity, "complexity") ?? DEFAULT_TASK_COMPLEXITY;
+  const onDeploy = optionalText(input.onDeploy, "onDeploy", 500);
   const context = optionalText(input.context, "context", 1_000_000);
   const branch = optionalText(input.branch, "branch", 500);
   const taskProject = cleanTaskProject(input);
@@ -237,8 +251,8 @@ export function createDeliverableTaskBody(input: CreateDeliverableTaskInput, now
     INSERT INTO tasks (
       source, title, body, severity, status, target, occurrence_count, metadata,
       created_at, updated_at, last_seen_at,
-      kind, intent, complexity, context, latest_steer, deliverable_stage, done_when, branch, team_id, project_id, repo, created_by, dispatch, tags, priority, backlog_state, owner
-    ) VALUES (?, ?, ?, 'info', 'open', ?, 1, '{}', ?, ?, ?, '${DELIVERABLE_TASK_KIND}', ?, ?, ?, ?, 'none', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      kind, intent, complexity, context, latest_steer, deliverable_stage, done_when, branch, team_id, project_id, repo, created_by, dispatch, tags, paths, priority, backlog_state, owner, on_deploy
+    ) VALUES (?, ?, ?, 'info', 'open', ?, 1, '{}', ?, ?, ?, '${DELIVERABLE_TASK_KIND}', ?, ?, ?, ?, 'none', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     optionalText(input.source, "source", 200) ?? "coordinator",
     title,
@@ -254,9 +268,11 @@ export function createDeliverableTaskBody(input: CreateDeliverableTaskInput, now
     createdBy,
     dispatch ? JSON.stringify(dispatch) : null,
     tags.length ? JSON.stringify(tags) : null,
+    taskPathsColumn(input.paths),
     priority ?? null,
     backlogState ?? null,
     ownerForNewTask(createdBy, teamId),
+    onDeploy ?? null,
   );
   const id = Number(result.lastInsertRowid);
   if (input.terminalStage) getDb().query("UPDATE tasks SET terminal_stage = ? WHERE id = ?").run(input.terminalStage, id);
@@ -282,6 +298,7 @@ export interface UpdateDeliverableTaskInput {
   complexity?: TaskComplexity;
   context?: string;
   latestSteer?: string;
+  onDeploy?: string;
   doneWhen?: string;
   dispatch?: TaskDispatch;
   teamId?: string;
@@ -290,6 +307,8 @@ export interface UpdateDeliverableTaskInput {
   actor?: string;
   /** Absent ⇒ untouched. `[]` (or `null`) ⇒ clear all tags. */
   tags?: string[] | null;
+  /** Absent ⇒ untouched. `[]` (or `null`) ⇒ clear all paths. */
+  paths?: string[] | null;
   /** Absent ⇒ untouched. `null` ⇒ clear (priority has no default, unlike complexity). */
   priority?: TaskPriority | null;
 }
@@ -309,6 +328,7 @@ export function updateDeliverableTaskBody(id: number, input: UpdateDeliverableTa
   if (input.complexity !== undefined) push("complexity", cleanTaskComplexity(input.complexity) ?? null);
   if (input.context !== undefined) push("context", optionalText(input.context, "context", 1_000_000) ?? null);
   if (input.latestSteer !== undefined) push("latest_steer", optionalText(input.latestSteer, "latestSteer", 1_000_000) ?? null);
+  if (input.onDeploy !== undefined) push("on_deploy", optionalText(input.onDeploy, "onDeploy", 500) ?? null);
   if (input.doneWhen !== undefined) push("done_when", optionalText(input.doneWhen, "doneWhen", 1_000_000) ?? null);
   if (input.teamId !== undefined) push("team_id", optionalText(input.teamId, "teamId", 200) ?? null);
   if (input.projectId !== undefined || input.repo !== undefined) {
@@ -321,6 +341,7 @@ export function updateDeliverableTaskBody(id: number, input: UpdateDeliverableTa
     const tags = input.tags === null ? [] : (cleanTags(input.tags) ?? []);
     push("tags", tags.length ? JSON.stringify(tags) : null);
   }
+  if (input.paths !== undefined) push("paths", taskPathsColumn(input.paths ?? []));
   if (input.terminalStage !== undefined) push("terminal_stage", input.terminalStage === null ? null : cleanTaskTerminalStage(input.terminalStage));
   if (input.priority !== undefined) push("priority", input.priority === null ? null : requireTaskPriority(input.priority));
   if (sets.length > 0) {

package/src/db/task-list.ts

@@ -41,7 +41,8 @@ function buildDeliverableTasksWhere(filter: ListDeliverableTasksFilter): { claus
   }
   if (filter.staleOwnerGone) conditions.push(STALE_TASK_OWNER_SQL);
   if (filter.status) { conditions.push("status = ?"); params.push(filter.status); }
-  if (filter.deliverableStage) { conditions.push("deliverable_stage = ?"); params.push(filter.deliverableStage); }
+  if (filter.deliverableStage === "awaiting-deploy") conditions.push("deliverable_stage IN ('landed-on-main', 'deploying')");
+  else if (filter.deliverableStage) { conditions.push("deliverable_stage = ?"); params.push(filter.deliverableStage); }
   if (filter.teamId) { conditions.push("team_id = ?"); params.push(filter.teamId); }
   if (filter.createdBy) { conditions.push("created_by = ?"); params.push(filter.createdBy); }
   if (filter.ownerAgentId) { conditions.push("owner_agent_id = ?"); params.push(filter.ownerAgentId); }
@@ -87,6 +88,7 @@ function taskListItem(task: Task): TaskListItem {
     status: task.status,
     kind: task.kind,
     ...(task.validationItems ? { validationItems: task.validationItems } : {}),
+    ...(task.onDeploy ? { onDeploy: task.onDeploy } : {}),
     ...(task.terminalStage ? { terminalStage: task.terminalStage } : {}),
     ...(task.completedAt ? { completedAt: task.completedAt } : {}),
     ...(task.staleOwnerGone ? { staleOwnerGone: true } : {}),

package/src/db/tasks.ts

@@ -1,19 +1,5 @@
 import { taskVisibilitySql, type ViewerScope } from "./viewer-scope";
-import { randomUUID } from "node:crypto";
-import { isRecord, stringValue, isMechanicalMessageKind } from "@humwick/sdk";
-import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
-import { parseJson } from "../utils";
-import { isLiveIsolatedWorkspace } from "../workspace-phase";
-import {
-  CONTRACT_REQUIREMENTS,
-  contractCompatibility,
-  parseRuntimeCapabilities,
-  parseRuntimeContracts,
-  parseRuntimePackage,
-  type RuntimeContracts,
-} from "../contracts";
-import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
-import { matchAgents } from "../agent-ref";
+import { CLAIM_LEASE_MS } from "../config";
 import { getAgent, validateAgentSession } from "./agents.ts";
 import { messageTaskClosed } from "./claim-sql.ts";
 import { ClaimError, getDb, writeTransaction } from "./connection.ts";
@@ -51,7 +37,6 @@ export function taskMessageBody(task: Pick<Task, "id" | "source" | "severity" |
   return lines.join("\n");
 }
 
-
 export function getTask(id: number): Task | null {
   const row = getDb().query(`${TASK_SELECT} WHERE id = ?`).get(id) as any;
   return row ? rowToTask(row) : null;
@@ -85,7 +70,6 @@ export function listTasks(filter?: { viewer?: ViewerScope | null; status?: strin
   return (getDb().query(`${TASK_SELECT} ${where} ORDER BY updated_at DESC LIMIT ?`).all(...params) as any[]).map(rowToTask);
 }
 
-
 /** Deliverable stages meaning the work already left the worker's hands (#2036): a Task sitting in
  *  `in_progress` while its land gate runs is not a stalled worker. Excluded IN SQL, not after the
  *  fact — these rows carry the OLDEST claims, so a post-LIMIT filter would let them consume the