fix(subagent): deliver send_input plainly when no escalation is pending

Models that fill every optional field attach a resolution to ordinary
messages. With no ask pending the resolution has nothing to answer,
yet it routed the call into the escalation path, which rejected it,
so the parent could not message its worker at all.

Author: bwachman

docs/ARCHITECTURE.md

@@ -255,7 +255,7 @@ Workers ask the spawning parent with **`ask_director`** (not the human). That pa
 
 The ask is never prose-only: `ask_director` requires a typed **`escalation`** object (`src/subagent/escalation-policy.ts`, `ask-director.ts`) with `policyVersion` plus the required facts — `classification`, `blockedOutcome`, `unavailableDirectorPath`, `permittedAlternatives`, `minimumAddition`, and `declineConsequence` (each a non-empty string, byte-bounded). It may also carry `recommendation`, `safeDefault`, `requestedMechanism` versus `minimumAuthority`, and an optional `verification` detail (`verificationOutcome`, `rootCause`, `attemptedNarrowChecks`, `reducedConfidence`). The five `classification` values decide where the ask settles (`decideEscalation`): `routine` never parks — the worker continues with one of its displayed permitted alternatives and the evaluation is recorded for audit (`routineEvaluations`, newest-only cap); it requires at least one alternative with `comparableConfidence: true`. `director_resolvable` also continues internally when such a comparable alternative exists and parks otherwise. `operator_decision_required`, `outcome_blocked`, and `irreversible_or_sensitive` always park — the first and last require an explicit `minimumAuthority`, which must differ from `requestedMechanism` when both are present — and every parked classification requires at least one permitted alternative to show what was already considered.
 
-The parent resolves a parked ask with **`send_input`**'s optional structured `resolution` (`questionId`, `kind`, `answer`; `parseEscalationResolution` validates it at the tool boundary). The four kinds are `director_answer` (normal answer), `declined`, `unavailable`, and `minimum_grant_available` (resume by text only — it grants nothing and leaves a denied-call envelope unconsumed). A resolution is bound to the pending `questionId` — a stale or mismatched id is refused so a late answer cannot settle a newer question — and is mutually exclusive with `interrupt`. The resolution's message is delivered to the worker together with the structured answer; neither can silently drop the other. A resolution never grants authority or retries a tool — a denied call still needs the envelope-owned covering-grant retry path described above.
+The parent resolves a parked ask with **`send_input`**'s optional structured `resolution` (`questionId`, `kind`, `answer`; `parseEscalationResolution` validates it at the tool boundary). The four kinds are `director_answer` (normal answer), `declined`, `unavailable`, and `minimum_grant_available` (resume by text only — it grants nothing and leaves a denied-call envelope unconsumed). A resolution is bound to the pending `questionId` — a stale or mismatched id is refused so a late answer cannot settle a newer question — and, while that ask is pending, cannot be combined with `interrupt` (answering resumes the parked turn, interrupting stops it). With no ask pending there is nothing to resolve, so `send_input` ignores the resolution, delivers the message as plain input (interrupting first when `interrupt` is set, exactly as without a resolution), and reports `resolution_ignored` in its result; models that fill every optional field would otherwise fail every plain message. The resolution's message is delivered to the worker together with the structured answer; neither can silently drop the other. A resolution never grants authority or retries a tool — a denied call still needs the envelope-owned covering-grant retry path described above.
 
 Projections keep the policy facts visible: wait JSON and `list_agents` carry the pending ask's `question`, `questionId`, and `assessment`, and the session's `terminal_outcome` (`verification_blocked` when a `declined`/`unavailable` resolution lands on an ask that carried a `verification` detail, `declined` for a plain decline/unavailability, or `verified` when the worker reports a successful verification in place of a blocked one) is projected through wait JSON, `list_agents`, and mailbox mail (`src/subagent/agent-fleet.ts`, `fleet-report.ts`).
 

src/subagent/lifecycle-tools.test.ts

@@ -1287,6 +1287,186 @@ describe("send_input", () => {
       resolution: "declined",
     });
   });
