@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/supervisor.js

@@ -6,9 +6,13 @@ import { join, resolve } from 'node:path';
 import { PROTOCOL_VERSION, canonical, object, ServiceError, textDigest, workerTools, workerCapabilities, string, } from './protocol.js';
 import { PI_CLI, HOUSE_EXTENSION, POLICY_DIGEST, bundleDigest } from './config.js';
 import { PiProcess, PiCommandError } from './pi.js';
-import { OFFLINE_ROUTE, providerRoute, validateClaudePayload, } from './provider-config.js';
-import { loadApiKey, validateApiKey } from './credentials.js';
+import { OFFLINE_ROUTE, providerRoute, providerHasOutputCap, } from './provider-config.js';
+import { validateApiKey } from './credentials.js';
+import { resolveProviderAuth } from './provider-auth.js';
+import { bindProviderConfiguration } from './provider-model.js';
+import { validateProviderPayload } from './provider-payload.js';
 import { digest } from './protocol.js';
+import { repositoryPath } from './repository-snapshots.js';
 export function processIdentity(pid) {
     try {
         return (execFileSync('/bin/ps', ['-ww', '-p', String(pid), '-o', 'lstart=', '-o', 'command='], {
@@ -42,14 +46,70 @@ export class Supervisor extends EventEmitter {
     managed;
     children;
     coding;
+    repositories;
+    team;
+    routeFor(id) {
+        const child = this.children?.owned(id);
+        return child
+            ? (this.store.workerBoundary.view(child.id).binding.agent?.route ?? this.route)
+            : this.route;
+    }
+    async prepareProviderRoute(input) {
+        const route = structuredClone(input);
+        if (route.provider === 'salaam-proof')
+            return { route, output_cap: true, auth: undefined };
+        const auth = route.provider === 'anthropic' && this.apiKey
+            ? { auth: { apiKey: this.apiKey }, env: {} }
+            : await resolveProviderAuth(route, this.options.providerCredentials, this.options.providerEnvironment);
+        const bound = bindProviderConfiguration(route, auth);
+        return { route: bound, output_cap: providerHasOutputCap(bound, auth), auth };
+    }
     codingBinding(id) {
-        return this.children?.owned(id) ? undefined : this.coding?.binding(id);
+        const child = this.children?.owned(id), coding = this.coding?.binding(id);
+        if (!child)
+            return coding;
+        const binding = this.store.workerBoundary.view(child.id).binding;
+        return binding.isolation && coding
+            ? {
+                ...coding,
+                files: binding.tools.includes('salaam_files'),
+                commands: coding.commands && binding.tools.includes('salaam_command'),
+            }
+            : undefined;
     }
     tools(id) {
+        const child = this.children?.owned(id);
+        if (child)
+            return JSON.parse(child.authority);
         return workerTools(!!this.options.effectsEnabled, !!this.children?.owned(id), this.codingBinding(id));
     }
+    childBoundary(id, epoch) {
+        const child = this.children?.owned(id);
+        return child ? this.store.workerBoundary.assert(child, epoch, this.routeFor(id)) : undefined;
+    }
     route;
     apiKey;
+    outputCap = true;
+    authInitialized = false;
+    providerCapabilities() {
+        return {
+            output_token_cap: this.outputCap,
+            durable_tasks: true,
+            warning: this.outputCap
+                ? null
+                : 'No provider-enforced output cap; tasks must explicitly disable token budgeting',
+        };
+    }
+    assertTaskProviderSupported(limits, outputCap = this.outputCap) {
+        if (!outputCap && (limits.token_units !== null || limits.output_token_bound !== null))
+            throw new ServiceError('provider_capability', 'This provider authentication has no output cap; set limits.token_units to null and omit output_token_bound');
+    }
+    assertSessionProviderSupported(id, outputCap = this.outputCap) {
+        const parent = this.children?.owned(id)?.parent_session ?? id;
+        const task = this.tasks.work?.forSession(parent);
+        if (task)
+            this.assertTaskProviderSupported(task.limits, outputCap);
+    }
     bootId = randomUUID();
     workers = new Map();
     monitor;
@@ -58,23 +118,46 @@ export class Supervisor extends EventEmitter {
         super();
         this.store = store;
         this.options = options;
-        this.route = options.providerRoute ?? { ...OFFLINE_ROUTE };
+        this.route = structuredClone(options.providerRoute ?? OFFLINE_ROUTE);
         // Validate public configuration without trusting programmatic callers.
-        const checked = providerRoute(this.route.provider === 'salaam-proof' ? 'offline' : this.route.provider, this.route.provider === 'anthropic' ? this.route.model : undefined, this.route.provider === 'anthropic' ? this.route.max_tokens : undefined, this.route.workspace_id);
+        const checked = providerRoute(this.route.provider === 'salaam-proof' ? 'offline' : this.route.provider, this.route.provider !== 'salaam-proof' ? this.route.model : undefined, this.route.provider !== 'salaam-proof' ? this.route.max_tokens : undefined, this.route.workspace_id, this.route.connection);
         if (canonical(checked) !== canonical(this.route))
             throw new Error('Invalid provider route');
-        if (this.route.provider === 'anthropic')
-            this.apiKey = options.anthropicApiKey
-                ? validateApiKey(options.anthropicApiKey)
-                : loadApiKey();
+        if (options.anthropicApiKey)
+            this.apiKey = validateApiKey(options.anthropicApiKey);
         this.bundle = bundleDigest();
         this.monitor = setInterval(() => {
             for (const worker of this.workers.values())
-                if (worker.ready && Date.now() - worker.lastBeat > (options.heartbeatTimeout ?? 2500))
-                    this.invalidate(worker, 'Worker heartbeat expired');
+                if (worker.ready) {
+                    if (Date.now() - worker.lastBeat > (options.heartbeatTimeout ?? 2500))
+                        this.invalidate(worker, 'Worker heartbeat expired');
+                    const child = this.children?.owned(worker.id);
+                    if (child?.state === 'accepted') {
+                        try {
+                            this.childBoundary(worker.id, worker.epoch);
+                        }
+                        catch (error) {
+                            this.invalidate(worker, 'Worker boundary revoked: ' + error.message);
+                        }
+                    }
+                }
         }, 250);
         this.monitor.unref();
     }
+    async providerAuth() {
+        if (this.route.provider === 'salaam-proof')
+            return undefined;
+        if (this.route.provider === 'anthropic' && this.apiKey)
+            return { auth: { apiKey: this.apiKey }, env: {} };
+        const auth = await resolveProviderAuth(this.route, this.options.providerCredentials, this.options.providerEnvironment);
+        Object.assign(this.route, bindProviderConfiguration(this.route, auth));
+        const outputCap = providerHasOutputCap(this.route, auth);
+        if (this.authInitialized && this.outputCap !== outputCap)
+            throw new Error('Provider output-cap capability changed; restart the service before using the new authentication');
+        this.outputCap = outputCap;
+        this.authInitialized = true;
+        return auth;
+    }
     async recover() {
         const rows = this.store.db.prepare("SELECT * FROM workers WHERE state!='exited'").all();
         for (const row of rows) {
@@ -102,6 +185,10 @@ export class Supervisor extends EventEmitter {
         }
     }
     async start(id) {
+        const child = this.children?.owned(id);
+        if (child && this.store.workerBoundary.view(child.id).binding.runtime !== 'native-pi')
+            throw new ServiceError('external_worker_owned', 'Use the external worker lifecycle; Pi cannot claim this session');
+        const route = this.routeFor(id);
         const prior = this.workers.get(id);
         if (prior && !prior.stopping)
             throw new ServiceError('worker_exists', 'Worker already supervised');
@@ -113,7 +200,7 @@ export class Supervisor extends EventEmitter {
                 .prepare("SELECT 1 FROM workers WHERE session_id=? AND state!='exited' LIMIT 1")
                 .get(id))
             throw new ServiceError('reconciliation_required', previous.error ?? 'Session requires reconciliation');
-        this.store.bindRoute(id, this.route);
+        this.store.bindRoute(id, route);
         const epoch = this.store.allocate(id, this.bootId);
         let accept;
         let reject;
@@ -124,6 +211,7 @@ export class Supervisor extends EventEmitter {
         const binding = randomBytes(16).toString('hex');
         const frame = this.tasks.frame(id, binding);
         const worker = {
+            route: structuredClone(route),
             id,
             epoch,
             token: randomBytes(32).toString('hex'),
@@ -144,6 +232,9 @@ export class Supervisor extends EventEmitter {
         void handshake.catch(() => { });
         let timer;
         try {
+            const child = this.children?.owned(id);
+            if (child)
+                this.store.workerBoundary.claim(child, epoch, route);
             const workerDir = join(this.options.stateDir, 'workers', id);
             mkdirSync(join(workerDir, 'agent'), { recursive: true, mode: 0o700 });
             writeFileSync(join(workerDir, 'agent', 'settings.json'), JSON.stringify({
@@ -161,7 +252,8 @@ export class Supervisor extends EventEmitter {
                 frame,
                 effects: !!this.options.effectsEnabled && !this.children?.owned(id),
                 child: !!this.children?.owned(id),
-                route: this.route,
+                worker_binding: this.childBoundary(id, epoch),
+                route: route,
                 coding: this.codingBinding(id),
             };
             const args = [
@@ -187,9 +279,9 @@ export class Supervisor extends EventEmitter {
                 '--tools',
                 this.tools(id).join(','),
                 '--provider',
-                this.route.provider,
+                route.provider,
                 '--model',
-                this.route.model,
+                route.model,
             ];
             if (previous.pi_session_file && existsSync(previous.pi_session_file)) {
                 const index = args.indexOf('--session-id');
@@ -208,7 +300,7 @@ export class Supervisor extends EventEmitter {
                 LANG: process.env.LANG ?? 'en_US.UTF-8',
                 PI_CODING_AGENT_DIR: join(workerDir, 'agent'),
                 SALAAM_WORKER_CONFIG: JSON.stringify(config),
-                ...(this.apiKey ? { ANTHROPIC_API_KEY: this.apiKey } : {}),
+                ...(route.connection?.configuration ?? {}),
             };
             worker.pi = (this.options.launch ?? ((x) => new PiProcess(x.command, x.args, x.cwd, x.env)))({
                 command: process.execPath,
@@ -298,8 +390,7 @@ export class Supervisor extends EventEmitter {
             const file = typeof state.sessionFile === 'string' ? resolve(state.sessionFile) : null;
             if (!file || !file.startsWith(resolve(sessionDir) + '/'))
                 throw new Error('Pi session is outside its managed directory');
-            if (object(state.model).provider !== this.route.provider ||
-                object(state.model).id !== this.route.model)
+            if (object(state.model).provider !== route.provider || object(state.model).id !== route.model)
                 throw new Error('Pi selected an unapproved provider route');
             if (worker.invalid)
                 throw new Error(worker.invalid);
@@ -307,7 +398,9 @@ export class Supervisor extends EventEmitter {
             // persist a cursor into that ephemeral tree before its file exists.
             if (existsSync(file))
                 await this.syncEntries(worker);
-            this.store.state(id, epoch, 'ready', null, workerCapabilities(this.codingBinding(id)), file);
+            if (child)
+                this.store.workerBoundary.accepted(child, epoch, route);
+            this.store.state(id, epoch, 'ready', null, workerCapabilities(this.codingBinding(id), this.tools(id)), file);
             worker.ready = true;
             worker.lastBeat = Date.now();
         }
@@ -362,6 +455,7 @@ export class Supervisor extends EventEmitter {
     }
     async bridge(id, method, token, body) {
         const w = this.authenticate(id, token, body);
+        const route = w.route;
         if (method === 'failure') {
             if (!w.stopping)
                 this.invalidate(w, 'Required extension failed');
@@ -373,6 +467,7 @@ export class Supervisor extends EventEmitter {
             try {
                 if (w.manifest)
                     throw new Error('Duplicate handshake');
+                const boundary = this.childBoundary(id, w.epoch);
                 const expected = {
                     protocol_version: PROTOCOL_VERSION,
                     bundle_digest: w.bundle,
@@ -380,13 +475,14 @@ export class Supervisor extends EventEmitter {
                     session_id: id,
                     pi_session_id: id,
                     epoch: w.epoch,
-                    capabilities: workerCapabilities(this.codingBinding(id)),
+                    capabilities: workerCapabilities(this.codingBinding(id), this.tools(id)),
                     tools: this.tools(id),
                     active_tools: this.tools(id),
                     ...(this.codingBinding(id) ? { coding: this.codingBinding(id) } : {}),
-                    provider: this.route.provider,
-                    route: this.route,
+                    provider: route.provider,
+                    route: route,
                     context_digest: textDigest(w.frame),
+                    ...(boundary ? { worker_binding: boundary } : {}),
                 };
                 for (const [key, value] of Object.entries(expected))
                     if (canonical(body[key]) !== canonical(value))
@@ -409,13 +505,87 @@ export class Supervisor extends EventEmitter {
         if (w.attempt && this.store.cancelled(w.attempt))
             throw new ServiceError('attempt_cancelled', 'Attempt cancellation revoked further grants');
         try {
+            this.childBoundary(id, w.epoch);
+            if (method.startsWith('team.')) {
+                const child = this.children?.owned(id);
+                if (!child || !this.team || !w.attempt)
+                    throw new Error('No owned team assignment');
+                const binding = this.store.workerBoundary.view(child.id).binding;
+                if (!binding.assignment || !binding.tools.includes('salaam_team'))
+                    throw new Error('No team message authority');
+                const authorize = () => {
+                    this.assertActive(id, w.epoch, w.attempt);
+                    this.team.assert(binding);
+                    this.store.taskGrantCheck?.(id);
+                };
+                authorize();
+                const request = string(body.request_id, 'request_id', 128), assignment = binding.assignment.id;
+                if (method === 'team.send')
+                    return this.team.send(binding.owner_task, assignment, string(body.recipient, 'recipient', 128), string(body.text, 'text', 4096), request, authorize);
+                if (method === 'team.receive')
+                    return this.team.receive(assignment, request, authorize);
+                if (method === 'team.ack')
+                    return this.team.acknowledge(assignment, string(body.message_id, 'message_id', 128), request, authorize);
+                throw new ServiceError('invalid_field', 'Unknown team method', 400);
+            }
+            if (method === 'specialist.read' || method === 'specialist.report') {
+                const child = this.children?.owned(id);
+                if (!child || !this.repositories || !w.attempt)
+                    throw new Error('No active specialist assignment');
+                this.assertActive(id, w.epoch, w.attempt);
+                const binding = this.store.workerBoundary.view(child.id).binding;
+                const tool = method === 'specialist.read' ? 'salaam_repository' : 'salaam_findings';
+                if (!binding.tools.includes(tool))
+                    throw new Error('Specialist authority is unavailable');
+                this.store.taskGrantCheck?.(id);
+                if (method === 'specialist.report')
+                    return this.repositories.report(binding, body.findings);
+                const args = object(body.args);
+                return this.store.request(`specialist-read:${id}:${w.epoch}`, string(body.tool_call_id, 'tool_call_id', 512), args, () => {
+                    const result = this.repositories.read(binding, args);
+                    this.store.event(id, 'specialist.read', {
+                        attempt_id: w.attempt,
+                        snapshot_digest: binding.repository?.digest,
+                        argument_digest: digest(args),
+                        result_digest: digest(result),
+                    });
+                    return result;
+                });
+            }
+            if (method === 'provider.auth') {
+                if (!this.children?.owned(id)) {
+                    const auth = await this.providerAuth();
+                    if (canonical(this.route) !== canonical(route))
+                        throw new Error('Provider route changed');
+                    w.providerOutputCap = this.outputCap;
+                    this.assertSessionProviderSupported(id, this.outputCap);
+                    return auth;
+                }
+                const prepared = await this.prepareProviderRoute(route);
+                const expectedCap = this.children?.owned(id)
+                    ? this.store.workerBoundary.view(this.children.owned(id).id).binding.agent?.output_cap
+                    : this.outputCap;
+                if (canonical(prepared.route) !== canonical(route) ||
+                    (expectedCap ?? this.outputCap) !== prepared.output_cap)
+                    throw new Error('Provider capability or route changed; restart or renew admission');
+                w.providerOutputCap = prepared.output_cap;
+                this.assertSessionProviderSupported(id, prepared.output_cap);
+                const auth = prepared.auth;
+                return auth;
+            }
             if (method === 'coding.files' || method === 'coding.command') {
-                if (this.children?.owned(id) || !this.coding || !this.codingBinding(id) || !w.attempt)
+                if (!this.coding || !this.codingBinding(id) || !w.attempt)
                     throw new Error('Coding authority is unavailable');
                 this.assertActive(id, w.epoch, w.attempt);
+                this.store.taskGrantCheck?.(id);
                 const args = object(body.args);
-                if (method === 'coding.files')
+                if (method === 'coding.files') {
+                    if (!this.codingBinding(id)?.files)
+                        throw new Error('File authority is unavailable');
+                    if (this.children?.owned(id) && args.path !== undefined)
+                        repositoryPath(args.path);
                     return this.coding.file(id, w.epoch, w.attempt, string(body.tool_call_id, 'tool_call_id', 512), args);
+                }
                 if (!this.codingBinding(id)?.commands)
                     throw new Error('Command execution is unavailable');
                 if (args.action === 'start')
@@ -452,11 +622,18 @@ export class Supervisor extends EventEmitter {
             if (method.startsWith('child.')) {
                 if (!this.children || !w.attempt)
                     throw new Error('No active parent attempt');
-                this.assertActive(id, w.epoch, w.attempt);
-                if (method === 'child.spawn')
+                // spawn() resolves a saved step before testing a fresh invocation/grant.
+                if (method !== 'child.spawn')
+                    this.assertActive(id, w.epoch, w.attempt);
+                if (method === 'child.spawn') {
+                    if (Object.keys(body).some((key) => !['epoch', 'step_key', 'prompt', 'budget', 'authority', 'profile'].includes(key)))
+                        throw new ServiceError('invalid_child', 'Unsupported child admission field');
                     return this.children.spawn(id, w.epoch, w.attempt, string(body.step_key, 'step_key', 128), string(body.prompt, 'prompt', 32768), Number(body.budget), Array.isArray(body.authority)
                         ? body.authority.map((x) => string(x, 'authority', 128))
-                        : ['salaam_probe']);
+                        : body.profile
+                            ? []
+                            : ['salaam_probe'], body.profile === undefined ? undefined : string(body.profile, 'profile', 128));
+                }
                 if (method === 'child.list')
                     return this.children.list(id);
                 const child = string(body.child_id, 'child_id', 128);
@@ -494,22 +671,25 @@ export class Supervisor extends EventEmitter {
                     .get(String(body.source_key));
                 if (!source || source.session_id !== id || source.attempt_id !== (w.attempt ?? null))
                     throw new Error('Usage does not belong to this request');
-                this.store.transaction(() => this.store.usage.observe(id, string(body.source_key, 'source_key', 256), this.route.provider, this.route.model, body.usage, this.route.provider === 'anthropic' ? 'estimated' : 'known'));
+                this.store.transaction(() => this.store.usage.observe(id, string(body.source_key, 'source_key', 256), route.provider, route.model, body.usage, route.provider !== 'salaam-proof' ? 'estimated' : 'known'));
                 return { ok: true };
             }
             if (method === 'model') {
                 this.coding?.assertSafe(id);
                 this.store.taskGrantCheck?.(id);
-                if (body.provider !== this.route.provider ||
-                    body.model !== this.route.model ||
+                if (body.provider !== route.provider ||
+                    body.model !== route.model ||
                     body.context_digest !== textDigest(this.tasks.frame(id, w.binding)))
                     throw new Error('Provider or task context is invalid');
-                if (this.route.provider === 'anthropic') {
-                    validateClaudePayload(body.payload, this.route, this.tasks.frame(id, w.binding), this.tools(id));
+                if (route.provider !== 'salaam-proof') {
+                    if (w.providerOutputCap === undefined)
+                        throw new Error('Provider authentication was not admitted');
+                    this.assertSessionProviderSupported(id, w.providerOutputCap);
+                    validateProviderPayload(body.payload, route, this.tasks.frame(id, w.binding), this.tools(id), !w.providerOutputCap);
                     if (body.payload_digest !== digest(body.payload))
-                        throw new Error('Claude payload digest changed');
+                        throw new Error('Provider payload digest changed');
                 }
-                if (this.route.provider === 'salaam-proof') {
+                if (route.provider === 'salaam-proof') {
                     const payload = object(body.payload);
                     if (!Array.isArray(payload.messages))
                         throw new Error('Proof payload missing');
@@ -526,7 +706,7 @@ export class Supervisor extends EventEmitter {
                         body.payload_digest !== digest(payload))
                         throw new Error('Proof task payload is stale or invalid');
                 }
-                this.store.usage.admit(id, w.attempt, string(body.source_key, 'source_key', 256), String(body.provider), String(body.model), { input: Buffer.byteLength(JSON.stringify(body.payload)), output: this.route.max_tokens });
+                this.store.usage.admit(id, w.attempt, string(body.source_key, 'source_key', 256), String(body.provider), String(body.model), { input: Buffer.byteLength(JSON.stringify(body.payload)), output: route.max_tokens });
                 this.store.transaction(() => {
                     this.store.event(id, 'model.admitted', {
                         attempt_id: w.attempt ?? null,
@@ -556,6 +736,17 @@ export class Supervisor extends EventEmitter {
         }
         catch (error) {
             this.store.taskBudgetDenied?.(id, error);
+            if (method.startsWith('specialist.') &&
+                error instanceof ServiceError &&
+                [
+                    'not_found',
+                    'binary_file',
+                    'line_limit',
+                    'invalid_field',
+                    'unsafe_path',
+                    'request_conflict',
+                ].includes(error.code))
+                throw error;
             if (method.startsWith('coding.') &&
                 error instanceof ServiceError &&
                 [
@@ -599,9 +790,25 @@ export class Supervisor extends EventEmitter {
         }
     }
     inspect(id) {
+        const externalChild = this.children?.owned(id);
+        if (externalChild && this.store.workerBoundary.view(externalChild.id).binding.external)
+            return this.store.session(id);
+        const child = this.children?.owned(id);
+        const cap = child
+            ? this.store.workerBoundary.view(child.id).binding.agent?.output_cap
+            : undefined;
         const state = {
             ...this.store.session(id),
             provider_route: this.store.providerRoute(id) ?? undefined,
+            provider_capabilities: cap === undefined
+                ? this.providerCapabilities()
+                : {
+                    output_token_cap: cap,
+                    durable_tasks: true,
+                    warning: cap
+                        ? null
+                        : 'No provider-enforced output cap; tasks must explicitly disable token budgeting',
+                },
         };
         const w = this.workers.get(id);
         if (w?.invalid)
@@ -805,6 +1012,7 @@ export class Supervisor extends EventEmitter {
                 throw new Error(w.invalid ?? 'Attempt aborted');
             const entries = await this.readEntries(w);
             const result = object((await w.pi.command('get_last_assistant_text')).data);
+            this.childBoundary(id, w.epoch);
             this.store.finish(work.attempt.id, outcomeError ? 'failed' : 'completed', String(result.text ?? ''), outcomeError, { epoch: w.epoch, ...entries });
         }
         catch (error) {
@@ -816,6 +1024,9 @@ export class Supervisor extends EventEmitter {
             w.pi.off('record', record);
             w.busy = false;
             delete w.attempt;
+            const child = this.children?.owned(id);
+            if (child && child.state !== 'accepted')
+                await this.stopWorker(w);
             this.emit('idle', id);
         }
         return true;

package/dist/src/task-budget.js

@@ -34,14 +34,18 @@ export class TaskBudget {
         return child ? this.tasks.forSession(child.parent_session) : null;
     }
     state(id) {
-        return this.store.db.prepare('SELECT * FROM task_runtime WHERE task_id=?').get(id);
+        const runtime = this.store.db.prepare('SELECT * FROM task_runtime WHERE task_id=?').get(id);
+        const n = Number(this.store.db.prepare('SELECT count(*) AS n FROM task_invocations WHERE task_id=?').get(id)
+            .n);
+        return { ...runtime, invocations_spent: n, external_model_usage: n ? 'unknown' : 'none' };
     }
     active(task) {
         const row = this.store.db
             .prepare(`WITH tree(id) AS (SELECT ? UNION ALL SELECT child_session FROM child_tasks WHERE parent_session=?) SELECT
       (SELECT count(*) FROM attempts WHERE session_id IN (SELECT id FROM tree) AND state IN ('accepted','dispatching','running')) +
-      (SELECT count(*) FROM command_runs WHERE session_id IN (SELECT id FROM tree) AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')) AS n`)
-            .get(task.session_id, task.session_id);
+      (SELECT count(*) FROM command_runs WHERE session_id IN (SELECT id FROM tree) AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')) +
+      (SELECT count(*) FROM external_runs e JOIN child_tasks c ON c.id=e.child_id JOIN attempts a ON a.id=c.child_attempt WHERE c.parent_session=? AND e.stopped=0 AND a.state NOT IN ('accepted','dispatching','running')) AS n`)
+            .get(task.session_id, task.session_id, task.session_id);
         return Number(row.n);
     }
     deny(session, message) {
@@ -74,8 +78,9 @@ export class TaskBudget {
         this.check(session);
         if (!attempt)
             this.deny(task.session_id, 'Task model work must belong to a durable attempt');
-        const l = task.limits, r = this.state(task.id), charge = l.input_token_bound + l.output_token_bound;
-        if (input > l.input_token_bound || output > l.output_token_bound)
+        const l = task.limits, r = this.state(task.id), charge = l.token_units === null ? 0 : l.input_token_bound + l.output_token_bound;
+        if (input > l.input_token_bound ||
+            (l.output_token_bound !== null && output > l.output_token_bound))
             this.deny(task.session_id, 'Provider payload exceeds declared per-request token bounds');
         const reservation = this.store.db
             .prepare('SELECT * FROM task_reservations WHERE attempt_id=? AND task_id=?')
@@ -93,7 +98,8 @@ export class TaskBudget {
         else {
             if (Number(r.requests_spent) + Number(r.reserved_requests) >= l.requests)
                 this.deny(task.session_id, 'Task request limit reached');
-            if (Number(r.token_units) + Number(r.reserved_tokens) + charge > l.token_units)
+            if (l.token_units !== null &&
+                Number(r.token_units) + Number(r.reserved_tokens) + charge > l.token_units)
                 this.deny(task.session_id, 'Task declared token budget reached');
             this.store.db
                 .prepare('UPDATE task_runtime SET requests_spent=requests_spent+1,token_units=token_units+? WHERE task_id=?')
@@ -105,9 +111,12 @@ export class TaskBudget {
         if (!task)
             return;
         this.check(session);
-        const r = this.state(task.id), tokens = count * (task.limits.input_token_bound + task.limits.output_token_bound);
+        const r = this.state(task.id), tokens = task.limits.token_units === null
+            ? 0
+            : count * (task.limits.input_token_bound + task.limits.output_token_bound);
         if (Number(r.requests_spent) + Number(r.reserved_requests) + count > task.limits.requests ||
-            Number(r.token_units) + Number(r.reserved_tokens) + tokens > task.limits.token_units)
+            (task.limits.token_units !== null &&
+                Number(r.token_units) + Number(r.reserved_tokens) + tokens > task.limits.token_units))
             this.deny(task.session_id, 'Task cannot reserve the child request/token bounds');
         this.store.db
             .prepare('INSERT INTO task_reservations VALUES (?,?,?,?)')

package/dist/src/task-context.js

@@ -36,6 +36,20 @@ export class TaskContext {
     }
     frame(id, binding) {
         const state = this.state(id);
+        const admitted = [
+            ...new Map((this.store.workerBoundary.profiles?.snapshot(id) ?? [])
+                .filter((p) => p.state === 'active')
+                .map((p) => [
+                p.profile_id,
+                {
+                    profile_id: p.profile_id,
+                    profile_digest: p.profile_digest,
+                    tools: p.tools,
+                    route: p.route,
+                    max_depth: 1,
+                },
+            ])).values(),
+        ].sort((a, b) => a.profile_id.localeCompare(b.profile_id));
         // The compaction cursor is a projection, not a task fact/version.
         const frame = 'SALAAM_TASK_STATE ' +
             canonical({
@@ -44,6 +58,7 @@ export class TaskContext {
                 version: state.version,
                 instructions: 'Use active facts. Superseded facts are historical. Do not repeat completed steps. Retrieve evidence with salaam_history.',
                 facts: state.facts,
+                ...(admitted.length ? { admitted_agents: admitted } : {}),
                 ...(this.work?.forSession(id) ? { work_task: this.work.frame(id) } : {}),
             });
         if (Buffer.byteLength(frame) > TASK_FRAME_BYTES)