intentdna 1.9.6 → 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.6",
+      "version": "1.9.8",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.9.6"
+  "version": "1.9.8"
 }

package/.claude-plugin/plugin.json

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

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/package.json

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