@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/agent-profiles.js

@@ -0,0 +1,289 @@
+import { constants, openSync, closeSync, readFileSync, fstatSync, lstatSync, existsSync, readdirSync, } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { canonical, digest, integer, object, ServiceError, string, textDigest, } from './protocol.js';
+import { providerRoute } from './provider-config.js';
+import { DIAGNOSTIC_PROFILE } from './worker-boundary.js';
+const ROLE_TOOLS = {
+    explorer: ['salaam_probe', 'salaam_repository'],
+    reviewer: ['salaam_probe', 'salaam_repository', 'salaam_findings'],
+    builder: ['salaam_probe', 'salaam_repository', 'salaam_files', 'salaam_command'],
+    tester: ['salaam_probe', 'salaam_repository', 'salaam_command', 'salaam_findings'],
+    integrator: ['salaam_probe', 'salaam_repository', 'salaam_findings'],
+};
+export function profileTools(role) {
+    return [...ROLE_TOOLS[role]].sort();
+}
+export const BUILTIN_PROFILES = [
+    DIAGNOSTIC_PROFILE,
+    ...['explorer', 'reviewer', 'builder', 'tester', 'integrator'].map((role) => ({
+        schema_version: 1,
+        id: 'salaam/' + role,
+        revision: 1,
+        role,
+        tools: profileTools(role),
+        max_depth: 1,
+        max_requests: 8,
+        description: role === 'explorer'
+            ? 'Bounded evidence from an immutable repository snapshot'
+            : role === 'reviewer'
+                ? 'Independent findings over an immutable repository diff'
+                : role === 'builder'
+                    ? 'Implement a proposal in a private owned workspace'
+                    : role === 'tester'
+                        ? 'Run bounded checks in an isolated disposable copy'
+                        : 'Review integration evidence without applying changes',
+        prompt: role === 'explorer'
+            ? 'Investigate only the supplied repository snapshot. Cite actual file paths, line numbers and hashes. Do not claim edits or execution.'
+            : role === 'builder'
+                ? 'Implement only the assigned change in your private owned workspace using salaam_files. Run bounded checks through salaam_command. Command edits are disposable. Do not claim the root workspace was changed or verified; return a proposal for explicit integration.'
+                : role === 'tester'
+                    ? 'Inspect the admitted snapshot and run bounded checks using salaam_command. You cannot edit persistent files. Report actual outcomes; a model answer is not a root verification receipt.'
+                    : 'Review only the supplied immutable diff and repository snapshot. Report concrete findings with file/line evidence through salaam_findings. A finding is analysis, not a verification receipt.',
+    })),
+];
+/** JSON front matter is a deliberately bounded subset, not an executable config format. */
+export function parseAgentProfile(name, source) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(name) || Buffer.byteLength(source) > 49152)
+        throw new ServiceError('invalid_profile', 'Invalid profile name or size');
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(source);
+    if (!match)
+        throw new ServiceError('invalid_profile', 'Use JSON front matter between --- lines');
+    let metadata;
+    try {
+        metadata = object(JSON.parse(match[1]));
+    }
+    catch {
+        throw new ServiceError('invalid_profile', 'Invalid JSON profile metadata');
+    }
+    const allowed = [
+        'description',
+        'revision',
+        'role',
+        'tools',
+        'provider',
+        'model',
+        'max_requests',
+        'max_depth',
+    ];
+    if (Object.keys(metadata).some((key) => !allowed.includes(key)))
+        throw new ServiceError('invalid_profile', 'Profiles cannot define executables, credentials, plugins, environment or additional fields');
+    const role = string(metadata.role, 'role', 32);
+    if (!Object.hasOwn(ROLE_TOOLS, role))
+        throw new ServiceError('invalid_profile', 'Unsupported specialist role');
+    const tools = metadata.tools === undefined
+        ? profileTools(role)
+        : [
+            ...new Set((Array.isArray(metadata.tools) ? metadata.tools : []).map((x) => string(x, 'tool', 128))),
+        ].sort();
+    if (!tools.length || tools.some((x) => !profileTools(role).includes(x)))
+        throw new ServiceError('invalid_profile', 'Tools exceed the specialist role');
+    const revision = integer(metadata.revision ?? 1, 'revision');
+    const maxRequests = integer(metadata.max_requests ?? 8, 'max_requests');
+    if (revision < 1 || maxRequests < 1 || maxRequests > 8 || (metadata.max_depth ?? 1) !== 1)
+        throw new ServiceError('invalid_profile', 'Invalid revision, request limit or delegation depth');
+    if ((metadata.provider === undefined) !== (metadata.model === undefined))
+        throw new ServiceError('invalid_profile', 'Select both provider and model');
+    const prompt = string(match[2].trim(), 'prompt', 32768);
+    return {
+        schema_version: 1,
+        id: 'project/' + name,
+        revision,
+        role,
+        tools,
+        max_depth: 1,
+        description: string(metadata.description ?? name, 'description', 512),
+        prompt,
+        max_requests: maxRequests,
+        source_digest: textDigest(source),
+        ...(metadata.provider
+            ? {
+                provider: string(metadata.provider, 'provider', 128),
+                model: string(metadata.model, 'model', 256),
+            }
+            : {}),
+    };
+}
+export class AgentProfiles {
+    store;
+    route;
+    prepareRoute;
+    assertExecution;
+    validateFrame;
+    constructor(store, route, prepareRoute) {
+        this.store = store;
+        this.route = route;
+        this.prepareRoute = prepareRoute;
+    }
+    list(session) {
+        const root = this.store.session(session).cwd;
+        const control = join(root, '.salaam'), directory = join(control, 'agents');
+        for (const path of [control, directory]) {
+            if (!existsSync(path))
+                return structuredClone(BUILTIN_PROFILES);
+            const stat = lstatSync(path);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                throw new ServiceError('invalid_profile', 'Profile directories must not be symlinks');
+        }
+        const names = readdirSync(directory)
+            .filter((name) => name.endsWith('.md'))
+            .sort();
+        if (names.length > 32)
+            throw new ServiceError('invalid_profile', 'At most 32 project profiles');
+        const profiles = names.map((file) => {
+            const path = join(directory, file), fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const stat = fstatSync(fd);
+                if (!stat.isFile() || stat.nlink !== 1 || stat.size > 49152)
+                    throw new ServiceError('invalid_profile', 'Profile must be a bounded regular file');
+                return parseAgentProfile(file.slice(0, -3), readFileSync(fd, 'utf8'));
+            }
+            finally {
+                closeSync(fd);
+            }
+        });
+        return [...structuredClone(BUILTIN_PROFILES), ...profiles];
+    }
+    inspect(session, id) {
+        this.store.session(session);
+        const builtin = BUILTIN_PROFILES.find((profile) => profile.id === id);
+        if (builtin)
+            return structuredClone(builtin);
+        const profile = this.list(session).find((x) => x.id === id);
+        if (!profile)
+            throw new ServiceError('not_found', 'Agent profile not found', 404);
+        return profile;
+    }
+    async admit(session, request, profileId, expectedDigest, factIds, controller) {
+        const input = { kind: 'agent-admit', session, profileId, expectedDigest, factIds };
+        const saved = this.store.cachedRequest('local-operator', request, input);
+        if (saved)
+            return saved;
+        this.store.authorizeControl(session, controller);
+        const profile = this.inspect(session, profileId);
+        if (digest(profile) !== expectedDigest)
+            throw new ServiceError('profile_changed', 'Review the current profile digest');
+        const writing = profile.tools.some((tool) => ['salaam_files', 'salaam_command'].includes(tool));
+        if (writing) {
+            if (!this.assertExecution)
+                throw new ServiceError('profile_unavailable', 'Writing roles require the parallel execution boundary');
+            this.assertExecution();
+        }
+        const prepared = await this.prepareRoute(profile.provider
+            ? providerRoute(profile.provider, profile.model, Math.min(2048, this.route.max_tokens))
+            : this.route, session);
+        return this.store.request('local-operator', request, input, () => {
+            this.store.authorizeControl(session, controller);
+            if (writing)
+                this.assertExecution();
+            if (digest(this.inspect(session, profileId)) !== expectedDigest)
+                throw new ServiceError('profile_changed', 'Profile changed during admission');
+            if (profile.role &&
+                !this.store.db.prepare('SELECT id FROM workspaces WHERE session_id=?').get(session))
+                throw new ServiceError('workspace_unavailable', 'Specialists need an admitted coding workspace');
+            if (factIds.length > 16 || new Set(factIds).size !== factIds.length)
+                throw new ServiceError('invalid_profile', 'Select at most 16 distinct facts');
+            const facts = factIds.map((id) => {
+                const fact = this.store.db
+                    .prepare('SELECT id,kind,text FROM task_facts WHERE id=? AND session_id=? AND id NOT IN (SELECT supersedes FROM task_facts WHERE supersedes IS NOT NULL)')
+                    .get(id, session);
+                if (!fact)
+                    throw new ServiceError('not_found', 'Selected fact is unavailable', 404);
+                return { id: String(fact.id), kind: String(fact.kind), text: String(fact.text) };
+            });
+            const grant = {
+                schema_version: 1,
+                id: randomUUID(),
+                owner_session: session,
+                profile,
+                profile_digest: expectedDigest,
+                route: prepared.route,
+                output_cap: prepared.output_cap,
+                facts,
+            };
+            const priorProfile = this.store.db
+                .prepare('SELECT digest FROM worker_profiles WHERE id=? AND revision=?')
+                .get(profile.id, profile.revision);
+            if (priorProfile && priorProfile.digest !== expectedDigest)
+                throw new ServiceError('profile_revision_conflict', 'Changed profile contents require a new revision');
+            this.store.db
+                .prepare('INSERT INTO agent_grants(id,owner_session,profile_id,document,digest,state) VALUES (?,?,?,?,?,?)')
+                .run(grant.id, session, profileId, canonical(grant), digest(grant), 'active');
+            this.store.db
+                .prepare('INSERT OR IGNORE INTO worker_profiles(id,revision,digest,document) VALUES (?,?,?,?)')
+                .run(profile.id, profile.revision, expectedDigest, canonical(profile));
+            this.store.event(session, 'agent.admitted', {
+                grant_id: grant.id,
+                profile_id: profileId,
+                profile_digest: expectedDigest,
+                route: prepared.route,
+            });
+            this.validateFrame?.(session);
+            return grant;
+        });
+    }
+    resolve(session, id) {
+        const row = this.store.db
+            .prepare("SELECT document,digest FROM agent_grants WHERE owner_session=? AND profile_id=? AND state='active' ORDER BY rowid DESC LIMIT 1")
+            .get(session, id);
+        if (!row)
+            throw new ServiceError('authority_denied', 'Operator must admit this agent profile first');
+        const grant = JSON.parse(String(row.document));
+        if (digest(grant) !== row.digest || digest(this.inspect(session, id)) !== grant.profile_digest)
+            throw new ServiceError('profile_changed', 'Profile changed; renew its admission');
+        return grant;
+    }
+    validate(grant) {
+        const row = this.store.db
+            .prepare('SELECT document,digest,state FROM agent_grants WHERE id=? AND owner_session=?')
+            .get(grant.id, grant.owner_session);
+        if (!row ||
+            row.state !== 'active' ||
+            row.digest !== digest(grant) ||
+            row.document !== canonical(grant) ||
+            digest(this.inspect(grant.owner_session, grant.profile.id)) !== grant.profile_digest)
+            throw new ServiceError('worker_profile_revoked', 'Specialist admission was revoked or changed');
+    }
+    revoke(session, grantId, request, controller) {
+        return this.store.request('local-operator', request, { kind: 'agent-revoke', session, grantId }, () => {
+            this.store.authorizeControl(session, controller);
+            const result = this.store.db
+                .prepare("UPDATE agent_grants SET state='revoked' WHERE id=? AND owner_session=?")
+                .run(grantId, session);
+            if (!result.changes)
+                throw new ServiceError('not_found', 'Agent admission not found', 404);
+            this.store.event(session, 'agent.revoked', { grant_id: grantId });
+            return { grant_id: grantId, state: 'revoked' };
+        });
+    }
+    snapshot(session) {
+        return this.store.db
+            .prepare('SELECT document,state FROM agent_grants WHERE owner_session=? ORDER BY rowid DESC LIMIT 64')
+            .all(session)
+            .reverse()
+            .map((row) => {
+            const grant = JSON.parse(String(row.document));
+            let state = String(row.state);
+            if (state === 'active') {
+                try {
+                    this.validate(grant);
+                }
+                catch {
+                    state = 'stale';
+                }
+            }
+            return {
+                grant_id: grant.id,
+                profile_id: grant.profile.id,
+                revision: grant.profile.revision,
+                profile_digest: grant.profile_digest,
+                tools: grant.profile.tools,
+                role: grant.profile.role,
+                route: grant.route,
+                output_cap: grant.output_cap,
+                selected_facts: grant.facts.map((f) => f.id),
+                state,
+            };
+        });
+    }
+}

