@lensagent/core 0.1.0 → 0.1.2

package/dist/runtime/observability.js

@@ -12,6 +12,11 @@ export class Observability {
     #sequence = 0;
     #writeTail = Promise.resolve();
     #retentionChecked = false;
+    #queuedRecords = 0;
+    #queuedBytes = 0;
+    #lastWriteError = null;
+    #lastWarningAt = 0;
+    #closed = false;
     constructor(root, config) {
         this.#root = root;
         this.#capacity = config?.traces?.capacity ?? 2048;
@@ -21,23 +26,45 @@ export class Observability {
         const record = {
             sequence: ++this.#sequence,
             occurred_at: now(),
-            component,
-            operation,
-            outcome,
+            component: component.slice(0, 128),
+            operation: operation.slice(0, 256),
+            outcome: outcome.slice(0, 128),
             duration_ms: durationMs,
-            fields
+            fields: safeFields(fields)
         };
         this.#push(this.#logs, record);
         this.#push(this.#traces, record);
         if (component === 'agent' || component === 'call')
             this.#push(this.#agentOps, record);
         this.increment(`${component}_${operation}_${outcome}`);
-        if (this.#logConfig?.enabled === true) {
-            this.#writeTail = this.#writeTail.then(() => this.#write(record)).catch(() => undefined);
+        if (this.#logConfig?.enabled === true && !this.#closed) {
+            const bytes = Buffer.byteLength(JSON.stringify(record));
+            if (this.#queuedRecords >= (this.#logConfig.maxQueuedRecords ?? 1024) || this.#queuedBytes + bytes > (this.#logConfig.maxQueuedBytes ?? 4194304)) {
+                this.increment('log_records_dropped');
+                return;
+            }
+            this.#queuedRecords++;
+            this.#queuedBytes += bytes;
+            this.#writeTail = this.#writeTail.then(() => this.#write(record)).catch((error) => {
+                this.#lastWriteError = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code.slice(0, 64) : 'LOG_WRITE_FAILED';
+                this.increment('log_write_failures');
+                if (Date.now() - this.#lastWarningAt > 60000) {
+                    this.#lastWarningAt = Date.now();
+                    process.stderr.write('Lens observability: log sink failed; see runtime diagnostics.\n');
+                }
+            }).finally(() => { this.#queuedRecords--; this.#queuedBytes -= bytes; });
         }
     }
     increment(name, amount = 1) {
-        this.#metrics.set(metricName(name), (this.#metrics.get(metricName(name)) ?? 0) + amount);
+        const key = metricName(name).slice(0, 128);
+        if (!this.#metrics.has(key) && this.#metrics.size >= 1024) {
+            this.#metrics.set('metric_series_dropped', (this.#metrics.get('metric_series_dropped') ?? 0) + 1);
+            return;
+        }
+        this.#metrics.set(key, (this.#metrics.get(key) ?? 0) + amount);
+    }
+    status() {
+        return { queued_records: this.#queuedRecords, queued_bytes: this.#queuedBytes, last_write_error: this.#lastWriteError, metric_series: this.#metrics.size };
     }
     logs(limit) {
         return this.#logs.slice(-limit);
@@ -54,6 +81,7 @@ export class Observability {
             .join('\n') + '\n';
     }
     async close() {
+        this.#closed = true;
         await this.#writeTail;
     }
     #push(target, record) {
@@ -71,17 +99,18 @@ export class Observability {
             this.#retentionChecked = true;
             await pruneLogs(path, config.retentionDays);
         }
-        const size = await stat(path).then((entry) => entry.size, () => 0);
+        const size = await stat(path).then((entry) => entry.size, (error) => { if (missing(error))
+            return 0; throw error; });
         if (size >= config.maxFileBytes) {
             if (config.maxFiles === 1)
-                await unlink(path).catch(() => undefined);
+                await allowMissing(unlink(path));
             else
-                await unlink(`${path}.${config.maxFiles - 1}`).catch(() => undefined);
+                await allowMissing(unlink(`${path}.${config.maxFiles - 1}`));
             for (let index = config.maxFiles - 2; index >= 1; index -= 1) {
-                await rename(`${path}.${index}`, `${path}.${index + 1}`).catch(() => undefined);
+                await allowMissing(rename(`${path}.${index}`, `${path}.${index + 1}`));
             }
             if (config.maxFiles > 1)
-                await rename(path, `${path}.1`).catch(() => undefined);
+                await allowMissing(rename(path, `${path}.1`));
         }
         await appendFile(path, `${JSON.stringify(record)}\n`, 'utf8');
     }
@@ -90,15 +119,31 @@ async function pruneLogs(path, retentionDays) {
     const threshold = Date.now() - retentionDays * 86400000;
     const directory = dirname(path);
     const name = basename(path);
-    for (const entry of await readdir(directory).catch(() => [])) {
+    for (const entry of await readdir(directory)) {
         if (entry !== name && !entry.startsWith(`${name}.`))
             continue;
         const candidate = resolve(directory, entry);
-        const modified = await stat(candidate).then((value) => value.mtimeMs, () => Date.now());
+        const modified = await stat(candidate).then((value) => value.mtimeMs, (error) => { if (missing(error))
+            return Date.now(); throw error; });
         if (modified < threshold)
-            await unlink(candidate).catch(() => undefined);
+            await allowMissing(unlink(candidate));
     }
 }
 function metricName(value) {
     return value.toLowerCase().replace(/[^a-z0-9_]/g, '_');
 }
+// Operational records contain identifiers and bounded status facts, never request bodies.
+function safeFields(fields) {
+    const allowed = new Set(['project_id', 'requested_project_id', 'agent_id', 'call_id', 'run_id', 'step_id', 'state', 'outcome', 'outcome_unknown', 'error_code', 'error_name', 'status', 'reason', 'grace_ms', 'interrupted', 'server_id']);
+    return Object.fromEntries(Object.entries(fields).filter(([key, value]) => allowed.has(key) && (value === null || typeof value !== 'object')).map(([key, value]) => [key, typeof value === 'string' ? value.slice(0, 256) : value]));
+}
+function missing(error) { return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT'; }
+async function allowMissing(operation) {
+    try {
+        await operation;
+    }
+    catch (error) {
+        if (!missing(error))
+            throw error;
+    }
+}

package/dist/runtime/policy.d.ts

@@ -5,4 +5,4 @@ export interface PolicyDecision {
     readonly autoReview: boolean;
 }
 export declare function decidePolicy(policy: Policy, effect: EffectScope): PolicyDecision;
-export declare function policyPrompt(capabilityId: string): Json;
+export declare function policyPrompt(capabilityId: string, reviewReason?: string): Json;

package/dist/runtime/policy.js

@@ -10,10 +10,10 @@ export function decidePolicy(policy, effect) {
         return { state: 'QUEUED', autoReview: false };
     fail('POLICY_DENIED', 403, `Policy ${policy} does not allow effect ${effect}.`);
 }
-export function policyPrompt(capabilityId) {
+export function policyPrompt(capabilityId, reviewReason) {
     return {
         kind: 'policy_approval',
-        question: `Approve the Capability call ${capabilityId}?`,
+        question: `Approve the Capability call ${capabilityId}?${reviewReason === undefined ? '' : `\nAuto review: ${reviewReason}`}`,
         options: [{ label: 'Approve', value: 'approve' }, { label: 'Reject', value: 'reject' }],
         allow_freeform: false,
         multi_select: false

package/dist/runtime/profile.d.ts

@@ -5,4 +5,5 @@ export interface ResolvedProfile {
     readonly value: ModelHarnessProfile;
 }
 export declare function resolveProfile(config: HarnessConfig, id?: string): ResolvedProfile;
-export declare function resolveReasoningEffort(profile: ResolvedProfile, configured: string | null): string;
+export declare function modelReasoningEfforts(config: HarnessConfig, reference: string): readonly string[];
+export declare function resolveReasoningEffort(config: HarnessConfig, reference: string, configured: string | null): string;

package/dist/runtime/profile.js

@@ -20,13 +20,6 @@ const genericProfile = {
         toolDescriptionStyle: 'plain',
         recoveryConstraints: { partialResponseResume: 'forbidden', preserveReasoningState: false }
     },
-    ptc: {
-        enabledByDefault: false,
-        maxToolCalls: 32,
-        schemaVersion: 'programmatic-tool-run-v1',
-        instruction: 'Run bounded tool-heavy work through the hosted programmatic tool runtime. Use only the capability IDs frozen in this request.'
-    },
-    effort: { allowed: ['none', 'minimal', 'low', 'medium', 'high'], default: 'medium' },
     cache: {
         enabledByDefault: false,
         minimumEligiblePrefixTokens: 1024,
@@ -38,15 +31,19 @@ export function resolveProfile(config, id = 'generic-v1') {
     const value = id === 'generic-v1' ? genericProfile : config.modelHarnessProfiles?.[id];
     if (value === undefined)
         fail('MODEL_PROFILE_NOT_FOUND', 503, `Model Harness Profile ${id} is not configured.`);
-    if (!value.effort.allowed.includes(value.effort.default)) {
-        fail('MODEL_PROFILE_INVALID', 503, `Model Harness Profile ${id} has an invalid default reasoning effort.`);
-    }
     return { id, digest: digest(value), value };
 }
-export function resolveReasoningEffort(profile, configured) {
-    const effort = configured ?? profile.value.effort.default;
-    if (!profile.value.effort.allowed.includes(effort)) {
-        fail('MODEL_EFFORT_UNSUPPORTED', 400, `Reasoning effort ${effort} is not supported by Model Harness Profile ${profile.id}.`);
+export function modelReasoningEfforts(config, reference) {
+    const slash = reference.indexOf('/');
+    const provider = config.providers[reference.slice(0, slash)];
+    const model = provider?.models[reference.slice(slash + 1)];
+    if (provider === undefined || model === undefined)
+        fail('MODEL_NOT_FOUND', 404, `Model ${reference} is not configured.`);
+    return model.reasoningEfforts ?? provider.reasoningEfforts ?? [];
+}
+export function resolveReasoningEffort(config, reference, configured) {
+    if (configured === null || !modelReasoningEfforts(config, reference).includes(configured)) {
+        fail('MODEL_EFFORT_UNSUPPORTED', 400, `Reasoning effort ${configured ?? '(not selected)'} is not in the configured reasoningEfforts for ${reference}.`);
     }
-    return effort;
+    return configured;
 }

package/dist/runtime/projects.d.ts

@@ -18,6 +18,7 @@ export interface ProjectRuntime {
     readonly context: ContextEngine;
     readonly agents: AgentRuntime;
     contractDigest(): string;
+    capabilitiesDigest(): string;
     refreshSkills(): void;
 }
 export declare class ProjectRuntimes {
@@ -32,7 +33,8 @@ export declare class ProjectRuntimes {
     readonly target: AdapterTarget;
     readonly events: EventBus;
     readonly pinnedProjectId: string;
-    constructor(store: Store, config: ConfigRuntime, scheduler: Scheduler, artifacts: ArtifactStore, models: AiModelGateway, reviewer: AutoReviewer, sharedCapabilities: readonly RegisteredCapability[], target: AdapterTarget, events: EventBus, pinnedProjectId: string);
+    readonly sharedWorkspace: (path: string, executorId?: string) => boolean;
+    constructor(store: Store, config: ConfigRuntime, scheduler: Scheduler, artifacts: ArtifactStore, models: AiModelGateway, reviewer: AutoReviewer, sharedCapabilities: readonly RegisteredCapability[], target: AdapterTarget, events: EventBus, pinnedProjectId: string, sharedWorkspace?: (path: string, executorId?: string) => boolean);
     get(projectId: string): ProjectRuntime;
     refresh(projectId: string): void;
     startIdleEviction(maxIdleMs?: number): void;

package/dist/runtime/projects.js

@@ -1,9 +1,11 @@
+import { digest } from '../core/codec.js';
 import { CapabilityRegistry } from './capabilities.js';
 import { CallRuntime } from './calls.js';
 import { ContextEngine } from './context.js';
 import { AgentRuntime } from './agent.js';
 import { KernelAdapter, kernelCapabilities } from './kernel-capabilities.js';
 import { workspaceSkills } from './skills.js';
+import { webCapabilities } from '../adapters/web.js';
 import { coreManifests, manifestSetDigest } from './manifests.js';
 export class ProjectRuntimes {
     store;
@@ -16,10 +18,11 @@ export class ProjectRuntimes {
     target;
     events;
     pinnedProjectId;
+    sharedWorkspace;
     #runtimes = new Map();
     #evictionTimer;
     #closed = false;
-    constructor(store, config, scheduler, artifacts, models, reviewer, sharedCapabilities, target, events, pinnedProjectId) {
+    constructor(store, config, scheduler, artifacts, models, reviewer, sharedCapabilities, target, events, pinnedProjectId, sharedWorkspace = () => false) {
         this.store = store;
         this.config = config;
         this.scheduler = scheduler;
@@ -30,6 +33,7 @@ export class ProjectRuntimes {
         this.target = target;
         this.events = events;
         this.pinnedProjectId = pinnedProjectId;
+        this.sharedWorkspace = sharedWorkspace;
     }
     get(projectId) {
         if (this.#closed)
@@ -60,7 +64,10 @@ export class ProjectRuntimes {
         this.#evictionTimer = undefined;
         const runtimes = [...this.#runtimes.values()].map((entry) => entry.runtime);
         this.#runtimes.clear();
-        await Promise.allSettled(runtimes.flatMap((runtime) => [runtime.agents.close(), runtime.calls.close()]));
+        const results = await Promise.allSettled(runtimes.flatMap((runtime) => [runtime.agents.close(), runtime.calls.close(runtime.projectId)]));
+        const failures = results.filter((result) => result.status === 'rejected');
+        if (failures.length > 0)
+            throw new AggregateError(failures.map((result) => result.reason), 'Project runtime cleanup failed.');
     }
     async #evictIdle(maxIdleMs) {
         const timestamp = Date.now();
@@ -71,34 +78,50 @@ export class ProjectRuntimes {
                 entry.lastAccessedAt = timestamp;
                 continue;
             }
-            const lastAccessedAt = entry.lastAccessedAt;
-            await Promise.allSettled([entry.runtime.agents.close(), entry.runtime.calls.close()]);
-            if (entry.lastAccessedAt === lastAccessedAt && !this.store.hasActiveRuntimeObjects(projectId))
-                this.#runtimes.delete(projectId);
+            this.#runtimes.delete(projectId);
+            await Promise.allSettled([entry.runtime.agents.close(), entry.runtime.calls.close(entry.runtime.projectId)]);
         }
     }
     #build(projectId) {
         const registry = new CapabilityRegistry(this.target);
         for (const capability of this.sharedCapabilities)
             registry.register(capability);
+        for (const capability of webCapabilities())
+            registry.register(capability);
         const context = new ContextEngine(this.store, registry);
         const calls = new CallRuntime(this.store, registry, this.scheduler, this.artifacts, this.events);
-        const agents = new AgentRuntime(this.store, this.config, context, this.models, registry, calls, this.reviewer, this.events);
-        const kernel = new KernelAdapter(this.store, registry, this.config, (targetProjectId, agentId) => this.get(targetProjectId).agents.wake(targetProjectId, agentId), (targetProjectId, input, signal) => this.get(targetProjectId).agents.createSubagent(targetProjectId, input, signal));
+        const agents = new AgentRuntime(this.store, this.config, context, this.models, registry, calls, this.reviewer, this.events, () => refreshSkills());
+        const kernel = new KernelAdapter(this.store, registry, this.config, (targetProjectId, agentId) => this.get(targetProjectId).agents.wake(targetProjectId, agentId), (targetProjectId, input, signal) => this.get(targetProjectId).agents.createSubagent(targetProjectId, input, signal), (targetProjectId, agentId, focus, signal) => this.get(targetProjectId).agents.compactFromTool(targetProjectId, agentId, focus, signal), (invocation) => agents.executeProgram(invocation), this.artifacts);
         for (const capability of kernelCapabilities(kernel))
             registry.register(capability);
+        const definitionsDigest = () => digest(JSON.parse(JSON.stringify(registry.list())));
         const refreshSkills = () => {
-            registry.removeKind('skill');
+            const previous = definitionsDigest();
             const paths = this.store.listWorkspaces(projectId).flatMap((workspace) => {
                 const value = workspace.paths;
-                return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+                return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string' && this.sharedWorkspace(entry, typeof workspace.executor_id === 'string' ? workspace.executor_id : 'remote')) : [];
             });
-            for (const capability of workspaceSkills(paths))
+            let skills;
+            try {
+                skills = workspaceSkills(paths);
+            }
+            catch {
+                // Keep the last complete catalog when a Workspace temporarily becomes inaccessible.
+                this.events.emit(projectId, this.store.stateRevision(), 'runtime.notice', { code: 'skill_refresh_failed', component: 'capabilities', message: 'Workspace Skills could not be refreshed; the previous catalog remains active.' });
+                return;
+            }
+            registry.removeKind('skill');
+            for (const capability of skills)
                 registry.register(capability);
+            if (definitionsDigest() !== previous) {
+                this.events.emit(projectId, this.store.stateRevision(), 'runtime.notice', { code: 'snapshot_required', component: 'capabilities', project_capabilities_digest: definitionsDigest() });
+            }
         };
+        const contractDigest = () => digest({
+            manifests: manifestSetDigest([...coreManifests(this.config.current.config), ...registry.contractManifests()], this.target),
+            capabilities: JSON.parse(JSON.stringify(registry.list().filter(definition => definition.kind !== 'skill')))
+        });
         refreshSkills();
-        for (const callId of this.store.queuedDirectCallIds(projectId))
-            calls.dispatch(projectId, callId);
         return {
             projectId,
             registry,
@@ -106,10 +129,8 @@ export class ProjectRuntimes {
             context,
             agents,
             refreshSkills,
-            contractDigest: () => manifestSetDigest([
-                ...coreManifests(this.config.current.config),
-                ...registry.contractManifests()
-            ], this.target)
+            capabilitiesDigest: definitionsDigest,
+            contractDigest
         };
     }
 }

package/dist/runtime/ptc-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ptc-worker.js

@@ -0,0 +1,97 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { stripTypeScriptTypes } from 'node:module';
+import { getQuickJS } from 'quickjs-emscripten';
+const port = parentPort;
+if (port === null)
+    throw new Error('PTC must run in a worker.');
+const input = workerData;
+const module = await getQuickJS();
+const runtime = module.newRuntime();
+runtime.setMemoryLimit(64 * 1024 * 1024);
+runtime.setMaxStackSize(1024 * 1024);
+let deadline = Date.now() + input.timeoutMs;
+runtime.setInterruptHandler(() => Date.now() >= deadline);
+const vm = runtime.newContext();
+const pending = new Map();
+let sequence = 0;
+let outputBytes = 0;
+const logs = [];
+let finished = false;
+const isFinished = () => finished;
+function report(error) {
+    if (isFinished())
+        return;
+    finished = true;
+    port?.postMessage({ type: 'error', error: error instanceof Error ? error.message : String(error) });
+}
+function pump() {
+    const result = runtime.executePendingJobs();
+    if (result.error !== undefined) {
+        const error = vm.dump(result.error);
+        result.error.dispose();
+        report(JSON.stringify(error));
+    }
+}
+try {
+    const call = vm.newFunction('__call', (name, args) => {
+        const deferred = vm.newPromise();
+        const id = sequence++;
+        pending.set(id, deferred);
+        port.postMessage({ type: 'call', id, name: vm.getString(name), arguments: vm.getString(args) });
+        return deferred.handle;
+    });
+    vm.setProp(vm.global, '__call', call);
+    call.dispose();
+    const log = vm.newFunction('__log', (value) => {
+        const text = vm.getString(value);
+        outputBytes += Buffer.byteLength(text);
+        if (outputBytes > 1024 * 1024)
+            throw new Error('PTC output exceeds 1 MiB; return selected data.');
+        logs.push(text);
+    });
+    vm.setProp(vm.global, '__log', log);
+    log.dispose();
+    const bootstrap = vm.evalCode(`
+    const tools = Object.freeze(Object.fromEntries(${JSON.stringify(input.capabilityIds)}.map(name => [name, async (args = {}) => JSON.parse(await __call(name, JSON.stringify(args)))])));
+    const console = Object.freeze({ log: (...args) => __log(args.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ')) });
+  `);
+    vm.unwrapResult(bootstrap).dispose();
+    port.on('message', (message) => {
+        if (isFinished())
+            return;
+        const deferred = pending.get(message.id);
+        if (deferred === undefined)
+            return;
+        pending.delete(message.id);
+        const value = message.error === undefined ? vm.newString(message.value ?? 'null') : vm.newError(message.error);
+        if (message.error === undefined)
+            deferred.resolve(value);
+        else
+            deferred.reject(value);
+        value.dispose();
+        deferred.dispose();
+        deadline = Date.now() + input.timeoutMs;
+        pump();
+    });
+    // Strip an async function body so top-level await/return and erasable TS annotations work.
+    const wrapped = `(async () => {\n${input.program}\n})()`;
+    const code = input.language === 'typescript' ? stripTypeScriptTypes(wrapped, { mode: 'transform' }) : wrapped;
+    const result = vm.unwrapResult(vm.evalCode(code, 'program.js'));
+    const settled = vm.resolvePromise(result);
+    pump();
+    const value = vm.unwrapResult(await settled);
+    if (!isFinished()) {
+        const content = vm.dump(value);
+        const serialized = JSON.stringify({ value: content ?? null, logs });
+        if (Buffer.byteLength(serialized) > 1024 * 1024)
+            throw new Error('PTC output exceeds 1 MiB; return selected data.');
+        finished = true;
+        port.postMessage({ type: 'done', value: serialized });
+    }
+    value.dispose();
+    result.dispose();
+}
+catch (error) {
+    report(error);
+}
+// Parent terminates the worker on every exit path, including pending promises and runaway jobs.

package/dist/runtime/ptc.d.ts

@@ -0,0 +1,16 @@
+import { type Json } from '../core/domain.js';
+export interface LocalProgram {
+    readonly program: string;
+    readonly language: 'javascript' | 'typescript';
+    readonly capabilityIds: readonly string[];
+    readonly timeoutMs: number;
+    readonly maxToolCalls: number;
+    readonly signal: AbortSignal;
+    readonly waiting?: {
+        read(): boolean;
+        subscribe(changed: () => void): () => void;
+    };
+    execute(capabilityId: string, args: Json, ordinal: number, signal: AbortSignal): Promise<Json>;
+}
+/** A fresh isolated interpreter per call. Only JSON crosses its tool bridge. */
+export declare function runLocalProgram(input: LocalProgram): Promise<Json>;

package/dist/runtime/ptc.js

@@ -0,0 +1,128 @@
+import { Worker } from 'node:worker_threads';
+import { fail } from '../core/domain.js';
+/** A fresh isolated interpreter per call. Only JSON crosses its tool bridge. */
+export async function runLocalProgram(input) {
+    input.signal.throwIfAborted();
+    if (Buffer.byteLength(input.program) > 262144)
+        fail('PTC_INPUT_LIMIT', 400, 'Program exceeds 256 KiB.');
+    const controller = new AbortController();
+    const abort = () => controller.abort(input.signal.reason);
+    input.signal.addEventListener('abort', abort, { once: true });
+    const worker = new Worker(new URL(import.meta.url.endsWith('.ts') ? './ptc-worker.ts' : './ptc-worker.js', import.meta.url), {
+        workerData: { program: input.program, language: input.language, capabilityIds: input.capabilityIds, timeoutMs: input.timeoutMs },
+        execArgv: [], env: {}, resourceLimits: { maxOldGenerationSizeMb: 128, stackSizeMb: 4 }
+    });
+    const pending = new Set();
+    let count = 0;
+    let bridgeBytes = 0;
+    let stopped = false;
+    const isStopped = () => stopped;
+    let timer;
+    let unsubscribe;
+    try {
+        return await new Promise((resolve, reject) => {
+            const stop = (error) => {
+                if (isStopped())
+                    return;
+                stopped = true;
+                controller.abort(error);
+                reject(error);
+            };
+            const failure = (code, message) => stop(Object.assign(new Error(message), { code }));
+            controller.signal.addEventListener('abort', () => stop(controller.signal.reason instanceof Error ? controller.signal.reason : new Error('Program cancelled.')), { once: true });
+            let remaining = input.timeoutMs;
+            let started = performance.now();
+            let paused = false;
+            const refreshDeadline = () => {
+                if (isStopped())
+                    return;
+                const now = performance.now();
+                if (!paused)
+                    remaining -= now - started;
+                started = now;
+                clearTimeout(timer);
+                try {
+                    paused = input.waiting?.read() === true;
+                }
+                catch (error) {
+                    stop(error instanceof Error ? error : new Error(String(error)));
+                    return;
+                }
+                // Policy review and user input pause the remaining execution budget.
+                if (!paused)
+                    timer = setTimeout(() => failure('PTC_TIMEOUT', 'Local program exceeded its deadline.'), Math.max(0, remaining));
+            };
+            unsubscribe = input.waiting?.subscribe(refreshDeadline);
+            refreshDeadline();
+            worker.on('error', (error) => stop(error));
+            worker.on('exit', (code) => { if (!isStopped())
+                failure('PTC_WORKER_EXIT', `Local program worker exited without a result (${code}).`); });
+            worker.on('message', (message) => {
+                if (isStopped())
+                    return;
+                if (message.type === 'error') {
+                    failure('PTC_EXECUTION_FAILED', message.error ?? 'Local program failed.');
+                    return;
+                }
+                if (message.type === 'done') {
+                    if (pending.size > 0) {
+                        failure('PTC_UNAWAITED_TOOLS', 'Await all tool calls before returning.');
+                        return;
+                    }
+                    stopped = true;
+                    resolve(JSON.parse(message.value ?? 'null'));
+                    return;
+                }
+                if (message.type !== 'call' || typeof message.name !== 'string' || typeof message.arguments !== 'string' || typeof message.id !== 'number') {
+                    failure('PTC_BRIDGE_INVALID', 'Invalid tool bridge request.');
+                    return;
+                }
+                if (!input.capabilityIds.includes(message.name) || message.name === 'programmatic_tool_run') {
+                    failure('CAPABILITY_NOT_LOADED', 'Tool is not in this program capability set.');
+                    return;
+                }
+                if (++count > input.maxToolCalls) {
+                    failure('PTC_CALL_LIMIT', 'Local program exceeded its tool call limit.');
+                    return;
+                }
+                const id = message.id;
+                const name = message.name;
+                const argumentsText = message.arguments;
+                bridgeBytes += Buffer.byteLength(argumentsText);
+                if (bridgeBytes > 32 * 1024 * 1024) {
+                    failure('PTC_BRIDGE_LIMIT', 'Program tool traffic exceeds 32 MiB; narrow tool queries.');
+                    return;
+                }
+                const execution = (async () => {
+                    try {
+                        const output = await input.execute(name, JSON.parse(argumentsText), count - 1, controller.signal);
+                        if (isStopped())
+                            return;
+                        const value = JSON.stringify(output);
+                        bridgeBytes += Buffer.byteLength(value);
+                        if (bridgeBytes > 32 * 1024 * 1024) {
+                            failure('PTC_BRIDGE_LIMIT', 'Program tool traffic exceeds 32 MiB; narrow tool queries.');
+                            return;
+                        }
+                        worker.postMessage({ id, value });
+                    }
+                    catch (error) {
+                        if (!isStopped())
+                            worker.postMessage({ id, error: error instanceof Error ? error.message : String(error) });
+                    }
+                })();
+                pending.add(execution);
+                void execution.finally(() => pending.delete(execution));
+            });
+        });
+    }
+    finally {
+        stopped = true;
+        clearTimeout(timer);
+        unsubscribe?.();
+        input.signal.removeEventListener('abort', abort);
+        controller.abort(new Error('Local program finished.'));
+        await worker.terminate();
+        await Promise.allSettled(pending);
+    }
+}

package/dist/runtime/results.d.ts

@@ -1,7 +1,8 @@
-import { type ArtifactOutput, type CapabilityOutput, type Json } from '../core/domain.js';
-export interface NormalizedOutput {
+import type { CapabilityOutput, Json } from '../core/domain.js';
+import type { ArtifactStore } from './artifacts.js';
+export interface StoredOutput {
     readonly content: Json;
-    readonly artifacts: readonly ArtifactOutput[];
+    readonly artifacts: readonly string[];
     readonly truncated: boolean;
 }
-export declare function normalizeOutput(output: CapabilityOutput, limit: number): NormalizedOutput;
+export declare function storeOutput(projectId: string, output: CapabilityOutput, store: ArtifactStore, preview?: boolean): Promise<StoredOutput>;