@swarm-agent/sdk 0.1.47

package/dist/storage/client.d.ts

@@ -0,0 +1,174 @@
+import type { SwarmTransport } from '../transport.js';
+import type { DeliverableTelemetry, DeliverableReview } from './types.js';
+export interface StorageBucketRecord {
+    id: string;
+    account_scope_id?: string;
+    name: string;
+    provider: 's3' | 'gcs' | 'mock' | 'local' | string;
+    bucket_name: string;
+    endpoint?: string;
+    region?: string;
+    prefix?: string;
+    access_key_id?: string;
+    secret_access_key?: string;
+    enabled: boolean;
+    canonical?: boolean;
+    status?: 'active' | 'pending_approval' | 'rejected' | string;
+    proposed_by?: string;
+    proposal_reason?: string;
+    created_at?: number;
+    updated_at?: number;
+}
+export interface StorageDiscoveredWorkerRecord {
+    worker_id: string;
+    bucket_id: string;
+    account_scope_id?: string;
+    name: string;
+    description?: string;
+    version?: string;
+    tags?: string[];
+    has_base_context: boolean;
+    base_context?: Record<string, any>;
+    sessions_count?: number;
+    last_session_id?: string;
+    last_status?: string;
+    last_step?: string;
+    last_progress?: number;
+    last_activity_at?: number;
+    imported: boolean;
+    imported_at?: number;
+    discovered_at?: number;
+    updated_at?: number;
+}
+export interface StorageDiscoveredDeliverableRecord {
+    deliverable_id: string;
+    worker_id: string;
+    session_id: string;
+    bucket_id: string;
+    account_scope_id?: string;
+    title: string;
+    summary?: string;
+    kind?: string;
+    status: 'pending_review' | 'accepted' | 'approved' | 'rejected' | string;
+    sha256?: string;
+    files?: Array<{
+        name: string;
+        path: string;
+        size_bytes: number;
+        sha256: string;
+        content_type?: string;
+    }>;
+    actions?: Array<{
+        id: string;
+        label: string;
+        action_type?: string;
+        endpoint: string;
+        variant?: string;
+    }>;
+    payload?: Record<string, any>;
+    telemetry?: DeliverableTelemetry;
+    review?: DeliverableReview;
+    created_at?: number;
+    updated_at?: number;
+    imported_at?: number;
+}
+export interface CloudConnectionProposal {
+    provider: 's3' | 'gcs' | 'r2' | 'minio' | 'local' | string;
+    bucket_name: string;
+    name?: string;
+    endpoint?: string;
+    region?: string;
+    prefix?: string;
+    access_key_id?: string;
+    secret_access_key?: string;
+    proposed_by?: string;
+    proposal_reason?: string;
+    make_canonical?: boolean;
+}
+export interface ScanSummary {
+    bucket_id: string;
+    workers_found: number;
+    workers_added?: string[];
+    workers_updated?: string[];
+    workers_removed?: string[];
+    sessions_found: number;
+    deliverables_new: number;
+    scanned_at: number;
+}
+export declare class SwarmStorageNamespace {
+    private transport;
+    constructor(transport: SwarmTransport);
+    /**
+     * Lists all configured storage buckets for this account.
+     */
+    listBuckets(): Promise<StorageBucketRecord[]>;
+    /**
+     * Registers a new S3, GCS, or local storage bucket.
+     */
+    registerBucket(bucket: Partial<StorageBucketRecord>): Promise<StorageBucketRecord>;
+    /**
+     * Deletes a registered storage bucket.
+     */
+    deleteBucket(id: string): Promise<boolean>;
+    /**
+     * Triggers an immediate scan of the storage bucket for workers and deliverables.
+     */
+    scanBucket(id: string): Promise<ScanSummary>;
+    /**
+     * Lists workers discovered across all registered buckets.
+     */
+    listWorkers(): Promise<StorageDiscoveredWorkerRecord[]>;
+    /**
+     * Accepts and imports a discovered worker into local state.
+     */
+    importWorker(workerId: string): Promise<StorageDiscoveredWorkerRecord>;
+    /**
+     * Lists deliverables discovered across all registered buckets.
+     */
+    listDeliverables(): Promise<StorageDiscoveredDeliverableRecord[]>;
+    /**
+     * Imports a discovered deliverable and downloads its artifacts to the target workspace directory.
+     */
+    importDeliverable(id: string, targetWorkspacePath?: string): Promise<{
+        deliverable: StorageDiscoveredDeliverableRecord;
+        targetDir: string;
+    }>;
+    /**
+     * Retrieves the current canonical Swarm cloud storage bucket.
+     */
+    getCanonicalBucket(): Promise<StorageBucketRecord | null>;
+    /**
+     * Accepts and designates a storage bucket as the canonical Swarm cloud connection.
+     */
+    setCanonicalBucket(id: string): Promise<StorageBucketRecord>;
+    /**
+     * Proposes a new cloud storage connection from an AI worker/agent for user approval.
+     */
+    proposeConnection(proposal: CloudConnectionProposal): Promise<StorageBucketRecord>;
+    /**
+     * Lists all pending cloud storage connection proposals awaiting user approval.
+     */
+    listProposals(): Promise<StorageBucketRecord[]>;
+    /**
+     * Accepts and approves a discovered deliverable, updating its durable state in S3/GCS
+     * and optionally triggering cloud or local execution.
+     */
+    acceptDeliverable(id: string, options?: {
+        target?: 'cloud' | 'local';
+        note?: string;
+    }): Promise<{
+        deliverable: StorageDiscoveredDeliverableRecord;
+        status: string;
+    }>;
+    /**
+     * Rejects/dismisses a discovered deliverable.
+     */
+    rejectDeliverable(id: string, note?: string): Promise<{
+        deliverable: StorageDiscoveredDeliverableRecord;
+        status: string;
+    }>;
+    /**
+     * Rejects/dismisses a pending connection proposal.
+     */
+    rejectProposal(id: string): Promise<boolean>;
+}

