agent-relay-runner 0.95.1 → 0.96.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.95.1",
+  "version": "0.96.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.76"
+    "agent-relay-sdk": "0.2.77"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.95.1",
+  "version": "0.96.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/control-server.ts

@@ -50,6 +50,7 @@ interface ControlServerOptions {
   // isPreFlush: true signals a mid-turn call from a PreToolUse hook — flush any
   // un-mirrored narrative before the interactive form appears in chat (#435).
   onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown; isPreFlush?: boolean }): Promise<void>;
+  onPermissionResolved?(input: ResolvedPermissionPrompt): Promise<void> | void;
   // A provider UserPromptSubmit hook hands over the prompt the human typed
   // directly into the session (web terminal / TUI) so the runner can mirror it
   // into the dashboard chat and start tailing the turn transcript for reasoning.
@@ -69,6 +70,21 @@ interface ControlServerOptions {
   permissionWaitMs?: number;
 }
 
+export interface ResolvedPermissionPrompt {
+  provider: "claude";
+  kind: "questions" | "plan" | "command" | "tool";
+  title: string;
+  body: string;
+  promptBody?: string;
+  toolName: string;
+  hookEventName: string;
+  approvalId: string;
+  decision: ProviderPermissionDecisionInput["decision"];
+  decisionLabel: string;
+  questions?: unknown[];
+  answers?: Record<string, string>;
+}
+
 export function startControlServer(options: ControlServerOptions): ControlServer {
   const monitors = new Set<MonitorSocket>();
   const pendingDeliveries = new Map<string, { resolve(ids: number[]): void; timer: Timer }>();
@@ -279,6 +295,10 @@ async function handlePermissionRequest(
     pendingPermissionRequests.set(approvalId, { resolve, timer });
   });
 
+  if (decision.reason !== PERMISSION_TIMEOUT_REASON && options.onPermissionResolved) {
+    await Promise.resolve(options.onPermissionResolved(claudeResolvedPermissionPrompt(view, decision, body))).catch(() => {});
+  }
+
   return Response.json(claudePermissionHookResponse(decision, body));
 }
 
@@ -409,6 +429,68 @@ function claudePermissionHookResponse(decision: ProviderPermissionDecisionInput,
   };
 }
 
