repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

fix(devil): compact and retry on timeout

167ffa0ab805d3265654a438f057aa079bafa30e

Oliver Jan Krylow <oliver@bugabinga.net> ·

unsigned

Browse filesCompare with HEAD

Changed files (4)

extensions/devil/README.md

Modified
64 64 ## Behavior
66 -| Aspect | Behavior |
67 -| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
68 -| Session state | Each debate is independent. Final accepted output is appended as `devil-result`. |
69 -| UI | Requires interactive Pi UI. Opens live review, then result editor. |
70 -| Context | Uses current cwd, context usage, and an ephemeral fork of the current Pi session branch. |
71 -| Models | Devil uses `devil.model` or current model. Defense uses `devil.defenderModel` or current model. Synthesis uses Devil model. |
72 -| Auth | Requires API auth for Devil and Defense model providers before starting. |
73 -| Context guard | Blocks before starting if current usage + 16k token overhead exceeds 85% of the smaller Devil/Defense context window. |
74 -| Sub-agents | Load normal Pi settings/resources/extensions unless `devil.extensionMode` is `off`. |
75 -| Sub-agent tools | All available tools except `write` and `edit`. |
76 -| Rounds | Devil challenges, Defense responds, transcript accumulates, synthesis produces final verdict. |
77 -| Stop: `consensus` | Stops after 2 consecutive resolved Defense responses using `concessionThreshold`, or after `maxRounds`. |
78 -| Stop: `blocking_found` | Stops when a Devil round raises zero blocking issues, or after `maxRounds`. |
79 -| Stop: `max_rounds` | Runs until `maxRounds`. |
80 -| Live review keys | `↑↓/j/k` scroll, `PgUp/Ctrl+u` and `PgDown/Ctrl+d` page, `g/G` top/end. |
81 -| Cancel | `q`, `Esc`, or `Ctrl+C` cancels the live review. |
82 -| Failure | Failed review stays open until closed. Timeout message suggests `/compact`, then retry. Closing a failed review restores `/devil <idea>` in the editor. |
83 -| Results | Edited verdict is appended as `devil-result`; main agent receives advisory handoff and must wait for the next user reply before execution. |
84 -| Cleanup | Role-agent forks are removed after use. Leftover temporary debate forks older than 24h are removed on extension load. |
66 +| Aspect | Behavior |
67 +| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
68 +| Session state | Each debate is independent. Final accepted output is appended as `devil-result`. |
69 +| UI | Requires interactive Pi UI. Opens live review, then result editor. |
70 +| Context | Uses current cwd, context usage, and an ephemeral fork of the current Pi session branch. |
71 +| Models | Devil uses `devil.model` or current model. Defense uses `devil.defenderModel` or current model. Synthesis uses Devil model. |
72 +| Auth | Requires API auth for Devil and Defense model providers before starting. |
73 +| Context guard | Blocks before starting if current usage + 16k token overhead exceeds 85% of the smaller Devil/Defense context window. |
74 +| Sub-agents | Load normal Pi settings/resources/extensions unless `devil.extensionMode` is `off`. |
75 +| Sub-agent tools | All available tools except `write` and `edit`. |
76 +| Rounds | Devil challenges, Defense responds, transcript accumulates, synthesis produces final verdict. |
77 +| Stop: `consensus` | Stops after 2 consecutive resolved Defense responses using `concessionThreshold`, or after `maxRounds`. |
78 +| Stop: `blocking_found` | Stops when a Devil round raises zero blocking issues, or after `maxRounds`. |
79 +| Stop: `max_rounds` | Runs until `maxRounds`. |
80 +| Live review keys | `↑↓/j/k` scroll, `PgUp/Ctrl+u` and `PgDown/Ctrl+d` page, `g/G` top/end. |
81 +| Cancel | `q`, `Esc`, or `Ctrl+C` cancels the live review. |
82 +| Failure | Failed review stays open until closed. Timeout auto-compacts once, then retries once. Closing a failed review restores `/devil <idea>` in the editor. |
83 +| Results | Edited verdict is appended as `devil-result`; main agent receives advisory handoff and must wait for the next user reply before execution. |
84 +| Cleanup | Role-agent forks are removed after use. Leftover temporary debate forks older than 24h are removed on extension load. |
86 86 ## Configuration
145 145 ### Context limit block
147 +If startup projected context is too large, `/devil` blocks before spending tokens.
147 148 Run `/compact`, then retry `/devil`.
149 +If a role times out mid-debate, `/devil` auto-compacts once and retries once.
149 151 ### Irrelevant challenges

