@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/service.js

@@ -14,7 +14,7 @@ import { Store } from './store.js';
 import { acquireStateLock } from './state-lock.js';
 import { Artifacts } from './artifacts.js';
 import { Supervisor } from './supervisor.js';
-import { canonical, integer, object, ServiceError, string } from './protocol.js';
+import { canonical, digest, integer, object, ServiceError, string } from './protocol.js';
 import { readJson } from './transport.js';
 import { Dispatcher } from './dispatcher.js';
 import { ManagedWork } from './managed.js';
@@ -24,7 +24,17 @@ import { engineRequest } from './execution-boundary.js';
 import { DockerCodingExecutor } from './coding-executor.js';
 import { Workspaces } from './workspaces.js';
 import { CodingWork } from './coding.js';
+import { AgentProfiles } from './agent-profiles.js';
+import { RepositorySnapshots } from './repository-snapshots.js';
+import { TeamWork } from './team-work.js';
+import { WorkerWorkspaces } from './worker-workspaces.js';
+import { ExternalWork } from './external-work.js';
+import { DockerHarnessBackend } from './harness-backend.js';
+import { A2AInbound } from './a2a-inbound.js';
+import { A2ABackend, ExternalBackends } from './a2a-backend.js';
 export class SalaamService {
+    external;
+    a2aInbound;
     stateDir;
     socket;
     bridgeSocket;
@@ -43,6 +53,10 @@ export class SalaamService {
     dispatcher;
     managed;
     children;
+    agents;
+    repositories;
+    team;
+    workerWorkspaces;
     workspaces;
     coding;
     codingSocket;
@@ -72,6 +86,13 @@ export class SalaamService {
                 this.tasks = new TaskContext(this.store, this.artifacts);
                 this.taskWork = new TaskWork(this.store, this.tasks);
                 this.taskBudget = new TaskBudget(this.store, this.taskWork);
+                if (options.admitModelRequest) {
+                    const taskAdmission = this.store.taskModelAdmission;
+                    this.store.taskModelAdmission = (session, attempt, input, output) => {
+                        taskAdmission(session, attempt, input, output);
+                        options.admitModelRequest(session, attempt, input, output);
+                    };
+                }
                 this.workspaces = new Workspaces(this.store, this.artifacts, options.codingRoot);
                 if (options.codingSocket && !options.codingRoot)
                     throw new Error('Command execution requires an explicit --coding-root');
@@ -79,6 +100,23 @@ export class SalaamService {
                     (options.codingSocket
                         ? new DockerCodingExecutor(engineRequest(options.codingSocket))
                         : undefined);
+                if (options.harnessConfig &&
+                    (options.externalBackend ||
+                        !(executor instanceof DockerCodingExecutor) ||
+                        !options.codingSocket ||
+                        !options.codingRoot))
+                    throw Error('Harness configuration requires the real configured Docker executor and an exclusive backend');
+                if (options.a2aConfig && (options.externalBackend || !options.codingRoot || !executor))
+                    throw Error('A2A configuration requires an owned coding root/executor and an exclusive backend');
+                const externalBackend = options.externalBackend ??
+                    new ExternalBackends([
+                        ...(options.harnessConfig
+                            ? [
+                                new DockerHarnessBackend(resolve(options.harnessConfig), join(resolve(options.codingRoot), 'external'), options.codingSocket, executor),
+                            ]
+                            : []),
+                        ...(options.a2aConfig ? [new A2ABackend(resolve(options.a2aConfig))] : []),
+                    ]);
                 this.coding = new CodingWork(this.store, this.workspaces, this.artifacts, executor, (id, error) => this.supervisor.failControl(id, error));
                 this.taskVerification = new TaskVerification(this.store, this.taskWork, this.taskBudget, this.workspaces, this.coding, this.artifacts);
                 this.taskCheckpoints = new TaskCheckpoints(this.store, this.taskWork, this.taskVerification, this.workspaces, this.artifacts);
@@ -89,22 +127,59 @@ export class SalaamService {
                     effectsEnabled: !!options.effectConnector,
                 });
                 this.supervisor.tasks = this.tasks;
+                this.taskWork.providerCheck = (limits) => this.supervisor.assertTaskProviderSupported(limits);
                 this.supervisor.coding = this.coding;
                 this.managed = new ManagedWork(this.store, {
                     connector: options.effectConnector,
                     approvalTtlMs: options.approvalTtlMs,
-                    assertActive: (id, epoch, attempt) => this.supervisor.assertActive(id, epoch, attempt),
+                    assertActive: (id, epoch, attempt) => this.external?.owns(id)
+                        ? this.external.assertActive(id, epoch, attempt)
+                        : this.supervisor.assertActive(id, epoch, attempt),
                     reply: (id, epoch, request, confirmed) => this.supervisor.replyUI(id, epoch, request, confirmed),
-                    failed: (id, error) => this.supervisor.failControl(id, error),
+                    failed: (id, error) => this.external?.owns(id)
+                        ? this.external.failControl(id, error)
+                        : this.supervisor.failControl(id, error),
                 });
                 this.supervisor.managed = this.managed;
-                this.children = new ChildWork(this.store, this.artifacts, this.supervisor);
+                this.agents = new AgentProfiles(this.store, this.supervisor.route, async (route, session) => {
+                    const prepared = await this.supervisor.prepareProviderRoute(route);
+                    const task = this.taskWork.forSession(session);
+                    if (task)
+                        this.supervisor.assertTaskProviderSupported(task.limits, prepared.output_cap);
+                    return { route: prepared.route, output_cap: prepared.output_cap };
+                });
+                this.store.workerBoundary.profiles = this.agents;
+                this.agents.validateFrame = (session) => {
+                    this.tasks.frame(session, 'x'.repeat(32));
+                };
+                this.repositories = new RepositorySnapshots(this.store, this.artifacts, this.workspaces);
+                this.supervisor.repositories = this.repositories;
+                this.children = new ChildWork(this.store, this.artifacts, this.supervisor, this.repositories);
                 this.supervisor.children = this.children;
+                this.workerWorkspaces = new WorkerWorkspaces(this.store, this.workspaces, this.repositories, this.artifacts, this.coding, this.children);
+                this.children.workspaces = this.workerWorkspaces;
+                this.agents.assertExecution = () => {
+                    this.workerWorkspaces.execution();
+                };
+                this.store.workerBoundary.assertIsolation = (binding) => this.workerWorkspaces.assert(binding);
+                this.taskWork.assertStepReview = (task, step) => this.workerWorkspaces.assertStepReview(task, step);
+                this.team = new TeamWork(this.store, this.taskWork, this.taskBudget, this.children, this.agents);
+                this.supervisor.team = this.team;
+                this.external = new ExternalWork(this.store, this.artifacts, this.children, this.taskBudget, this.managed, this.workspaces, externalBackend, options.admitModelRequest);
+                this.children.external = this.external;
+                const guardSubmission = this.store.guardTaskSubmission;
+                this.store.guardTaskSubmission = (session, step) => {
+                    const child = this.children.owned(session);
+                    if (child && this.store.workerBoundary.view(child.id).binding.external)
+                        throw new ServiceError('external_worker_owned', 'Use the owning team assignment and an explicit continuation');
+                    guardSubmission(session, step);
+                };
                 this.dispatcher = new Dispatcher(this.store, this.supervisor);
                 this.taskDriver = new TaskDriver(this.store, this.taskWork, this.taskBudget, this.taskVerification, this.supervisor, this.children, this.coding);
                 this.jobs = new JobWork(this.store, this.taskWork, this.taskDriver, this.taskVerification, this.managed);
                 this.recurring = new RecurringWork(this.jobs);
                 this.inbox = new OperatorInbox(this.store, (error) => {
+                    this.external.failAll(error);
                     for (const session of this.store.sessions())
                         this.supervisor.failControl(session.id, error);
                 });
@@ -164,19 +239,27 @@ export class SalaamService {
                 (service.coding.executor?.profileDigest !== options.expectedExecution.profile_digest ||
                     service.coding.executor?.engineId !== options.expectedExecution.engine_id))
                 throw new Error('Host executor does not match reviewed manifest');
+            await service.supervisor.providerAuth();
+            await service.external.backend?.prepare?.();
             await service.supervisor.recover();
+            await service.external.recover();
             service.store.recoverWork();
             service.taskWork.recover();
             service.tasks.recover();
             service.workspaces.recover();
             service.coding.recover();
             service.children.recover();
+            service.workerWorkspaces.recover();
             service.managed.recover();
             await service.managed.reconcileAll();
             service.taskCheckpoints.recover();
             await service.jobs.recover();
             await service.recurring.recover();
             service.inbox.reconcile();
+            if (options.a2aListenConfig) {
+                service.a2aInbound = new A2AInbound(service, resolve(options.a2aListenConfig));
+                await service.a2aInbound.listen();
+            }
             await service.listen(service.bridgeServer, service.bridgeSocket);
             await service.listen(service.operator, service.socket);
             service.taskDriver.start();
@@ -213,6 +296,46 @@ export class SalaamService {
                 throw new ServiceError('stopping', 'Service is stopping', 503);
             const url = new URL(req.url ?? '/', 'http://local');
             const parts = url.pathname.split('/').filter(Boolean);
+            if (!bridge &&
+                req.method === 'GET' &&
+                parts[0] === 'v1' &&
+                parts[1] === 'a2a' &&
+                parts[2] === 'grants' &&
+                parts[3] &&
+                parts.length === 4) {
+                this.send(res, 200, A2AInbound.binding(this, parts[3]));
+                return;
+            }
+            if (!bridge && parts[0] === 'v1' && parts[1] === 'harnesses') {
+                if (req.method === 'GET' && parts.length === 2) {
+                    this.send(res, 200, this.external.runtimes());
+                    return;
+                }
+                if (parts[2]) {
+                    const raw = this.store.db
+                        .prepare('SELECT * FROM child_tasks WHERE id=?')
+                        .get(parts[2]);
+                    if (!raw || !this.store.workerBoundary.view(raw.id).binding.external)
+                        throw new ServiceError('not_found', 'External worker not found', 404);
+                    if (req.method === 'GET' && parts.length === 3) {
+                        this.send(res, 200, {
+                            child: this.children.inspect(raw.parent_session, raw.id),
+                            execution: this.external.view(raw.id),
+                        });
+                        return;
+                    }
+                    if (req.method === 'POST' && parts.length === 4 && parts[3] === 'reconcile') {
+                        const body = object(await readJson(req));
+                        const result = await this.external.reconcile(raw, string(body.request_id, 'request_id', 128), string(body.run_id, 'run_id', 128), () => this.store.authorizeControl(raw.parent_session, {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }));
+                        this.send(res, 200, result);
+                        return;
+                    }
+                }
+                throw new ServiceError('not_found', 'External worker route not found', 404);
+            }
             if (bridge) {
                 if (req.method !== 'POST' || parts.length !== 3 || parts[0] !== 'worker')
                     throw new ServiceError('not_found', 'Bridge route not found', 404);
@@ -332,7 +455,95 @@ export class SalaamService {
                 }
                 throw new ServiceError('not_found', 'Job route not found', 404);
             }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'integrations' &&
+                parts[2] &&
+                parts.length === 4 &&
+                parts[3] === 'resolve' &&
+                req.method === 'POST') {
+                const body = object(await readJson(req)), controller = {
+                    client_id: string(body.client_id, 'client_id', 128),
+                    token: string(body.token, 'token', 128),
+                }, parent = this.workerWorkspaces.owner(parts[2]);
+                this.send(res, 200, this.workerWorkspaces.resolve(parts[2], string(body.request_id, 'request_id', 128), integer(body.workspace_revision, 'workspace_revision'), string(body.workspace_digest, 'workspace_digest', 128), () => this.store.authorizeControl(parent, controller)));
+                return;
+            }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'integrations' &&
+                parts[2] &&
+                parts.length === 3 &&
+                req.method === 'GET') {
+                this.send(res, 200, this.workerWorkspaces.inspect(parts[2]));
+                return;
+            }
+            if (parts[0] === 'v1' && parts[1] === 'workers' && parts[2] && parts.length === 4) {
+                const child = this.store.db
+                    .prepare('SELECT parent_session FROM child_tasks WHERE id=?')
+                    .get(parts[2]);
+                if (!child)
+                    throw new ServiceError('not_found', 'Worker not found', 404);
+                const parent = String(child.parent_session);
+                if (parts[3] === 'proposal' && req.method === 'GET') {
+                    this.send(res, 200, this.workerWorkspaces.proposal(parent, parts[2], integer(Number(url.searchParams.get('offset') ?? '0'), 'offset')));
+                    return;
+                }
+                if (parts[3] === 'integrate' && req.method === 'POST') {
+                    const body = object(await readJson(req)), controller = {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    };
+                    this.send(res, 200, this.workerWorkspaces.integrate(parent, parts[2], string(body.request_id, 'request_id', 128), integer(body.workspace_revision, 'workspace_revision'), string(body.workspace_digest, 'workspace_digest', 128), string(body.patch_digest, 'patch_digest', 128), () => this.store.authorizeControl(parent, controller)));
+                    return;
+                }
+            }
             if (parts[0] === 'v1' && parts[1] === 'tasks') {
+                if (parts[2] && parts[3] === 'team') {
+                    const task = this.taskWork.get(parts[2]);
+                    if (req.method === 'GET' && parts.length === 4) {
+                        this.send(res, 200, this.team.view(task.id));
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        const request = string(body.request_id, 'request_id', 128);
+                        const controller = {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        };
+                        const authorize = () => this.store.authorizeControl(task.session_id, controller);
+                        let result;
+                        if (parts.length === 5 && parts[4] === 'assign') {
+                            if (body.runtime !== undefined && body.requests !== undefined)
+                                throw new ServiceError('worker_budget_scope', 'Use invocations for an external runtime; requests always means model requests', 400);
+                            result = this.team.assign(task.id, string(body.step_id, 'step_id', 128), string(body.profile_id, 'profile_id', 128), integer(body.runtime === undefined ? body.requests : body.invocations, body.runtime === undefined ? 'requests' : 'invocations'), request, integer(body.expected_revision, 'expected_revision'), controller, body.runtime === undefined ? undefined : string(body.runtime, 'runtime', 128));
+                        }
+                        else if (parts.length === 5 && parts[4] === 'send') {
+                            result = this.team.send(task.id, 'operator', string(body.recipient, 'recipient', 128), string(body.text, 'text', 4096), request, authorize);
+                        }
+                        else if (parts.length === 6 && parts[4]) {
+                            const assignment = this.team.get(parts[4]);
+                            if (assignment.task_id !== task.id)
+                                throw new ServiceError('team_message_scope', 'Assignment belongs to another task');
+                            if (parts[5] === 'run')
+                                result = this.team.run(assignment.id, request, integer(body.expected_revision, 'expected_revision'), integer(body.generation, 'generation'), body.instruction == null ? null : string(body.instruction, 'instruction', 4096), body.continues_attempt_id == null
+                                    ? null
+                                    : string(body.continues_attempt_id, 'continues_attempt_id', 128), controller);
+                            else if (parts[5] === 'reject')
+                                result = this.team.reject(assignment.id, request, integer(body.expected_revision, 'expected_revision'), integer(body.generation, 'generation'), string(body.reason, 'reason', 4096), controller);
+                            else if (parts[5] === 'receive')
+                                result = this.team.receive(assignment.id, request, authorize);
+                            else if (parts[5] === 'ack')
+                                result = this.team.acknowledge(assignment.id, string(body.message_id, 'message_id', 128), request, authorize);
+                            else
+                                throw new ServiceError('not_found', 'Team action not found', 404);
+                        }
+                        else
+                            throw new ServiceError('not_found', 'Team route not found', 404);
+                        this.send(res, 200, result);
+                        return;
+                    }
+                    throw new ServiceError('not_found', 'Team route not found', 404);
+                }
                 if (req.method === 'GET' && parts.length === 2) {
                     const session = string(url.searchParams.get('session_id'), 'session_id', 128);
                     this.store.session(session);
@@ -430,6 +641,22 @@ export class SalaamService {
                 const sessions = this.store.sessions().map((x) => this.supervisor.inspect(x.id));
                 this.send(res, 200, {
                     service: 'healthy',
+                    a2a: {
+                        inbound_enabled: !!this.a2aInbound,
+                        listener: this.a2aInbound?.server.address() ?? null,
+                        wire_version: '1.0',
+                        remote_execution: 'unobserved',
+                        inbound_authority: 'one-use-native-analysis-assignment',
+                    },
+                    external_workers: {
+                        control: this.external.status(),
+                        runtimes: this.external.runtimes(),
+                        opaque_budget: 'explicit-invocations-only',
+                        unknown_model_usage: true,
+                        uncertain_stops: Number(this.store.db
+                            .prepare("SELECT count(*) AS n FROM external_runs WHERE stopped=0 AND state='unknown'")
+                            .get().n),
+                    },
                     job_execution: {
                         durable_jobs: true,
                         one_shot_triggers: !!this.coding.executor,
@@ -441,16 +668,18 @@ export class SalaamService {
                         control_error: this.jobs.controlError,
                     },
                     task_execution: {
-                        durable_tasks: true,
+                        durable_tasks: this.supervisor.providerCapabilities().durable_tasks,
                         explicit_steps: true,
                         automatic_progression: 'operator-bounded-opt-in',
                         verified_completion: !!this.coding.executor,
                         verification_supported: true,
                         task_budgets: true,
+                        task_token_budgets: this.supervisor.providerCapabilities().output_token_cap,
                         checkpoints: true,
                         deterministic_compaction: 'operator-bounded-idle-only',
                     },
                     provider_route: this.supervisor.route,
+                    provider_capabilities: this.supervisor.providerCapabilities(),
                     effect_connector: this.managed.options.connector?.id ?? null,
                     coding_root: this.workspaces.root ?? null,
                     coding_socket: this.codingSocket,
@@ -524,6 +753,40 @@ export class SalaamService {
             }
             if (parts[0] === 'v1' && parts[1] === 'sessions' && parts[2]) {
                 const id = parts[2];
+                if (parts[3] === 'agents') {
+                    if (req.method === 'GET') {
+                        const profile = url.searchParams.get('profile');
+                        this.send(res, 200, profile
+                            ? {
+                                ...this.agents.inspect(id, profile),
+                                digest: digest(this.agents.inspect(id, profile)),
+                            }
+                            : this.agents.list(id).map((p) => ({ ...p, digest: digest(p) })));
+                        return;
+                    }
+                    const body = object(await readJson(req));
+                    const controller = {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    };
+                    const request = string(body.request_id, 'request_id', 128);
+                    if (parts[4] === 'admit') {
+                        const facts = body.fact_ids === undefined
+                            ? []
+                            : Array.isArray(body.fact_ids)
+                                ? body.fact_ids.map((x) => string(x, 'fact_id', 128))
+                                : (() => {
+                                    throw new ServiceError('invalid_field', 'fact_ids must be an array');
+                                })();
+                        this.send(res, 201, await this.agents.admit(id, request, string(body.profile_id, 'profile_id', 128), string(body.expected_digest, 'expected_digest', 64), facts, controller));
+                        return;
+                    }
+                    if (parts[4] === 'revoke') {
+                        this.send(res, 200, this.agents.revoke(id, string(body.grant_id, 'grant_id', 128), request, controller));
+                        return;
+                    }
+                    throw new ServiceError('not_found', 'Agent operation not found', 404);
+                }
                 if (parts[3] === 'activity' && req.method === 'GET') {
                     this.store.session(id);
                     const rows = this.store.db
@@ -693,10 +956,10 @@ export class SalaamService {
                     token: string(body.token, 'token', 128),
                 });
                 this.coding.cancelAttempt(attempt);
-                void this.children
-                    .cancelOwned(attempt)
-                    .then(() => this.supervisor.cancelAttempt(attempt))
-                    .catch((error) => this.supervisor.failControl(this.store.attempt(attempt).session_id, error));
+                const owned = this.children.owned(this.store.attempt(attempt).session_id);
+                void (owned && this.store.workerBoundary.view(owned.id).binding.external
+                    ? this.external.cancel(owned)
+                    : this.children.cancelOwned(attempt).then(() => this.supervisor.cancelAttempt(attempt))).catch((error) => this.supervisor.failControl(this.store.attempt(attempt).session_id, error));
                 this.send(res, 202, receipt);
                 return;
             }
@@ -905,6 +1168,8 @@ export class SalaamService {
         this.children.pause();
         const errors = [];
         try {
+            await this.a2aInbound?.close();
+            await this.external.close();
             await this.coding.close();
             try {
                 await this.children.close();

package/dist/src/store.js

@@ -3,6 +3,7 @@ import { chmodSync } from 'node:fs';
 import { randomUUID, randomBytes } from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import { UsageLedger } from './usage.js';
+import { WorkerBoundary } from './worker-boundary.js';
 import { OFFLINE_ROUTE } from './provider-config.js';
 import { canonical } from './protocol.js';
 import { digest, ServiceError, textDigest, } from './protocol.js';
@@ -10,9 +11,11 @@ export class Store {
     db;
     changes = new EventEmitter();
     usage = new UsageLedger(this);
+    workerBoundary = new WorkerBoundary(this);
     reconcileCompactions;
     finishChild;
     projectTaskAttempt;
+    teamSnapshot;
     guardTaskSubmission;
     cancelChildren;
     recordTaskMutation;
@@ -32,7 +35,7 @@ export class Store {
         this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=1000;`);
         const version = this.db.prepare('PRAGMA user_version').get()
             .user_version;
-        if (version > 11) {
+        if (version > 17) {
             this.db.close();
             throw new ServiceError('schema_too_new', 'Database schema is newer than this service');
         }
@@ -158,6 +161,38 @@ export class Store {
           CREATE TABLE recurring_occurrences(id TEXT PRIMARY KEY,job_id TEXT NOT NULL REFERENCES recurring_jobs(id),occurrence_key TEXT NOT NULL,session_id TEXT NOT NULL UNIQUE REFERENCES sessions(id),job_run_id TEXT UNIQUE REFERENCES jobs(id),schedule_revision INTEGER NOT NULL,due_at INTEGER,state TEXT NOT NULL,error TEXT,created_at INTEGER NOT NULL,UNIQUE(job_id,occurrence_key));
           CREATE TABLE operator_inbox(id TEXT PRIMARY KEY,session_id TEXT NOT NULL REFERENCES sessions(id),source_key TEXT NOT NULL UNIQUE,kind TEXT NOT NULL,detail TEXT NOT NULL,revision INTEGER NOT NULL,state TEXT NOT NULL,ack_revision INTEGER NOT NULL DEFAULT 0,updated_at INTEGER NOT NULL);
           PRAGMA user_version=11; COMMIT;`);
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 12) {
+                this.db.exec('BEGIN IMMEDIATE');
+                this.workerBoundary.migrate();
+                this.db.exec('PRAGMA user_version=12; COMMIT;');
+            }
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 13)
+                this.db.exec(`BEGIN IMMEDIATE;
+          CREATE TABLE agent_grants(id TEXT PRIMARY KEY,owner_session TEXT NOT NULL REFERENCES sessions(id),profile_id TEXT NOT NULL,document TEXT NOT NULL,digest TEXT NOT NULL,state TEXT NOT NULL);
+          CREATE TABLE specialist_reports(worker_id TEXT PRIMARY KEY,input_digest TEXT NOT NULL,artifact_id TEXT NOT NULL REFERENCES artifacts(id));
+          PRAGMA user_version=13; COMMIT;`);
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 14)
+                this.db.exec(`BEGIN IMMEDIATE;
+          CREATE TABLE team_assignments(id TEXT PRIMARY KEY,task_id TEXT NOT NULL REFERENCES durable_tasks(id),step_id TEXT NOT NULL REFERENCES task_steps(id),plan_revision INTEGER NOT NULL,profile_id TEXT NOT NULL,grant_id TEXT NOT NULL REFERENCES agent_grants(id),budget INTEGER NOT NULL,generation INTEGER NOT NULL DEFAULT 0,child_id TEXT REFERENCES child_tasks(id),superseded INTEGER NOT NULL DEFAULT 0);
+          CREATE UNIQUE INDEX team_active_step ON team_assignments(step_id) WHERE superseded=0;
+          CREATE TABLE team_messages(id TEXT PRIMARY KEY,task_id TEXT NOT NULL REFERENCES durable_tasks(id),sender TEXT NOT NULL,recipient TEXT NOT NULL REFERENCES team_assignments(id),text TEXT NOT NULL,input_digest TEXT NOT NULL,created_at INTEGER NOT NULL,delivered_at INTEGER,acknowledged_at INTEGER);
+          PRAGMA user_version=14; COMMIT;`);
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 15)
+                this.db.exec(`BEGIN IMMEDIATE;
+          CREATE TABLE worker_integrations(id TEXT PRIMARY KEY,parent_session TEXT NOT NULL REFERENCES sessions(id),child_id TEXT NOT NULL UNIQUE REFERENCES child_tasks(id),worker_id TEXT NOT NULL,patch_digest TEXT NOT NULL,before_revision INTEGER NOT NULL,before_digest TEXT NOT NULL,after_artifact TEXT NOT NULL REFERENCES artifacts(id),state TEXT NOT NULL,mutation_id TEXT REFERENCES workspace_mutations(id),mutation_key TEXT NOT NULL UNIQUE,generation INTEGER NOT NULL DEFAULT 1);
+          CREATE TABLE team_rejections(step_id TEXT NOT NULL REFERENCES task_steps(id),attempt_id TEXT NOT NULL REFERENCES attempts(id),request_id TEXT NOT NULL,reason TEXT NOT NULL,PRIMARY KEY(step_id,attempt_id));
+          PRAGMA user_version=15; COMMIT;`);
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 16)
+                this.db.exec(`BEGIN IMMEDIATE;
+          CREATE TABLE external_assignments(assignment_id TEXT PRIMARY KEY REFERENCES team_assignments(id),runtime TEXT NOT NULL,digest TEXT NOT NULL);
+          CREATE TABLE external_runs(child_id TEXT PRIMARY KEY REFERENCES child_tasks(id),run_id TEXT NOT NULL UNIQUE,state TEXT NOT NULL,epoch INTEGER NOT NULL,checkpoint TEXT,receipt TEXT,stopped INTEGER NOT NULL DEFAULT 0,error TEXT,result TEXT,import_artifact TEXT REFERENCES artifacts(id));
+          CREATE TABLE task_invocations(attempt_id TEXT PRIMARY KEY REFERENCES attempts(id),task_id TEXT NOT NULL REFERENCES durable_tasks(id),runtime_id TEXT NOT NULL,input_digest TEXT NOT NULL,created_at INTEGER NOT NULL);
+          CREATE TABLE external_model_requests(id TEXT PRIMARY KEY,child_id TEXT NOT NULL REFERENCES external_runs(child_id),input_bytes INTEGER NOT NULL,output_bound INTEGER NOT NULL);
+          PRAGMA user_version=16; COMMIT;`);
+            if (this.db.prepare('PRAGMA user_version').get().user_version < 17)
+                this.db.exec(`BEGIN IMMEDIATE;
+          CREATE TABLE a2a_inbound(id TEXT PRIMARY KEY,peer TEXT NOT NULL,tenant TEXT NOT NULL,message_id TEXT NOT NULL,input_digest TEXT NOT NULL,assignment_id TEXT NOT NULL UNIQUE REFERENCES team_assignments(id),grant_digest TEXT NOT NULL,context_id TEXT NOT NULL UNIQUE,child_id TEXT NOT NULL UNIQUE REFERENCES child_tasks(id),created_at INTEGER NOT NULL,skill TEXT NOT NULL,cancel_requested INTEGER NOT NULL DEFAULT 0,UNIQUE(peer,tenant,message_id));
+          PRAGMA user_version=17; COMMIT;`);
         }
         catch (error) {
             if (this.db.isTransaction)
@@ -641,7 +676,14 @@ export class Store {
             operations: this.operations(id),
             children: this.db
                 .prepare('SELECT * FROM child_tasks WHERE parent_session=? ORDER BY rowid DESC LIMIT 100')
-                .all(id),
+                .all(id).map((child) => ({
+                ...child,
+                worker: this.workerBoundary.view(child.id),
+            })),
+            ...(this.workerBoundary.profiles
+                ? { agents: this.workerBoundary.profiles.snapshot(id) }
+                : {}),
+            ...(this.teamSnapshot ? { team: this.teamSnapshot(id) } : {}),
         };
     }
     cancelled(id) {