@whittlelabs/sifter 0.20.0 → 0.22.0

package/bin.js

@@ -15184,6 +15184,20 @@ var require_schema4 = __commonJS({
         identityId: zod_1.z.string().uuid(),
         metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional()
       }),
+      /**
+       * Runner-owned per-dispatch credential reveal (ADR 0027): the deployment's
+       * reveal service identity. Present ⇒ hosted (the runner builds a credential
+       * broker and reveals customer keys/tokens per dispatch); absent ⇒ local (no
+       * reveals, ambient credentials). Distinct from the pairing-derived AGENT
+       * credential (`auth`), which authenticates the claim loop. `keepClientId` /
+       * `keepClientSecret` fall back to the KEEP_CLIENT_ID / KEEP_CLIENT_SECRET env.
+       */
+      credentials: zod_1.z.object({
+        apiKeyFrom: zod_1.z.literal("job-metadata"),
+        keepApiUrl: zod_1.z.string().url(),
+        keepClientId: zod_1.z.string().optional(),
+        keepClientSecret: zod_1.z.string().optional()
+      }).passthrough().optional(),
       pools: zod_1.z.array(poolSchema).min(1, "At least one pool is required"),
       polling: zod_1.z.object({
         intervalMs: zod_1.z.number().int().positive().default(defaults_1.DEFAULTS.polling.intervalMs),
@@ -18435,226 +18449,610 @@ var require_chain = __commonJS({
   }
 });
 
-// ../../packages/shuttle/dist/executors/output-gates.js
-var require_output_gates = __commonJS({
-  "../../packages/shuttle/dist/executors/output-gates.js"(exports2) {
+// ../../packages/shuttle/dist/workspace/git.js
+var require_git = __commonJS({
+  "../../packages/shuttle/dist/workspace/git.js"(exports2) {
     "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolvePath = resolvePath;
-    exports2.evaluateOutputGates = evaluateOutputGates;
-    exports2.renderRepairPrompt = renderRepairPrompt;
-    var INPUT_REF = "input:";
-    function resolvePath(root, path) {
-      let ctx = root;
-      for (const seg of path.split(".")) {
-        const project = seg.endsWith("[*]");
-        const key = project ? seg.slice(0, -3) : seg;
-        if (Array.isArray(ctx)) {
-          ctx = ctx.map((el) => key ? el?.[key] : el);
-        } else {
-          ctx = key ? ctx?.[key] : ctx;
-        }
-        if (project && !Array.isArray(ctx)) {
-          ctx = ctx == null ? [] : [ctx];
+    exports2.gitMaterializer = void 0;
+    exports2.buildGitAuthEnv = buildGitAuthEnv;
+    var child_process_1 = require("child_process");
+    var fs_1 = require("fs");
+    var path_1 = __importDefault(require("path"));
+    var DEFAULT_GIT_TIMEOUT_MS = 12e4;
+    var DEFAULT_GIT_PROTOCOLS = "https:ssh:git";
+    var DEFAULT_MAX_CONTEXT_REPOS = 5;
+    exports2.gitMaterializer = {
+      namespace: "git",
+      materialize: materializeGit
+    };
+    async function materializeGit(request, runRoot, options) {
+      const resolvedPrimary = readGitWorkspace(request);
+      const primaryDir = path_1.default.join(runRoot, "primary");
+      await fs_1.promises.mkdir(primaryDir, { recursive: true });
+      if ("warning" in resolvedPrimary) {
+        return { materialized: false, warning: resolvedPrimary.warning, context: [] };
+      }
+      const primary = resolvedPrimary.git;
+      const timeoutMs = options.commandTimeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
+      const allowedProtocols = options.allowedProtocols ?? DEFAULT_GIT_PROTOCOLS;
+      const signal = options.signal;
+      const maxContext = options.maxContextRepos ?? DEFAULT_MAX_CONTEXT_REPOS;
+      const contextPlan = planContextRepos(primary.context, maxContext);
+      const ref = primary.fetchCredential;
+      let gitToken = null;
+      if (ref && typeof ref.name === "string" && typeof ref.principal === "string" && options.credentials) {
+        try {
+          gitToken = await options.credentials.reveal(ref);
+        } catch {
+          gitToken = null;
         }
       }
-      return ctx;
-    }
-    function resolveRef(ref, output, inputs) {
-      if (ref.startsWith(INPUT_REF)) {
-        const label = ref.slice(INPUT_REF.length);
-        const row = inputs.find((i) => i.label === label) ?? inputs.find((i) => i.label === "artifacts" && i.payload.label === label);
-        if (!row)
-          return void 0;
-        return Object.prototype.hasOwnProperty.call(row.payload, "value") ? row.payload.value : row.payload;
+      const authEnv = gitToken !== null ? buildGitAuthEnv([primary.remote, ...contextPlan.materialize.map((c) => c.git.remote)], gitToken) : void 0;
+      const git = (args, cwd) => runGit(args, cwd, { timeoutMs, signal, allowedProtocols, extraEnv: authEnv });
+      const primaryResult = await materializeCommit(primary, primaryDir, git);
+      if (!primaryResult.ok) {
+        await fs_1.promises.rm(primaryDir, { recursive: true, force: true }).catch(() => {
+        });
+        await fs_1.promises.mkdir(primaryDir).catch(() => {
+        });
+        return { materialized: false, warning: primaryResult.warning, context: [] };
+      }
+      const context = [];
+      for (const planned of contextPlan.skip) {
+        context.push({ ...planned, materialized: false });
+      }
+      if (contextPlan.materialize.length > 0) {
+        const contextRoot = path_1.default.join(runRoot, "context");
+        await fs_1.promises.mkdir(contextRoot, { recursive: true });
+        for (const entry of contextPlan.materialize) {
+          const dir = path_1.default.join(contextRoot, entry.name);
+          await fs_1.promises.mkdir(dir);
+          const result = await materializeCommit(entry.git, dir, git);
+          context.push({
+            name: entry.name,
+            requestedName: entry.requestedName,
+            materialized: result.ok,
+            ...result.ok ? {} : { warning: result.warning }
+          });
+        }
       }
-      return resolvePath(output, ref);
-    }
-    function asStrings(value) {
-      if (Array.isArray(value))
-        return value.map((v) => String(v));
-      if (value == null)
-        return [];
-      return [String(value)];
-    }
-    var PRIMITIVES = {
-      /**
-       * `coverage` — the values at `got` must exactly cover the set at `want`:
-       * every wanted value present, nothing invented, none repeated. Params:
-       * `{ got: <output path>, want: <ref>, subject?: <noun> }`.
-       */
-      coverage(params, output, inputs) {
-        const subject = typeof params.subject === "string" ? params.subject : "item";
-        const got = asStrings(resolveRef(String(params.got), output, inputs));
-        const want = asStrings(resolveRef(String(params.want), output, inputs));
-        const gotSet = new Set(got);
-        const wantSet = new Set(want);
-        const missing = want.filter((v) => !gotSet.has(v));
-        const unknown = [...new Set(got.filter((v) => !wantSet.has(v)))];
-        const seen = /* @__PURE__ */ new Set();
-        const duplicated = [];
-        for (const v of got) {
-          if (seen.has(v))
-            duplicated.push(v);
-          else
-            seen.add(v);
+      context.sort((a, b) => contextOrder(contextPlan, a.requestedName) - contextOrder(contextPlan, b.requestedName));
+      return { materialized: true, primaryDir, context };
+    }
+    function planContextRepos(raw, maxContext) {
+      const plan = { materialize: [], skip: [], order: /* @__PURE__ */ new Map() };
+      if (raw === void 0)
+        return plan;
+      if (!Array.isArray(raw))
+        return plan;
+      const usedNames = /* @__PURE__ */ new Set();
+      raw.forEach((entry, index) => {
+        const requestedName = entry && typeof entry.name === "string" ? entry.name : `context-${index}`;
+        plan.order.set(requestedName, index);
+        const resolved = readContextRepo(entry, index);
+        if ("warning" in resolved) {
+          plan.skip.push({ name: sanitizeMountName(requestedName, usedNames), requestedName, warning: resolved.warning });
+          return;
         }
-        if (missing.length === 0 && unknown.length === 0 && duplicated.length === 0)
-          return [];
-        const parts = [];
-        if (missing.length)
-          parts.push(`missing ${subject}(s): [${missing.join(", ")}]`);
-        if (unknown.length)
-          parts.push(`not a known ${subject}: [${unknown.join(", ")}]`);
-        if (duplicated.length)
-          parts.push(`assessed more than once: [${[...new Set(duplicated)].join(", ")}]`);
-        return [
-          `every ${subject} must be covered exactly once \u2014 ${parts.join("; ")}. Return one entry per ${subject}, using its exact id.`
-        ];
-      },
-      /**
-       * `non_empty_when` — the array at `path` must be non-empty, optionally only
-       * when `when.path` equals `when.equals`. Params:
-       * `{ path: <output path>, when?: { path: <output path>, equals: <value> } }`.
-       */
-      non_empty_when(params, output) {
-        const when = params.when;
-        if (when && typeof when.path === "string") {
-          if (resolvePath(output, when.path) !== when.equals)
-            return [];
+        if (plan.materialize.length >= maxContext) {
+          plan.skip.push({
+            name: sanitizeMountName(requestedName, usedNames),
+            requestedName,
+            warning: `skipped: exceeds the ${maxContext}-context-repo cap`
+          });
+          return;
         }
-        const path = String(params.path);
-        const value = resolvePath(output, path);
-        if (Array.isArray(value) && value.length > 0)
-          return [];
-        const cond = when && typeof when.path === "string" ? ` when ${when.path} is ${JSON.stringify(when.equals)}` : "";
-        return [
-          `'${path}' must be a non-empty array${cond}; it was ${Array.isArray(value) ? "empty" : "absent"}.`
-        ];
+        plan.materialize.push({
+          git: resolved.git,
+          name: sanitizeMountName(requestedName, usedNames),
+          requestedName
+        });
+      });
+      return plan;
+    }
+    function contextOrder(plan, requestedName) {
+      return plan.order.get(requestedName) ?? Number.MAX_SAFE_INTEGER;
+    }
+    async function materializeCommit(gitWorkspace, dir, git) {
+      const hasCommit = () => git(["cat-file", "-e", `${gitWorkspace.commit}^{commit}`], dir).then((r) => r.code === 0);
+      const init = await git(["init", "-q"], dir);
+      if (init.code !== 0)
+        return { ok: false, warning: `git init failed: ${firstLine(init.stderr)}` };
+      const attempts = [];
+      for (const ref of gitWorkspace.fetchRefs ?? []) {
+        attempts.push({
+          source: `${gitWorkspace.remote} ${ref}`,
+          args: ["fetch", "--no-tags", "--depth=1", gitWorkspace.remote, ref]
+        });
       }
-    };
-    function evaluateOutputGates(gates, output, inputs) {
-      const findings = [];
-      for (const gate of gates) {
-        const primitive = PRIMITIVES[gate.primitive];
-        if (!primitive) {
-          findings.push({ gate: gate.name, message: `unknown gate primitive '${gate.primitive}'` });
+      attempts.push({
+        source: `${gitWorkspace.remote} commit`,
+        args: ["fetch", "--no-tags", "--depth=1", gitWorkspace.remote, gitWorkspace.commit]
+      });
+      const failures = [];
+      let present = await hasCommit();
+      for (const { source, args } of attempts) {
+        if (present)
+          break;
+        const result = await git(args, dir);
+        if (result.code !== 0) {
+          failures.push(`${source}: ${firstLine(result.stderr)}`);
           continue;
         }
-        for (const message of primitive(gate.params, output, inputs)) {
-          findings.push({ gate: gate.name, message });
-        }
+        present = await hasCommit();
+        if (!present)
+          failures.push(`${source}: fetch succeeded but ${gitWorkspace.commit} is still absent`);
       }
-      return { ok: findings.length === 0, findings };
-    }
-    function renderRepairPrompt(findings) {
-      return [
-        "Your previous answer did not satisfy these output checks. Return the corrected, complete answer that resolves every item below. Produce the same output shape with the problems fixed, and nothing else \u2014 no commentary, no explanation of the changes.",
-        "",
-        ...findings.map((f) => `- [${f.gate}] ${f.message}`)
-      ].join("\n");
+      if (!present) {
+        return {
+          ok: false,
+          warning: `could not materialize ${gitWorkspace.commit} from ${gitWorkspace.remote}` + (failures.length > 0 ? ` (${failures.join("; ")})` : "")
+        };
+      }
+      const checkout = await git(["checkout", "--detach", gitWorkspace.commit], dir);
+      if (checkout.code !== 0)
+        return { ok: false, warning: `git checkout failed: ${firstLine(checkout.stderr)}` };
+      return { ok: true };
     }
-  }
-});
-
-// ../../packages/keep/dist/client.js
-var require_client2 = __commonJS({
-  "../../packages/keep/dist/client.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.KeepClient = void 0;
-    var KeepClient = class {
-      baseUrl;
-      headers;
-      constructor(config) {
-        this.baseUrl = config.baseUrl.replace(/\/$/, "");
-        this.headers = { "Content-Type": "application/json" };
-        if (config.serviceToken) {
-          this.headers["Authorization"] = `Bearer ${config.serviceToken}`;
-        } else if (config.accessToken) {
-          this.headers["Authorization"] = `Bearer ${config.accessToken}`;
+    function buildGitAuthEnv(remotes, token) {
+      const origins = [];
+      for (const remote of remotes) {
+        try {
+          const url = new URL(remote);
+          if (url.protocol !== "https:")
+            continue;
+          const origin = `${url.protocol}//${url.host}/`;
+          if (!origins.includes(origin))
+            origins.push(origin);
+        } catch {
+          continue;
         }
       }
-      // ── Actor Tokens ────────────────────────────────────────────────
-      /**
-       * Mint a short-lived `act_` token for an end user, with this client's
-       * service identity recorded as the conduit. Requires this client to be
-       * constructed with a service token holding `keep:actor-tokens:write`.
-       */
-      async mintActorToken(actor) {
-        return this.request("POST", "/api/actor-tokens", { actor });
-      }
-      // ── Identity ────────────────────────────────────────────────────
-      async createAccount(email, password, name) {
-        return this.request("POST", "/api/accounts", { email, password, name });
-      }
-      async createSession(email, password) {
-        return this.request("POST", "/api/sessions", { email, password });
-      }
-      async destroySession(refreshToken) {
-        await this.request("DELETE", "/api/sessions", refreshToken ? { refreshToken } : void 0);
-      }
-      async refreshSession(refreshToken) {
-        return this.request("POST", "/api/sessions/renewal", { refreshToken });
-      }
-      async getCurrentUser() {
-        return this.request("GET", "/api/accounts/me");
-      }
-      async updateProfile(updates) {
-        return this.request("PATCH", "/api/accounts/me", updates);
-      }
-      async confirmEmail(email, code) {
-        await this.request("POST", "/api/email-confirmations", { email, code });
-      }
-      async requestVerificationCode(email) {
-        await this.request("POST", "/api/verification-codes", { email });
-      }
-      async requestPasswordReset(email) {
-        await this.request("POST", "/api/password-resets", { email });
-      }
-      async resetPassword(email, code, newPassword) {
-        await this.request("PUT", `/api/password-resets/${code}`, { email, newPassword });
-      }
-      async changePassword(currentPassword, newPassword) {
-        await this.request("PUT", "/api/passwords", { currentPassword, newPassword });
-      }
-      // ── Organizations ───────────────────────────────────────────────
-      async listOrganizations() {
-        const { organizations } = await this.request("GET", "/api/organizations");
-        return organizations;
-      }
-      async getOrganization(orgId) {
-        return this.request("GET", `/api/organizations/${orgId}`);
-      }
-      async createOrganization(name, description) {
-        return this.request("POST", "/api/organizations", { name, description });
-      }
-      async updateOrganization(orgId, updates) {
-        return this.request("PATCH", `/api/organizations/${orgId}`, updates);
-      }
-      async deleteOrganization(orgId) {
-        await this.request("DELETE", `/api/organizations/${orgId}`);
-      }
-      async listMembers(orgId) {
-        return this.request("GET", `/api/organizations/${orgId}/members`);
+      if (origins.length === 0)
+        return void 0;
+      const basic = Buffer.from(`x-access-token:${token}`).toString("base64");
+      const env = { GIT_CONFIG_COUNT: String(origins.length) };
+      origins.forEach((origin, i) => {
+        env[`GIT_CONFIG_KEY_${i}`] = `http.${origin}.extraheader`;
+        env[`GIT_CONFIG_VALUE_${i}`] = `Authorization: Basic ${basic}`;
+      });
+      return env;
+    }
+    var COMMIT_PATTERN = /^[0-9a-f]{40}$/i;
+    var REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9/_.@^~+-]*$/;
+    function readGitWorkspace(request) {
+      if (typeof request !== "object" || request === null || Array.isArray(request)) {
+        return { warning: "git workspace request must be an object" };
       }
-      async removeMember(orgId, userId) {
-        await this.request("DELETE", `/api/organizations/${orgId}/members/${userId}`);
+      return validateGitShape(request);
+    }
+    function readContextRepo(entry, index) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        return { warning: `context[${index}] must be an object` };
       }
-      async listTeams(orgId) {
-        return this.request("GET", `/api/organizations/${orgId}/teams`);
+      const e = entry;
+      if (typeof e.name !== "string" || e.name.length === 0) {
+        return { warning: `context[${index}].name must be a non-empty string` };
       }
-      async createTeam(orgId, name, description) {
-        return this.request("POST", `/api/organizations/${orgId}/teams`, { name, description });
+      const shape = validateGitShape(e);
+      if ("warning" in shape)
+        return { warning: `context[${index}] ${shape.warning}` };
+      return { git: { ...shape.git, name: e.name } };
+    }
+    function validateGitShape(git) {
+      if (typeof git.remote !== "string" || git.remote.length === 0 || git.remote.startsWith("-")) {
+        return { warning: "git.remote must be a non-empty remote URL or path" };
       }
-      async listTeamMembers(orgId, teamId) {
-        return this.request("GET", `/api/organizations/${orgId}/teams/${teamId}/members`);
+      if (typeof git.commit !== "string" || !COMMIT_PATTERN.test(git.commit)) {
+        return { warning: "git.commit must be a full 40-char commit SHA" };
       }
-      async addTeamMember(orgId, teamId, userId) {
-        return this.request("POST", `/api/organizations/${orgId}/teams/${teamId}/members`, { userId });
+      if (git.fetchRefs !== void 0) {
+        if (!Array.isArray(git.fetchRefs) || !git.fetchRefs.every((r) => typeof r === "string")) {
+          return { warning: "git.fetchRefs must be an array of ref strings" };
+        }
+        const bad = git.fetchRefs.find((r) => !REF_PATTERN.test(r));
+        if (bad !== void 0) {
+          return { warning: `git.fetchRefs contains an invalid ref: ${JSON.stringify(bad)}` };
+        }
       }
-      async createInvitation(orgId, email, roleGrants) {
-        return this.request("POST", `/api/organizations/${orgId}/invitations`, { email, roleGrants });
+      return { git };
+    }
+    function sanitizeMountName(requested, used) {
+      let base = requested.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "").replace(/-+$/, "").slice(0, 100);
+      if (base.length === 0)
+        base = "context";
+      let name = base;
+      let n = 2;
+      while (used.has(name)) {
+        name = `${base}-${n}`;
+        n += 1;
+      }
+      used.add(name);
+      return name;
+    }
+    function runGit(args, cwd, opts) {
+      return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)("git", args, {
+          cwd,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            ...opts.extraEnv ?? {},
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_ALLOW_PROTOCOL: opts.allowedProtocols
+          }
+        });
+        const stdout = [];
+        const stderr = [];
+        let settled = false;
+        const settle = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          opts.signal?.removeEventListener("abort", onAbort);
+          resolve(result);
+        };
+        const killChild = () => {
+          child.kill("SIGTERM");
+          const escalate = setTimeout(() => child.kill("SIGKILL"), 5e3);
+          escalate.unref();
+          child.once("close", () => clearTimeout(escalate));
+        };
+        const timer = setTimeout(() => {
+          killChild();
+          settle({ code: -1, stdout: Buffer.concat(stdout).toString("utf-8"), stderr: `git ${args[0]} timed out after ${opts.timeoutMs}ms` });
+        }, opts.timeoutMs);
+        const onAbort = () => {
+          killChild();
+          settle({ code: -1, stdout: Buffer.concat(stdout).toString("utf-8"), stderr: "aborted" });
+        };
+        if (opts.signal?.aborted) {
+          onAbort();
+          return;
+        }
+        opts.signal?.addEventListener("abort", onAbort, { once: true });
+        child.stdout.on("data", (c) => stdout.push(c));
+        child.stderr.on("data", (c) => stderr.push(c));
+        child.on("error", (err) => settle({ code: -1, stdout: "", stderr: err.message }));
+        child.on("close", (code) => settle({ code: code ?? -1, stdout: Buffer.concat(stdout).toString("utf-8"), stderr: Buffer.concat(stderr).toString("utf-8") }));
+      });
+    }
+    function firstLine(text) {
+      const line = text.trim().split("\n", 1)[0];
+      return line.length > 0 ? line : "(no output)";
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/workspace/overlay.js
+var require_overlay = __commonJS({
+  "../../packages/shuttle/dist/workspace/overlay.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.overlayModifier = void 0;
+    exports2.applyOverlay = applyOverlay;
+    var fs_1 = require("fs");
+    var path_1 = __importDefault(require("path"));
+    var DEFAULT_TIMEOUT_MS = 3e4;
+    var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+    exports2.overlayModifier = {
+      namespace: "overlay",
+      apply: applyOverlay
+    };
+    async function applyOverlay(request, runDir, options) {
+      const timeoutMs = DEFAULT_TIMEOUT_MS;
+      const maxBytes = options.overlayMaxBytes ?? DEFAULT_MAX_BYTES;
+      const allowed = new Set((options.overlayAllowedHosts ?? []).map(normalizeOrigin).filter((o) => !!o));
+      const rootReal = await fs_1.promises.realpath(runDir);
+      const result = { written: 0, writtenPaths: [], skipped: [] };
+      const files = request && typeof request === "object" && Array.isArray(request.files) ? request.files : [];
+      for (const file of files) {
+        const skip = (reason) => result.skipped.push({ path: String(file?.path ?? "?"), reason });
+        if (typeof file?.path !== "string" || typeof file?.url !== "string") {
+          skip("malformed overlay entry (path/url must be strings)");
+          continue;
+        }
+        const dest = safeDestination(rootReal, file.path);
+        if (!dest) {
+          skip("path escapes the workspace root");
+          continue;
+        }
+        let origin;
+        try {
+          const u = new URL(file.url);
+          if (u.protocol !== "https:" && u.protocol !== "http:") {
+            skip(`unsupported url protocol ${u.protocol}`);
+            continue;
+          }
+          origin = normalizeOrigin(u.origin);
+        } catch {
+          skip("invalid url");
+          continue;
+        }
+        if (!origin || !allowed.has(origin)) {
+          skip(`origin not in the overlay allowlist (${origin})`);
+          continue;
+        }
+        try {
+          const content = await fetchCapped(file.url, { timeoutMs, maxBytes, signal: options.signal });
+          const parent = path_1.default.dirname(dest);
+          await fs_1.promises.mkdir(parent, { recursive: true });
+          const parentReal = await fs_1.promises.realpath(parent);
+          if (parentReal !== rootReal && !parentReal.startsWith(rootReal + path_1.default.sep)) {
+            skip("destination parent escapes the workspace root");
+            continue;
+          }
+          const handle = await fs_1.promises.open(dest, fs_1.constants.O_WRONLY | fs_1.constants.O_CREAT | fs_1.constants.O_TRUNC | fs_1.constants.O_NOFOLLOW, 420);
+          try {
+            await handle.writeFile(content);
+          } finally {
+            await handle.close();
+          }
+          result.written += 1;
+          result.writtenPaths.push(file.path);
+        } catch (err) {
+          skip(err instanceof Error ? err.message : String(err));
+        }
+      }
+      return result;
+    }
+    function safeDestination(rootReal, relPath) {
+      if (relPath.length === 0 || path_1.default.isAbsolute(relPath))
+        return void 0;
+      const resolved = path_1.default.resolve(rootReal, relPath);
+      const rootWithSep = rootReal.endsWith(path_1.default.sep) ? rootReal : rootReal + path_1.default.sep;
+      if (resolved !== rootReal && !resolved.startsWith(rootWithSep))
+        return void 0;
+      if (relPath.split(/[/\\]/).includes(".."))
+        return void 0;
+      return resolved;
+    }
+    function normalizeOrigin(value) {
+      try {
+        const u = new URL(value.includes("://") ? value : `https://${value}`);
+        return u.origin;
+      } catch {
+        return void 0;
+      }
+    }
+    async function fetchCapped(url, opts) {
+      const controller = new AbortController();
+      const onParentAbort = () => controller.abort();
+      opts.signal?.addEventListener("abort", onParentAbort, { once: true });
+      const timer = setTimeout(() => controller.abort(), opts.timeoutMs);
+      try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok)
+          throw new Error(`overlay fetch returned HTTP ${response.status}`);
+        if (!response.body) {
+          const buf = Buffer.from(await response.arrayBuffer());
+          if (buf.byteLength > opts.maxBytes)
+            throw new Error("overlay file exceeds size cap");
+          return buf;
+        }
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of response.body) {
+          const buf = Buffer.from(chunk);
+          total += buf.byteLength;
+          if (total > opts.maxBytes)
+            throw new Error("overlay file exceeds size cap");
+          chunks.push(buf);
+        }
+        return Buffer.concat(chunks);
+      } finally {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onParentAbort);
+      }
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/workspace/materialize.js
+var require_materialize = __commonJS({
+  "../../packages/shuttle/dist/workspace/materialize.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.registerMaterializer = registerMaterializer;
+    exports2.registerModifier = registerModifier;
+    exports2.materializeWorkspace = materializeWorkspace;
+    var fs_1 = require("fs");
+    var os_1 = __importDefault(require("os"));
+    var path_1 = __importDefault(require("path"));
+    var git_1 = require_git();
+    var overlay_1 = require_overlay();
+    var materializers = /* @__PURE__ */ new Map();
+    var modifiers = /* @__PURE__ */ new Map();
+    function registerMaterializer(provider) {
+      materializers.set(provider.namespace, provider);
+    }
+    function registerModifier(provider) {
+      modifiers.set(provider.namespace, provider);
+    }
+    registerMaterializer(git_1.gitMaterializer);
+    registerModifier(overlay_1.overlayModifier);
+    async function materializeWorkspace(bag, options = {}) {
+      const tmpBase = options.tmpDir ?? os_1.default.tmpdir();
+      const runRoot = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-ws-"));
+      const cleanup = async () => {
+        await fs_1.promises.rm(runRoot, { recursive: true, force: true }).catch(() => {
+        });
+      };
+      let materialized = false;
+      let primaryDir;
+      let warning;
+      let context = [];
+      let ranBase = false;
+      for (const [namespace, provider] of materializers) {
+        if (bag[namespace] !== void 0) {
+          const outcome = await provider.materialize(bag[namespace], runRoot, options);
+          materialized = outcome.materialized;
+          primaryDir = outcome.primaryDir;
+          warning = outcome.warning;
+          context = outcome.context;
+          ranBase = true;
+          break;
+        }
+      }
+      if (!ranBase) {
+        const offered = Object.keys(bag).join(", ") || "(none)";
+        await fs_1.promises.mkdir(path_1.default.join(runRoot, "primary"), { recursive: true }).catch(() => {
+        });
+        warning = `workspace carries no materializer this runner understands (offered: ${offered}; supported: ${[...materializers.keys()].join(", ")})`;
+      }
+      let overlay;
+      for (const [namespace, provider] of modifiers) {
+        if (bag[namespace] !== void 0) {
+          overlay = await provider.apply(bag[namespace], runRoot, options);
+        }
+      }
+      return { cwd: runRoot, materialized, primaryDir, warning, context, overlay, cleanup };
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/workspace/index.js
+var require_workspace = __commonJS({
+  "../../packages/shuttle/dist/workspace/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.applyOverlay = exports2.overlayModifier = exports2.buildGitAuthEnv = exports2.gitMaterializer = exports2.registerModifier = exports2.registerMaterializer = exports2.materializeWorkspace = void 0;
+    var materialize_1 = require_materialize();
+    Object.defineProperty(exports2, "materializeWorkspace", { enumerable: true, get: function() {
+      return materialize_1.materializeWorkspace;
+    } });
+    Object.defineProperty(exports2, "registerMaterializer", { enumerable: true, get: function() {
+      return materialize_1.registerMaterializer;
+    } });
+    Object.defineProperty(exports2, "registerModifier", { enumerable: true, get: function() {
+      return materialize_1.registerModifier;
+    } });
+    var git_1 = require_git();
+    Object.defineProperty(exports2, "gitMaterializer", { enumerable: true, get: function() {
+      return git_1.gitMaterializer;
+    } });
+    Object.defineProperty(exports2, "buildGitAuthEnv", { enumerable: true, get: function() {
+      return git_1.buildGitAuthEnv;
+    } });
+    var overlay_1 = require_overlay();
+    Object.defineProperty(exports2, "overlayModifier", { enumerable: true, get: function() {
+      return overlay_1.overlayModifier;
+    } });
+    Object.defineProperty(exports2, "applyOverlay", { enumerable: true, get: function() {
+      return overlay_1.applyOverlay;
+    } });
+  }
+});
+
+// ../../packages/keep/dist/client.js
+var require_client2 = __commonJS({
+  "../../packages/keep/dist/client.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.KeepClient = void 0;
+    var KeepClient = class {
+      baseUrl;
+      headers;
+      constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.headers = { "Content-Type": "application/json" };
+        if (config.serviceToken) {
+          this.headers["Authorization"] = `Bearer ${config.serviceToken}`;
+        } else if (config.accessToken) {
+          this.headers["Authorization"] = `Bearer ${config.accessToken}`;
+        }
+      }
+      // ── Actor Tokens ────────────────────────────────────────────────
+      /**
+       * Mint a short-lived `act_` token for an end user, with this client's
+       * service identity recorded as the conduit. Requires this client to be
+       * constructed with a service token holding `keep:actor-tokens:write`.
+       */
+      async mintActorToken(actor) {
+        return this.request("POST", "/api/actor-tokens", { actor });
+      }
+      // ── Identity ────────────────────────────────────────────────────
+      async createAccount(email, password, name) {
+        return this.request("POST", "/api/accounts", { email, password, name });
+      }
+      async createSession(email, password) {
+        return this.request("POST", "/api/sessions", { email, password });
+      }
+      async destroySession(refreshToken) {
+        await this.request("DELETE", "/api/sessions", refreshToken ? { refreshToken } : void 0);
+      }
+      async refreshSession(refreshToken) {
+        return this.request("POST", "/api/sessions/renewal", { refreshToken });
+      }
+      async getCurrentUser() {
+        return this.request("GET", "/api/accounts/me");
+      }
+      async updateProfile(updates) {
+        return this.request("PATCH", "/api/accounts/me", updates);
+      }
+      async confirmEmail(email, code) {
+        await this.request("POST", "/api/email-confirmations", { email, code });
+      }
+      async requestVerificationCode(email) {
+        await this.request("POST", "/api/verification-codes", { email });
+      }
+      async requestPasswordReset(email) {
+        await this.request("POST", "/api/password-resets", { email });
+      }
+      async resetPassword(email, code, newPassword) {
+        await this.request("PUT", `/api/password-resets/${code}`, { email, newPassword });
+      }
+      async changePassword(currentPassword, newPassword) {
+        await this.request("PUT", "/api/passwords", { currentPassword, newPassword });
+      }
+      // ── Organizations ───────────────────────────────────────────────
+      async listOrganizations() {
+        const { organizations } = await this.request("GET", "/api/organizations");
+        return organizations;
+      }
+      async getOrganization(orgId) {
+        return this.request("GET", `/api/organizations/${orgId}`);
+      }
+      async createOrganization(name, description) {
+        return this.request("POST", "/api/organizations", { name, description });
+      }
+      async updateOrganization(orgId, updates) {
+        return this.request("PATCH", `/api/organizations/${orgId}`, updates);
+      }
+      async deleteOrganization(orgId) {
+        await this.request("DELETE", `/api/organizations/${orgId}`);
+      }
+      async listMembers(orgId) {
+        return this.request("GET", `/api/organizations/${orgId}/members`);
+      }
+      async removeMember(orgId, userId) {
+        await this.request("DELETE", `/api/organizations/${orgId}/members/${userId}`);
+      }
+      async listTeams(orgId) {
+        return this.request("GET", `/api/organizations/${orgId}/teams`);
+      }
+      async createTeam(orgId, name, description) {
+        return this.request("POST", `/api/organizations/${orgId}/teams`, { name, description });
+      }
+      async listTeamMembers(orgId, teamId) {
+        return this.request("GET", `/api/organizations/${orgId}/teams/${teamId}/members`);
+      }
+      async addTeamMember(orgId, teamId, userId) {
+        return this.request("POST", `/api/organizations/${orgId}/teams/${teamId}/members`, { userId });
+      }
+      async createInvitation(orgId, email, roleGrants) {
+        return this.request("POST", `/api/organizations/${orgId}/invitations`, { email, roleGrants });
       }
       async getInvitation(token) {
         return this.request("GET", `/api/invitations/${token}`);
@@ -18925,6 +19323,252 @@ var require_dist4 = __commonJS({
   }
 });
 
+// ../../packages/shuttle/dist/config/env-ref.js
+var require_env_ref = __commonJS({
+  "../../packages/shuttle/dist/config/env-ref.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveEnvRef = resolveEnvRef;
+    exports2.isEnvRef = isEnvRef;
+    exports2.resolveConfigStringOrEnv = resolveConfigStringOrEnv;
+    var ENV_REF_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+    function resolveEnvRef(value, fieldName) {
+      const match = ENV_REF_PATTERN.exec(value);
+      if (!match)
+        return value;
+      const varName = match[1];
+      const resolved = process.env[varName];
+      if (resolved === void 0 || resolved === "") {
+        const subject = fieldName ? `${fieldName} (${value})` : value;
+        throw new Error(`Environment variable "${varName}" referenced by ${subject} is not set. Export it before starting the Sifter, or hard-code the value in the YAML.`);
+      }
+      return resolved;
+    }
+    function isEnvRef(value) {
+      return ENV_REF_PATTERN.test(value);
+    }
+    function resolveConfigStringOrEnv(config, field, envFallback) {
+      const raw = config[field];
+      if (typeof raw === "string" && raw.length > 0) {
+        return resolveEnvRef(raw, field);
+      }
+      const fromEnv = process.env[envFallback];
+      if (fromEnv && fromEnv.length > 0) {
+        return fromEnv;
+      }
+      throw new Error(`dynamic-key mode requires "${field}" in config or the ${envFallback} env var`);
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/credentials/registry.js
+var require_registry = __commonJS({
+  "../../packages/shuttle/dist/credentials/registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.registerCredentialResolver = registerCredentialResolver;
+    exports2.getCredentialResolver = getCredentialResolver;
+    var resolvers = /* @__PURE__ */ new Map();
+    function registerCredentialResolver(name, resolver) {
+      resolvers.set(name, resolver);
+    }
+    function getCredentialResolver(name) {
+      return resolvers.get(name);
+    }
+    registerCredentialResolver("managed-model-key", async (keep, principal) => {
+      const reveal = await keep.revealManagedSifterKey(principal);
+      return reveal.apiKey;
+    });
+    registerCredentialResolver("github-user-token", async (keep, principal) => {
+      try {
+        const reveal = await keep.getUserGithubToken(principal);
+        return reveal.access_token;
+      } catch {
+        return null;
+      }
+    });
+  }
+});
+
+// ../../packages/shuttle/dist/credentials/broker.js
+var require_broker = __commonJS({
+  "../../packages/shuttle/dist/credentials/broker.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createCredentialBroker = createCredentialBroker;
+    var keep_1 = require_dist4();
+    var env_ref_1 = require_env_ref();
+    var registry_1 = require_registry();
+    function createCredentialBroker(config, deps = {}) {
+      if (typeof config !== "object" || config === null || config.apiKeyFrom !== "job-metadata") {
+        return null;
+      }
+      const cfg = config;
+      const keepApiUrl = (0, env_ref_1.resolveConfigStringOrEnv)(cfg, "keepApiUrl", "KEEP_API_URL");
+      const clientId = (0, env_ref_1.resolveConfigStringOrEnv)(cfg, "keepClientId", "KEEP_CLIENT_ID");
+      const clientSecret = (0, env_ref_1.resolveConfigStringOrEnv)(cfg, "keepClientSecret", "KEEP_CLIENT_SECRET");
+      const stmFactory = deps.buildServiceTokenManager ?? ((c) => new keep_1.ServiceTokenManager(c));
+      const stm = stmFactory({ keepApiUrl, clientId, clientSecret });
+      const keepFactory = deps.buildKeepClient ?? ((c) => new keep_1.KeepClient(c));
+      return {
+        async reveal({ name, principal }) {
+          const resolver = (0, registry_1.getCredentialResolver)(name);
+          if (!resolver)
+            return null;
+          const serviceToken = await stm.getToken();
+          if (!serviceToken) {
+            throw new Error("credential broker: Keep service-token exchange failed. Check KEEP_CLIENT_ID / KEEP_CLIENT_SECRET.");
+          }
+          const keep = keepFactory({ baseUrl: keepApiUrl, serviceToken });
+          return resolver(keep, principal);
+        }
+      };
+    }
+  }
+});
+
+// ../../packages/shuttle/dist/credentials/index.js
+var require_credentials = __commonJS({
+  "../../packages/shuttle/dist/credentials/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getCredentialResolver = exports2.registerCredentialResolver = exports2.createCredentialBroker = void 0;
+    var broker_1 = require_broker();
+    Object.defineProperty(exports2, "createCredentialBroker", { enumerable: true, get: function() {
+      return broker_1.createCredentialBroker;
+    } });
+    var registry_1 = require_registry();
+    Object.defineProperty(exports2, "registerCredentialResolver", { enumerable: true, get: function() {
+      return registry_1.registerCredentialResolver;
+    } });
+    Object.defineProperty(exports2, "getCredentialResolver", { enumerable: true, get: function() {
+      return registry_1.getCredentialResolver;
+    } });
+  }
+});
+
+// ../../packages/shuttle/dist/executors/output-gates.js
+var require_output_gates = __commonJS({
+  "../../packages/shuttle/dist/executors/output-gates.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolvePath = resolvePath;
+    exports2.evaluateOutputGates = evaluateOutputGates;
+    exports2.renderRepairPrompt = renderRepairPrompt;
+    var INPUT_REF = "input:";
+    function resolvePath(root, path) {
+      let ctx = root;
+      for (const seg of path.split(".")) {
+        const project = seg.endsWith("[*]");
+        const key = project ? seg.slice(0, -3) : seg;
+        if (Array.isArray(ctx)) {
+          ctx = ctx.map((el) => key ? el?.[key] : el);
+        } else {
+          ctx = key ? ctx?.[key] : ctx;
+        }
+        if (project && !Array.isArray(ctx)) {
+          ctx = ctx == null ? [] : [ctx];
+        }
+      }
+      return ctx;
+    }
+    function resolveRef(ref, output, inputs) {
+      if (ref.startsWith(INPUT_REF)) {
+        const label = ref.slice(INPUT_REF.length);
+        const row = inputs.find((i) => i.label === label) ?? inputs.find((i) => i.label === "artifacts" && i.payload.label === label);
+        if (!row)
+          return void 0;
+        return Object.prototype.hasOwnProperty.call(row.payload, "value") ? row.payload.value : row.payload;
+      }
+      return resolvePath(output, ref);
+    }
+    function asStrings(value) {
+      if (Array.isArray(value))
+        return value.map((v) => String(v));
+      if (value == null)
+        return [];
+      return [String(value)];
+    }
+    var PRIMITIVES = {
+      /**
+       * `coverage` — the values at `got` must exactly cover the set at `want`:
+       * every wanted value present, nothing invented, none repeated. Params:
+       * `{ got: <output path>, want: <ref>, subject?: <noun> }`.
+       */
+      coverage(params, output, inputs) {
+        const subject = typeof params.subject === "string" ? params.subject : "item";
+        const got = asStrings(resolveRef(String(params.got), output, inputs));
+        const want = asStrings(resolveRef(String(params.want), output, inputs));
+        const gotSet = new Set(got);
+        const wantSet = new Set(want);
+        const missing = want.filter((v) => !gotSet.has(v));
+        const unknown = [...new Set(got.filter((v) => !wantSet.has(v)))];
+        const seen = /* @__PURE__ */ new Set();
+        const duplicated = [];
+        for (const v of got) {
+          if (seen.has(v))
+            duplicated.push(v);
+          else
+            seen.add(v);
+        }
+        if (missing.length === 0 && unknown.length === 0 && duplicated.length === 0)
+          return [];
+        const parts = [];
+        if (missing.length)
+          parts.push(`missing ${subject}(s): [${missing.join(", ")}]`);
+        if (unknown.length)
+          parts.push(`not a known ${subject}: [${unknown.join(", ")}]`);
+        if (duplicated.length)
+          parts.push(`assessed more than once: [${[...new Set(duplicated)].join(", ")}]`);
+        return [
+          `every ${subject} must be covered exactly once \u2014 ${parts.join("; ")}. Return one entry per ${subject}, using its exact id.`
+        ];
+      },
+      /**
+       * `non_empty_when` — the array at `path` must be non-empty, optionally only
+       * when `when.path` equals `when.equals`. Params:
+       * `{ path: <output path>, when?: { path: <output path>, equals: <value> } }`.
+       */
+      non_empty_when(params, output) {
+        const when = params.when;
+        if (when && typeof when.path === "string") {
+          if (resolvePath(output, when.path) !== when.equals)
+            return [];
+        }
+        const path = String(params.path);
+        const value = resolvePath(output, path);
+        if (Array.isArray(value) && value.length > 0)
+          return [];
+        const cond = when && typeof when.path === "string" ? ` when ${when.path} is ${JSON.stringify(when.equals)}` : "";
+        return [
+          `'${path}' must be a non-empty array${cond}; it was ${Array.isArray(value) ? "empty" : "absent"}.`
+        ];
+      }
+    };
+    function evaluateOutputGates(gates, output, inputs) {
+      const findings = [];
+      for (const gate of gates) {
+        const primitive = PRIMITIVES[gate.primitive];
+        if (!primitive) {
+          findings.push({ gate: gate.name, message: `unknown gate primitive '${gate.primitive}'` });
+          continue;
+        }
+        for (const message of primitive(gate.params, output, inputs)) {
+          findings.push({ gate: gate.name, message });
+        }
+      }
+      return { ok: findings.length === 0, findings };
+    }
+    function renderRepairPrompt(findings) {
+      return [
+        "Your previous answer did not satisfy these output checks. Return the corrected, complete answer that resolves every item below. Produce the same output shape with the problems fixed, and nothing else \u2014 no commentary, no explanation of the changes.",
+        "",
+        ...findings.map((f) => `- [${f.gate}] ${f.message}`)
+      ].join("\n");
+    }
+  }
+});
+
 // ../../packages/shuttle/dist/logging/logger.js
 var require_logger = __commonJS({
   "../../packages/shuttle/dist/logging/logger.js"(exports2) {
@@ -18958,614 +19602,251 @@ var require_logger = __commonJS({
         message,
         ...context
       };
-      return JSON.stringify(entry);
-    }
-    function createLogger(options) {
-      const threshold = LEVEL_ORDER[options.level];
-      const format = options.format === "json" ? formatJson : formatPretty;
-      function emit(level, message, context) {
-        if (LEVEL_ORDER[level] < threshold)
-          return;
-        const line = format(level, message, context);
-        if (level === "error") {
-          console.error(line);
-        } else if (level === "warn") {
-          console.warn(line);
-        } else {
-          console.log(line);
-        }
-      }
-      return {
-        debug: (message, context) => emit("debug", message, context),
-        info: (message, context) => emit("info", message, context),
-        warn: (message, context) => emit("warn", message, context),
-        error: (message, context) => emit("error", message, context)
-      };
-    }
-    var globalLogger = createLogger({ level: "info", format: "pretty" });
-    function setGlobalLogger(logger) {
-      globalLogger = logger;
-    }
-    function getLogger() {
-      return globalLogger;
-    }
-  }
-});
-
-// ../../packages/shuttle/dist/executors/registry.js
-var require_registry = __commonJS({
-  "../../packages/shuttle/dist/executors/registry.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ExecutorRegistry = void 0;
-    var ExecutorRegistry = class {
-      factories = /* @__PURE__ */ new Map();
-      allowlist;
-      constructor(allowlist = ["*"]) {
-        this.allowlist = allowlist;
-      }
-      register(name, factory) {
-        if (!this.isAllowed(name)) {
-          throw new Error(`Executor "${name}" is not enabled for this build. Allowed executors: ${this.allowlist.join(", ")}`);
-        }
-        this.factories.set(name, factory);
-      }
-      create(name, config) {
-        const factory = this.factories.get(name);
-        if (!factory) {
-          throw new Error(`Executor not registered: ${name}`);
-        }
-        return factory(config, name);
-      }
-      has(name) {
-        return this.factories.has(name);
-      }
-      get allowedExecutors() {
-        return this.allowlist;
-      }
-      /** All registered factories as JobExecutors built with their default config. */
-      build(configs) {
-        const out = [];
-        for (const [name, cfg] of Object.entries(configs)) {
-          if (!this.factories.has(name)) {
-            throw new Error(`Executor "${name}" in config is not registered or not enabled for this build.`);
-          }
-          out.push(this.create(name, cfg));
-        }
-        return out;
-      }
-      isAllowed(name) {
-        return this.allowlist[0] === "*" || this.allowlist.includes(name);
-      }
-    };
-    exports2.ExecutorRegistry = ExecutorRegistry;
-  }
-});
-
-// ../../packages/shuttle/dist/executors/validate-output.js
-var require_validate_output = __commonJS({
-  "../../packages/shuttle/dist/executors/validate-output.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.assertOutputValid = assertOutputValid;
-    var loom_1 = require_dist3();
-    function assertOutputValid(spec, parsed) {
-      const { valid, errors } = (0, loom_1.validateAgainstSchema)(parsed ?? null, spec.outputSchema);
-      if (!valid) {
-        throw new Error(`prompt-execution output failed schema validation: ${errors.join("; ")}`);
-      }
-    }
-  }
-});
-
-// ../../packages/shuttle/dist/executors/progress.js
-var require_progress = __commonJS({
-  "../../packages/shuttle/dist/executors/progress.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.StreamJsonTap = exports2.ProgressReporter = void 0;
-    var ProgressReporter = class {
-      sink;
-      seq = 0;
-      pending = [];
-      textBuf = "";
-      timer = null;
-      closed = false;
-      flushMs;
-      maxChars;
-      constructor(sink, options = {}) {
-        this.sink = sink;
-        this.flushMs = options.flushMs ?? 400;
-        this.maxChars = options.maxChars ?? 1200;
-      }
-      reasoning(text) {
-        if (this.closed || !text)
-          return;
-        this.textBuf += text;
-        if (this.textBuf.length >= this.maxChars) {
-          this.flush();
-        } else {
-          this.arm();
-        }
-      }
-      tool(name, target) {
-        if (this.closed || !name)
-          return;
-        this.drainText();
-        this.push({ kind: "tool", tool: target ? { name, target } : { name } });
-        this.flush();
-      }
-      /** Flush pending text + frames now. */
-      flush() {
-        if (this.closed)
-          return;
-        this.drainText();
-        this.clearTimer();
-        if (this.pending.length === 0)
-          return;
-        const batch = this.pending;
-        this.pending = [];
-        try {
-          this.sink(batch);
-        } catch {
-        }
-      }
-      /** Final flush; no further frames are emitted after this. */
-      close() {
-        this.flush();
-        this.closed = true;
-        this.clearTimer();
-      }
-      drainText() {
-        if (this.textBuf.length === 0)
-          return;
-        this.push({ kind: "reasoning", text: this.textBuf });
-        this.textBuf = "";
-      }
-      push(frame) {
-        this.pending.push({ seq: this.seq++, at: (/* @__PURE__ */ new Date()).toISOString(), ...frame });
-      }
-      arm() {
-        if (this.timer)
-          return;
-        this.timer = setTimeout(() => {
-          this.timer = null;
-          this.flush();
-        }, this.flushMs);
-        this.timer.unref?.();
-      }
-      clearTimer() {
-        if (this.timer) {
-          clearTimeout(this.timer);
-          this.timer = null;
-        }
-      }
-    };
-    exports2.ProgressReporter = ProgressReporter;
-    var StreamJsonTap = class {
-      handlers;
-      buf = "";
-      constructor(handlers) {
-        this.handlers = handlers;
-      }
-      /** Feed a raw stdout chunk. Emits handlers for every complete line parsed. */
-      push(chunk) {
-        this.buf += chunk;
-        let nl;
-        while ((nl = this.buf.indexOf("\n")) !== -1) {
-          const line = this.buf.slice(0, nl);
-          this.buf = this.buf.slice(nl + 1);
-          this.consumeLine(line);
-        }
-      }
-      /** Flush a trailing partial line (best-effort; usually empty at process close). */
-      end() {
-        if (this.buf.trim().length > 0)
-          this.consumeLine(this.buf);
-        this.buf = "";
-      }
-      consumeLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("{"))
-          return;
-        let event;
-        try {
-          event = JSON.parse(trimmed);
-        } catch {
-          return;
-        }
-        if (event.type === "assistant") {
-          const content = event.message?.content;
-          if (!Array.isArray(content))
-            return;
-          for (const block of content) {
-            const b = block;
-            if (b?.type === "text" && typeof b.text === "string" && b.text.length > 0) {
-              this.handlers.onReasoning?.(b.text);
-            } else if (b?.type === "thinking" && typeof b.thinking === "string" && b.thinking.length > 0) {
-              this.handlers.onReasoning?.(b.thinking);
-            } else if (b?.type === "tool_use" && typeof b.name === "string") {
-              this.handlers.onTool?.(b.name, toolTarget(b.input));
-            }
-          }
-        } else if (event.type === "result") {
-          this.handlers.onResult?.();
+      return JSON.stringify(entry);
+    }
+    function createLogger(options) {
+      const threshold = LEVEL_ORDER[options.level];
+      const format = options.format === "json" ? formatJson : formatPretty;
+      function emit(level, message, context) {
+        if (LEVEL_ORDER[level] < threshold)
+          return;
+        const line = format(level, message, context);
+        if (level === "error") {
+          console.error(line);
+        } else if (level === "warn") {
+          console.warn(line);
+        } else {
+          console.log(line);
         }
       }
-    };
-    exports2.StreamJsonTap = StreamJsonTap;
-    function toolTarget(input) {
-      if (!input)
-        return void 0;
-      for (const key of ["file_path", "path", "pattern", "command", "url", "query", "notebook_path"]) {
-        const v = input[key];
-        if (typeof v === "string" && v.length > 0)
-          return v;
-      }
-      return void 0;
+      return {
+        debug: (message, context) => emit("debug", message, context),
+        info: (message, context) => emit("info", message, context),
+        warn: (message, context) => emit("warn", message, context),
+        error: (message, context) => emit("error", message, context)
+      };
+    }
+    var globalLogger = createLogger({ level: "info", format: "pretty" });
+    function setGlobalLogger(logger) {
+      globalLogger = logger;
+    }
+    function getLogger() {
+      return globalLogger;
     }
   }
 });
 
-// ../../packages/shuttle/dist/executors/workspace.js
-var require_workspace = __commonJS({
-  "../../packages/shuttle/dist/executors/workspace.js"(exports2) {
+// ../../packages/shuttle/dist/executors/registry.js
+var require_registry2 = __commonJS({
+  "../../packages/shuttle/dist/executors/registry.js"(exports2) {
     "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.prepareWorkspace = prepareWorkspace;
-    exports2.buildGitAuthEnv = buildGitAuthEnv;
-    var child_process_1 = require("child_process");
-    var fs_1 = require("fs");
-    var os_1 = __importDefault(require("os"));
-    var path_1 = __importDefault(require("path"));
-    var DEFAULT_GIT_TIMEOUT_MS = 12e4;
-    var DEFAULT_GIT_PROTOCOLS = "https:ssh:git";
-    async function prepareWorkspace(workspace, options = {}) {
-      const tmpBase = options.tmpDir ?? os_1.default.tmpdir();
-      const resolved = readGitWorkspace(workspace);
-      if ("warning" in resolved) {
-        return degradedWorkspace(resolved.warning, tmpBase);
+    exports2.ExecutorRegistry = void 0;
+    var ExecutorRegistry = class {
+      factories = /* @__PURE__ */ new Map();
+      allowlist;
+      constructor(allowlist = ["*"]) {
+        this.allowlist = allowlist;
       }
-      const gitWorkspace = resolved.git;
-      const timeoutMs = options.commandTimeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
-      const allowedProtocols = options.allowedProtocols ?? DEFAULT_GIT_PROTOCOLS;
-      const signal = options.signal;
-      const authEnv = options.gitToken !== void 0 ? buildGitAuthEnv(gitWorkspace.remote, options.gitToken) : void 0;
-      const git = (args, cwd) => runGit(args, cwd, { timeoutMs, signal, allowedProtocols, extraEnv: authEnv });
-      const hasCommit = (dir) => git(["cat-file", "-e", `${gitWorkspace.commit}^{commit}`], dir).then((r) => r.code === 0);
-      const fetchCommit = async (dir, opts) => {
-        if (await hasCommit(dir))
-          return [];
-        const depth = opts.shallow ? ["--depth=1"] : [];
-        const attempts = [];
-        for (const ref of gitWorkspace.fetchRefs ?? []) {
-          attempts.push({
-            source: `${gitWorkspace.remote} ${ref}`,
-            args: ["fetch", "--no-tags", ...depth, gitWorkspace.remote, ref]
-          });
-        }
-        attempts.push({
-          source: `${gitWorkspace.remote} commit`,
-          args: ["fetch", "--no-tags", ...depth, gitWorkspace.remote, gitWorkspace.commit]
-        });
-        const failures2 = [];
-        for (const { source, args } of attempts) {
-          const result = await git(args, dir);
-          if (result.code !== 0) {
-            failures2.push(`${source}: ${firstLine(result.stderr)}`);
-            continue;
-          }
-          if (await hasCommit(dir))
-            return [];
-          failures2.push(`${source}: fetch succeeded but ${gitWorkspace.commit} is still absent`);
+      register(name, factory) {
+        if (!this.isAllowed(name)) {
+          throw new Error(`Executor "${name}" is not enabled for this build. Allowed executors: ${this.allowlist.join(", ")}`);
         }
-        return failures2;
-      };
-      const notMaterialized = (failures2) => `could not materialize ${gitWorkspace.commit} from ${gitWorkspace.remote}` + (failures2.length > 0 ? ` (${failures2.join("; ")})` : "");
-      const tempRoot = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-ws-"));
-      const checkoutDir = path_1.default.join(tempRoot, "checkout");
-      const removeTempRoot = async () => {
-        await fs_1.promises.rm(tempRoot, { recursive: true, force: true }).catch(() => {
-        });
-      };
-      await fs_1.promises.mkdir(checkoutDir);
-      const init = await git(["init", "-q"], checkoutDir);
-      if (init.code !== 0) {
-        await removeTempRoot();
-        return degradedWorkspace(`git init failed: ${firstLine(init.stderr)}`, tmpBase);
-      }
-      const failures = await fetchCommit(checkoutDir, { shallow: true });
-      if (!await hasCommit(checkoutDir)) {
-        await removeTempRoot();
-        return degradedWorkspace(notMaterialized(failures), tmpBase);
-      }
-      const checkout = await git(["checkout", "--detach", gitWorkspace.commit], checkoutDir);
-      if (checkout.code !== 0) {
-        await removeTempRoot();
-        return degradedWorkspace(`git checkout failed: ${firstLine(checkout.stderr)}`, tmpBase);
-      }
-      return { cwd: checkoutDir, materialized: true, cleanup: removeTempRoot };
-    }
-    function buildGitAuthEnv(remote, token) {
-      let origin;
-      try {
-        const url = new URL(remote);
-        if (url.protocol !== "https:")
-          return void 0;
-        origin = `${url.protocol}//${url.host}/`;
-      } catch {
-        return void 0;
-      }
-      const basic = Buffer.from(`x-access-token:${token}`).toString("base64");
-      return {
-        GIT_CONFIG_COUNT: "1",
-        GIT_CONFIG_KEY_0: `http.${origin}.extraheader`,
-        GIT_CONFIG_VALUE_0: `Authorization: Basic ${basic}`
-      };
-    }
-    var COMMIT_PATTERN = /^[0-9a-f]{40}$/i;
-    var REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9/_.@^~+-]*$/;
-    function readGitWorkspace(workspace) {
-      const git = workspace.git;
-      if (git === void 0) {
-        const offered = Object.keys(workspace).join(", ") || "(none)";
-        return {
-          warning: `workspace carries no namespace this executor understands (offered: ${offered}; supported: git)`
-        };
+        this.factories.set(name, factory);
       }
-      if (typeof git.remote !== "string" || git.remote.length === 0 || git.remote.startsWith("-")) {
-        return { warning: "workspace.git.remote must be a non-empty remote URL or path" };
+      create(name, config) {
+        const factory = this.factories.get(name);
+        if (!factory) {
+          throw new Error(`Executor not registered: ${name}`);
+        }
+        return factory(config, name);
       }
-      if (typeof git.commit !== "string" || !COMMIT_PATTERN.test(git.commit)) {
-        return { warning: "workspace.git.commit must be a full 40-char commit SHA" };
+      has(name) {
+        return this.factories.has(name);
       }
-      if (git.fetchRefs !== void 0) {
-        if (!Array.isArray(git.fetchRefs) || !git.fetchRefs.every((r) => typeof r === "string")) {
-          return { warning: "workspace.git.fetchRefs must be an array of ref strings" };
-        }
-        const bad = git.fetchRefs.find((r) => !REF_PATTERN.test(r));
-        if (bad !== void 0) {
-          return { warning: `workspace.git.fetchRefs contains an invalid ref: ${JSON.stringify(bad)}` };
-        }
+      get allowedExecutors() {
+        return this.allowlist;
       }
-      return { git };
-    }
-    async function degradedWorkspace(warning, tmpBase = os_1.default.tmpdir()) {
-      const scratchDir = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-ws-degraded-"));
-      return {
-        cwd: scratchDir,
-        materialized: false,
-        warning,
-        cleanup: async () => {
-          await fs_1.promises.rm(scratchDir, { recursive: true, force: true }).catch(() => {
-          });
-        }
-      };
-    }
-    function runGit(args, cwd, opts) {
-      return new Promise((resolve) => {
-        const child = (0, child_process_1.spawn)("git", args, {
-          cwd,
-          stdio: ["ignore", "pipe", "pipe"],
-          // `extraEnv` (e.g. the credential extraheader) goes first so the two
-          // security-critical vars below always win and can't be overridden.
-          env: {
-            ...process.env,
-            ...opts.extraEnv ?? {},
-            GIT_TERMINAL_PROMPT: "0",
-            // Transport allowlist. `remote` passes readGitWorkspace as any
-            // non-empty non-`-` string, which still admits `ext::sh -c …` and
-            // `fd::` remotes that execute arbitrary commands on this host.
-            // Restricting to the transports we actually use turns those into a
-            // fast failure (→ degrade) rather than RCE across the boundary this
-            // executor is meant to defend.
-            GIT_ALLOW_PROTOCOL: opts.allowedProtocols
+      /** All registered factories as JobExecutors built with their default config. */
+      build(configs) {
+        const out = [];
+        for (const [name, cfg] of Object.entries(configs)) {
+          if (!this.factories.has(name)) {
+            throw new Error(`Executor "${name}" in config is not registered or not enabled for this build.`);
           }
-        });
-        const stdout = [];
-        const stderr = [];
-        let settled = false;
-        const settle = (result) => {
-          if (settled)
-            return;
-          settled = true;
-          clearTimeout(timer);
-          opts.signal?.removeEventListener("abort", onAbort);
-          resolve(result);
-        };
-        const killChild = () => {
-          child.kill("SIGTERM");
-          const escalate = setTimeout(() => child.kill("SIGKILL"), 5e3);
-          escalate.unref();
-          child.once("close", () => clearTimeout(escalate));
-        };
-        const timer = setTimeout(() => {
-          killChild();
-          settle({
-            code: -1,
-            stdout: Buffer.concat(stdout).toString("utf-8"),
-            stderr: `git ${args[0]} timed out after ${opts.timeoutMs}ms`
-          });
-        }, opts.timeoutMs);
-        const onAbort = () => {
-          killChild();
-          settle({
-            code: -1,
-            stdout: Buffer.concat(stdout).toString("utf-8"),
-            stderr: "aborted"
-          });
-        };
-        if (opts.signal?.aborted) {
-          onAbort();
-          return;
+          out.push(this.create(name, cfg));
         }
-        opts.signal?.addEventListener("abort", onAbort, { once: true });
-        child.stdout.on("data", (c) => stdout.push(c));
-        child.stderr.on("data", (c) => stderr.push(c));
-        child.on("error", (err) => settle({ code: -1, stdout: "", stderr: err.message }));
-        child.on("close", (code) => settle({
-          code: code ?? -1,
-          stdout: Buffer.concat(stdout).toString("utf-8"),
-          stderr: Buffer.concat(stderr).toString("utf-8")
-        }));
-      });
-    }
-    function firstLine(text) {
-      const line = text.trim().split("\n", 1)[0];
-      return line.length > 0 ? line : "(no output)";
+        return out;
+      }
+      isAllowed(name) {
+        return this.allowlist[0] === "*" || this.allowlist.includes(name);
+      }
+    };
+    exports2.ExecutorRegistry = ExecutorRegistry;
+  }
+});
+
+// ../../packages/shuttle/dist/executors/validate-output.js
+var require_validate_output = __commonJS({
+  "../../packages/shuttle/dist/executors/validate-output.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.assertOutputValid = assertOutputValid;
+    var loom_1 = require_dist3();
+    function assertOutputValid(spec, parsed) {
+      const { valid, errors } = (0, loom_1.validateAgainstSchema)(parsed ?? null, spec.outputSchema);
+      if (!valid) {
+        throw new Error(`prompt-execution output failed schema validation: ${errors.join("; ")}`);
+      }
     }
   }
 });
 
-// ../../packages/shuttle/dist/executors/overlay.js
-var require_overlay = __commonJS({
-  "../../packages/shuttle/dist/executors/overlay.js"(exports2) {
+// ../../packages/shuttle/dist/executors/progress.js
+var require_progress = __commonJS({
+  "../../packages/shuttle/dist/executors/progress.js"(exports2) {
     "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.applyOverlay = applyOverlay;
-    var fs_1 = require("fs");
-    var path_1 = __importDefault(require("path"));
-    var DEFAULT_TIMEOUT_MS = 3e4;
-    var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
-    async function applyOverlay(runDir, overlay, options) {
-      const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-      const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-      const allowed = new Set(options.allowedHosts.map(normalizeOrigin).filter((o) => !!o));
-      const rootReal = await fs_1.promises.realpath(runDir);
-      const result = { written: 0, writtenPaths: [], skipped: [] };
-      const files = Array.isArray(overlay.files) ? overlay.files : [];
-      for (const file of files) {
-        const skip = (reason) => result.skipped.push({ path: String(file?.path ?? "?"), reason });
-        if (typeof file?.path !== "string" || typeof file?.url !== "string") {
-          skip("malformed overlay entry (path/url must be strings)");
-          continue;
-        }
-        const dest = safeDestination(rootReal, file.path);
-        if (!dest) {
-          skip("path escapes the workspace root");
-          continue;
-        }
-        let origin;
-        try {
-          const u = new URL(file.url);
-          if (u.protocol !== "https:" && u.protocol !== "http:") {
-            skip(`unsupported url protocol ${u.protocol}`);
-            continue;
-          }
-          origin = normalizeOrigin(u.origin);
-        } catch {
-          skip("invalid url");
-          continue;
-        }
-        if (!origin || !allowed.has(origin)) {
-          skip(`origin not in the overlay allowlist (${origin})`);
-          continue;
+    exports2.StreamJsonTap = exports2.ProgressReporter = void 0;
+    var ProgressReporter = class {
+      sink;
+      seq = 0;
+      pending = [];
+      textBuf = "";
+      timer = null;
+      closed = false;
+      flushMs;
+      maxChars;
+      constructor(sink, options = {}) {
+        this.sink = sink;
+        this.flushMs = options.flushMs ?? 400;
+        this.maxChars = options.maxChars ?? 1200;
+      }
+      reasoning(text) {
+        if (this.closed || !text)
+          return;
+        this.textBuf += text;
+        if (this.textBuf.length >= this.maxChars) {
+          this.flush();
+        } else {
+          this.arm();
         }
+      }
+      tool(name, target) {
+        if (this.closed || !name)
+          return;
+        this.drainText();
+        this.push({ kind: "tool", tool: target ? { name, target } : { name } });
+        this.flush();
+      }
+      /** Flush pending text + frames now. */
+      flush() {
+        if (this.closed)
+          return;
+        this.drainText();
+        this.clearTimer();
+        if (this.pending.length === 0)
+          return;
+        const batch = this.pending;
+        this.pending = [];
         try {
-          const content = await fetchCapped(file.url, { timeoutMs, maxBytes, signal: options.signal });
-          await fs_1.promises.mkdir(path_1.default.dirname(dest), { recursive: true });
-          await fs_1.promises.writeFile(dest, content);
-          result.written += 1;
-          result.writtenPaths.push(file.path);
-        } catch (err) {
-          skip(err instanceof Error ? err.message : String(err));
+          this.sink(batch);
+        } catch {
         }
       }
-      return result;
-    }
-    function safeDestination(rootReal, relPath) {
-      if (relPath.length === 0 || path_1.default.isAbsolute(relPath))
-        return void 0;
-      const resolved = path_1.default.resolve(rootReal, relPath);
-      const rootWithSep = rootReal.endsWith(path_1.default.sep) ? rootReal : rootReal + path_1.default.sep;
-      if (resolved !== rootReal && !resolved.startsWith(rootWithSep))
-        return void 0;
-      if (relPath.split(/[/\\]/).includes(".."))
-        return void 0;
-      return resolved;
-    }
-    function normalizeOrigin(value) {
-      try {
-        const u = new URL(value.includes("://") ? value : `https://${value}`);
-        return u.origin;
-      } catch {
-        return void 0;
+      /** Final flush; no further frames are emitted after this. */
+      close() {
+        this.flush();
+        this.closed = true;
+        this.clearTimer();
       }
-    }
-    async function fetchCapped(url, opts) {
-      const controller = new AbortController();
-      const onParentAbort = () => controller.abort();
-      opts.signal?.addEventListener("abort", onParentAbort, { once: true });
-      const timer = setTimeout(() => controller.abort(), opts.timeoutMs);
-      try {
-        const response = await fetch(url, { signal: controller.signal });
-        if (!response.ok) {
-          throw new Error(`overlay fetch returned HTTP ${response.status}`);
-        }
-        if (!response.body) {
-          const buf = Buffer.from(await response.arrayBuffer());
-          if (buf.byteLength > opts.maxBytes)
-            throw new Error("overlay file exceeds size cap");
-          return buf;
+      drainText() {
+        if (this.textBuf.length === 0)
+          return;
+        this.push({ kind: "reasoning", text: this.textBuf });
+        this.textBuf = "";
+      }
+      push(frame) {
+        this.pending.push({ seq: this.seq++, at: (/* @__PURE__ */ new Date()).toISOString(), ...frame });
+      }
+      arm() {
+        if (this.timer)
+          return;
+        this.timer = setTimeout(() => {
+          this.timer = null;
+          this.flush();
+        }, this.flushMs);
+        this.timer.unref?.();
+      }
+      clearTimer() {
+        if (this.timer) {
+          clearTimeout(this.timer);
+          this.timer = null;
         }
-        const chunks = [];
-        let total = 0;
-        for await (const chunk of response.body) {
-          const buf = Buffer.from(chunk);
-          total += buf.byteLength;
-          if (total > opts.maxBytes)
-            throw new Error("overlay file exceeds size cap");
-          chunks.push(buf);
+      }
+    };
+    exports2.ProgressReporter = ProgressReporter;
+    var StreamJsonTap = class {
+      handlers;
+      buf = "";
+      constructor(handlers) {
+        this.handlers = handlers;
+      }
+      /** Feed a raw stdout chunk. Emits handlers for every complete line parsed. */
+      push(chunk) {
+        this.buf += chunk;
+        let nl;
+        while ((nl = this.buf.indexOf("\n")) !== -1) {
+          const line = this.buf.slice(0, nl);
+          this.buf = this.buf.slice(nl + 1);
+          this.consumeLine(line);
         }
-        return Buffer.concat(chunks);
-      } finally {
-        clearTimeout(timer);
-        opts.signal?.removeEventListener("abort", onParentAbort);
       }
-    }
-  }
-});
-
-// ../../packages/shuttle/dist/config/env-ref.js
-var require_env_ref = __commonJS({
-  "../../packages/shuttle/dist/config/env-ref.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolveEnvRef = resolveEnvRef;
-    exports2.isEnvRef = isEnvRef;
-    exports2.resolveConfigStringOrEnv = resolveConfigStringOrEnv;
-    var ENV_REF_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
-    function resolveEnvRef(value, fieldName) {
-      const match = ENV_REF_PATTERN.exec(value);
-      if (!match)
-        return value;
-      const varName = match[1];
-      const resolved = process.env[varName];
-      if (resolved === void 0 || resolved === "") {
-        const subject = fieldName ? `${fieldName} (${value})` : value;
-        throw new Error(`Environment variable "${varName}" referenced by ${subject} is not set. Export it before starting the Sifter, or hard-code the value in the YAML.`);
+      /** Flush a trailing partial line (best-effort; usually empty at process close). */
+      end() {
+        if (this.buf.trim().length > 0)
+          this.consumeLine(this.buf);
+        this.buf = "";
       }
-      return resolved;
-    }
-    function isEnvRef(value) {
-      return ENV_REF_PATTERN.test(value);
-    }
-    function resolveConfigStringOrEnv(config, field, envFallback) {
-      const raw = config[field];
-      if (typeof raw === "string" && raw.length > 0) {
-        return resolveEnvRef(raw, field);
+      consumeLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+          return;
+        let event;
+        try {
+          event = JSON.parse(trimmed);
+        } catch {
+          return;
+        }
+        if (event.type === "assistant") {
+          const content = event.message?.content;
+          if (!Array.isArray(content))
+            return;
+          for (const block of content) {
+            const b = block;
+            if (b?.type === "text" && typeof b.text === "string" && b.text.length > 0) {
+              this.handlers.onReasoning?.(b.text);
+            } else if (b?.type === "thinking" && typeof b.thinking === "string" && b.thinking.length > 0) {
+              this.handlers.onReasoning?.(b.thinking);
+            } else if (b?.type === "tool_use" && typeof b.name === "string") {
+              this.handlers.onTool?.(b.name, toolTarget(b.input));
+            }
+          }
+        } else if (event.type === "result") {
+          this.handlers.onResult?.();
+        }
       }
-      const fromEnv = process.env[envFallback];
-      if (fromEnv && fromEnv.length > 0) {
-        return fromEnv;
+    };
+    exports2.StreamJsonTap = StreamJsonTap;
+    function toolTarget(input) {
+      if (!input)
+        return void 0;
+      for (const key of ["file_path", "path", "pattern", "command", "url", "query", "notebook_path"]) {
+        const v = input[key];
+        if (typeof v === "string" && v.length > 0)
+          return v;
       }
-      throw new Error(`dynamic-key mode requires "${field}" in config or the ${envFallback} env var`);
+      return void 0;
     }
   }
 });
@@ -19588,12 +19869,8 @@ var require_claude_code = __commonJS({
     var path_1 = __importDefault(require("path"));
     var string_decoder_1 = require("string_decoder");
     var loom_1 = require_dist3();
-    var keep_1 = require_dist4();
     var validate_output_1 = require_validate_output();
     var progress_1 = require_progress();
-    var workspace_1 = require_workspace();
-    var overlay_1 = require_overlay();
-    var env_ref_1 = require_env_ref();
     var apply_1 = require_apply();
     var DEFAULT_TIMEOUT = 6e5;
     var ClaudeCodeExecutor = class {
@@ -19611,47 +19888,49 @@ var require_claude_code = __commonJS({
           outputTokens: spec.costCapHint?.estimatedOutputTokens
         };
       }
+      /**
+       * Declare the run environment to the runner (ADR 0026): the opaque workspace
+       * bag plus the materialization config (tmp dir, overlay allowlist). No
+       * credentials here (ADR 0027) — the runner's broker reveals them on demand:
+       * this executor pulls its model key from `ctx.credentials` in `execute()`,
+       * and the git request references its own fetch credential. The executor
+       * touches neither git nor Keep.
+       */
+      async prepareEnvironment(dispatch) {
+        const spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : void 0;
+        return {
+          ...spec.workspace ? { workspaceRequest: spec.workspace } : {},
+          materializeOptions: {
+            ...tmpBase ? { tmpDir: tmpBase } : {},
+            overlayAllowedHosts: this.config.overlayAllowedHosts ?? []
+          }
+        };
+      }
       async execute(dispatch, signal, ctx) {
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
-        let credentials = null;
-        if (this.config.resolveCredentials) {
+        const workspace = ctx?.workspace ?? null;
+        let modelKey = null;
+        if (ctx?.credentials) {
           const hints = (0, loom_1.pickProviderHints)(spec, "anthropic-api");
           const customerId = typeof hints.customerId === "string" ? hints.customerId : void 0;
           if (!customerId) {
             throw new Error("claude-code dynamic-key mode requires providerHints.anthropicApi.customerId on every job");
           }
-          credentials = await this.config.resolveCredentials({
-            customerId,
-            needGithubToken: !!spec.workspace
-          });
+          modelKey = await ctx.credentials.reveal({ name: "managed-model-key", principal: customerId });
         }
         let jobScratch = null;
         let configDir;
-        if (credentials) {
+        if (modelKey) {
           jobScratch = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "shuttle-cc-"));
           configDir = path_1.default.join(jobScratch, "claude-config");
           await fs_1.promises.mkdir(configDir);
         }
         const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
-        let workspace = null;
         let promptOnlyScratch = null;
-        let overlayResult = null;
         const reporter = spec.progressChannel && ctx?.reportProgress ? new progress_1.ProgressReporter((frames) => ctx.reportProgress(spec.progressChannel, frames)) : null;
         try {
-          if (spec.workspace) {
-            workspace = await (0, workspace_1.prepareWorkspace)(spec.workspace, {
-              signal,
-              tmpDir: tmpBase,
-              ...credentials?.githubToken ? { gitToken: credentials.githubToken } : {}
-            });
-            if (spec.workspace.overlay) {
-              overlayResult = await (0, overlay_1.applyOverlay)(workspace.cwd, spec.workspace.overlay, {
-                allowedHosts: this.config.overlayAllowedHosts ?? [],
-                signal
-              });
-            }
-          }
-          const childEnv = buildChildEnv(credentials, configDir);
+          const childEnv = buildChildEnv(modelKey, configDir);
           const claudeHints = (0, loom_1.pickProviderHints)(spec, "claude-code");
           const hintedModel = typeof claudeHints.model === "string" && claudeHints.model.length > 0 ? claudeHints.model : void 0;
           if (!workspace) {
@@ -19661,7 +19940,7 @@ var require_claude_code = __commonJS({
           const { response, readPaths, toolText } = await this.runClaude(prompt, spec, runCwd, childEnv, signal, hintedModel, reporter);
           if (workspace) {
             const reads = [...readPaths];
-            for (const rel of overlayResult?.writtenPaths ?? []) {
+            for (const rel of workspace.overlay?.writtenPaths ?? []) {
               if (toolText.includes(rel))
                 reads.push(path_1.default.join(runCwd, rel));
             }
@@ -19674,10 +19953,17 @@ var require_claude_code = __commonJS({
               content: {
                 materialized: workspace.materialized,
                 ...workspace.warning ? { warning: workspace.warning } : {},
-                ...overlayResult ? {
+                ...workspace.context.length > 0 ? {
+                  context: workspace.context.map((c) => ({
+                    name: c.requestedName,
+                    materialized: c.materialized,
+                    ...c.warning ? { warning: c.warning } : {}
+                  }))
+                } : {},
+                ...workspace.overlay ? {
                   overlay: {
-                    written: overlayResult.written,
-                    ...overlayResult.skipped.length > 0 ? { skipped: overlayResult.skipped } : {}
+                    written: workspace.overlay.written,
+                    ...workspace.overlay.skipped.length > 0 ? { skipped: workspace.overlay.skipped } : {}
                   }
                 } : {}
               }
@@ -19686,8 +19972,6 @@ var require_claude_code = __commonJS({
           return response;
         } finally {
           reporter?.close();
-          if (workspace)
-            await workspace.cleanup();
           if (promptOnlyScratch)
             await fs_1.promises.rm(promptOnlyScratch, { recursive: true, force: true }).catch(() => {
             });
@@ -19767,18 +20051,27 @@ var require_claude_code = __commonJS({
             onResult: () => reporter.flush()
           }) : null;
           const decoder = tap ? new string_decoder_1.StringDecoder("utf8") : null;
+          child.stdin.write(prompt);
+          child.stdin.end();
+          const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
+          let timer;
+          const armIdleTimer = () => {
+            if (settled)
+              return;
+            if (timer)
+              clearTimeout(timer);
+            timer = setTimeout(() => {
+              child.kill("SIGTERM");
+              settle(() => reject(new Error(`Claude Code produced no output for ${timeout}ms; killed as hung`)));
+            }, timeout);
+          };
+          armIdleTimer();
           child.stdout.on("data", (chunk) => {
             stdoutChunks.push(chunk);
+            armIdleTimer();
             if (tap && decoder)
               tap.push(decoder.write(chunk));
           });
-          child.stdin.write(prompt);
-          child.stdin.end();
-          const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
-          const timer = setTimeout(() => {
-            child.kill("SIGTERM");
-            settle(() => reject(new Error(`Claude Code timed out after ${timeout}ms`)));
-          }, timeout);
           function onAbort() {
             child.kill("SIGTERM");
             settle(() => reject(new Error("Dispatch aborted")));
@@ -19850,7 +20143,7 @@ var require_claude_code = __commonJS({
         });
       }
     };
-    function createClaudeCodeExecutor(config, capabilityId = "claude-code", deps = {}) {
+    function createClaudeCodeExecutor(config, capabilityId = "claude-code") {
       const validated = { capabilityId };
       if (config.tmpDir !== void 0) {
         if (typeof config.tmpDir !== "string" || config.tmpDir.length === 0) {
@@ -19881,9 +20174,6 @@ var require_claude_code = __commonJS({
         }
         validated.timeout = config.timeout;
       }
-      if (config.apiKeyFrom !== void 0) {
-        validated.resolveCredentials = buildCredentialResolver(config, deps);
-      }
       if (config.overlayAllowedHosts !== void 0) {
         if (!Array.isArray(config.overlayAllowedHosts) || !config.overlayAllowedHosts.every((h) => typeof h === "string")) {
           throw new Error('"overlayAllowedHosts" must be an array of strings');
@@ -19892,43 +20182,15 @@ var require_claude_code = __commonJS({
       }
       return new ClaudeCodeExecutor(validated);
     }
-    function buildChildEnv(credentials, configDir) {
-      if (!credentials && !configDir)
+    function buildChildEnv(modelKey, configDir) {
+      if (!modelKey && !configDir)
         return void 0;
       return {
         ...process.env,
-        ...credentials ? { ANTHROPIC_API_KEY: credentials.anthropicApiKey } : {},
+        ...modelKey ? { ANTHROPIC_API_KEY: modelKey } : {},
         ...configDir ? { CLAUDE_CONFIG_DIR: configDir } : {}
       };
     }
-    function buildCredentialResolver(config, deps) {
-      if (config.apiKeyFrom !== "job-metadata") {
-        throw new Error(`Unsupported "apiKeyFrom" value: ${JSON.stringify(config.apiKeyFrom)}. Only "job-metadata" is supported.`);
-      }
-      const keepApiUrl = (0, env_ref_1.resolveConfigStringOrEnv)(config, "keepApiUrl", "KEEP_API_URL");
-      const clientId = (0, env_ref_1.resolveConfigStringOrEnv)(config, "keepClientId", "KEEP_CLIENT_ID");
-      const clientSecret = (0, env_ref_1.resolveConfigStringOrEnv)(config, "keepClientSecret", "KEEP_CLIENT_SECRET");
-      const stmFactory = deps.buildServiceTokenManager ?? ((cfg) => new keep_1.ServiceTokenManager(cfg));
-      const stm = stmFactory({ keepApiUrl, clientId, clientSecret });
-      const keepClientFactory = deps.buildKeepClient ?? ((cfg) => new keep_1.KeepClient(cfg));
-      return async ({ customerId, needGithubToken }) => {
-        const serviceToken = await stm.getToken();
-        if (!serviceToken) {
-          throw new Error("claude-code dynamic-key mode failed to exchange a Keep service token. Check KEEP_CLIENT_ID / KEEP_CLIENT_SECRET.");
-        }
-        const keep = keepClientFactory({ baseUrl: keepApiUrl, serviceToken });
-        const reveal = await keep.revealManagedSifterKey(customerId);
-        const credentials = { anthropicApiKey: reveal.apiKey };
-        if (needGithubToken) {
-          try {
-            const gh = await keep.getUserGithubToken(customerId);
-            credentials.githubToken = gh.access_token;
-          } catch {
-          }
-        }
-        return credentials;
-      };
-    }
     function parseStreamJson(stdout) {
       let finalText = null;
       const readPaths = [];
@@ -21173,12 +21435,14 @@ var require_shuttle = __commonJS({
     var decommission_1 = require_decommission();
     var loom_1 = require_dist3();
     var chain_1 = require_chain();
+    var workspace_1 = require_workspace();
+    var credentials_1 = require_credentials();
     var output_gates_1 = require_output_gates();
     var keep_1 = require_dist4();
     var apply_1 = require_apply();
     var version_check_1 = require_version_check();
     var logger_1 = require_logger();
-    var registry_1 = require_registry();
+    var registry_1 = require_registry2();
     var claude_code_1 = require_claude_code();
     var http_api_1 = require_http_api();
     var anthropic_api_1 = require_anthropic_api();
@@ -21223,12 +21487,20 @@ var require_shuttle = __commonJS({
       brand;
       config;
       profile;
+      credentialDeps;
       subscription = null;
       spendTracker = null;
+      /**
+       * The runner-owned credential broker (ADR 0027), built once from the
+       * `credentials` config (the reveal service identity). Null in local mode
+       * (no such config) → consumers reveal nothing and use ambient credentials.
+       */
+      broker = null;
       constructor(options) {
         this.brand = options.brand;
         this.config = options.config;
         this.profile = options.profile ?? apply_1.DEFAULT_PROFILE;
+        this.credentialDeps = options.credentialDeps ?? {};
       }
       /** Exposed so the CLI's `caps set` can reload after a write. */
       get spendTrackerHandle() {
@@ -21242,6 +21514,7 @@ var require_shuttle = __commonJS({
         const logger = (0, logger_1.getLogger)();
         logger.info(`${this.brand.product.title} starting...`);
         const paths = (0, apply_1.resolvePaths)(this.brand, this.profile);
+        this.broker = (0, credentials_1.createCredentialBroker)(this.config.credentials, this.credentialDeps);
         const enforceMinVersion = (response) => {
           (0, version_check_1.checkResponseMinVersion)({
             response,
@@ -21315,11 +21588,30 @@ var require_shuttle = __commonJS({
           }
           await observerChain.notify({ kind: "executor.dispatch.started", jobId, attendanceId, executor: executor.capability.id, strategy }, onObserverError);
           const dispatchStartedAt = Date.now();
+          const environment = executor.prepareEnvironment ? await executor.prepareEnvironment(dispatch) : void 0;
+          let preparedWorkspace = null;
+          if (environment?.workspaceRequest) {
+            try {
+              preparedWorkspace = await (0, workspace_1.materializeWorkspace)(environment.workspaceRequest, {
+                ...environment.materializeOptions ?? {},
+                credentials: this.broker,
+                signal
+              });
+            } catch (err) {
+              (0, logger_1.getLogger)().warn("workspace materialization failed; running prompt-only", {
+                jobId,
+                error: err instanceof Error ? err.message : String(err)
+              });
+              preparedWorkspace = null;
+            }
+          }
           const executionCtx = {
             reportProgress: (channel, frames) => {
               void jobsClient.postProgress(jobId, { channel, frames }).then(() => activity.record()).catch(() => {
               });
-            }
+            },
+            workspace: preparedWorkspace,
+            credentials: this.broker
           };
           let response;
           try {
@@ -21328,6 +21620,9 @@ var require_shuttle = __commonJS({
             const reason = `executor failed: ${err instanceof Error ? err.message : String(err)}`;
             await observerChain.notify({ kind: "attendance.closed", jobId, attendanceId, status: "failed", reason, totalDurationMs: Date.now() - startedAt }, onObserverError);
             return { status: "failed", reason };
+          } finally {
+            if (preparedWorkspace)
+              await preparedWorkspace.cleanup();
           }
           const gated = await runOutputGates(dispatch, response, executor, signal, executionCtx);
           if (!gated.ok) {
@@ -21911,7 +22206,7 @@ var require_dist5 = __commonJS({
     Object.defineProperty(exports2, "AgentCredentialRevokedError", { enumerable: true, get: function() {
       return keep_1.AgentCredentialRevokedError;
     } });
-    var registry_1 = require_registry();
+    var registry_1 = require_registry2();
     Object.defineProperty(exports2, "ExecutorRegistry", { enumerable: true, get: function() {
       return registry_1.ExecutorRegistry;
     } });
@@ -22007,7 +22302,7 @@ var import_path = require("path");
 var import_promises = require("fs/promises");
 var import_yaml = __toESM(require_dist());
 var import_shuttle = __toESM(require_dist5());
-var buildVersion = true ? "0.20.0" : pkg.version;
+var buildVersion = true ? "0.22.0" : pkg.version;
 var sifterBrand = {
   product: {
     id: "sifter",