package/dist/storage/client.js

@@ -0,0 +1,121 @@
+export class SwarmStorageNamespace {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * Lists all configured storage buckets for this account.
+     */
+    async listBuckets() {
+        const res = await this.transport.request('/v1/storage/buckets', { method: 'GET' });
+        return res.data.buckets;
+    }
+    /**
+     * Registers a new S3, GCS, or local storage bucket.
+     */
+    async registerBucket(bucket) {
+        const res = await this.transport.request('/v1/storage/buckets', { method: 'POST', body: bucket });
+        return res.data.bucket;
+    }
+    /**
+     * Deletes a registered storage bucket.
+     */
+    async deleteBucket(id) {
+        const res = await this.transport.request(`/v1/storage/buckets/${id}`, { method: 'DELETE' });
+        return res.data.deleted;
+    }
+    /**
+     * Triggers an immediate scan of the storage bucket for workers and deliverables.
+     */
+    async scanBucket(id) {
+        const res = await this.transport.request(`/v1/storage/buckets/${id}/scan`, { method: 'POST' });
+        return res.data.scan_summary;
+    }
+    /**
+     * Lists workers discovered across all registered buckets.
+     */
+    async listWorkers() {
+        const res = await this.transport.request('/v1/storage/workers', { method: 'GET' });
+        return res.data.workers;
+    }
+    /**
+     * Accepts and imports a discovered worker into local state.
+     */
+    async importWorker(workerId) {
+        const res = await this.transport.request(`/v1/storage/workers/${workerId}/import`, { method: 'POST' });
+        return res.data.worker;
+    }
+    /**
+     * Lists deliverables discovered across all registered buckets.
+     */
+    async listDeliverables() {
+        const res = await this.transport.request('/v1/storage/deliverables', { method: 'GET' });
+        return res.data.deliverables;
+    }
+    /**
+     * Imports a discovered deliverable and downloads its artifacts to the target workspace directory.
+     */
+    async importDeliverable(id, targetWorkspacePath) {
+        const res = await this.transport.request(`/v1/storage/deliverables/${id}/import`, {
+            method: 'POST',
+            body: { target_workspace_path: targetWorkspacePath },
+        });
+        return { deliverable: res.data.deliverable, targetDir: res.data.target_dir };
+    }
+    /**
+     * Retrieves the current canonical Swarm cloud storage bucket.
+     */
+    async getCanonicalBucket() {
+        const res = await this.transport.request('/v1/storage/canonical', { method: 'GET' });
+        return res.data.bucket;
+    }
+    /**
+     * Accepts and designates a storage bucket as the canonical Swarm cloud connection.
+     */
+    async setCanonicalBucket(id) {
+        const res = await this.transport.request(`/v1/storage/buckets/${id}/accept-canonical`, { method: 'POST' });
+        return res.data.bucket;
+    }
+    /**
+     * Proposes a new cloud storage connection from an AI worker/agent for user approval.
+     */
+    async proposeConnection(proposal) {
+        const res = await this.transport.request('/v1/storage/proposals', { method: 'POST', body: proposal });
+        return res.data.proposal;
+    }
+    /**
+     * Lists all pending cloud storage connection proposals awaiting user approval.
+     */
+    async listProposals() {
+        const res = await this.transport.request('/v1/storage/proposals', { method: 'GET' });
+        return res.data.proposals;
+    }
+    /**
+     * Accepts and approves a discovered deliverable, updating its durable state in S3/GCS
+     * and optionally triggering cloud or local execution.
+     */
+    async acceptDeliverable(id, options) {
+        const res = await this.transport.request(`/v1/storage/deliverables/${id}/accept`, {
+            method: 'POST',
+            body: options ?? { target: 'cloud' },
+        });
+        return res.data;
+    }
+    /**
+     * Rejects/dismisses a discovered deliverable.
+     */
+    async rejectDeliverable(id, note) {
+        const res = await this.transport.request(`/v1/storage/deliverables/${id}/reject`, {
+            method: 'POST',
+            body: { note },
+        });
+        return res.data;
+    }
+    /**
+     * Rejects/dismisses a pending connection proposal.
+     */
+    async rejectProposal(id) {
+        const res = await this.transport.request(`/v1/storage/buckets/${id}/reject`, { method: 'POST' });
+        return res.data.rejected;
+    }
+}

