@humwick/server 0.130.0 → 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 { deleteAgent, heartbeat, upsertAgent } from "./agents.ts";
+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) {
@@ -259,8 +192,8 @@ function mergeOrchestratorRuntimeMeta(meta: Record<string, unknown>, input: Orch
   };
 }
 
-export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrator {
-  const now = Date.now();
+/** The orchestrator row write alone (no agent registration); returns the agent registration to follow. */
+function writeOrchestratorRow(input: RegisterOrchestratorInput, now: number): RegisterAgentInput {
   // #1554 — the command-delivery key. Built from the SAME helper the orchestrator's command poller
   // binds with, so a registered host is always addressed under the exact id it polls under.
   const agentId = orchestratorAgentId(input.id);
@@ -311,7 +244,7 @@ export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrat
   });
 
   // Also register as an agent so the orchestrator can receive messages
-  upsertAgent({
+  return {
     id: agentId,
     name: `Orchestrator (${input.hostname})`,
     tags: ["orchestrator", input.hostname],
@@ -329,11 +262,23 @@ export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrat
       ...(input.protocolVersion !== undefined ? { protocolVersion: input.protocolVersion } : {}),
       ...(input.gitSha ? { gitSha: input.gitSha } : {}),
     },
-  });
+  };
+}
 
+export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrator {
+  upsertAgent(writeOrchestratorRow(input, Date.now()));
   return getOrchestrator(input.id)!;
 }
 
+/** #1870 S6c — the whole registration as one off-loop op: the orchestrator row and its agent row
+ *  commit together. The agent's main-thread follow-ups (presence eviction, pool binding, steward
+ *  election) run in the facade from the returned `agent`/`contextState`. */
+export function registerOrchestratorOp(input: RegisterOrchestratorInput, now: number, seq: number): { orchestrator: Orchestrator } & UpsertAgentTxResult {
+  const agentInput = writeOrchestratorRow(input, now);
+  const tx = upsertAgentInternal(agentInput, undefined, now, seq);
+  return { orchestrator: getOrchestrator(input.id)!, ...tx };
+}
+
 export function getOrchestrator(id: string): Orchestrator | null {
   const row = getDb().query("SELECT * FROM orchestrators WHERE id = ?").get(id) as any;
   return row ? rowToOrchestrator(row) : null;
@@ -440,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-ops.ts

@@ -10,6 +10,7 @@ export const PROMPT_VERSION_READ_OPS = {
 
 export const PROMPT_VERSION_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = {
   "prompts.write": {
+    offLoop: true,
     idempotent: false,
     fn: (args: PromptWrite, ctx: WriterOpContext) => writePromptVersion(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-catalog-write-ops.ts

@@ -9,8 +9,8 @@ import type { SpawnProvider } from "../types.ts";
 import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PROVIDER_CATALOG_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
-  "providerCatalog.upsert": { idempotent: false, fn: (args: { input: ProviderModelOverrideInput }, ctx: WriterOpContext) => upsertProviderModelOverride(args.input, ctx.now) },
-  "providerCatalog.setDisabled": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; disabled: boolean; updatedBy?: string }, ctx: WriterOpContext) => setProviderModelDisabled(args.provider, args.alias, args.disabled, args.updatedBy, ctx.now) },
-  "providerCatalog.remove": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => removeProviderModelOverride(args.provider, args.alias, args.updatedBy, ctx.now) },
-  "providerCatalog.setDefault": { idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => setProviderDefaultModel(args.provider, args.alias, args.updatedBy, ctx.now) },
+  "providerCatalog.upsert": { offLoop: true, idempotent: false, fn: (args: { input: ProviderModelOverrideInput }, ctx: WriterOpContext) => upsertProviderModelOverride(args.input, ctx.now) },
+  "providerCatalog.setDisabled": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; disabled: boolean; updatedBy?: string }, ctx: WriterOpContext) => setProviderModelDisabled(args.provider, args.alias, args.disabled, args.updatedBy, ctx.now) },
+  "providerCatalog.remove": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => removeProviderModelOverride(args.provider, args.alias, args.updatedBy, ctx.now) },
+  "providerCatalog.setDefault": { offLoop: true, idempotent: false, fn: (args: { provider: SpawnProvider; alias: string; updatedBy?: string }, ctx: WriterOpContext) => setProviderDefaultModel(args.provider, args.alias, args.updatedBy, ctx.now) },
 });

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-flap-messages-write-ops.ts

