melchizedek-agents 0.17.0 → 0.19.0

package/dist/lib/workflow/turn.js

@@ -0,0 +1,216 @@
+/**
+ * lib/workflow/turn.ts — one turn of a workflow syndicate on the native
+ * runtime: the message stored, the graph walked by the engine's scheduler,
+ * and every event the walk stores yielded in the order it was stored, the
+ * node inputs aside, as ADK's Runner yields them (ADR 0095).
+ *
+ * WHY this file exists:
+ *   runSyndicateTurn (lib/runtime/syndicateTurn.ts) runs a workflow on ADK
+ *   by handing ADK's Workflow to its Runner and draining the events the
+ *   Runner yields (drainAgentStream). On the native runtime it hands this
+ *   generator to the same drain, under the same root span, so the progress
+ *   lines, onProgress calls, node errors, the paused input and the ledger
+ *   rows come out of one reader on both runtimes. Everything a node does is
+ *   the WS4 modules': the scheduler (scheduler.ts), agent nodes on the
+ *   native loop (agentNode.ts), tool nodes (toolNode.ts), ask_user nodes and
+ *   the workflow's pause record (pause.ts), and the resume rebuilt from the
+ *   session (resume.ts). This file wires them for one turn, as ADK's Runner
+ *   and Workflow wire theirs:
+ *
+ *   1. THE MESSAGE. Stored as the user's event under a new `e-` invocation
+ *      id, before the walk, as the Runner stores it (runNativeAgent does the
+ *      same for one agent). A turn whose signal aborted first stores nothing.
+ *   2. THE START. workflowResume rebuilds every node's prior runs and the
+ *      answers from the session, as ADK's rehydration does on every message:
+ *      with nothing paused every node runs fresh. The walk's input is the
+ *      message's text, not its content, as ADK hands its root workflow, and
+ *      that text is what the workflow's pause record keeps. A pause only ADK
+ *      can resume (UnsupportedWorkflowResumeError) fails the turn; it never
+ *      walks afresh and asks the person again.
+ *   3. THE WALK. runWorkflowGraph with the runners chained (ask_user, tool,
+ *      then agentNodeRuntime for agent nodes and map items), under the
+ *      turn's signal. Every event a runner stores goes through the agent
+ *      node runtime's one queue, in walk order: node inputs, the agents'
+ *      events, tool and ask_user events, route steps, joins and maps, and
+ *      the node-error event ADK writes for a node that gave up
+ *      (nodeErrorEvent, on the scheduler's `workflow` node_error). A node's
+ *      input turn is stored and not yielded, as ADK's Runner never yields
+ *      it; a node agent's partial (streamed) event is yielded and not
+ *      stored, as the Runner yields it.
+ *   4. THE END. A paused walk stores the workflow's own record
+ *      (workflowPauseEvent) after every node's event. A walk the turn
+ *      stopped (InvocationAbortedError, or any failure once the signal
+ *      fired) ends quietly, as ADK's Runner ends an aborted run: the turn
+ *      runner reads the stop reason from its control. A node that gave up
+ *      rethrows its error once every event is stored and yielded, as ADK's
+ *      Runner throws it.
+ *   5. THE SPANS. `workflow.invoke <name>` around the walk, `node.execute
+ *      <name>` around each node run (the scheduler's traceNode hook), and
+ *      `tool.execute <name>` around a tool node's call
+ *      (lib/runtime/native/telemetry.ts). An agent node's `agent.invoke`
+ *      opens inside its node's span, so each model call is attributed to
+ *      its node's agent in the ledger.
+ *
+ * WHAT IT REFUSES before any model call: refuseUnrunnableNodes throws, for
+ * a tool node, ADK's compile-time refusals (an unregistered tool, a
+ * long-running one). A pause raised inside an agent node is refused by
+ * runAgentNode by name.
+ *
+ * It imports nothing from ADK: the caller passes the tool lookup (the
+ * registry builds ADK's tools) and the store as the engine's interface.
+ * The message, the answers and every stored event are data the walk
+ * carries, never instructions this module acts on.
+ */
+import { randomUUID } from 'node:crypto';
+import { createTurnEvent } from '../runtime/events.js';
+import { traceNodeExecution, traceToolNodeCall, traceWorkflowInvocation } from '../runtime/native/telemetry.js';
+import { agentNodeRuntime } from './agentNode.js';
+import { askUserNodeRunner, workflowPauseEvent } from './pause.js';
+import { workflowResume } from './resume.js';
+import { InvocationAbortedError, nodeErrorEvent, runWorkflowGraph } from './scheduler.js';
+import { resolveToolNode, toolNodeRunner } from './toolNode.js';
+/**
+ * Throws, before any model call, what ADK's compileWorkflow throws for a
+ * tool node: an unregistered tool, or a long-running one (ADR 0091).
+ */
+export function refuseUnrunnableNodes(graph, resolveTool) {
+    for (const node of graph.nodes.values())
+        if (node.kind === 'tool')
+            resolveToolNode(node, { resolveTool });
+}
+const isAborted = (error) => error instanceof InvocationAbortedError || error?.name === 'InvocationAbortedError';
+/**
+ * Runs one turn of the workflow: stores the message, walks the graph (a
+ * resume when the session holds a paused walk), and yields every event the
+ * walk stores, in the order stored, but the node inputs (ADK's Runner
+ * yields none of them). Returns how the walk ended, or
+ * undefined when the signal fired before the message was stored. Throws
+ * the error a node gave up with (after its events), ADK's message for a
+ * reply that answers nothing, and UnsupportedWorkflowResumeError.
+ */
+export async function* runNativeWorkflow(params) {
+    const { graph, sessions, appName, userId, sessionId, signal } = params;
+    const session = await sessions.get({ appName, userId, sessionId });
+    if (!session)
+        throw new Error(`Session not found: ${sessionId} (appName=${appName}, userId=${userId})`);
+    if (signal?.aborted)
+        return undefined;
+    if (params.userParts.length === 0)
+        throw new Error('No parts in the newMessage.');
+    // 1. The message, as the Runner stores it.
+    const invocationId = `e-${randomUUID()}`;
+    const userContent = { role: 'user', parts: params.userParts };
+    await sessions.append(session, createTurnEvent({ invocationId, author: 'user', content: userContent }));
+    if (signal?.aborted)
+        return { stopped: true };
+    // 2. The start: the message's text as the input, and every node's prior runs.
+    const start = workflowResume({ events: session.events, invocationId, userContent, workflowPath: graph.name });
+    // 3. The walk, its events handed on in the order they are stored.
+    const queue = [];
+    let wake;
+    const runtime = agentNodeRuntime({
+        agents: params.agents,
+        session,
+        sessions,
+        invocationId,
+        userContent,
+        loop: {
+            adapterFor: params.adapterFor,
+            stream: params.stream ?? false,
+            ...(params.memory ? { memory: params.memory } : {}),
+            ...(params.log ? { log: params.log } : {}),
+            ...(params.selfCorrection ? { selfCorrection: params.selfCorrection } : {}),
+            ...(params.credentials ? { credentials: params.credentials } : {}),
+        },
+        onEvent: (event) => {
+            // A node's input turn is appended straight to the session, as ADK's runLlmAgentAsNode appends it: stored, never yielded.
+            if (event.author === 'user')
+                return;
+            queue.push(event);
+            wake?.();
+        },
+        // A node agent's streamed text, yielded as ADK's Runner yields its partial events.
+        onPartial: (event) => {
+            queue.push(event);
+            wake?.();
+        },
+    });
+    // Every event handed over is queued a microtask later (agentNodeRuntime.store); `stored` waits for all of them.
+    const handed = new Set();
+    const store = (event) => {
+        const queued = runtime.store(event).catch(() => { }); // a store error surfaces from settled()
+        handed.add(queued);
+        void queued.finally(() => handed.delete(queued));
+    };
+    const stored = async () => {
+        while (handed.size > 0)
+            await Promise.all([...handed]);
+        await runtime.settled();
+    };
+    const runNode = askUserNodeRunner({ invocationId, onEvent: store }, toolNodeRunner({
+        invocationId,
+        appName,
+        userId,
+        sessionId,
+        userContent,
+        resolveTool: params.resolveTool,
+        state: () => session.state,
+        ...(params.memory ? { memory: params.memory } : {}),
+        ...(params.credentials ? { credentials: params.credentials } : {}),
+        onEvent: store,
+        traceCall: traceToolNodeCall,
+    }, runtime.runNode));
+    const onEvent = (event) => {
+        runtime.onEvent(event);
+        // ADK's reportNodeError: the workflow's own event for a node that gave up.
+        if (event.type === 'node_error' && event.source === 'workflow')
+            store(nodeErrorEvent(event, invocationId));
+    };
+    let end;
+    let failure;
+    let finished = false;
+    const walk = traceWorkflowInvocation({ name: graph.name, path: graph.name }, { sessionId, invocationId }, async () => {
+        try {
+            const run = await runWorkflowGraph(graph, {
+                input: start.input,
+                resume: start.resume,
+                runNode,
+                onEvent,
+                traceNode: traceNodeExecution,
+                ...(signal ? { signal } : {}),
+            });
+            // 4. A paused walk: the workflow's own record, after every node's event.
+            if (run.interruptIds.length > 0)
+                store(workflowPauseEvent({ name: graph.name, invocationId, input: start.input, interruptIds: run.interruptIds }));
+            await stored();
+            return run;
+        }
+        catch (error) {
+            await stored().catch(() => { });
+            throw error;
+        }
+    }).then((run) => {
+        end = { run };
+    }, (error) => {
+        // ADK's Runner ends an aborted run without an error; the turn's control holds why.
+        if (isAborted(error) || signal?.aborted)
+            end = { stopped: true };
+        else
+            failure = { error };
+    }).finally(() => {
+        finished = true;
+        wake?.();
+    });
+    for (;;) {
+        while (queue.length > 0)
+            yield queue.shift();
+        if (finished)
+            break;
+        await new Promise((resolve) => (wake = resolve));
+        wake = undefined;
+    }
+    await walk;
+    if (failure)
+        throw failure.error;
+    return end;
+}

