@harness-engineering/intelligence 0.8.0 → 0.9.0

package/dist/index.d.mts

@@ -367,6 +367,14 @@ interface AnalysisRequest {
     responseSchema: z.ZodType;
     model?: string;
     maxTokens?: number;
+    /**
+     * Request that the backend suppress any chain-of-thought / `<think>` reasoning for THIS call.
+     * Intended for narrow structured-extraction calls where a reasoning trace adds latency but not
+     * quality. Advisory + best-effort: a provider that can honor it (e.g. Ollama's native
+     * `think:false`) does; one that cannot ignores it and answers normally. Never changes the
+     * response contract — only whether the model reasons out loud first.
+     */
+    disableThinking?: boolean;
 }
 interface AnalysisResponse<T> {
     result: T;
@@ -437,12 +445,26 @@ interface OpenAICompatibleProviderOptions {
  */
 declare class OpenAICompatibleAnalysisProvider implements AnalysisProvider {
     private readonly client;
+    private readonly baseUrl;
+    private readonly timeoutMs;
     private readonly defaultModel;
     private readonly getModel?;
     private readonly promptSuffix;
     private readonly jsonMode;
     constructor(options: OpenAICompatibleProviderOptions);
     analyze<T>(request: AnalysisRequest): Promise<AnalysisResponse<T>>;
+    /** Build the system + user message content shared by both the OpenAI-compat and native paths. */
+    private buildMessages;
+    /** Ollama's native chat route, derived from the configured `/v1` base URL. */
+    private ollamaNativeChatUrl;
+    /**
+     * Take Ollama's NATIVE `/api/chat` with `think:false` — the only way to actually suppress a
+     * Qwen3-style reasoning trace (the OpenAI-compatible `/v1` shim ignores every thinking knob).
+     * Schema is enforced via native `format`; `num_predict` bounds output. Throws on any non-2xx,
+     * missing content, or schema-parse failure so `analyze` can fall back to the OpenAI-compatible
+     * path (e.g. when the endpoint is not actually Ollama).
+     */
+    private analyzeViaOllamaNative;
 }
 
 interface ClaudeCliProviderOptions {
@@ -1759,6 +1781,14 @@ interface ProbeConfig {
 interface ProbeDeps {
     /** The SEL analysis provider for the semantic-read + open-decisions levers. Absent ⇒ offline. */
     provider?: AnalysisProvider;
+    /**
+     * Signals that a model IS available but its levers were intentionally DEFERRED for this run
+     * (e.g. a cheap-first report pass that holds obviously-out-of-band items before spending an LLM
+     * call). Only affects wording: a provider-less lever then reports "not evaluated (held before
+     * the model pass)" instead of "no provider (offline)", so a deferred lever is not mistaken for a
+     * missing/mis-configured provider. No effect on the gate — an unread lever never dispatches.
+     */
+    modelDeferred?: boolean;
     /** The graph-resolution seam for the scope lever. Absent ⇒ scope degrades to unknown. */
     graph?: GraphScope;
     /** The precedent lever. Absent ⇒ `unknown` (cold-start), which never blocks. */

package/dist/index.d.ts

@@ -367,6 +367,14 @@ interface AnalysisRequest {
     responseSchema: z.ZodType;
     model?: string;
     maxTokens?: number;
+    /**
+     * Request that the backend suppress any chain-of-thought / `<think>` reasoning for THIS call.
+     * Intended for narrow structured-extraction calls where a reasoning trace adds latency but not
+     * quality. Advisory + best-effort: a provider that can honor it (e.g. Ollama's native
+     * `think:false`) does; one that cannot ignores it and answers normally. Never changes the
+     * response contract — only whether the model reasons out loud first.
+     */
+    disableThinking?: boolean;
 }
 interface AnalysisResponse<T> {
     result: T;
@@ -437,12 +445,26 @@ interface OpenAICompatibleProviderOptions {
  */
 declare class OpenAICompatibleAnalysisProvider implements AnalysisProvider {
     private readonly client;
+    private readonly baseUrl;
+    private readonly timeoutMs;
     private readonly defaultModel;
     private readonly getModel?;
     private readonly promptSuffix;
     private readonly jsonMode;
     constructor(options: OpenAICompatibleProviderOptions);
     analyze<T>(request: AnalysisRequest): Promise<AnalysisResponse<T>>;
+    /** Build the system + user message content shared by both the OpenAI-compat and native paths. */
+    private buildMessages;
+    /** Ollama's native chat route, derived from the configured `/v1` base URL. */
+    private ollamaNativeChatUrl;
+    /**
+     * Take Ollama's NATIVE `/api/chat` with `think:false` — the only way to actually suppress a
+     * Qwen3-style reasoning trace (the OpenAI-compatible `/v1` shim ignores every thinking knob).
+     * Schema is enforced via native `format`; `num_predict` bounds output. Throws on any non-2xx,
+     * missing content, or schema-parse failure so `analyze` can fall back to the OpenAI-compatible
+     * path (e.g. when the endpoint is not actually Ollama).
+     */
+    private analyzeViaOllamaNative;
 }
 
 interface ClaudeCliProviderOptions {
@@ -1759,6 +1781,14 @@ interface ProbeConfig {
 interface ProbeDeps {
     /** The SEL analysis provider for the semantic-read + open-decisions levers. Absent ⇒ offline. */
     provider?: AnalysisProvider;
+    /**
+     * Signals that a model IS available but its levers were intentionally DEFERRED for this run
+     * (e.g. a cheap-first report pass that holds obviously-out-of-band items before spending an LLM
+     * call). Only affects wording: a provider-less lever then reports "not evaluated (held before
+     * the model pass)" instead of "no provider (offline)", so a deferred lever is not mistaken for a
+     * missing/mis-configured provider. No effect on the gate — an unread lever never dispatches.
+     */
+    modelDeferred?: boolean;
     /** The graph-resolution seam for the scope lever. Absent ⇒ scope degrades to unknown. */
     graph?: GraphScope;
     /** The precedent lever. Absent ⇒ `unknown` (cold-start), which never blocks. */

package/dist/index.js

@@ -449,15 +449,19 @@ var DEFAULT_MAX_TOKENS2 = 8192;
 var DEFAULT_TIMEOUT_MS = 9e4;
 var OpenAICompatibleAnalysisProvider = class {
   client;
+  baseUrl;
+  timeoutMs;
   defaultModel;
   getModel;
   promptSuffix;
   jsonMode;
   constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.client = new import_openai.default({
       apiKey: options.apiKey,
       baseURL: options.baseUrl,
-      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      timeout: this.timeoutMs
     });
     this.defaultModel = options.defaultModel ?? DEFAULT_MODEL2;
     if (options.getModel !== void 0) {
@@ -471,16 +475,19 @@ var OpenAICompatibleAnalysisProvider = class {
     const model = request.model ?? (resolved != null && resolved !== "" ? resolved : this.defaultModel);
     const maxTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS2;
     const jsonSchema = zodToJsonSchema(request.responseSchema);
-    const systemParts = [];
-    if (request.systemPrompt) systemParts.push(request.systemPrompt);
-    if (this.jsonMode) {
-      systemParts.push(
-        "Respond ONLY with the JSON object, no other text. Be concise \u2014 use short sentences in string fields and limit arrays to the most important items."
-      );
-    } else {
-      systemParts.push(
-        "You MUST respond with valid JSON matching this schema:\n" + JSON.stringify(jsonSchema, null, 2) + "\n\nRespond ONLY with the JSON object, no other text."
-      );
+    const { systemContent, userContent } = this.buildMessages(request, jsonSchema);
+    if (request.disableThinking === true) {
+      try {
+        return await this.analyzeViaOllamaNative(
+          request,
+          model,
+          maxTokens,
+          jsonSchema,
+          systemContent,
+          userContent
+        );
+      } catch {
+      }
     }
     const startMs = performance.now();
     const responseFormat = this.jsonMode ? {
@@ -492,13 +499,8 @@ var OpenAICompatibleAnalysisProvider = class {
       max_tokens: maxTokens,
       ...responseFormat && { response_format: responseFormat },
       messages: [
-        { role: "system", content: systemParts.join("\n\n") },
-        {
-          role: "user",
-          content: this.promptSuffix ? `${request.prompt}
-
-${this.promptSuffix}` : request.prompt
-        }
+        { role: "system", content: systemContent },
+        { role: "user", content: userContent }
       ]
     });
     const latencyMs = Math.round(performance.now() - startMs);
@@ -524,6 +526,81 @@ ${this.promptSuffix}` : request.prompt
     };
     return { result, tokenUsage, model, latencyMs };
   }
+  /** Build the system + user message content shared by both the OpenAI-compat and native paths. */
+  buildMessages(request, jsonSchema) {
+    const systemParts = [];
+    if (request.systemPrompt) systemParts.push(request.systemPrompt);
+    if (this.jsonMode) {
+      systemParts.push(
+        "Respond ONLY with the JSON object, no other text. Be concise \u2014 use short sentences in string fields and limit arrays to the most important items."
+      );
+    } else {
+      systemParts.push(
+        "You MUST respond with valid JSON matching this schema:\n" + JSON.stringify(jsonSchema, null, 2) + "\n\nRespond ONLY with the JSON object, no other text."
+      );
+    }
+    const userContent = this.promptSuffix ? `${request.prompt}
+
+${this.promptSuffix}` : request.prompt;
+    return { systemContent: systemParts.join("\n\n"), userContent };
+  }
+  /** Ollama's native chat route, derived from the configured `/v1` base URL. */
+  ollamaNativeChatUrl() {
+    return this.baseUrl.replace(/\/v1\/?$/, "") + "/api/chat";
+  }
+  /**
+   * Take Ollama's NATIVE `/api/chat` with `think:false` — the only way to actually suppress a
+   * Qwen3-style reasoning trace (the OpenAI-compatible `/v1` shim ignores every thinking knob).
+   * Schema is enforced via native `format`; `num_predict` bounds output. Throws on any non-2xx,
+   * missing content, or schema-parse failure so `analyze` can fall back to the OpenAI-compatible
+   * path (e.g. when the endpoint is not actually Ollama).
+   */
+  async analyzeViaOllamaNative(request, model, maxTokens, jsonSchema, systemContent, userContent) {
+    const startMs = performance.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(this.ollamaNativeChatUrl(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          think: false,
+          stream: false,
+          format: jsonSchema,
+          options: { num_predict: maxTokens },
+          messages: [
+            { role: "system", content: systemContent },
+            { role: "user", content: userContent }
+          ]
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`Ollama native /api/chat returned ${res.status}`);
+      }
+      const data = await res.json();
+      if (data.done_reason === "length") {
+        throw new Error("Ollama native /api/chat response truncated (done_reason=length)");
+      }
+      const content = data.message?.content;
+      if (!content) {
+        throw new Error("Ollama native /api/chat response missing message content");
+      }
+      const parsed = JSON.parse(content);
+      const result = request.responseSchema.parse(parsed);
+      const inputTokens = data.prompt_eval_count ?? 0;
+      const outputTokens = data.eval_count ?? 0;
+      return {
+        result,
+        tokenUsage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens },
+        model,
+        latencyMs: Math.round(performance.now() - startMs)
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 };
 
 // src/analysis-provider/claude-cli.ts
@@ -2275,7 +2352,18 @@ async function llmTiebreak(provider, prompt, fastModel) {
       responseSchema: TiebreakSchema,
       // Only include `model` when supplied (exactOptionalPropertyTypes).
       ...fastModel !== void 0 ? { model: fastModel } : {},
-      maxTokens: 256
+      // A trivial/simple/moderate/complex classification does not benefit from a reasoning
+      // trace (verified: identical verdict with thinking on vs off) — suppress it where the
+      // backend can (Ollama native), so a reasoning model answers in ~10 tokens instead of
+      // ~1000. No-op on backends that cannot honor it.
+      disableThinking: true,
+      // Headroom for reasoning models: a thinking model (e.g. Qwen3) emits a
+      // `<think>` trace BEFORE the JSON, so a tight cap truncates mid-reasoning →
+      // `finish_reason: length` → empty content → the catch below silently returns
+      // the `moderate/low` fallback, masking the real verdict. `maxTokens` is a
+      // ceiling, not a target (a non-thinking model still stops at ~14 tokens), so
+      // this is free on the fast path and only spends tokens when reasoning occurs.
+      maxTokens: 4096
     });
     return result;
   } catch {
@@ -2443,7 +2531,7 @@ async function runScopingProbe(input, deps = {}) {
   const config = { ...DEFAULT_CONFIG, ...deps.config };
   const scope = await runScopeLever(input, deps.graph);
   const semanticRead = await runSemanticReadLever(input, scope.value, deps);
-  const openDecisions = await runOpenDecisionsLever(input, deps.provider);
+  const openDecisions = await runOpenDecisionsLever(input, deps.provider, deps.modelDeferred);
   const precedent = runPrecedentLever(input, semanticRead.value, deps.precedent);
   const levers = { scope, semanticRead, openDecisions, precedent };
   const verdict = semanticRead.value === "unknown" ? { level: "moderate", confidence: "low", signals: {}, source: "static" } : semanticRead.value;
@@ -2507,16 +2595,29 @@ async function runSemanticReadLever(input, scope, deps) {
     return { value: "unknown", reason: `semantic-read: classify failed \u2014 ${errMsg(err)}` };
   }
 }
-async function runOpenDecisionsLever(input, provider) {
+async function runOpenDecisionsLever(input, provider, modelDeferred) {
   if (provider === void 0) {
-    return { value: "unknown", reason: "open-decisions: no provider (offline)" };
+    return {
+      value: "unknown",
+      reason: modelDeferred === true ? "open-decisions: not evaluated (item held before the model pass)" : "open-decisions: no provider (offline)"
+    };
   }
   try {
     const { result } = await provider.analyze({
       prompt: input.taskText.prompt,
       systemPrompt: OPEN_DECISIONS_SYSTEM_PROMPT,
       responseSchema: OpenDecisionsSchema,
-      maxTokens: 512
+      // Suppress the reasoning trace where the backend can (Ollama native) — enumerating the
+      // human-judgment decisions is structured extraction, not open-ended reasoning. Verified to
+      // surface the same decisions as with thinking on. No-op on backends that cannot honor it.
+      disableThinking: true,
+      // Headroom for reasoning models (Qwen3 et al.): they emit a `<think>` trace
+      // before the JSON, and this open-ended decisions schema elicits more of it than
+      // the tiny classify schema. A tight cap truncates mid-reasoning →
+      // `finish_reason: length` → the catch degrades this lever to `unknown`, silently
+      // blinding the open-decisions signal. `maxTokens` is a ceiling (a non-thinking
+      // model still stops early), so this is free on the fast path.
+      maxTokens: 4096
     });
     const decisions = result.openDecisions ?? [];
     const note = decisions.length === 0 ? "open-decisions: none surfaced" : `open-decisions: ${decisions.length} requiring human judgment`;

package/dist/index.mjs

@@ -334,15 +334,19 @@ var DEFAULT_MAX_TOKENS2 = 8192;
 var DEFAULT_TIMEOUT_MS = 9e4;
 var OpenAICompatibleAnalysisProvider = class {
   client;
+  baseUrl;
+  timeoutMs;
   defaultModel;
   getModel;
   promptSuffix;
   jsonMode;
   constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.client = new OpenAI({
       apiKey: options.apiKey,
       baseURL: options.baseUrl,
-      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      timeout: this.timeoutMs
     });
     this.defaultModel = options.defaultModel ?? DEFAULT_MODEL2;
     if (options.getModel !== void 0) {
@@ -356,16 +360,19 @@ var OpenAICompatibleAnalysisProvider = class {
     const model = request.model ?? (resolved != null && resolved !== "" ? resolved : this.defaultModel);
     const maxTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS2;
     const jsonSchema = zodToJsonSchema(request.responseSchema);
-    const systemParts = [];
-    if (request.systemPrompt) systemParts.push(request.systemPrompt);
-    if (this.jsonMode) {
-      systemParts.push(
-        "Respond ONLY with the JSON object, no other text. Be concise \u2014 use short sentences in string fields and limit arrays to the most important items."
-      );
-    } else {
-      systemParts.push(
-        "You MUST respond with valid JSON matching this schema:\n" + JSON.stringify(jsonSchema, null, 2) + "\n\nRespond ONLY with the JSON object, no other text."
-      );
+    const { systemContent, userContent } = this.buildMessages(request, jsonSchema);
+    if (request.disableThinking === true) {
+      try {
+        return await this.analyzeViaOllamaNative(
+          request,
+          model,
+          maxTokens,
+          jsonSchema,
+          systemContent,
+          userContent
+        );
+      } catch {
+      }
     }
     const startMs = performance.now();
     const responseFormat = this.jsonMode ? {
@@ -377,13 +384,8 @@ var OpenAICompatibleAnalysisProvider = class {
       max_tokens: maxTokens,
       ...responseFormat && { response_format: responseFormat },
       messages: [
-        { role: "system", content: systemParts.join("\n\n") },
-        {
-          role: "user",
-          content: this.promptSuffix ? `${request.prompt}
-
-${this.promptSuffix}` : request.prompt
-        }
+        { role: "system", content: systemContent },
+        { role: "user", content: userContent }
       ]
     });
     const latencyMs = Math.round(performance.now() - startMs);
@@ -409,6 +411,81 @@ ${this.promptSuffix}` : request.prompt
     };
     return { result, tokenUsage, model, latencyMs };
   }
+  /** Build the system + user message content shared by both the OpenAI-compat and native paths. */
+  buildMessages(request, jsonSchema) {
+    const systemParts = [];
+    if (request.systemPrompt) systemParts.push(request.systemPrompt);
+    if (this.jsonMode) {
+      systemParts.push(
+        "Respond ONLY with the JSON object, no other text. Be concise \u2014 use short sentences in string fields and limit arrays to the most important items."
+      );
+    } else {
+      systemParts.push(
+        "You MUST respond with valid JSON matching this schema:\n" + JSON.stringify(jsonSchema, null, 2) + "\n\nRespond ONLY with the JSON object, no other text."
+      );
+    }
+    const userContent = this.promptSuffix ? `${request.prompt}
+
+${this.promptSuffix}` : request.prompt;
+    return { systemContent: systemParts.join("\n\n"), userContent };
+  }
+  /** Ollama's native chat route, derived from the configured `/v1` base URL. */
+  ollamaNativeChatUrl() {
+    return this.baseUrl.replace(/\/v1\/?$/, "") + "/api/chat";
+  }
+  /**
+   * Take Ollama's NATIVE `/api/chat` with `think:false` — the only way to actually suppress a
+   * Qwen3-style reasoning trace (the OpenAI-compatible `/v1` shim ignores every thinking knob).
+   * Schema is enforced via native `format`; `num_predict` bounds output. Throws on any non-2xx,
+   * missing content, or schema-parse failure so `analyze` can fall back to the OpenAI-compatible
+   * path (e.g. when the endpoint is not actually Ollama).
+   */
+  async analyzeViaOllamaNative(request, model, maxTokens, jsonSchema, systemContent, userContent) {
+    const startMs = performance.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(this.ollamaNativeChatUrl(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          think: false,
+          stream: false,
+          format: jsonSchema,
+          options: { num_predict: maxTokens },
+          messages: [
+            { role: "system", content: systemContent },
+            { role: "user", content: userContent }
+          ]
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`Ollama native /api/chat returned ${res.status}`);
+      }
+      const data = await res.json();
+      if (data.done_reason === "length") {
+        throw new Error("Ollama native /api/chat response truncated (done_reason=length)");
+      }
+      const content = data.message?.content;
+      if (!content) {
+        throw new Error("Ollama native /api/chat response missing message content");
+      }
+      const parsed = JSON.parse(content);
+      const result = request.responseSchema.parse(parsed);
+      const inputTokens = data.prompt_eval_count ?? 0;
+      const outputTokens = data.eval_count ?? 0;
+      return {
+        result,
+        tokenUsage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens },
+        model,
+        latencyMs: Math.round(performance.now() - startMs)
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 };
 
 // src/analysis-provider/claude-cli.ts
@@ -2160,7 +2237,18 @@ async function llmTiebreak(provider, prompt, fastModel) {
       responseSchema: TiebreakSchema,
       // Only include `model` when supplied (exactOptionalPropertyTypes).
       ...fastModel !== void 0 ? { model: fastModel } : {},
-      maxTokens: 256
+      // A trivial/simple/moderate/complex classification does not benefit from a reasoning
+      // trace (verified: identical verdict with thinking on vs off) — suppress it where the
+      // backend can (Ollama native), so a reasoning model answers in ~10 tokens instead of
+      // ~1000. No-op on backends that cannot honor it.
+      disableThinking: true,
+      // Headroom for reasoning models: a thinking model (e.g. Qwen3) emits a
+      // `<think>` trace BEFORE the JSON, so a tight cap truncates mid-reasoning →
+      // `finish_reason: length` → empty content → the catch below silently returns
+      // the `moderate/low` fallback, masking the real verdict. `maxTokens` is a
+      // ceiling, not a target (a non-thinking model still stops at ~14 tokens), so
+      // this is free on the fast path and only spends tokens when reasoning occurs.
+      maxTokens: 4096
     });
     return result;
   } catch {
@@ -2328,7 +2416,7 @@ async function runScopingProbe(input, deps = {}) {
   const config = { ...DEFAULT_CONFIG, ...deps.config };
   const scope = await runScopeLever(input, deps.graph);
   const semanticRead = await runSemanticReadLever(input, scope.value, deps);
-  const openDecisions = await runOpenDecisionsLever(input, deps.provider);
+  const openDecisions = await runOpenDecisionsLever(input, deps.provider, deps.modelDeferred);
   const precedent = runPrecedentLever(input, semanticRead.value, deps.precedent);
   const levers = { scope, semanticRead, openDecisions, precedent };
   const verdict = semanticRead.value === "unknown" ? { level: "moderate", confidence: "low", signals: {}, source: "static" } : semanticRead.value;
@@ -2392,16 +2480,29 @@ async function runSemanticReadLever(input, scope, deps) {
     return { value: "unknown", reason: `semantic-read: classify failed \u2014 ${errMsg(err)}` };
   }
 }
-async function runOpenDecisionsLever(input, provider) {
+async function runOpenDecisionsLever(input, provider, modelDeferred) {
   if (provider === void 0) {
-    return { value: "unknown", reason: "open-decisions: no provider (offline)" };
+    return {
+      value: "unknown",
+      reason: modelDeferred === true ? "open-decisions: not evaluated (item held before the model pass)" : "open-decisions: no provider (offline)"
+    };
   }
   try {
     const { result } = await provider.analyze({
       prompt: input.taskText.prompt,
       systemPrompt: OPEN_DECISIONS_SYSTEM_PROMPT,
       responseSchema: OpenDecisionsSchema,
-      maxTokens: 512
+      // Suppress the reasoning trace where the backend can (Ollama native) — enumerating the
+      // human-judgment decisions is structured extraction, not open-ended reasoning. Verified to
+      // surface the same decisions as with thinking on. No-op on backends that cannot honor it.
+      disableThinking: true,
+      // Headroom for reasoning models (Qwen3 et al.): they emit a `<think>` trace
+      // before the JSON, and this open-ended decisions schema elicits more of it than
+      // the tiny classify schema. A tight cap truncates mid-reasoning →
+      // `finish_reason: length` → the catch degrades this lever to `unknown`, silently
+      // blinding the open-decisions signal. `maxTokens` is a ceiling (a non-thinking
+      // model still stops early), so this is free on the fast path.
+      maxTokens: 4096
     });
     const decisions = result.openDecisions ?? [];
     const note = decisions.length === 0 ? "open-decisions: none surfaced" : `open-decisions: ${decisions.length} requiring human judgment`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/intelligence",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Intelligence pipeline for spec enrichment, complexity modeling, and pre-execution simulation",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,8 +40,8 @@
     "@anthropic-ai/sdk": "^0.95.1",
     "openai": "^6.0.0",
     "zod": "^3.25.76",
-    "@harness-engineering/graph": "0.11.8",
-    "@harness-engineering/types": "0.22.0"
+    "@harness-engineering/graph": "0.11.9",
+    "@harness-engineering/types": "0.23.0"
   },
   "optionalDependencies": {
     "canary-test-cli": "^5.4.0"