@axiom-lattice/core 3.0.4 → 3.0.6

package/dist/index.js

@@ -9035,7 +9035,7 @@ var createReactAgentSchema = (schema6) => {
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
-var import_langchain45 = require("langchain");
+var import_langchain47 = require("langchain");
 
 // src/middlewares/codeEvalMiddleware.ts
 var import_langchain37 = require("langchain");
@@ -11249,8 +11249,11 @@ Please select a valid tool from the list above.`
      * The only place to access request.tools (all available tools).
      * Identifies unknown tools and stores error info in metadata.
      *
-     * Key: Preserve all tool_calls in original AIMessage, including unknown ones.
-     * This allows the model to see what it selected in the next round.
+     * Key: Strip valid tool_calls and only keep unknown ones in the returned
+     * AIMessage. Valid calls must NOT be preserved: afterModel jumps to "model"
+     * and skips ToolNode, so a preserved valid call would have no ToolMessage
+     * and the next model call would be rejected with a 400 dangling tool_calls
+     * error. Stripped valid calls are re-issued by the model in the next round.
      */
     wrapModelCall: async (request, handler) => {
       const availableTools = request.tools || [];
@@ -11280,10 +11283,11 @@ Please select a valid tool from the list above.`
         toolCallId: toolCall.id,
         errorMessage: errorMessageTemplate(toolCall.name, availableToolNames)
       }));