package/dist/lib/workflowConfig.d.ts

@@ -69,9 +69,10 @@ export declare function nodeSettings(node: WorkflowNodeYaml | undefined): {
 /**
  * The route an output names: the `routeKey` property of an object (a parsed
  * JSON output), else the trimmed text. Never undefined, so an edge with a
- * `default` key always has something to fall back from.
+ * `default` key always has something to fall back from. One function for
+ * both runtimes; it lives in lib/workflow/route.ts.
  */
-export declare function routeOf(output: unknown, routeKey?: string): string;
+export { routeOf } from './workflow/route.ts';
 /** A pause raised by an `ask_user` node, read from the run's events (`adk_request_input`). */
 export interface PendingInput {
     /** The interrupt id. A plain-text next message answers it. */

package/dist/lib/workflowConfig.js

@@ -57,19 +57,10 @@ export function nodeSettings(node) {
 /**
  * The route an output names: the `routeKey` property of an object (a parsed
  * JSON output), else the trimmed text. Never undefined, so an edge with a
- * `default` key always has something to fall back from.
+ * `default` key always has something to fall back from. One function for
+ * both runtimes; it lives in lib/workflow/route.ts.
  */
-export function routeOf(output, routeKey = 'route') {
-    if (output && typeof output === 'object' && !Array.isArray(output)) {
-        const value = output[routeKey];
-        if (value === undefined || value === null)
-            return '';
-        return String(value).trim();
-    }
-    if (typeof output === 'string')
-        return output.trim();
-    return output === undefined || output === null ? '' : String(output).trim();
-}
+export { routeOf } from './workflow/route.js';
 /** ADK's function-call name for a workflow input request. */
 export const INPUT_REQUEST = 'adk_request_input';
 /** The request an `adk_request_input` call carries, or undefined for another call. */

package/dist/scripts/a2a_server.js

@@ -25,7 +25,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  *                             with A2A_AUTH=callers it stays valid beside the caller
  *                             tokens, with its old scoping, until you remove it
  *   A2A_AUTH                  who a caller is (ADR 0025): secret (default) | callers |
- *                             jwt | header
+ *                             jwt | header (required with PUBLIC_URL, ADR 0039)
  *   A2A_CALLERS               callers: `name:sha256[:scope]; …` — one token per calling
  *                             backend. Mint: melchizedek-serve --new-caller <name>
  *   A2A_JWT_JWKS_URL          jwt: your identity provider's JWKS (or A2A_JWT_SECRET, HS256)
@@ -39,20 +39,25 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  *   ALLOW_UNHARDENED_DB       "true" to accept an unhardened Supabase schema
  *   A2A_TASK_TIMEOUT_MS       per-task wall-clock budget (900000; 0 = none)
  *   A2A_MAX_CONCURRENT_TASKS  concurrent tasks across all agents (0 = unlimited)
+ *   A2A_MAX_CONCURRENT_PER_SCOPE   concurrent tasks for one end user (4; 0 = unlimited)
+ *   A2A_MAX_CONCURRENT_PER_CALLER  concurrent tasks for one caller (0 = unlimited)
  *   A2A_RATE_LIMIT_MAX        task submissions per window per IP (60)
  *   A2A_RATE_LIMIT_WINDOW_MS  rate-limit window (900000)
  *   A2A_AUTH_FAILURE_MAX      failed authentications per window per IP (30)
- *   A2A_TRUST_PROXY           Express trust-proxy: hop count, true/false, or subnets (1)
+ *   A2A_TRUST_PROXY           Express trust-proxy: hop count, true/false, or subnets
+ *                             (false; required with PUBLIC_URL)
  *   A2A_BODY_LIMIT            JSON body limit ("1mb")
  *   A2A_KEY_MODE              server (default): models run on the server's keys;
  *                             byok: the caller's X-API-Key pays. Under A2A_AUTH=secret
  *                             the mode also scopes data: X-User-Id in server mode,
  *                             the key's hash in byok (the pre-0.16 behaviour)
  *   A2A_SERVED_AGENTS         comma list: the only agent ids /:agentId/ serves;
- *                             only these may fall back to examples/ and templates/
+ *                             only these may fall back to examples/ and templates/;
+ *                             * serves every one (required with PUBLIC_URL)
  *   A2A_REGISTRY_AGENTS       comma list: bare ids that load from adk_agent_registry
  *                             (others are files; registry:<id> always is the registry)
  *   A2A_SHUTDOWN_GRACE_MS     how long SIGTERM waits for running tasks (25000)
+ *   A2A_SHUTDOWN_DELAY_MS     of that, how long /readyz fails while requests are still served (5000)
  *   A2A_BUDGETS               daily budgets per UTC day (ADR 0026), JSON:
  *                             {"perCaller":{"tasks":500,"llmCalls":5000,"tokens":5000000},
  *                              "callers":{"reports":{"tasks":100}},"perScope":{"tasks":50}}.
@@ -74,7 +79,6 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { randomBytes } from 'node:crypto';
 import { realpathSync, writeFileSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
-import { setLogLevel, LogLevel } from '@google/adk';
 import { createA2AApp } from '../lib/a2a/app.js';
 import { callerTokens, firstOf, hashCallerToken, jwtIdentity, parseCallers, sharedSecret, trustedHeader, } from '../lib/a2a/identity.js';
 import { budgets, memoryUsageStore, parseBudgets, postgresUsageStore, supabaseUsageStore } from '../lib/a2a/policy.js';
@@ -85,6 +89,7 @@ import { dbSchema } from '../lib/storage/schema.js';
 import { postgresStorage } from '../lib/storage/postgres/index.js';
 import { isPlaceholderValue, loadEnv } from '../lib/loadEnv.js';
 import { flushTracing } from '../lib/observability/tracer.js';
+import { setLogLevel } from '../lib/runtime/logging.js';
 // Re-exported for existing importers (tests/failNarration.test.ts).
 export { describeTurnError } from '../lib/a2a/executor.js';
 /** Minimum bearer-secret length below which the server warns. */
@@ -101,8 +106,10 @@ function envInt(name, fallback) {
 }
 function envTrustProxy() {
     const raw = process.env.A2A_TRUST_PROXY?.trim();
+    // Unset: trust no proxy, so a client cannot choose its own IP with
+    // X-Forwarded-For. A public server must set it (the posture check below).
     if (!raw)
-        return 1;
+        return false;
     if (/^\d+$/.test(raw))
         return Number(raw);
     if (raw === 'true')
@@ -131,8 +138,9 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
     // the root span carries the full user message and answer.
     if (process.env.OTEL_CONSOLE_SPANS === undefined)
         process.env.OTEL_CONSOLE_SPANS = 'false';
-    // ADK's INFO/DEBUG logs carry raw event JSON; keep them quiet.
-    setLogLevel(LogLevel.WARN);
+    // The engine's level, which ADK's logger follows: ADK's INFO/DEBUG logs
+    // carry raw event JSON, so keep them quiet.
+    setLogLevel('warn');
     const publicUrl = process.env.PUBLIC_URL?.trim() || undefined;
     const port = envInt('PORT', 4000);
     // ── Authentication posture ─────────────────────────────────────────────────
@@ -219,7 +227,28 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
         }
         return n;
     };
-    const servedAgents = list('A2A_SERVED_AGENTS');
+    // `*` serves every file in the agents directory and every registry row,
+    // stated on purpose; unset means the same off a public URL (ADR 0039).
+    const servedList = list('A2A_SERVED_AGENTS');
+    const servedAgents = servedList?.length === 1 && servedList[0] === '*' ? undefined : servedList;
+    // ── Public posture (ADR 0039) ──────────────────────────────────────────────
+    // A server on a public URL states how it authenticates, which agents it
+    // answers, and how many proxies stand in front of it. Each default was the
+    // permissive choice, so none is taken silently here.
+    if (publicUrl) {
+        const missing = [];
+        if (!process.env.A2A_AUTH?.trim()) {
+            missing.push('A2A_AUTH: callers or jwt (one identity per caller; recommended), header (a gateway authenticates users), or secret (one shared secret; any holder can act as any user by naming them in X-User-Id)');
+        }
+        if (!servedList?.length) {
+            missing.push('A2A_SERVED_AGENTS: the agent ids this server answers, comma-separated, or * for every file in the agents directory and every registry row');
+        }
+        if (!process.env.A2A_TRUST_PROXY?.trim()) {
+            missing.push('A2A_TRUST_PROXY: how many proxies stand in front of this server (1 behind one load balancer), or false when clients connect directly');
+        }
+        if (missing.length)
+            fatal(`PUBLIC_URL is set, so this server must state its security posture. Set:\n  - ${missing.join('\n  - ')}`);
+    }
     const registryAgents = list('A2A_REGISTRY_AGENTS');
     // Storage: Postgres when DATABASE_URL is set (every durable store, safe
     // across instances); otherwise createA2AApp's default (Supabase, else memory).
@@ -305,6 +334,8 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
             allowSchemaMismatch: process.env.ALLOW_SCHEMA_MISMATCH?.trim().toLowerCase() === 'true',
             turnLockWaitMs: envInt('A2A_TURN_LOCK_WAIT_MS', 30_000),
             maxConcurrentTasks: envInt('A2A_MAX_CONCURRENT_TASKS', 0),
+            maxConcurrentPerScope: envInt('A2A_MAX_CONCURRENT_PER_SCOPE', 4),
+            maxConcurrentPerCaller: envInt('A2A_MAX_CONCURRENT_PER_CALLER', 0),
             rateLimit: { windowMs: envInt('A2A_RATE_LIMIT_WINDOW_MS', 15 * 60 * 1000), max: envInt('A2A_RATE_LIMIT_MAX', 60) },
             authFailureLimit: { windowMs: 15 * 60 * 1000, max: envInt('A2A_AUTH_FAILURE_MAX', 30) },
             trustProxy: envTrustProxy(),
@@ -334,7 +365,7 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
     const authMode = `${identityLabel || (secret ? 'bearer secret' : 'no secret (loopback only)')}; keys: ${keyMode === 'byok' ? "caller's X-API-Key (byok)" : "server's own"}`;
     // The secret is not needed past this point; drop the reference.
     secret = undefined;
-    const { app, config, sessionBackend, shutdown } = built;
+    const { app, config, sessionBackend, shutdown, markUnready } = built;
     const server = await new Promise((resolve) => {
         const s = host ? app.listen(port, host, () => resolve(s)) : app.listen(port, () => resolve(s));
     });
@@ -364,13 +395,26 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
     // ── Lifecycle ──────────────────────────────────────────────────────────────
     let stopping = false;
     const graceMs = envInt('A2A_SHUTDOWN_GRACE_MS', 25_000);
+    // A load balancer keeps sending requests for a few seconds after SIGTERM,
+    // until it sees /readyz fail and deregisters this instance. Closing the
+    // listener at once would refuse those requests; fail readiness first and
+    // keep serving for the delay, then close and drain. The delay is part of
+    // the grace budget (running tasks keep running through it), so a stop still
+    // takes at most A2A_SHUTDOWN_GRACE_MS, inside Kubernetes' default 30 s.
+    const delayMs = Math.min(envInt('A2A_SHUTDOWN_DELAY_MS', 5_000), graceMs);
     const stop = async (signal) => {
         if (stopping)
             return;
         stopping = true;
-        emit('info', `[A2A] ${signal}: draining — no new tasks; waiting up to ${graceMs} ms for running ones.`);
+        markUnready();
+        if (delayMs > 0) {
+            emit('info', `[A2A] ${signal}: /readyz now fails; still serving for ${delayMs} ms while the load balancer deregisters this instance.`);
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+        const drainMs = graceMs - delayMs;
+        emit('info', `[A2A] ${signal}: draining — no new tasks; waiting up to ${drainMs} ms for running ones.`);
         server.close();
-        const canceled = await shutdown(graceMs);
+        const canceled = await shutdown(drainMs);
         if (canceled > 0)
             emit('warn', `[A2A] ⚠ ${canceled} task(s) did not finish in time and were canceled.`);
         // Give canceled tasks a moment to publish their final status, then flush

package/dist/scripts/assistant_worker.d.ts

@@ -13,7 +13,8 @@
  *   and writes the result (or the error) back to the store, where
  *   `task_get` reads it in a later conversation.
  *
- *   A job runs through lib/runtime/syndicateTurn.ts, the same runtime the
+ *   A job runs through lib/runtime/syndicateTurn.ts (on the runtime
+ *   MELCHIZEDEK_RUNTIME names, ADK by default), the same runtime the
  *   A2A server, the REPL and the observatory use, so it runs the exact agent
  *   the conversation would have called directly — with the same step cap —
  *   and the job timeout ABORTS the run (the model call in flight included)

package/dist/scripts/assistant_worker.js

@@ -13,7 +13,8 @@
  *   and writes the result (or the error) back to the store, where
  *   `task_get` reads it in a later conversation.
  *
- *   A job runs through lib/runtime/syndicateTurn.ts, the same runtime the
+ *   A job runs through lib/runtime/syndicateTurn.ts (on the runtime
+ *   MELCHIZEDEK_RUNTIME names, ADK by default), the same runtime the
  *   A2A server, the REPL and the observatory use, so it runs the exact agent
  *   the conversation would have called directly — with the same step cap —
  *   and the job timeout ABORTS the run (the model call in flight included)
@@ -31,17 +32,19 @@
  *   and must match the chat process's value. Run ONE worker per store.
  */
 import { randomUUID } from 'node:crypto';
-import { InMemorySessionService, LogLevel, setLogLevel } from '@google/adk';
 import { loadEnv } from '../lib/loadEnv.js';
 import { loadSyndicate } from '../lib/loadSyndicate.js';
 import { runSyndicateTurn } from '../lib/runtime/syndicateTurn.js';
+import { asAdkSessionService } from '../lib/runtime/adkSessionBridge.js';
+import { setLogLevel } from '../lib/runtime/logging.js';
+import { InProcessSessionService } from '../lib/runtime/sessions.js';
 import { PROVIDERS, providerForModel, providerKeyPresent, registerAvailableProviders, } from '../lib/models/registry.js';
 import { getTaskBackend, setTaskBackend, taskStorePath } from '../lib/tools/taskTools.js';
 import { postgresStorage } from '../lib/storage/postgres/index.js';
 import { dbSchema } from '../lib/storage/schema.js';
 import { hostname } from 'node:os';
 loadEnv(import.meta.url);
-setLogLevel(LogLevel.WARN);
+setLogLevel('warn');
 registerAvailableProviders();
 // ── CLI ──────────────────────────────────────────────────────────────────────
 const argv = process.argv.slice(2).filter((a) => a !== '--');
@@ -111,7 +114,9 @@ async function runJob(job) {
             appName: 'assistant-worker',
             userId: 'local-user',
             sessionId: randomUUID(),
-            sessionService: new InMemorySessionService(),
+            // A fresh in-process store per job, as the turn runner's signature
+            // names it (ADR 0080). The runtime follows MELCHIZEDEK_RUNTIME.
+            sessionService: asAdkSessionService(new InProcessSessionService()),
             compile: { log, onUnknownTool: (n) => log(`unknown tool '${n}' skipped`) },
             signal: current.signal,
             deadlineMs: JOB_TIMEOUT_MS,

package/dist/scripts/db.d.ts

@@ -22,5 +22,14 @@
 /** db/migrations/NNNN_name.sql, in numeric order. */
 export declare function migrationFiles(dir?: string): string[];
 export declare function installOrder(withTelemetry: boolean): string[];
+/**
+ * The whole install as one psql script: an advisory lock first, then every
+ * file in order with a progress line before each. psql runs it with
+ * --single-transaction and ON_ERROR_STOP, so a failure anywhere rolls the
+ * whole install back (no half-applied migration), and a second `apply`
+ * started meanwhile waits on the lock instead of interleaving with this one.
+ */
+export declare const APPLY_LOCK_KEY = "melchizedek-db apply";
+export declare function applyScript(files: string[], sqlOf: (file: string) => string, label?: (file: string) => string): string;
 /** postgres://user:pass@host:port/db?sslmode=… → libpq environment variables. */
 export declare function pgEnv(url: string): Record<string, string>;

package/dist/scripts/db.js

@@ -42,6 +42,20 @@ export function installOrder(withTelemetry) {
     const base = [...migrationFiles(), 'hardening.sql'];
     return withTelemetry ? [...base, 'telemetry.sql', 'hardening.sql'] : base;
 }
+/**
+ * The whole install as one psql script: an advisory lock first, then every
+ * file in order with a progress line before each. psql runs it with
+ * --single-transaction and ON_ERROR_STOP, so a failure anywhere rolls the
+ * whole install back (no half-applied migration), and a second `apply`
+ * started meanwhile waits on the lock instead of interleaving with this one.
+ */
+export const APPLY_LOCK_KEY = 'melchizedek-db apply';
+export function applyScript(files, sqlOf, label = (f) => `db/${f}`) {
+    const parts = [`SELECT pg_advisory_xact_lock(hashtext('${APPLY_LOCK_KEY}'));\n`];
+    for (const file of files)
+        parts.push(`\\echo '→ applying ${label(file).replace(/'/g, '')}'\n`, sqlOf(file), '\n');
+    return parts.join('');
+}
 /** postgres://user:pass@host:port/db?sslmode=… → libpq environment variables. */
 export function pgEnv(url) {
     const u = new URL(url);
@@ -100,21 +114,22 @@ async function main() {
                 console.error('  or set DATABASE_URL to the Postgres connection string (Supabase: Settings → Database).');
                 process.exit(1);
             }
-            for (const file of installOrder(withTelemetry)) {
-                console.log(`→ applying db/${file}${schema === 'public' ? '' : ` into schema ${schema}`}`);
-                const r = spawnSync('psql', ['-v', 'ON_ERROR_STOP=1', '-q', '-f', '-'], {
-                    input: sqlOf(file),
-                    stdio: ['pipe', 'inherit', 'inherit'],
-                    // The connection goes to psql as PG* variables, never as an
-                    // argument, so the password stays out of the process list.
-                    env: { ...process.env, ...pgEnv(url) },
-                });
-                if (r.error) {
-                    console.error(`✗ could not run psql (${r.error.message}). Install the Postgres client, or use \`print\`.`);
-                    process.exit(1);
-                }
-                if (r.status !== 0)
-                    process.exit(r.status ?? 1);
+            // One transaction under one lock (see applyScript): all of it, or none.
+            const script = applyScript(installOrder(withTelemetry), sqlOf, (f) => `db/${f}${schema === 'public' ? '' : ` into schema ${schema}`}`);
+            const r = spawnSync('psql', ['-v', 'ON_ERROR_STOP=1', '-q', '--single-transaction', '-f', '-'], {
+                input: script,
+                stdio: ['pipe', 'inherit', 'inherit'],
+                // The connection goes to psql as PG* variables, never as an
+                // argument, so the password stays out of the process list.
+                env: { ...process.env, ...pgEnv(url) },
+            });
+            if (r.error) {
+                console.error(`✗ could not run psql (${r.error.message}). Install the Postgres client, or use \`print\`.`);
+                process.exit(1);
+            }
+            if (r.status !== 0) {
+                console.error('✗ the install failed and was rolled back: the database is as it was before `apply`.');
+                process.exit(r.status ?? 1);
             }
             console.log('✓ database is installed and hardened');
             return;

package/dist/scripts/syndicate_chat.js

@@ -5,7 +5,11 @@ import { join } from 'node:path';
 import { loadSyndicate, parseCliBindings } from '../lib/loadSyndicate.js';
 import { isDispatchSyndicate } from '../lib/dispatch.js';
 import { approvalResponsePart, describeApproval, describeInput, ingestTurnMemory, runSyndicateTurn } from '../lib/runtime/syndicateTurn.js';
-import { InMemorySessionService, getFunctionCalls, getFunctionResponses, setLogLevel, LogLevel, } from '@google/adk';
+import { getFunctionCalls, getFunctionResponses } from '../lib/runtime/events.js';
+import { InProcessSessionService } from '../lib/runtime/sessions.js';
+import { asAdkSessionService, asSessionService } from '../lib/runtime/adkSessionBridge.js';
+import { asAdkMemoryService } from '../lib/runtime/adkMemoryBridge.js';
+import { setLogLevel } from '../lib/runtime/logging.js';
 import { randomUUID } from 'node:crypto';
 import { loadEnv } from '../lib/loadEnv.js';
 // ── LLM Provider Registration ─────────────────────────────────────────────────
@@ -18,8 +22,8 @@ import { registerAvailableProviders, providerForModel, providerKeyPresent, PROVI
 // ── Persistence Factory ───────────────────────────────────────────────────────
 // Supabase-specific initialization lives in supabaseProvider.ts.
 import { hasSupabaseCredentials, createSupabaseServices, } from '../lib/persistence/supabaseProvider.js';
-// Silence ADK verbose INFO logging natively
-setLogLevel(LogLevel.WARN);
+// The engine's level, which ADK's logger follows: no INFO chatter in the chat.
+setLogLevel('warn');
 const c = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -175,7 +179,10 @@ async function main() {
     // The same services the server would use for this syndicate's
     // memory_system: Supabase sessions (and the memory service for
     // long-term) when configured, process memory otherwise.
-    let sessionService = new InMemorySessionService();
+    // The engine's stores (ADR 0080): the in-process one, or Supabase's,
+    // which has both faces. The turn runner takes ADK's face (its signature
+    // is fixed), and follows MELCHIZEDEK_RUNTIME for the runtime.
+    let sessionService = new InProcessSessionService();
     let memoryService;
     if (persistence.sessionService === 'supabase') {
         const services = await createSupabaseServices({
@@ -188,7 +195,9 @@ async function main() {
         memoryService = services.memoryService;
     }
     const appName = config.syndicate_name || 'melchizedek-syndicate';
-    await sessionService.createSession({ appName, userId: SESSION_USER_ID, sessionId: SESSION_ID, state: {} });
+    await asSessionService(sessionService).create({ appName, userId: SESSION_USER_ID, sessionId: SESSION_ID, state: {} });
+    const turnSessions = asAdkSessionService(sessionService);
+    const turnMemory = memoryService ? asAdkMemoryService(memoryService) : undefined;
     banner(config, persistence, mergedBindings, SESSION_ID);
     // Plan-dispatch, nested yaml_reference syndicates, guards and the
     // max_steps cap run here exactly as the A2A server runs them: both call
@@ -227,8 +236,8 @@ async function main() {
                 appName,
                 userId: SESSION_USER_ID,
                 sessionId: SESSION_ID,
-                sessionService,
-                memoryService,
+                sessionService: turnSessions,
+                memoryService: turnMemory,
                 compile: {
                     onUnknownTool: (name) => console.warn(`${c.yellow}⚠ Unknown tool: '${name}' — skipping.${c.reset}`),
                     log: (message) => console.log(`${c.dim}  ${message}${c.reset}`),
@@ -276,12 +285,12 @@ async function main() {
         }
     }
     const ingest = async () => {
-        if (!memoryService)
+        if (!turnMemory)
             return;
         try {
             const ingested = await ingestTurnMemory({
-                memoryService,
-                sessionService,
+                memoryService: turnMemory,
+                sessionService: turnSessions,
                 appName,
                 userId: SESSION_USER_ID,
                 sessionId: SESSION_ID,