@@ -3,6 +3,7 @@ import type { WriterOpSpec } from "./write-ops.ts";
 
 export const PROVIDER_FLAP_MESSAGES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "providerFlapMessages.ensureIndex": {
+    offLoop: true,
     idempotent: true,
     fn: () => {
       ensureProviderFlapMessagesIndex();

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/provider-quota-lease-write-ops.ts

@@ -17,6 +17,7 @@ export const PROVIDER_QUOTA_LEASE_WRITE_OPS: Readonly<Record<string, WriterOpSpe
       acquireProviderQuotaLeaseInTx(normalizeProviderQuotaLeaseAcquireInput({ ...args.input, now: args.input.now ?? ctx.now })),
   },
   "providerQuotaLeases.release": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { input: Parameters<typeof releaseProviderQuotaLeaseInTx>[0] }) => releaseProviderQuotaLeaseInTx(args.input),
   },

package/src/db/provider-quota-write-ops.ts

@@ -54,6 +54,7 @@ export const PROVIDER_QUOTA_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
   // It returns concrete messages for main-thread SSE fanout; never call notifySystemMessage in a
   // worker, whose listener set is intentionally not shared with the server.
   "providerQuotas.routeNotification": {
+    offLoop: true,
     // Routing inserts message rows. The effect facade supplies a stable per-effect key so a
     // post-commit acknowledgement loss returns these exact messages instead of routing twice.
     idempotent: false,
@@ -63,6 +64,7 @@ export const PROVIDER_QUOTA_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> =
     fn: (args: { input: RouteNotificationInput; now?: number }, ctx: WriterOpContext) => routeProviderQuotaNotificationInTx(args.input, args.now ?? ctx.now),
   },
   "providerQuotas.pruneHistory": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { olderThan: number }) => ({ changes: pruneProviderQuotaHistory(args.olderThan) }),
   },

package/src/db/provisioning-write-ops.ts

@@ -26,18 +26,19 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 
 export const PROVISIONING_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   // Creating a capability mints a random id, so the generic durable ledger owns phantom-ACK retry.
-  "provisioning.capabilities.create": { idempotent: false, fn: (args: CreateProvisioningCapabilityInput, ctx: WriterOpContext) => createProvisioningCapability(args, ctx.now) },
-  "provisioning.capabilities.update": { idempotent: true, fn: (args: { id: string; patch: UpdateProvisioningCapabilityInput }, ctx: WriterOpContext) => updateProvisioningCapability(args.id, args.patch, ctx.now) },
-  "provisioning.capabilities.delete": { idempotent: true, fn: (args: { id: string }) => deleteProvisioningCapability(args.id) },
+  "provisioning.capabilities.create": { offLoop: true, idempotent: false, fn: (args: CreateProvisioningCapabilityInput, ctx: WriterOpContext) => createProvisioningCapability(args, ctx.now) },
+  "provisioning.capabilities.update": { offLoop: true, idempotent: true, fn: (args: { id: string; patch: UpdateProvisioningCapabilityInput }, ctx: WriterOpContext) => updateProvisioningCapability(args.id, args.patch, ctx.now) },
+  "provisioning.capabilities.delete": { offLoop: true, idempotent: true, fn: (args: { id: string }) => deleteProvisioningCapability(args.id) },
   // The capability lookup and its variant insert/update execute under one writer lock.