package/dist/storage/hub.d.ts

@@ -0,0 +1,30 @@
+import type { StorageHubConfig, WorkerManifest, WorkerBaseContext, WorkerSessionState, DeliverableManifest, PublishDeliverableOptions, WorkerActorSpec, WorkerActorTask, WorkerJobExecutionLog } from './types.js';
+export declare class WorkerStorageHub {
+    private driver;
+    private workerId;
+    private prefix;
+    constructor(config: StorageHubConfig);
+    private key;
+    private sha256Hex;
+    initWorker(definition?: Partial<WorkerManifest>): Promise<WorkerManifest>;
+    getWorkerManifest(): Promise<WorkerManifest | null>;
+    loadBaseContext(): Promise<WorkerBaseContext>;
+    saveBaseContext(context: WorkerBaseContext): Promise<void>;
+    startSession(sessionId: string, initialConfig?: Record<string, any>): Promise<WorkerSessionState>;
+    updateSessionState(sessionId: string, updates: Partial<WorkerSessionState>): Promise<WorkerSessionState>;
+    appendTrace(sessionId: string, message: string, data?: any): Promise<void>;
+    publishDeliverable(options: PublishDeliverableOptions): Promise<DeliverableManifest>;
+    getSessionState(sessionId: string): Promise<WorkerSessionState | null>;
+    getDeliverableManifest(deliverableId: string): Promise<DeliverableManifest | null>;
+    listDeliverables(): Promise<DeliverableManifest[]>;
+    getWorkerActor(): Promise<WorkerActorSpec | null>;
+    saveWorkerActor(spec: WorkerActorSpec): Promise<void>;
+    updateWorkerActor(updates: Partial<WorkerActorSpec>): Promise<WorkerActorSpec>;
+    addTask(task: Omit<WorkerActorTask, 'id' | 'createdAt' | 'status'> & {
+        id?: string;
+    }): Promise<WorkerActorTask>;
+    updateTask(taskId: string, updates: Partial<WorkerActorTask>): Promise<WorkerActorTask>;
+    logJobExecution(log: WorkerJobExecutionLog): Promise<void>;
+    getJobExecutionLog(jobId: string): Promise<WorkerJobExecutionLog | null>;
+    listJobExecutionLogs(): Promise<WorkerJobExecutionLog[]>;
+}

package/dist/storage/hub.js

