@whittlelabs/sifter 0.15.0 → 0.17.0

package/bin.js

@@ -15420,6 +15420,15 @@ var require_client = __commonJS({
       async createOutput(jobId, options) {
         return this.request("POST", `/api/jobs/${jobId}/output`, options);
       }
+      /**
+       * Post a batch of live progress frames for a running job. Best-effort
+       * telemetry: the service publishes it over core NATS and never derives
+       * authoritative state from it, so callers should swallow failures rather than
+       * let a dropped frame affect the job.
+       */
+      async postProgress(jobId, options) {
+        await this.request("POST", `/api/jobs/${jobId}/progress`, options);
+      }
       // ── Attendance (subscriber dispatch lifecycle) ───────────────────
       /**
        * Accept a dispatched job. The subscribe loop calls this; direct
@@ -15722,8 +15731,12 @@ var require_self_update = __commonJS({
       });
     }
     function defaultRespawn() {
-      const child = (0, child_process_1.spawn)(process.execPath, process.argv.slice(1), { stdio: "inherit" });
-      child.on("exit", (code) => process.exit(code ?? 0));
+      const child = (0, child_process_1.spawn)(process.execPath, process.argv.slice(1), {
+        detached: true,
+        stdio: "inherit"
+      });
+      child.unref();
+      process.exit(0);
     }
   }
 });
@@ -15790,6 +15803,17 @@ var require_prompt_execution = __commonJS({
           }
         }
       }
+      if (spec.gates !== void 0) {
+        if (!Array.isArray(spec.gates)) {
+          throw new Error("prompt-execution: spec.gates must be an array when present");
+        }
+        for (const gate of spec.gates) {
+          const g = gate;
+          if (typeof gate !== "object" || gate === null || typeof g.name !== "string" || typeof g.primitive !== "string" || typeof g.params !== "object" || g.params === null) {
+            throw new Error("prompt-execution: each spec.gates entry must be { name, primitive, params }");
+          }
+        }
+      }
       return spec;
     }
     function renderPromptExecution(inputs) {
@@ -16007,6 +16031,10 @@ var require_prompt_execution2 = __commonJS({
         spec.providerHints = options.providerHints;
       if (options.costCapHint)
         spec.costCapHint = options.costCapHint;
+      if (options.progressChannel !== void 0)
+        spec.progressChannel = options.progressChannel;
+      if (options.outputGates && options.outputGates.length > 0)
+        spec.gates = options.outputGates;
       if (options.rendering === "producer" && !options.prompt) {
         throw new Error("rendering='producer' requires `prompt`");
       }
@@ -18066,6 +18094,7 @@ var require_canonicalise = __commonJS({
           promptTemplate: templateText,
           promptTemplatePath: promptOptions.promptTemplate,
           outputSchema: toJsonSchema(promptOptions.outputSchema),
+          ...promptOptions.outputGates ? { outputGates: promptOptions.outputGates } : {},
           outputLabel,
           rendering: promptOptions.rendering,
           ...promptOptions.maxAttempts !== void 0 ? { maxAttempts: promptOptions.maxAttempts } : {},
@@ -18348,6 +18377,128 @@ var require_chain = __commonJS({
   }
 });
 
+// ../../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/keep/dist/client.js
 var require_client2 = __commonJS({
   "../../packages/keep/dist/client.js"(exports2) {
@@ -18880,6 +19031,155 @@ var require_validate_output = __commonJS({
   }
 });
 
+// ../../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?.();
+        }
+      }
+    };
+    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;
+    }
+  }
+});
+
 // ../../packages/shuttle/dist/executors/workspace.js
 var require_workspace = __commonJS({
   "../../packages/shuttle/dist/executors/workspace.js"(exports2) {
@@ -19111,7 +19411,7 @@ var require_overlay = __commonJS({
       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 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 });
@@ -19145,6 +19445,7 @@ var require_overlay = __commonJS({
           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));
         }
@@ -19258,9 +19559,11 @@ var require_claude_code = __commonJS({
     var fs_1 = require("fs");
     var os_1 = __importDefault(require("os"));
     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();
@@ -19281,7 +19584,7 @@ var require_claude_code = __commonJS({
           outputTokens: spec.costCapHint?.estimatedOutputTokens
         };
       }
-      async execute(dispatch, signal) {
+      async execute(dispatch, signal, ctx) {
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
         let credentials = null;
         if (this.config.resolveCredentials) {
@@ -19306,6 +19609,7 @@ var require_claude_code = __commonJS({
         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, {
@@ -19327,11 +19631,16 @@ var require_claude_code = __commonJS({
             promptOnlyScratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-run-"));
           }
           const runCwd = workspace?.cwd ?? promptOnlyScratch;
-          const { response, readPaths } = await this.runClaude(prompt, spec, runCwd, childEnv, signal, hintedModel);
+          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 ?? []) {
+              if (toolText.includes(rel))
+                reads.push(path_1.default.join(runCwd, rel));
+            }
             response.outputs.push({
               label: "workspace_reads",
-              content: { paths: relativeWorkspaceReads(readPaths, runCwd) }
+              content: { paths: relativeWorkspaceReads(reads, runCwd) }
             });
             response.outputs.push({
               label: "workspace",
@@ -19349,6 +19658,7 @@ var require_claude_code = __commonJS({
           }
           return response;
         } finally {
+          reporter?.close();
           if (workspace)
             await workspace.cleanup();
           if (promptOnlyScratch)
@@ -19359,11 +19669,40 @@ var require_claude_code = __commonJS({
             });
         }
       }
-      runClaude(prompt, spec, cwd, childEnv, signal, modelOverride) {
+      /**
+       * In-session gate repair (ADR 0017): resume the session `execute()` returned a
+       * handle for and correct its output. The repair turn works from the resumed
+       * session's own context (no checkout needed), under the same `--json-schema`
+       * constraint. A throwaway cwd hosts the run; the same handle rides back out so
+       * a second repair round can resume again.
+       */
+      async continue(continuation, followUp, signal, _ctx) {
+        const handle = continuation;
+        if (!handle || typeof handle.sessionId !== "string") {
+          throw new Error("claude-code continue: missing session to resume");
+        }
+        const tmpBase = this.config.tmpDir ? (0, apply_1.expandHome)(this.config.tmpDir) : os_1.default.tmpdir();
+        const scratch = await fs_1.promises.mkdtemp(path_1.default.join(tmpBase, "shuttle-cc-resume-"));
+        try {
+          const spec = {
+            rendering: "producer",
+            outputLabel: handle.outputLabel,
+            outputSchema: handle.outputSchema
+          };
+          const { response } = await this.runClaude(followUp, spec, scratch, handle.childEnv, signal, handle.model, null, handle.sessionId);
+          return response;
+        } finally {
+          await fs_1.promises.rm(scratch, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+      runClaude(prompt, spec, cwd, childEnv, signal, modelOverride, reporter, resumeSessionId) {
         const outputLabel = spec.outputLabel;
         const model = modelOverride ?? this.config.model;
         return new Promise((resolve, reject) => {
           const args = ["--print", "--output-format", "stream-json", "--verbose"];
+          if (resumeSessionId)
+            args.push("--resume", resumeSessionId);
           if (spec.outputSchema && typeof spec.outputSchema === "object" && Object.keys(spec.outputSchema).length > 0) {
             args.push("--json-schema", JSON.stringify(spec.outputSchema));
           }
@@ -19395,7 +19734,17 @@ var require_claude_code = __commonJS({
             settled = true;
             fn();
           };
-          child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+          const tap = reporter ? new progress_1.StreamJsonTap({
+            onReasoning: (t) => reporter.reasoning(t),
+            onTool: (name, target) => reporter.tool(name, target),
+            onResult: () => reporter.flush()
+          }) : null;
+          const decoder = tap ? new string_decoder_1.StringDecoder("utf8") : null;
+          child.stdout.on("data", (chunk) => {
+            stdoutChunks.push(chunk);
+            if (tap && decoder)
+              tap.push(decoder.write(chunk));
+          });
           child.stdin.write(prompt);
           child.stdin.end();
           const timeout = this.config.timeout ?? DEFAULT_TIMEOUT;
@@ -19422,6 +19771,10 @@ var require_claude_code = __commonJS({
           child.on("close", (code) => {
             clearTimeout(timer);
             signal.removeEventListener("abort", onAbort);
+            if (tap && decoder) {
+              tap.push(decoder.end());
+              tap.end();
+            }
             const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
             if (code === 0) {
               try {
@@ -19444,9 +19797,21 @@ var require_claude_code = __commonJS({
                       aiProvider: "claude-code",
                       ...model ? { aiModel: model } : {},
                       ...stream.usage ?? {}
-                    }
+                    },
+                    // In-session repair handle (ADR 0017): present only when the run
+                    // reported a session id, so the runner can `--resume` it.
+                    ...stream.sessionId ? {
+                      continuation: {
+                        sessionId: stream.sessionId,
+                        model,
+                        childEnv,
+                        outputLabel,
+                        outputSchema: spec.outputSchema
+                      }
+                    } : {}
                   },
-                  readPaths: stream.readPaths
+                  readPaths: stream.readPaths,
+                  toolText: stream.toolText
                 }));
               } catch (err) {
                 settle(() => reject(err instanceof Error ? err : new Error(String(err))));
@@ -19543,6 +19908,8 @@ var require_claude_code = __commonJS({
       let usage = null;
       let resultMeta = null;
       let structuredOutput = null;
+      let sessionId = null;
+      let toolText = "";
       for (const line of stdout.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed.startsWith("{"))
@@ -19553,15 +19920,22 @@ var require_claude_code = __commonJS({
         } catch {
           continue;
         }
+        if (typeof event.session_id === "string")
+          sessionId = event.session_id;
         if (event.type === "assistant") {
           const content = event.message?.content;
           if (!Array.isArray(content))
             continue;
           for (const block of content) {
             const b = block;
-            if (b?.type === "tool_use" && b.name === "Read" && typeof b.input?.file_path === "string") {
-              readPaths.push(b.input.file_path);
+            if (b?.type !== "tool_use")
+              continue;
+            const fp = b.input?.file_path;
+            if (b.name === "Read" && typeof fp === "string") {
+              readPaths.push(fp);
             }
+            if (b.input && typeof b.input === "object")
+              toolText += JSON.stringify(b.input);
           }
         } else if (event.type === "result") {
           if (typeof event.result === "string" && event.result.trim().length > 0) {
@@ -19584,7 +19958,7 @@ var require_claude_code = __commonJS({
           };
         }
       }
-      return { finalText, readPaths, usage, resultMeta, structuredOutput };
+      return { finalText, readPaths, usage, resultMeta, structuredOutput, sessionId, toolText };
     }
     var MAX_REPORTED_READS = 2e3;
     function relativeWorkspaceReads(readPaths, cwd) {
@@ -19848,7 +20222,6 @@ var require_anthropic_api = __commonJS({
       }
       async execute(dispatch, signal) {
         const { prompt, spec } = (0, loom_1.renderPromptExecution)(dispatch.inputs);
-        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;
@@ -19857,6 +20230,33 @@ var require_anthropic_api = __commonJS({
           max_tokens: this.instance.maxTokens,
           messages: [{ role: "user", content: prompt }]
         };
+        return this.callApi(apiKey, body, spec, spec.outputLabel, signal);
+      }
+      /**
+       * In-session gate repair (ADR 0017): re-call the Messages API with the prior
+       * conversation plus the model's own last turn plus the repair turn, under the
+       * same output contract. A fresh conversation is not started — the appended
+       * assistant turn gives the model its previous answer to correct.
+       */
+      async continue(continuation, followUp, signal, _ctx) {
+        const handle = continuation;
+        if (!handle || !Array.isArray(handle.messages)) {
+          throw new Error("anthropic-api continue: missing conversation to resume");
+        }
+        const spec = {
+          rendering: "producer",
+          outputLabel: handle.outputLabel,
+          outputSchema: handle.outputSchema
+        };
+        const body = {
+          model: handle.model,
+          max_tokens: handle.maxTokens,
+          messages: [...handle.messages, { role: "user", content: followUp }]
+        };
+        return this.callApi(handle.apiKey, body, spec, handle.outputLabel, signal);
+      }
+      /** Shared Messages-API call + parse + validate, used by execute and continue. */
+      async callApi(apiKey, body, spec, outputLabel, signal) {
         const timeoutController = new AbortController();
         const timer = setTimeout(() => timeoutController.abort(), this.instance.timeoutMs);
         function onAbort() {
@@ -19904,7 +20304,17 @@ var require_anthropic_api = __commonJS({
             outputs: [{ label: outputLabel, content: parsed ?? { raw: rawText } }],
             rawText,
             parsed,
-            ...usage ? { usage } : {}
+            ...usage ? { usage } : {},
+            // In-session repair handle (ADR 0017): the conversation with the model's
+            // answer appended, ready for `continue()` to add the repair turn.
+            continuation: {
+              apiKey,
+              model: body.model,
+              maxTokens: body.max_tokens,
+              messages: [...body.messages, { role: "assistant", content: rawText }],
+              outputLabel,
+              outputSchema: spec.outputSchema
+            }
           };
         } finally {
           clearTimeout(timer);
@@ -20737,6 +21147,7 @@ var require_shuttle = __commonJS({
     var decommission_1 = require_decommission();
     var loom_1 = require_dist3();
     var chain_1 = require_chain();
+    var output_gates_1 = require_output_gates();
     var keep_1 = require_dist4();
     var apply_1 = require_apply();
     var version_check_1 = require_version_check();
@@ -20751,6 +21162,37 @@ var require_shuttle = __commonJS({
     var audit_log_1 = require_audit_log();
     var spend_tracker_1 = require_spend_tracker();
     var store_1 = require_store();
+    var GATE_REPAIR_BUDGET = 2;
+    async function runOutputGates(dispatch, response, executor, signal, ctx) {
+      let spec;
+      try {
+        spec = (0, loom_1.readPromptExecutionSpec)(dispatch.inputs);
+      } catch {
+        return { ok: true, response };
+      }
+      const gates = spec.gates;
+      if (!gates || gates.length === 0)
+        return { ok: true, response };
+      let current = response;
+      let result = (0, output_gates_1.evaluateOutputGates)(gates, current.parsed ?? {}, dispatch.inputs);
+      let attempts = 0;
+      while (!result.ok && attempts < GATE_REPAIR_BUDGET && current.continuation !== void 0 && typeof executor.continue === "function") {
+        try {
+          current = await executor.continue(current.continuation, (0, output_gates_1.renderRepairPrompt)(result.findings), signal, ctx);
+        } catch {
+          break;
+        }
+        result = (0, output_gates_1.evaluateOutputGates)(gates, current.parsed ?? {}, dispatch.inputs);
+        attempts += 1;
+      }
+      if (result.ok)
+        return { ok: true, response: current };
+      const detail = result.findings.map((f) => `[${f.gate}] ${f.message}`).join(" | ");
+      return {
+        ok: false,
+        reason: `output gate(s) failed${attempts > 0 ? ` after ${attempts} repair attempt(s)` : ""}: ${detail}`
+      };
+    }
     var Shuttle = class {
       brand;
       config;
@@ -20847,14 +21289,26 @@ var require_shuttle = __commonJS({
           }
           await observerChain.notify({ kind: "executor.dispatch.started", jobId, attendanceId, executor: executor.capability.id, strategy }, onObserverError);
           const dispatchStartedAt = Date.now();
+          const executionCtx = {
+            reportProgress: (channel, frames) => {
+              void jobsClient.postProgress(jobId, { channel, frames }).catch(() => {
+              });
+            }
+          };
           let response;
           try {
-            response = await executor.execute(dispatch, signal);
+            response = await executor.execute(dispatch, signal, executionCtx);
           } catch (err) {
             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 };
           }
+          const gated = await runOutputGates(dispatch, response, executor, signal, executionCtx);
+          if (!gated.ok) {
+            await observerChain.notify({ kind: "attendance.closed", jobId, attendanceId, status: "failed", reason: gated.reason, totalDurationMs: Date.now() - startedAt }, onObserverError);
+            return { status: "failed", reason: gated.reason };
+          }
+          response = gated.response;
           await observerChain.notify({
             kind: "executor.dispatch.completed",
             jobId,
@@ -21527,58 +21981,14 @@ var import_path = require("path");
 var import_promises = require("fs/promises");
 var import_yaml = __toESM(require_dist());
 var import_shuttle = __toESM(require_dist5());
-
-// package.json
-var package_default = {
-  name: "@whittlelabs/sifter",
-  version: "0.15.0",
-  description: "Whittle Sifter: paired AI reviewer for Whittle Sift job pools.",
-  bin: {
-    "whittle-sifter": "./dist/bin.js"
-  },
-  main: "dist/bin.js",
-  engines: {
-    node: ">=20"
-  },
-  scripts: {
-    dev: "tsx watch src/bin.ts",
-    build: "node scripts/bundle.mjs",
-    typecheck: "tsc --noEmit",
-    start: "node dist/bin.js",
-    lint: "eslint src/"
-  },
-  publishConfig: {
-    registry: "https://registry.npmjs.org/",
-    access: "public"
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/whittlelabs/whittlelabs.git",
-    directory: "apps/whittle-sifter"
-  },
-  author: "Whittle Labs",
-  license: "UNLICENSED",
-  private: false,
-  dependencies: {
-    "@whittlelabs/shuttle": "workspace:*",
-    yaml: "^2.7.1"
-  },
-  devDependencies: {
-    "@types/node": "^20.10.5",
-    esbuild: "^0.25.0",
-    tsx: "^4.21.0",
-    typescript: "^5.3.3"
-  }
-};
-
-// src/brand.ts
+var buildVersion = true ? "0.17.0" : pkg.version;
 var sifterBrand = {
   product: {
     id: "sifter",
     title: "Whittle Sifter",
     cliBinary: "whittle-sifter",
     packageName: "@whittlelabs/sifter",
-    version: package_default.version,
+    version: buildVersion,
     description: "Pairs with Whittle Sift to run AI code reviews on your hardware with your credentials."
   },
   paths: {
@@ -21723,7 +22133,7 @@ async function buildExecutorBlock(executor, ctx) {
     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(`Run \`${sifterBrand.product.cliBinary} init\` to pair again.`);
     console.error("");
     process.exit(3);
   }