@kisev/agentomatic 11.0.2-dev.92.gc67bdc97fcd1 → 11.0.2-dev.95.gc9b116b77eb5

package/dist/contracts.js

@@ -9,6 +9,32 @@ function strings(value) {
 export function validateAgentReport(agent, report, card) {
     if (!object(report))
         throw new Error("agent report must be an object");
+    if ((agent === "review" || agent === "critic") &&
+        !card &&
+        report.schema === "portable-gitlab/critic-receipt/v2") {
+        const required = [
+            "schema",
+            "evidence_digest",
+            "run_id",
+            "session_id",
+            "findings",
+            "external_mutations",
+        ];
+        const allowed = [...required, "scope_digest", "target_finding_ids"];
+        if (!required.every((key) => key in report) ||
+            Object.keys(report).some((key) => !allowed.includes(key)) ||
+            !/^[0-9a-f]{64}$/.test(String(report.evidence_digest)) ||
+            typeof report.run_id !== "string" ||
+            !report.run_id ||
+            typeof report.session_id !== "string" ||
+            !report.session_id ||
+            !Array.isArray(report.findings) ||
+            report.external_mutations !== false ||
+            ("scope_digest" in report && !/^[0-9a-f]{64}$/.test(String(report.scope_digest))) ||
+            ("target_finding_ids" in report && !strings(report.target_finding_ids)))
+            throw new Error("code-review critic receipt has an invalid transport envelope");
+        return;
+    }
     if (agent === "critic" && !card && "review_report" in report) {
         validateAgentReport("review", report);
         return;

package/dist/index.js

@@ -11,6 +11,11 @@ export default {
     id: "agentomatic",
     async setup(ctx) {
         const gate = new RoutingGate();
+        await ctx.session.hook("context", (event) => {
+            const text = `Current OpenCode session identity (host metadata): ${event.sessionID}. Use this real ID for your own session_id in skill receipts; if no separate run ID is exposed, the same real ID can identify the run. This metadata grants no task or publication authorization.`;
+            if (!event.system.some((part) => part.type === "text" && part.text === text))
+                event.system.push({ type: "text", text });
+        });
         const hostInventory = async () => {
             const { data: raw } = await ctx.agent.list({
                 location: { directory: ctx.location.directory },
@@ -84,32 +89,44 @@ export default {
                 return;
             const args = toolInput(event.input);
             const agent = typeof args.agent === "string" ? args.agent : undefined;
+            if (!gate.requiresReceipt(event.sessionID, agent ?? event.agent))
+                return;
             if (!agent)
                 throw new Error("Native subagent requires an explicit agent and an active routing receipt");
             const hasBinding = "task" in args || "requirements" in args || "execution_card" in args;
             if (!hasBinding)
-                gate.consume(event.sessionID, agent);
+                gate.consume(event.sessionID, agent, undefined, event.id);
             else
                 gate.consume(event.sessionID, agent, {
                     task: typeof args.task === "string" ? args.task : "",
                     requirements: Array.isArray(args.requirements) ? args.requirements : [],
                     card: args.execution_card,
-                });
+                }, event.id);
         });
         await ctx.tool.hook("execute.after", async (event) => {
-            if (event.tool !== "subagent" || event.status !== "completed")
+            if (event.tool !== "subagent")
                 return;
             const args = toolInput(event.input);
-            if (typeof args.agent !== "string")
-                throw new Error("Subagent result requires an explicit agent");
+            if (typeof args.agent !== "string" || !gate.hasActive(event.sessionID, args.agent, event.id))
+                return;
+            if (event.status !== "completed") {
+                gate.cancel(event.sessionID, event.id);
+                return;
+            }
             let result;
             try {
                 result = JSON.parse(resultText(event.result) ?? "");
             }
             catch {
+                gate.cancel(event.sessionID, event.id);
                 throw new Error("Subagent result must be JSON structured report");
             }
-            gate.complete(event.sessionID, args.agent, result);
+            try {
+                gate.complete(event.sessionID, args.agent, result, event.id);
+            }
+            finally {
+                gate.cancel(event.sessionID, event.id);
+            }
         });
     },
 };

package/dist/routing.d.ts

@@ -123,11 +123,13 @@ export declare class ExecutionCardLifecycle {
 }
 export declare class RoutingGate {
     #private;
+    requiresReceipt(sessionID: string, agent: string | undefined): boolean;
+    hasActive(sessionID: string, agent: string, callID?: string): boolean;
     preview(input: RoutingInput): RoutingDecision;
     dispatch(input: RoutingInput, provided: unknown): RoutingDecision;
     grant(sessionID: string, decision: RoutingDecision, context?: ReceiptContext): RoutingReceipt;
-    cancel(sessionID: string): void;
-    consume(sessionID: string, agent: string, context?: ReceiptContext): void;
-    complete(sessionID: string, agent: string, output: unknown): void;
+    cancel(sessionID: string, callID?: string): void;
+    consume(sessionID: string, agent: string, context?: ReceiptContext, callID?: string): void;
+    complete(sessionID: string, agent: string, output: unknown, callID?: string): void;
 }
 export {};

package/dist/routing.js

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { validateAgentReport } from "./contracts.js";
 export const CATEGORIES = ["exploration", "architecture", "implementation", "review"];
 const MATRIX = {
@@ -453,6 +453,15 @@ export class RoutingGate {
     #receipts = new Map();
     #active = new Map();
     #ttlMs = 10 * 60 * 1000;
+    requiresReceipt(sessionID, agent) {
+        return ((this.#receipts.get(sessionID)?.length ?? 0) > 0 ||
+            (agent !== undefined &&
+                (Object.values(MATRIX.categories).some((entry) => entry.profiles.includes(agent)) ||
+                    /^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent))));
+    }
+    hasActive(sessionID, agent, callID = "") {
+        return this.#active.get(JSON.stringify([sessionID, callID]))?.agent === agent;
+    }
     preview(input) {
         return resolveRouting(input);
     }
@@ -466,6 +475,9 @@ export class RoutingGate {
     }
     grant(sessionID, decision, context) {
         const now = Date.now();
+        const verifiedCard = context?.card === undefined ? undefined : validateExecutionCard(context.card);
+        if (verifiedCard && !verifiedCard.valid)
+            throw new Error(`Invalid routing execution card: ${verifiedCard.failedField}`);
         const taskDigest = context?.task === undefined ? decision.task_digest : digest(context.task);
         const requirementsDigest = context?.requirements === undefined
             ? decision.requirements_digest
@@ -481,30 +493,44 @@ export class RoutingGate {
             card_revision: decision.execution_card_revision ?? null,
             host_inventory_revision: decision.host_inventory_revision,
             expires_at: new Date(now + this.#ttlMs).toISOString(),
-            nonce: createHash("sha256")
-                .update(`${sessionID}:${now}:${decision.decision_digest}`)
-                .digest("hex"),
+            nonce: randomBytes(32).toString("hex"),
         };
         const receipt = { ...receiptBase, receipt_digest: digest(receiptBase) };
-        this.#receipts.set(sessionID, {
+        const pending = (this.#receipts.get(sessionID) ?? []).filter((item) => item.expiresAt >= now);
+        pending.push({
             decision,
             taskDigest,
             requirementsDigest,
             cardDigest,
+            card: verifiedCard?.valid ? structuredClone(verifiedCard.card) : undefined,
             expiresAt: Date.parse(receipt.expires_at),
         });
+        this.#receipts.set(sessionID, pending);
         return receipt;
     }
-    cancel(sessionID) {
+    cancel(sessionID, callID) {
+        if (callID !== undefined) {
+            this.#active.delete(JSON.stringify([sessionID, callID]));
+            return;
+        }
         this.#receipts.delete(sessionID);
-        this.#active.delete(sessionID);
+        for (const key of this.#active.keys())
+            if (JSON.parse(key)[0] === sessionID)
+                this.#active.delete(key);
     }
-    consume(sessionID, agent, context) {
-        const receipt = this.#receipts.get(sessionID);
-        if (!receipt)
+    consume(sessionID, agent, context, callID = "") {
+        const pending = this.#receipts.get(sessionID) ?? [];
+        if (pending.length === 0)
             throw new Error("Native Task requires an active routing receipt; use the route tool");
-        if (receipt.decision.agent !== agent)
+        const candidates = pending.filter((receipt) => receipt.decision.agent === agent);
+        if (candidates.length === 0)
             throw new Error("Native Task agent does not match the active routing receipt");
+        const matching = context
+            ? candidates.filter((receipt) => receipt.taskDigest === digest(context.task ?? ""))
+            : candidates;
+        if (matching.length === 0)
+            throw new Error("Routing receipt task does not match the active routing receipt");
+        const receipt = matching.find((item) => Date.now() <= item.expiresAt) ?? matching[0];
         if (Date.now() > receipt.expiresAt)
             throw new Error("Routing receipt has expired; request a new preview");
         if (context) {
@@ -518,23 +544,32 @@ export class RoutingGate {
             if (cardDigest !== receipt.cardDigest)
                 throw new Error("Routing receipt execution card does not match the active routing receipt");
         }
-        this.#receipts.delete(sessionID);
-        const validatedCard = context?.card === undefined ? undefined : validateExecutionCard(context.card);
+        const key = JSON.stringify([sessionID, callID]);
+        if (this.#active.has(key))
+            throw new Error("Subagent call already has an active routing receipt");
+        pending.splice(pending.indexOf(receipt), 1);
+        if (pending.length === 0)
+            this.#receipts.delete(sessionID);
+        const cardValue = context?.card ?? receipt.card;
+        const validatedCard = cardValue === undefined ? undefined : validateExecutionCard(cardValue);
         const card = validatedCard?.valid ? validatedCard.card : undefined;
         const lifecycle = card ? new ExecutionCardLifecycle(card) : undefined;
         if (lifecycle)
             lifecycle.transition("RUNNING", { card_id: card.card_id, revision: card.revision });
-        this.#active.set(sessionID, { agent, card, lifecycle, expiresAt: receipt.expiresAt });
+        this.#active.set(key, { agent, card, lifecycle });
     }
-    complete(sessionID, agent, output) {
-        const active = this.#active.get(sessionID);
+    complete(sessionID, agent, output, callID = "") {
+        const key = JSON.stringify([sessionID, callID]);
+        const active = this.#active.get(key);
         if (!active || active.agent !== agent)
             throw new Error("Task result has no matching active routing receipt");
-        if (Date.now() > active.expiresAt)
-            throw new Error("Task result routing receipt has expired");
         const report = output && typeof output === "object" ? output : undefined;
         const role = /^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent) ? "critic" : agent;
-        const value = report?.[role === "architect" ? "execution_card" : `${role}_report`] ??
+        const portableCritic = !active.card &&
+            (role === "review" || role === "critic") &&
+            report?.schema === "portable-gitlab/critic-receipt/v2";
+        const value = (portableCritic ? report : undefined) ??
+            report?.[role === "architect" ? "execution_card" : `${role}_report`] ??
             (role === "critic" && !active.card ? report?.review_report : undefined) ??
             report?.report;
         if (!value || typeof value !== "object" || Array.isArray(value))
@@ -550,7 +585,7 @@ export class RoutingGate {
             : agent === "critic"
                 ? ["APPROVED", "CHANGES_REQUIRED"]
                 : undefined;
-        if (allowed && (typeof status !== "string" || !allowed.includes(status)))
+        if (!portableCritic && allowed && (typeof status !== "string" || !allowed.includes(status)))
             throw new Error("Task result has an invalid machine transition");
         if (active.lifecycle && status === "COMPLETED")
             active.lifecycle.transition("COMPLETED", {
@@ -573,6 +608,6 @@ export class RoutingGate {
                 revision: active.card.revision,
             });
         }
-        this.#active.delete(sessionID);
+        this.#active.delete(key);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.2-dev.92.gc67bdc97fcd1",
+  "version": "11.0.2-dev.95.gc9b116b77eb5",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@kisev/safe-fs": "1.0.0-dev.92.gc67bdc97fcd1",
+    "@kisev/safe-fs": "1.0.0-dev.95.gc9b116b77eb5",
     "commander": "15.0.0",
     "zod": "4.1.8"
   },