feat(core): allow user feedback when cancelling a tool call

packages/core/src/scheduler/confirmation.ts

@@ -46,6 +46,11 @@ export interface ConfirmationResult {
 export interface ResolutionResult {
   outcome: ToolConfirmationOutcome;
   lastDetails?: SerializableConfirmationDetails;
+  /**
+   * Final payload from the user's confirmation response. May carry feedback
+   * (when outcome is Cancel) or other outcome-specific data.
+   */
+  payload?: ToolConfirmationPayload;
 }
 
 /**
@@ -125,6 +130,7 @@ export async function resolveConfirmation(
   const callId = toolCall.request.callId;
   let outcome = ToolConfirmationOutcome.ModifyWithEditor;
   let lastDetails: SerializableConfirmationDetails | undefined;
+  let lastPayload: ToolConfirmationPayload | undefined;
 
   // Loop exists to allow the user to modify the parameters and see the new
   // diff.
@@ -173,6 +179,7 @@ export async function resolveConfirmation(
     );
     onWaitingForConfirmation?.(false);
     outcome = response.outcome;
+    lastPayload = response.payload;
 
     if ('onConfirm' in details && typeof details.onConfirm === 'function') {
       await details.onConfirm(outcome, response.payload);
@@ -195,7 +202,7 @@ export async function resolveConfirmation(
     }
   }
 
-  return { outcome, lastDetails };
+  return { outcome, lastDetails, payload: lastPayload };
 }
 
 /**

packages/core/src/scheduler/scheduler.test.ts

@@ -978,6 +978,51 @@ describe('Scheduler (Orchestrator)', () => {
       );
     });
 
+    it('should include feedback in cancel reason when payload carries feedback', async () => {
+      vi.mocked(checkPolicy).mockResolvedValue({
+        decision: PolicyDecision.ASK_USER,
+        rule: undefined,
+      });
+
+      const resolution = {
+        outcome: ToolConfirmationOutcome.Cancel,
+        lastDetails: undefined,
+        payload: { feedback: "don't overwrite, append instead" },
+      };
+      vi.mocked(resolveConfirmation).mockResolvedValue(resolution);
+
+      await scheduler.schedule(req1, signal);
+
+      expect(mockStateManager.updateStatus).toHaveBeenCalledWith(
+        'call-1',
+        CoreToolCallStatus.Cancelled,
+        "User denied execution. Feedback: don't overwrite, append instead",
+      );
+      expect(mockExecutor.execute).not.toHaveBeenCalled();
+    });
+
+    it('should fall back to plain reason when feedback is empty string', async () => {
+      vi.mocked(checkPolicy).mockResolvedValue({
+        decision: PolicyDecision.ASK_USER,
+        rule: undefined,
+      });
+
+      const resolution = {
+        outcome: ToolConfirmationOutcome.Cancel,
+        lastDetails: undefined,
+        payload: { feedback: '' },
+      };
+      vi.mocked(resolveConfirmation).mockResolvedValue(resolution);
+
+      await scheduler.schedule(req1, signal);
+
+      expect(mockStateManager.updateStatus).toHaveBeenCalledWith(
+        'call-1',
+        CoreToolCallStatus.Cancelled,
+        'User denied execution.',
+      );
+    });
+
     it('should preserve confirmation details (e.g. diff) in cancelled state', async () => {
       vi.mocked(checkPolicy).mockResolvedValue({
         decision: PolicyDecision.ASK_USER,

packages/core/src/scheduler/scheduler.ts

@@ -646,6 +646,7 @@ export class Scheduler {
     // User Confirmation Loop
     let outcome = ToolConfirmationOutcome.ProceedOnce;
     let lastDetails: SerializableConfirmationDetails | undefined;
+    let cancelFeedback: string | undefined;
 
     if (decision === PolicyDecision.ASK_USER) {
       const result = await resolveConfirmation(toolCall, signal, {
@@ -661,6 +662,15 @@ export class Scheduler {
       });
       outcome = result.outcome;
       lastDetails = result.lastDetails;
+      if (
+        outcome === ToolConfirmationOutcome.Cancel &&
+        result.payload &&
+        'feedback' in result.payload &&
+        typeof result.payload.feedback === 'string' &&
+        result.payload.feedback.length > 0
+      ) {
+        cancelFeedback = result.payload.feedback;
+      }
     }
 
     this.state.setOutcome(callId, outcome);
@@ -679,11 +689,10 @@ export class Scheduler {
 
     // Handle cancellation (cascades to entire batch)
     if (outcome === ToolConfirmationOutcome.Cancel) {
-      this.state.updateStatus(
-        callId,
-        CoreToolCallStatus.Cancelled,
-        'User denied execution.',
-      );
+      const reason = cancelFeedback
+        ? `User denied execution. Feedback: ${cancelFeedback}`
+        : 'User denied execution.';
+      this.state.updateStatus(callId, CoreToolCallStatus.Cancelled, reason);
       this.state.cancelAllQueued('User cancelled operation');
       return; // Skip execution
     }

packages/core/src/tools/tools.ts

@@ -1005,10 +1005,21 @@ export interface ToolExitPlanModeConfirmationPayload {
   feedback?: string;
 }
 
+export interface ToolCancelWithFeedbackPayload {
+  /**
+   * User-authored reason for cancelling the tool call. When present on a
+   * response whose outcome is Cancel, the scheduler appends this string to
+   * the cancellation message delivered back to the model, so the model can
+   * see why the call was denied without waiting for the next user turn.
+   */
+  feedback: string;
+}
+
 export type ToolConfirmationPayload =
   | ToolEditConfirmationPayload
   | ToolAskUserConfirmationPayload
-  | ToolExitPlanModeConfirmationPayload;
+  | ToolExitPlanModeConfirmationPayload
+  | ToolCancelWithFeedbackPayload;
 
 export interface ToolSandboxExpansionConfirmationDetails {
   type: 'sandbox_expansion';