package/dist/src/children.js

@@ -4,12 +4,16 @@ export class ChildWork {
     store;
     artifacts;
     supervisor;
+    repositories;
+    external;
+    workspaces;
     paused = false;
     starts = new Set();
-    constructor(store, artifacts, supervisor) {
+    constructor(store, artifacts, supervisor, repositories) {
         this.store = store;
         this.artifacts = artifacts;
         this.supervisor = supervisor;
+        this.repositories = repositories;
         store.finishChild = (attempt) => this.finish(attempt);
         store.cancelChildren = (attempt) => this.cancelIntents(attempt);
     }
@@ -21,7 +25,7 @@ export class ChildWork {
     list(parent) {
         return this.store.db
             .prepare('SELECT * FROM child_tasks WHERE parent_session=? ORDER BY rowid')
-            .all(parent);
+            .all(parent).map((child) => ({ ...child, worker: this.store.workerBoundary.view(child.id) }));
     }
     inspect(parent, id) {
         const row = this.store.db
@@ -29,9 +33,9 @@ export class ChildWork {
             .get(id, parent);
         if (!row)
             throw new ServiceError('not_found', 'Child task not found', 404);
-        return row;
+        return { ...row, worker: this.store.workerBoundary.view(row.id) };
     }
-    spawn(parent, epoch, attempt, step, prompt, budget, requested) {
+    spawn(parent, epoch, attempt, step, prompt, budget, requested, profileId, admission) {
         if (!Number.isSafeInteger(budget) || budget < 1 || budget > 8)
             throw new ServiceError('invalid_budget', 'Child request budget must be 1–8');
         if (step.length > 128 ||
@@ -41,12 +45,18 @@ export class ChildWork {
             prompt.trimStart().startsWith('/'))
             throw new ServiceError('invalid_child', 'Invalid child step or prompt');
         // Current child authority is deliberately read-only and closed-world.
-        const authority = requested
-            .filter((x) => x === 'salaam_probe')
-            .filter((x, i, a) => a.indexOf(x) === i)
-            .sort();
-        const input = digest({ prompt, budget, requested: [...new Set(requested)].sort() });
-        const child = this.store.transaction(() => {
+        const input = digest({
+            prompt,
+            budget,
+            requested: [...new Set(requested)].sort(),
+            ...(profileId ? { profile: profileId } : {}),
+            ...(admission ? { assignment: admission.assignment } : {}),
+            ...(admission?.runtime ? { runtime: admission.runtime } : {}),
+        });
+        let fresh = false;
+        if (this.store.db.isTransaction && !admission?.defer)
+            throw new Error('Nested child dispatch requires an owned deferred admission');
+        const prepare = () => {
             const old = this.store.db
                 .prepare('SELECT * FROM child_tasks WHERE parent_session=? AND step_key=?')
                 .get(parent, step);
@@ -57,34 +67,83 @@ export class ChildWork {
             }
             if (this.paused)
                 throw new ServiceError('stopping', 'Child dispatch is stopping');
-            this.supervisor.assertActive(parent, epoch, attempt);
+            if (admission)
+                admission.authorize();
+            else
+                this.supervisor.assertActive(parent, epoch, attempt);
+            const agent = profileId
+                ? this.store.workerBoundary.profiles?.resolve(parent, profileId)
+                : undefined;
+            if (profileId && !agent)
+                throw new ServiceError('authority_denied', 'Agent profile is unavailable');
+            if (!admission?.runtime)
+                this.supervisor.assertSessionProviderSupported(parent, agent?.output_cap);
+            if (!admission?.runtime && agent && budget > (agent.profile.max_requests ?? 8))
+                throw new ServiceError('invalid_budget', 'Budget exceeds the admitted profile limit');
+            const available = [
+                ...(agent?.profile.tools ?? ['salaam_probe']),
+                ...(admission && !admission.runtime ? ['salaam_team'] : []),
+            ];
+            const authority = [
+                ...new Set(agent && !requested.length ? available : requested.filter((x) => available.includes(x))),
+            ].sort();
+            const effectivePrompt = agent
+                ? `${agent.profile.prompt ?? 'Run the diagnostic probe.'}${admission?.runtime ? '\n\nRuntime binding: use the admitted external harness tools for the corresponding file and command actions. Its private draft is /workspace. Return evidence for explicit root integration; this invocation cannot verify the root task.' : ''}\n\nGoal:\n${prompt}\n\nExplicitly selected facts:\n${JSON.stringify(agent.facts)}`
+                : prompt;
+            if (Buffer.byteLength(effectivePrompt) > 65536)
+                throw new ServiceError('invalid_child', 'Specialist context exceeds 64 KiB');
             if (this.owned(parent))
                 throw new ServiceError('depth_exceeded', 'Child depth is limited to one');
             if (!authority.length)
                 throw new ServiceError('authority_denied', 'No requested read-only authority is available');
-            if (this.list(parent).filter((x) => x.state === 'accepted').length >= 2)
+            if (this.activeCount(parent) >= 2)
                 throw new ServiceError('child_limit', 'At most two children may be active');
-            this.store.usage.budget(attempt);
-            const changed = this.store.db
-                .prepare('UPDATE attempt_budgets SET reserved_requests=reserved_requests+? WHERE attempt_id=? AND spent_requests+reserved_requests+?<=limit_requests')
-                .run(budget, attempt, budget);
-            if (!changed.changes)
-                throw new ServiceError('budget_exhausted', 'Parent cannot reserve this child budget');
+            if (this.activeCount() >= 8)
+                throw new ServiceError('child_limit', 'Daemon worker admission limit reached');
+            if (!admission?.runtime) {
+                this.store.usage.budget(attempt);
+                const changed = this.store.db
+                    .prepare('UPDATE attempt_budgets SET reserved_requests=reserved_requests+? WHERE attempt_id=? AND spent_requests+reserved_requests+?<=limit_requests')
+                    .run(budget, attempt, budget);
+                if (!changed.changes)
+                    throw new ServiceError('budget_exhausted', 'Parent cannot reserve this child budget');
+            }
             const id = randomUUID(), session = randomUUID(), submission = randomUUID(), childAttempt = randomUUID();
             this.store.db
                 .prepare('INSERT INTO sessions(id,cwd,pi_session_id) VALUES (?,?,?)')
                 .run(session, this.store.session(parent).cwd, session);
             this.store.db
                 .prepare('INSERT INTO submissions(id,session_id,text,attempt_id) VALUES (?,?,?,?)')
-                .run(submission, session, prompt, childAttempt);
+                .run(submission, session, effectivePrompt, childAttempt);
             this.store.db
                 .prepare("INSERT INTO attempts(id,session_id,submission_id,state) VALUES (?,?,?,'accepted')")
                 .run(childAttempt, session, submission);
             this.store.db
                 .prepare("INSERT INTO child_tasks(id,parent_session,parent_attempt,step_key,input_digest,child_session,child_attempt,authority,budget,state) VALUES (?,?,?,?,?,?,?,?,?,'accepted')")
                 .run(id, parent, attempt, step, input, session, childAttempt, JSON.stringify(authority), budget);
-            this.store.taskChildReserve?.(parent, childAttempt, budget);
-            this.store.usage.budget(childAttempt, budget);
+            if (!admission?.runtime) {
+                this.store.taskChildReserve?.(parent, childAttempt, budget);
+                this.store.usage.budget(childAttempt, budget);
+            }
+            const artifact = this.artifacts.prepare(session, effectivePrompt);
+            artifact.commit();
+            const repository = agent?.profile.role
+                ? this.repositories?.capture(parent, session)
+                : undefined;
+            if (agent?.profile.role && !repository)
+                throw new ServiceError('workspace_unavailable', 'No specialist snapshot boundary');
+            const writing = authority.some((tool) => ['salaam_files', 'salaam_command'].includes(tool));
+            const isolation = (writing || admission?.runtime) && repository
+                ? this.workspaces?.prepare(session, repository)
+                : undefined;
+            if (writing && !isolation)
+                throw new ServiceError('authority_denied', 'No isolated coding boundary');
+            this.store.workerBoundary.freeze(this.owned(session), artifact.id, false, agent, repository, admission?.assignment, isolation, admission?.runtime);
+            if (admission?.runtime) {
+                if (!this.external)
+                    throw new ServiceError('runtime_unavailable', 'External runtime is unavailable');
+                this.external.prepare(this.owned(session));
+            }
             this.store.event(session, 'session.created', { parent_session: parent, child_id: id });
             this.store.event(session, 'submission.accepted', {
                 attempt_id: childAttempt,
@@ -97,17 +156,37 @@ export class ChildWork {
                 budget,
                 authority,
             });
+            fresh = true;
             return this.inspect(parent, id);
-        });
+        };
+        const child = this.store.db.isTransaction ? prepare() : this.store.transaction(prepare);
         // Repeated calls only return the durable binding. They never restart a child.
-        if (this.store.session(child.child_session).epoch === 0 &&
+        if (fresh &&
+            !admission?.defer &&
+            this.store.session(child.child_session).epoch === 0 &&
             this.store.attempt(child.child_attempt).state === 'accepted')
             this.start(child);
         return child;
     }
+    activeCount(parent) {
+        return Number(this.store.db
+            .prepare(`SELECT count(*) AS n FROM child_tasks c WHERE (? IS NULL OR c.parent_session=?) AND (c.state='accepted' OR EXISTS(SELECT 1 FROM workers w WHERE w.session_id=c.child_session AND w.state!='exited') OR EXISTS(SELECT 1 FROM external_runs e WHERE e.child_id=c.id AND e.stopped=0))`)
+            .get(parent ?? null, parent ?? null).n);
+    }
+    launchPrepared(child) {
+        if (this.store.db.isTransaction)
+            throw new Error('Commit child intent before launch');
+        if (this.store.workerBoundary.view(child.id).dispatch_state === 'intent')
+            this.start(child);
+    }
+    cancelSessionInTransaction(parent) {
+        const child = this.list(parent)[0];
+        if (child)
+            this.cancelIntents(child.parent_attempt);
+    }
     start(child) {
-        const task = this.supervisor
-            .start(child.child_session)
+        const external = this.store.workerBoundary.view(child.id).binding.external;
+        const task = (external ? this.external.start(child) : this.supervisor.start(child.child_session))
             .catch((error) => {
             this.store.transaction(() => {
                 const attempt = this.store.attempt(child.child_attempt);
@@ -119,6 +198,7 @@ export class ChildWork {
                 this.store.db
                     .prepare("UPDATE submissions SET state='interrupted' WHERE id=?")
                     .run(attempt.submission_id);
+                this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
                 this.finish(this.store.attempt(attempt.id));
             });
         })
@@ -143,6 +223,7 @@ export class ChildWork {
             this.store.db
                 .prepare('UPDATE submissions SET state=? WHERE id=?')
                 .run(state, attempt.submission_id);
+            this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
             this.finish(this.store.attempt(attempt.id));
         });
     }
@@ -159,12 +240,22 @@ export class ChildWork {
             state: attempt.state,
             text: attempt.result,
             error: attempt.error,
+            ...(this.store.workerBoundary.view(child.id).binding.agent
+                ? {
+                    worker_id: this.store.workerBoundary.view(child.id).binding.worker_id,
+                    report: this.store.db
+                        .prepare('SELECT artifact_id FROM specialist_reports WHERE worker_id=?')
+                        .get(this.store.workerBoundary.view(child.id).binding.worker_id)?.artifact_id ??
+                        null,
+                }
+                : {}),
         }));
         artifact.commit();
         const result = randomUUID();
         this.store.db
             .prepare('UPDATE child_tasks SET state=?,result_id=?,artifact_id=? WHERE id=?')
             .run(attempt.state, result, artifact.id, child.id);
+        this.store.workerBoundary.finish(child, attempt.state === 'interrupted');
         this.store.event(child.parent_session, 'child.result_available', {
             child_id: child.id,
             result_id: result,
@@ -208,6 +299,7 @@ export class ChildWork {
                     this.store.db
                         .prepare("UPDATE submissions SET state='interrupted' WHERE id=?")
                         .run(attempt.submission_id);
+                    this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
                 }
                 this.finish(this.store.attempt(attempt.id));
             }
@@ -226,6 +318,7 @@ export class ChildWork {
                 this.store.db
                     .prepare("UPDATE submissions SET state='cancelled' WHERE id=?")
                     .run(work.submission_id);
+                this.store.projectTaskAttempt?.(this.store.attempt(work.id));
                 this.finish(this.store.attempt(work.id));
             }
             this.store.event(child.child_session, 'attempt.cancel_requested', {
@@ -238,9 +331,22 @@ export class ChildWork {
         const children = this.store.db
             .prepare('SELECT * FROM child_tasks WHERE parent_session=?')
             .all(this.store.attempt(attempt).session_id);
+        for (const child of children.filter((child) => this.store.cancelled(child.child_attempt)))
+            for (const run of this.supervisor.coding?.list(child.child_session) ?? [])
+                if (![
+                    'succeeded',
+                    'failed',
+                    'cancelled',
+                    'timed_out',
+                    'output_limited',
+                    'interrupted',
+                ].includes(run.state))
+                    this.supervisor.coding.cancel(child.child_session, run.id, 'child-stop:' + run.id, () => { });
         await Promise.all(children
             .filter((child) => this.store.cancelled(child.child_attempt))
-            .map((child) => this.supervisor.cancelAttempt(child.child_attempt)));
+            .map((child) => this.store.workerBoundary.view(child.id).binding.external
+            ? this.external.cancel(child)
+            : this.supervisor.cancelAttempt(child.child_attempt)));
     }
     pause() {
         this.paused = true;