@akagilnc/pi-workflow-roles 0.1.2020 → 0.1.2033

package/dist/compliance-transport.js

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
 import { executeAuditorChild, } from "./evidence-child-executor.js";
 import { createAuditorDossierTool } from "./auditor-dossier-tool.js";
+import { withPackageOwnedToolIdleSuspended } from "./package-owned-tool-idle.js";
 /** Zero-projection kickoff — soul already carries dossier-fetch duty; no hand-delivered materials. */
 export const AUDITOR_DOSSIER_PROMPT = "Audit the current run dossier.";
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
@@ -61,24 +62,28 @@ export function readComplianceCandidate(arguments_, usage) {
     return { status: "audit-incomplete", observation: { kind: "object-status-unreadable", status: status === undefined ? "missing" : "unknown" }, candidate: arguments_, ...(usage === undefined ? {} : { usage }) };
 }
 export async function runComplianceAudit(options) {
-    const prompt = options.serializedInput ?? AUDITOR_DOSSIER_PROMPT;
-    const receipt = await executeAuditorChild({
-        tool: options.tool,
-        dossierTool: createAuditorDossierTool(options.runDirectory),
-        systemPrompt: options.systemPrompt,
-        prompt,
-        roleLabel: options.roleLabel,
-        context: options.context,
-        retainResponse: (response) => retainComplianceResponse(options.context, response),
-        ...(options.runCompletion === undefined ? {} : { runCompletion: options.runCompletion }),
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    // #339: only the real compliance-audit await leaves the outer package-owned
+    // idle owner. Pre/post-audit work stays under the single outer backstop.
+    return withPackageOwnedToolIdleSuspended(async () => {
+        const prompt = options.serializedInput ?? AUDITOR_DOSSIER_PROMPT;
+        const receipt = await executeAuditorChild({
+            tool: options.tool,
+            dossierTool: createAuditorDossierTool(options.runDirectory),
+            systemPrompt: options.systemPrompt,
+            prompt,
+            roleLabel: options.roleLabel,
+            context: options.context,
+            retainResponse: (response) => retainComplianceResponse(options.context, response),
+            ...(options.runCompletion === undefined ? {} : { runCompletion: options.runCompletion }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
+        if (receipt.noReceiptLifecycle !== undefined) {
+            return {
+                status: "no-receipt",
+                ...receipt.noReceiptLifecycle,
+                ...(receipt.response.usage === undefined ? {} : { usage: receipt.response.usage }),
+            };
+        }
+        return readComplianceCandidate(receipt.decision, receipt.response.usage);
     });
-    if (receipt.noReceiptLifecycle !== undefined) {
-        return {
-            status: "no-receipt",
-            ...receipt.noReceiptLifecycle,
-            ...(receipt.response.usage === undefined ? {} : { usage: receipt.response.usage }),
-        };
-    }
-    return readComplianceCandidate(receipt.decision, receipt.response.usage);
 }

package/dist/evidence-child-executor.js

@@ -296,6 +296,10 @@ export async function createInheritedRuntime(options) {
             },
         };
     runtime.registerNativeProvider(provider);
+    // registerNativeProvider fires a background refresh; await it so child
+    // AgentSession.prompt sees configured auth without racing void refresh
+    // (mock timers / slow CI otherwise stall before the compliance stream).
+    await runtime.refresh({ allowNetwork: false });
     return state;
 }
 function numericHttpStatus(value) {

package/dist/package-owned-tool-idle.js

@@ -1,8 +1,26 @@
+/**
+ * #102 package-owned tool idle backstop.
+ *
+ * Fixed 183000ms silence clock on package-owned tool execute only.
+ * Real producing onUpdate resets; final resolve/reject clears; timeout throws so
+ * Pi settles the current call as an LLM-visible isError tool result. No retry,
+ * role failure, process termination, signal abort, config, or Pi built-in coverage.
+ *
+ * #339: do not name-exempt whole terminating tools. Outer idle stays armed for
+ * pre/post-audit work. Only the real compliance-audit await suspends this single
+ * layer (ADR 0059 owns that interval); resume re-arms the same outer backstop.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
 import { DEFAULT_STREAM_IDLE_TIMEOUT_MS, createStreamIdleGuard, } from "./stream-idle-guard.js";
 import { isProducingToolUpdate } from "./tool-execution-observation.js";
 export const PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_MS = DEFAULT_STREAM_IDLE_TIMEOUT_MS;
 export const PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_CODE = "AK_PACKAGE_OWNED_TOOL_IDLE_TIMEOUT";
 const WRAPPED = Symbol.for("ak.packageOwnedToolIdleWrapped");
+/**
+ * Active outer package-owned execute idle, if any. Nested tool executes install
+ * their own store; compliance audit only suspends the store visible at await time.
+ */
+const packageOwnedToolIdleScope = new AsyncLocalStorage();
 export class PackageOwnedToolIdleTimeoutError extends Error {
     code = PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_CODE;
     idleTimeoutMs = PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_MS;
@@ -33,6 +51,23 @@ function isPackageOwnedToolActivityUpdate(partialResult) {
         return Reflect.ownKeys(details).length > 0;
     return true;
 }
+/**
+ * #339: suspend the active package-owned execute idle for one real compliance
+ * audit await. Single-layer only — production has one runComplianceAudit seam.
+ * No-op outside a wrapped package-owned execute. No second timeout or retry.
+ */
+export async function withPackageOwnedToolIdleSuspended(run) {
+    const scope = packageOwnedToolIdleScope.getStore();
+    if (scope === undefined)
+        return run();
+    scope.suspend();
+    try {
+        return await run();
+    }
+    finally {
+        scope.resume();
+    }
+}
 /**
  * Single shared execute wrapper for package-owned tool definitions.
  * Idempotent: wrapping twice returns the same protected definition.
@@ -48,7 +83,8 @@ export function wrapPackageOwnedToolDefinition(tool) {
         const onUpdate = args[3];
         return new Promise((resolve, reject) => {
             let settled = false;
-            const idle = createStreamIdleGuard({
+            let suspended = false;
+            let idle = createStreamIdleGuard({
                 idleTimeoutMs: PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_MS,
             });
             const settle = (deliver) => {
@@ -63,6 +99,26 @@ export function wrapPackageOwnedToolDefinition(tool) {
                 settle(() => reject(new PackageOwnedToolIdleTimeoutError()));
             };
             idle.signal.addEventListener("abort", onIdle, { once: true });
+            const suspension = {
+                suspend() {
+                    if (settled || suspended)
+                        return;
+                    suspended = true;
+                    // ADR 0059 owns the audit interval — drop this layer until audit returns.
+                    idle.signal.removeEventListener("abort", onIdle);
+                    idle.dispose();
+                },
+                resume() {
+                    if (settled || !suspended)
+                        return;
+                    suspended = false;
+                    // Fresh single-layer silence window for post-audit work (e.g. cleanup).
+                    idle = createStreamIdleGuard({
+                        idleTimeoutMs: PACKAGE_OWNED_TOOL_IDLE_TIMEOUT_MS,
+                    });
+                    idle.signal.addEventListener("abort", onIdle, { once: true });
+                },
+            };
             const guardedOnUpdate = onUpdate === undefined
                 ? undefined
                 : (partialResult) => {
@@ -76,9 +132,15 @@ export function wrapPackageOwnedToolDefinition(tool) {
             // Preserve the original signal at args[2]; timeout must not abort it.
             callArgs[2] = signal;
             callArgs[3] = guardedOnUpdate;
-            void Promise.resolve()
-                .then(() => originalExecute(...callArgs))
-                .then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
+            void packageOwnedToolIdleScope.run(suspension, async () => {
+                try {
+                    const result = await originalExecute(...callArgs);
+                    settle(() => resolve(result));
+                }
+                catch (error) {
+                    settle(() => reject(error));
+                }
+            });
         });
     };
     wrappedExecute[WRAPPED] = true;