+
+  test("a resolution with no pending escalation is ignored and the message is delivered as plain input", async () => {
+    const sessions = createSubAgentSessionStore();
+    const fleetRecords = createFleetMailbox(sessions);
+    const sendInput = createSendInputTool({ sessions, fleetRecords });
+    const worker = startSession(sessions, { description: "worker" });
+    sessions.markRunning(worker.id);
+    const delivered: string[] = [];
+    sessions.registerDeliver(worker.id, (message) => {
+      delivered.push(message);
+    });
+
+    // Filler a field-filling model sent after approve_worker_call had
+    // already answered the worker's only ask.
+    const fillers = [
+      { questionId: "", kind: "director_answer", answer: "" },
+      {
+        questionId: "ask-2",
+        kind: "director_answer",
+        answer: "Additional requirement applies after rebase.",
+      },
+      {
+        questionId: "none",
+        kind: "unavailable",
+        answer: "No escalation; normal task update only.",
+      },
+    ];
+    for (const resolution of fillers) {
+      const result = await callTool(sendInput, {
+        target: worker.id,
+        message: "also require the PR checklist",
+        interrupt: false,
+        resolution,
+      });
+      expect(result).toEqual({
+        agent_id: worker.id,
+        status: "running",
+        resolution_ignored: "no pending escalation",
+      });
+    }
+    expect(delivered).toEqual(
+      fillers.map(() => "also require the PR checklist"),
+    );
+  });
+
+  test("an interrupt carrying a resolution with no pending escalation interrupts as a plain interrupt would", async () => {
+    let interrupted = false;
+    const followups: string[] = [];
+    const { sessions, fleetRecords, worker } = liveLane({
+      interrupt: () => {
+        interrupted = true;
+      },
+      followup: async (message) => {
+        followups.push(message);
+        return "queued turn finished";
+      },
+      deliver: () => {
+        throw new Error("interrupt:true should not soft-deliver");
+      },
+    });
+    const sendInput = createSendInputTool({ sessions, fleetRecords });
+
+    const result = await callTool(sendInput, {
+      target: worker.id,
+      message: "patch only the test",
+      interrupt: true,
+      resolution: {
+        questionId: "none",
+        kind: "unavailable",
+        answer: "No escalation; normal task update only.",
+      },
+    });
+    expect(result).toEqual({
+      agent_id: worker.id,
+      status: "interrupted",
+      resolution_ignored: "no pending escalation",
+    });
+    expect(interrupted).toBe(true);
+    sessions.attachReport(worker.id, "salvage", { stopReason: "interrupted" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(followups).toEqual(["patch only the test"]);
+  });
+
+  test("an interrupt carrying a resolution is refused while an ask is pending", async () => {
+    let interrupted = false;
+    const { sessions, fleetRecords, worker } = liveLane({
+      interrupt: () => {
+        interrupted = true;
+      },
+      followup: async () => "unused",
+    });
+    sessions.registerAsk(worker.id, {
+      question: "which file?",
+      questionId: "ask-1",
+      assessment: assessedAsk,
+      resolve: () => {
+        throw new Error("should not resolve");
+      },
+      reject: () => undefined,
+    });
+    const sendInput = createSendInputTool({ sessions, fleetRecords });
+
+    const result = await callFleetToolRaw(sendInput, {
+      target: worker.id,
+      message: "use branch X",
+      interrupt: true,
+      resolution: {
+        questionId: "ask-1",
+        kind: "director_answer",
+        answer: "use branch X",
+      },
+    });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("cannot interrupt");
+    expect(interrupted).toBe(false);
+    expect(sessions.hasPendingAsk(worker.id)).toBe(true);
+  });
+
+  test("an interrupt carrying a malformed resolution while an ask is pending reports the interrupt conflict", async () => {
+    let interrupted = false;
+    const { sessions, fleetRecords, worker } = liveLane({
+      interrupt: () => {
+        interrupted = true;
+      },
+      followup: async () => "unused",
+    });
+    sessions.registerAsk(worker.id, {
+      question: "which file?",
+      questionId: "ask-1",
+      assessment: assessedAsk,
+      resolve: () => {
+        throw new Error("should not resolve");
+      },
+      reject: () => undefined,
+    });
+    const sendInput = createSendInputTool({ sessions, fleetRecords });
+
+    const result = await callFleetToolRaw(sendInput, {
+      target: worker.id,
+      message: "use branch X",
+      interrupt: true,
+      resolution: { questionId: "", kind: "not_a_kind", answer: "" },
+    });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("cannot interrupt");
+    expect(result.content).not.toContain("resolution invalid");
+    expect(interrupted).toBe(false);
+    expect(sessions.hasPendingAsk(worker.id)).toBe(true);
+  });
+
+  test("an unusable resolution against a pending ask names the plain-message alternative", async () => {
+    const sessions = createSubAgentSessionStore();
+    const fleetRecords = createFleetMailbox(sessions);
+    const sendInput = createSendInputTool({ sessions, fleetRecords });
+    const worker = startSession(sessions, { description: "worker" });
+    sessions.markRunning(worker.id);
+    sessions.registerAsk(worker.id, {
+      question: "which file?",
+      questionId: "ask-1",
+      assessment: assessedAsk,
+      resolve: () => undefined,
+      reject: () => undefined,
+    });
+
+    for (const resolution of [
+      { questionId: "", kind: "director_answer", answer: "" },
+      { questionId: "ask-0", kind: "declined", answer: "No." },
+    ]) {
+      const result = await callFleetToolRaw(sendInput, {
+        target: worker.id,
+        message: "No.",
+        resolution,
+      });
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "Omit resolution to answer with a plain message.",
+      );
+    }
+    expect(sessions.hasPendingAsk(worker.id)).toBe(true);
+  });
 });
 
 describe("nested lifecycle authority", () => {

src/subagent/lifecycle-tools.ts

@@ -448,6 +448,8 @@ export function createInterruptAgentTool(
   });
 }
 