-  "provisioning.variants.createMcp": { idempotent: false, fn: (args: { capabilityId: string; input: CreateMcpProvisioningVariantInput }, ctx: WriterOpContext) => createMcpProvisioningVariant(args.capabilityId, args.input, ctx.now) },
-  "provisioning.variants.patch": { idempotent: true, fn: (args: { id: string; patch: PatchProvisioningAssetVariantInput }, ctx: WriterOpContext) => patchProvisioningAssetVariant(args.id, args.patch, ctx.now) },
-  "provisioning.variants.validate": { idempotent: true, fn: (args: { id: string }, ctx: WriterOpContext) => validateProvisioningAssetVariant(args.id, ctx.now) },
-  "provisioning.assets.upsert": { idempotent: false, fn: (args: UpsertProvisioningAssetInput, ctx: WriterOpContext) => upsertProvisioningAsset(args, ctx.now) },
+  "provisioning.variants.createMcp": { offLoop: true, idempotent: false, fn: (args: { capabilityId: string; input: CreateMcpProvisioningVariantInput }, ctx: WriterOpContext) => createMcpProvisioningVariant(args.capabilityId, args.input, ctx.now) },
+  "provisioning.variants.patch": { offLoop: true, idempotent: true, fn: (args: { id: string; patch: PatchProvisioningAssetVariantInput }, ctx: WriterOpContext) => patchProvisioningAssetVariant(args.id, args.patch, ctx.now) },
+  "provisioning.variants.validate": { offLoop: true, idempotent: true, fn: (args: { id: string }, ctx: WriterOpContext) => validateProvisioningAssetVariant(args.id, ctx.now) },
+  "provisioning.assets.upsert": { offLoop: true, idempotent: false, fn: (args: UpsertProvisioningAssetInput, ctx: WriterOpContext) => upsertProvisioningAsset(args, ctx.now) },
   "provisioning.assets.importGithub": {
+    offLoop: true,
     idempotent: false,
     fn: (args: { input: ImportProvisioningAssetFromGitHubInput; source: GitHubVendoredSource; definition: ResolvedAssetDefinition; now: number; target?: ProvisioningGitHubImportTarget }) =>
       upsertImportedAssetBody(args.input, args.source, args.definition, args.now, args.target),
   },
-  "provisioning.assets.delete": { idempotent: true, fn: (args: { kind: ProvisioningAssetKind; name: string; provider?: AgentProfileProvider }) => deleteProvisioningAsset(args.kind, args.name, args.provider) },
+  "provisioning.assets.delete": { offLoop: true, idempotent: true, fn: (args: { kind: ProvisioningAssetKind; name: string; provider?: AgentProfileProvider }) => deleteProvisioningAsset(args.kind, args.name, args.provider) },
 });

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,12 +52,12 @@ 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 };
 }
 
 export const ROUTING_POLICY_READ_OPS = { "routingPolicy.get": () => readRoutingPolicy() };
 export const ROUTING_POLICY_WRITE_OPS = {
-  "routingPolicy.set": { idempotent: false, fn: (args: RoutingPolicyWrite, ctx: { now: number }) => writeRoutingPolicy(args, ctx.now) },
+  "routingPolicy.set": { offLoop: true, idempotent: false, fn: (args: RoutingPolicyWrite, ctx: { now: number }) => writeRoutingPolicy(args, ctx.now) },
 };

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/secrets-broker-write-ops.ts

@@ -14,10 +14,10 @@ import type { WriterOpContext, WriterOpSpec } from "./write-ops.ts";
 export const SECRETS_BROKER_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   // Caller-generated ids + INSERT OR IGNORE make both inserts safe to replay.
   "secretsBroker.audit.record": { idempotent: true, offLoop: true, fn: (a: SecretAuditInput, ctx: WriterOpContext) => recordSecretAudit(a, ctx.now) },
-  "secretsBroker.link.create": { idempotent: true, fn: (a: SecretUploadLinkInput, ctx: WriterOpContext) => createSecretUploadLink(a, ctx.now) },
+  "secretsBroker.link.create": { offLoop: true, idempotent: true, fn: (a: SecretUploadLinkInput, ctx: WriterOpContext) => createSecretUploadLink(a, ctx.now) },
   // A replayed claim must not hand the link out twice: the ledger returns the first claim's result.
