intentdna 1.9.5 → 1.9.8

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "Declarative policy layer for AI agent behavior with plugin-managed hook runtime for Claude Code.",
-      "version": "1.9.5",
+      "version": "1.9.8",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.9.5"
+  "version": "1.9.8"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.9.5",
+  "version": "1.9.8",
   "description": "Declarative policy layer for AI agent behavior",
   "author": {
     "name": "Samuel"

package/dist/cli/commands/run.js

@@ -170,15 +170,15 @@ function readCanonicalMetadata(value) {
         || !hasExactKeys(value.provider, [
             "kind",
             "executable",
-            "max_budget_usd",
+            ...(value.provider.max_budget_usd === undefined ? [] : ["max_budget_usd"]),
             "permission_mode",
         ])
         || (value.provider.kind !== "claude" && value.provider.kind !== "codex")
         || (value.provider.executable !== null && (typeof value.provider.executable !== "string"
             || value.provider.executable.length === 0))
-        || typeof value.provider.max_budget_usd !== "number"
-        || !Number.isFinite(value.provider.max_budget_usd)
-        || value.provider.max_budget_usd <= 0
+        || (value.provider.max_budget_usd !== undefined && (typeof value.provider.max_budget_usd !== "number"
+            || !Number.isFinite(value.provider.max_budget_usd)
+            || value.provider.max_budget_usd <= 0))
         || typeof value.provider.permission_mode !== "string"
         || value.provider.permission_mode.length === 0
         || typeof value.max_concurrency !== "number"
@@ -220,7 +220,9 @@ function providerConfiguration(metadata) {
             ...(metadata.provider.executable === null
                 ? {}
                 : { executable: metadata.provider.executable }),
-            max_budget_usd: metadata.provider.max_budget_usd,
+            ...(metadata.provider.max_budget_usd === undefined
+                ? {}
+                : { max_budget_usd: metadata.provider.max_budget_usd }),
             permission_mode: metadata.provider.permission_mode,
         },
         credential_references: [],
@@ -299,8 +301,8 @@ function createProvider(binding) {
     }
     const maxBudget = configuration.options.max_budget_usd;
     const permissionMode = configuration.options.permission_mode;
-    if (maxBudget === undefined || permissionMode === undefined) {
-        throw new Error("Claude run binding is missing launch budget or permission mode");
+    if (permissionMode === undefined) {
+        throw new Error("Claude run binding is missing launch permission mode");
     }
     const mcpConfigPath = findProjectMcpConfig(binding.workspace_root);
     return createClaudeExecutionProvider({
@@ -308,8 +310,7 @@ function createProvider(binding) {
         agentName: (packet) => `dna-${toKebabCase(packet.role)}`,
         mcpConfigPath,
         extraArgs: [
-            "--max-budget-usd",
-            String(maxBudget),
+            ...(maxBudget === undefined ? [] : ["--max-budget-usd", String(maxBudget)]),
             "--permission-mode",
             permissionMode,
         ],
@@ -425,7 +426,9 @@ function startMetadata(opts, projectDirectory) {
         provider: {
             kind: provider,
             executable: opts.providerExecutable === undefined ? null : requireText(opts.providerExecutable, "--provider-executable"),
-            max_budget_usd: requirePositiveNumber(opts.maxBudget ?? 5, "--max-budget"),
+            ...(opts.maxBudget === undefined
+                ? {}
+                : { max_budget_usd: requirePositiveNumber(opts.maxBudget, "--max-budget") }),
             // Durable workers have no interactive prompt available for tool approvals.
             // Keep an explicitly supplied mode unchanged, but make the unattended
             // default writable so required artifacts can be produced.

package/dist/cli/index.js

@@ -310,7 +310,7 @@ Options:
   --max-concurrency <n>    Maximum simultaneously active Steps (default: 1)
   --timeout-ms <n>         Per-attempt timeout in milliseconds
   --cancellation-grace-ms <n> Process-tree cancellation grace period (default: 5000)
-  --max-budget <usd>       Claude budget per Step attempt (default: 5)
+  --max-budget <usd>       Optional Claude budget per Step attempt (no budget by default)
   --permission-mode <mode> Claude permission mode (default: bypassPermissions for unattended runs)
   --agents <dir>           Project agent output directory (default: .claude/agents)
   --reason <text>          Cancellation or closure reason
@@ -588,9 +588,9 @@ async function main() {
                 context: runValues.context,
                 vars: Object.keys(vars).length > 0 ? vars : undefined,
                 dryRun: runValues["dry-run"],
-                maxBudget: runValues["max-budget"]
-                    ? parseFloat(runValues["max-budget"])
-                    : undefined,
+                maxBudget: runValues["max-budget"] === undefined
+                    ? undefined
+                    : Number(runValues["max-budget"]),
                 logDir: runValues["log-dir"],
                 permissionMode: runValues["permission-mode"],
                 agentsDir: runValues.agents,

package/dist/runtime/canonical-run-service.js

@@ -3560,7 +3560,14 @@ export class CanonicalRunService {
             resolution = await this.executionAuthority.requestStop(stopRequest);
         }
         catch (error) {
-            throw new CanonicalRunServiceError("unsupported", "worker stop authority is unavailable", { cause: error });
+            const details = error !== null && typeof error === "object"
+                ? error
+                : {};
+            const diagnostic = [
+                "control_timeout", "control_connection", "control_empty_response",
+                "identity_conflict", "corrupt_state", "invalid_configuration", "unsupported",
+            ].find((code) => code === details.diagnostic_code || code === details.code);
+            throw new CanonicalRunServiceError("unsupported", `worker stop authority is unavailable${diagnostic === undefined ? "" : ` (${diagnostic})`}`, { cause: error });
         }
         const matches = resolution?.kind === "stopped_by_request"
             ? resolution.authority !== undefined

package/dist/runtime/local-execution-authority.d.ts

@@ -185,7 +185,9 @@ export declare class LocalAttemptExecutionAuthority implements AttemptExecutionA
     private executeSupervised;
     private observeRecoveredExecution;
     private recordNormalizedCompletion;
+    private recoverControlCompletion;
     private sendControl;
+    private sendControlOnce;
     private issueReceipt;
     private issueAlreadyStoppedEvidence;
     withStoppedExecution<T>(request: AttemptExecutionAuthorityRequest, operation: (authority: StoppedExecutionAuthority) => Promise<T>): Promise<T>;

package/dist/runtime/local-execution-authority.js

@@ -31,6 +31,13 @@ export class LocalExecutionAuthorityError extends Error {
         this.code = code;
     }
 }
+class LocalExecutionControlTransportError extends LocalExecutionAuthorityError {
+    diagnostic_code;
+    constructor(diagnostic_code, message, options) {
+        super("unsupported", message, options);
+        this.diagnostic_code = diagnostic_code;
+    }
+}
 function durableLockOwnersEqual(left, right) {
     return left !== null && canonicalizeJson(left) === canonicalizeJson(right);
 }
@@ -1561,22 +1568,24 @@ export class LocalAttemptExecutionAuthority {
         if (initial.backend.kind !== "windows_job" || initial.raw_completion !== null)
             return initial;
         await this.ensureWindowsBackendTrusted(initial, path);
-        let lastError = null;
+        const deadline = Date.now() + this.controlTimeoutMs;
         for (let attempt = 0; attempt < 3; attempt += 1) {
             const before = this.readRecord(path);
             if (before.raw_completion !== null || before.phase === "unsupported")
                 return before;
             if (before.phase !== "running" || before.supervisor.pid === null || before.supervisor.ready_at === null) {
-                lastError = new Error("Windows execution supervisor is not durably ready");
-                break;
+                throw new LocalExecutionControlTransportError("control_connection", "Windows execution supervisor is not durably ready");
             }
             try {
-                const response = await this.sendControl(before, { action: "probe" });
+                const response = await this.sendControl(before, { action: "probe" }, deadline);
                 const after = this.readRecord(path);
                 if (after.raw_completion !== null || after.phase === "unsupported")
                     return after;
-                if (after.revision !== before.revision)
+                if (after.revision !== before.revision) {
+                    if (Date.now() >= deadline)
+                        break;
                     continue;
+                }
                 const identity = response.identity;
                 const expected = {
                     record_revision: after.revision,
@@ -1597,14 +1606,15 @@ export class LocalAttemptExecutionAuthority {
                 return after;
             }
             catch (error) {
-                lastError = error;
-                break;
+                if (error instanceof LocalExecutionControlTransportError)
+                    throw error;
+                const message = error instanceof Error
+                    ? error.message
+                    : "Windows execution supervisor identity could not be authenticated";
+                return this.failWindowsAuthentication(path, message, error);
             }
         }
-        const message = lastError instanceof Error
-            ? lastError.message
-            : "Windows execution supervisor identity could not be authenticated";
-        return this.failWindowsAuthentication(path, message, lastError);
+        throw new LocalExecutionControlTransportError("control_timeout", "Windows execution supervisor identity changed during control authentication");
     }
     readRecoveryRecord(request) {
         const identity = recoveryIdentity(request);
@@ -2619,7 +2629,64 @@ export class LocalAttemptExecutionAuthority {
             };
         });
     }
-    sendControl(record, request) {
+    recoverControlCompletion(record, request) {
+        const durable = this.readRecord(this.recordPath(record.identity));
+        if (canonicalizeJson(durable.identity) !== canonicalizeJson(record.identity)
+            || durable.identity_digest !== record.identity_digest
+            || durable.execution_instance_id !== record.execution_instance_id
+            || durable.authority_instance_id !== record.authority_instance_id
+            || durable.challenge !== record.challenge
+            || canonicalizeJson(durable.backend) !== canonicalizeJson(record.backend)
+            || canonicalizeJson(durable.supervisor) !== canonicalizeJson(record.supervisor)
+            || durable.revision < record.revision) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "durable control recovery identity does not match");
+        }
+        if (durable.phase === "unsupported") {
+            throw new LocalExecutionAuthorityError("unsupported", "execution supervisor evidence is unavailable");
+        }
+        if (request.action === "stop") {
+            if (request.stop_idempotency_key !== undefined) {
+                if (durable.stop_fact?.kind === "canonical_stop"
+                    && (durable.stop_fact.stop_idempotency_key !== request.stop_idempotency_key
+                        || durable.stop_fact.requested_at !== request.requested_at
+                        || canonicalizeJson(durable.stop_fact.requested_outcome) !== canonicalizeJson(request.requested_outcome))) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "durable canonical stop conflicts with the request");
+                }
+                // Natural completion can win the race; requestStop issues distinct already-stopped evidence.
+            }
+            else if (durable.stop_fact !== null
+                && (durable.stop_fact.kind !== "local_cancel" || durable.stop_fact.reason !== (request.reason ?? null))) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "durable local cancellation conflicts with the request");
+            }
+        }
+        if (durable.raw_completion === null)
+            return null;
+        if (durable.raw_completion.process_tree_drained !== true) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "trusted process-tree drain evidence is unavailable");
+        }
+        return { ok: true, raw_completion: durable.raw_completion };
+    }
+    async sendControl(record, request, deadline = Date.now() + this.controlTimeoutMs) {
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            try {
+                return await this.sendControlOnce(record, request, Math.max(1, Math.floor(remaining / (3 - attempt))));
+            }
+            catch (error) {
+                if (!(error instanceof LocalExecutionControlTransportError))
+                    throw error;
+                const completed = this.recoverControlCompletion(record, request);
+                if (completed !== null)
+                    return completed;
+                lastError = error;
+            }
+        }
+        throw lastError ?? new LocalExecutionControlTransportError("control_timeout", "execution supervisor control timed out");
+    }
+    sendControlOnce(record, request, timeoutMs) {
         const socketPath = record.supervisor.socket_path;
         if (record.backend.kind !== "windows_job") {
             let metadata;
@@ -2627,6 +2694,9 @@ export class LocalAttemptExecutionAuthority {
                 metadata = lstatSync(socketPath);
             }
             catch (error) {
+                if (isErrno(error, "ENOENT") || isErrno(error, "ENOTDIR")) {
+                    throw new LocalExecutionControlTransportError("control_connection", "execution supervisor control socket is unavailable", { cause: error });
+                }
                 throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control socket is unavailable", { cause: error });
             }
             if (!metadata.isSocket() || metadata.isSymbolicLink() || (metadata.mode & 0o077) !== 0) {
@@ -2639,42 +2709,32 @@ export class LocalAttemptExecutionAuthority {
             let response = "";
             const timer = setTimeout(() => {
                 socket.destroy();
-                rejectPromise(new LocalExecutionAuthorityError("unsupported", "execution supervisor control timed out"));
-            }, this.controlTimeoutMs);
+                rejectPromise(new LocalExecutionControlTransportError("control_timeout", "execution supervisor control timed out"));
+            }, timeoutMs);
             timer.unref?.();
             const fail = (error) => {
                 clearTimeout(timer);
-                rejectPromise(new LocalExecutionAuthorityError("unsupported", "execution supervisor control failed", { cause: error }));
+                const transient = ["ECONNRESET", "ECONNREFUSED", "ECONNABORTED", "EPIPE", "ENOENT", "ETIMEDOUT"]
+                    .some((code) => isErrno(error, code));
+                rejectPromise(transient
+                    ? new LocalExecutionControlTransportError("control_connection", "execution supervisor control failed", { cause: error })
+                    : new LocalExecutionAuthorityError("unsupported", "execution supervisor control failed", { cause: error }));
             };
             socket.once("error", fail);
             socket.setEncoding("utf8");
             socket.on("data", (chunk) => {
                 response += chunk;
                 if (Buffer.byteLength(response, "utf8") > MAX_CONTROL_RESPONSE_BYTES) {
-                    socket.destroy(new Error("execution control response too large"));
+                    clearTimeout(timer);
+                    rejectPromise(new LocalExecutionAuthorityError("unsupported", "execution control response too large"));
+                    socket.destroy();
                 }
             });
             socket.once("end", () => {
                 clearTimeout(timer);
                 try {
                     if (response.trim().length === 0) {
-                        try {
-                            const durable = this.readRecord(this.recordPath(record.identity));
-                            const matchesStop = durable.raw_completion !== null
-                                && (request.stop_idempotency_key === undefined
-                                    || (durable.stop_fact?.kind === "canonical_stop"
-                                        && durable.stop_fact.stop_idempotency_key === request.stop_idempotency_key
-                                        && canonicalizeJson(durable.stop_fact.requested_outcome)
-                                            === canonicalizeJson(request.requested_outcome)));
-                            if (matchesStop) {
-                                resolvePromise({ ok: true, raw_completion: durable.raw_completion });
-                                return;
-                            }
-                        }
-                        catch {
-                            // The control response remains authoritative unless durable completion proves the stop.
-                        }
-                        throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control response was empty");
+                        throw new LocalExecutionControlTransportError("control_empty_response", "execution supervisor control response was empty");
                     }
                     let responseText = response;
                     if (framedControl) {
@@ -2909,6 +2969,9 @@ export class LocalAttemptExecutionAuthority {
                 record = await this.authenticateWindowsSupervisor(record, path);
             }
         }
+        if (record.phase === "unsupported") {
+            throw new LocalExecutionAuthorityError("unsupported", "execution supervisor evidence is unavailable");
+        }
         if (record.raw_completion === null) {
             await this.sendControl(record, {
                 action: "stop",
@@ -2918,9 +2981,14 @@ export class LocalAttemptExecutionAuthority {
             });
             record = this.readRecord(path);
         }
+        if (record.raw_completion !== null && record.stop_fact?.kind !== "canonical_stop") {
+            const evidence = await this.issueAlreadyStoppedEvidence(path, request);
+            return { kind: "already_stopped", drain_evidence: evidence };
+        }
         if (record.raw_completion === null
             || record.stop_fact?.kind !== "canonical_stop"
             || record.stop_fact.stop_idempotency_key !== request.stop_idempotency_key
+            || record.stop_fact.requested_at !== request.requested_at
             || canonicalizeJson(record.stop_fact.requested_outcome) !== canonicalizeJson(request.requested_outcome)) {
             throw new LocalExecutionAuthorityError("unsupported", "canonical stop evidence was not durably published");
         }

package/dist/runtime/local-windows-execution-supervisor-script.js

@@ -508,17 +508,18 @@ async function main() {
   }
 
   async function registerStop(kind, detail) {
-    if (rawCompletion !== null || pendingCompletionFact !== null) {
-      throw controlConflict("execution already completed before the stop request");
-    }
     if (stopFact !== null) {
+      if (kind === "canonical_stop" && stopFact.kind !== "canonical_stop") return;
       const same = stopFact.kind === kind && (kind !== "canonical_stop" || (
         stopFact.stop_idempotency_key === detail.stop_idempotency_key
+        && stopFact.requested_at === detail.requested_at
         && canonical(stopFact.requested_outcome) === canonical(detail.requested_outcome)
       ));
       if (!same) throw controlConflict("execution already has a different terminal fact");
       return;
     }
+    // An authenticated stop can race natural completion; preserve the original completion.
+    if (rawCompletion !== null || pendingCompletionFact !== null) return;
     if (kind === "canonical_stop" && canonicalStopMode(detail.requested_outcome) === null) {
       throw controlConflict("canonical stop outcome is unsupported by Windows execution");
     }
@@ -533,6 +534,7 @@ async function main() {
     const next = await persist({ stop_fact: stopFact });
     if (next.phase !== "running" || canonical(next.stop_fact) !== canonical(stopFact)) {
       stopFact = null;
+      if (next.phase !== "unsupported" && next.raw_completion !== null && next.stop_fact === null) return;
       throw controlConflict("execution completion won before the stop request");
     }
     sendTerminateIfReleased();

package/dist/runtime/workflow-runner.d.ts

@@ -19,7 +19,7 @@ import type { WorkflowPlan } from "../schema/types.js";
 export interface WorkflowShellOptions {
     /** Agent name prefix (default "dna-") */
     agentPrefix?: string;
-    /** Max budget per agent in USD (default 10) */
+    /** Optional max budget per agent in USD; no budget unless explicitly set */
     maxBudgetPerAgent?: number;
     /** Output format for agent results (default "json") */
     outputFormat?: "json" | "text";

package/dist/runtime/workflow-runner.js

@@ -111,7 +111,9 @@ function generateHeader(plan, options) {
     lines.push("");
     // Variables
     lines.push("# Configuration");
-    lines.push(`MAX_BUDGET="${options.maxBudgetPerAgent}"`);
+    if (options.maxBudgetPerAgent !== undefined) {
+        lines.push(`MAX_BUDGET="${options.maxBudgetPerAgent}"`);
+    }
     lines.push(`LOG_DIR="${options.logDir}"`);
     lines.push('mkdir -p "$LOG_DIR"');
     lines.push("");
@@ -142,7 +144,9 @@ function generateRunAgentFn(options) {
     lines.push('  echo "$prompt" | claude -p \\');
     lines.push('    --agent "$agent" \\');
     lines.push(`    --output-format ${options.outputFormat} \\`);
-    lines.push('    --max-budget-usd "$MAX_BUDGET" \\');
+    if (options.maxBudgetPerAgent !== undefined) {
+        lines.push('    --max-budget-usd "$MAX_BUDGET" \\');
+    }
     lines.push(`    --permission-mode ${options.permissionMode} \\`);
     lines.push('    --session-id "$(uuidgen | tr \'[:upper:]\' \'[:lower:]\')" \\');
     lines.push('    --no-session-persistence \\');
@@ -469,9 +473,12 @@ function generateFailureChecks(plan) {
  * RunController through `dna run` for canonical execution.
  */
 export function compileWorkflowToShell(plan, options) {
+    if (options?.maxBudgetPerAgent !== undefined && (!Number.isFinite(options.maxBudgetPerAgent) || options.maxBudgetPerAgent <= 0)) {
+        throw new TypeError("maxBudgetPerAgent must be a positive finite number");
+    }
     const opts = {
         agentPrefix: options?.agentPrefix ?? "dna-",
-        maxBudgetPerAgent: options?.maxBudgetPerAgent ?? 10,
+        maxBudgetPerAgent: options?.maxBudgetPerAgent,
         outputFormat: options?.outputFormat ?? "json",
         permissionMode: options?.permissionMode ?? "default",
         logDir: options?.logDir ?? ".",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.9.5",
+  "version": "1.9.8",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",