+      const unknownToolIds = new Set(unknownToolCalls.map((toolCall) => toolCall.id));
+      const remainingToolCalls = aiResponse.tool_calls.filter((toolCall) => unknownToolIds.has(toolCall.id));
       const modifiedResponse = new import_messages2.AIMessage({
         content: aiResponse.content,
-        tool_calls: aiResponse.tool_calls,
-        // Key: preserve all tool_calls, don't delete unknown
+        tool_calls: remainingToolCalls,
         response_metadata: {
           ...aiResponse.response_metadata,
           _unknownToolErrors: unknownToolErrors
@@ -11336,6 +11340,64 @@ Please select a valid tool from the list above.`
   });
 }
 
+// src/deep_agent_new/middleware/patch_tool_calls.ts
+var import_langchain45 = require("langchain");
+function createPatchToolCallsMiddleware() {
+  return (0, import_langchain45.createMiddleware)({
+    name: "patchToolCallsMiddleware",
+    beforeAgent: async (state) => {
+      const messages = state.messages;
+      if (!messages || messages.length === 0) {
+        return;
+      }
+      const replacements = [];
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (import_langchain45.AIMessage.isInstance(msg) && msg.tool_calls != null) {
+          const respondedIds = /* @__PURE__ */ new Set();
+          for (const toolCall of msg.tool_calls) {
+            if (!toolCall.id) continue;
+            const correspondingToolMsg = messages.slice(i).find(
+              (m) => import_langchain45.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
+            );
+            if (correspondingToolMsg) {
+              respondedIds.add(toolCall.id);
+            }
+          }
+          const remainingToolCalls = msg.tool_calls.filter(
+            (toolCall) => toolCall.id && respondedIds.has(toolCall.id)
+          );
+          if (remainingToolCalls.length === msg.tool_calls.length) {
+            continue;
+          }
+          const additionalKwargs = { ...msg.additional_kwargs };
+          delete additionalKwargs.tool_calls;
+          if (!msg.id) continue;
+          replacements.push(
+            new import_langchain45.AIMessage({
+              id: msg.id,
+              content: msg.content,
+              name: msg.name,
+              tool_calls: remainingToolCalls,
+              additional_kwargs: additionalKwargs,
+              response_metadata: msg.response_metadata
+            })
+          );
+        }
+      }
+      if (replacements.length === 0) {
+        return;
+      }
+      return {
+        messages: replacements
+      };
+    }
+  });
+}
+
+// src/agent_lattice/builders/commonMiddleware.ts
+var import_langchain46 = require("langchain");
+
 // src/plugin/metaSerializer.ts
 function tryExtractTools(plugin) {
   if (!plugin.middleware) return [];
@@ -12572,6 +12634,30 @@ actually achieve, not just what to build:
 
 Record the goal model in the parent task's description ([[task-tracking]]).
 
+**HARD RULE \u2014 never guess the target.** If the goal, expected output,
+consumer, or usable state is unclear at ANY point before writing test
+cases, you MUST ask the user via ask_user_to_clarify \u2014 never proceed
+with an assumed expectation. A test case written against a guessed
+expectation validates the wrong thing. When in doubt, ask.
+
+## Knowledge in Skills (apply to EVERY sub-skill workflow)
+
+**Domain knowledge lives in SKILL.md files, not in prompts.** The
+deliverable's knowledge (rules, formats, decision logic, procedures) is
+authored as skills; the executable (agent prompt, workflow step) stays
+THIN \u2014 role/process only, loading knowledge via "Load [[skill-name]]
+and follow it". Never write domain knowledge directly into a system
+prompt or a workflow step's prompt.
+
+Why: knowledge in prompts cannot be reused, individually verified, or
+evolved. Knowledge in skills is shared (subSkills), regression-tested
+([[eval-verify]]), and improved without touching the executable.
+
+Applies to every construction path: [[learn-capability]] (skills are
+the primary output), [[agent-build]] (agent prompt thin, loads skill),
+[[design-workflow]] (steps reference [[skill-name]] or ref to
+skill-loading agents). All three follow this single principle.
+
 ## Goal-Driven Validation (apply to EVERY sub-skill workflow)
 
 The agent evaluates goal achievement ITSELF via multi-dimensional test
@@ -12591,6 +12677,29 @@ green = goal achieved (per [[completion-gate]] and [[eval-verify]]).
 The goal model is the acceptance standard \u2014 contentAssertion must
 encode the usable state, not just technical correctness.
 
+## Undefined Tasks (outside the skill map)
+
+If the request does not match any sub-skill workflow: do NOT guess, do
+NOT refuse, do NOT force-fit an existing flow. Follow the
+EXPLORE \u2192 PROPOSE \u2192 CONFIRM protocol:
+
+1. **Explore** \u2014 inventory before proposing anything:
+   \`list_agents\` / \`load_skills\` (existing assets), \`list_tools\` /
+   \`list_middleware_types\` (capabilities), \`list_connections\`
+   (data sources), eval projects (verification), docs at hand.
+   Goal: know what is reusable and what is missing.
+2. **Propose** \u2014 present 2-3 concrete options, each with: what it
+   does, cost, risk, and what it needs (new tools / new skills /
+   approvals).
+3. **Confirm** \u2014 the user picks an option or adjusts it. Never
+   execute without a chosen option.
+4. **New capability needed?** (new tool type, new skill, new
+   connection) \u2014 include creating it ([[create-skill]] / connection
+   setup) IN the proposed option; never silently proceed without it.
+5. **Boundary honesty** \u2014 state clearly what the architect cannot do
+   (e.g. deploy to production, monitor runtime, change frontend),
+   and give the alternative \u2014 never overpromise or silently refuse.
+
 ## Skill Map
 - [[learn-capability]] \u2014 Learn from any source material (user
   description, documents, API specs, conversations, spreadsheets) and
@@ -12657,16 +12766,29 @@ Do NOT use reviewer as:
    verification. If findings show config errors, fix and re-check.`,
   "task-tracking": `---
 name: task-tracking
-description: Manage persistent tasks for agent creation workflows. Use
-  manage_task to create parent/subtasks, track progress, and resume
-  interrupted runs. Applies to ALL agent building processes.
+description: Manage persistent tasks with manage_task. Universal rule:
+  once the goal is clear and you know what to do, create the task FIRST
+  then execute. Track parent/subtasks, update status to reflect reality,
+  resume interrupted work. Applies to ANY multi-step agent work \u2014 not
+  just agent building.
 metadata:
   domain: agent-building
 verified: unverified
 ---
 # Task Tracking \u2014 manage_task for Agent Workflows
 
-Every agent creation workflow is a multi-step process \u2014 track it.
+**Task management is the ongoing record of a goal and its acceptance
+criteria** \u2014 it answers at any moment: what are we achieving, and what
+does "done" look like. Create a task when the goal is clear; keep its
+Objective and Acceptance Criteria current as work proceeds; change
+status only when the criteria are actually met.
+
+**Universal principle**: whenever the goal is understood and the work
+is about to start, create a task BEFORE executing. If you can write an
+Objective and Acceptance Criteria, it deserves a task. This is not
+optional and not limited to agent-building \u2014 it applies to any
+multi-step work (learning, building, modifying skills, fixing, anything
+with a clear goal).
 
 ## When to create (and when NOT)
 
@@ -12683,13 +12805,32 @@ Do NOT create tasks for:
 
 ## Setup
 
+**A task is a living record of the GOAL + ACCEPTANCE CRITERIA** \u2014 not a
+todo label. Every task's description must carry:
+
+- **Goal Model** \u2014 the full goal model ([[agent-architecture|Goal
+  Model]]): real goal, consumer (who uses the result), usable state
+  (what "done and usable" means concretely)
+- **Objective** \u2014 one measurable sentence: what result to achieve
+- **Acceptance Criteria** \u2014 checkboxes that define "done": when ALL
+  are checked, the task is verifiably complete
+
+The task is created when the goal is confirmed, and its description is
+CONTINUALLY UPDATED as the work progresses (spec evolves, criteria are
+met, new criteria emerge). Status changes only when the criteria are
+truly met \u2014 never as a workaround.
+
 - **Create the parent task when the scope is confirmed** \u2014 before
   starting the first real work phase (probe/design/build):
-  \`manage_task create(title: <goal>, description: <summary>, ownerType: "agent")\`
+  \`manage_task create(title: <goal>, description: <Objective + Acceptance Criteria>, ownerType: "agent")\`
   Record the returned parent task id.
 - **Create a subtask per phase** as you start each phase (probe /
   design / build / eval / retro):
-  \`manage_task create(title: <phase>, parentId: <parent>, ownerType: "agent")\`
+  \`manage_task create(title: <phase>, description: <Objective + Acceptance Criteria>, parentId: <parent>, ownerType: "agent")\`
+- **Update the description as work proceeds**: append progress, mark
+  criteria \`[x]\`, revise criteria when the goal model/spec changes.
+  The task tracks the target and its acceptance \u2014 read it to know what
+  "done" means, keep it current so it always reflects reality.
 
 ## Status discipline \u2014 MANDATORY
 
@@ -12820,8 +12961,13 @@ When unsure, use \`show_widget\` for visual comparison.
 - **Follow [[agent-architecture|Goal Model]]** \u2014 establish the goal
   model (real goal / consumer / usable state) and design the agent to
   achieve it; verification is goal-driven ([[agent-architecture|Goal-Driven Validation]]).
-- **NEVER build before confirming.** Design \u2192 ask \u2192 wait for "yes" \u2192
-  only then build. No exceptions.
+- **Follow [[agent-architecture|Knowledge in Skills]]** \u2014 the prompt is
+  thin (role/behavior); domain knowledge lives in SKILL.md which the
+  agent loads ("Load [[skill-name]] and follow it"). Never write
+  domain knowledge directly into a system prompt.
+- **NEVER build before confirming.** Design \u2192 confirm via
+  \`ask_user_to_clarify\` \u2192 wait for approval \u2192 only then build.
+  No exceptions.
 - **Track with tasks once scope is clear.** After requirements are
   clarified, create the parent task ([[task-tracking]]) before starting
   design. Don't create tasks during clarification.
@@ -12834,18 +12980,23 @@ When unsure, use \`show_widget\` for visual comparison.
 
 ## REACT design steps
 
-1. Understand the goal (who uses it? inputs? outputs?)
+1. **Establish the goal model FIRST** \u2014 real goal / user expectation /
+   consumer / usable state ([[agent-architecture|Goal Model]]); record
+   it in the parent task. Design, build, and verification all derive
+   from it. Only then:
 2. Choose middleware \u2014 call \`list_tools\` and \`list_middleware_types\`
    first. MUST include \`ask_user_to_clarify\` if the agent needs
    confirmation or clarifying questions.
 3. Write the system prompt: role \u2192 workflow \u2192 constraints
 4. Present the design with \`show_widget\`
-5. Ask for explicit approval \u2014 do NOT build until confirmed
+5. Confirm via \`ask_user_to_clarify\` \u2014 do NOT build until approved
 6. Build with \`create_agent\`
 
 ## DEEP_AGENT design steps
 
-1. Domain analysis \u2014 explain why DEEP_AGENT is the right choice
+1. **Establish the goal model FIRST** \u2014 real goal / consumer / usable
+   state, recorded in the parent task ([[agent-architecture|Goal
+   Model]]); then explain why DEEP_AGENT is the right choice
 2. Capability mapping with \`show_widget\`
 3. System prompt emphasizes dynamic todo workflow (analyze \u2192 break
    into todos \u2192 work one at a time \u2192 refine). Middleware: code_eval,
@@ -12997,6 +13148,9 @@ description: Run agent evaluations, interpret results, fix failures, and
 metadata:
   domain: agent-building
 verified: unverified
+subSkills:
+  - eval-design-tests
+  - eval-run-and-govern
 ---
 # Eval Verify \u2014 Run Evaluations and Upgrade Trust
 
@@ -13013,6 +13167,13 @@ verified: unverified
      parent (eval-{parent-id}) \u2014 see Layered verification below.
 2. \`manage_eval create_case(suiteId, ...)\` per sample or scenario
    Required: inputMessage, steps=[{agent_id}], outputType, contentAssertion
+   **contentAssertion MUST come from the confirmed expected output spec**
+   (learn-capability Phase 2.6) \u2014 never invent expectations at
+   case-writing time. If a needed expectation is not in the spec, extend
+   the spec with user confirmation first.
+   **HARD RULE**: if the target/expected output is unclear at this
+   point, STOP and ask the user (ask_user_to_clarify) \u2014 do not write a
+   case with a guessed expectation.
 
 ## Suites per skill, by source
 
@@ -13022,22 +13183,70 @@ verified: unverified
   (hold-out, never run during fix loop)
 - 0.2 \u2460 \u2192 {skill}-api-verified \u2014 queryability assertion, single step
 
-## Layered verification (orchestrator + subAgents)
-
-When the design has a parent deep_agent with subAgents (learn-capability
-Phase 2), verification is layered:
-- **Each sub-agent**: its OWN eval project (eval-{sub-agent-id}) \u2014 the
-  sub capability is verified independently, with its own fix loop.
-- **The parent agent**: an integration eval project (eval-{parent-id}).
-  Integration cases: full end-to-end task input \u2192 parent invokes
-  sub-agents \u2192 final aggregated output \u2192 contentAssertion on the final
-  result. This verifies ORCHESTRATION (does the parent call the right
-  sub-agents in the right order and aggregate correctly).
-- **Parent trust upgrade** requires BOTH: all sub-agent evals pass AND
-  the parent's integration eval passes. The parent's metadata
-  (verified/source) records this dependency.
-- Independent agents (no parent) keep single-level eval \u2014 no integration
-  layer needed.
+## Layered verification (orchestrator + components)
+
+When the design delegates to other agents, verification is layered.
+"Orchestrator" = a parent deep_agent with subAgents (learn-capability
+Phase 2) OR a workflow with \`ref\` steps ([[design-workflow]]).
+"Components" = the subAgents / ref'd agents it calls. Order is MANDATORY:
+**component evals first, integration second** \u2014 never run the
+integration eval before every component eval passes.
+
+- **Each component**: its OWN eval project (eval-{sub-agent-id} /
+  eval-{ref-agent-id}) \u2014 the sub capability is verified independently,
+  with its own fix loop.
+- **The orchestrator**: an integration eval project (eval-{parent-id} /
+  eval-{workflow-id}). Integration cases: full end-to-end task input \u2192
+  orchestrator invokes components \u2192 final aggregated output \u2192
+  contentAssertion on the final result. This verifies ORCHESTRATION
+  (does the orchestrator call the right components in the right order
+  and aggregate correctly).
+- **Workflow integration cases** also include branch paths and \`ask\`
+  handling (see Workflow testing below) \u2014 but only AFTER the ref'd
+  agents are independently verified.
+- **Orchestrator trust upgrade** requires BOTH: all component evals pass
+  AND the orchestrator's integration eval passes. The orchestrator's
+  metadata (verified/source) records this dependency.
+- Independent agents (no parent, no ref) keep single-level eval \u2014 no
+  integration layer needed.
+
+## Workflow testing (WORKFLOW-type agents)
+
+Workflows compile to the same agent registry and run through the same
+eval path \u2014 same project naming (eval-{agent-id}), same case structure
+(inputMessage + steps + contentAssertion). Design differs because the
+pipeline is DETERMINISTIC:
+
+- **One case per branch path** \u2014 each if/map/parallel route gets a case
+  whose inputMessage drives it down that path; contentAssertion = the
+  exact output that path must produce (from the expected output spec,
+  Phase 1.5 in [[design-workflow]]).
+- **Goal-driven dimensions** \u2014 cases cover all four dimensions
+  ([[agent-architecture|Goal-Driven Validation]]), not just happy paths:
+  - Functional correctness \u2014 each branch path produces the right result
+  - Edge robustness \u2014 empty input, if-condition not met, map source
+    empty, malformed data: the pipeline must fail gracefully or take
+    the designed fallback, not crash
+  - Business usability \u2014 output reaches the usable state (usable-state
+    cases come from the confirmed spec, never invented)
+  - Consumer fit \u2014 exact fields/format for system consumers, readable
+    for human consumers
+- **Data contract cases** \u2014 intermediate \`{{refs}}\` handoffs and
+  \`map\` source shapes are contracts; a contract broken mid-pipeline
+  only surfaces at the end. One case per non-trivial handoff asserting
+  the intermediate output shape (source data + step output).
+- **\`ask\` steps** \u2014 case interruptPolicy controls them
+  (mode: stop | auto-approve | auto-reject | canned-response):
+  - \`stop\` \u2192 the run pauses at the ask; assert the partial output
+    BEFORE the interaction point
+  - auto-approve / auto-reject / canned-response \u2192 supply the response
+    and continue; assert the flow AFTER the interaction point
+  - \`value\` holds the response text (defaults "\u540C\u610F"/"\u62D2\u7EDD" for
+    approve/reject)
+- **Exact assertions** \u2014 deterministic pipeline means expected outputs
+  are precise; judge still scores semantics on top.
+- **Trust upgrade is the same gate** \u2014 [[completion-gate]] applies to
+  workflows: no eval \u2192 stays configured, never verified.
 
 ## Run
 
@@ -13103,11 +13312,39 @@ verified: unverified
 # Design Workflow \u2014 WORKFLOW Agent Design
 
 Use the WORKFLOW type when the process is fully known \u2014 a deterministic
-state machine with pre-defined paths.
+state machine with pre-defined paths. If the process is NOT fully known
+(open-ended, needs dynamic decomposition) \u2192 use [[learn-capability]] /
+[[agent-build]] (REACT / DEEP_AGENT) instead.
 Follow [[agent-architecture|User Interaction Rules]] and
 [[agent-architecture|Goal Model]] \u2014 establish the goal model (real
 goal / consumer / usable state) before designing, and design steps
 that achieve it. Acceptance = workflow outcome meets the usable state.
+Follow [[agent-architecture|Knowledge in Skills]]: workflow steps
+orchestrate; domain knowledge lives in SKILL.md. Never write domain
+knowledge directly into a step's prompt \u2014 load it via [[skill-name]]
+or delegate to an agent that loads the skill.
+
+## CRITICAL RULES
+- **NEVER build before confirming.** Design \u2192 present the flow as a
+  widget \u2192 discuss step-by-step with the user \u2192 confirm via
+  \`ask_user_to_clarify\` (blocking approval) \u2192 only then call
+  \`create_workflow\`. No exceptions.
+- **Always visualize the design** \u2014 present with \`show_widget\` as a
+  Flowchart (every step, branch, \`ask\` interaction point) \u2014 never a
+  bare text list (see Visual communication below).
+- **One decision at a time.** Each message asks exactly one question.
+- **Track with tasks once scope is clear.** Create the parent task
+  ([[task-tracking]]) before designing; record the expected output spec
+  (Phase 1.5) in it.
+
+## Visual communication
+
+Use \`show_widget\` for all structure explanations \u2014 never ASCII art.
+| Scenario | What |
+|----------|------|
+| Workflow flow | Flowchart (steps, branches, ask points) |
+| Step-level comparison | Comparison cards |
+| Data flow / {{refs}} | Flowchart |
 
 ## Phase 0: Load Skills
 
@@ -13117,20 +13354,122 @@ that achieve it. Acceptance = workflow outcome meets the usable state.
 
 ## Phase 1: Design
 
-1. Analyze the process. Map every step, branch, data dependency.
-2. Design using the YAML linear DSL (steps, parallel, map, if, ask).
-3. Present the design as a widget.
-4. Confirm with user before building.
-
-## Phase 2: Build
+1. **Establish the goal model FIRST** \u2014 real goal / user expectation /
+   consumer / usable state ([[agent-architecture|Goal Model]]); record
+   it in the parent task. It drives the expected output spec (Phase
+   1.5) and verification (Phase 4). Then analyze the process: map
+   every step, branch, data dependency.
+2. **Choose implementation mode per step \u2014 ASK the user** (present as
+   comparison cards). Each step's logic is either inline or \`ref\`:
+   - **inline prompt** \u2014 logic lives in the step's prompt. Fast, no
+     extra agents. Cost: not reusable, no own tools, verified ONLY via
+     the integration eval. OK for trivial one-off glue steps.
+   - **ref sub-agent** \u2014 the step delegates to a registered agent with
+     its own tools/model/skills (built via [[agent-build]], prompt =
+     "Load [[skill-name]] and follow it"). Reusable, independently
+     verified (Phase 2.6). Use when the step needs tools, non-trivial
+     or reusable logic, or independent verification.
+   Present the per-step choice with trade-offs and let the user
+   decide \u2014 NEVER silently pick inline or ref. When in doubt, ask.
+3. **Identify knowledge per step** \u2014 for each step, determine the domain
+   knowledge it needs:
+   - Existing skill covers it \u2192 reference [[skill-name]] in the step
+   - No skill yet, but the knowledge is reusable or non-trivial \u2192
+     plan to create it (Phase 1.5)
+   - Trivial one-off logic \u2192 may stay inline in the prompt (accept the
+     trade-off: it is not reusable or individually verifiable)
+4. Design using the YAML linear DSL (steps, parallel, map, if, ask).
+5. **Present the design as a Flowchart widget** (\`show_widget\`) \u2014 every
+   step, branch, and \`ask\` interaction point. Walk through it with the
+   user step-by-step (each step's responsibility, branch logic, ask
+   points). CONFIRM via \`ask_user_to_clarify\` \u2014 never build without
+   explicit user approval.
+
+## Phase 1.5: Expected Output Specification (mandatory \u2014 goal-driven)
+
+Define the workflow's EXPECTED OUTPUT SPEC from the goal model BEFORE
+writing skills or building: what the final outcome looks like, per
+consumer (0.1.5). This is the acceptance standard \u2014 [[eval-verify]]
+contentAssertion derives from it. HARD RULE: if the target/expected
+output is unclear, ask the user \u2014 never guess.
+Present the spec, confirm with the user, record in the parent task.
+
+## Phase 2: Create Skills (for missing knowledge)
+
+For each planned skill (Phase 1.2): write SKILL.md (frontmatter +
+body encoding the domain rules). Present each for user approval.
+When 3+ skills share a domain \u2192 create a MOC ([[domain-moc]]).
+If a ref step needs an agent \u2192 build it via [[agent-build]] (agent
+prompt = "Load [[skill-name]] and follow it" \u2014 thin, knowledge in
+skill). Order: sub-agents/skills first, then the workflow that
+references them.
+
+## Phase 2.6: Verify components FIRST (mandatory)
+
+Every agent referenced by a \`ref\` step is a component with its OWN
+independent eval (eval-{ref-agent-id}) \u2014 run it and pass it BEFORE
+building the integration eval. The workflow cannot be considered tested
+until: \u2460 each ref'd agent's eval passes independently, \u2461 then the
+workflow's integration eval (branch paths + ask handling) passes. See
+[[eval-verify|Layered verification]].
+
+## Phase 3: Build
+
+1. **Configure middleware & tools for the workflow itself** \u2014 inline
+   steps run on the workflow's own model/tools: call
+   \`list_middleware_types\` first; add what the workflow needs \u2014 skill
+   (if steps load [[skill-name]]), widget, ask_user_to_clarify, etc.
+   Tool filtering via \`allowedTools\`. \`ref\` steps use the ref'd
+   agent's own tools/model \u2014 nothing to configure here. Choose
+   \`modelKey\` only when a specific model is required (default
+   otherwise).
+2. Call \`create_workflow\` with \`skillLoaded: true\` \u2014 steps reference
+   [[skill-name]] or \`ref\` to skill-loading agents.
+3. Then \`validate_workflow(id)\`.
+
+## Phase 4: Test (mandatory \u2014 no eval, no trust tier)
+
+The authoritative verification is [[eval-verify]] \u2014 cases derive from
+the expected output spec (Phase 1.5). A workflow without a passing eval
+stays at "configured" forever \u2014 trust can never upgrade
+([[completion-gate]], no skip option).
+
+**Testing is managed through the eval project (eval-{workflow-id})
+and its cases \u2014 the same governance as agents.** Temporary or quick
+checks (ad-hoc runs, previewing behavior) may use [[review-agent]] as
+an interactive pre-check \u2014 but that is NOT the workflow's test suite:
+it never upgrades trust and never replaces the eval project. Only the
+eval project's cases passing determine "tested".
+
+**Test order \u2014 components first, then integration:**
+1. Each \`ref\`'d agent: its OWN eval (eval-{ref-agent-id}) must pass
+   independently (Phase 2.6) \u2014 fix it in isolation, not through the
+   workflow.
+2. Then the workflow's integration eval (eval-{workflow-id}): one case
+   per branch path (if/map/parallel); \`ask\` steps via case
+   interruptPolicy (auto-approve/canned-response to test the flow AFTER
+   the pause, stop to test up to the pause); assertions are exact \u2014
+   the pipeline is deterministic.
+
+Workflow trust upgrade requires BOTH layers passing.
+[[review-agent]] is an optional cheap pre-check only.
+
+## Editing workflows
+
+Get the current YAML \u2192 present the diff \u2192 confirm with the user \u2192
+\`update_workflow(id, ...)\`. Never re-create.
+After ANY change: verified resets to unverified and the eval is re-run
+([[eval-verify]]) \u2014 the change is not done until the eval passes again.
+Deleting: warn if any step \`ref\`s it \u2192 confirm \u2192 \`delete_agent\`.
 
-Call \`create_workflow\` with \`skillLoaded: true\`, then
-\`validate_workflow(id)\`.
-
-## Phase 3: Test
+## Metadata
 
-Ask user if they want to test \u2014 the authoritative verification is
-[[eval-verify]]. [[review-agent]] is an optional cheap pre-check only.
+Always set metadata on workflow creation. At minimum:
+- verified: "unverified" (upgraded after eval passes)
+- version: "1.0" (bump on each update)
+- source: the material name or "user-description"
+When trust upgrades, update BOTH the skill's verified frontmatter and
+the workflow's metadata.verified \u2014 they must stay in sync.
 
 ## No edges, state fields, or end step
 The engine auto-generates them. Steps execute top-to-bottom in written
@@ -13356,10 +13695,20 @@ async function resolveConnections(type, connections, tenantId2) {
     throw err;
   }
 }
-async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised, tenantId2) {
+async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised, tenantId2, model) {
   const middlewares = [];
   middlewares.push(createUnknownToolHandlerMiddleware());
   middlewares.push(createModelSelectorMiddleware());
+  middlewares.push(createPatchToolCallsMiddleware());
+  if (model) {
+    middlewares.push(
+      (0, import_langchain46.summarizationMiddleware)({
+        model,
+        trigger: { tokens: 17e4 },
+        keep: { messages: 6 }
+      })
+    );
+  }
   const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
   const clawConfig = middlewareConfigs.find((m) => m.type === "claw");
   const needsFilesystemBackend = filesystemConfig?.enabled || clawConfig?.enabled;
@@ -13691,8 +14040,8 @@ var ReActAgentGraphBuilder = class {
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, void 0, params.tenantId);
-    return (0, import_langchain45.createAgent)({
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, void 0, params.tenantId, params.model);
+    return (0, import_langchain47.createAgent)({
       model: params.model,
       tools,
       systemPrompt: params.prompt,
@@ -13706,11 +14055,11 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent_new/agent.ts
-var import_langchain53 = require("langchain");
+var import_langchain54 = require("langchain");
 
 // src/deep_agent_new/middleware/subagents.ts
 var import_v32 = require("zod/v3");
-var import_langchain48 = require("langchain");
+var import_langchain50 = require("langchain");
 var import_langgraph8 = require("@langchain/langgraph");
 var import_messages3 = require("@langchain/core/messages");
 
@@ -14125,7 +14474,7 @@ var QueueMode = /* @__PURE__ */ ((QueueMode2) => {
 
 // src/services/Agent.ts
 var import_langgraph6 = require("@langchain/langgraph");
-var import_langchain46 = require("langchain");
+var import_langchain48 = require("langchain");
 
 // src/chunk_buffer_lattice/ChunkBuffer.ts
 var ChunkBuffer = class {
@@ -14622,7 +14971,7 @@ var Agent = class {
             });
             const humanContent = p.content;
             const input = {
-              messages: [new import_langchain46.HumanMessage({ id: humanContent.id, content: humanContent.message })]
+              messages: [new import_langchain48.HumanMessage({ id: humanContent.id, content: humanContent.message })]
             };
             if (files) {
               input.files = files;
@@ -14696,7 +15045,7 @@ var Agent = class {
             remainingPendings.forEach((p) => {
               this.queueStore?.markProcessing(p.id);
               const humanContent = p.content;
-              userMessages.push(new import_langchain46.HumanMessage({ id: humanContent.id, content: humanContent.message }));
+              userMessages.push(new import_langchain48.HumanMessage({ id: humanContent.id, content: humanContent.message }));
               this.publish("message:started", {
                 type: "message:started",
                 messageId: humanContent.id,
@@ -14776,7 +15125,7 @@ var Agent = class {
               if (signal?.aborted) break;
               await this.queueStore?.markProcessing(p.id);
               const humanContent = p.content;
-              const message = new import_langchain46.HumanMessage({ id: humanContent.id, content: humanContent.message });
+              const message = new import_langchain48.HumanMessage({ id: humanContent.id, content: humanContent.message });
               const startTime = Date.now();
               this.publish("message:started", {
                 type: "message:started",
@@ -14947,7 +15296,7 @@ var Agent = class {
     const messageId = (0, import_uuid4.v4)();
     const input = {
       ...queueMessage.input,
-      messages: [new import_langchain46.HumanMessage({ id: messageId, content: queueMessage.input.message })]
+      messages: [new import_langchain48.HumanMessage({ id: messageId, content: queueMessage.input.message })]
     };
     const inputMessage = { ...queueMessage, input };
     return this.agentExecutor(inputMessage, signal);
@@ -14966,7 +15315,7 @@ var Agent = class {
     const messageId = (0, import_uuid4.v4)();
     const input = {
       ...queueMessage.input,
-      messages: [new import_langchain46.HumanMessage({ id: messageId, content: queueMessage.input.message })]
+      messages: [new import_langchain48.HumanMessage({ id: messageId, content: queueMessage.input.message })]
     };
     const inputMessage = { ...queueMessage, input };
     const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(inputMessage.custom_run_config);
@@ -15329,7 +15678,7 @@ var Agent = class {
   async getCurrentMessages() {
     const state = await this.getCurrentState();
     const messages = state.values.messages || [];
-    const filteredMessages = (0, import_langchain46.filterMessages)(messages, {
+    const filteredMessages = (0, import_langchain48.filterMessages)(messages, {
       includeTypes: ["ai", "human", "tool"]
       //["human", "ai", "tool"],
     });
@@ -15648,7 +15997,7 @@ var AgentInstanceManager = class _AgentInstanceManager {
 var agentInstanceManager = AgentInstanceManager.getInstance();
 
 // src/middlewares/taskMiddleware.ts
-var import_langchain47 = require("langchain");
+var import_langchain49 = require("langchain");
 var import_zod43 = require("zod");
 var import_langgraph7 = require("@langchain/langgraph");
 function getRunConfig(config) {
@@ -15956,26 +16305,37 @@ function createTaskMiddleware() {
         });
     }
   };
-  return (0, import_langchain47.createMiddleware)({
+  return (0, import_langchain49.createMiddleware)({
     name: "TaskMiddleware",
     contextSchema,
     wrapModelCall: async (request, handler) => {
       const taskPrompt = `## Task Management
 
-You can use the \`manage_task\` tool to create persistent tasks for user-visible work tracking.
+You have the \`manage_task\` tool to track work. Task management is the
+ongoing record of a GOAL and its ACCEPTANCE CRITERIA.
 
-### When to create a task
+### When to create a task (universal rule)
+- The goal is clear and you are about to start real work \u2192 create the
+  parent task FIRST (with Objective + Acceptance Criteria in the
+  description), then execute. This is a core duty, not optional.
 - The user explicitly asks you to track, manage, or follow up on work
 - The work spans multiple sessions or might need resumption later
 - The user needs to review or approve output before it is considered done
 - There are multiple independent work items the user wants visibility into
 
 ### When NOT to create a task
+- Goal not yet clear (still clarifying) \u2014 clarify first, then create
 - One-shot lookups or simple Q&A ("what is X?", "search for Y")
 - Internal exploration steps you take to understand the problem (use \`write_todos\` for your execution plan instead)
 - Trivial single-step actions that complete in the same turn
 - Conversational or informational requests with no deliverable
 
+### Keep the task current
+A task is the living record of the goal + its acceptance criteria.
+Update the description as work proceeds: check off criteria as met,
+revise criteria when scope changes, append progress. Status changes
+only when the criteria are truly met.
+
 ### Ownership defaults
 - No params: ownerType defaults to "user" with current user's ID
 - ownerType="agent": auto-fills ownerId from current agent (subtask for yourself)
@@ -15986,7 +16346,7 @@ You can use the \`manage_task\` tool to create persistent tasks for user-visible
       });
     },
     tools: [
-      (0, import_langchain47.tool)(
+      (0, import_langchain49.tool)(
         handleManageTask,
         {
           name: "manage_task",
@@ -16029,6 +16389,29 @@ var taskPlugin = {
   skills: {
     "task-definition": `## Using manage_task
 
+### When to create a task (universal rule)
+
+Create a task BEFORE executing whenever the goal is clear and you know
+what to do \u2014 not just for long or complex work:
+
+- Goal is understood and you are about to start real work \u2192 create the
+  parent task FIRST, then execute. The task tracks the work.
+- Goal is NOT yet clear (still clarifying, gathering requirements) \u2192
+  do NOT create a task yet. Clarify first, create the task once scope
+  is defined.
+- One-shot lookups, trivial single-step actions, or internal reasoning
+  \u2192 no task needed.
+
+Rule of thumb: if you can write an Objective and Acceptance Criteria
+for it, create the task before doing it. Work without a task = work
+without a contract.
+
+**A task is the living record of the goal + its acceptance criteria.**
+Keep the description current as work proceeds: update the Objective
+when the target evolves, check off criteria as they are met, revise
+criteria when scope changes. Reading the task always tells you what
+"done" means; an outdated task is a broken contract.
+
 ### Task description format
 
 When creating a task with manage_task, write the description in this Markdown structure:
@@ -16230,7 +16613,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new import_langchain48.ToolMessage({
+        new import_langchain50.ToolMessage({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -16259,10 +16642,10 @@ function getSubagents(options) {
     const generalPurposeMiddleware = [...defaultSubagentMiddleware, ...taskMiddleware];
     if (defaultInterruptOn) {
       generalPurposeMiddleware.push(
-        (0, import_langchain48.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
+        (0, import_langchain50.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
       );
     }
-    const generalPurposeSubagent = (0, import_langchain48.createAgent)({
+    const generalPurposeSubagent = (0, import_langchain50.createAgent)({
       model: defaultModel,
       systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
@@ -16285,8 +16668,8 @@ function getSubagents(options) {
       const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...taskMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware, ...taskMiddleware];
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
-        middleware.push((0, import_langchain48.humanInTheLoopMiddleware)({ interruptOn }));
-      agents[agentParams.key] = (0, import_langchain48.createAgent)({
+        middleware.push((0, import_langchain50.humanInTheLoopMiddleware)({ interruptOn }));
+      agents[agentParams.key] = (0, import_langchain50.createAgent)({
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
@@ -16336,7 +16719,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return (0, import_langchain48.tool)(
+  return (0, import_langchain50.tool)(
     async (input, config) => {
       const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
@@ -16423,7 +16806,7 @@ You are executing a persistent task (ID: ${input.taskId}). Use manage_task.updat
           return new import_langgraph8.Command({
             update: {
               messages: [
-                new import_langchain48.ToolMessage({
+                new import_langchain50.ToolMessage({
                   content: `Async task started: ${subagent_thread_id}
 ${description}
 The result will be delivered as a notification when complete. Do not poll.`,
@@ -16457,7 +16840,7 @@ The result will be delivered as a notification when complete. Do not poll.`,
         return new import_langgraph8.Command({
           update: {
             messages: [
-              new import_langchain48.ToolMessage({
+              new import_langchain50.ToolMessage({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -16500,7 +16883,7 @@ function getMainAgentFromConfig(config) {
   });
 }
 function createCheckAsyncTaskTool() {
-  return (0, import_langchain48.tool)(
+  return (0, import_langchain50.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -16567,7 +16950,7 @@ Description: ${cached.description}`;
   );
 }
 function createListAsyncTasksTool() {
-  return (0, import_langchain48.tool)(
+  return (0, import_langchain50.tool)(
     async (_input, config) => {
       const mainAgent = getMainAgentFromConfig(config);
       if (!mainAgent) {
@@ -16618,7 +17001,7 @@ function createListAsyncTasksTool() {
   );
 }
 function createCancelAsyncTaskTool() {
-  return (0, import_langchain48.tool)(
+  return (0, import_langchain50.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -16694,7 +17077,7 @@ function createSubAgentMiddleware(options) {
     );
   }
   const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
-  return (0, import_langchain48.createMiddleware)({
+  return (0, import_langchain50.createMiddleware)({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -16713,51 +17096,8 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
   });
 }
 
-// src/deep_agent_new/middleware/patch_tool_calls.ts
-var import_langchain49 = require("langchain");
-function createPatchToolCallsMiddleware() {
-  return (0, import_langchain49.createMiddleware)({
-    name: "patchToolCallsMiddleware",
-    beforeAgent: async (state) => {
-      const messages = state.messages;
-      if (!messages || messages.length === 0) {
-        return;
-      }
-      const patchedMessages = [];
-      for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        patchedMessages.push(msg);
-        if (import_langchain49.AIMessage.isInstance(msg) && msg.tool_calls != null) {
-          for (const toolCall of msg.tool_calls) {
-            const correspondingToolMsg = messages.slice(i).find(
-              (m) => import_langchain49.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
-            );
-            if (!correspondingToolMsg) {
-              const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
-              patchedMessages.push(
-                new import_langchain49.ToolMessage({
-                  content: toolMsg,
-                  name: toolCall.name,
-                  tool_call_id: toolCall.id
-                })
-              );
-            }
-          }
-        }
-      }
-      if (patchedMessages.length === messages.length) {
-        return;
-      }
-      return {
-        messages: patchedMessages.slice(messages.length)
-        // only the new ToolMessage patches
-      };
-    }
-  });
-}
-
 // src/deep_agent_new/middleware/date.ts
-var import_langchain50 = require("langchain");
+var import_langchain51 = require("langchain");
 var import_zod44 = require("zod");
 function formatCurrentDate(timezone = "UTC") {
   const now = /* @__PURE__ */ new Date();
@@ -16786,10 +17126,10 @@ function generateDateContext(timezone = "UTC") {
 function createDateMiddleware(options = {}) {
   const timezone = options.timezone || "UTC";
   const dateContext = generateDateContext(timezone);
-  return (0, import_langchain50.createMiddleware)({
+  return (0, import_langchain51.createMiddleware)({
     name: "DateMiddleware",
     tools: [
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async () => {
           const now = /* @__PURE__ */ new Date();
           let validTimezone = timezone;
@@ -16885,7 +17225,7 @@ var datePlugin = {
 };
 
 // src/deep_agent_new/middleware/scheduler.ts
-var import_langchain51 = require("langchain");
+var import_langchain52 = require("langchain");
 var import_zod45 = require("zod");
 var import_uuid5 = require("uuid");
 var import_protocols8 = require("@axiom-lattice/protocols");
@@ -17954,10 +18294,10 @@ function registerAgentAddMessageHandler() {
 function createSchedulerMiddleware(options = {}) {
   const defaultMaxRetries = options.defaultMaxRetries ?? 0;
   registerAgentAddMessageHandler();
-  return (0, import_langchain51.createMiddleware)({
+  return (0, import_langchain52.createMiddleware)({
     name: "SchedulerMiddleware",
     tools: [
-      (0, import_langchain51.tool)(
+      (0, import_langchain52.tool)(
         async (input, config) => {
           const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
@@ -17992,7 +18332,7 @@ function createSchedulerMiddleware(options = {}) {
           })
         }
       ),
-      (0, import_langchain51.tool)(
+      (0, import_langchain52.tool)(
         async (input, config) => {
           const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
@@ -18027,7 +18367,7 @@ function createSchedulerMiddleware(options = {}) {
           })
         }
       ),
-      (0, import_langchain51.tool)(
+      (0, import_langchain52.tool)(
         async (input, config) => {
           const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
@@ -18071,7 +18411,7 @@ function createSchedulerMiddleware(options = {}) {
           })
         }
       ),
-      (0, import_langchain51.tool)(
+      (0, import_langchain52.tool)(
         async (input) => {
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const success = await scheduleLattice.client.cancel(input.taskId);
@@ -18085,7 +18425,7 @@ function createSchedulerMiddleware(options = {}) {
           })
         }
       ),
-      (0, import_langchain51.tool)(
+      (0, import_langchain52.tool)(
         async (input, config) => {
           const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
@@ -19355,7 +19695,7 @@ var MemoryBackend = class {
 // src/deep_agent_new/middleware/todos.ts
 var import_langgraph9 = require("@langchain/langgraph");
 var import_zod46 = require("zod");
-var import_langchain52 = require("langchain");
+var import_langchain53 = require("langchain");
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -19589,13 +19929,13 @@ var TodoSchema = import_zod46.z.object({
 });
 var stateSchema = import_zod46.z.object({ todos: import_zod46.z.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = (0, import_langchain52.tool)(
+  const writeTodos = (0, import_langchain53.tool)(
     ({ todos }, config) => {
       return new import_langgraph9.Command({
         update: {
           todos,
           messages: [
-            new import_langchain52.ToolMessage({
+            new import_langchain53.ToolMessage({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -19611,7 +19951,7 @@ function todoListMiddleware(options) {
       })
     }
   );
-  return (0, import_langchain52.createMiddleware)({
+  return (0, import_langchain53.createMiddleware)({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -19662,42 +20002,26 @@ ${BASE_PROMPT}` : BASE_PROMPT;
         createFilesystemMiddleware({
           backend: filesystemBackend
         }),
-        // Subagent middleware: Automatic conversation summarization when token limits are approached
-        (0, import_langchain53.summarizationMiddleware)({
-          model,
-          trigger: { tokens: 17e4 },
-          keep: { messages: 6 }
-        }),
         // Subagent middleware: Anthropic prompt caching for improved performance
-        (0, import_langchain53.anthropicPromptCachingMiddleware)({
+        (0, import_langchain54.anthropicPromptCachingMiddleware)({
           unsupportedModelBehavior: "ignore"
         }),
-        // Subagent middleware: Patches tool calls for compatibility
-        createPatchToolCallsMiddleware(),
         ...customMiddleware
       ],
       defaultInterruptOn: interruptOn,
       subagents,
       generalPurposeAgent: true
     }),
-    // Automatically summarizes conversation history when token limits are approached
-    (0, import_langchain53.summarizationMiddleware)({
-      model,
-      trigger: { tokens: 17e4 },
-      keep: { messages: 6 }
-    }),
     // Enables Anthropic prompt caching for improved performance and reduced costs
-    (0, import_langchain53.anthropicPromptCachingMiddleware)({
+    (0, import_langchain54.anthropicPromptCachingMiddleware)({
       unsupportedModelBehavior: "ignore"
-    }),
-    // Patches tool calls to ensure compatibility across different model providers
-    createPatchToolCallsMiddleware()
+    })
   ];
   if (interruptOn) {
-    middleware.push((0, import_langchain53.humanInTheLoopMiddleware)({ interruptOn }));
+    middleware.push((0, import_langchain54.humanInTheLoopMiddleware)({ interruptOn }));
   }
   middleware.push(...customMiddleware);
-  return (0, import_langchain53.createAgent)({
+  return (0, import_langchain54.createAgent)({
     model,
     systemPrompt: finalSystemPrompt,
     tools,
@@ -19747,7 +20071,7 @@ var DeepAgentGraphBuilder = class {
     }));
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true, params.tenantId);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true, params.tenantId, params.model);
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
@@ -19769,7 +20093,7 @@ init_MemoryLatticeManager();
 
 // src/agent_team/agent_team.ts
 var import_v35 = require("zod/v3");
-var import_langchain56 = require("langchain");
+var import_langchain57 = require("langchain");
 
 // src/agent_team/types.ts
 var TaskStatus = /* @__PURE__ */ ((TaskStatus3) => {
@@ -20205,13 +20529,13 @@ var InMemoryMailboxStore = class {
 
 // src/agent_team/middleware/team.ts
 var import_v34 = require("zod/v3");
-var import_langchain55 = require("langchain");
+var import_langchain56 = require("langchain");
 var import_langgraph11 = require("@langchain/langgraph");
 var import_uuid6 = require("uuid");
 
 // src/agent_team/middleware/teammate_tools.ts
 var import_v33 = require("zod/v3");
-var import_langchain54 = require("langchain");
+var import_langchain55 = require("langchain");
 var import_langgraph10 = require("@langchain/langgraph");
 
 // src/agent_team/middleware/formatMessages.ts
@@ -20236,7 +20560,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = (0, import_langchain54.tool)(
+  const claimTaskTool = (0, import_langchain55.tool)(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -20266,7 +20590,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const completeTaskTool = (0, import_langchain54.tool)(
+  const completeTaskTool = (0, import_langchain55.tool)(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -20293,7 +20617,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const failTaskTool = (0, import_langchain54.tool)(
+  const failTaskTool = (0, import_langchain55.tool)(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -20320,7 +20644,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const sendMessageTool = (0, import_langchain54.tool)(
+  const sendMessageTool = (0, import_langchain55.tool)(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -20358,7 +20682,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = (0, import_langchain54.tool)(
+  const readMessagesTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -20370,7 +20694,7 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new import_langchain54.ToolMessage({
+        const toolMessage2 = new import_langchain55.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -20395,7 +20719,7 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain54.ToolMessage({
+        const toolMessage2 = new import_langchain55.ToolMessage({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -20405,7 +20729,7 @@ function createTeammateTools(options) {
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain54.ToolMessage({
+      const toolMessage = new import_langchain55.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -20420,7 +20744,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const checkTasksTool = (0, import_langchain54.tool)(
+  const checkTasksTool = (0, import_langchain55.tool)(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -20431,7 +20755,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const broadcastMessageTool = (0, import_langchain54.tool)(
+  const broadcastMessageTool = (0, import_langchain55.tool)(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -20617,7 +20941,7 @@ You have access to these tools:
 - \`read_messages\`: Read messages from team_lead or teammates
 - \`check_tasks\`: Get current status of all tasks in the team`;
   const assistantId = getTeammateAssistantId(ctx.teamId, spec.name);
-  agent = (0, import_langchain55.createAgent)({
+  agent = (0, import_langchain56.createAgent)({
     model: spec.model ?? ctx.defaultModel,
     systemPrompt: teammatePrompt,
     tools: allTools,
@@ -20686,12 +21010,12 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore, tenantId: tenantId2 } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = (0, import_langchain55.tool)(
+  const createTeamTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const state = (0, import_langgraph11.getCurrentTaskInput)();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new import_langchain55.ToolMessage({
+        const msg = new import_langchain56.ToolMessage({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
@@ -20780,7 +21104,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new import_langchain55.ToolMessage({
+      const toolMessage = new import_langchain56.ToolMessage({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -20865,7 +21189,7 @@ After calling create_team, you MUST:
     if (state?.team?.teamId) return state.team.teamId;
     throw new Error("No team_id provided and no team in state. Call create_team first.");
   };
-  const addTasksTool = (0, import_langchain55.tool)(
+  const addTasksTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -20879,7 +21203,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -20930,20 +21254,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const assignTaskTool = (0, import_langchain55.tool)(
+  const assignTaskTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new import_langchain55.ToolMessage({
+        return new import_langchain56.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -20958,20 +21282,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskStatusTool = (0, import_langchain55.tool)(
+  const setTaskStatusTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new import_langchain55.ToolMessage({
+        return new import_langchain56.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -20986,20 +21310,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskDependenciesTool = (0, import_langchain55.tool)(
+  const setTaskDependenciesTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new import_langchain55.ToolMessage({
+        return new import_langchain56.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -21014,7 +21338,7 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const checkTasksTool = (0, import_langchain55.tool)(
+  const checkTasksTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -21023,7 +21347,7 @@ IMPORTANT: Assigning to a specific teammate
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new import_langchain55.ToolMessage({
+            new import_langchain56.ToolMessage({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -21059,7 +21383,7 @@ Task Status Values:
       })
     }
   );
-  const sendMessageTool = (0, import_langchain55.tool)(
+  const sendMessageTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -21069,7 +21393,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -21084,7 +21408,7 @@ Task Status Values:
       })
     }
   );
-  const readMessagesTool = (0, import_langchain55.tool)(
+  const readMessagesTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -21112,7 +21436,7 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new import_langchain55.ToolMessage({
+        const toolMessage2 = new import_langchain56.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -21144,7 +21468,7 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain55.ToolMessage({
+        const toolMessage2 = new import_langchain56.ToolMessage({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -21154,7 +21478,7 @@ Task Status Values:
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain55.ToolMessage({
+      const toolMessage = new import_langchain56.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -21171,7 +21495,7 @@ Task Status Values:
       })
     }
   );
-  const disbandTeamTool = (0, import_langchain55.tool)(
+  const disbandTeamTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -21181,7 +21505,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -21192,7 +21516,7 @@ Task Status Values:
       description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
     }
   );
-  const broadcastMessageTool = (0, import_langchain55.tool)(
+  const broadcastMessageTool = (0, import_langchain56.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -21201,7 +21525,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new import_langchain55.ToolMessage({
+      return new import_langchain56.ToolMessage({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -21215,7 +21539,7 @@ Task Status Values:
       })
     }
   );
-  return (0, import_langchain55.createMiddleware)({
+  return (0, import_langchain56.createMiddleware)({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -21324,7 +21648,7 @@ function createAgentTeam(config) {
   ];
   const systemPrompt = config.systemPrompt + "\n\n" + TEAM_LEAD_BASE_PROMPT;
   const stateSchema2 = createReactAgentSchema(TEAM_STATE_SCHEMA);
-  return (0, import_langchain56.createAgent)({
+  return (0, import_langchain57.createAgent)({
     model: config.model ?? "claude-sonnet-4-5-20250929",
     systemPrompt,
     tools: [],
@@ -21367,7 +21691,7 @@ var TeamAgentGraphBuilder = class {
     });
     const middlewareConfigs = params.middleware || [];
     let filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, void 0, void 0, params.model);
     if (!filesystemBackend) {
       filesystemBackend = async (config2) => {
         return new StateBackend(config2);
@@ -21736,7 +22060,7 @@ function extractLastHumanMessage(messages) {
 }
 
 // src/agent_lattice/builders/WorkflowAgentGraphBuilder.ts
-var import_langchain57 = require("langchain");
+var import_langchain58 = require("langchain");
 init_MemoryLatticeManager();
 var import_protocols10 = require("@axiom-lattice/protocols");
 init_compile();
@@ -21787,7 +22111,7 @@ var WorkflowAgentGraphBuilder = class {
     const checkpointer = getCheckpointSaver("default");
     const tools = params.tools.map((t) => t.executor).filter(Boolean);
     const middlewareConfigs = params.middleware || [];
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false, params.tenantId);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false, params.tenantId, params.model);
     const askMiddlewares = await createCommonMiddlewares([
       {
         id: "ask_user_to_clarify",
@@ -21797,11 +22121,11 @@ var WorkflowAgentGraphBuilder = class {
         enabled: true,
         config: {}
       }
-    ], void 0, false);
+    ], void 0, false, void 0, params.model);
     const noWrapMiddlewares = stripWrapModelCallHook(middlewares);
     const noWrapAskMiddlewares = stripWrapModelCallHook(askMiddlewares);
     console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
-    const defaultAgent = (0, import_langchain57.createAgent)({
+    const defaultAgent = (0, import_langchain58.createAgent)({
       model: params.model,
       tools,
       systemPrompt: buildStepSystemPrompt(false, params.prompt),
@@ -21821,7 +22145,7 @@ var WorkflowAgentGraphBuilder = class {
         console.log(`[WF BUILDER] resolveAgent: cacheKey=${key4.slice(0, 80)}... | cached=${agentCache.has(key4)}`);
         if (!agentCache.has(key4)) {
           console.log(`[WF BUILDER] creating ${isAsk ? "ask" : "agent"} with responseFormat`);
-          const agent = (0, import_langchain57.createAgent)({
+          const agent = (0, import_langchain58.createAgent)({
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(isAsk, params.prompt),
@@ -21837,7 +22161,7 @@ var WorkflowAgentGraphBuilder = class {
         const key4 = "ask:default";
         if (!agentCache.has(key4)) {
           console.log(`[WF BUILDER] creating ask default agent`);
-          const agent = (0, import_langchain57.createAgent)({
+          const agent = (0, import_langchain58.createAgent)({
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(true, params.prompt),
@@ -23476,6 +23800,40 @@ Call the \`skill\` tool with skill_name: "agent-architecture" to load the
 authoritative workflow. Never announce that you will follow a skill \u2014
 load it and follow its content. If the load fails, retry once, then report it.
 
+TASK MANAGEMENT IS A CORE DUTY, not a per-skill option. Whenever the
+goal is clear and you know what to do, create a task FIRST (manage_task)
+before executing \u2014 for any multi-step work: learning, building,
+modifying, fixing, anything with an Objective and Acceptance Criteria.
+- **Check for duplicates BEFORE creating** \u2014 always manage_task
+  action: "list" first (filter ownerType: "agent"). If a task with the
+  same objective already exists (e.g. from an interrupted session),
+  RESUME it instead of creating a new one.
+- **Decompose into subtasks** \u2014 after the parent task, create a
+  subtask per work item / phase (e.g. design, build, eval), each with
+  its own Objective + Acceptance Criteria.
+- **Update on completion** \u2014 every finished subtask and the parent:
+  manage_task update(status: "completed", result: "what was done").
+  Use interrupted/failed with summary/failureReason when blocked or
+  unable. Status must always reflect reality \u2014 never leave a finished
+  task dangling in an in-progress state.
+See [[task-tracking]].
+The sub-skills below only ADD their own task details on top of this
+universal duty.
+
+BUILD GATES \u2014 hard behavioral requirements, no exceptions, no skipping:
+- Creating a WORKFLOW ([[design-workflow]]): \u2460 show the design as a
+  Flowchart widget (every step, branch, ask point) \u2461 walk through it
+  step-by-step with the user \u2462 ask inline-vs-ref per step \u2463 CONFIRM via
+  ask_user_to_clarify \u2014 only then call create_workflow.
+- Creating an AGENT ([[agent-build]]): \u2460 present the design with
+  show_widget \u2461 confirm via ask_user_to_clarify \u2014 only then call
+  create_agent.
+- Both: if the goal model (real goal / consumer / usable state) is
+  unclear, ask BEFORE designing \u2014 never guess.
+The skills document WHY and HOW; these gates are the unskippable
+minimum. If you cannot satisfy a gate (e.g. user says skip), record it
+and proceed only on the user's explicit instruction.
+
 Your sub-skills (accessible via the MOC or direct loading):
 - [[learn-capability]] \u2014 Learn from any source material \u2192 skills + agents
 - [[agent-build]] \u2014 Design and build single agents (REACT/DEEP_AGENT)
@@ -23640,7 +23998,15 @@ var agentArchitectConfig = {
       id: "task",
       type: "task",
       name: "Task",
-      description: "Track learning processes and fix loops with approval gates",
+      description: "Core architect duty: once the goal is clear, create tasks to track every multi-step piece of work (learning, building, modifying, fixing). Subtasks per work item; status reflects reality.",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "code_eval",
+      type: "code_eval",
+      name: "Code Evaluation",
+      description: "Execute shell commands in the sandbox to support agent creation: unzip files, process data, run helper scripts. Distinct from the eval assessment system (run_eval).",
       enabled: true,
       config: {}
     },
@@ -27267,6 +27633,15 @@ function parseJudgeVerdict(raw) {
     return { error: error instanceof Error ? error.message : String(error) };
   }
 }
+var MAX_INTERRUPT_RESUMES = 5;
+function resolveInterruptResponse(policy, interrupt5) {
+  if (policy.mode === "auto-approve") return policy.value ?? "\u540C\u610F";
+  if (policy.mode === "auto-reject") return policy.value ?? "\u62D2\u7EDD";
+  return policy.value ?? "";
+}
+function interruptValueText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
 var _LatticeEval = class _LatticeEval {
   constructor(config = {}) {
     this.inMemoryLogs = [];
@@ -27333,7 +27708,8 @@ var _LatticeEval = class _LatticeEval {
       return acc;
     }, {});
   }
-  async executeAgentStep(step, threadId, inputMessage, files) {
+  async executeAgentStep(step, threadId, inputMessage, files, interruptPolicy) {
+    const hitlEvents = [];
     this.log("Executing agent step", {
       agent_id: step.agent_id,
       thread_id: threadId,
@@ -27351,19 +27727,74 @@ var _LatticeEval = class _LatticeEval {
     };
     const agent = agentInstanceManager.getAgent(agentParams);
     try {
-      const result = await agent.invoke({
-        input: {
-          message: step.override_message || inputMessage,
-          files: this.buildFileEntries(files)
+      const stepInput = {
+        message: step.override_message || inputMessage,
+        files: this.buildFileEntries(files)
+      };
+      let result = await agent.invokeWithState({ input: stepInput });
+      let resumeCount = 0;
+      let pendingInterrupt;
+      let interrupts = Array.isArray(result?.__interrupt__) ? result.__interrupt__ : [];
+      while (interrupts.length > 0) {
+        const interrupt5 = interrupts[0];
+        if (!interrupt5) break;
+        const policy = interruptPolicy;
+        if (!policy || policy.mode === "stop" || resumeCount >= MAX_INTERRUPT_RESUMES) {
+          pendingInterrupt = interrupt5;
+          break;
         }
-      });
+        const response = resolveInterruptResponse(policy, interrupt5);
+        hitlEvents.push({
+          type: "interrupt",
+          id: interrupt5.id,
+          value: interrupt5.value
+        });
+        this.log("Auto-resolving HITL interrupt", {
+          agent_id: step.agent_id,
+          thread_id: threadId,
+          mode: policy.mode,
+          interrupt_id: interrupt5.id,
+          response,
+          resume_count: resumeCount + 1
+        });
+        result = await agent.invokeWithState({ input: stepInput, command: { resume: response } });
+        hitlEvents.push({
+          type: "interrupt_response",
+          id: interrupt5.id,
+          mode: policy.mode,
+          response
+        });
+        resumeCount++;
+        interrupts = Array.isArray(result?.__interrupt__) ? result.__interrupt__ : [];
+      }
+      if (pendingInterrupt) {
+        hitlEvents.push({
+          type: "interrupt",
+          id: pendingInterrupt.id,
+          value: pendingInterrupt.value
+        });
+        this.log("Agent step interrupted by HITL (human input requested)", {
+          agent_id: step.agent_id,
+          thread_id: threadId,
+          interrupt_id: pendingInterrupt.id,
+          auto_resolved: resumeCount
+        });
+      } else {
+        this.log("Agent step completed", {
+          agent_id: step.agent_id,
+          thread_id: threadId,
+          response_keys: result ? Object.keys(result) : [],
+          auto_resolved: resumeCount
+        });
+      }
       const responseData = { success: true, ...result };
-      this.log("Agent step completed", {
-        agent_id: step.agent_id,
-        thread_id: threadId,
-        response_keys: result ? Object.keys(result) : []
-      });
-      return { threadId, responseData };
+      return {
+        threadId,
+        responseData,
+        interrupted: pendingInterrupt ? true : void 0,
+        interrupt: pendingInterrupt,
+        hitlEvents
+      };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.log("Agent step failed", {
@@ -27426,15 +27857,32 @@ var _LatticeEval = class _LatticeEval {
     });
     let currentThreadId = threadId;
     let lastResponseData = null;
+    let interrupt5;
     for (const step of evalCase.steps) {
       const result = await this.executeAgentStep(
         step,
         currentThreadId,
         evalCase.input.message,
-        evalCase.input.files || {}
+        evalCase.input.files || {},
+        evalCase.interruptPolicy
       );
       currentThreadId = result.threadId;
       lastResponseData = result.responseData;
+      for (const evt of result.hitlEvents) {
+        if (evt.type === "interrupt") {
+          this.lastMessages.push({
+            role: "interrupt",
+            content: `HITL \u6682\u505C\uFF1AAgent \u8BF7\u6C42\u4EBA\u5DE5\u8F93\u5165 \u2014 ${interruptValueText(evt.value)}`,
+            id: evt.id
+          });
+        } else {
+          this.lastMessages.push({
+            role: "interrupt_response",
+            content: `\u5DF2\u81EA\u52A8\u54CD\u5E94\uFF08\u6D4B\u8BD5\u7B56\u7565 ${evt.mode}\uFF09\uFF1A${evt.response}`,
+            id: evt.id
+          });
+        }
+      }
       const existingIds = new Set(this.lastMessages.map((m) => m.id).filter(Boolean));
       if (result.responseData?.messages && Array.isArray(result.responseData.messages)) {
         for (const msg of result.responseData.messages) {
@@ -27456,6 +27904,13 @@ var _LatticeEval = class _LatticeEval {
             } else {
               content = String(msg.content || "");
             }
+            if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+              const toolCallStr = msg.tool_calls.map(
+                (tc) => `tool_call: ${tc.name}(${JSON.stringify(tc.args ?? {})})`
+              ).join("\n");
+              content = content ? `${content}
+${toolCallStr}` : toolCallStr;
+            }
             this.lastMessages.push({
               role,
               content,
@@ -27467,13 +27922,21 @@ var _LatticeEval = class _LatticeEval {
           }
         }
       }
+      if (result.interrupted) {
+        interrupt5 = result.interrupt;
+        this.log("Case paused for HITL \u2014 remaining steps skipped; judge will evaluate the pause", {
+          case_id: evalCase.caseId,
+          interrupt_id: interrupt5?.id
+        });
+        break;
+      }
     }
     this.log("All agent steps completed", {
       case_id: evalCase.caseId,
       final_thread_id: currentThreadId,
       message_count: this.lastMessages.length
     });
-    const finalOutput = this.extractFinalMessage(lastResponseData);
+    const finalOutput = interrupt5 ? typeof interrupt5.value === "string" ? interrupt5.value : JSON.stringify(interrupt5.value ?? "") : this.extractFinalMessage(lastResponseData);
     this.lastFinalOutput = finalOutput;
     const trajectory = this.buildTrajectory();
     this.log("Final output extracted", {
@@ -27532,6 +27995,8 @@ ${rubricsSection}
 3. **\u8FC7\u7A0B\u6821\u9A8C**\uFF1A\u5982\u679C"\u6267\u884C\u8FC7\u7A0B"\u663E\u793A Agent \u672A\u6267\u884C\u5FC5\u8981\u7684\u4E2D\u95F4\u6B65\u9AA4\uFF08\u5982\u5E94\u8C03\u7528\u5DE5\u5177\u800C\u672A\u8C03\u7528\uFF09\uFF0C\u5373\u4F7F\u6700\u7EC8\u8F93\u51FA\u770B\u4F3C\u5408\u7406\uFF0C\u4E5F\u5E94\u5728\u5BF9\u5E94\u6307\u6807\u4E0A\u6263\u5206\u3002
 4. **\u8BC1\u636E\u5BFC\u5411**\uFF1A\u5728\u7ED9\u51FA\u539F\u56E0\uFF08reason\uFF09\u65F6\uFF0C\u5FC5\u987B\u5F15\u7528\u6267\u884C\u8FC7\u7A0B\u6216\u6700\u7EC8\u8F93\u51FA\u4E2D\u7684\u5177\u4F53\u5185\u5BB9\u3002
 5. **\u52A0\u6743\u8BA1\u7B97**\uFF1A\u6700\u7EC8\u5206\u6570\u4E3A\u5404\u9879\u6307\u6807\u5F97\u5206\u4E0E\u5176\u6743\u91CD\u7684\u4E58\u79EF\u4E4B\u548C\uFF080-100\u5206\u5236\uFF09\u3002
+6. **HITL \u4E2D\u65AD\u5224\u5B9A**\uFF1A\u5982\u679C\u6267\u884C\u8FC7\u7A0B\u4E2D\u51FA\u73B0\u300CHITL \u6682\u505C\uFF1AAgent \u8BF7\u6C42\u4EBA\u5DE5\u8F93\u5165\u300D\u6761\u76EE\uFF0C\u8BF4\u660E Agent \u5728\u7B49\u5F85\u4EBA\u5DE5\u786E\u8BA4\u3002\u8BF7\u628A\u5B83\u5F53\u4F5C\u88AB\u6D4B\u4E1A\u52A1\u884C\u4E3A\u6765\u8BC4\u5224\uFF1A\u82E5\u671F\u671B\u8F93\u51FA\u8981\u6C42\u81EA\u4E3B\u5B8C\u6210\uFF08\u5982"\u65E0\u9700\u786E\u8BA4\u81EA\u52A8\u6267\u884C"\uFF09\uFF0C\u8BF7\u6C42\u4EBA\u5DE5\u8F93\u5165\u5E94\u5224\u5931\u8D25\uFF1B\u82E5\u671F\u671B\u8F93\u51FA\u8981\u6C42\u5148\u83B7\u5F97\u786E\u8BA4\u6216\u6279\u51C6\uFF08\u5982"\u6267\u884C\u524D\u5FC5\u987B\u8BF7\u6C42\u6279\u51C6"\uFF09\uFF0C\u8BF7\u6C42\u4EBA\u5DE5\u8F93\u5165\u662F\u6B63\u786E\u884C\u4E3A\uFF0C\u5E94\u7ED3\u5408\u5176\u65F6\u673A\u4E0E\u5185\u5BB9\u5224\u5B9A\u4E3A\u901A\u8FC7\u6216\u6309\u6307\u6807\u7ED9\u5206\u3002
+7. **HITL \u81EA\u52A8\u54CD\u5E94\u5224\u5B9A**\uFF1A\u5982\u679C\u300CHITL \u6682\u505C\u300D\u6761\u76EE\u4E4B\u540E\u51FA\u73B0\u300C\u5DF2\u81EA\u52A8\u54CD\u5E94\uFF08\u6D4B\u8BD5\u7B56\u7565 auto-approve/auto-reject/canned-response\uFF09\u300D\u6761\u76EE\uFF0C\u8BF4\u660E\u6D4B\u8BD5\u6846\u67B6\u6CE8\u5165\u4E86\u4EBA\u5DE5\u56DE\u590D\u3001\u6D41\u7A0B\u5DF2\u7EE7\u7EED\u2014\u2014\u8BF7\u6309**\u5B8C\u6574\u6D41\u7A0B**\u8BC4\u5224\u6682\u505C\u4E4B\u540E\u7684\u884C\u4E3A\uFF08\u5982\u6279\u51C6\u540E\u662F\u5426\u6B63\u786E\u6267\u884C\u4E86\u64CD\u4F5C\uFF09\uFF0C\u5E76\u6838\u5BF9\u81EA\u52A8\u54CD\u5E94\u5185\u5BB9\u662F\u5426\u7B26\u5408\u4EBA\u5DE5\u56DE\u590D\u7684\u5408\u7406\u9884\u671F\u3002
 
 # \u8F93\u51FA\u683C\u5F0F\uFF08\u4EC5JSON\uFF09
 \u4F60\u5FC5\u987B\u4EC5\u4EE5 JSON \u683C\u5F0F\u56DE\u590D\uFF0C\u7ED3\u6784\u5982\u4E0B\uFF1A
@@ -27686,7 +28151,9 @@ ${rubricsSection}
       pass,
       final_score: finalScore,
       dimension_results: dimensionResults,
-      summary: parsedResult.summary || testResultContent
+      summary: parsedResult.summary || testResultContent,
+      interrupted: interrupt5 ? true : void 0,
+      interrupt: interrupt5 ? { id: interrupt5.id, value: interrupt5.value } : void 0
     };
   }
 };
@@ -27701,6 +28168,8 @@ async function evaluateLatticeCaseWithLogs(evalCase, config) {
     return {
       caseId: evalCase.caseId,
       result,
+      interrupted: result?.interrupted,
+      interrupt: result?.interrupt,
       duration_ms: meta.duration_ms,
       thread_id: meta.thread_id,
       judge_thread_id: meta.judge_thread_id,
@@ -27783,7 +28252,8 @@ function resolveTemplateCase(templateCase, templates) {
     eval: {
       content_assertion: templateCase.eval.content_assertion,
       eval_rubrics: templateCase.eval.eval_rubrics || template.default_case.eval?.eval_rubrics
-    }
+    },
+    interruptPolicy: templateCase.interruptPolicy ?? template.default_case.interruptPolicy
   };
   return resolvedCase;
 }
@@ -27849,6 +28319,8 @@ var LatticeEvalSuite = class {
         result: run.result,
         error: run.error,
         error_stack: run.error_stack,
+        interrupted: run.interrupted,
+        interrupt: run.interrupt,
         duration_ms: run.duration_ms,
         thread_id: run.thread_id,
         judge_thread_id: run.judge_thread_id,
@@ -27881,6 +28353,8 @@ var LatticeEvalSuite = class {
           result: run.result,
           error: run.error,
           error_stack: run.error_stack,
+          interrupted: run.interrupted,
+          interrupt: run.interrupt,
           duration_ms: run.duration_ms,
           thread_id: run.thread_id,
           judge_thread_id: run.judge_thread_id,
@@ -28090,24 +28564,29 @@ Running batch: ${this.project.projectName} (${this.getSuiteNames().length} suite
     let total_cases = 0;
     let passed_cases = 0;
     let failed_cases = 0;
+    let interrupted_cases = 0;
     const suites = [];
     for (const [suiteName, caseResults] of results.entries()) {
       const suiteTotal = caseResults.length;
       const suitePassed = caseResults.filter((r) => r.result?.pass).length;
+      const suiteInterrupted = caseResults.filter((r) => r.interrupted).length;
       const suiteFailed = suiteTotal - suitePassed;
       total_cases += suiteTotal;
       passed_cases += suitePassed;
       failed_cases += suiteFailed;
+      interrupted_cases += suiteInterrupted;
       suites.push({
         suiteName,
         total_cases: suiteTotal,
         passed_cases: suitePassed,
         failed_cases: suiteFailed,
+        interrupted_cases: suiteInterrupted,
         cases: caseResults.map((r) => ({
           caseId: r.caseId,
           pass: r.result?.pass,
           final_score: r.result?.final_score,
-          error: r.error
+          error: r.error,
+          interrupted: r.interrupted
         }))
       });
     }
@@ -28125,13 +28604,14 @@ Running batch: ${this.project.projectName} (${this.getSuiteNames().length} suite
         total_cases,
         passed_cases,
         failed_cases,
+        interrupted_cases,
         pass_rate: total_cases > 0 ? passed_cases / total_cases : 0
       },
       suites
     };
     console.log(`
 === Summary ===`);
-    console.log(`Total: ${report.summary.total_cases} | Passed: ${report.summary.passed_cases} | Failed: ${report.summary.failed_cases} | Pass Rate: ${(report.summary.pass_rate * 100).toFixed(2)}%`);
+    console.log(`Total: ${report.summary.total_cases} | Passed: ${report.summary.passed_cases} | Failed: ${report.summary.failed_cases} | Interrupted: ${report.summary.interrupted_cases} | Pass Rate: ${(report.summary.pass_rate * 100).toFixed(2)}%`);
     return { batch_id, results, report };
   }
 };
@@ -28216,11 +28696,11 @@ function clearEncryptionKeyCache() {
 }
 
 // src/middlewares/skillMiddleware.ts
-var import_langchain61 = require("langchain");
+var import_langchain62 = require("langchain");
 
 // src/tool_lattice/skill/load_skills.ts
 var import_zod48 = __toESM(require("zod"));
-var import_langchain58 = require("langchain");
+var import_langchain59 = require("langchain");
 var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure.`;
 function getSandboxFromExeConfig(_exe_config) {
   const runConfig = _exe_config?.configurable?.runConfig || {};
@@ -28235,7 +28715,7 @@ function getSandboxFromExeConfig(_exe_config) {
   });
 }
 var createLoadSkillsTool = ({ skills } = {}) => {
-  return (0, import_langchain58.tool)(
+  return (0, import_langchain59.tool)(
     async (_input, _exe_config) => {
       try {
         const sandbox = await getSandboxFromExeConfig(_exe_config);
@@ -28276,7 +28756,7 @@ var createLoadSkillsTool = ({ skills } = {}) => {
 
 // src/tool_lattice/skill/load_skill_content.ts
 var import_zod49 = __toESM(require("zod"));
-var import_langchain59 = require("langchain");
+var import_langchain60 = require("langchain");
 var LOAD_SKILL_CONTENT_DESCRIPTION = `
 Execute a skill within the main conversation
 
@@ -28314,7 +28794,7 @@ function getSandboxFromExeConfig2(_exe_config) {
   });
 }
 var createLoadSkillContentTool = (pluginSkillContents) => {
-  return (0, import_langchain59.tool)(
+  return (0, import_langchain60.tool)(
     async (input, _exe_config) => {
       try {
         if (pluginSkillContents?.[input.skill_name]) {
@@ -28372,7 +28852,7 @@ var createLoadSkillContentTool = (pluginSkillContents) => {
 
 // src/tool_lattice/skill/delete_skill.ts
 var import_zod50 = __toESM(require("zod"));
-var import_langchain60 = require("langchain");
+var import_langchain61 = require("langchain");
 var DELETE_SKILL_DESCRIPTION = `
 Delete a skill by name from the skill system.
 This permanently removes the skill and its SKILL.md file.
@@ -28399,7 +28879,7 @@ function validateSkillName2(name) {
   }
 }
 var createDeleteSkillTool = () => {
-  return (0, import_langchain60.tool)(
+  return (0, import_langchain61.tool)(
     async (input, _exe_config) => {
       try {
         validateSkillName2(input.skill_name);
@@ -28441,7 +28921,7 @@ function createSkillMiddleware(params = {}) {
   } = params;
   const skills = params.skills;
   let latestSkills = [];
-  return (0, import_langchain61.createMiddleware)({
+  return (0, import_langchain62.createMiddleware)({
     name: "skillMiddleware",
     contextSchema,
     tools: [
@@ -28576,17 +29056,17 @@ var skillPlugin = {
 };
 
 // src/middlewares/collectionMiddleware.ts
-var import_langchain72 = require("langchain");
+var import_langchain73 = require("langchain");
 
 // src/tool_lattice/collection/list_collections.ts
 var import_zod51 = __toESM(require("zod"));
-var import_langchain62 = require("langchain");
+var import_langchain63 = require("langchain");
 var LIST_COLLECTIONS_DESCRIPTION = `List all available collections for the current tenant. Returns collection names, labels, and field definitions (including field types and enum values). Use this tool to discover what collections are available before searching.`;
 var createListCollectionsTool = ({
   collectionKeys,
   connectAll
 }) => {
-  return (0, import_langchain62.tool)(
+  return (0, import_langchain63.tool)(
     async (_input, _exeConfig) => {
       try {
         const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28627,7 +29107,7 @@ var createListCollectionsTool = ({
 
 // src/tool_lattice/collection/search_collection.ts
 var import_zod52 = __toESM(require("zod"));
-var import_langchain63 = require("langchain");
+var import_langchain64 = require("langchain");
 var SEARCH_COLLECTION_DESCRIPTION = `Search for content within a specific collection using semantic (vector) similarity. Use the 'filter' parameter to narrow results by metadata fields (e.g., {"category": "cardiovascular"}). Returns the most relevant content entries with similarity scores.`;
 var searchSchema = import_zod52.default.object({
   collection: import_zod52.default.string().describe("The collection name to search in"),
@@ -28636,7 +29116,7 @@ var searchSchema = import_zod52.default.object({
   top_k: import_zod52.default.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = () => {
-  return (0, import_langchain63.tool)(
+  return (0, import_langchain64.tool)(
     async (input, _exeConfig) => {
       try {
         const { collection, query, filter: filter2, top_k } = input;
@@ -28687,9 +29167,9 @@ var createSearchCollectionTool = () => {
 
 // src/tool_lattice/collection/get_collection.ts
 var import_zod53 = __toESM(require("zod"));
-var import_langchain64 = require("langchain");
+var import_langchain65 = require("langchain");
 var GET_COLLECTION_DESCRIPTION = `Get a collection's full definition including its custom fields schema. Use this to discover what metadata fields are available before adding entries.`;
-var createGetCollectionTool = () => (0, import_langchain64.tool)(
+var createGetCollectionTool = () => (0, import_langchain65.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28717,7 +29197,7 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
 
 // src/tool_lattice/collection/create_collection.ts
 var import_zod54 = __toESM(require("zod"));
-var import_langchain65 = require("langchain");
+var import_langchain66 = require("langchain");
 var createSchema = import_zod54.default.object({
   name: import_zod54.default.string().describe("Collection name (lowercase, underscores only)"),
   label: import_zod54.default.string().describe("Display name"),
@@ -28729,7 +29209,7 @@ var createSchema = import_zod54.default.object({
     required: import_zod54.default.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
-var createCreateCollectionTool = () => (0, import_langchain65.tool)(
+var createCreateCollectionTool = () => (0, import_langchain66.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28755,7 +29235,7 @@ var createCreateCollectionTool = () => (0, import_langchain65.tool)(
 
 // src/tool_lattice/collection/update_collection.ts
 var import_zod55 = __toESM(require("zod"));
-var import_langchain66 = require("langchain");
+var import_langchain67 = require("langchain");
 var schema = import_zod55.default.object({
   name: import_zod55.default.string().describe("Collection name"),
   label: import_zod55.default.string().optional().describe("New display name"),
@@ -28767,7 +29247,7 @@ var schema = import_zod55.default.object({
     required: import_zod55.default.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
-var createUpdateCollectionTool = () => (0, import_langchain66.tool)(
+var createUpdateCollectionTool = () => (0, import_langchain67.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28787,8 +29267,8 @@ var createUpdateCollectionTool = () => (0, import_langchain66.tool)(
 
 // src/tool_lattice/collection/delete_collection.ts
 var import_zod56 = __toESM(require("zod"));
-var import_langchain67 = require("langchain");
-var createDeleteCollectionTool = () => (0, import_langchain67.tool)(
+var import_langchain68 = require("langchain");
+var createDeleteCollectionTool = () => (0, import_langchain68.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28803,14 +29283,14 @@ var createDeleteCollectionTool = () => (0, import_langchain67.tool)(
 
 // src/tool_lattice/collection/list_entries.ts
 var import_zod57 = __toESM(require("zod"));
-var import_langchain68 = require("langchain");
+var import_langchain69 = require("langchain");
 var schema2 = import_zod57.default.object({
   collection: import_zod57.default.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
 }
-var createListEntriesTool = () => (0, import_langchain68.tool)(
+var createListEntriesTool = () => (0, import_langchain69.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28838,7 +29318,7 @@ var createListEntriesTool = () => (0, import_langchain68.tool)(
 
 // src/tool_lattice/collection/add_entry.ts
 var import_zod58 = __toESM(require("zod"));
-var import_langchain69 = require("langchain");
+var import_langchain70 = require("langchain");
 var import_documents = require("@langchain/core/documents");
 var import_uuid11 = require("uuid");
 var schema3 = import_zod58.default.object({
@@ -28849,7 +29329,7 @@ var schema3 = import_zod58.default.object({
 function key(t, n) {
   return `${t}:${n}`;
 }
-var createAddEntryTool = () => (0, import_langchain69.tool)(
+var createAddEntryTool = () => (0, import_langchain70.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28869,7 +29349,7 @@ var createAddEntryTool = () => (0, import_langchain69.tool)(
 
 // src/tool_lattice/collection/update_entry.ts
 var import_zod59 = __toESM(require("zod"));
-var import_langchain70 = require("langchain");
+var import_langchain71 = require("langchain");
 var schema4 = import_zod59.default.object({
   collection: import_zod59.default.string().describe("Collection name"),
   entryId: import_zod59.default.string().describe("Entry ID to update"),
@@ -28879,7 +29359,7 @@ var schema4 = import_zod59.default.object({
 function key2(t, n) {
   return `${t}:${n}`;
 }
-var createUpdateEntryTool = () => (0, import_langchain70.tool)(
+var createUpdateEntryTool = () => (0, import_langchain71.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28899,7 +29379,7 @@ var createUpdateEntryTool = () => (0, import_langchain70.tool)(
 
 // src/tool_lattice/collection/delete_entry.ts
 var import_zod60 = __toESM(require("zod"));
-var import_langchain71 = require("langchain");
+var import_langchain72 = require("langchain");
 var schema5 = import_zod60.default.object({
   collection: import_zod60.default.string().describe("Collection name"),
   entryId: import_zod60.default.string().describe("Entry ID to delete")
@@ -28907,7 +29387,7 @@ var schema5 = import_zod60.default.object({
 function key3(t, n) {
   return `${t}:${n}`;
 }
-var createDeleteEntryTool = () => (0, import_langchain71.tool)(
+var createDeleteEntryTool = () => (0, import_langchain72.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -28925,7 +29405,7 @@ var createDeleteEntryTool = () => (0, import_langchain71.tool)(
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll } = params;
   if (!connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return (0, import_langchain72.createMiddleware)({
+    return (0, import_langchain73.createMiddleware)({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -28935,7 +29415,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const listToolParams = { collectionKeys, connectAll };
-  return (0, import_langchain72.createMiddleware)({
+  return (0, import_langchain73.createMiddleware)({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -28997,11 +29477,11 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-var import_langchain74 = require("langchain");
+var import_langchain75 = require("langchain");
 var import_langgraph15 = require("@langchain/langgraph");
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
-var import_langchain73 = require("langchain");
+var import_langchain74 = require("langchain");
 var import_zod61 = __toESM(require("zod"));
 var questionSchema = import_zod61.default.object({
   question: import_zod61.default.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
@@ -29014,7 +29494,7 @@ var inputSchema = import_zod61.default.object({
   questions: import_zod61.default.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
 });
 function createAskUserToClarifyTool() {
-  return (0, import_langchain73.tool)(
+  return (0, import_langchain74.tool)(
     async (input) => {
       return JSON.stringify(input);
     },
@@ -29028,7 +29508,7 @@ function createAskUserToClarifyTool() {
 
 // src/middlewares/askUserClarifyMiddleware.ts
 function createAskUserClarifyMiddleware() {
-  return (0, import_langchain74.createMiddleware)({
+  return (0, import_langchain75.createMiddleware)({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -29042,7 +29522,7 @@ function createAskUserClarifyMiddleware() {
             throw error;
           }
           console.error(`Error executing tool "${toolName}":`, error);
-          return new import_langchain74.ToolMessage({
+          return new import_langchain75.ToolMessage({
             content: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`,
             tool_call_id: toolCall?.id,
             name: toolName
@@ -29051,7 +29531,7 @@ function createAskUserClarifyMiddleware() {
       }
       const parsed = inputSchema.safeParse(toolCall?.args);
       if (!parsed.success) {
-        return new import_langchain74.ToolMessage({
+        return new import_langchain75.ToolMessage({
           content: `Invalid clarify tool arguments: ${parsed.error.message}`,
           tool_call_id: toolCall?.id,
           name: toolName
@@ -29071,7 +29551,7 @@ function createAskUserClarifyMiddleware() {
       const result = await (0, import_langgraph15.interrupt)(md);
       const response = result.data;
       if (!response?.answers || response.answers.length === 0) {
-        return new import_langchain74.ToolMessage({
+        return new import_langchain75.ToolMessage({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName
@@ -29081,7 +29561,7 @@ function createAskUserClarifyMiddleware() {
         (answer) => (answer.selectedOptions?.length ?? 0) > 0 || answer.otherText && answer.otherText.trim() !== "" || answer.filePath && answer.filePath.trim() !== ""
       );
       if (answeredQuestions.length === 0) {
-        return new import_langchain74.ToolMessage({
+        return new import_langchain75.ToolMessage({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName
@@ -29111,7 +29591,7 @@ function createAskUserClarifyMiddleware() {
         }
         lines.push("");
       }
-      return new import_langchain74.ToolMessage({
+      return new import_langchain75.ToolMessage({
         content: lines.join("\n"),
         tool_call_id: toolCall?.id,
         name: toolName
@@ -29137,10 +29617,10 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-var import_langchain77 = require("langchain");
+var import_langchain78 = require("langchain");
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var import_langchain75 = require("langchain");
+var import_langchain76 = require("langchain");
 var import_zod62 = require("zod");
 
 // src/middlewares/guidelines/index.ts
@@ -29938,7 +30418,7 @@ var LoadGuidelinesInputSchema = import_zod62.z.object({
   )
 });
 function createLoadGuidelinesTool() {
-  return (0, import_langchain75.tool)(
+  return (0, import_langchain76.tool)(
     async (input) => {
       const result = getGuidelines(input.modules);
       return result;
@@ -29952,7 +30432,7 @@ function createLoadGuidelinesTool() {
 }
 
 // src/tool_lattice/widget/showWidget.ts
-var import_langchain76 = require("langchain");
+var import_langchain77 = require("langchain");
 var import_zod63 = require("zod");
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
@@ -29988,7 +30468,7 @@ var ShowWidgetInputSchema = import_zod63.z.object({
   )
 });
 function createShowWidgetTool() {
-  return (0, import_langchain76.tool)(
+  return (0, import_langchain77.tool)(
     async (input) => {
       if (!input.i_have_seen_guidelines) {
         return "Error: You must call load_guidelines before using show_widget. Set i_have_seen_guidelines to true only after loading guidelines.";
@@ -30019,7 +30499,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return (0, import_langchain77.createMiddleware)({
+  return (0, import_langchain78.createMiddleware)({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -30043,7 +30523,7 @@ var widgetPlugin = {
 };
 
 // src/middlewares/evalMiddleware.ts
-var import_langchain78 = require("langchain");
+var import_langchain79 = require("langchain");
 var import_zod64 = require("zod");
 var import_uuid12 = require("uuid");
 
@@ -30080,10 +30560,21 @@ Write assertions as objective, verifiable natural language:
 - steps: [{agent_id: "a"}, {agent_id: "b", override_message: "Based on..."}] for chain
 - outputType: "message_content" or "file_content"
 
+## Designing HITL Cases
+If the flow under test PAUSES for human input (HITL \u2014 the agent requests approval/confirmation), configure interruptPolicy on the case \u2014 otherwise the run stops at the pause and the flow AFTER the human input is never tested:
+
+- interruptPolicy: {mode: "auto-approve"} \u2014 inject "\u540C\u610F"; tests the full flow after approval (e.g. payment executed after approval). Use value to override the injected text.
+- interruptPolicy: {mode: "auto-reject"} \u2014 inject "\u62D2\u7EDD"; tests the rejection path.
+- interruptPolicy: {mode: "canned-response", value: "..."} \u2014 inject an exact human reply; tests behavior under a specific response.
+- Omit (default "stop") \u2014 the case pauses at the request; the judge evaluates whether pausing was the correct behavior (e.g. "must request approval" PASSES; "must be autonomous" FAILS).
+
+Choose per the assertion: if the assertion describes what happens AFTER the human input, you MUST set an auto-resolve policy.
+
 ## Checklist
 1. Check existing assets with read_eval to avoid duplication
 2. Start with 3-5 high-signal cases
-3. Confirm with user before calling manage_eval
+3. If the flow contains a human-approval step and the assertion covers what happens AFTER it, set interruptPolicy (auto-approve / auto-reject / canned-response) \u2014 never leave it unset in that case
+4. Confirm with user before calling manage_eval
 `,
   "eval-run-and-govern": `---
 name: eval-run-and-govern
@@ -30093,8 +30584,11 @@ description: Run agent evaluations, interpret results, diagnose failures, and re
 # Agent Governance Loop
 
 1. Discover project \u2192 read_eval list_projects
-2. Start evaluation \u2192 run_eval start(projectId) \u2014 ASYNC, may take minutes
-3. Poll status \u2192 run_eval status(runId) with backoff: 15s, 30s, 60s, max 120s
+2. Start evaluation \u2192 run_eval start(projectId) \u2014 SYNCHRONOUS by default:
+   blocks up to ~150s and returns the FINAL RESULTS in one call.
+   Hold-out (validation) runs return aggregates only.
+3. If still running (or use wait: false for fire-and-forget) \u2192 poll
+   run_eval status(runId, sleepMs) \u2014 pass sleepMs to pace (15s, 30s, 60s, max 120s)
 4. If runnerAlive=false and status=running \u2192 ORPHANED (gateway restart).
    resume(runId) marks it failed automatically \u2014 then start a new run.
 5. Get results \u2192 read_eval get_run_results(runId) for per-case dimension scores
@@ -30163,10 +30657,12 @@ function sanitize(obj) {
 }
 function aggregateHoldoutResults(results) {
   const passed = results.filter((r) => r.pass).length;
+  const interrupted = results.filter((r) => r.interrupted).length;
   return {
     holdout: true,
     passedCases: passed,
     failedCases: results.length - passed,
+    interruptedCases: interrupted,
     passRate: results.length > 0 ? passed / results.length : 0,
     totalCases: results.length
   };
@@ -30198,7 +30694,7 @@ function createReadEvalTool() {
     runId: import_zod64.z.string().optional(),
     status: import_zod64.z.string().optional().describe("Filter: running|completed|failed|aborted")
   });
-  return (0, import_langchain78.tool)(
+  return (0, import_langchain79.tool)(
     async (input, exeConfig) => {
       const tid = tenantId(exeConfig);
       if (!tid) {
@@ -30237,13 +30733,8 @@ function createReadEvalTool() {
             if (!run) return JSON.stringify({ success: false, error: "Run not found" });
             const results = await store.getResultsByRun(tid, input.runId);
             if (run.holdout) {
-              const passed = results.filter((r) => r.pass).length;
               data = {
-                holdout: true,
-                passedCases: passed,
-                failedCases: results.length - passed,
-                passRate: results.length > 0 ? passed / results.length : 0,
-                totalCases: results.length,
+                ...aggregateHoldoutResults(results),
                 message: "Hold-out run \u2014 per-case results withheld. Only aggregates are available."
               };
             } else {
@@ -30278,6 +30769,7 @@ ACTIONS:
 - get_run_results(runId) \u2014 per-case results with dimension scores.
   For HOLD-OUT (validation-only) runs: returns AGGREGATES ONLY
   (passRate, counts) \u2014 per-case details are withheld by design.
+  Cases paused for human input (HITL) carry interrupted=true and are judged \u2014 the judge evaluates whether pausing was correct business behavior.
 - get_project_report(projectId) \u2014 aggregated stats across all runs`,
       schema: schema6
     }
@@ -30308,9 +30800,13 @@ function createManageEvalTool() {
     steps: import_zod64.z.array(import_zod64.z.object({ agent_id: import_zod64.z.string(), override_message: import_zod64.z.string().optional() })).optional(),
     outputType: import_zod64.z.enum(["file_content", "message_content"]).optional(),
     contentAssertion: import_zod64.z.string().optional(),
-    rubrics: import_zod64.z.array(import_zod64.z.object({ name: import_zod64.z.string(), weight: import_zod64.z.number(), description: import_zod64.z.string() })).optional()
+    rubrics: import_zod64.z.array(import_zod64.z.object({ name: import_zod64.z.string(), weight: import_zod64.z.number(), description: import_zod64.z.string() })).optional(),
+    interruptPolicy: import_zod64.z.object({
+      mode: import_zod64.z.enum(["stop", "auto-approve", "auto-reject", "canned-response"]).describe("stop=judge the pause; auto-approve/auto-reject/canned-response=resume the agent to test the flow after the human input"),
+      value: import_zod64.z.string().optional().describe("Response to inject (defaults: \u540C\u610F / \u62D2\u7EDD; required for canned-response)")
+    }).optional().describe("Optional for create_case/update_case \u2014 how HITL interrupts are handled")
   });
-  return (0, import_langchain78.tool)(
+  return (0, import_langchain79.tool)(
     async (input, exeConfig) => {
       const tid = tenantId(exeConfig);
       if (!tid) {
@@ -30366,7 +30862,8 @@ function createManageEvalTool() {
               steps: input.steps,
               outputType: input.outputType,
               contentAssertion: input.contentAssertion,
-              rubrics: input.rubrics
+              rubrics: input.rubrics,
+              interruptPolicy: input.interruptPolicy
             });
             break;
           case "update_case":
@@ -30374,7 +30871,8 @@ function createManageEvalTool() {
               inputMessage: input.inputMessage,
               contentAssertion: input.contentAssertion,
               steps: input.steps,
-              rubrics: input.rubrics
+              rubrics: input.rubrics,
+              interruptPolicy: input.interruptPolicy
             });
             break;
           case "delete_case":
@@ -30399,9 +30897,13 @@ Project: create_project(name, description?, judgeModelKey?, concurrency?) | upda
   **When creating a project from within a workspace, the workspace/project context is
   automatically bound \u2014 eval runs will execute in the same workspace.**
 Suite: create_suite(projectId, name) | update_suite | delete_suite
-Case: create_case(suiteId, inputMessage, steps, outputType, contentAssertion, inputFiles?, rubrics?)
+Case: create_case(suiteId, inputMessage, steps, outputType, contentAssertion, inputFiles?, rubrics?, interruptPolicy?)
   steps is [{agent_id, override_message?}]. outputType is "file_content" or "message_content".
-  rubrics is [{name, weight, description}]. | update_case | delete_case`,
+  rubrics is [{name, weight, description}]. | update_case | delete_case
+  interruptPolicy: {mode: "stop"|"auto-approve"|"auto-reject"|"canned-response", value?} \u2014 how HITL interrupts are handled:
+    stop (default): case pauses at the human-input request; the judge evaluates the pause as business behavior.
+    auto-approve / auto-reject: the runner injects approval/rejection and tests the FULL flow after the pause.
+    canned-response: injects the exact value (simulates a specific human reply).`,
       schema: schema6
     }
   );
@@ -30416,7 +30918,7 @@ function createRunEvalTool() {
     sleepMs: import_zod64.z.number().int().min(0).max(12e4).optional().describe("Optional for status \u2014 sleep this many ms BEFORE checking the run, to pace polling (e.g. 15000 \u2192 30000 \u2192 60000 \u2192 120000). Omit to check immediately."),
     wait: import_zod64.z.boolean().optional().describe("Optional for start \u2014 defaults to true: block synchronously (up to ~150s) and return final results in one call. Set false to return the runId immediately and poll.")
   });
-  return (0, import_langchain78.tool)(
+  return (0, import_langchain79.tool)(
     withToolTimeout(
       async (input, exeConfig) => {
         const tid = tenantId(exeConfig);
@@ -30515,6 +31017,8 @@ ACTIONS:
 - start(projectId, suiteIds?, caseIds?, wait?) \u2014 begin evaluation (optionally only the listed suites, and/or only the listed cases).
     wait=true (DEFAULT): SYNCHRONOUS \u2014 blocks up to ~150s and returns the FINAL RESULTS in one call:
       { status, results } with per-case pass/score (hold-out/validation runs: aggregates only \u2014 per-case details withheld by design).
+      Cases paused for human input (HITL) carry interrupted=true and ARE judged \u2014 the judge evaluates whether requesting
+      the human was the correct behavior (assertions like "must approve first" PASS; "must be autonomous" FAIL). interruptedCases counts these.
       If the run exceeds 150s: returns { runId, status: "running" } \u2014 NOT an error \u2014 then poll with status/resume until completed.
     wait=false: fire-and-forget \u2014 returns { runId } immediately; poll with status.
 - status(runId, sleepMs?) \u2014 sleep sleepMs first (to pace polling), then return current status + runnerAlive flag:
@@ -30545,7 +31049,7 @@ var evalPlugin = {
     defaultConfig: {}
   },
   skills: EVAL_SKILLS,
-  middleware: () => (0, import_langchain78.createMiddleware)({
+  middleware: () => (0, import_langchain79.createMiddleware)({
     name: "EvalMiddleware",
     tools: [createReadEvalTool(), createManageEvalTool(), createRunEvalTool()]
   })
@@ -30820,67 +31324,64 @@ verification choice, then start benchmarking.
 
 ## Task Tracking \u2014 see [[task-tracking]]
 
-**Create the parent task when the task is actually defined** \u2014 after
-Phase 0 clarification is complete and the user confirmed the path
-(fresh vs incremental). Do NOT create tasks during clarification:
-while asking questions (0.0-0.4) you don't know what the task is yet.
-Once the scope is clear (end of 0.5), that is the moment to create:
-manage_task create("Learn [material]", ownerType: "agent"). Then a
-subtask per phase as you start it. Update status to reflect reality \u2014
-never mark a subtask completed while eval fails. Resume interrupted
-runs with manage_task list.
+**Universal principle**: once the goal is clear and you know what to
+do, create the parent task BEFORE executing (manage_task create, see
+[[task-tracking]]). In this workflow: after Phase 0 clarification
+completes and the user confirmed the path (end of 0.5), create the
+parent task; then a subtask per phase as you start it. The parent task
+description carries the GOAL MODEL (0.1.5) as Objective + Acceptance
+Criteria; the expected output spec (2.6) updates the criteria. Update
+status to reflect reality \u2014 never mark a subtask completed while eval
+fails. Resume interrupted runs with manage_task list.
 
 Widgets: call \`load_guidelines\` ONCE before your first \`show_widget\`
 (show_widget hard-requires it), then reuse.
 
 ---
 
-## Phase 1: Probe (material-dependent)
-
-The probing strategy depends on the material type from Phase 0.0:
-
-**User-description material**: the requirements come from the
-conversation itself \u2014 no probing needed. Extract the agent's goal,
-inputs, outputs, and constraints from what the user described. Go
-straight to design.
-
-**Document material** (PDF / spec / manual):
-If the engine was chosen in Phase 0 (0.3 \u2460-\u2464): skip the comparison \u2014
-parse directly with \`parse_document\` using the chosen engine
-(file_path, engine, output_path per file).
-Otherwise: run the document-parser-benchmark subagent via \`task\` on each file.
-Collect engine scores, parsed output (via \`read_file\`), and feature signatures.
-
-**Engine selection IS distilled knowledge, not just setup.** For document
-material, the benchmark answers "which engine parses THIS document (or
-this class of document) best?" \u2014 that answer is knowledge that drives
-the whole rest of the run:
-- **Builds the agent**: the chosen engine's \`parse_document\` goes into
-  the production agent's middleware/tools.
-- **Designs the tests**: the chosen engine's parsed output becomes the
-  baseline input for eval cases \u2014 cases feed parsed output to the agent
-  and assert correct extraction from it.
-- **Seeds the skill**: the feature signature (tables? scans? mixed
-  zh/en?) plus the winning engine becomes a skill note ("for PO PDFs
-  with tables, use textin") reusable for future similar documents.
-So when the user wants an agent whose purpose is document PARSING (not
-extraction), the workflow is the same: benchmark to learn the engine
-choice, then build the agent around that engine and test against its
-output. Do NOT treat parsing as a pure tool-assembly task \u2014 the engine
-choice is unknown knowledge until probed.
-
-**API spec material**: read the spec directly \u2014 no parsing engine needed.
-Extract endpoints, schemas, request/response examples from the text.
-
-**Conversation material**: extract the workflow, decisions, and corrections
-from the conversation context \u2014 no parsing engine needed.
-
-**Spreadsheet material**: parse cells directly \u2014 structured data needs
-no engine comparison.
-If verification will happen (0.2 \u2460 or \u2461): concurrently, \`list_agents\` to
-discover existing agents with relevant capabilities (see \xA75).
-For \u2460, look for agents with data-access tools (SQL / API). For \u2461, look
-for agents with independence.
+## Phase 1: Explore (goal-driven path finding)
+
+The goal model (0.1.5) is set. Now EXPLORE how to achieve it \u2014 actively
+hunt for the path, do not passively read. Three exploration fronts:
+
+**A. Existing assets (reuse, don't rebuild):**
+- \`list_agents\` / \`load_skills\` \u2192 are there existing agents or skills
+  that already do part of this? Reuse them (update_agent if needed)
+  instead of building from scratch. This is a goal-relevant check, not
+  a materials step.
+- \`list_tools\` / \`list_middleware_types\` \u2192 what capabilities exist
+  that the goal needs (parsing, data access, browser...)?
+- \`list_connections\` \u2192 are the data sources the goal depends on
+  already connected?
+- If verification will happen (0.2 \u2460 or \u2461): concurrently discover
+  executor candidates (see \xA75). \u2460 \u2192 data-access tools; \u2461 \u2192 independence.
+
+**B. Material probing (by material type):**
+- **User-description**: the requirements come from the conversation.
+  Extract goal, inputs, outputs, constraints \u2014 then explore the
+  implementation path (A + feasibility): what assets exist, what tools
+  are needed, what blockers stand between the goal and its achievement.
+- **Document** (PDF / spec / manual): benchmark engines as needed \u2014
+  parse directly with the chosen engine (0.3 \u2460-\u2464) or run
+  document-parser-benchmark. Engine selection IS distilled knowledge:
+  it builds the agent (engine's parse_document into middleware), seeds
+  the skill (feature signature + winning engine), and designs the tests
+  (engine output as case baseline input).
+- **API spec**: read directly \u2014 endpoints, schemas, examples.
+- **Conversation**: extract workflow, decisions, corrections.
+- **Spreadsheet**: parse cells directly.
+
+**C. Feasibility (path blockers):**
+- What stands between the goal and achievement? Missing tools, missing
+  connections, data access, permission constraints, ambiguous
+  requirements.
+- Does the goal require orchestration (\u2192 Phase 2 split decision)?
+- Surface these in the recommendation (Phase 1.5) \u2014 the user decides
+  the path, informed by what exploration found.
+
+Exploration is COMPLETE when you can answer: what exists to reuse,
+what must be built, what tools/connections are needed, and what blocks
+the goal. Do not go to design without this map.
 
 ---
 
@@ -30895,17 +31396,21 @@ candidate and assess (Validation Agent Design \xA70) \u2014 state which are
 usable and which are not, with reasons. For \u2460, the executor needs data
 tools + independence. For \u2461, independence only. If no candidate fits,
 plan to build one via \xA75.
-Present probe results as widget, then MUST call
+Present the EXPLORATION map as widget \u2014 what exists to reuse, what
+must be built, tools/connections needed, blockers found \u2014 then
+recommend the IMPLEMENTATION PATH: reuse existing X, build new Y,
+split or single agent (Phase 2 input). MUST call
 \`ask_user_to_clarify\` NOW:
   {
     "questions": [{
-      "question": "Confirm the recommendation?",
+      "question": "Confirm the recommended path?",
       "options": ["Confirm", "Adjust"],
       "type": "single",
       "required": true
     }]
   }
-Skills planning belongs to Phase 2 \u2014 this phase presents data, not plans.
+Skills planning belongs to Phase 2 \u2014 this phase presents the path, not
+the detailed plan.
 
 ---
 
@@ -30973,9 +31478,53 @@ user-description material this IS the core phase; for material-based
 learning it designs the agent that runs the learned skill. Agent
 metadata (verified/version/source) must be set on creation.
 
+## Phase 2.6: Expected Output Specification (mandatory \u2014 goal-driven)
+
+**Expectations come FIRST, before writing the skill.** You cannot write
+a skill (or test cases) without a target. Define the expected output
+specification from the goal model (0.1.5: real goal / consumer / usable
+state) BEFORE Phase 3:
+
+**HARD RULE \u2014 never guess the target.** If the goal, the expected
+output, the consumer, or the usable state is unclear at ANY point
+before writing test cases, you MUST ask the user via
+\`ask_user_to_clarify\` \u2014 do NOT proceed with an assumed expectation.
+A test case written against a guessed expectation is worthless: it
+validates the wrong thing. When in doubt, ask.
+
+Per skill, define the EXPECTED OUTPUT SPEC (based on intent 0.1 and
+consumer 0.1.5):
+- Extract data \u2192 expected fields (names, types, formats), required vs
+  optional, output structure (JSON schema shape, table columns)
+- Validate rules \u2192 expected judgment outcomes (pass/fail conditions),
+  boundary values, and the reason format
+- Execute workflow \u2192 expected step sequence, decision points, final
+  outcome shape
+- Answer knowledge \u2192 expected answer form (with/without sources,
+  length, structure)
+
+This spec IS the acceptance standard. Phase 4 contentAssertion must be
+derived from it (not invented at case-writing time). Present the
+expected output spec to the user and MUST call \`ask_user_to_clarify\`
+NOW per skill:
+  {
+    "questions": [{
+      "question": "Confirm the expected output spec for {skill-name}?",
+      "options": ["Confirm", "Adjust"],
+      "type": "single",
+      "required": true,
+      "allowOther": true
+    }]
+  }
+Record the confirmed spec in the parent task description. This replaces
+guess-then-confirm: the skill is written TO MEET the spec, and test
+cases assert AGAINST the spec \u2014 no expectation is invented later.
+
 ## Phase 3: Create Skills
 
-Write SKILL.md to \`/root/.agents/skills/{name}/SKILL.md\` one at a time.
+Write SKILL.md to \`/root/.agents/skills/{name}/SKILL.md\` one at a time,
+designed TO MEET the expected output spec confirmed in Phase 2.6 \u2014 the
+skill encodes how to produce the spec's expected output.
 Show the skill content in text first, then MUST call
 \`ask_user_to_clarify\` NOW per skill:
   {
@@ -31269,7 +31818,8 @@ This learning loop adds its own scenario rules:
    - Business usability (output reaches the goal's "usable state")
    - Consumer fit (format/contract satisfies who uses the result)
    contentAssertion must encode the usable state from the goal model
-   (0.1.5), not just technical correctness.
+   (0.1.5), derived from the EXPECTED OUTPUT SPEC (Phase 2.6) \u2014 never
+   invented at case-writing time.
 
 1. One suite per skill per source: cases test "can this skill do it" \u2014
    never mix skills in one suite
@@ -31312,6 +31862,12 @@ Learning-specific suite guidance:
 - User-description material: {skill}-requirement-derived \u2014 cases from
   user's described requirements
 
+**Case expectations come from the confirmed spec** (Phase 2.6): the
+contentAssertion of every case must be derived from the expected output
+spec, NOT invented at case-writing time. If a case needs an expectation
+not in the spec, go back and extend the spec with user confirmation
+first \u2014 never guess expectations on the fly.
+
 [[completion-gate]] applies \u2014 eval must pass before declaring done.
 
 ## Phase 5: Retrospective
@@ -31454,12 +32010,12 @@ var documentLearningPlugin = {
 };
 
 // src/middlewares/documentParserMiddleware.ts
-var import_langchain80 = require("langchain");
+var import_langchain81 = require("langchain");
 
 // src/tool_lattice/document_parser/index.ts
 var path7 = __toESM(require("path"));
 var import_zod65 = __toESM(require("zod"));
-var import_langchain79 = require("langchain");
+var import_langchain80 = require("langchain");
 var PARSE_DOCUMENT_DESCRIPTION = `Parse a document file (docx, pdf) into structured Markdown using a remote document parsing service.
 This tool handles the full pipeline internally: file upload \u2192 document parsing \u2192 polling until complete \u2192 download result \u2192 save to filesystem.
 
@@ -31581,7 +32137,7 @@ function createParseDocumentTool({
   baseUrl = "",
   apiKey = ""
 }) {
-  return (0, import_langchain79.tool)(
+  return (0, import_langchain80.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config?.configurable?.runConfig ?? { assistant_id: "", thread_id: "" };
@@ -31845,7 +32401,7 @@ function createDocumentParserMiddleware(config) {
   const connectAll = config.connectAll === true;
   const baseUrl = config.baseUrl || "";
   const apiKey = config.apiKey || "";
-  return (0, import_langchain80.createMiddleware)({
+  return (0, import_langchain81.createMiddleware)({
     name: "DocumentParser",
     contextSchema,
     tools: [createParseDocumentTool({ connectAll, baseUrl, apiKey })]