-  "secretsBroker.link.claim": { idempotent: false, fn: (a: { tokenHash: string }, ctx: WriterOpContext) => claimSecretUploadLink(a.tokenHash, ctx.now) },
-  "secretsBroker.loginLatch.set": { idempotent: true, fn: (a: { fingerprint: string; state: SecretBrokerLoginLatchState }, ctx: WriterOpContext) => setSecretBrokerLoginLatch(a, ctx.now) },
-  "secretsBroker.loginLatch.clear": { idempotent: true, fn: (a: { fingerprint: string }) => clearSecretBrokerLoginLatch(a.fingerprint) },
-  "secretsBroker.link.finish": { idempotent: true, fn: (a: Parameters<typeof finishSecretUploadLink>[0]) => finishSecretUploadLink(a) },
+  "secretsBroker.link.claim": { offLoop: true, idempotent: false, fn: (a: { tokenHash: string }, ctx: WriterOpContext) => claimSecretUploadLink(a.tokenHash, ctx.now) },
+  "secretsBroker.loginLatch.set": { offLoop: true, idempotent: true, fn: (a: { fingerprint: string; state: SecretBrokerLoginLatchState }, ctx: WriterOpContext) => setSecretBrokerLoginLatch(a, ctx.now) },
+  "secretsBroker.loginLatch.clear": { offLoop: true, idempotent: true, fn: (a: { fingerprint: string }) => clearSecretBrokerLoginLatch(a.fingerprint) },
+  "secretsBroker.link.finish": { offLoop: true, idempotent: true, fn: (a: Parameters<typeof finishSecretUploadLink>[0]) => finishSecretUploadLink(a) },
 });

package/src/db/secrets-vault-write.ts

@@ -87,11 +87,11 @@ export function editVaultMetadata(args: { name: string; patch: VaultMetadataPatc
   });
 }
 export const VAULT_WRITE_OPS = {
-  "secretsVault.metadata": { idempotent: true, fn: editVaultMetadata },
-  "secretsVault.delete": { idempotent: false, fn: deleteVaultSecret },
-  "secretsVault.set": { idempotent: true, fn: setVaultRow },
-  "secretsVault.request": { idempotent: false, fn: (args: Parameters<typeof fileVaultDecision>[0]) => fileVaultDecision(args) },
-  "secretsVault.withdraw": { idempotent: true, fn: withdrawVaultDecisions },
-  "secretsVault.expire": { idempotent: true, fn: expireVaultDecisions },
-  "secretsVault.answer": { idempotent: true, fn: (args: { id: number; now: number }) => answerOpenOperatorDecision(args.id, { answers: {}, answeredBy: "vault-form", now: args.now }) },
+  "secretsVault.metadata": { offLoop: true, idempotent: true, fn: editVaultMetadata },
+  "secretsVault.delete": { offLoop: true, idempotent: false, fn: deleteVaultSecret },
+  "secretsVault.set": { offLoop: true, idempotent: true, fn: setVaultRow },
+  "secretsVault.request": { offLoop: true, idempotent: false, fn: (args: Parameters<typeof fileVaultDecision>[0]) => fileVaultDecision(args) },
+  "secretsVault.withdraw": { offLoop: true, idempotent: true, fn: withdrawVaultDecisions },
+  "secretsVault.expire": { offLoop: true, idempotent: true, fn: expireVaultDecisions },
+  "secretsVault.answer": { offLoop: true, idempotent: true, fn: (args: { id: number; now: number }) => answerOpenOperatorDecision(args.id, { answers: {}, answeredBy: "vault-form", now: args.now }) },
 };

package/src/db/services-write-ops.ts

@@ -16,6 +16,7 @@ function parsedParams(raw: string): Record<string, unknown> {
 
 export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object.freeze({
   "services.spawnWatchdog.markUnconfirmed": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { rows: SpawnCommandPatchRow[]; now: number; phase: "dispatch_unacknowledged" | "registration_unconfirmed" }) => {
       const changed: string[] = [];
@@ -31,6 +32,7 @@ export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     },
   },
   "services.spawnWatchdog.markConfirmed": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { rows: SpawnCommandPatchRow[]; now: number }) => {
       const changed: string[] = [];
@@ -46,6 +48,7 @@ export const SERVICES_WRITE_OPS: Readonly<Record<string, WriterOpSpec>> = Object
     },
   },
   "services.providerFlap.persist": {
+    offLoop: true,
     idempotent: true,
     fn: (args: { agentId: string; kind: string; episodeCount: number; lastEpisodeAt: number; latestSuppressedSeq: number }) => {
       const row = getDb().query(`