claude-autorouter 0.3.3 → 0.3.4

package/docs/reference.md

@@ -166,7 +166,8 @@ The following policy applies after classification:
 
 - Jev's 1,500 ms deadline covers the response body and has no retry. Successful calls return immediately. Timeouts, HTTP errors, and invalid responses fall back to Sonnet or retain an existing stronger model.
 - Jev confidence below 0.75 prevents a downgrade below Sonnet or the requested tier. Ollama returns a tier without calibrated confidence; its failure handling and compatibility guards still apply.
-- Tool continuations retain the model chosen at the start of the human turn. Session, agent, and prompt headers identify turns; normalized conversation content provides a fallback. Moving prompt-cache markers does not create a new turn.
+- Tool continuations retain the model chosen at the start of the human turn. Session, agent, and prompt headers identify turns; normalized conversation content provides a fallback. Text feedback from a Stop hook also retains the model when it serves the same gateway prompt ID and the client has not changed its requested model, subject to capability and context checks. Moving prompt-cache markers does not create a new turn.
+- Claude's local `/goal` command can omit the prompt-ID header. For that path, an exact feedback label matching a preceding expanded `/goal` command keeps the original task and conversation anchor. This narrow text fallback also recognizes Claude's repeated-goal truncation format; arbitrary hook text is not treated as a goal. Feedback remains in the evaluator's recent conversation and the full API request. A new human message becomes the current task normally. The status line shows `prompt pinned` or `goal pinned` when either text-continuation rule applies.
 - Thinking history, fixed-budget thinking, server tools, context management, and other recognized model-specific features preserve the current model. Adaptive thinking, effort, and output above 64K prevent a Haiku choice. Fields are never stripped to force a downgrade.
 - Mid-conversation `system` messages preserve the requested model and pass through unchanged. They do not count as a tool continuation by themselves.
 - Recognized compaction and auxiliary requests otherwise preserve their requested model. Token counting and model discovery pass through without classification.
@@ -233,6 +234,10 @@ The launcher is quiet by default. Standalone `serve` logs to stderr by default.
 
 **Claude says Haiku while AutoRouter says Opus:** the built-in model label is Claude's starting/requested model. The AutoRouter confirmed-model label comes from Anthropic. Claude's own token-cost estimate can likewise be attributed to the requested model.
 