@@ -0,0 +1,372 @@
+export class WorkerStorageHub {
+    driver;
+    workerId;
+    prefix;
+    constructor(config) {
+        this.driver = config.driver;
+        this.workerId = config.workerId;
+        this.prefix = config.prefix ? config.prefix.replace(/\/+$/, '') + '/' : '';
+    }
+    key(path) {
+        return `${this.prefix}${path.replace(/^\/+/, '')}`;
+    }
+    async sha256Hex(data) {
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
+        return Array.from(new Uint8Array(hashBuffer))
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    async initWorker(definition = {}) {
+        const key = this.key(`workers/${this.workerId}/worker.json`);
+        const now = new Date().toISOString();
+        let existing = null;
+        try {
+            const raw = await this.driver.readString(key);
+            if (raw)
+                existing = JSON.parse(raw);
+        }
+        catch {
+            // ignore parse error on new worker
+        }
+        const manifest = {
+            id: this.workerId,
+            name: definition.name || existing?.name || this.workerId,
+            description: definition.description ?? existing?.description ?? '',
+            version: definition.version || existing?.version || '1.0.0',
+            tags: definition.tags || existing?.tags || [],
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+        };
+        await this.driver.write(key, JSON.stringify(manifest, null, 2), 'application/json');
+        return manifest;
+    }
+    async getWorkerManifest() {
+        const key = this.key(`workers/${this.workerId}/worker.json`);
+        const raw = await this.driver.readString(key);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    async loadBaseContext() {
+        const basePrefix = `workers/${this.workerId}/base`;
+        const instructionsStr = await this.driver.readString(this.key(`${basePrefix}/instructions.md`));
+        const toolsStr = await this.driver.readString(this.key(`${basePrefix}/tools.json`));
+        const memoryStr = await this.driver.readString(this.key(`${basePrefix}/memory.json`));
+        return {
+            instructions: instructionsStr ?? undefined,
+            tools: toolsStr ? JSON.parse(toolsStr) : undefined,
+            memory: memoryStr ? JSON.parse(memoryStr) : undefined,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    async saveBaseContext(context) {
+        const basePrefix = `workers/${this.workerId}/base`;
+        if (context.instructions !== undefined) {
+            await this.driver.write(this.key(`${basePrefix}/instructions.md`), context.instructions, 'text/markdown');
+        }
+        if (context.tools !== undefined) {
+            await this.driver.write(this.key(`${basePrefix}/tools.json`), JSON.stringify(context.tools, null, 2), 'application/json');
+        }
+        if (context.memory !== undefined) {
+            await this.driver.write(this.key(`${basePrefix}/memory.json`), JSON.stringify(context.memory, null, 2), 'application/json');
+        }
+    }
+    async startSession(sessionId, initialConfig) {
+        const sessionPrefix = `workers/${this.workerId}/sessions/${sessionId}`;
+        const now = new Date().toISOString();
+        if (initialConfig) {
+            await this.driver.write(this.key(`${sessionPrefix}/run_config.json`), JSON.stringify(initialConfig, null, 2), 'application/json');
+        }
+        const state = {
+            sessionId,
+            workerId: this.workerId,
+            status: 'starting',
+            progress: 0,
+            step: 'Initialized session',
+            startedAt: now,
+            updatedAt: now,
+        };
+        await this.driver.write(this.key(`${sessionPrefix}/state.json`), JSON.stringify(state, null, 2), 'application/json');
+        return state;
+    }
+    async updateSessionState(sessionId, updates) {
+        const sessionPrefix = `workers/${this.workerId}/sessions/${sessionId}`;
+        const stateKey = this.key(`${sessionPrefix}/state.json`);
+        const now = new Date().toISOString();
+        let current = {
+            sessionId,
+            workerId: this.workerId,
+            status: 'running',
+            startedAt: now,
+            updatedAt: now,
+        };
+        try {
+            const raw = await this.driver.readString(stateKey);
+            if (raw)
+                current = JSON.parse(raw);
+        }
+        catch {
+            // ignore
+        }
+        const merged = {
+            ...current,
+            ...updates,
+            sessionId,
+            workerId: this.workerId,
+            updatedAt: now,
+        };
+        if (merged.status === 'completed' && !merged.completedAt) {
+            merged.completedAt = now;
+            if (merged.progress === undefined || merged.progress < 100) {
+                merged.progress = 100;
+            }
+        }
+        await this.driver.write(stateKey, JSON.stringify(merged, null, 2), 'application/json');
+        return merged;
+    }
+    async appendTrace(sessionId, message, data) {
+        const traceKey = this.key(`workers/${this.workerId}/sessions/${sessionId}/trace.jsonl`);
+        const entry = JSON.stringify({
+            timestamp: new Date().toISOString(),
+            message,
+            ...(data ? { data } : {}),
+        }) + '\n';
+        const existing = await this.driver.readString(traceKey);
+        const combined = existing ? existing + entry : entry;
+        await this.driver.write(traceKey, combined, 'application/x-ndjson');
+    }
+    async publishDeliverable(options) {
+        const deliverableId = options.id || `deliv_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const deliverablePrefix = `deliverables/${this.workerId}/${deliverableId}`;
+        const now = new Date().toISOString();
+        const fileRefs = [];
+        let combinedFileDigests = '';
+        if (options.files && options.files.length > 0) {
+            for (const file of options.files) {
+                const fileContent = typeof file.content === 'string'
+                    ? new TextEncoder().encode(file.content)
+                    : file.content;
+                const fileSha256 = await this.sha256Hex(fileContent);
+                const filePath = `${deliverablePrefix}/files/${file.name}`;
+                await this.driver.write(this.key(filePath), fileContent, file.contentType || 'application/octet-stream');
+                fileRefs.push({
+                    name: file.name,
+                    path: filePath,
+                    sizeBytes: fileContent.byteLength,
+                    sha256: fileSha256,
+                    contentType: file.contentType,
+                });
+                combinedFileDigests += fileSha256;
+            }
+        }
+        const aggregateSha256 = options.payload
+            ? await this.sha256Hex(JSON.stringify(options.payload) + combinedFileDigests)
+            : await this.sha256Hex(combinedFileDigests || deliverableId);
+        const manifest = {
+            id: deliverableId,
+            workerId: this.workerId,
+            sessionId: options.sessionId,
+            title: options.title,
+            summary: options.summary,
+            kind: options.kind || 'ai_deliverable',
+            status: 'pending_review',
+            telemetry: options.telemetry,
+            files: fileRefs,
+            actions: options.actions || [],
+            payload: options.payload,
+            sha256: aggregateSha256,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.driver.write(this.key(`${deliverablePrefix}/manifest.json`), JSON.stringify(manifest, null, 2), 'application/json');
+        // Automatically update the session state to completed
+        await this.updateSessionState(options.sessionId, {
+            status: 'completed',
+            progress: 100,
+            step: `Published deliverable: ${options.title}`,
+        });
+        return manifest;
+    }
+    async getSessionState(sessionId) {
+        const sessionPrefix = `workers/${this.workerId}/sessions/${sessionId}`;
+        const stateKey = this.key(`${sessionPrefix}/state.json`);
+        const raw = await this.driver.readString(stateKey);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    async getDeliverableManifest(deliverableId) {
+        const deliverablePrefix = `deliverables/${this.workerId}/${deliverableId}`;
+        const manifestKey = this.key(`${deliverablePrefix}/manifest.json`);
+        const raw = await this.driver.readString(manifestKey);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    async listDeliverables() {
+        const prefix = this.key(`deliverables/${this.workerId}/`);
+        const keys = await this.driver.list(prefix);
+        const manifests = [];
+        for (const k of keys) {
+            if (k.endsWith('/manifest.json')) {
+                const raw = await this.driver.readString(k);
+                if (raw) {
+                    try {
+                        manifests.push(JSON.parse(raw));
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        return manifests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // WORKER ACTOR SPECIFICATION (SINGLE FILE: worker.json) & JOB LOGS
+    // ─────────────────────────────────────────────────────────────────────────
+    async getWorkerActor() {
+        const key = this.key(`workers/${this.workerId}/worker.json`);
+        const raw = await this.driver.readString(key);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    async saveWorkerActor(spec) {
+        const key = this.key(`workers/${this.workerId}/worker.json`);
+        const payload = {
+            ...spec,
+            id: this.workerId,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.driver.write(key, JSON.stringify(payload, null, 2), 'application/json');
+    }
+    async updateWorkerActor(updates) {
+        const existing = await this.getWorkerActor();
+        const now = new Date().toISOString();
+        const merged = {
+            id: this.workerId,
+            name: updates.name || existing?.name || this.workerId,
+            description: updates.description ?? existing?.description,
+            version: updates.version || existing?.version || '1.0.0',
+            status: updates.status || existing?.status || 'pending_approval',
+            cloud: updates.cloud || existing?.cloud,
+            schedule: updates.schedule || existing?.schedule,
+            brain: updates.brain || existing?.brain || {
+                model: 'gemini-3.8-flash',
+                instructions: 'Autonomous Swarm Cloud Worker',
+            },
+            tasks: updates.tasks || existing?.tasks || [],
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+        };
+        await this.saveWorkerActor(merged);
+        return merged;
+    }
+    async addTask(task) {
+        const spec = (await this.getWorkerActor()) || {
+            id: this.workerId,
+            name: this.workerId,
+            version: '1.0.0',
+            status: 'pending_approval',
+            brain: { model: 'gemini-3.8-flash', instructions: '' },
+            tasks: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const taskId = task.id || `task_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const newTask = {
+            ...task,
+            id: taskId,
+            status: 'pending',
+            createdAt: new Date().toISOString(),
+        };
+        const currentTasks = spec.tasks || [];
+        spec.tasks = [...currentTasks, newTask];
+        await this.saveWorkerActor(spec);
+        return newTask;
+    }
+    async updateTask(taskId, updates) {
+        const spec = await this.getWorkerActor();
+        if (!spec) {
+            throw new Error(`Worker actor not found: ${this.workerId}`);
+        }
+        const tasks = spec.tasks || [];
+        const index = tasks.findIndex((t) => t.id === taskId);
+        if (index === -1) {
+            throw new Error(`Task ${taskId} not found on worker ${this.workerId}`);
+        }
+        const current = tasks[index];
+        const updated = {
+            ...current,
+            ...updates,
+            id: taskId,
+        };
+        tasks[index] = updated;
+        spec.tasks = tasks;
+        await this.saveWorkerActor(spec);
+        return updated;
+    }
+    async logJobExecution(log) {
+        const jobKey = this.key(`workers/${this.workerId}/jobs/${log.jobId}/execution.json`);
+        await this.driver.write(jobKey, JSON.stringify(log, null, 2), 'application/json');
+        // Also append to session trace if sessionId is present
+        if (log.taskId) {
+            await this.appendTrace(log.taskId, `[${log.type}] ${log.status}: ${log.durationMs}ms - $${log.telemetry.cost_usd.toFixed(6)}`, {
+                tokens: log.telemetry,
+                error: log.error,
+            });
+        }
+        // Update worker task if associated with a taskId
+        if (log.taskId) {
+            try {
+                await this.updateTask(log.taskId, {
+                    status: log.status === 'success' ? 'completed' : 'failed',
+                    completedAt: log.completedAt,
+                    deliverableId: log.deliverableId,
+                    error: log.error,
+                    telemetry: {
+                        model: log.telemetry.model,
+                        thinking_level: log.telemetry.thinking_level,
+                        prompt_tokens: log.telemetry.prompt_tokens,
+                        candidate_tokens: log.telemetry.candidate_tokens,
+                        thinking_tokens: log.telemetry.thinking_tokens,
+                        total_tokens: log.telemetry.total_tokens,
+                        compute_duration_ms: log.durationMs,
+                        cost_usd: log.telemetry.cost_usd,
+                    },
+                });
+            }
+            catch {
+                // Task might not have been pre-registered in worker.json
+            }
+        }
+    }
+    async getJobExecutionLog(jobId) {
+        const jobKey = this.key(`workers/${this.workerId}/jobs/${jobId}/execution.json`);
+        const raw = await this.driver.readString(jobKey);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    async listJobExecutionLogs() {
+        const prefix = this.key(`workers/${this.workerId}/jobs/`);
+        const keys = await this.driver.list(prefix);
+        const logs = [];
+        for (const k of keys) {
+            if (k.endsWith('/execution.json')) {
+                const raw = await this.driver.readString(k);
+                if (raw) {
+                    try {
+                        logs.push(JSON.parse(raw));
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        return logs.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+}