extensions/devil/__tests__/settings.test.ts

Modified
7 7 DEFAULT_SYNTHESIS_THINKING,
8 8 DebateReviewComponent,
9 9 DevilTimeoutError,
10 + formatDebateError,
10 11 handleDebateResult,
11 12 normalizeThinkingLevel,
12 13 renderDebateTranscript,
13 14 responseTextFromContent,
14 15 withRoleTimeout,
16 + withTimeoutCompactionRetry,
15 17 } from "../index.ts";
17 19 describe("devil settings", () => {
61 + it("formats timeout errors without manual compact instruction", () => {
62 + expect(formatDebateError(new DevilTimeoutError("Devil", 90_000))).toBe(
63 + "Devil timed out after 90s. Provider stalled or prompt too large.",
64 + );
65 + });
67 + it("compacts once and retries after timeout", async () => {
68 + let attempts = 0;
69 + let compactions = 0;
70 + const statuses: string[] = [];
72 + const result = await withTimeoutCompactionRetry({
73 + run: async () => {
74 + attempts++;
75 + if (attempts === 1) throw new DevilTimeoutError("Devil", 90_000);
76 + return "ok";
77 + },
78 + compact: async () => {
79 + compactions++;
80 + },
81 + onStatus: (status) => statuses.push(status),
82 + });
84 + expect(result).toBe("ok");
85 + expect(attempts).toBe(2);
86 + expect(compactions).toBe(1);
87 + expect(statuses).toEqual([
88 + "Devil timed out after 90s · compacting",
89 + "Compaction complete · retrying debate",
90 + ]);
91 + });
93 + it("does not retry non-timeout errors", async () => {
94 + let attempts = 0;
95 + let compactions = 0;
96 + await expect(
97 + withTimeoutCompactionRetry({
98 + run: async () => {
99 + attempts++;
100 + throw new Error("provider failed");
101 + },
102 + compact: async () => {
103 + compactions++;
104 + },
105 + }),
106 + ).rejects.toThrow("provider failed");
107 + expect(attempts).toBe(1);
108 + expect(compactions).toBe(0);
109 + });
111 + it("surfaces compact failure after timeout", async () => {
112 + await expect(
113 + withTimeoutCompactionRetry({
114 + run: async () => {
115 + throw new DevilTimeoutError("Defense", 90_000);
116 + },
117 + compact: async () => {
118 + throw new Error("compact broke");
119 + },
120 + }),
121 + ).rejects.toThrow(
122 + "Defense timed out after 90s. Compaction failed: compact broke",
123 + );
124 + });
126 + it("reports second timeout after compaction without retry loop", async () => {
127 + let attempts = 0;
128 + await expect(
129 + withTimeoutCompactionRetry({
130 + run: async () => {
131 + attempts++;
132 + throw new DevilTimeoutError("Devil", 90_000);
133 + },
134 + compact: async () => {},
135 + }),
136 + ).rejects.toThrow(
137 + "Devil timed out after 90s after compaction. Provider stalled or prompt too large.",
138 + );
139 + expect(attempts).toBe(2);
140 + });
59 142 it("aborts child signal and calls timeout hook on timeout", async () => {
60 143 let aborted = false;
61 144 let timeoutCount = 0;

extensions/devil/index.ts

Modified
60 60 formatDebateError,
61 61 type TimeoutRole,
62 62 withRoleTimeout,
63 + withTimeoutCompactionRetry,
63 64 } from "./timeouts";
64 65 import type { DebateOutput } from "./types";
65 66 import {
71 72 } from "./ui";
73 74 export { buildMainAgentHandoff, handleDebateResult } from "./handoff";
74 -export { DevilTimeoutError, withRoleTimeout } from "./timeouts";
75 +export {
76 + DevilTimeoutError,
77 + formatDebateError,
78 + withRoleTimeout,
79 + withTimeoutCompactionRetry,
80 +} from "./timeouts";
75 81 export {
76 82 createDebateState,
77 83 DebateReviewComponent,
901 907 return Math.max(10_000, Math.min(600_000, value));
910 +function compactSession(ctx: ExtensionContext, idea: string): Promise<void> {
911 + return new Promise((resolve, reject) => {
912 + ctx.compact({
913 + customInstructions: `Preserve enough context to retry /devil for this idea:\n${idea}`,
914 + onComplete: () => resolve(),
915 + onError: reject,
916 + });
917 + });
904 920 // ── Extension entry ───────────────────────────────────────────────────
906 922 export default async function (pi: ExtensionAPI) {
1022 1038 const concessionThreshold =
1023 1039 devilSettings.concessionThreshold ?? DEFAULT_CONCESSION_THRESHOLD;
1024 1040 const onBlocking = devilSettings.onBlocking ?? DEFAULT_ON_BLOCKING;
1025 - const debateContext = gatherContext(ctx);
1027 1042 const debateController = new AbortController();
1028 1043 activeControllers.add(debateController);
1046 1061 debateController,
1049 - runDebate({
1050 - idea,
1051 - context: debateContext,
1052 - model,
1053 - defenderModel,
1054 - ctx,
1055 - apiKey,
1056 - headers: auth.headers,
1057 - devilThinkingLevel,
1058 - defenderThinkingLevel,
1059 - synthesisThinkingLevel,
1060 - roleTimeoutMs,
1061 - maxRounds,
1062 - extensionMode,
1063 - stoppingConditions,
1064 - concessionThreshold,
1065 - signal: review.signal,
1066 - onStatus: (status, round, _max, blocking) => {
1067 - if (!review.isActive()) return;
1068 - setDebateStatus(live, status, round, blocking);
1069 - review.refresh();
1070 - },
1071 - onPartial: (role, round, _max, blocking, text) => {
1072 - if (!review.isActive()) return;
1073 - upsertDebateEntry(live, role, round, blocking, text, false);
1074 - review.refresh();
1075 - },
1076 - onChallenge: (round, _max, blocking, devilOutput) => {
1077 - if (!review.isActive()) return;
1078 - upsertDebateEntry(
1079 - live,
1080 - "devil",
1081 - round,
1082 - blocking,
1083 - devilOutput,
1084 - true,
1085 - );
1086 - review.refresh();
1087 - },
1088 - onRound: (
1089 - round,
1090 - _max,
1091 - blocking,
1092 - _status,
1093 - _devilOutput,
1094 - proposerOutput,
1095 - ) => {
1096 - if (!review.isActive()) return;
1097 - upsertDebateEntry(
1098 - live,
1099 - "proposer",
1064 + const runOnce = () =>
1065 + runDebate({
1066 + idea,
1067 + context: gatherContext(ctx),
1068 + model,
1069 + defenderModel,
1070 + ctx,
1071 + apiKey,
1072 + headers: auth.headers,
1073 + devilThinkingLevel,
1074 + defenderThinkingLevel,
1075 + synthesisThinkingLevel,
1076 + roleTimeoutMs,
1077 + maxRounds,
1078 + extensionMode,
1079 + stoppingConditions,
1080 + concessionThreshold,
1081 + signal: review.signal,
1082 + onStatus: (status, round, _max, blocking) => {
1083 + if (!review.isActive()) return;
1084 + setDebateStatus(live, status, round, blocking);
1085 + review.refresh();
1086 + },
1087 + onPartial: (role, round, _max, blocking, text) => {
1088 + if (!review.isActive()) return;
1089 + upsertDebateEntry(live, role, round, blocking, text, false);
1090 + review.refresh();
1091 + },
1092 + onChallenge: (round, _max, blocking, devilOutput) => {
1093 + if (!review.isActive()) return;
1094 + upsertDebateEntry(
1095 + live,
1096 + "devil",
1097 + round,
1098 + blocking,
1099 + devilOutput,
1100 + true,
1101 + );
1102 + review.refresh();
1103 + },
1104 + onRound: (
1106 + _max,
1101 1107 blocking,
1108 + _status,
1109 + _devilOutput,
1102 1110 proposerOutput,
1103 - true,
1104 - );
1111 + ) => {
1112 + if (!review.isActive()) return;
1113 + upsertDebateEntry(
1114 + live,
1115 + "proposer",
1116 + round,
1117 + blocking,
1118 + proposerOutput,
1119 + true,
1120 + );
1121 + review.refresh();
1122 + },
1123 + });
1125 + withTimeoutCompactionRetry({
1126 + run: runOnce,
1127 + compact: () => compactSession(ctx, idea),
1128 + signal: review.signal,
1129 + onStatus: (status) => {
1130 + if (!review.isActive()) return;
1131 + if (status.startsWith("Compaction complete")) {
1132 + live.entries = [];
1133 + live.error = undefined;
1134 + setDebateStatus(live, status, 0, 0);
1135 + } else {
1136 + setDebateStatus(
1137 + live,
1138 + status,
1139 + live.currentRound,
1140 + live.blocking,
1141 + );
1105 1143 review.refresh();
1109 1147 .catch((err) => {
1110 1148 if (!review.signal.aborted && review.isActive()) {
1111 1149 failedMessage = formatDebateError(err);
1112 - console.error("[devil] runDebate error:", err);
1150 + console.error("[devil] runDebate error:", failedMessage);
1113 1151 live.error = failedMessage;
1114 1152 setDebateStatus(

extensions/devil/timeouts.ts

Modified
13 13 export function formatDebateError(error: unknown): string {
14 14 if (error instanceof DevilTimeoutError) {
15 - return `${error.message}. Likely huge context or stalled provider. Run /compact, then retry /devil.`;
15 + return `${error.message}. Provider stalled or prompt too large.`;
17 17 return error instanceof Error ? error.message : String(error);
20 +export async function withTimeoutCompactionRetry<T>(opts: {
21 + run: () => Promise<T>;
22 + compact: () => Promise<void>;
23 + signal?: AbortSignal;
24 + onStatus?: (status: string) => void;
25 +}): Promise<T> {
26 + try {
27 + return await opts.run();
28 + } catch (error) {
29 + if (!(error instanceof DevilTimeoutError) || opts.signal?.aborted)
30 + throw error;
31 + opts.onStatus?.(`${error.message} · compacting`);
32 + try {
33 + await opts.compact();
34 + } catch (compactError) {
35 + throw new Error(
36 + `${error.message}. Compaction failed: ${formatDebateError(compactError)}`,
37 + );
38 + }
39 + if (opts.signal?.aborted) throw new Error("Aborted");
40 + opts.onStatus?.("Compaction complete · retrying debate");
41 + try {
42 + return await opts.run();
43 + } catch (retryError) {
44 + if (retryError instanceof DevilTimeoutError) {
45 + throw new Error(
46 + `${retryError.message} after compaction. Provider stalled or prompt too large.`,
47 + );
48 + }
49 + throw retryError;
50 + }
51 + }
20 54 export async function withRoleTimeout<T>(
21 55 role: TimeoutRole,
22 56 timeoutMs: number,