+const OMIT_RESOLUTION_HINT = "Omit resolution to answer with a plain message.";
+
 const SendInputArgs = type({
   target: "string",
   message: "string",
@@ -458,7 +460,7 @@ const SendInputArgs = type({
 export const sendInputToolDefinition: ToolDefinition = {
   name: "send_input",
   description:
-    "Message a running worker only (check list_agents for status) — completed or interrupted workers need resume_agent instead; shutdown workers are gone (see read_agent_trace or spawn anew). Answers a pending ask_director; interrupt:true stops the current turn first and queues message as the next turn.",
+    "Message a running worker only (check list_agents for status) — completed or interrupted workers need resume_agent instead; shutdown workers are gone (see read_agent_trace or spawn anew). Answers a pending ask_director; a resolution sent with no ask pending is ignored and the message is delivered plainly (the result carries resolution_ignored). interrupt:true stops the current turn first and queues message as the next turn.",
   inputSchema: {
     type: "object",
     properties: {
@@ -477,7 +479,7 @@ export const sendInputToolDefinition: ToolDefinition = {
       resolution: {
         type: "object",
         description:
-          "Optional explicit pending-escalation resolution (questionId, kind, answer). It never grants or retries a tool. The message is delivered together with the structured answer.",
+          "Optional explicit pending-escalation resolution (questionId, kind, answer). Omit it unless answering a pending ask_director; with no ask pending it is ignored and the message is delivered as plain input. It never grants or retries a tool. The message is delivered together with the structured answer.",
         properties: {
           questionId: {
             type: "string",
@@ -534,31 +536,32 @@ export function createSendInputTool(deps: LifecycleToolDeps): AgentTool {
             `(got ${message.length}).`,
         );
       }
-      if (parsed.resolution !== undefined) {
-        if (parsed.interrupt === true) {
-          return lifecycleResult(
-            call.id,
-            "Error: structured escalation resolution cannot interrupt a worker.",
-          );
-        }
+      // Field-filling models send a resolution on every call. With no ask
+      // pending it has nothing to answer, so the message goes out as plain
+      // input instead of failing on filler.
+      const pending = deps.sessions.peekAsk(target);
+      const answersAsk =
+        parsed.resolution !== undefined && pending !== undefined;
+      // Answering resumes the parked turn and an interrupt would stop it.
+      // Checked before parsing so a malformed resolution still gets this error.
+      if (answersAsk && parsed.interrupt === true) {
+        return lifecycleResult(
+          call.id,
+          "Error: structured escalation resolution cannot interrupt a worker.",
+        );
+      }
+      if (answersAsk) {
         const resolution = parseEscalationResolution(parsed.resolution);
         if (resolution instanceof Error) {
           return lifecycleResult(
             call.id,
-            `Error: send_input resolution invalid: ${resolution.message}`,
-          );
-        }
-        const pending = deps.sessions.peekAsk(target);
-        if (pending === undefined) {
-          return lifecycleResult(
-            call.id,
-            `Error: no pending escalation for "${target}".`,
+            `Error: send_input resolution invalid: ${resolution.message} ${OMIT_RESOLUTION_HINT}`,
           );
         }
         if (pending.questionId !== resolution.questionId) {
           return lifecycleResult(
             call.id,
-            `Error: send_input resolution questionId mismatch: pending ask is "${pending.questionId}", resolution names "${resolution.questionId}".`,
+            `Error: send_input resolution questionId mismatch: pending ask is "${pending.questionId}", resolution names "${resolution.questionId}". ${OMIT_RESOLUTION_HINT}`,
           );
         }
         // SF6: deliver the parent's message together with the structured
@@ -629,7 +632,13 @@ export function createSendInputTool(deps: LifecycleToolDeps): AgentTool {
       }
       return lifecycleResult(
         call.id,
-        fleetJson({ agent_id: target, status: outcome.status }),
+        fleetJson({
+          agent_id: target,
+          status: outcome.status,
+          ...(parsed.resolution !== undefined
+            ? { resolution_ignored: "no pending escalation" }
+            : {}),
+        }),
       );
     },
   });