@zeroroot-ai/zerocool 0.3.0 → 0.3.1

package/dist/dispatch.d.ts

@@ -16,9 +16,9 @@
  * first run trades it for a persistent host key, and every later run re-registers
  * with that key (ADR-0045). A sandboxed run has neither. It authenticates with
  * the PER-DISPATCH capability grant gibson mints for this run and injects as
- * `GIBSON_CALLBACK_ENDPOINT` + `GIBSON_CALLBACK_TOKEN`. That grant carries exactly
- * the authority of this dispatch, so this process never reads a bootstrap token
- * and never touches a host key.
+ * `GIBSON_CALLBACK_ENDPOINT` + `GIBSON_CG_JWT`. That grant carries exactly the
+ * authority of this dispatch, so this process never reads a bootstrap token and
+ * never touches a host key.
  *
  * THE CALLBACKS ARE GRANT-AUTHENTICATED. This process drives `opencode run`
  * headless and passes the per-dispatch grant to the child (see
@@ -35,15 +35,23 @@
  *
  * Environment (injected by the sandbox launch):
  *
+ * These names are gibson's canonical dispatch contract — the constants in gibson
+ * `internal/engine/harness/sandboxed/agent.go` (envAgent*). This process conforms
+ * to them; it does not define its own.
+ *
  *   GIBSON_CALLBACK_ENDPOINT   per-dispatch harness callback dial target (required)
- *   GIBSON_CALLBACK_TOKEN      per-dispatch capability grant             (required)
- *   GIBSON_TASK_GOAL           the task to pursue                        (required)
+ *   GIBSON_CG_JWT              per-dispatch capability grant (CG-JWT)    (required)
+ *   GIBSON_AGENT_TASK_B64      base64 protojson gibson.types.v1.Task     (required)
+ *   GIBSON_MODEL               provider/model resolved for the tenant at dispatch
  *   GIBSON_CALLBACK_INSECURE   "1" to dial the callback listener without TLS (kind)
- *   GIBSON_MISSION_RUN_ID / GIBSON_AGENT_RUN_ID / GIBSON_TRACE_ID   provenance
+ *   GIBSON_MISSION_ID / GIBSON_MISSION_RUN_ID / GIBSON_AGENT_RUN_ID   provenance
  *   ZEROCOOL_WORKSPACE         working directory (defaults to the cwd)
- *   ZEROCOOL_MODEL             provider/model for opencode
  *   GIBSON_OPENCODE_SESSION_ID continue an earlier opencode session
  *   GIBSON_TIMEOUT_MS          hard deadline for the run, in ms
+ *
+ * The child `opencode run` still receives the grant as GIBSON_CALLBACK_TOKEN via
+ * {@link dispatchChildEnv} — that is the opencode plugin's own contract, fed from
+ * the GIBSON_CG_JWT this process reads.
  */
 import type { AgentOutcome } from "@zeroroot-ai/sdk";
 import { runOpencode } from "./opencode-run.js";
@@ -86,6 +94,13 @@ export interface DispatchContext extends CallbackGrant {
  * same environment.
  */
 export declare function dispatchChildEnv(g: CallbackGrant): NodeJS.ProcessEnv;
+/**
+ * Decode the base64 protojson `gibson.types.v1.Task` the sandbox launch injects
+ * as `GIBSON_AGENT_TASK_B64` (gibson agent.go `envAgentTaskB64`) and return its
+ * goal. gibson sends the full typed Task, not a plain goal string, so decode it
+ * here rather than run opencode against an empty or malformed prompt.
+ */
+export declare function decodeTaskGoal(taskB64: string | undefined): string;
 /**
  * Read one sandboxed dispatch's context from the environment.
  *

package/dist/dispatch.js

@@ -19,6 +19,32 @@ export function dispatchChildEnv(g) {
         ...(g.traceId ? { GIBSON_TRACE_ID: g.traceId } : {}),
     };
 }
+/**
+ * Decode the base64 protojson `gibson.types.v1.Task` the sandbox launch injects
+ * as `GIBSON_AGENT_TASK_B64` (gibson agent.go `envAgentTaskB64`) and return its
+ * goal. gibson sends the full typed Task, not a plain goal string, so decode it
+ * here rather than run opencode against an empty or malformed prompt.
+ */
+export function decodeTaskGoal(taskB64) {
+    if (!taskB64) {
+        throw new Error("GIBSON_AGENT_TASK_B64 is not set. The sandbox launch injects the task to pursue as the " +
+            "base64 protojson of a gibson.types.v1.Task; without it there is nothing to run.");
+    }
+    let task;
+    try {
+        task = JSON.parse(Buffer.from(taskB64, "base64").toString("utf8"));
+    }
+    catch (e) {
+        throw new Error("GIBSON_AGENT_TASK_B64 is not valid base64 protojson of a gibson.types.v1.Task: " +
+            (e instanceof Error ? e.message : String(e)));
+    }
+    const goal = typeof task.goal === "string" ? task.goal.trim() : "";
+    if (!goal) {
+        throw new Error("GIBSON_AGENT_TASK_B64 decoded to a Task with no goal. Running opencode against an empty " +
+            "prompt would report whatever it says back as a mission result.");
+    }
+    return goal;
+}
 /**
  * Read one sandboxed dispatch's context from the environment.
  *
@@ -34,22 +60,18 @@ export function dispatchChildEnv(g) {
  */
 export function readDispatchContext(env, opts = {}) {
     const endpoint = env.GIBSON_CALLBACK_ENDPOINT;
-    const token = env.GIBSON_CALLBACK_TOKEN;
+    const token = env.GIBSON_CG_JWT;
     if (!endpoint) {
         throw new Error("GIBSON_CALLBACK_ENDPOINT is not set. A sandboxed dispatched run is authenticated by " +
             "the per-dispatch grant the sandbox launch injects, not by a bootstrap token — the " +
-            "launch must supply the callback endpoint and token.");
+            "launch must supply the callback endpoint and the grant.");
     }
     if (!token) {
-        throw new Error("GIBSON_CALLBACK_ENDPOINT is set but GIBSON_CALLBACK_TOKEN is not. The callbacks would " +
-            "have no grant to authenticate with; a sandboxed run must not fall back to any other " +
-            "identity, so this fails instead.");
-    }
-    const goal = env.GIBSON_TASK_GOAL?.trim();
-    if (!goal) {
-        throw new Error("GIBSON_TASK_GOAL is empty. The sandbox launch injects the task to pursue; running " +
-            "opencode against an empty prompt would report whatever it says back as a mission result.");
+        throw new Error("GIBSON_CALLBACK_ENDPOINT is set but GIBSON_CG_JWT is not. The callbacks would have no " +
+            "grant to authenticate with; a sandboxed run must not fall back to any other identity, " +
+            "so this fails instead.");
     }
+    const goal = decodeTaskGoal(env.GIBSON_AGENT_TASK_B64);
     const timeoutRaw = env.GIBSON_TIMEOUT_MS ? Number(env.GIBSON_TIMEOUT_MS) : 0;
     return {
         callbackEndpoint: endpoint,
@@ -60,7 +82,7 @@ export function readDispatchContext(env, opts = {}) {
         traceId: env.GIBSON_TRACE_ID ?? "",
         goal,
         workspace: env.ZEROCOOL_WORKSPACE ?? opts.cwd ?? process.cwd(),
-        ...(env.ZEROCOOL_MODEL ? { model: env.ZEROCOOL_MODEL } : {}),
+        ...(env.GIBSON_MODEL ? { model: env.GIBSON_MODEL } : {}),
         ...(env.GIBSON_OPENCODE_SESSION_ID ? { sessionId: env.GIBSON_OPENCODE_SESSION_ID } : {}),
         timeoutMs: Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? timeoutRaw : 0,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeroroot-ai/zerocool",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "opencode plugin: Gibson platform integration (zerocool). Zero-config LLM, tools, findings, knowledge, delegate/missions.",
   "license": "MIT",
   "repository": {