+**`/goal` repeats a question or says it is blocked:** Claude Code runs its own completion checker after each turn, separately from AutoRouter's Jev/Ollama classifier. AutoRouter preserves the requested model for that auxiliary check and forwards its verdict unchanged. The check cannot authorize GitHub SAML, approve a tool, or resolve an external dependency. A tool's authentication error is also different from a Claude API authentication failure.
+
+If the worker reports a blocker but the checker keeps returning “not yet met,” Claude can repeat its answer until its no-progress guard pauses the goal. Repeated tool calls can keep the loop running longer. Use `/goal clear` to end the loop, resolve the external blocker, and set the goal again. For tasks that may require human action, explicitly allow reporting a blocker as an alternative end condition, for example: `/goal Verify the discrepancy against upstream main and run the relevant tests, or report an external authorization blocker and stop.` This changes what counts as completion; AutoRouter does not declare blocked work successful or rewrite goal instructions. See [Claude Code goal evaluation](https://code.claude.com/docs/en/goal#how-evaluation-works).
+
 **After restarting mid-conversation:** turn state is in memory and expires after 30 minutes. Unknown continuations preserve the incoming model. Start a fresh conversation when restarting around signed thinking; AutoRouter cannot reconstruct the prior actual model from lost turn state.
 
 Switching models can lose prompt-cache reuse. A cheaper price per token does not guarantee a cheaper or faster task. Only requests using Claude's configured base URL are visible to this proxy. Alternate provider modes such as Bedrock, Vertex, Foundry, Mantle, and `ANTHROPIC_AWS` are unsupported; unset their enable flags before launching. Use ordinary `claude` to bypass routing.

package/docs/releasing.md

@@ -8,6 +8,8 @@ Version `0.3.2` fixes local timeout fallbacks with model-specific deadlines, rem
 
 Version `0.3.3` fixes HTTP 400 errors when a compatible request with disabled thinking is routed to Sonnet 5.5. Inference and token counting translate that setting to `between_tools`, or adaptive thinking when effort settings require it. Model defaults are unchanged; select Sonnet 5.5 with `AUTOROUTER_SONNET_MODEL=claude-sonnet-5-5`.
 
+Version `0.3.4` preserves the selected model across Stop-hook feedback for the same prompt, including `/goal` commands that omit the gateway prompt-ID header. Recognized goal feedback remains conversation context rather than replacing the human task in evaluator excerpts. Goal-checker verdicts remain unchanged; external authorization blockers can still cause Claude's own goal loop to repeat. See [goal troubleshooting](reference.md#troubleshooting).
+
 The GitHub repository is private. Publishing to npm makes the tarball's runtime source, README, configuration example, license, and shipped documentation public. Model weights, user configuration, credentials, transcripts, local artifacts, and test fixtures are excluded. Review the archive before the first publication and whenever the package allowlist changes.
 
 ## What runs automatically

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autorouter",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "license": "Apache-2.0",
   "type": "module",
   "description": "A Claude Code model router with Jev and local Ollama System One evaluators",

package/src/prompt-state.mjs

@@ -76,12 +76,60 @@ function humanTask(message) {
   return contentText(message.content, true);
 }
 
+// Claude Code emits /goal Stop-hook feedback as user text. Recognize only its
+// observed wrapper and a condition established by an earlier expanded command;
+// ordinary messages mentioning hooks remain human tasks. This does not alter
+// message content, and the feedback remains available as classifier history.
+export function goalFeedbackIndexes(messages) {
+  const indexes = new Set();
+  if (!Array.isArray(messages)) return indexes;
+  let condition;
+  let shortCondition;
+  let sawFullFeedback = false;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== 'user') continue;
+    const command = /^\s*<command-name>\/goal<\/command-name>\s*<command-message>goal<\/command-message>\s*<command-args>([\s\S]*?)<\/command-args>(?:\s|$)/.exec(humanTask(message));
+    if (command) {
+      const value = command[1].trim();
+      // /goal with no arguments is a status query, not a replacement goal.
+      if (!value) continue;
+      condition = value.length <= 4000 && !/^(?:clear|stop|off|reset|none|cancel)$/i.test(value) ? value : undefined;
+      shortCondition = undefined;
+      sawFullFeedback = false;
+      if (condition?.length > 500) {
+        let prefix = condition.slice(0, 500);
+        const last = prefix.charCodeAt(prefix.length - 1);
+        if (last >= 0xd800 && last <= 0xdbff) prefix = prefix.slice(0, -1);
+        shortCondition = `${prefix}… [+${condition.length - prefix.length} chars]`;
+      }
+      continue;
+    }
+    if (!condition || messages[index - 1]?.role !== 'assistant') continue;
+    const text = typeof message.content === 'string' ? message.content
+      : Array.isArray(message.content) && message.content.length === 1 && message.content[0]?.type === 'text'
+        && typeof message.content[0].text === 'string' ? message.content[0].text : undefined;
+    if (text === undefined) continue;
+    const matches = label => {
+      const prefix = `Stop hook feedback:\n[${label}]: `;
+      return text.startsWith(prefix) && Boolean(text.slice(prefix.length).trim());
+    };
+    if (matches(condition)) {
+      indexes.add(index);
+      sawFullFeedback = true;
+    } else if (sawFullFeedback && shortCondition && matches(shortCondition)) indexes.add(index);
+  }
+  return indexes;
+}
+
 export function buildState(body, limit = 12000) {
   const messages = body.messages ?? [];
+  const feedbackIndexes = goalFeedbackIndexes(messages);
   let firstTask = '';
   let currentTask = '';
   let currentIndex = -1;
   for (let index = 0; index < messages.length; index++) {
+    if (feedbackIndexes.has(index)) continue;
     const task = humanTask(messages[index]);
     if (!task.trim()) continue;
     if (!firstTask) firstTask = task;

package/src/router.mjs

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { TIERS } from './config.mjs';
-import { buildState } from './prompt-state.mjs';
+import { buildState, goalFeedbackIndexes } from './prompt-state.mjs';
 import { buildOllamaState, evaluateOllama } from './ollama-evaluator.mjs';
 export { buildState } from './prompt-state.mjs';
 
@@ -134,10 +134,11 @@ function turnContent(content) {
 
 function turnInfo(body, scope, promptId = '') {
   const messages = body.messages ?? [];
+  const feedback = goalFeedbackIndexes(messages);
   let index = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if (message.role === 'user' && !(Array.isArray(message.content) && message.content.some(b => b.type === 'tool_result'))) {
+    if (message.role === 'user' && !feedback.has(i) && !(Array.isArray(message.content) && message.content.some(b => b.type === 'tool_result'))) {
       index = i; break;
     }
   }
@@ -147,6 +148,7 @@ function turnInfo(body, scope, promptId = '') {
     index,
     key: promptId ? hash(['prompt', scope, promptId]) : contentKey,
     contentKey,
+    goalFeedback: feedback.has(messages.length - 1),
     // Claude Code can append turn-scoped system instructions after the human
     // prompt. These do not start an assistant/tool continuation.
     continuation: index < 0 || messages.slice(index + 1).some(m => m.role !== 'system'),
@@ -248,11 +250,15 @@ export class Router {
     let model = c.models[decision.tier];
     let reason = decision.reason;
     const turn = turnInfo(body, scope, promptId);
-    let previous = this.turns.get(turn.key) ?? this.turns.get(turn.contentKey);
+    const promptPin = promptId ? this.turns.get(turn.key) : undefined;
+    const turnPin = promptPin ?? this.turns.get(turn.contentKey);
+    let previous = turnPin?.model;
+    const textTurn = !turn.continuation || turn.goalFeedback;
+    const textPin = promptPin ?? (!promptId && turn.goalFeedback ? turnPin : undefined);
     // A new human prompt can still carry signed thinking from the preceding
     // turn. Recover that turn's actual routed model when it is known.
     if (!turn.continuation && body.messages.length > 1 && !previous) {
-      previous = this.turns.get(turnInfo({ ...body, messages: body.messages.slice(0, turn.index) }, scope).key);
+      previous = this.turns.get(turnInfo({ ...body, messages: body.messages.slice(0, turn.index) }, scope).key)?.model;
     }
     let preserved = false;
     const preserve = (chosen, why) => { model = chosen; reason = why; preserved = true; };
@@ -272,8 +278,21 @@ export class Router {
     // A new native request can explicitly select a model-specific thinking
     // mode, including between_tools. An earlier turn's model is not evidence
     // that it accepts that mode. Existing tool turns retain their pin below.
-    else if (modelSpecificThinking && body.thinking.type !== 'enabled' && !turn.continuation) preserve(body.model, 'model_specific_features');
-    else if (turn.continuation) keep(previous ? 'tool_turn_pinned' : 'unknown_continuation');
+    else if (modelSpecificThinking && body.thinking.type !== 'enabled' && textTurn) preserve(body.model, 'model_specific_features');
+    // Stop hooks (including /goal) return feedback as user-role text, even
+    // though it still serves the same human prompt. Trust the scoped gateway
+    // identity instead of treating that text as a new task. A client model
+    // change can be an explicit fallback after a failure; do not undo it.
+    // Local /goal commands can omit the gateway prompt ID. Exact feedback for
+    // a known goal then uses the original conversation anchor as a fallback.
+    else if (textTurn && textPin?.requestedModel === body.model && !modelSpecificFeatures) {
+      const needsSonnet = body.thinking?.type === 'adaptive' || body.output_config?.effort || body.max_tokens > 64000;
+      if (needsSonnet && (textPin.model === c.models.haiku || rank(textPin.model) === 0)) {
+        preserve(c.models.sonnet, 'requires_sonnet_capabilities');
+      } else preserve(textPin.model, promptPin ? 'prompt_turn_pinned' : 'goal_turn_pinned');
+    }
+    else if (turn.goalFeedback && !turnPin) preserve(body.model, 'unknown_continuation');
+    else if (turn.continuation && !turn.goalFeedback) keep(previous ? 'tool_turn_pinned' : 'unknown_continuation');
     // Unknown or model-specific features are preserved, never silently removed.
     else if (decision.source === 'fallback' && rank(body.model) >= 1) keep('classifier_unavailable');
     else if (modelSpecificFeatures) keep('model_specific_features');
@@ -318,12 +337,13 @@ export class Router {
     }
     const identifiableUpgrade = capacityUpgraded && (turn.index >= 0 || promptId);
     if ((!turn.continuation || previous || identifiableUpgrade || reason === 'mid_conversation_system') && !['compaction', 'auxiliary'].includes(requestClass)) {
-      this.turns.set(turn.key, model);
+      const pin = { model, requestedModel: body.model };
+      this.turns.set(turn.key, pin);
       // Keep the content key too: later human turns carry signed thinking but
       // have a new prompt ID, so they must recover the preceding routed model.
       // Refresh this alias during known continuations too, since tool discovery
       // can change the content key without changing the gateway prompt ID.
-      if (turn.contentKey !== turn.key) this.turns.set(turn.contentKey, model);
+      if (turn.contentKey !== turn.key) this.turns.set(turn.contentKey, pin);
     }
     return { ...decision, ...contextCheck, model, reason, latency_ms: Math.round((performance.now() - start) * 100) / 100 };
   }

package/src/statusline.mjs

@@ -1,6 +1,7 @@
 const PHASES = new Set(['routing', 'connecting', 'streaming', 'ready', 'error', 'cancelled']);
 const REASONS = {
-  tool_turn_pinned: 'turn pinned', thinking_history: 'thinking pinned', unknown_continuation: 'continuation pinned',
+  tool_turn_pinned: 'turn pinned', prompt_turn_pinned: 'prompt pinned', goal_turn_pinned: 'goal pinned',
+  thinking_history: 'thinking pinned', unknown_continuation: 'continuation pinned',
   mid_conversation_system: 'system features', requires_sonnet_capabilities: 'capability guard',
   model_specific_features: 'model features', large_or_multimodal_request: 'large request',
   context_capacity: 'large context',