@whittlelabs/sifter 0.7.0 → 0.8.0

package/bin.js

@@ -15665,6 +15665,21 @@ var require_prompt_execution = __commonJS({
       if (typeof spec.outputSchema !== "object" || spec.outputSchema === null) {
         throw new Error("prompt-execution: spec.outputSchema must be a JSON Schema object");
       }
+      if (spec.workspace !== void 0) {
+        const ws = spec.workspace;
+        if (typeof ws !== "object" || ws === null || Array.isArray(ws)) {
+          throw new Error("prompt-execution: spec.workspace must be an object when present");
+        }
+        const namespaces = Object.entries(ws);
+        if (namespaces.length === 0) {
+          throw new Error("prompt-execution: spec.workspace must carry at least one namespace");
+        }
+        for (const [name, value] of namespaces) {
+          if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error(`prompt-execution: spec.workspace.${name} must be an object`);
+          }
+        }
+      }
       return spec;
     }
     function renderPromptExecution(inputs) {
@@ -15876,6 +15891,8 @@ var require_prompt_execution2 = __commonJS({
         outputLabel: options.output.label,
         outputSchema: options.output.schema
       };
+      if (options.workspace)
+        spec.workspace = options.workspace;
       if (options.providerHints)
         spec.providerHints = options.providerHints;
       if (options.costCapHint)
@@ -18418,6 +18435,17 @@ var require_client2 = __commonJS({
       async getManagedSifterStatus(userId) {
         return this.request("GET", `/api/users/${encodeURIComponent(userId)}/managed-sifter-status`);
       }
+      // ── GitHub OAuth token ──────────────────────────────────────────
+      /**
+       * Reveal a user's decrypted GitHub OAuth token for a service-to-service
+       * call on their behalf (e.g. the hosted Sifter cloning the repo under
+       * review). Service-token only; requires `keep:oauth-tokens:read`. Treat
+       * the returned token as a single-use, in-memory secret. Throws (404 →
+       * NotFound) when the user has not connected GitHub.
+       */
+      async getUserGithubToken(userId) {
+        return this.request("GET", `/api/users/${encodeURIComponent(userId)}/github-token`);
+      }
       // ── HTTP ────────────────────────────────────────────────────────
       async request(method, path, body) {
         const url = `${this.baseUrl}${path}`;
@@ -18516,7 +18544,15 @@ var require_agent_token = __commonJS({
   "../../packages/keep/dist/agent-token.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.AgentTokenManager = void 0;
+    exports2.AgentTokenManager = exports2.AgentCredentialRevokedError = void 0;
+    var AgentCredentialRevokedError2 = class extends Error {
+      code = "PAIRING_REVOKED";
+      constructor(message) {
+        super(message);
+        this.name = "AgentCredentialRevokedError";
+      }
+    };
+    exports2.AgentCredentialRevokedError = AgentCredentialRevokedError2;
     var AgentTokenManager = class {
       token = null;
       expiresAt = 0;
@@ -18563,6 +18599,9 @@ var require_agent_token = __commonJS({
         const json = await response.json();
         if (!response.ok || !json.success) {
           const msg = json.error?.message ?? `Agent token exchange failed with status ${response.status}`;
+          if (response.status === 401) {
+            throw new AgentCredentialRevokedError2(`[AgentTokenManager] Keep refused this agent's credentials (401): the pairing was revoked or the secret rotated. Re-pair to continue.`);
+          }
           throw new Error(`[AgentTokenManager] ${msg}`);
         }
         this.token = json.data.token;
@@ -18579,7 +18618,7 @@ var require_dist4 = __commonJS({
   "../../packages/keep/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.AgentTokenManager = exports2.ServiceTokenManager = exports2.KeepClient = void 0;
+    exports2.AgentCredentialRevokedError = exports2.AgentTokenManager = exports2.ServiceTokenManager = exports2.KeepClient = void 0;
     var client_1 = require_client2();
     Object.defineProperty(exports2, "KeepClient", { enumerable: true, get: function() {
       return client_1.KeepClient;
@@ -18592,6 +18631,9 @@ var require_dist4 = __commonJS({
     Object.defineProperty(exports2, "AgentTokenManager", { enumerable: true, get: function() {
       return agent_token_1.AgentTokenManager;
     } });
+    Object.defineProperty(exports2, "AgentCredentialRevokedError", { enumerable: true, get: function() {
+      return agent_token_1.AgentCredentialRevokedError;
+    } });
   }
 });
 
@@ -18728,15 +18770,415 @@ var require_validate_output = __commonJS({
   }
 });
 
+// ../../packages/shuttle/dist/executors/workspace.js
+var require_workspace = __commonJS({
+  "../../packages/shuttle/dist/executors/workspace.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(repoDir, workspace, options = {}) {
+      const resolved = readGitWorkspace(workspace);
+      if ("warning" in resolved) {
+        return degradedWorkspace(resolved.warning);
+      }
+      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 gitCleanup = (args, cwd) => runGit(args, cwd, { timeoutMs, allowedProtocols });
+      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 ?? []) {
+          if (opts.includeOrigin) {
+            attempts.push({ source: `origin ${ref}`, args: ["fetch", "--no-tags", ...depth, "origin", ref] });
+          }
+          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`);
+        }
+        return failures2;
+      };
+      const notMaterialized = (failures2) => `could not materialize ${gitWorkspace.commit} from ${gitWorkspace.remote}` + (failures2.length > 0 ? ` (${failures2.join("; ")})` : "");
+      const isRepo = (await git(["rev-parse", "--git-dir"], repoDir)).code === 0;
+      if (isRepo) {
+        const failures2 = await fetchCommit(repoDir, { includeOrigin: true, shallow: false });
+        if (!await hasCommit(repoDir))
+          return degradedWorkspace(notMaterialized(failures2));
+        const tempRoot2 = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "shuttle-ws-"));
+        const worktreeDir = path_1.default.join(tempRoot2, "checkout");
+        const add = await git(["worktree", "add", "--detach", worktreeDir, gitWorkspace.commit], repoDir);
+        if (add.code !== 0) {
+          await fs_1.promises.rm(tempRoot2, { recursive: true, force: true }).catch(() => {
+          });
+          return degradedWorkspace(`git worktree add failed: ${firstLine(add.stderr)}`);
+        }
+        return {
+          cwd: worktreeDir,
+          materialized: true,
+          cleanup: async () => {
+            await gitCleanup(["worktree", "remove", "--force", worktreeDir], repoDir);
+            await gitCleanup(["worktree", "prune"], repoDir);
+            await fs_1.promises.rm(tempRoot2, { recursive: true, force: true }).catch(() => {
+            });
+          }
+        };
+      }
+      const tempRoot = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "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)}`);
+      }
+      const failures = await fetchCommit(checkoutDir, { includeOrigin: false, shallow: true });
+      if (!await hasCommit(checkoutDir)) {
+        await removeTempRoot();
+        return degradedWorkspace(notMaterialized(failures));
+      }
+      const checkout = await git(["checkout", "--detach", gitWorkspace.commit], checkoutDir);
+      if (checkout.code !== 0) {
+        await removeTempRoot();
+        return degradedWorkspace(`git checkout failed: ${firstLine(checkout.stderr)}`);
+      }
+      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)`
+        };
+      }
+      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" };
+      }
+      if (typeof git.commit !== "string" || !COMMIT_PATTERN.test(git.commit)) {
+        return { warning: "workspace.git.commit must be a full 40-char commit SHA" };
+      }
+      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)}` };
+        }
+      }
+      return { git };
+    }
+    async function degradedWorkspace(warning) {
+      const scratchDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "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
+          }
+        });
+        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/executors/overlay.js
+var require_overlay = __commonJS({
+  "../../packages/shuttle/dist/executors/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.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, 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;
+        }
+        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;
+        } 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/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/executors/claude-code.js
 var require_claude_code = __commonJS({
   "../../packages/shuttle/dist/executors/claude-code.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.createClaudeCodeExecutor = createClaudeCodeExecutor;
+    exports2.extractJsonObject = extractJsonObject;
     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 loom_1 = require_dist3();
+    var keep_1 = require_dist4();
     var validate_output_1 = require_validate_output();
+    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 {
@@ -18754,13 +19196,77 @@ var require_claude_code = __commonJS({
           outputTokens: spec.costCapHint?.estimatedOutputTokens
         };
       }
-      execute(dispatch, signal) {
+      async execute(dispatch, signal) {
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
+        let credentials = null;
+        if (this.config.resolveCredentials) {
+          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
+          });
+        }
+        let jobScratch = null;
+        let configDir;
+        if (credentials) {
+          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);
+        }
+        let workspace = null;
+        let overlayResult = null;
+        try {
+          if (spec.workspace) {
+            workspace = await (0, workspace_1.prepareWorkspace)(this.config.cwd, spec.workspace, {
+              signal,
+              ...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 claudeHints = (0, loom_1.pickProviderHints)(spec, "claude-code");
+          const hintedModel = typeof claudeHints.model === "string" && claudeHints.model.length > 0 ? claudeHints.model : void 0;
+          const response = await this.runClaude(prompt, spec, workspace?.cwd ?? this.config.cwd, childEnv, signal, hintedModel);
+          if (workspace) {
+            response.outputs.push({
+              label: "workspace",
+              content: {
+                materialized: workspace.materialized,
+                ...workspace.warning ? { warning: workspace.warning } : {},
+                ...overlayResult ? {
+                  overlay: {
+                    written: overlayResult.written,
+                    ...overlayResult.skipped.length > 0 ? { skipped: overlayResult.skipped } : {}
+                  }
+                } : {}
+              }
+            });
+          }
+          return response;
+        } finally {
+          if (workspace)
+            await workspace.cleanup();
+          if (jobScratch)
+            await fs_1.promises.rm(jobScratch, { recursive: true, force: true }).catch(() => {
+            });
+        }
+      }
+      runClaude(prompt, spec, cwd, childEnv, signal, modelOverride) {
         const outputLabel = spec.outputLabel;
         return new Promise((resolve, reject) => {
           const args = ["--print"];
-          if (this.config.model)
-            args.push("--model", this.config.model);
+          const model = modelOverride ?? this.config.model;
+          if (model)
+            args.push("--model", model);
           if (this.config.maxTurns !== void 0)
             args.push("--max-turns", String(this.config.maxTurns));
           if (this.config.allowedTools && this.config.allowedTools.length > 0) {
@@ -18769,8 +19275,11 @@ var require_claude_code = __commonJS({
           let child;
           try {
             child = (0, child_process_1.spawn)("claude", args, {
-              cwd: this.config.cwd,
-              stdio: ["pipe", "pipe", "pipe"]
+              cwd,
+              stdio: ["pipe", "pipe", "pipe"],
+              // Undefined in local mode → inherit the ambient env (and its
+              // `~/.claude` login) unchanged.
+              ...childEnv ? { env: childEnv } : {}
             });
           } catch (err) {
             reject(err);
@@ -18813,14 +19322,18 @@ var require_claude_code = __commonJS({
             signal.removeEventListener("abort", onAbort);
             const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
             if (code === 0) {
-              const parsed = safeJsonParse(stdout);
-              (0, validate_output_1.assertOutputValid)(spec, parsed);
-              settle(() => resolve({
-                outputs: [{ label: outputLabel, content: parsed ?? { raw: stdout } }],
-                rawText: stdout,
-                parsed,
-                usage: this.config.model ? { aiProvider: "claude-code", aiModel: this.config.model } : void 0
-              }));
+              try {
+                const parsed = extractJsonObject(stdout);
+                (0, validate_output_1.assertOutputValid)(spec, parsed);
+                settle(() => resolve({
+                  outputs: [{ label: outputLabel, content: parsed ?? { raw: stdout } }],
+                  rawText: stdout,
+                  parsed,
+                  usage: this.config.model ? { aiProvider: "claude-code", aiModel: this.config.model } : void 0
+                }));
+              } catch (err) {
+                settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+              }
             } else {
               settle(() => reject(new Error(`Claude Code exited with code ${code}`)));
             }
@@ -18828,7 +19341,7 @@ var require_claude_code = __commonJS({
         });
       }
     };
-    function createClaudeCodeExecutor(config, capabilityId = "claude-code") {
+    function createClaudeCodeExecutor(config, capabilityId = "claude-code", deps = {}) {
       const cwdRaw = config.cwd;
       if (typeof cwdRaw !== "string" || cwdRaw.length === 0) {
         throw new Error('ClaudeCodeExecutor requires a non-empty "cwd" string in config');
@@ -18858,12 +19371,108 @@ 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');
+        }
+        validated.overlayAllowedHosts = config.overlayAllowedHosts;
+      }
       return new ClaudeCodeExecutor(validated);
     }
-    function safeJsonParse(s) {
+    function buildChildEnv(credentials, configDir) {
+      if (!credentials && !configDir)
+        return void 0;
+      return {
+        ...process.env,
+        ...credentials ? { ANTHROPIC_API_KEY: credentials.anthropicApiKey } : {},
+        ...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 extractJsonObject(s) {
+      const exact = tryParseObject(s);
+      if (exact)
+        return exact;
+      let last;
+      let i = 0;
+      while (i < s.length) {
+        if (s[i] !== "{") {
+          i++;
+          continue;
+        }
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let end = -1;
+        for (let j = i; j < s.length; j++) {
+          const ch = s[j];
+          if (escaped) {
+            escaped = false;
+            continue;
+          }
+          if (ch === "\\") {
+            escaped = inString;
+            continue;
+          }
+          if (ch === '"') {
+            inString = !inString;
+            continue;
+          }
+          if (inString)
+            continue;
+          if (ch === "{")
+            depth++;
+          else if (ch === "}") {
+            depth--;
+            if (depth === 0) {
+              end = j;
+              break;
+            }
+          }
+        }
+        if (end === -1)
+          break;
+        const candidate = tryParseObject(s.slice(i, end + 1));
+        if (candidate)
+          last = candidate;
+        i = end + 1;
+      }
+      return last;
+    }
+    function tryParseObject(s) {
       try {
         const parsed = JSON.parse(s);
-        return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
       } catch {
         return void 0;
       }
@@ -19024,32 +19633,6 @@ var require_http_api = __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;
-    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);
-    }
-  }
-});
-
 // ../../packages/shuttle/dist/executors/anthropic-api.js
 var require_anthropic_api = __commonJS({
   "../../packages/shuttle/dist/executors/anthropic-api.js"(exports2) {
@@ -19085,8 +19668,9 @@ var require_anthropic_api = __commonJS({
         const outputLabel = spec.outputLabel;
         const providerHints = (0, loom_1.pickProviderHints)(spec, this.instance.capabilityId);
         const apiKey = await this.instance.resolveKey(providerHints);
+        const hintedModel = providerHints.model;
         const body = {
-          model: this.instance.model,
+          model: typeof hintedModel === "string" && hintedModel.length > 0 ? hintedModel : this.instance.model,
           max_tokens: this.instance.maxTokens,
           messages: [{ role: "user", content: prompt }]
         };
@@ -19113,6 +19697,12 @@ var require_anthropic_api = __commonJS({
               bodyText = await response.text();
             } catch {
             }
+            const envelope = bodyText ? safeJsonParse(bodyText) : void 0;
+            const apiErr = envelope?.error;
+            if (apiErr?.message) {
+              const kind = apiErr.type ? ` (${apiErr.type})` : "";
+              throw new Error(`Anthropic API error${kind}: ${apiErr.message} [HTTP ${response.status}]`);
+            }
             throw new Error(`HTTP ${response.status}${bodyText ? `: ${bodyText}` : ""}`);
           }
           const data = await response.json();
@@ -19194,9 +19784,9 @@ var require_anthropic_api = __commonJS({
       if (config.apiKeyFrom !== "job-metadata") {
         throw new Error(`Unsupported "apiKeyFrom" value: ${JSON.stringify(config.apiKeyFrom)}. Only "job-metadata" is supported in v0.2.`);
       }
-      const keepApiUrl = resolveStringConfig(config, "keepApiUrl", "KEEP_API_URL");
-      const clientId = resolveStringConfig(config, "keepClientId", "KEEP_CLIENT_ID");
-      const clientSecret = resolveStringConfig(config, "keepClientSecret", "KEEP_CLIENT_SECRET");
+      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));
@@ -19215,17 +19805,6 @@ var require_anthropic_api = __commonJS({
         return reveal.apiKey;
       };
     }
-    function resolveStringConfig(config, field, envFallback) {
-      const raw = config[field];
-      if (typeof raw === "string" && raw.length > 0) {
-        return (0, env_ref_1.resolveEnvRef)(raw, field);
-      }
-      const fromEnv = process.env[envFallback];
-      if (fromEnv && fromEnv.length > 0) {
-        return fromEnv;
-      }
-      throw new Error(`AnthropicApiExecutor dynamic-key mode requires "${field}" in config or the ${envFallback} env var`);
-    }
     function safeJsonParse(s) {
       try {
         const parsed = JSON.parse(s);
@@ -20590,7 +21169,7 @@ var require_dist5 = __commonJS({
   "../../packages/shuttle/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.revokePairing = exports2.listPairings = exports2.PairingConfigStore = exports2.pair = exports2.DEFAULT_REFUSAL_MESSAGE = exports2.DEFAULT_MONTHLY_PERIOD = exports2.DEFAULT_DAILY_PERIOD = exports2.SUBSTRATE_BRAND = exports2.renderTemplate = exports2.expandHome = exports2.resolvePaths = exports2.SpendStore = exports2.AuditLogStore = exports2.createSpendTrackerObserver = exports2.createAuditLogObserver = exports2.createLoggerObserver = exports2.SpendCapExceeded = exports2.ObserverChain = exports2.createCustomScriptExecutor = exports2.createWebhookExecutor = exports2.createHttpApiExecutor = exports2.createClaudeCodeExecutor = exports2.ExecutorRegistry = exports2.checkResponseMinVersion = exports2.compareSemver = exports2.UpgradeRequiredError = exports2.MIN_VERSION_HEADER = exports2.loadConfig = exports2.Shuttle = exports2.createCli = void 0;
+    exports2.revokePairing = exports2.listPairings = exports2.PairingConfigStore = exports2.pair = exports2.DEFAULT_REFUSAL_MESSAGE = exports2.DEFAULT_MONTHLY_PERIOD = exports2.DEFAULT_DAILY_PERIOD = exports2.SUBSTRATE_BRAND = exports2.renderTemplate = exports2.expandHome = exports2.resolvePaths = exports2.SpendStore = exports2.AuditLogStore = exports2.createSpendTrackerObserver = exports2.createAuditLogObserver = exports2.createLoggerObserver = exports2.SpendCapExceeded = exports2.ObserverChain = exports2.createCustomScriptExecutor = exports2.createWebhookExecutor = exports2.createHttpApiExecutor = exports2.createClaudeCodeExecutor = exports2.ExecutorRegistry = exports2.AgentCredentialRevokedError = exports2.checkResponseMinVersion = exports2.compareSemver = exports2.UpgradeRequiredError = exports2.MIN_VERSION_HEADER = exports2.loadConfig = exports2.Shuttle = exports2.createCli = void 0;
     var cli_1 = require_cli();
     Object.defineProperty(exports2, "createCli", { enumerable: true, get: function() {
       return cli_1.createCli;
@@ -20616,6 +21195,10 @@ var require_dist5 = __commonJS({
     Object.defineProperty(exports2, "checkResponseMinVersion", { enumerable: true, get: function() {
       return version_check_1.checkResponseMinVersion;
     } });
+    var keep_1 = require_dist4();
+    Object.defineProperty(exports2, "AgentCredentialRevokedError", { enumerable: true, get: function() {
+      return keep_1.AgentCredentialRevokedError;
+    } });
     var registry_1 = require_registry();
     Object.defineProperty(exports2, "ExecutorRegistry", { enumerable: true, get: function() {
       return registry_1.ExecutorRegistry;
@@ -20717,7 +21300,7 @@ var import_shuttle = __toESM(require_dist5());
 // package.json
 var package_default = {
   name: "@whittlelabs/sifter",
-  version: "0.7.0",
+  version: "0.8.0",
   description: "Whittle Sifter: paired AI reviewer for Whittle Sift job pools.",
   bin: {
     "whittle-sifter": "./dist/bin.js"
@@ -20901,6 +21484,17 @@ async function promptForCwd(prompt, fallback) {
     console.error("");
     process.exit(2);
   }
+  if (err instanceof import_shuttle2.AgentCredentialRevokedError) {
+    console.error("");
+    console.error(`This ${sifterBrand.product.title}'s pairing has been revoked.`);
+    console.error("");
+    console.error("Keep refused its credentials \u2014 it was decommissioned from the");
+    console.error("web app, or its secret was rotated by a newer pairing.");
+    console.error("");
+    console.error(`Run \`${sifterBrand.product.command} init\` to pair again.`);
+    console.error("");
+    process.exit(3);
+  }
   const message = err instanceof Error ? err.message : String(err);
   console.error(`Fatal: ${message}`);
   process.exit(1);