@brainervirus/workit-core 8.27.0 → 8.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "8.27.0",
+  "version": "8.28.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/src/core/role-models.ts

@@ -207,3 +207,30 @@ export const roleModelIssues = (cwd: string, dir?: string): string[] => {
   }
   return issues;
 };
+
+/**
+ * The role a Claude Code subagent type runs as: the Workit agents by their
+ * namespaced name, the built-in `Explore`. Plan, general-purpose and every
+ * other type map to none (their model is not Workit's to choose). An
+ * implementer spawn names its brief tier on a `TIER: <tier>` line in its
+ * prompt; without one it is `standard`.
+ */
+export const roleForAgentType = (agentType: unknown, prompt?: unknown): RoleSelector | null => {
+  switch (agentType) {
+    case "workit:implementer": {
+      const tier =
+        typeof prompt === "string"
+          ? /^[ \t]*TIER:[ \t]*(mundane|standard|hard)\b/im.exec(prompt)?.[1]
+          : undefined;
+      return { role: "implementer", tier: (tier?.toLowerCase() as ModelTier) ?? "standard" };
+    }
+    case "workit:verifier":
+      return { role: "verifier" };
+    case "workit:reviewer":
+      return { role: "reviewer" };
+    case "Explore":
+      return { role: "explore" };
+    default:
+      return null;
+  }
+};

package/src/hooks/agent-model.ts

@@ -0,0 +1,40 @@
+// Role models on a Claude Code subagent spawn (#420): a spawn that names no
+// `model` gets its role's model (and effort) from the role config, through
+// PreToolUse `updatedInput` on the Agent tool. An explicit `model` always
+// wins and a spawn is never denied over its model: a type with no role, or a
+// role with nothing usable configured, runs as the caller wrote it.
+import { resolveRoleModel, roleForAgentType } from "../core/role-models";
+import type { HookDecision } from "./protocol";
+
+/** The Agent tool's `model` and `effort` enums (claude 2.1.309); anything else fails its schema. */
+const MODELS = new Set(["sonnet", "opus", "haiku", "fable"]);
+const EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+
+const given = (value: unknown): boolean => typeof value === "string" && value.trim() !== "";
+
+export const agentModelDecision = (
+  cwd: string,
+  tool: Record<string, unknown>,
+  env: NodeJS.ProcessEnv = process.env,
+): HookDecision => {
+  // The host fixes the model itself: nothing to fill, and `model` is not in its schema.
+  if (given(tool.model) || env.CLAUDE_CODE_SUBAGENT_MODEL_FORCE) return { kind: "none" };
+  const selector = roleForAgentType(tool.subagent_type, tool.prompt);
+  if (!selector) return { kind: "none" };
+  const resolved = resolveRoleModel(cwd, selector, "claude_code");
+  if (!resolved) return { kind: "none" };
+  const model = resolved.model.toLowerCase();
+  const effort = resolved.effort?.toLowerCase() ?? null;
+  const input: Record<string, unknown> = { ...tool };
+  if (MODELS.has(model)) input.model = model;
+  if (effort && EFFORTS.has(effort) && !given(tool.effort)) input.effort = effort;
+  if (input.model === undefined && input.effort === tool.effort) return { kind: "none" };
+  const label = selector.tier ? `${selector.role} ${selector.tier}` : selector.role;
+  return {
+    kind: "update-input",
+    input,
+    text: `Workit set ${String(input.model ?? "no model")}${
+      input.effort !== tool.effort ? ` (effort ${String(input.effort)})` : ""
+    } on this ${String(tool.subagent_type)} spawn: role ${label}, ${resolved.source}. Name a model to choose another.`,
+  };
+};

package/src/hooks/handle.ts

@@ -9,6 +9,7 @@ import type { HostDescriptor, Support } from "./descriptor";
 import { branchGuidance } from "../core/branch";
 import { workspaceTrailers } from "../core/workspaces";
 import { judgeBranch, recordIssuedSession, verdictCommand } from "../host-session";
+import { agentModelDecision } from "./agent-model";
 import { cwdRewrite, verbFirst } from "./cwd-normalize";
 import { workitBypassFlag } from "./delivery-verbs";
 import { heavyDenial, heavyGate, rewriteNote, splitDenial } from "./heavy-gate";
@@ -159,7 +160,7 @@ export function handleHook(input: HookInput, deps: HookDeps): HookDecision {
     return decision;
   const delta = standingDelta(input);
   if (!delta) return decision;
-  return decision.kind === "rewrite"
+  return decision.kind === "rewrite" || decision.kind === "update-input"
     ? { ...decision, text: [decision.text, delta].filter(Boolean).join("\n") }
     : withContextLine(decision, delta);
 }
@@ -307,6 +308,8 @@ function decide(input: HookInput, deps: HookDeps): HookDecision {
     case "tool.pre":
       // Host permission policy owns other tools; a skill load is recorded.
       if (event.skill) recordSkillLoad(input, event.skill, "tool");
+      if (event.agentInput && input.host === "claude_code")
+        return agentModelDecision(input.cwd, event.agentInput);
       return NONE;
     case "stop":
       return usable(descriptor.events.stop.support) ? stopDecision(input, descriptor) : NONE;

package/src/hooks/hosts/claude-code.ts

@@ -186,6 +186,17 @@ const eventOf = (name: ClaudeHookEvent, value: Record<string, unknown>): Parsed
             skill: isRecord(value.tool_input) ? optionalText(value.tool_input.skill) : null,
           },
         };
+      // `Task` is the Agent tool's legacy name.
+      if (value.tool_name === "Agent" || value.tool_name === "Task")
+        return {
+          ok: true,
+          event: {
+            kind: "tool.pre",
+            tool: value.tool_name,
+            toolUseId,
+            ...(isRecord(value.tool_input) ? { agentInput: value.tool_input } : {}),
+          },
+        };
       if (!SHELL_TOOLS.has(value.tool_name))
         return { ok: true, event: { kind: "tool.pre", tool: value.tool_name, toolUseId } };
       const command = toolCommand(value);
@@ -276,7 +287,11 @@ const CONTEXT_EVENTS = new Set([
  * yielded as the input to run).
  */
 const render = (decision: HookDecision, native: string | null) => {
-  if (decision.kind === "rewrite" && native === "PreToolUse" && decision.input)
+  if (
+    (decision.kind === "rewrite" || decision.kind === "update-input") &&
+    native === "PreToolUse" &&
+    decision.input
+  )
     return {
       json: {
         hookSpecificOutput: {

package/src/hooks/protocol.ts

@@ -37,6 +37,8 @@ export type HookEvent =
       toolUseId: string | null;
       /** The skill a skill-loading tool loads (Claude Code's Skill tool). */
       skill?: string | null;
+      /** A subagent spawn's whole tool input (Claude Code's Agent tool), where a default is filled in. */
+      agentInput?: Record<string, unknown>;
     }
   /** A file-writing tool (Edit, Write, apply_patch…): the before-write gate (S17). */
   | {
@@ -105,6 +107,12 @@ export type HookDecision =
    * host takes the whole input back; `text` is model-visible context.
    */
   | { kind: "rewrite"; command: string; input: Record<string, unknown> | null; text: string | null }
+  /**
+   * tool.pre: run the tool with `input` (the host's whole tool input, with
+   * defaults filled in) instead; `text` is model-visible context. Never a
+   * permission decision.
+   */
+  | { kind: "update-input"; input: Record<string, unknown>; text: string | null }
   /** Stop/SubagentStop: keep working. */
   | { kind: "continue"; reason: string }
   | { kind: "notice"; userMessage: string };