nexus-agentd 0.1.8 → 0.2.0

package/dist/a2a/runtime.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSessionRuntime, AgentSessionSink } from '../session-contract.js';
-import type { AgentdA2AConfig, AgentdAgentView, AgentdInputAttachment } from '../types.js';
+import type { AgentdA2AConfig, AgentdAgentView, AgentdInputAttachment, AgentdPendingResponse } from '../types.js';
 export declare function probeA2AAgent(id: string, config: AgentdA2AConfig): Promise<AgentdAgentView>;
 export declare class A2AClientRuntime implements AgentSessionRuntime {
     private readonly config;
@@ -10,16 +10,17 @@ export declare class A2AClientRuntime implements AgentSessionRuntime {
     private taskId;
     private contextId;
     private prompting;
-    private firstPrompt;
-    private readonly instructions;
     private disposed;
     private activeController?;
     private readonly artifactCache;
     private readonly emittedMessages;
+    private sawTaskStatus;
+    private sawAgentMessage;
+    private completionProof?;
     constructor(config: AgentdA2AConfig, sink: AgentSessionSink, promptTimeoutMs: number);
     start(): Promise<void>;
     prompt(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
-    respondPending(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
+    respondPending(response: AgentdPendingResponse | string, attachments?: AgentdInputAttachment[]): Promise<void>;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     private messageRequest;

package/dist/a2a/runtime.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { Role, TaskState } from '@a2a-js/sdk';
 import { ClientFactory, DefaultAgentCardResolver, JsonRpcTransportFactory, RestTransportFactory } from '@a2a-js/sdk/client';
-import { buildAgentInstructions, composeInitialAgentPrompt } from '../agent-instructions.js';
+import { TURN_COMPLETION_CONTRACT } from '../completion-contract.js';
 export async function probeA2AAgent(id, config) {
     const startedAt = Date.now();
     if (config.enabled === false)
@@ -44,17 +44,17 @@ export class A2AClientRuntime {
     taskId = '';
     contextId = '';
     prompting = false;
-    firstPrompt = true;
-    instructions;
     disposed = false;
     activeController;
     artifactCache = new Map();
     emittedMessages = new Set();
+    sawTaskStatus = false;
+    sawAgentMessage = false;
+    completionProof;
     constructor(config, sink, promptTimeoutMs) {
         this.config = config;
         this.sink = sink;
         this.promptTimeoutMs = promptTimeoutMs;
-        this.instructions = buildAgentInstructions(config.instructions);
     }
     async start() {
         const resolver = createResolver(this.config);
@@ -80,25 +80,38 @@ export class A2AClientRuntime {
         if (this.disposed)
             throw new Error('A2A runtime is disposed');
         this.prompting = true;
+        this.sawTaskStatus = false;
+        this.sawAgentMessage = false;
+        this.completionProof = undefined;
         this.sink.clearPending();
         this.sink.setState('running');
-        const promptMessage = this.firstPrompt
-            ? composeInitialAgentPrompt(this.instructions, message)
-            : message;
-        this.firstPrompt = false;
         const controller = new AbortController();
         this.activeController = controller;
         const timer = setTimeout(() => controller.abort(new Error('A2A message timed out')), Math.min(this.promptTimeoutMs, this.config.timeoutMs || this.promptTimeoutMs));
         timer.unref?.();
         try {
-            const request = this.messageRequest(promptMessage, attachments);
+            const request = this.messageRequest(message, attachments);
             for await (const response of this.client.sendMessageStream(request, {
                 signal: controller.signal
             })) {
                 this.processResponse(response);
             }
-            if (this.sink.state === 'running')
-                this.sink.setState('completed');
+            if (this.sink.state === 'running') {
+                if (this.completionProof) {
+                    this.sink.completeTurn(this.completionProof);
+                }
+                else if (!this.sawTaskStatus && this.sawAgentMessage) {
+                    this.sink.completeTurn({
+                        source: 'a2a_message_stream',
+                        stopReason: 'message_stream_end'
+                    });
+                }
+                else {
+                    this.sink.setState('failed', this.sawTaskStatus
+                        ? 'A2A stream ended without a terminal task status.'
+                        : 'A2A stream ended without an agent result.');
+                }
+            }
         }
         catch (error) {
             if (this.sink.state !== 'canceled') {
@@ -112,10 +125,19 @@ export class A2AClientRuntime {
             this.prompting = false;
         }
     }
-    async respondPending(message, attachments = []) {
+    async respondPending(response, attachments = []) {
         if (this.sink.state !== 'input_required') {
             throw new Error('A2A session is not waiting for input');
         }
+        const message = typeof response === 'string'
+            ? response
+            : response.action === 'cancel'
+                ? 'cancel'
+                : response.action === 'decline'
+                    ? 'decline'
+                    : response.message ?? response.optionId ?? '';
+        if (!message.trim())
+            throw new Error('A2A pending response is empty');
         this.sink.clearPending();
         await this.prompt(message, attachments);
     }
@@ -155,6 +177,12 @@ export class A2AClientRuntime {
                         filename: '',
                         mediaType: 'text/plain'
                     },
+                    {
+                        content: { $case: 'text', value: TURN_COMPLETION_CONTRACT },
+                        metadata: undefined,
+                        filename: '',
+                        mediaType: 'text/plain'
+                    },
                     ...attachments.map((attachment) => ({
                         content: {
                             $case: 'raw',
@@ -209,6 +237,7 @@ export class A2AClientRuntime {
     processMessage(message) {
         if (!message || message.role !== Role.ROLE_AGENT)
             return;
+        this.sawAgentMessage = true;
         this.captureIds(message.taskId, message.contextId);
         if (message.messageId && this.emittedMessages.has(message.messageId))
             return;
@@ -221,10 +250,18 @@ export class A2AClientRuntime {
                 content: { type: 'text', text }
             });
         }
+        message.parts.forEach((part, index) => {
+            const artifact = artifactFromPart(part, `message:${message.messageId || 'agent'}:${index}`);
+            if (!artifact)
+                return;
+            this.sink.addArtifact(artifact);
+            this.sink.emit('artifact', artifact);
+        });
     }
     processStatus(status) {
         if (!status)
             return;
+        this.sawTaskStatus = true;
         this.processMessage(status.message);
         const statusText = textParts(status.message?.parts || []).join('\n').trim();
         switch (status.state) {
@@ -234,7 +271,10 @@ export class A2AClientRuntime {
                 break;
             case TaskState.TASK_STATE_COMPLETED:
                 this.sink.clearPending();
-                this.sink.setState('completed');
+                this.completionProof = {
+                    source: 'a2a_task_status',
+                    stopReason: 'completed'
+                };
                 break;
             case TaskState.TASK_STATE_CANCELED:
                 this.sink.clearPending();
@@ -348,6 +388,36 @@ function artifactFromA2A(artifact) {
         metadata: artifact.metadata || undefined
     };
 }
+function artifactFromPart(part, id) {
+    switch (part.content?.$case) {
+        case 'raw':
+            return {
+                id,
+                name: part.filename || id,
+                filename: part.filename || undefined,
+                mediaType: part.mediaType || undefined,
+                bytesBase64: Buffer.from(part.content.value).toString('base64')
+            };
+        case 'url':
+            return {
+                id,
+                name: part.filename || part.content.value || id,
+                filename: part.filename || undefined,
+                mediaType: part.mediaType || undefined,
+                url: part.content.value || undefined
+            };
+        case 'data':
+            return {
+                id,
+                name: part.filename || id,
+                filename: part.filename || undefined,
+                mediaType: part.mediaType || undefined,
+                data: part.content.value
+            };
+        default:
+            return undefined;
+    }
+}
 function textParts(parts) {
     return parts.flatMap((part) => part.content?.$case === 'text' && part.content.value ? [part.content.value] : []);
 }

package/dist/acp/runtime.d.ts

@@ -1,9 +1,6 @@
 import type { AgentDriver } from '../drivers/index.js';
 import type { AcpSessionSink } from '../session-contract.js';
-import type { AgentdInputAttachment } from '../types.js';
-export declare class InvalidPermissionAnswerError extends Error {
-    constructor(message: string);
-}
+import type { AgentdInputAttachment, AgentdPendingResponse } from '../types.js';
 export declare class AcpProcessRuntime {
     private readonly driver;
     private readonly sink;
@@ -15,14 +12,12 @@ export declare class AcpProcessRuntime {
     private prompting;
     private readonly maxStderrChunkChars;
     private readonly promptTimeoutMs;
-    private readonly instructions;
-    private firstPrompt;
     private promptCapabilities;
     private inputDirectory?;
-    constructor(driver: AgentDriver, sink: AcpSessionSink, maxStderrChunkChars?: number, promptTimeoutMs?: number, customInstructions?: string);
+    constructor(driver: AgentDriver, sink: AcpSessionSink, maxStderrChunkChars?: number, promptTimeoutMs?: number);
     start(workspace: string): Promise<void>;
     prompt(message: string, attachments?: AgentdInputAttachment[]): Promise<void>;
-    respondPending(message: string, _attachments?: AgentdInputAttachment[]): Promise<void>;
+    respondPending(input: AgentdPendingResponse | string, _attachments?: AgentdInputAttachment[]): Promise<void>;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     private requestPermission;

package/dist/acp/runtime.js

@@ -4,13 +4,7 @@ import path from 'node:path';
 import { Readable, Writable } from 'node:stream';
 import { pathToFileURL } from 'node:url';
 import * as acp from '@agentclientprotocol/sdk';
-import { buildAgentInstructions, composeInitialAgentPrompt } from '../agent-instructions.js';
-export class InvalidPermissionAnswerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPermissionAnswerError';
-    }
-}
+import { TURN_COMPLETION_CONTRACT } from '../completion-contract.js';
 export class AcpProcessRuntime {
     driver;
     sink;
@@ -22,11 +16,9 @@ export class AcpProcessRuntime {
     prompting = false;
     maxStderrChunkChars;
     promptTimeoutMs;
-    instructions;
-    firstPrompt = true;
     promptCapabilities = {};
     inputDirectory;
-    constructor(driver, sink, maxStderrChunkChars = 16 * 1024, promptTimeoutMs = 30 * 60 * 1000, customInstructions) {
+    constructor(driver, sink, maxStderrChunkChars = 16 * 1024, promptTimeoutMs = 30 * 60 * 1000) {
         this.driver = driver;
         this.sink = sink;
         const limit = Number.isFinite(maxStderrChunkChars)
@@ -34,7 +26,6 @@ export class AcpProcessRuntime {
             : 16 * 1024;
         this.maxStderrChunkChars = Math.max(1, Math.min(16 * 1024, limit));
         this.promptTimeoutMs = Math.max(10_000, Math.trunc(promptTimeoutMs));
-        this.instructions = buildAgentInstructions(customInstructions);
     }
     async start(workspace) {
         if (this.process)
@@ -70,7 +61,7 @@ export class AcpProcessRuntime {
             },
             clientInfo: {
                 name: 'nexus-agentd',
-                version: '0.1.4'
+                version: '0.2.0'
             }
         });
         if (initialize.protocolVersion !== acp.PROTOCOL_VERSION) {
@@ -96,26 +87,29 @@ export class AcpProcessRuntime {
         this.prompting = true;
         this.sink.clearPending();
         this.sink.setState('running');
-        const promptMessage = this.firstPrompt
-            ? composeInitialAgentPrompt(this.instructions, message)
-            : message;
-        this.firstPrompt = false;
         try {
             const response = await withTimeout(this.connection.agent.request(acp.methods.agent.session.prompt, {
                 sessionId,
-                prompt: await this.promptBlocks(promptMessage, attachments)
+                prompt: await this.promptBlocks(message, attachments)
             }), this.promptTimeoutMs, 'ACP prompt timed out');
             if (this.sink.state === 'canceled' || this.sink.state === 'failed') {
                 return;
             }
-            if (response.stopReason === 'cancelled') {
-                this.sink.setState('canceled');
-            }
-            else if (response.stopReason === 'refusal') {
-                this.sink.setState('failed', 'ACP agent refused the prompt');
-            }
-            else {
-                this.sink.setState('completed');
+            switch (response.stopReason) {
+                case 'end_turn':
+                    this.sink.completeTurn({
+                        source: 'acp_prompt_response',
+                        stopReason: response.stopReason
+                    });
+                    break;
+                case 'cancelled':
+                    this.sink.setState('canceled');
+                    break;
+                case 'refusal':
+                    this.sink.setState('failed', 'ACP agent refused the prompt');
+                    break;
+                default:
+                    this.sink.setState('failed', `ACP turn stopped before completion: ${response.stopReason}`);
             }
         }
         catch (error) {
@@ -129,16 +123,47 @@ export class AcpProcessRuntime {
             this.prompting = false;
         }
     }
-    async respondPending(message, _attachments = []) {
+    async respondPending(input, _attachments = []) {
+        const response = typeof input === 'string'
+            ? {
+                requestId: this.pendingInput?.request.id ??
+                    this.pending?.request.id ??
+                    '',
+                message: input
+            }
+            : input;
         if (this.pendingInput) {
-            this.finishInput(message);
+            if (response.requestId !== this.pendingInput.request.id) {
+                throw new Error(`ACP pending request no longer matches: ${response.requestId}`);
+            }
+            this.finishInput(response.message ?? response.optionId ?? '', response.action);
             return;
         }
         const pending = this.pending;
         if (!pending)
             throw new Error('ACP session is not waiting for input');
-        const normalized = message.trim().toLowerCase();
+        if (response.requestId !== pending.request.id) {
+            throw new Error(`ACP pending request no longer matches: ${response.requestId}`);
+        }
         const options = pending.request.options || [];
+        if (response.action === 'cancel' || response.action === 'decline') {
+            this.finishPermission({ outcome: { outcome: 'cancelled' } });
+            return;
+        }
+        if (response.action === 'accept') {
+            const option = options.find((item) => item.kind?.startsWith('allow')) ||
+                options.find((item) => !(item.kind?.startsWith('reject') ?? false));
+            if (!option) {
+                throw new Error('Permission request does not provide an allow option');
+            }
+            this.finishPermission({
+                outcome: { outcome: 'selected', optionId: option.id }
+            });
+            return;
+        }
+        const normalized = (response.optionId ?? response.message ?? '')
+            .trim()
+            .toLowerCase();
         if (['cancel', 'deny', 'reject', '拒绝', '取消', '不同意'].includes(normalized)) {
             this.finishPermission({ outcome: { outcome: 'cancelled' } });
             return;
@@ -147,9 +172,9 @@ export class AcpProcessRuntime {
         const option = Number.isInteger(numeric) && numeric >= 1
             ? options[numeric - 1]
             : options.find((item) => item.id.toLowerCase() === normalized ||
-                item.name.toLowerCase() === normalized) || permissionApprovalOption(normalized, options);
+                item.name.toLowerCase() === normalized);
         if (!option) {
-            throw new InvalidPermissionAnswerError(`Permission answer must be an option id/name or index: ${options
+            throw new Error(`Permission answer must be an option id/name or index: ${options
                 .map((item, index) => `${index + 1}. ${item.name} (${item.id})`)
                 .join('; ')}`);
         }
@@ -221,18 +246,6 @@ export class AcpProcessRuntime {
                 }
                 : { outcome: { outcome: 'cancelled' } };
         }
-        if (this.driver.permissionPolicy === 'allow') {
-            const allow = params.options.find((option) => option.kind.toLowerCase() === 'allow_once') ||
-                params.options.find((option) => option.kind.toLowerCase().startsWith('allow'));
-            return allow
-                ? {
-                    outcome: {
-                        outcome: 'selected',
-                        optionId: allow.optionId
-                    }
-                }
-                : { outcome: { outcome: 'cancelled' } };
-        }
         if (this.pending) {
             return { outcome: { outcome: 'cancelled' } };
         }
@@ -295,16 +308,17 @@ export class AcpProcessRuntime {
             this.pendingInput = { request, params, resolve, timer };
         });
     }
-    finishInput(message) {
+    finishInput(message, requestedAction) {
         const pending = this.pendingInput;
         if (!pending)
             return;
         const normalized = message.trim().toLowerCase();
         let response;
-        if (['cancel', '取消'].includes(normalized)) {
+        if (requestedAction === 'cancel' || ['cancel', '取消'].includes(normalized)) {
             response = { action: 'cancel' };
         }
-        else if (['decline', '拒绝', '不同意'].includes(normalized)) {
+        else if (requestedAction === 'decline' ||
+            ['decline', '拒绝', '不同意'].includes(normalized)) {
             response = { action: 'decline' };
         }
         else if (!isFormElicitation(pending.params)) {
@@ -434,7 +448,10 @@ export class AcpProcessRuntime {
         return value;
     }
     async promptBlocks(message, attachments) {
-        const blocks = [{ type: 'text', text: message }];
+        const blocks = [
+            { type: 'text', text: message },
+            { type: 'text', text: TURN_COMPLETION_CONTRACT }
+        ];
         for (const attachment of attachments) {
             const mediaType = attachment.mediaType || 'application/octet-stream';
             const data = attachment.bytes.toString('base64');
@@ -477,39 +494,6 @@ export class AcpProcessRuntime {
         };
     }
 }
-function permissionApprovalOption(answer, options) {
-    const approvals = new Set([
-        'yes',
-        'y',
-        'ok',
-        'okay',
-        'approve',
-        'approved',
-        'accept',
-        'allow',
-        'proceed',
-        '同意',
-        '允许',
-        '允许一次',
-        '确认',
-        '好的',
-        '可以',
-        '继续',
-        '是',
-        '是的'
-    ]);
-    if (!approvals.has(answer))
-        return undefined;
-    return (options.find((item) => item.kind?.toLowerCase() === 'allow_once') ||
-        options.find((item) => isApprovalOption(item)));
-}
-function isApprovalOption(option) {
-    const kind = option.kind?.toLowerCase() || '';
-    if (kind.startsWith('allow'))
-        return true;
-    const values = [option.id, option.name].map((value) => value.trim().toLowerCase());
-    return values.some((value) => ['allow', 'approve', 'accept', 'permit', '允许', '同意'].some((word) => value === word || value.startsWith(`${word} `) || value.startsWith(`${word}_`)));
-}
 class PromptTimeoutError extends Error {
 }
 function safeFilename(value) {

package/dist/completion-contract.d.ts

@@ -0,0 +1 @@
+export declare const TURN_COMPLETION_CONTRACT: string;

package/dist/completion-contract.js

@@ -0,0 +1,9 @@
+export const TURN_COMPLETION_CONTRACT = [
+    '<agent_nexus_completion_contract>',
+    'Do not end this turn while requested work is still running or incomplete.',
+    'If you need user input or permission, use the protocol input/permission request and wait for the response.',
+    'Before ending the turn, verify the requested work and provide a non-empty final response.',
+    'The final response must summarize the outcome, verification performed, and workspace-relative paths for generated files.',
+    'Attach generated resources or artifacts through the protocol when supported.',
+    '</agent_nexus_completion_contract>'
+].join('\n');

package/dist/config.js

@@ -1,6 +1,5 @@
 import { mkdir, open, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { normalizeAgentInstructions } from './agent-instructions.js';
 import { agentdDriverKinds } from './types.js';
 export async function ensureAgentdConfig(filePath, options = {}) {
     const absolute = path.resolve(filePath);
@@ -98,12 +97,6 @@ export async function loadAgentdConfig(filePath) {
         workspaceRoots,
         maxRequestBytes: integerValue(value.maxRequestBytes, 'maxRequestBytes', 1024 * 1024, 1024, 16 * 1024 * 1024),
         maxAttachmentBytes: integerValue(value.maxAttachmentBytes, 'maxAttachmentBytes', 32 * 1024 * 1024, 1024, 64 * 1024 * 1024),
-        artifactStoragePath: resolveConfigPath(absolute, optionalString(value.artifactStoragePath, 'artifactStoragePath') || './artifacts'),
-        maxArtifactBytes: integerValue(value.maxArtifactBytes, 'maxArtifactBytes', 512 * 1024 * 1024, 1024, 16 * 1024 * 1024 * 1024),
-        maxArtifactStorageBytes: integerValue(value.maxArtifactStorageBytes, 'maxArtifactStorageBytes', 4 * 1024 * 1024 * 1024, 1024 * 1024, Number.MAX_SAFE_INTEGER),
-        maxPublishedArtifacts: integerValue(value.maxPublishedArtifacts, 'maxPublishedArtifacts', 4096, 1, 1_000_000),
-        maxConcurrentArtifactPublishes: integerValue(value.maxConcurrentArtifactPublishes, 'maxConcurrentArtifactPublishes', 4, 1, 128),
-        artifactTtlMs: integerValue(value.artifactTtlMs, 'artifactTtlMs', 24 * 60 * 60 * 1000, 60_000, 30 * 24 * 60 * 60 * 1000),
         maxEventsPerSession: integerValue(value.maxEventsPerSession, 'maxEventsPerSession', 2048, 64, 100_000),
         maxOutputChars: integerValue(value.maxOutputChars, 'maxOutputChars', 512 * 1024, 16 * 1024, 16 * 1024 * 1024),
         sessionTtlMs: integerValue(value.sessionTtlMs, 'sessionTtlMs', 24 * 60 * 60 * 1000, 60_000, 30 * 24 * 60 * 60 * 1000),
@@ -141,9 +134,7 @@ function parseAgent(id, value) {
         throw new Error(`Unsupported nexus-agentd driver: ${driver || id}`);
     }
     const permissionPolicy = optionalString(input.permissionPolicy, `agents.${id}.permissionPolicy`) || 'ask';
-    if (permissionPolicy !== 'ask' &&
-        permissionPolicy !== 'allow' &&
-        permissionPolicy !== 'deny') {
+    if (permissionPolicy !== 'ask' && permissionPolicy !== 'deny') {
         throw new Error(`Invalid permissionPolicy for ${id}`);
     }
     const result = {
@@ -151,7 +142,6 @@ function parseAgent(id, value) {
         driver,
         name: optionalString(input.name, `agents.${id}.name`),
         description: optionalString(input.description, `agents.${id}.description`),
-        instructions: normalizeAgentInstructions(input.instructions, `agents.${id}.instructions`),
         enabled: optionalBoolean(input.enabled, `agents.${id}.enabled`) ?? true,
         workspace: optionalString(input.workspace, `agents.${id}.workspace`),
         command: optionalString(input.command, `agents.${id}.command`),
@@ -207,7 +197,6 @@ function parseA2AAgent(id, input) {
         protocol: 'a2a',
         name: optionalString(input.name, `agents.${id}.name`),
         description: optionalString(input.description, `agents.${id}.description`),
-        instructions: normalizeAgentInstructions(input.instructions, `agents.${id}.instructions`),
         enabled: optionalBoolean(input.enabled, `agents.${id}.enabled`) ?? true,
         agentCardUrl,
         agentUrl,
@@ -340,9 +329,6 @@ function validateHttpUrl(value, name) {
         throw new Error(`nexus-agentd ${name} must be an http(s) URL without credentials or a fragment`);
     }
 }
-function resolveConfigPath(configPath, value) {
-    return path.resolve(path.dirname(configPath), value);
-}
 function secretsEqual(left, right) {
     return left.length === right.length && left === right;
 }

package/dist/control-plane.d.ts

@@ -5,7 +5,6 @@ export interface AgentdAgentUpdate {
     driver?: AgentdDriverKind;
     name?: string;
     description?: string;
-    instructions?: string;
     enabled?: boolean;
     workspace?: string;
     permissionPolicy?: PermissionPolicy;

package/dist/control-plane.js

@@ -2,7 +2,6 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmod, open, readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { hashAdminPassword, validateAdminPassword, verifyAdminPassword } from './auth.js';
-import { normalizeAgentInstructions } from './agent-instructions.js';
 import { loadAgentdConfig } from './config.js';
 import { createDriverRegistry } from './drivers/index.js';
 import { agentdDriverKinds } from './types.js';
@@ -312,7 +311,6 @@ export class AgentdControlPlane {
                 next.name = cleanString(update.name) || cleanString(previous.name);
             }
         }
-        setOptionalInstructions(next, update.instructions ?? cleanString(previous.instructions));
         setOptionalString(next, 'description', update.description ?? cleanString(previous.description));
         agents[id] = next;
         raw.agents = agents;
@@ -450,7 +448,6 @@ export class AgentdControlPlane {
                 protocol: 'a2a',
                 name: config.name || id,
                 description: config.description,
-                instructions: config.instructions,
                 enabled: config.enabled !== false,
                 agentCardUrl: config.agentCardUrl || defaultAgentCardUrl(config.agentUrl),
                 agentUrl: config.agentUrl,
@@ -469,7 +466,6 @@ export class AgentdControlPlane {
             driver: config.driver,
             name: config.name || id,
             description: config.description,
-            instructions: config.instructions,
             enabled: config.enabled !== false,
             workspace: config.workspace || this.config.workspaceRoots[0] || '',
             permissionPolicy: config.permissionPolicy || 'ask',
@@ -505,9 +501,8 @@ function validateUpdate(update) {
     }
     if (update.permissionPolicy !== undefined &&
         update.permissionPolicy !== 'ask' &&
-        update.permissionPolicy !== 'allow' &&
         update.permissionPolicy !== 'deny') {
-        throw new ControlPlaneError(400, 'permissionPolicy must be ask, allow, or deny');
+        throw new ControlPlaneError(400, 'permissionPolicy must be ask or deny');
     }
     if (update.preferredTransport !== undefined &&
         !['auto', 'jsonrpc', 'http-json'].includes(update.preferredTransport)) {
@@ -612,19 +607,6 @@ function setOptionalString(target, key, value) {
     else
         delete target[key];
 }
-function setOptionalInstructions(target, value) {
-    let text;
-    try {
-        text = normalizeAgentInstructions(value);
-    }
-    catch (error) {
-        throw new ControlPlaneError(400, errorMessage(error));
-    }
-    if (text)
-        target.instructions = text;
-    else
-        delete target.instructions;
-}
 function validHeaderName(value) {
     return /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(value);
 }

package/dist/run-store.d.ts

@@ -32,7 +32,7 @@ export declare class RunStore {
     constructor(filePath: string, maxRuns?: number, maxTaskChars?: number);
     init(): Promise<void>;
     create(input: CreateRunInput): AgentdRunDetail;
-    update(id: string, patch: Partial<Pick<StoredRun, 'protocolSessionId' | 'state' | 'progress' | 'output' | 'error' | 'artifacts' | 'artifactCount' | 'updatedAt' | 'endedAt' | 'durationMs' | 'inputAttachmentCount'>>): AgentdRunDetail | undefined;
+    update(id: string, patch: Partial<Pick<StoredRun, 'protocolSessionId' | 'state' | 'progress' | 'output' | 'error' | 'artifacts' | 'artifactCount' | 'updatedAt' | 'endedAt' | 'durationMs' | 'inputAttachmentCount' | 'completion'>>): AgentdRunDetail | undefined;
     get(id: string): AgentdRunDetail | undefined;
     list(query?: RunListQuery): {
         runs: AgentdRunView[];