@absolutejs/agent-control 0.1.0 → 0.3.0

package/README.md

@@ -8,3 +8,34 @@ leased idempotency records so operator retries cannot change the requested input
 Scopes are `agents:read`, `agents:revoke`, and `agents:restore`. Mutations require
 an `operationId` and `reason`; PostgreSQL operations can be safely reclaimed
 after a crashed operator process's lease expires.
+
+`createAgentControlConsoleHandler()` adds a dependency-free authenticated
+operator console to the same package. Its snapshot shows agent status, pending
+approvals, durable runs and budgets, delegation scope and expiry, memory
+metadata, and scope-specific reputation without exposing memory contents or raw
+action inputs. Approval decisions require `agents:approve`, same-origin
+requests, an explicit mutation-intent header, a reason, and an idempotency key.
+
+```ts
+const console = createAgentControlConsoleHandler({
+  authorize: verifyOperator,
+  operations: createPostgresOperationStore({ client }),
+  data: {
+    snapshot: (operator) => loadSafeOperatorSnapshot(operator),
+    decideApproval: (decision) => applyAgencyDecision(decision),
+  },
+});
+```
+
+The HTML console uses a per-response Content Security Policy nonce, constructs
+all remote data with DOM `textContent`, cannot be framed, stores no cache, and
+has no third-party assets. The data adapter keeps it provider-neutral and lets
+applications compose `@absolutejs/agency`, `agent-runtime`, `agent-memory`, and
+`agent-reputation` without creating hard dependencies.
+
+`createAgentPlaygroundHandler()` adds a provider-neutral plan-then-execute UI
+and API. Planning is a separate, explicitly effect-free adapter operation. The
+server stores the full input and only returns its digest, expires plans quickly,
+binds them to the operator, refuses denied or approval-pending plans, and uses
+the same leased idempotency store for execution. The browser cannot mutate a
+plan between review and execution.

package/dist/console.d.ts