+function claudeResolvedPermissionPrompt(view: Record<string, unknown>, decision: ProviderPermissionDecisionInput, body: Record<string, unknown>): ResolvedPermissionPrompt {
+  const toolName = typeof body.tool_name === "string" ? body.tool_name : "Tool";
+  const toolInput = isRecord(body.tool_input) ? body.tool_input : {};
+  const kind = view.kind === "questions" || view.kind === "plan" || view.kind === "command" || view.kind === "tool"
+    ? view.kind
+    : toolName.toLowerCase() === "bash" ? "command" : "tool";
+  const questions = Array.isArray(view.questions)
+    ? view.questions
+    : Array.isArray(toolInput.questions) ? toolInput.questions : undefined;
+  const promptBody = typeof view.body === "string" ? view.body : "";
+  const decisionLabel = claudePermissionDecisionLabel(kind, decision.decision);
+  return {
+    provider: "claude",
+    kind,
+    title: typeof view.title === "string" && view.title ? view.title : `Approve ${toolName}`,
+    body: claudeResolvedPermissionBody({ kind, title: typeof view.title === "string" && view.title ? view.title : `Approve ${toolName}`, toolName, promptBody, decisionLabel, questions, answers: decision.answers }),
+    ...(promptBody ? { promptBody } : {}),
+    toolName,
+    hookEventName: typeof body.hook_event_name === "string" ? body.hook_event_name : "PermissionRequest",
+    approvalId: decision.approvalId,
+    decision: decision.decision,
+    decisionLabel,
+    ...(questions ? { questions } : {}),
+    ...(decision.answers ? { answers: decision.answers } : {}),
+  };
+}
+
+function claudeResolvedPermissionBody(input: { kind: ResolvedPermissionPrompt["kind"]; title: string; toolName: string; promptBody: string; decisionLabel: string; questions?: unknown[]; answers?: Record<string, string> }): string {
+  if (input.kind === "questions") {
+    return [
+      input.title,
+      input.decisionLabel,
+      ...resolvedQuestionRows(input.questions, input.answers, input.decisionLabel).map((row) => `Q: ${row.question}\nA: ${row.answer}`),
+    ].filter(Boolean).join("\n\n");
+  }
+  const subject = input.kind === "plan" ? "Plan prompt resolved" : `${input.toolName} permission resolved`;
+  return [subject, `Decision: ${input.decisionLabel}`, input.promptBody.trim()].filter(Boolean).join("\n\n");
+}
+
+function resolvedQuestionRows(questions: unknown[] | undefined, answers: Record<string, string> | undefined, fallback: string): Array<{ question: string; answer: string }> {
+  const answerMap = answers ?? {};
+  const rows = (questions ?? []).map((question, index) => {
+    const record = question && typeof question === "object" && !Array.isArray(question) ? question as Record<string, unknown> : {};
+    const label = typeof record.question === "string" && record.question.trim()
+      ? record.question.trim()
+      : typeof record.header === "string" && record.header.trim() ? record.header.trim() : `Question ${index + 1}`;
+    const rawAnswer = answerMap[label] ?? answerMap[String(record.question ?? "")] ?? answerMap[String(record.header ?? "")];
+    return { question: label, answer: typeof rawAnswer === "string" && rawAnswer.trim() ? rawAnswer.trim() : fallback };
+  });
+  return rows.length ? rows : Object.entries(answerMap).map(([question, answer]) => ({ question, answer }));
+}
+
+function claudePermissionDecisionLabel(kind: ResolvedPermissionPrompt["kind"], decision: ProviderPermissionDecisionInput["decision"]): string {
+  if (kind === "questions") return decision === "answer" ? "Answered" : "Dismissed";
+  if (kind === "plan") return decision === "approve" || decision === "approve-session" ? "Approved plan" : "Kept planning";
+  if (decision === "approve-session") return "Approved for session";
+  if (decision === "approve") return "Approved";
+  if (decision === "abort") return "Aborted";
+  if (decision === "answer") return "Answered";
+  return "Denied";
+}
+
 async function handleSessionTurn(req: Request, options: ControlServerOptions): Promise<Response> {
   if (!options.onSessionTurn) return Response.json({ ok: false, reason: "session capture unavailable" });
   const body = await req.json().catch(() => null);

package/src/runner-core.ts

@@ -12,7 +12,7 @@ import { messagesWithCachedAttachments } from "./attachment-cache";
 import { ClaimTracker } from "./claim-tracker";
 import { ClaudeQuotaHarvest } from "./claude-quota-harvest";
 import { readRunnerContextProbeState } from "./context-probe-state";
-import { startControlServer, type ControlServer } from "./control-server";
+import { startControlServer, type ControlServer, type ResolvedPermissionPrompt } from "./control-server";
 import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureReplyRoute } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
@@ -409,7 +409,7 @@ export class AgentRunner {
       // Hot-path-safe: answered instantly from the local snapshot, never a server
       // round-trip. The snapshot is kept warm by the background refresh below (#196).
       onReplyObligations: () => Promise.resolve(this.obligationCache.get()),
-      onSessionTurn: (input) => this.publishSessionTurn(input),
+      onSessionTurn: (input) => this.publishSessionTurn(input), onPermissionResolved: (input) => this.publishSessionEvent({ from: this.agentId, to: "user", body: input.body, session: { type: "prompt-resolution", origin: "provider", label: input.decisionLabel, ...(this.currentTurnId ? { turnId: this.currentTurnId } : {}), stepId: `prompt-resolution:${input.approvalId}`, promptResolution: input } }),
       onUserPrompt: (input) => this.handleUserPrompt(input),
       onSessionBoundary: (input) => this.handleSessionBoundary(input),
       onHookFatal: (report) => this.reportHookFatal(report),