@@ -0,0 +1,63 @@
+import type { OperationStore, Operator } from "./index";
+export type AgentControlSnapshot = {
+    agents: Array<{
+        description?: string;
+        id: string;
+        status: string;
+    }>;
+    approvals: Array<{
+        action: string;
+        agentId: string;
+        id: string;
+        requestedAt: string;
+        risk?: string;
+        summary: string;
+    }>;
+    delegations: Array<{
+        expiresAt?: string;
+        from: string;
+        id: string;
+        scopes: string[];
+        to: string;
+    }>;
+    memories: Array<{
+        agentId: string;
+        id: string;
+        scope: string;
+        updatedAt: string;
+    }>;
+    reputations: Array<{
+        confidence: number;
+        scope: string;
+        score: number;
+        subject: string;
+    }>;
+    runs: Array<{
+        agentId: string;
+        budget?: {
+            limit: number;
+            spent: number;
+            unit: string;
+        };
+        id: string;
+        startedAt: string;
+        status: string;
+    }>;
+};
+export type AgentControlConsoleData = {
+    decideApproval: (input: {
+        approvalId: string;
+        decision: "approve" | "deny";
+        operatorId: string;
+        reason: string;
+    }) => Promise<unknown>;
+    snapshot: (operator: Operator) => Promise<AgentControlSnapshot>;
+};
+export declare const sanitizeAgentControlSnapshot: (source: AgentControlSnapshot) => AgentControlSnapshot;
+export declare const createAgentControlConsoleHandler: (options: {
+    authorize: (request: Request) => Promise<Operator | undefined> | Operator | undefined;
+    basePath?: string;
+    data: AgentControlConsoleData;
+    now?: () => number;
+    operations: OperationStore;
+}) => (request: Request) => Promise<Response | null>;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import type { AgentControlPlane } from "@absolutejs/agency";
+export * from "./console";
+export * from "./playground";
 export type Operator = {
     id: string;
     scopes: readonly string[];

package/dist/index.js

@@ -1,29 +1,319 @@
 // @bun
+// src/console.ts
+var hash = async (value) => [
+  ...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(value))))
+].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var bounded = (value, field) => {
+  if (typeof value !== "string" || value.length > 2000)
+    throw new Error(`Invalid agent control snapshot ${field}`);
+  return value;
+};
+var boundedNumber = (value, field) => {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`Invalid agent control snapshot ${field}`);
+  return value;
+};
+var rows = (value, map) => {
+  if (!Array.isArray(value) || value.length > 1000)
+    throw new Error("Agent control snapshot collection is too large");
+  return value.map(map);
+};
+var sanitizeAgentControlSnapshot = (source) => ({
+  agents: rows(source.agents, (item) => ({
+    ...item.description === undefined ? {} : { description: bounded(item.description, "agent.description") },
+    id: bounded(item.id, "agent.id"),
+    status: bounded(item.status, "agent.status")
+  })),
+  approvals: rows(source.approvals, (item) => ({
+    action: bounded(item.action, "approval.action"),
+    agentId: bounded(item.agentId, "approval.agentId"),
+    id: bounded(item.id, "approval.id"),
+    requestedAt: bounded(item.requestedAt, "approval.requestedAt"),
+    ...item.risk === undefined ? {} : { risk: bounded(item.risk, "approval.risk") },
+    summary: bounded(item.summary, "approval.summary")
+  })),
+  delegations: rows(source.delegations, (item) => ({
+    ...item.expiresAt === undefined ? {} : { expiresAt: bounded(item.expiresAt, "delegation.expiresAt") },
+    from: bounded(item.from, "delegation.from"),
+    id: bounded(item.id, "delegation.id"),
+    scopes: rows(item.scopes, (scope) => bounded(scope, "delegation.scope")),
+    to: bounded(item.to, "delegation.to")
+  })),
+  memories: rows(source.memories, (item) => ({
+    agentId: bounded(item.agentId, "memory.agentId"),
+    id: bounded(item.id, "memory.id"),
+    scope: bounded(item.scope, "memory.scope"),
+    updatedAt: bounded(item.updatedAt, "memory.updatedAt")
+  })),
+  reputations: rows(source.reputations, (item) => ({
+    confidence: boundedNumber(item.confidence, "reputation.confidence"),
+    scope: bounded(item.scope, "reputation.scope"),
+    score: boundedNumber(item.score, "reputation.score"),
+    subject: bounded(item.subject, "reputation.subject")
+  })),
+  runs: rows(source.runs, (item) => ({
+    agentId: bounded(item.agentId, "run.agentId"),
+    ...item.budget === undefined ? {} : {
+      budget: {
+        limit: boundedNumber(item.budget.limit, "run.budget.limit"),
+        spent: boundedNumber(item.budget.spent, "run.budget.spent"),
+        unit: bounded(item.budget.unit, "run.budget.unit")
+      }
+    },
+    id: bounded(item.id, "run.id"),
+    startedAt: bounded(item.startedAt, "run.startedAt"),
+    status: bounded(item.status, "run.status")
+  }))
+});
+var page = (nonce) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>AbsoluteJS Agent Control</title><style nonce="${nonce}">
+:root{color-scheme:dark;font:15px/1.45 system-ui,sans-serif;background:#09090b;color:#fafafa}body{margin:0}header{padding:1.2rem 1.5rem;border-bottom:1px solid #27272a;display:flex;align-items:center;justify-content:space-between}main{padding:1.5rem;display:grid;gap:1.25rem}.status{color:#a1a1aa}.error{color:#fca5a5}section{background:#18181b;border:1px solid #27272a;border-radius:.75rem;overflow:auto}h2{font-size:1rem;margin:0;padding:1rem}table{border-collapse:collapse;width:100%;min-width:42rem}th,td{text-align:left;padding:.7rem 1rem;border-top:1px solid #27272a;vertical-align:top}th{color:#a1a1aa;font-size:.8rem;text-transform:uppercase}button{background:#27272a;color:#fff;border:1px solid #3f3f46;border-radius:.4rem;padding:.4rem .65rem;margin:.15rem;cursor:pointer}button.approve{background:#14532d}button.deny{background:#7f1d1d}code{font-size:.8rem} @media(max-width:700px){main{padding:.75rem}header{padding:1rem}}
+</style></head><body><header><strong>AbsoluteJS Agent Control</strong><span id="status" class="status">Loading\u2026</span></header><main id="content"></main>
+<script nonce="${nonce}">(()=>{const base=location.pathname.replace(//$/,"");const root=document.querySelector("#content"),status=document.querySelector("#status");const columns={agents:["id","status","description"],approvals:["id","agentId","action","summary","risk","requestedAt"],runs:["id","agentId","status","startedAt","budget"],delegations:["id","from","to","scopes","expiresAt"],memories:["id","agentId","scope","updatedAt"],reputations:["subject","scope","score","confidence"]};const text=v=>v==null?"":typeof v==="object"?JSON.stringify(v):String(v);function render(data){root.replaceChildren();for(const [name,fields] of Object.entries(columns)){const section=document.createElement("section"),heading=document.createElement("h2"),table=document.createElement("table"),head=document.createElement("tr");heading.textContent=name[0].toUpperCase()+name.slice(1);for(const field of fields){const th=document.createElement("th");th.textContent=field;head.append(th)}if(name==="approvals"){const th=document.createElement("th");th.textContent="Decision";head.append(th)}table.append(head);for(const item of data[name]??[]){const row=document.createElement("tr");for(const field of fields){const td=document.createElement("td");td.textContent=text(item[field]);row.append(td)}if(name==="approvals"){const td=document.createElement("td");for(const decision of ["approve","deny"]){const button=document.createElement("button");button.className=decision;button.textContent=decision;button.addEventListener("click",()=>decide(item.id,decision));td.append(button)}row.append(td)}table.append(row)}section.append(heading,table);root.append(section)}}async function load(){try{const response=await fetch(base+"/api/snapshot",{headers:{accept:"application/json"}});if(!response.ok)throw new Error("Snapshot failed: "+response.status);render(await response.json());status.textContent="Live";status.className="status"}catch(error){status.textContent=error.message;status.className="error"}}async function decide(id,decision){const reason=prompt("Reason for "+decision+":");if(!reason)return;status.textContent="Applying\u2026";const response=await fetch(base+"/api/approvals/"+encodeURIComponent(id)+"/"+decision,{method:"POST",headers:{"content-type":"application/json","idempotency-key":crypto.randomUUID(),"x-agent-control-intent":"mutate"},body:JSON.stringify({reason})});if(!response.ok){status.textContent="Decision failed: "+response.status;status.className="error";return}await load()}load()})();</script></body></html>`;
+var createAgentControlConsoleHandler = (options) => {
+  const basePath = (options.basePath ?? "/agent-control").replace(/\/$/u, "");
+  const now = options.now ?? Date.now;
+  return async (request) => {
+    const url = new URL(request.url);
+    if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`))
+      return null;
+    const operator = await options.authorize(request);
+    if (!operator)
+      return new Response("Unauthorized", { status: 401 });
+    const required = request.method === "GET" ? "agents:read" : "agents:approve";
+    if (!operator.scopes.includes(required))
+      return new Response("Forbidden", { status: 403 });
+    if (request.method === "GET" && (url.pathname === basePath || url.pathname === `${basePath}/`)) {
+      const nonce = crypto.randomUUID().replaceAll("-", "");
+      return new Response(page(nonce), {
+        headers: {
+          "cache-control": "no-store",
+          "content-security-policy": `default-src 'none'; connect-src 'self'; img-src 'self'; style-src 'nonce-${nonce}'; script-src 'nonce-${nonce}'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'`,
+          "content-type": "text/html; charset=utf-8",
+          "referrer-policy": "no-referrer",
+          "x-content-type-options": "nosniff"
+        }
+      });
+    }
+    if (request.method === "GET" && url.pathname === `${basePath}/api/snapshot`) {
+      return Response.json(sanitizeAgentControlSnapshot(await options.data.snapshot(operator)), {
+        headers: { "cache-control": "no-store" }
+      });
+    }
+    const match = new RegExp(`^${basePath.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}/api/approvals/([^/]+)/(approve|deny)$`, "u").exec(url.pathname);
+    if (!match?.[1] || !match[2] || request.method !== "POST")
+      return new Response(null, { status: 405 });
+    if (request.headers.get("origin") !== url.origin || request.headers.get("x-agent-control-intent") !== "mutate")
+      return new Response("Cross-site mutation denied", { status: 403 });
+    const operationId = request.headers.get("idempotency-key");
+    const body = await request.json().catch(() => {
+      return;
+    });
+    if (!operationId || !body?.reason || body.reason.length > 1000)
+      return Response.json({ error: "Idempotency-Key and a bounded reason are required" }, { status: 400 });
+    const input = {
+      approvalId: decodeURIComponent(match[1]),
+      decision: match[2],
+      operatorId: operator.id,
+      reason: body.reason
+    };
+    const digest = await hash(input);
+    let claim;
+    try {
+      claim = await options.operations.claim(operationId, digest, now(), 30000);
+    } catch (error) {
+      return Response.json({ error: error instanceof Error ? error.message : "conflict" }, { status: 409 });
+    }
+    if (claim.response !== undefined)
+      return Response.json(claim.response);
+    if (!claim.acquired)
+      return Response.json({ error: "operation in progress" }, { status: 409, headers: { "retry-after": "5" } });
+    const response = await options.data.decideApproval(input);
+    if (!await options.operations.complete(operationId, digest, response))
+      throw new Error("Approval operation completion lost");
+    return Response.json(response);
+  };
+};
+// src/playground.ts
+var createMemoryAgentPlaygroundPlanStore = (now = Date.now) => {
+  const plans = new Map;
+  return {
+    get: async (id, operatorId) => {
+      const plan = plans.get(id);
+      if (!plan || plan.operatorId !== operatorId || plan.expiresAt <= now())
+        return;
+      return structuredClone(plan);
+    },
+    save: async (plan) => {
+      for (const [id, existing] of plans)
+        if (existing.expiresAt <= now())
+          plans.delete(id);
+      if (plans.has(plan.planId))
+        throw new Error("Playground plan already exists");
+      plans.set(plan.planId, structuredClone(plan));
+    }
+  };
+};
+var digest = async (value) => [
+  ...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(value))))
+].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var text = (value, field, maximum = 2000) => {
+  if (typeof value !== "string" || value === "" || value.length > maximum)
+    throw new Error(`Invalid playground ${field}`);
+  return value;
+};
+var list = (values, map) => {
+  if (!Array.isArray(values) || values.length > 1000)
+    throw new Error("Playground collection is too large");
+  return values.map(map);
+};
+var safeCatalog = (items) => list(items, (item) => ({
+  ...item.description === undefined ? {} : { description: text(item.description, "description") },
+  id: text(item.id, "agent id", 256),
+  name: text(item.name, "agent name", 256),
+  operations: list(item.operations, (value) => text(value, "operation", 256)),
+  protocols: list(item.protocols, (value) => text(value, "protocol", 128))
+}));
+var page2 = (nonce) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>AbsoluteJS Agent Playground</title><style nonce="${nonce}">:root{color-scheme:dark;font:15px/1.5 system-ui;background:#09090b;color:#fafafa}body{max-width:70rem;margin:auto;padding:2rem}label{display:block;margin:1rem 0}.grid{display:grid;grid-template-columns:1fr 1fr;gap:1rem}select,textarea,button{font:inherit;background:#18181b;color:#fff;border:1px solid #3f3f46;border-radius:.5rem;padding:.7rem;width:100%;box-sizing:border-box}textarea{min-height:14rem;font-family:ui-monospace,monospace}button{cursor:pointer;margin:.4rem 0}.execute{background:#14532d}pre{white-space:pre-wrap;background:#18181b;padding:1rem;border-radius:.5rem}.error{color:#fca5a5}@media(max-width:700px){.grid{grid-template-columns:1fr}}</style></head><body><h1>Agent Playground</h1><p>Plan first. Review exact effects. Execute only a bound server-side plan.</p><div class="grid"><div><label>Agent<select id="agent"></select></label><label>Operation<select id="operation"></select></label><label>JSON input<textarea id="input">{}</textarea></label><button id="plan">Create effect-free plan</button><button id="execute" class="execute" disabled>Execute reviewed plan</button></div><div><h2>Bound plan</h2><pre id="output">No plan yet.</pre></div></div><script nonce="${nonce}">(()=>{const base=location.pathname.replace(//$/,""),agent=document.querySelector("#agent"),operation=document.querySelector("#operation"),input=document.querySelector("#input"),output=document.querySelector("#output"),execute=document.querySelector("#execute");let plan;const headers={"content-type":"application/json","x-agent-control-intent":"mutate"};async function catalog(){const data=await fetch(base+"/api/catalog").then(r=>r.json());for(const item of data){const option=document.createElement("option");option.value=item.id;option.textContent=item.name;option.dataset.operations=JSON.stringify(item.operations);agent.append(option)}changed()}function changed(){operation.replaceChildren();for(const value of JSON.parse(agent.selectedOptions[0]?.dataset.operations??"[]")){const option=document.createElement("option");option.value=value;option.textContent=value;operation.append(option)}}agent.addEventListener("change",changed);document.querySelector("#plan").addEventListener("click",async()=>{try{const response=await fetch(base+"/api/plans",{method:"POST",headers,body:JSON.stringify({agentId:agent.value,operation:operation.value,input:JSON.parse(input.value)})});const data=await response.json();if(!response.ok)throw new Error(data.error??("HTTP "+response.status));plan=data;output.textContent=JSON.stringify(data,null,2);execute.disabled=data.status!=="ready"}catch(error){output.textContent=error.message;output.className="error"}});execute.addEventListener("click",async()=>{if(!plan)return;execute.disabled=true;const response=await fetch(base+"/api/plans/"+encodeURIComponent(plan.planId)+"/execute",{method:"POST",headers:{...headers,"idempotency-key":crypto.randomUUID()},body:"{}"});output.textContent=JSON.stringify(await response.json(),null,2)});catalog()})();</script></body></html>`;
+var createAgentPlaygroundHandler = (options) => {
+  const base = (options.basePath ?? "/agent-playground").replace(/\/$/u, "");
+  const now = options.now ?? Date.now;
+  const mutationAllowed = (request, url) => request.headers.get("origin") === url.origin && request.headers.get("x-agent-control-intent") === "mutate";
+  return async (request) => {
+    const url = new URL(request.url);
+    if (url.pathname !== base && !url.pathname.startsWith(`${base}/`))
+      return null;
+    const operator = await options.authorize(request);
+    if (!operator)
+      return new Response("Unauthorized", { status: 401 });
+    const scope = request.method === "GET" ? "agents:read" : url.pathname.endsWith("/execute") ? "agents:execute" : "agents:simulate";
+    if (!operator.scopes.includes(scope))
+      return new Response("Forbidden", { status: 403 });
+    if (request.method === "GET" && (url.pathname === base || url.pathname === `${base}/`)) {
+      const nonce = crypto.randomUUID().replaceAll("-", "");
+      return new Response(page2(nonce), {
+        headers: {
+          "cache-control": "no-store",
+          "content-security-policy": `default-src 'none'; connect-src 'self'; style-src 'nonce-${nonce}'; script-src 'nonce-${nonce}'; base-uri 'none'; frame-ancestors 'none'`,
+          "content-type": "text/html; charset=utf-8",
+          "x-content-type-options": "nosniff"
+        }
+      });
+    }
+    if (request.method === "GET" && url.pathname === `${base}/api/catalog`)
+      return Response.json(safeCatalog(await options.adapter.catalog(operator)), {
+        headers: { "cache-control": "no-store" }
+      });
+    if (request.method === "POST" && url.pathname === `${base}/api/plans`) {
+      if (!mutationAllowed(request, url))
+        return new Response("Cross-site mutation denied", { status: 403 });
+      const raw = await request.text();
+      if (new TextEncoder().encode(raw).byteLength > 256000)
+        return Response.json({ error: "Input is too large" }, { status: 413 });
+      let body;
+      try {
+        body = JSON.parse(raw);
+      } catch {
+        return Response.json({ error: "Input must be valid JSON" }, { status: 400 });
+      }
+      const agentId = text(body.agentId, "agent id", 256);
+      const operation = text(body.operation, "operation", 256);
+      const inputDigest = await digest(body.input ?? null);
+      const proposed = await options.adapter.plan({ agentId, input: structuredClone(body.input ?? null), operation }, operator);
+      if (proposed.status !== "ready" && proposed.status !== "approval-required" && proposed.status !== "denied")
+        throw new Error("Invalid playground plan status");
+      if (proposed.spend && (!Number.isSafeInteger(proposed.spend.amountMinor) || proposed.spend.amountMinor < 0 || !/^[A-Z]{3}$/u.test(proposed.spend.currency)))
+        throw new Error("Invalid playground plan spend");
+      const plan2 = {
+        agentId,
+        effects: list(proposed.effects, (value) => text(value, "effect", 128)),
+        expiresAt: now() + (options.planTtlMs ?? 10 * 60000),
+        input: structuredClone(body.input ?? null),
+        inputDigest,
+        operation,
+        operatorId: operator.id,
+        planId: `plan_${crypto.randomUUID()}`,
+        ...proposed.spend ? {
+          spend: {
+            amountMinor: proposed.spend.amountMinor,
+            currency: text(proposed.spend.currency, "currency", 3)
+          }
+        } : {},
+        status: proposed.status,
+        steps: list(proposed.steps, (step) => ({
+          description: text(step.description, "step description"),
+          ...step.protocol ? { protocol: text(step.protocol, "protocol", 128) } : {},
+          ...step.target ? { target: text(step.target, "target") } : {}
+        })),
+        summary: text(proposed.summary, "summary")
+      };
+      await options.plans.save(plan2);
+      const { input: _input, ...visible } = plan2;
+      return Response.json(visible, {
+        status: 201,
+        headers: { "cache-control": "no-store" }
+      });
+    }
+    const execute = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}/api/plans/([^/]+)/execute$`, "u").exec(url.pathname);
+    if (request.method !== "POST" || !execute?.[1])
+      return new Response(null, { status: 405 });
+    if (!mutationAllowed(request, url))
+      return new Response("Cross-site mutation denied", { status: 403 });
+    const operationId = request.headers.get("idempotency-key");
+    if (!operationId)
+      return Response.json({ error: "Idempotency-Key is required" }, { status: 400 });
+    const plan = await options.plans.get(decodeURIComponent(execute[1]), operator.id);
+    if (!plan)
+      return Response.json({ error: "Plan not found or expired" }, { status: 404 });
+    if (plan.status !== "ready")
+      return Response.json({ error: `Plan is ${plan.status}` }, { status: 409 });
+    const binding = await digest({
+      inputDigest: plan.inputDigest,
+      planId: plan.planId
+    });
+    let claim;
+    try {
+      claim = await options.operations.claim(`playground:${plan.planId}`, binding, now(), 30000);
+    } catch (error) {
+      return Response.json({ error: error instanceof Error ? error.message : "conflict" }, { status: 409 });
+    }
+    if (claim.response !== undefined)
+      return Response.json(claim.response);
+    if (!claim.acquired)
+      return Response.json({ error: "operation in progress" }, { status: 409, headers: { "retry-after": "5" } });
+    const result = await options.adapter.execute(structuredClone(plan), operator);
+    if (!await options.operations.complete(`playground:${plan.planId}`, binding, result))
+      throw new Error("Playground execution completion lost");
+    return Response.json(result);
+  };
+};
+
 // src/index.ts
 var createMemoryOperationStore = () => {
-  const rows = new Map;
+  const rows2 = new Map;
   return {
-    claim: async (key, digest, now, leaseMs) => {
-      const row = rows.get(key);
-      if (row?.digest !== undefined && row.digest !== digest)
+    claim: async (key, digest2, now, leaseMs) => {
+      const row = rows2.get(key);
+      if (row?.digest !== undefined && row.digest !== digest2)
         throw new Error("Idempotency key reused with different input");
       if (row?.response !== undefined)
         return { acquired: false, response: structuredClone(row.response) };
       if (row && row.leaseUntil > now)
         return { acquired: false };
-      rows.set(key, { digest, key, leaseUntil: now + leaseMs });
+      rows2.set(key, { digest: digest2, key, leaseUntil: now + leaseMs });
       return { acquired: true };
     },
-    complete: async (key, digest, response) => {
-      const row = rows.get(key);
-      if (!row || row.digest !== digest)
+    complete: async (key, digest2, response) => {
+      const row = rows2.get(key);
+      if (!row || row.digest !== digest2)
         return false;
-      rows.set(key, { ...row, response: structuredClone(response) });
+      rows2.set(key, { ...row, response: structuredClone(response) });
       return true;
     }
   };
 };
-var hash = async (value) => [
+var hash2 = async (value) => [
   ...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(value))))
 ].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 var createAgentControlHandler = ({
@@ -54,10 +344,10 @@ var createAgentControlHandler = ({
   });
   if (!body?.operationId || !body.reason)
     return Response.json({ error: "operationId and reason are required" }, { status: 400 });
-  const digest = await hash({ action, agentId, reason: body.reason });
+  const digest2 = await hash2({ action, agentId, reason: body.reason });
   let claim;
   try {
-    claim = await operations.claim(body.operationId, digest, now(), 30000);
+    claim = await operations.claim(body.operationId, digest2, now(), 30000);
   } catch (error) {
     return Response.json({ error: error instanceof Error ? error.message : "conflict" }, { status: 409 });
   }
@@ -70,7 +360,7 @@ var createAgentControlHandler = ({
     agentId,
     reason: body.reason
   }) : (await control.restore(agentId), { agentId, restored: true, restoredBy: operator.id });
-  if (!await operations.complete(body.operationId, digest, response))
+  if (!await operations.complete(body.operationId, digest2, response))
     throw new Error("Control operation completion lost");
   return Response.json(response);
 };
@@ -89,12 +379,12 @@ var createPostgresOperationStore = ({
 }) => {
   const ns = nsOf(namespace);
   return {
-    claim: async (key, digest, now, leaseMs) => {
-      const result = await client.query(`INSERT INTO ${ns}.operations (operation_key,digest,lease_until) VALUES ($1,$2,$3) ON CONFLICT (operation_key) DO UPDATE SET lease_until=$3 WHERE ${ns}.operations.digest=$2 AND ${ns}.operations.response IS NULL AND ${ns}.operations.lease_until <= $4 RETURNING digest,response`, [key, digest, now + leaseMs, now]);
+    claim: async (key, digest2, now, leaseMs) => {
+      const result = await client.query(`INSERT INTO ${ns}.operations (operation_key,digest,lease_until) VALUES ($1,$2,$3) ON CONFLICT (operation_key) DO UPDATE SET lease_until=$3 WHERE ${ns}.operations.digest=$2 AND ${ns}.operations.response IS NULL AND ${ns}.operations.lease_until <= $4 RETURNING digest,response`, [key, digest2, now + leaseMs, now]);
       const row = result.rows[0];
       if (!row) {
         const existing = (await client.query(`SELECT digest,response FROM ${ns}.operations WHERE operation_key=$1`, [key])).rows[0];
-        if (existing?.digest !== undefined && existing.digest !== digest)
+        if (existing?.digest !== undefined && existing.digest !== digest2)
           throw new Error("Idempotency key reused with different input");
         return {
           acquired: false,
@@ -103,12 +393,16 @@ var createPostgresOperationStore = ({
       }
       return { acquired: row.response === null || row.response === undefined };
     },
-    complete: async (key, digest, response) => (await client.query(`UPDATE ${ns}.operations SET response=$3::jsonb WHERE operation_key=$1 AND digest=$2 AND response IS NULL RETURNING operation_key`, [key, digest, JSON.stringify(response)])).rows.length === 1
+    complete: async (key, digest2, response) => (await client.query(`UPDATE ${ns}.operations SET response=$3::jsonb WHERE operation_key=$1 AND digest=$2 AND response IS NULL RETURNING operation_key`, [key, digest2, JSON.stringify(response)])).rows.length === 1
   };
 };
 export {
+  sanitizeAgentControlSnapshot,
   createPostgresOperationStore,
   createMemoryOperationStore,
+  createMemoryAgentPlaygroundPlanStore,
+  createAgentPlaygroundHandler,
   createAgentControlHandler,
+  createAgentControlConsoleHandler,
   agentControlPostgresSchemaSql
 };

package/dist/manifest.js

@@ -5901,6 +5901,14 @@ var serializedTool = Type.Object({
 });
 var manifestSchema = Type.Object({
   contract: Type.Union([Type.Literal(1), Type.Literal(2)]),
+  discovery: Type.Optional(Type.Object({
+    audiences: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    certificationUrl: Type.Optional(Type.String()),
+    intents: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    keywords: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    protocols: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    url: Type.Optional(Type.String())
+  })),
   identity: Type.Object({
     accent: Type.Optional(Type.String({ pattern: "^#[0-9a-fA-F]{3,8}$" })),
     category: Type.String({ minLength: 1 }),
@@ -5935,7 +5943,7 @@ var manifest = defineManifest()({
   identity: {
     accent: "#dc2626",
     category: "security",
-    description: "Authenticated operator API for agent inventory, durable kill switches, source revocation, restoration, and leased idempotent operations.",
+    description: "Authenticated operator API, CSP-hardened console, and bound plan-then-execute playground for approvals, runs, budgets, delegations, memory metadata, reputation, durable kill switches, and leased idempotent operations.",
     docsUrl: "https://github.com/absolutejs/agent-control",
     name: "@absolutejs/agent-control",
     tagline: "See and stop every capability an agent holds."

package/dist/manifest.json

@@ -3,7 +3,7 @@
 	"identity": {
 		"accent": "#dc2626",
 		"category": "security",
-		"description": "Authenticated operator API for agent inventory, durable kill switches, source revocation, restoration, and leased idempotent operations.",
+		"description": "Authenticated operator API, CSP-hardened console, and bound plan-then-execute playground for approvals, runs, budgets, delegations, memory metadata, reputation, durable kill switches, and leased idempotent operations.",
 		"docsUrl": "https://github.com/absolutejs/agent-control",
 		"name": "@absolutejs/agent-control",
 		"tagline": "See and stop every capability an agent holds."

package/dist/playground.d.ts

@@ -0,0 +1,53 @@
+import type { OperationStore, Operator } from "./index";
+export type AgentPlaygroundCatalogItem = {
+    description?: string;
+    id: string;
+    name: string;
+    operations: string[];
+    protocols: string[];
+};
+export type AgentPlaygroundPlan = {
+    agentId: string;
+    effects: string[];
+    expiresAt: number;
+    input: unknown;
+    inputDigest: string;
+    operation: string;
+    operatorId: string;
+    planId: string;
+    spend?: {
+        amountMinor: number;
+        currency: string;
+    };
+    status: "ready" | "approval-required" | "denied";
+    steps: Array<{
+        description: string;
+        protocol?: string;
+        target?: string;
+    }>;
+    summary: string;
+};
+export type AgentPlaygroundPlanStore = {
+    get: (planId: string, operatorId: string) => Promise<AgentPlaygroundPlan | undefined>;
+    save: (plan: AgentPlaygroundPlan) => Promise<void>;
+};
+export type AgentPlaygroundAdapter = {
+    catalog: (operator: Operator) => Promise<AgentPlaygroundCatalogItem[]> | AgentPlaygroundCatalogItem[];
+    /** Must not produce external effects. Return only a proposed plan. */
+    plan: (request: {
+        agentId: string;
+        input: unknown;
+        operation: string;
+    }, operator: Operator) => Promise<Omit<AgentPlaygroundPlan, "agentId" | "expiresAt" | "input" | "inputDigest" | "operation" | "operatorId" | "planId">> | Omit<AgentPlaygroundPlan, "agentId" | "expiresAt" | "input" | "inputDigest" | "operation" | "operatorId" | "planId">;
+    execute: (plan: AgentPlaygroundPlan, operator: Operator) => Promise<unknown>;
+};
+export declare const createMemoryAgentPlaygroundPlanStore: (now?: () => number) => AgentPlaygroundPlanStore;
+export declare const createAgentPlaygroundHandler: (options: {
+    adapter: AgentPlaygroundAdapter;
+    authorize: (request: Request) => Promise<Operator | undefined> | Operator | undefined;
+    basePath?: string;
+    now?: () => number;
+    operations: OperationStore;
+    plans: AgentPlaygroundPlanStore;
+    planTtlMs?: number;
+}) => (request: Request) => Promise<Response | null>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@absolutejs/agent-control",
-  "version": "0.1.0",
-  "description": "Authenticated operator API for AI agent inventory, kill switches, revocation, and restoration.",
+  "version": "0.3.0",
+  "description": "Authenticated AI agent operator API, console, and bound plan-then-execute playground.",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/absolutejs/agent-control.git"
+    "url": "git+https://github.com/absolutejs/agent-control.git"
   },
   "publishConfig": {
     "access": "public"
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@absolutejs/agency": "^0.4.0",
-    "@absolutejs/manifest": "^0.2.0",
+    "@absolutejs/manifest": "^0.3.0",
     "@sinclair/typebox": "^0.34.0"
   },
   "devDependencies": {