@narumitw/pi-goal 0.11.0 → 0.13.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +51 -21
- package/package.json +4 -3
- package/src/goal.ts +748 -145
package/src/goal.ts
CHANGED
|
@@ -10,7 +10,19 @@ import {
|
|
|
10
10
|
} from "@earendil-works/pi-ai";
|
|
11
11
|
import { Type } from "typebox";
|
|
12
12
|
|
|
13
|
-
|
|
13
|
+
// This extension intentionally keeps its state machine in one module: every Pi
|
|
14
|
+
// lifecycle hook and tool coordinates the same goal, continuation, retry, and
|
|
15
|
+
// budget single-flight state. Splitting those handlers would create ambiguous
|
|
16
|
+
// state ownership; colocated pure helpers keep each transition reviewable with
|
|
17
|
+
// the callbacks that consume it.
|
|
18
|
+
|
|
19
|
+
type GoalStatus =
|
|
20
|
+
| "active"
|
|
21
|
+
| "paused"
|
|
22
|
+
| "blocked"
|
|
23
|
+
| "usage_limited"
|
|
24
|
+
| "budget_limited"
|
|
25
|
+
| "complete";
|
|
14
26
|
type AgentStopReason = "stop" | "length" | "toolUse" | "error" | "aborted";
|
|
15
27
|
|
|
16
28
|
interface ActiveGoal {
|
|
@@ -24,20 +36,35 @@ interface ActiveGoal {
|
|
|
24
36
|
tokensUsed: number;
|
|
25
37
|
timeUsedSeconds: number;
|
|
26
38
|
baselineTokens: number;
|
|
39
|
+
activeStartedAt?: number;
|
|
27
40
|
}
|
|
28
41
|
|
|
29
42
|
interface GoalCompleteDetails {
|
|
30
43
|
goal: string;
|
|
44
|
+
goal_id: string;
|
|
31
45
|
summary: string;
|
|
32
46
|
}
|
|
33
47
|
|
|
34
|
-
interface
|
|
48
|
+
interface GoalBlockedDetails {
|
|
49
|
+
goal: string;
|
|
50
|
+
goal_id: string;
|
|
51
|
+
reason: string;
|
|
52
|
+
evidence: string;
|
|
53
|
+
repeated_turns: number;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
interface ContinuationTicket {
|
|
35
57
|
goalId: string;
|
|
36
58
|
iteration: number;
|
|
37
59
|
marker: string;
|
|
38
60
|
prompt: string;
|
|
39
61
|
}
|
|
40
62
|
|
|
63
|
+
interface BudgetWrapUp {
|
|
64
|
+
goalId: string;
|
|
65
|
+
delivered: boolean;
|
|
66
|
+
}
|
|
67
|
+
|
|
41
68
|
type GoalRecoveryKind = "provider_retry" | "compaction_retry";
|
|
42
69
|
|
|
43
70
|
interface GoalRecovery {
|
|
@@ -89,20 +116,38 @@ interface StatusContext {
|
|
|
89
116
|
const STATUS_KEY = "goal";
|
|
90
117
|
const GOAL_STATE_ENTRY_TYPE = "goal-state";
|
|
91
118
|
const MAX_OBJECTIVE_LENGTH = 4_000;
|
|
119
|
+
const MAX_BLOCKER_REASON_LENGTH = 1_000;
|
|
120
|
+
const MAX_BLOCKER_EVIDENCE_LENGTH = 4_000;
|
|
92
121
|
const MAX_CANCELLED_CONTINUATION_PROMPTS = 20;
|
|
93
122
|
const CONTINUATION_MARKER_PREFIX = "pi-goal-continuation:";
|
|
123
|
+
const BUDGET_WRAP_UP_MESSAGE_TYPE = "goal-budget-wrap-up";
|
|
124
|
+
const BUDGET_WRAP_UP_PROMPT =
|
|
125
|
+
"The active /goal token budget is exhausted. Stop substantive work and do not call substantive tools. Summarize progress, verified results, remaining work, and blockers concisely. Treat completion as unproven. Do not call goal_complete unless authoritative, requirement-by-requirement evidence already proves every requirement is complete. Weak, indirect, or missing evidence is not enough. Budget exhaustion is not completion.";
|
|
94
126
|
const CONTRADICTORY_COMPLETION_PATTERNS = [
|
|
95
127
|
/(?<!could\s)\bnot\s+(?:yet\s+)?(?:complete|completed|done|finished)\b/i,
|
|
96
128
|
/\bstill\s+(?:incomplete|failing|failing\s+tests?|fails?)\b/i,
|
|
97
129
|
/\btests?\s+(?:still\s+)?fail(?:ing)?\b/i,
|
|
98
130
|
] as const;
|
|
131
|
+
const USAGE_LIMIT_GOAL_ERROR_PATTERNS = [
|
|
132
|
+
/usage[_\s-]*(?:limit|cap)|chatgpt.{0,32}usage/i,
|
|
133
|
+
/quota.{0,32}(?:reached|exceeded|exhausted|depleted)|(?:reached|exceeded|exhausted|depleted).{0,32}quota/i,
|
|
134
|
+
/insufficient[_\s-]*(?:quota|credits?)|out of credits|out of budget|available balance|payment required/i,
|
|
135
|
+
/(?:credit|balance).{0,32}(?:low|exhausted|depleted)|billing/i,
|
|
136
|
+
] as const;
|
|
99
137
|
const NON_RETRYABLE_GOAL_ERROR_RE =
|
|
100
|
-
/
|
|
101
|
-
|
|
102
|
-
|
|
138
|
+
/multi-auth rotation failed|credentials tried|unauthori[sz]ed|invalid api key/i;
|
|
139
|
+
// Pi 0.79 does not export its assistant-error retry classifier. Keep this
|
|
140
|
+
// compatibility mirror aligned with Pi's public retry utility in newer versions.
|
|
141
|
+
const RETRYABLE_GOAL_ERROR_PATTERNS = [
|
|
142
|
+
/overloaded|rate.?limit|too many requests|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error/i,
|
|
143
|
+
/provider.?returned.?error|you can retry your request|try your request again|please retry your request/i,
|
|
144
|
+
/network.?error|connection.?(?:error|refused|lost)|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up/i,
|
|
145
|
+
/timed? out|timeout|terminated|websocket.?(?:closed|error)|ended without|stream ended before message_stop|http2 request did not get a response|retry delay/i,
|
|
146
|
+
/context[_\s-]*length[_\s-]*exceeded|input exceeds the context window/i,
|
|
147
|
+
] as const;
|
|
103
148
|
const GOAL_ARGUMENT_COMPLETIONS: readonly GoalArgumentCompletion[] = [
|
|
104
149
|
{ value: "pause", label: "pause", description: "Pause the active goal" },
|
|
105
|
-
{ value: "resume", label: "resume", description: "Resume a
|
|
150
|
+
{ value: "resume", label: "resume", description: "Resume a stopped or budget-limited goal" },
|
|
106
151
|
{ value: "clear", label: "clear", description: "Clear the current goal" },
|
|
107
152
|
{ value: "edit", label: "edit", description: "Edit the current goal objective" },
|
|
108
153
|
{ value: "status", label: "status", description: "Show the current goal" },
|
|
@@ -121,8 +166,10 @@ const STATE_FILE = join(
|
|
|
121
166
|
let activeGoal: ActiveGoal | undefined;
|
|
122
167
|
let completionStatusTimer: NodeJS.Timeout | undefined;
|
|
123
168
|
let extensionApi: ExtensionAPI | undefined;
|
|
124
|
-
let
|
|
169
|
+
let continuationIntent: ContinuationTicket | undefined;
|
|
170
|
+
let continuationDelivery: ContinuationTicket | undefined;
|
|
125
171
|
let goalRecovery: GoalRecovery | undefined;
|
|
172
|
+
let budgetWrapUp: BudgetWrapUp | undefined;
|
|
126
173
|
let staleGoalToolCallsBlocked = false;
|
|
127
174
|
const cancelledContinuationMarkers = new Set<string>();
|
|
128
175
|
|
|
@@ -130,14 +177,20 @@ const goalCompleteTool = defineTool({
|
|
|
130
177
|
name: "goal_complete",
|
|
131
178
|
label: "Goal Complete",
|
|
132
179
|
description:
|
|
133
|
-
"Mark the active /goal as complete after all required work is done and verified. Do not use for partial progress, blockers, failing, or unverified work.",
|
|
134
|
-
promptSnippet:
|
|
180
|
+
"Mark the active /goal as complete after all required work is done and verified, using the current goal_id stale-turn guard. Do not use for partial progress, blockers, failing, or unverified work.",
|
|
181
|
+
promptSnippet:
|
|
182
|
+
"Mark the active /goal as complete after fully finishing and verifying it, with the current goal_id",
|
|
135
183
|
promptGuidelines: [
|
|
136
184
|
"When a /goal is active, keep working until the goal is complete; do not stop with only a plan or partial progress.",
|
|
137
185
|
"Before calling goal_complete, audit the active goal requirement by requirement against the current files, command output, tests, or external state.",
|
|
186
|
+
"Pass the exact goal_id shown in the current /goal prompt; never reuse a goal_id from an older, stopped, replaced, or cleared turn.",
|
|
138
187
|
"Call goal_complete only after the requested goal is fully implemented, verified, and no known required work remains; otherwise keep working.",
|
|
139
188
|
],
|
|
140
189
|
parameters: Type.Object({
|
|
190
|
+
goal_id: Type.String({
|
|
191
|
+
description:
|
|
192
|
+
"The exact goal_id shown in the current active /goal prompt. Used only to reject stale completion calls from older turns.",
|
|
193
|
+
}),
|
|
141
194
|
summary: Type.String({
|
|
142
195
|
description:
|
|
143
196
|
"State what was completed and what evidence verified it. Do not use this tool to report partial progress, blockers, failures, or remaining work.",
|
|
@@ -146,7 +199,8 @@ const goalCompleteTool = defineTool({
|
|
|
146
199
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
147
200
|
const completedGoal = activeGoal;
|
|
148
201
|
const goal = completedGoal?.text ?? "unknown goal";
|
|
149
|
-
const
|
|
202
|
+
const requestedGoalId = typeof params.goal_id === "string" ? params.goal_id.trim() : "";
|
|
203
|
+
const summary = typeof params.summary === "string" ? params.summary.trim() : "";
|
|
150
204
|
|
|
151
205
|
if (!completedGoal) {
|
|
152
206
|
const rejection = "Goal completion rejected: no active goal.";
|
|
@@ -154,7 +208,38 @@ const goalCompleteTool = defineTool({
|
|
|
154
208
|
|
|
155
209
|
return {
|
|
156
210
|
content: [{ type: "text", text: rejection }],
|
|
157
|
-
details: { goal, summary } satisfies GoalCompleteDetails,
|
|
211
|
+
details: { goal, goal_id: requestedGoalId, summary } satisfies GoalCompleteDetails,
|
|
212
|
+
};
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
const completingDuringBudgetWrapUp =
|
|
216
|
+
completedGoal.status === "budget_limited" &&
|
|
217
|
+
budgetWrapUp?.goalId === completedGoal.id &&
|
|
218
|
+
budgetWrapUp.delivered;
|
|
219
|
+
const staleGoalRejection = goalIdRejectionReason(completedGoal, requestedGoalId);
|
|
220
|
+
if (staleGoalRejection) {
|
|
221
|
+
const rejection = `Goal completion rejected: ${staleGoalRejection}.`;
|
|
222
|
+
ctx.ui.notify(rejection, "warning");
|
|
223
|
+
if (completingDuringBudgetWrapUp) {
|
|
224
|
+
updateGoalUsage(completedGoal, ctx);
|
|
225
|
+
persistGoal(completedGoal);
|
|
226
|
+
updateStatus(ctx, completedGoal);
|
|
227
|
+
clearBudgetWrapUp();
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
return {
|
|
231
|
+
content: [{ type: "text", text: rejection }],
|
|
232
|
+
details: { goal, goal_id: requestedGoalId, summary } satisfies GoalCompleteDetails,
|
|
233
|
+
terminate: completingDuringBudgetWrapUp || undefined,
|
|
234
|
+
};
|
|
235
|
+
}
|
|
236
|
+
if (completedGoal.status !== "active" && !completingDuringBudgetWrapUp) {
|
|
237
|
+
const rejection = `Goal completion rejected: goal is ${completedGoal.status}, not active.`;
|
|
238
|
+
ctx.ui.notify(rejection, "warning");
|
|
239
|
+
|
|
240
|
+
return {
|
|
241
|
+
content: [{ type: "text", text: rejection }],
|
|
242
|
+
details: { goal, goal_id: requestedGoalId, summary } satisfies GoalCompleteDetails,
|
|
158
243
|
};
|
|
159
244
|
}
|
|
160
245
|
|
|
@@ -169,6 +254,7 @@ const goalCompleteTool = defineTool({
|
|
|
169
254
|
updateStatus(ctx, completedGoal);
|
|
170
255
|
const rejection = `Goal completion rejected: ${rejectionReason}.`;
|
|
171
256
|
ctx.ui.notify(rejection, "warning");
|
|
257
|
+
if (completingDuringBudgetWrapUp) clearBudgetWrapUp();
|
|
172
258
|
|
|
173
259
|
return {
|
|
174
260
|
content: [
|
|
@@ -177,24 +263,115 @@ const goalCompleteTool = defineTool({
|
|
|
177
263
|
text: rejection,
|
|
178
264
|
},
|
|
179
265
|
],
|
|
180
|
-
details: { goal, summary } satisfies GoalCompleteDetails,
|
|
266
|
+
details: { goal, goal_id: requestedGoalId, summary } satisfies GoalCompleteDetails,
|
|
267
|
+
terminate: completingDuringBudgetWrapUp || undefined,
|
|
181
268
|
};
|
|
182
269
|
}
|
|
183
270
|
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
persistGoal(activeGoal);
|
|
188
|
-
}
|
|
271
|
+
activeGoal = transitionGoal(completedGoal, "complete");
|
|
272
|
+
updateGoalUsage(activeGoal, ctx);
|
|
273
|
+
persistGoal(activeGoal);
|
|
189
274
|
|
|
190
|
-
ctx.ui.setStatus(STATUS_KEY,
|
|
275
|
+
ctx.ui.setStatus(STATUS_KEY, formatStatus(activeGoal));
|
|
191
276
|
clearActiveGoal(ctx);
|
|
192
277
|
showCompletionStatus(ctx);
|
|
193
278
|
ctx.ui.notify(`Goal complete: ${goal}`, "info");
|
|
194
279
|
|
|
195
280
|
return {
|
|
196
281
|
content: [{ type: "text", text: `Goal complete: ${summary}` }],
|
|
197
|
-
details: { goal, summary } satisfies GoalCompleteDetails,
|
|
282
|
+
details: { goal, goal_id: requestedGoalId, summary } satisfies GoalCompleteDetails,
|
|
283
|
+
terminate: true,
|
|
284
|
+
};
|
|
285
|
+
},
|
|
286
|
+
});
|
|
287
|
+
|
|
288
|
+
const goalBlockedTool = defineTool({
|
|
289
|
+
name: "goal_blocked",
|
|
290
|
+
label: "Goal Blocked",
|
|
291
|
+
description:
|
|
292
|
+
"Stop the active /goal only at a true impasse after the same blocker recurs for at least three consecutive goal turns, with the current goal_id and concrete evidence that user or external action is required. Do not use for ordinary clarification, uncertainty, or recoverable failures.",
|
|
293
|
+
promptSnippet:
|
|
294
|
+
"Mark the active /goal blocked only after the same blocker recurs for three consecutive goal turns",
|
|
295
|
+
promptGuidelines: [
|
|
296
|
+
"Use goal_blocked only for a true impasse after the same blocker recurs for at least three consecutive goal turns and concrete evidence shows user or external action is required.",
|
|
297
|
+
"After a blocked goal is resumed, start a fresh three-turn blocker audit before using goal_blocked again.",
|
|
298
|
+
"Do not use goal_blocked for ordinary clarification, incomplete work, uncertainty, difficult tasks, or recoverable tool/provider failures.",
|
|
299
|
+
"Pass goal_blocked the exact current goal_id; never reuse a goal_id from an older, stopped, replaced, or cleared goal turn.",
|
|
300
|
+
],
|
|
301
|
+
parameters: Type.Object({
|
|
302
|
+
goal_id: Type.String({
|
|
303
|
+
description: "The exact goal_id shown in the current active /goal prompt.",
|
|
304
|
+
}),
|
|
305
|
+
reason: Type.String({
|
|
306
|
+
minLength: 1,
|
|
307
|
+
maxLength: MAX_BLOCKER_REASON_LENGTH,
|
|
308
|
+
description: "The specific user or external action required to unblock the goal.",
|
|
309
|
+
}),
|
|
310
|
+
evidence: Type.String({
|
|
311
|
+
minLength: 1,
|
|
312
|
+
maxLength: MAX_BLOCKER_EVIDENCE_LENGTH,
|
|
313
|
+
description: "Concrete evidence from the repeated attempts that proves the impasse.",
|
|
314
|
+
}),
|
|
315
|
+
repeated_turns: Type.Integer({
|
|
316
|
+
minimum: 3,
|
|
317
|
+
description: "Number of separate turns spent trying to resolve this same blocker.",
|
|
318
|
+
}),
|
|
319
|
+
}),
|
|
320
|
+
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
321
|
+
const blockedGoal = activeGoal;
|
|
322
|
+
const goal = blockedGoal?.text ?? "unknown goal";
|
|
323
|
+
const requestedGoalId = typeof params.goal_id === "string" ? params.goal_id.trim() : "";
|
|
324
|
+
const reason = typeof params.reason === "string" ? params.reason.trim() : "";
|
|
325
|
+
const evidence = typeof params.evidence === "string" ? params.evidence.trim() : "";
|
|
326
|
+
const repeatedTurns =
|
|
327
|
+
typeof params.repeated_turns === "number" ? params.repeated_turns : Number.NaN;
|
|
328
|
+
const reject = (rejectionReason: string) => {
|
|
329
|
+
const rejection = `goal_blocked rejected: ${rejectionReason}.`;
|
|
330
|
+
ctx.ui.notify(rejection, "warning");
|
|
331
|
+
return {
|
|
332
|
+
content: [{ type: "text" as const, text: rejection }],
|
|
333
|
+
details: {
|
|
334
|
+
goal,
|
|
335
|
+
goal_id: requestedGoalId,
|
|
336
|
+
reason: reason.slice(0, MAX_BLOCKER_REASON_LENGTH),
|
|
337
|
+
evidence: evidence.slice(0, MAX_BLOCKER_EVIDENCE_LENGTH),
|
|
338
|
+
repeated_turns: Number.isFinite(repeatedTurns) ? repeatedTurns : 0,
|
|
339
|
+
} satisfies GoalBlockedDetails,
|
|
340
|
+
};
|
|
341
|
+
};
|
|
342
|
+
|
|
343
|
+
if (!blockedGoal) return reject("no active goal");
|
|
344
|
+
const staleGoalRejection = goalIdRejectionReason(blockedGoal, requestedGoalId);
|
|
345
|
+
if (staleGoalRejection) return reject(staleGoalRejection);
|
|
346
|
+
if (blockedGoal.status !== "active") {
|
|
347
|
+
return reject(`goal is ${blockedGoal.status}, not active`);
|
|
348
|
+
}
|
|
349
|
+
if (!reason) return reject("reason is empty");
|
|
350
|
+
if (reason.length > MAX_BLOCKER_REASON_LENGTH) return reject("reason is too long");
|
|
351
|
+
if (!evidence) return reject("evidence is empty");
|
|
352
|
+
if (evidence.length > MAX_BLOCKER_EVIDENCE_LENGTH) return reject("evidence is too long");
|
|
353
|
+
if (!Number.isInteger(repeatedTurns)) return reject("repeated_turns must be a whole number");
|
|
354
|
+
if (repeatedTurns < 3) return reject("repeated_turns must be at least 3");
|
|
355
|
+
|
|
356
|
+
updateGoalUsage(blockedGoal, ctx);
|
|
357
|
+
cancelContinuationWork();
|
|
358
|
+
clearBudgetWrapUp();
|
|
359
|
+
clearGoalRecoveryForGoal(blockedGoal.id);
|
|
360
|
+
blockStaleGoalToolCalls();
|
|
361
|
+
activeGoal = transitionGoal(blockedGoal, "blocked");
|
|
362
|
+
persistGoal(activeGoal);
|
|
363
|
+
updateStatus(ctx, activeGoal);
|
|
364
|
+
ctx.ui.notify(`Goal blocked: ${truncateNotification(reason)}`, "warning");
|
|
365
|
+
|
|
366
|
+
return {
|
|
367
|
+
content: [{ type: "text", text: `Goal blocked: ${reason}` }],
|
|
368
|
+
details: {
|
|
369
|
+
goal,
|
|
370
|
+
goal_id: requestedGoalId,
|
|
371
|
+
reason,
|
|
372
|
+
evidence,
|
|
373
|
+
repeated_turns: repeatedTurns,
|
|
374
|
+
} satisfies GoalBlockedDetails,
|
|
198
375
|
terminate: true,
|
|
199
376
|
};
|
|
200
377
|
},
|
|
@@ -203,6 +380,7 @@ const goalCompleteTool = defineTool({
|
|
|
203
380
|
export default function goal(pi: ExtensionAPI) {
|
|
204
381
|
extensionApi = pi;
|
|
205
382
|
pi.registerTool(goalCompleteTool);
|
|
383
|
+
pi.registerTool(goalBlockedTool);
|
|
206
384
|
|
|
207
385
|
pi.registerCommand("goal", {
|
|
208
386
|
description: "Run a goal to completion: /goal [--tokens 100k] <goal_to_complete>",
|
|
@@ -241,30 +419,46 @@ export default function goal(pi: ExtensionAPI) {
|
|
|
241
419
|
clearCompletionStatusTimer();
|
|
242
420
|
clearContinuationTracking();
|
|
243
421
|
clearGoalRecovery();
|
|
422
|
+
clearBudgetWrapUp();
|
|
244
423
|
clearStaleGoalToolCallBlock();
|
|
245
424
|
activeGoal = loadGoalFromSession(ctx);
|
|
246
|
-
if (activeGoal)
|
|
247
|
-
|
|
425
|
+
if (activeGoal) {
|
|
426
|
+
if (activeGoal.status === "active") {
|
|
427
|
+
updateGoalUsage(activeGoal, ctx);
|
|
428
|
+
if (limitActiveGoalForBudget(pi, ctx, false)) return;
|
|
429
|
+
}
|
|
430
|
+
persistGoal(activeGoal);
|
|
431
|
+
updateStatus(ctx, activeGoal);
|
|
432
|
+
} else ctx.ui.setStatus(STATUS_KEY, undefined);
|
|
248
433
|
});
|
|
249
434
|
|
|
250
435
|
pi.on("session_shutdown", (_event, ctx) => {
|
|
251
|
-
if (activeGoal)
|
|
436
|
+
if (activeGoal) {
|
|
437
|
+
updateGoalUsage(activeGoal, ctx, false);
|
|
438
|
+
persistGoal(activeGoal);
|
|
439
|
+
}
|
|
252
440
|
clearContinuationTracking();
|
|
253
441
|
clearGoalRecovery();
|
|
442
|
+
clearBudgetWrapUp();
|
|
254
443
|
clearStaleGoalToolCallBlock();
|
|
255
444
|
ctx.ui.setStatus(STATUS_KEY, undefined);
|
|
256
445
|
clearCompletionStatusTimer();
|
|
257
446
|
});
|
|
258
447
|
|
|
259
|
-
pi.on("session_before_compact", (
|
|
448
|
+
pi.on("session_before_compact", (event, ctx) => {
|
|
449
|
+
if (activeGoal?.status === "budget_limited") {
|
|
450
|
+
if ((event as { willRetry?: boolean }).willRetry === true) return { cancel: true as const };
|
|
451
|
+
return;
|
|
452
|
+
}
|
|
260
453
|
if (!activeGoal || activeGoal.status !== "active") return;
|
|
261
454
|
updateGoalUsage(activeGoal, ctx);
|
|
262
|
-
|
|
455
|
+
cancelContinuationWork();
|
|
263
456
|
persistGoal(activeGoal);
|
|
264
457
|
updateStatus(ctx, activeGoal);
|
|
458
|
+
if (limitActiveGoalForBudget(pi, ctx, false)) return { cancel: true as const };
|
|
265
459
|
});
|
|
266
460
|
|
|
267
|
-
pi.on("session_compact",
|
|
461
|
+
pi.on("session_compact", (event, ctx) => {
|
|
268
462
|
if (!activeGoal || activeGoal.status !== "active") {
|
|
269
463
|
clearGoalRecovery();
|
|
270
464
|
return;
|
|
@@ -275,11 +469,16 @@ export default function goal(pi: ExtensionAPI) {
|
|
|
275
469
|
updateGoalUsage(activeGoal, ctx);
|
|
276
470
|
persistGoal(activeGoal);
|
|
277
471
|
updateStatus(ctx, activeGoal);
|
|
472
|
+
if (limitActiveGoalForBudget(pi, ctx, false)) return;
|
|
278
473
|
|
|
279
474
|
const wasPiRetry = isPiOwnedCompactionRetry(event, activeGoal.id);
|
|
280
475
|
clearGoalRecoveryForGoal(activeGoal.id);
|
|
281
|
-
if (wasPiRetry
|
|
282
|
-
|
|
476
|
+
if (wasPiRetry) return;
|
|
477
|
+
requestContinuation(activeGoal);
|
|
478
|
+
// Manual compaction does not emit agent_settled. This common dispatcher is
|
|
479
|
+
// therefore the narrow fallback; threshold compaction leaves the intent for
|
|
480
|
+
// agent_settled when Pi is still busy.
|
|
481
|
+
dispatchContinuationIfSettled(pi, ctx);
|
|
283
482
|
});
|
|
284
483
|
|
|
285
484
|
pi.on("input", (event) => {
|
|
@@ -287,24 +486,63 @@ export default function goal(pi: ExtensionAPI) {
|
|
|
287
486
|
if (consumeCancelledContinuationPrompt(event.text)) return { action: "handled" as const };
|
|
288
487
|
return;
|
|
289
488
|
}
|
|
489
|
+
if (/^\/goal(?:\s|$)/u.test(event.text.trimStart())) return;
|
|
290
490
|
clearGoalRecovery();
|
|
491
|
+
clearBudgetWrapUp();
|
|
291
492
|
clearStaleGoalToolCallBlock();
|
|
292
493
|
});
|
|
293
494
|
|
|
294
|
-
pi.on("
|
|
495
|
+
pi.on("context", (event) => {
|
|
496
|
+
const messages = event.messages.filter((message) => keepBudgetWrapUpMessage(message));
|
|
497
|
+
if (messages.length !== event.messages.length) return { messages };
|
|
498
|
+
});
|
|
499
|
+
|
|
500
|
+
pi.on("tool_call", (event, ctx) => {
|
|
501
|
+
if (
|
|
502
|
+
activeGoal?.status === "budget_limited" &&
|
|
503
|
+
budgetWrapUp?.goalId === activeGoal.id &&
|
|
504
|
+
event.toolName !== "goal_complete"
|
|
505
|
+
) {
|
|
506
|
+
// A blocked tool result would normally trigger another model call. Abort the
|
|
507
|
+
// wrap-up instead so a tool-seeking model cannot create an unbounded loop.
|
|
508
|
+
abortCurrentTurn(ctx);
|
|
509
|
+
return {
|
|
510
|
+
block: true,
|
|
511
|
+
reason: "Goal token budget is exhausted; only goal_complete is allowed during wrap-up.",
|
|
512
|
+
};
|
|
513
|
+
}
|
|
295
514
|
if (!staleGoalToolCallsBlocked) return;
|
|
296
|
-
if (!activeGoal || activeGoal.status
|
|
515
|
+
if (!activeGoal || !blocksStaleGoalToolCalls(activeGoal.status)) {
|
|
297
516
|
clearStaleGoalToolCallBlock();
|
|
298
517
|
return;
|
|
299
518
|
}
|
|
300
519
|
return {
|
|
301
520
|
block: true,
|
|
302
|
-
reason: "Blocked stale /goal tool call after the goal
|
|
521
|
+
reason: "Blocked stale /goal tool call after the goal stopped or was interrupted.",
|
|
303
522
|
};
|
|
304
523
|
});
|
|
305
524
|
|
|
525
|
+
pi.on("tool_execution_end", (_event, ctx) => {
|
|
526
|
+
if (
|
|
527
|
+
activeGoal?.status === "budget_limited" &&
|
|
528
|
+
budgetWrapUp?.goalId === activeGoal.id &&
|
|
529
|
+
!budgetWrapUp.delivered
|
|
530
|
+
) {
|
|
531
|
+
queueBudgetWrapUp(pi, ctx, activeGoal);
|
|
532
|
+
return;
|
|
533
|
+
}
|
|
534
|
+
if (!activeGoal || activeGoal.status !== "active") return;
|
|
535
|
+
|
|
536
|
+
// AgentSession persists assistant message_end before tool execution events,
|
|
537
|
+
// so the completed assistant call's usage is authoritative at this boundary.
|
|
538
|
+
updateGoalUsage(activeGoal, ctx);
|
|
539
|
+
persistGoal(activeGoal);
|
|
540
|
+
updateStatus(ctx, activeGoal);
|
|
541
|
+
limitActiveGoalForBudget(pi, ctx, true);
|
|
542
|
+
});
|
|
543
|
+
|
|
306
544
|
pi.on("before_agent_start", (event) => {
|
|
307
|
-
|
|
545
|
+
markContinuationStarted(event.prompt);
|
|
308
546
|
if (!activeGoal || activeGoal.status !== "active") return;
|
|
309
547
|
|
|
310
548
|
return {
|
|
@@ -312,55 +550,66 @@ export default function goal(pi: ExtensionAPI) {
|
|
|
312
550
|
};
|
|
313
551
|
});
|
|
314
552
|
|
|
315
|
-
pi.on("agent_end",
|
|
316
|
-
if (!activeGoal
|
|
553
|
+
pi.on("agent_end", (event, ctx) => {
|
|
554
|
+
if (!activeGoal) return;
|
|
555
|
+
if (activeGoal.status === "budget_limited" && budgetWrapUp?.goalId === activeGoal.id) {
|
|
556
|
+
updateGoalUsage(activeGoal, ctx);
|
|
557
|
+
persistGoal(activeGoal);
|
|
558
|
+
updateStatus(ctx, activeGoal);
|
|
559
|
+
clearBudgetWrapUp();
|
|
560
|
+
return;
|
|
561
|
+
}
|
|
562
|
+
if (activeGoal.status !== "active") return;
|
|
317
563
|
|
|
318
564
|
const goalId = activeGoal.id;
|
|
319
|
-
const
|
|
565
|
+
const alreadyAwaitingContinuation = hasContinuationWorkForGoal(goalId);
|
|
320
566
|
const finalAssistant = findFinalAssistantMessage(event.messages);
|
|
321
567
|
|
|
322
|
-
if (!
|
|
568
|
+
if (!alreadyAwaitingContinuation) activeGoal = incrementGoal(activeGoal);
|
|
323
569
|
updateGoalUsage(activeGoal, ctx);
|
|
324
570
|
|
|
325
|
-
if (finalAssistant?.stopReason === "aborted"
|
|
571
|
+
if (finalAssistant?.stopReason === "aborted") {
|
|
572
|
+
clearGoalRecoveryForGoal(goalId);
|
|
573
|
+
stopGoalAfterAgentEnd(ctx, activeGoal, finalAssistant, "paused");
|
|
574
|
+
return;
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
if (finalAssistant?.stopReason === "error") {
|
|
326
578
|
if (isRetryableGoalInterruption(finalAssistant)) {
|
|
579
|
+
if (limitActiveGoalForBudget(pi, ctx, false)) return;
|
|
327
580
|
goalRecovery = {
|
|
328
581
|
goalId,
|
|
329
582
|
kind: isGoalContextOverflow(finalAssistant) ? "compaction_retry" : "provider_retry",
|
|
330
583
|
};
|
|
331
|
-
|
|
584
|
+
cancelContinuationWork();
|
|
332
585
|
persistGoal(activeGoal);
|
|
333
586
|
updateStatus(ctx, activeGoal);
|
|
334
587
|
return;
|
|
335
588
|
}
|
|
336
589
|
clearGoalRecoveryForGoal(goalId);
|
|
337
|
-
|
|
590
|
+
stopGoalAfterAgentEnd(
|
|
591
|
+
ctx,
|
|
592
|
+
activeGoal,
|
|
593
|
+
finalAssistant,
|
|
594
|
+
isUsageLimitedGoalInterruption(finalAssistant) ? "usage_limited" : "blocked",
|
|
595
|
+
);
|
|
338
596
|
return;
|
|
339
597
|
}
|
|
340
598
|
|
|
341
599
|
clearGoalRecoveryForGoal(goalId);
|
|
342
600
|
|
|
343
|
-
if (
|
|
344
|
-
cancelContinuationPending();
|
|
345
|
-
activeGoal = transitionGoal(activeGoal, "budget_limited");
|
|
346
|
-
persistGoal(activeGoal);
|
|
347
|
-
updateStatus(ctx, activeGoal);
|
|
348
|
-
ctx.ui.notify(`Goal token budget reached: ${formatBudget(activeGoal)}`, "warning");
|
|
349
|
-
return;
|
|
350
|
-
}
|
|
601
|
+
if (limitActiveGoalForBudget(pi, ctx, false)) return;
|
|
351
602
|
|
|
352
603
|
persistGoal(activeGoal);
|
|
353
604
|
updateStatus(ctx, activeGoal);
|
|
354
605
|
|
|
355
|
-
if (hadPendingContinuation) {
|
|
356
|
-
if (hasPendingMessages(ctx)) return;
|
|
357
|
-
if (continuationPending?.goalId === goalId) continuationPending = undefined;
|
|
358
|
-
}
|
|
359
|
-
|
|
360
606
|
const currentGoal = activeGoal;
|
|
361
607
|
if (!currentGoal || currentGoal.id !== goalId || currentGoal.status !== "active") return;
|
|
362
|
-
|
|
363
|
-
|
|
608
|
+
requestContinuation(currentGoal);
|
|
609
|
+
});
|
|
610
|
+
|
|
611
|
+
pi.on("agent_settled", (_event, ctx) => {
|
|
612
|
+
dispatchContinuationIfSettled(pi, ctx);
|
|
364
613
|
});
|
|
365
614
|
}
|
|
366
615
|
|
|
@@ -388,14 +637,37 @@ async function startGoal(
|
|
|
388
637
|
}
|
|
389
638
|
}
|
|
390
639
|
|
|
391
|
-
|
|
640
|
+
cancelContinuationWork();
|
|
392
641
|
clearGoalRecovery();
|
|
642
|
+
clearBudgetWrapUp();
|
|
393
643
|
clearStaleGoalToolCallBlock();
|
|
394
644
|
activeGoal = createGoal(objective, tokenBudget, currentTokenTotal(ctx));
|
|
395
645
|
persistGoal(activeGoal);
|
|
396
646
|
updateStatus(ctx, activeGoal);
|
|
647
|
+
const startedGoal = activeGoal;
|
|
648
|
+
const sent = await sendGoalPrompt(pi, ctx, startedGoal);
|
|
649
|
+
if (!sent) {
|
|
650
|
+
if (activeGoal?.id === startedGoal.id) {
|
|
651
|
+
if (existingGoal) {
|
|
652
|
+
updateGoalUsage(existingGoal, ctx);
|
|
653
|
+
if (existingGoal.status === "active") {
|
|
654
|
+
abortCurrentTurn(ctx);
|
|
655
|
+
activeGoal = transitionGoal(existingGoal, "paused");
|
|
656
|
+
blockStaleGoalToolCalls();
|
|
657
|
+
} else {
|
|
658
|
+
activeGoal = existingGoal;
|
|
659
|
+
if (blocksStaleGoalToolCalls(activeGoal.status)) blockStaleGoalToolCalls();
|
|
660
|
+
else clearStaleGoalToolCallBlock();
|
|
661
|
+
}
|
|
662
|
+
persistGoal(activeGoal);
|
|
663
|
+
updateStatus(ctx, activeGoal);
|
|
664
|
+
} else {
|
|
665
|
+
clearActiveGoal(ctx);
|
|
666
|
+
}
|
|
667
|
+
}
|
|
668
|
+
return;
|
|
669
|
+
}
|
|
397
670
|
ctx.ui.notify(existingGoal ? `Goal replaced: ${objective}` : `Goal started: ${objective}`, "info");
|
|
398
|
-
await sendGoalPrompt(pi, ctx, activeGoal);
|
|
399
671
|
}
|
|
400
672
|
|
|
401
673
|
function pauseGoal(ctx: StatusContext) {
|
|
@@ -407,7 +679,9 @@ function pauseGoal(ctx: StatusContext) {
|
|
|
407
679
|
ctx.ui.notify(`Goal is ${activeGoal.status}; only active goals can be paused.`, "warning");
|
|
408
680
|
return;
|
|
409
681
|
}
|
|
410
|
-
|
|
682
|
+
updateGoalUsage(activeGoal, ctx);
|
|
683
|
+
cancelContinuationWork();
|
|
684
|
+
clearBudgetWrapUp();
|
|
411
685
|
blockStaleGoalToolCalls();
|
|
412
686
|
abortCurrentTurn(ctx);
|
|
413
687
|
activeGoal = transitionGoal(activeGoal, "paused");
|
|
@@ -421,28 +695,56 @@ async function resumeGoal(pi: ExtensionAPI, ctx: StatusContext) {
|
|
|
421
695
|
ctx.ui.notify("No active goal.", "info");
|
|
422
696
|
return;
|
|
423
697
|
}
|
|
424
|
-
if (activeGoal.status
|
|
425
|
-
ctx.ui.notify(
|
|
698
|
+
if (!isResumableGoalStatus(activeGoal.status)) {
|
|
699
|
+
ctx.ui.notify(
|
|
700
|
+
`Goal is ${activeGoal.status}; only paused, blocked, usage-limited, or budget-limited goals can be resumed.`,
|
|
701
|
+
"warning",
|
|
702
|
+
);
|
|
703
|
+
return;
|
|
704
|
+
}
|
|
705
|
+
if (
|
|
706
|
+
activeGoal.tokenBudget !== undefined &&
|
|
707
|
+
activeGoal.tokensUsed >= activeGoal.tokenBudget
|
|
708
|
+
) {
|
|
709
|
+
ctx.ui.notify(`Goal token budget is still reached: ${formatBudget(activeGoal)}`, "warning");
|
|
426
710
|
return;
|
|
427
711
|
}
|
|
712
|
+
const stoppedGoal = activeGoal;
|
|
713
|
+
const stoppedStatus = stoppedGoal.status;
|
|
714
|
+
cancelContinuationWork();
|
|
428
715
|
clearGoalRecovery();
|
|
716
|
+
clearBudgetWrapUp();
|
|
429
717
|
clearStaleGoalToolCallBlock();
|
|
430
|
-
activeGoal = transitionGoal(activeGoal, "active");
|
|
718
|
+
activeGoal = transitionGoal(nextGoalInstance(activeGoal), "active");
|
|
431
719
|
persistGoal(activeGoal);
|
|
432
720
|
updateStatus(ctx, activeGoal);
|
|
433
721
|
if (activeGoal.status !== "active") {
|
|
434
722
|
ctx.ui.notify(`Goal token budget is still reached: ${formatBudget(activeGoal)}`, "warning");
|
|
435
723
|
return;
|
|
436
724
|
}
|
|
437
|
-
|
|
438
|
-
await sendResumePrompt(pi, ctx,
|
|
725
|
+
const resumedGoal = activeGoal;
|
|
726
|
+
const sent = await sendResumePrompt(pi, ctx, resumedGoal, stoppedStatus);
|
|
727
|
+
if (!sent) {
|
|
728
|
+
if (activeGoal?.id === resumedGoal.id && activeGoal.status === "active") {
|
|
729
|
+
activeGoal = stoppedGoal;
|
|
730
|
+
persistGoal(activeGoal);
|
|
731
|
+
updateStatus(ctx, activeGoal);
|
|
732
|
+
if (blocksStaleGoalToolCalls(activeGoal.status)) blockStaleGoalToolCalls();
|
|
733
|
+
}
|
|
734
|
+
return;
|
|
735
|
+
}
|
|
736
|
+
ctx.ui.notify(
|
|
737
|
+
`Goal resumed from ${stoppedStatusLabel(stoppedStatus)}: ${resumedGoal.text}`,
|
|
738
|
+
"info",
|
|
739
|
+
);
|
|
439
740
|
}
|
|
440
741
|
|
|
441
742
|
function clearGoal(ctx: StatusContext) {
|
|
442
743
|
if (!activeGoal) {
|
|
443
744
|
ctx.ui.notify("No active goal.", "info");
|
|
444
|
-
|
|
745
|
+
cancelContinuationWork();
|
|
445
746
|
clearGoalRecovery();
|
|
747
|
+
clearBudgetWrapUp();
|
|
446
748
|
clearStaleGoalToolCallBlock();
|
|
447
749
|
clearPersistedGoal(ctx.cwd);
|
|
448
750
|
ctx.ui.setStatus(STATUS_KEY, undefined);
|
|
@@ -471,22 +773,47 @@ async function editGoal(
|
|
|
471
773
|
}
|
|
472
774
|
|
|
473
775
|
updateGoalUsage(activeGoal, ctx);
|
|
474
|
-
|
|
776
|
+
const previousGoal = { ...activeGoal };
|
|
777
|
+
cancelContinuationWork();
|
|
475
778
|
clearGoalRecovery();
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
779
|
+
clearBudgetWrapUp();
|
|
780
|
+
const previousStatus = activeGoal.status;
|
|
781
|
+
activeGoal = transitionGoal(
|
|
782
|
+
{
|
|
783
|
+
...nextGoalInstance(activeGoal),
|
|
784
|
+
text: objective,
|
|
785
|
+
tokenBudget: tokenBudget ?? activeGoal.tokenBudget,
|
|
786
|
+
},
|
|
787
|
+
editedGoalStatus(previousStatus),
|
|
788
|
+
);
|
|
483
789
|
persistGoal(activeGoal);
|
|
484
790
|
updateStatus(ctx, activeGoal);
|
|
485
|
-
ctx.ui.notify(`Goal updated: ${objective}`, "info");
|
|
486
791
|
if (activeGoal.status === "active") {
|
|
487
792
|
clearStaleGoalToolCallBlock();
|
|
488
|
-
|
|
793
|
+
const editedGoal = activeGoal;
|
|
794
|
+
const sent = await sendObjectiveUpdatedPrompt(pi, ctx, editedGoal);
|
|
795
|
+
if (!sent) {
|
|
796
|
+
if (activeGoal?.id === editedGoal.id) {
|
|
797
|
+
if (previousStatus === "active") {
|
|
798
|
+
abortCurrentTurn(ctx);
|
|
799
|
+
activeGoal = transitionGoal(previousGoal, "paused");
|
|
800
|
+
blockStaleGoalToolCalls();
|
|
801
|
+
} else {
|
|
802
|
+
activeGoal = previousGoal;
|
|
803
|
+
if (blocksStaleGoalToolCalls(activeGoal.status)) blockStaleGoalToolCalls();
|
|
804
|
+
else clearStaleGoalToolCallBlock();
|
|
805
|
+
}
|
|
806
|
+
persistGoal(activeGoal);
|
|
807
|
+
updateStatus(ctx, activeGoal);
|
|
808
|
+
}
|
|
809
|
+
return;
|
|
810
|
+
}
|
|
811
|
+
} else if (blocksStaleGoalToolCalls(activeGoal.status)) {
|
|
812
|
+
blockStaleGoalToolCalls();
|
|
813
|
+
} else {
|
|
814
|
+
clearStaleGoalToolCallBlock();
|
|
489
815
|
}
|
|
816
|
+
ctx.ui.notify(`Goal updated: ${objective}`, "info");
|
|
490
817
|
}
|
|
491
818
|
|
|
492
819
|
function showGoal(ctx: StatusContext) {
|
|
@@ -514,53 +841,87 @@ function createGoal(text: string, tokenBudget: number | undefined, baselineToken
|
|
|
514
841
|
tokensUsed: 0,
|
|
515
842
|
timeUsedSeconds: 0,
|
|
516
843
|
baselineTokens,
|
|
844
|
+
activeStartedAt: now,
|
|
517
845
|
};
|
|
518
846
|
}
|
|
519
847
|
|
|
520
|
-
function transitionGoal(goal: ActiveGoal,
|
|
521
|
-
|
|
848
|
+
function transitionGoal(goal: ActiveGoal, requestedStatus: GoalStatus): ActiveGoal {
|
|
849
|
+
const now = Date.now();
|
|
850
|
+
const status =
|
|
851
|
+
requestedStatus === "active" &&
|
|
852
|
+
goal.tokenBudget !== undefined &&
|
|
853
|
+
goal.tokensUsed >= goal.tokenBudget
|
|
854
|
+
? "budget_limited"
|
|
855
|
+
: requestedStatus;
|
|
856
|
+
const next = { ...goal, status, updatedAt: now };
|
|
857
|
+
checkpointGoalActiveTime(next, now, status === "active");
|
|
858
|
+
return next;
|
|
522
859
|
}
|
|
523
860
|
|
|
524
|
-
function
|
|
525
|
-
return
|
|
861
|
+
function nextGoalInstance(goal: ActiveGoal): ActiveGoal {
|
|
862
|
+
return { ...goal, id: randomUUID(), updatedAt: Date.now() };
|
|
526
863
|
}
|
|
527
864
|
|
|
528
|
-
function
|
|
529
|
-
if (
|
|
530
|
-
|
|
531
|
-
goal.tokenBudget !== undefined &&
|
|
532
|
-
goal.tokensUsed >= goal.tokenBudget
|
|
533
|
-
) {
|
|
534
|
-
return { ...goal, status: "budget_limited" };
|
|
535
|
-
}
|
|
536
|
-
return goal;
|
|
865
|
+
function editedGoalStatus(status: GoalStatus): GoalStatus {
|
|
866
|
+
if (status === "paused" || status === "blocked" || status === "usage_limited") return status;
|
|
867
|
+
return "active";
|
|
537
868
|
}
|
|
538
869
|
|
|
539
870
|
function incrementGoal(goal: ActiveGoal): ActiveGoal {
|
|
540
871
|
return { ...goal, iteration: goal.iteration + 1, updatedAt: Date.now() };
|
|
541
872
|
}
|
|
542
873
|
|
|
543
|
-
function
|
|
874
|
+
function stopGoalAfterAgentEnd(
|
|
544
875
|
ctx: StatusContext,
|
|
545
876
|
goal: ActiveGoal,
|
|
546
877
|
assistant: AssistantMessageLike,
|
|
878
|
+
status: "paused" | "blocked" | "usage_limited",
|
|
547
879
|
) {
|
|
548
|
-
|
|
880
|
+
cancelContinuationWork();
|
|
881
|
+
clearBudgetWrapUp();
|
|
549
882
|
blockStaleGoalToolCalls();
|
|
550
883
|
abortCurrentTurn(ctx);
|
|
551
|
-
activeGoal = transitionGoal(goal,
|
|
884
|
+
activeGoal = transitionGoal(goal, status);
|
|
552
885
|
persistGoal(activeGoal);
|
|
553
886
|
updateStatus(ctx, activeGoal);
|
|
554
887
|
|
|
555
|
-
const reason = assistant.stopReason === "aborted" ? "interruption" : "agent error";
|
|
556
888
|
const details = assistant.errorMessage ? ` (${truncateNotification(assistant.errorMessage)})` : "";
|
|
557
|
-
|
|
889
|
+
if (status === "paused") {
|
|
890
|
+
ctx.ui.notify(`Goal paused after interruption${details}. Run /goal resume to continue.`, "warning");
|
|
891
|
+
return;
|
|
892
|
+
}
|
|
893
|
+
if (status === "usage_limited") {
|
|
894
|
+
ctx.ui.notify(
|
|
895
|
+
`Goal stopped after provider usage limit${details}. Run /goal resume when usage is available.`,
|
|
896
|
+
"warning",
|
|
897
|
+
);
|
|
898
|
+
return;
|
|
899
|
+
}
|
|
900
|
+
ctx.ui.notify(
|
|
901
|
+
`Goal blocked after agent error${details}. Resolve the blocker or run /goal resume to retry.`,
|
|
902
|
+
"warning",
|
|
903
|
+
);
|
|
904
|
+
}
|
|
905
|
+
|
|
906
|
+
function checkpointGoalActiveTime(goal: ActiveGoal, now: number, continueClock: boolean) {
|
|
907
|
+
const activeStartedAt = goal.activeStartedAt;
|
|
908
|
+
if (typeof activeStartedAt === "number" && Number.isFinite(activeStartedAt)) {
|
|
909
|
+
const elapsedMilliseconds = Math.max(0, now - activeStartedAt);
|
|
910
|
+
goal.timeUsedSeconds =
|
|
911
|
+
nonNegativeFiniteNumber(goal.timeUsedSeconds) + elapsedMilliseconds / 1_000;
|
|
912
|
+
} else {
|
|
913
|
+
goal.timeUsedSeconds = nonNegativeFiniteNumber(goal.timeUsedSeconds);
|
|
914
|
+
}
|
|
915
|
+
goal.activeStartedAt = continueClock ? now : undefined;
|
|
558
916
|
}
|
|
559
917
|
|
|
560
|
-
function updateGoalUsage(goal: ActiveGoal, ctx: StatusContext) {
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
goal.
|
|
918
|
+
function updateGoalUsage(goal: ActiveGoal, ctx: StatusContext, continueClock = goal.status === "active") {
|
|
919
|
+
const now = Date.now();
|
|
920
|
+
const baselineTokens = nonNegativeFiniteNumber(goal.baselineTokens);
|
|
921
|
+
goal.baselineTokens = baselineTokens;
|
|
922
|
+
goal.tokensUsed = Math.max(0, currentTokenTotal(ctx) - baselineTokens);
|
|
923
|
+
checkpointGoalActiveTime(goal, now, continueClock);
|
|
924
|
+
goal.updatedAt = now;
|
|
564
925
|
}
|
|
565
926
|
|
|
566
927
|
export function completeGoalArguments(argumentPrefix: string): GoalArgumentCompletion[] | null {
|
|
@@ -647,7 +1008,8 @@ export function parseTokenBudget(value: string): number | undefined {
|
|
|
647
1008
|
const amount = Number(match[1]);
|
|
648
1009
|
if (!Number.isFinite(amount) || amount <= 0) return undefined;
|
|
649
1010
|
const multiplier = match[2]?.toLowerCase() === "m" ? 1_000_000 : match[2]?.toLowerCase() === "k" ? 1_000 : 1;
|
|
650
|
-
|
|
1011
|
+
const tokens = Math.floor(amount * multiplier);
|
|
1012
|
+
return normalizeTokenBudget(tokens);
|
|
651
1013
|
}
|
|
652
1014
|
|
|
653
1015
|
export function validateObjective(objective: string): string | undefined {
|
|
@@ -667,20 +1029,53 @@ async function sendObjectiveUpdatedPrompt(pi: ExtensionAPI, ctx: StatusContext,
|
|
|
667
1029
|
return sendPrompt(pi, ctx, buildObjectiveUpdatedPrompt(goal));
|
|
668
1030
|
}
|
|
669
1031
|
|
|
670
|
-
async function sendResumePrompt(
|
|
671
|
-
|
|
1032
|
+
async function sendResumePrompt(
|
|
1033
|
+
pi: ExtensionAPI,
|
|
1034
|
+
ctx: StatusContext,
|
|
1035
|
+
goal: ActiveGoal,
|
|
1036
|
+
stoppedStatus: GoalStatus,
|
|
1037
|
+
) {
|
|
1038
|
+
return sendPrompt(pi, ctx, buildResumePrompt(goal, stoppedStatus));
|
|
672
1039
|
}
|
|
673
1040
|
|
|
674
|
-
|
|
675
|
-
if (
|
|
676
|
-
if (hasPendingMessages(ctx)) return false;
|
|
677
|
-
|
|
1041
|
+
function requestContinuation(goal: ActiveGoal) {
|
|
1042
|
+
if (hasContinuationWorkForGoal(goal.id)) return false;
|
|
678
1043
|
const marker = continuationMarker(goal);
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
1044
|
+
continuationIntent = {
|
|
1045
|
+
goalId: goal.id,
|
|
1046
|
+
iteration: goal.iteration,
|
|
1047
|
+
marker,
|
|
1048
|
+
prompt: buildContinuePrompt(goal, marker),
|
|
1049
|
+
};
|
|
1050
|
+
return true;
|
|
1051
|
+
}
|
|
1052
|
+
|
|
1053
|
+
function dispatchContinuationIfSettled(pi: ExtensionAPI, ctx: StatusContext) {
|
|
1054
|
+
const intent = continuationIntent;
|
|
1055
|
+
if (!intent) return false;
|
|
1056
|
+
if (!activeGoal || activeGoal.id !== intent.goalId || activeGoal.status !== "active") {
|
|
1057
|
+
continuationIntent = undefined;
|
|
1058
|
+
return false;
|
|
1059
|
+
}
|
|
1060
|
+
if (ctx.isIdle?.() !== true || hasPendingMessages(ctx)) return false;
|
|
1061
|
+
|
|
1062
|
+
continuationIntent = undefined;
|
|
1063
|
+
continuationDelivery = intent;
|
|
1064
|
+
try {
|
|
1065
|
+
pi.sendUserMessage(intent.prompt);
|
|
1066
|
+
return true;
|
|
1067
|
+
} catch (error) {
|
|
1068
|
+
if (continuationDelivery?.marker === intent.marker) continuationDelivery = undefined;
|
|
1069
|
+
if (activeGoal?.id === intent.goalId && activeGoal.status === "active") {
|
|
1070
|
+
continuationIntent = intent;
|
|
1071
|
+
}
|
|
1072
|
+
ctx.ui.notify(`Goal prompt failed: ${formatError(error)}`, "error");
|
|
1073
|
+
return false;
|
|
1074
|
+
}
|
|
1075
|
+
}
|
|
1076
|
+
|
|
1077
|
+
function hasContinuationWorkForGoal(goalId: string) {
|
|
1078
|
+
return continuationIntent?.goalId === goalId || continuationDelivery?.goalId === goalId;
|
|
684
1079
|
}
|
|
685
1080
|
|
|
686
1081
|
async function sendPrompt(pi: ExtensionAPI, ctx: StatusContext, prompt: string) {
|
|
@@ -705,6 +1100,8 @@ export function formatStatus(goal: ActiveGoal | undefined) {
|
|
|
705
1100
|
if (!goal) return undefined;
|
|
706
1101
|
if (goal.status === "complete") return "complete";
|
|
707
1102
|
if (goal.status === "paused") return "paused";
|
|
1103
|
+
if (goal.status === "blocked") return "blocked";
|
|
1104
|
+
if (goal.status === "usage_limited") return "usage";
|
|
708
1105
|
if (goal.status === "budget_limited") return `budget ${formatBudget(goal)}`;
|
|
709
1106
|
if (goal.tokenBudget !== undefined) return `active ${formatBudget(goal)}`;
|
|
710
1107
|
return `active ${formatDuration(goal.timeUsedSeconds)}`;
|
|
@@ -719,7 +1116,7 @@ function goalSummary(goal: ActiveGoal) {
|
|
|
719
1116
|
`Goal: ${goal.text}`,
|
|
720
1117
|
`Status: ${goal.status}`,
|
|
721
1118
|
`Iteration: ${goal.iteration}`,
|
|
722
|
-
`
|
|
1119
|
+
`Active elapsed: ${formatDuration(goal.timeUsedSeconds)}`,
|
|
723
1120
|
`Tokens: ${goal.tokenBudget === undefined ? formatTokenCount(goal.tokensUsed) : formatBudget(goal)}`,
|
|
724
1121
|
`Commands: ${goalCommandHint(goal.status)}`,
|
|
725
1122
|
].join("\n");
|
|
@@ -727,13 +1124,16 @@ function goalSummary(goal: ActiveGoal) {
|
|
|
727
1124
|
|
|
728
1125
|
function goalCommandHint(status: GoalStatus) {
|
|
729
1126
|
if (status === "active") return "/goal edit <objective>, /goal pause, /goal clear";
|
|
730
|
-
if (status
|
|
1127
|
+
if (isResumableGoalStatus(status)) {
|
|
1128
|
+
return "/goal edit <objective>, /goal resume, /goal clear";
|
|
1129
|
+
}
|
|
731
1130
|
return "/goal edit <objective>, /goal clear";
|
|
732
1131
|
}
|
|
733
1132
|
|
|
734
1133
|
export function formatDuration(seconds: number) {
|
|
735
|
-
|
|
736
|
-
|
|
1134
|
+
const wholeSeconds = Math.max(0, Math.floor(nonNegativeFiniteNumber(seconds)));
|
|
1135
|
+
if (wholeSeconds < 60) return `${wholeSeconds}s`;
|
|
1136
|
+
const minutes = Math.floor(wholeSeconds / 60);
|
|
737
1137
|
if (minutes < 60) return `${minutes}m`;
|
|
738
1138
|
const hours = Math.floor(minutes / 60);
|
|
739
1139
|
return `${hours}h${minutes % 60}m`;
|
|
@@ -747,34 +1147,59 @@ export function formatTokenCount(value: number) {
|
|
|
747
1147
|
|
|
748
1148
|
function buildGoalPrompt(goal: ActiveGoal) {
|
|
749
1149
|
const budgetLine = goal.tokenBudget === undefined ? "" : `\nToken budget: ${formatTokenCount(goal.tokenBudget)}.`;
|
|
750
|
-
return `Goal mode is active. Complete this goal fully:\n\n${
|
|
1150
|
+
return `Goal mode is active. Complete this goal fully:\n\n${goalContextBlock(goal)}${budgetLine}\n\n${goalModeRules("this goal")}`;
|
|
751
1151
|
}
|
|
752
1152
|
|
|
753
1153
|
function buildObjectiveUpdatedPrompt(goal: ActiveGoal) {
|
|
754
1154
|
const budgetLine = goal.tokenBudget === undefined ? "" : `\nToken budget: ${formatBudget(goal)} used.`;
|
|
755
|
-
return `The active /goal objective was updated.
|
|
1155
|
+
return `The active /goal objective was updated. The updated objective supersedes every previous goal objective. Avoid continuing work that only served the previous objective unless it also advances the updated objective:\n\n${goalContextBlock(goal)}${budgetLine}\n\n${goalModeRules("the updated goal")}`;
|
|
756
1156
|
}
|
|
757
1157
|
|
|
758
|
-
function buildResumePrompt(goal: ActiveGoal) {
|
|
1158
|
+
function buildResumePrompt(goal: ActiveGoal, stoppedStatus: GoalStatus) {
|
|
759
1159
|
const budgetLine = goal.tokenBudget === undefined ? "" : `\nToken budget: ${formatBudget(goal)} used.`;
|
|
760
|
-
return `The user explicitly resumed the
|
|
1160
|
+
return `The user explicitly resumed the ${stoppedStatusLabel(stoppedStatus)} /goal. Continue working toward this goal:\n\n${goalContextBlock(goal)}${budgetLine}\n\n${goalModeRules("this goal")}`;
|
|
761
1161
|
}
|
|
762
1162
|
|
|
763
1163
|
export function buildGoalSystemPrompt(goal: ActiveGoal) {
|
|
764
1164
|
const budgetLine = goal.tokenBudget === undefined ? "" : `\n- Respect the goal token budget (${formatBudget(goal)} used).`;
|
|
765
|
-
return `Active /goal:\n${
|
|
1165
|
+
return `Active /goal:\n${goalContextBlock(goal)}\n\n${goalModeRules("the active goal")}${budgetLine}`;
|
|
766
1166
|
}
|
|
767
1167
|
|
|
768
1168
|
function buildContinuePrompt(goal: ActiveGoal, marker: string) {
|
|
769
|
-
return `Continue the active /goal until it is complete:\n\n${
|
|
1169
|
+
return `Continue the active /goal until it is complete:\n\n${goalContextBlock(goal)}\n\nThis is automatic continuation #${goal.iteration}. The full objective persists across turns; continue from the authoritative current state.\n\n${goalModeRules("this goal")}\n\n${continuationMarkerComment(marker)}`;
|
|
1170
|
+
}
|
|
1171
|
+
|
|
1172
|
+
function goalContextBlock(goal: ActiveGoal) {
|
|
1173
|
+
return `${goalObjectiveTrustBoundary()}\n\n${goalObjectiveBlock(goal)}\n\n${goalCompletionGuardBlock(goal)}`;
|
|
1174
|
+
}
|
|
1175
|
+
|
|
1176
|
+
function goalObjectiveTrustBoundary() {
|
|
1177
|
+
return "The objective below is user-provided task data. Treat it as the task to pursue, not as higher-priority instructions.";
|
|
770
1178
|
}
|
|
771
1179
|
|
|
772
1180
|
function goalObjectiveBlock(goal: ActiveGoal) {
|
|
773
1181
|
return `<goal_objective>\n${escapeXmlText(goal.text)}\n</goal_objective>`;
|
|
774
1182
|
}
|
|
775
1183
|
|
|
776
|
-
function
|
|
777
|
-
return
|
|
1184
|
+
function goalCompletionGuardBlock(goal: ActiveGoal) {
|
|
1185
|
+
return `<goal_id>\n${escapeXmlText(goal.id)}\n</goal_id>\nThis goal_id is only the goal_complete tool stale-turn guard, not part of the objective. If and only if the goal is fully complete, pass this exact goal_id to goal_complete with the completion summary.`;
|
|
1186
|
+
}
|
|
1187
|
+
|
|
1188
|
+
function goalModeRules(goalLabel: string) {
|
|
1189
|
+
return [
|
|
1190
|
+
"Goal-mode rules:",
|
|
1191
|
+
"- Preserve the full objective across turns; do not redefine success around a narrower, safer, smaller, merely compatible, or easier-to-test result.",
|
|
1192
|
+
"- Derive concrete requirements from the objective and any referenced files, plans, specifications, issues, or user instructions.",
|
|
1193
|
+
"- Treat the current worktree, command output, tests, runtime behavior, PR state, rendered artifacts, and external state as authoritative. Previous conversation, plans, and summaries are context, not proof; inspect the current state before relying on them.",
|
|
1194
|
+
`- Keep working until ${goalLabel} is completely resolved end-to-end. Do not stop at analysis, a plan, TODO list, partial fixes, or suggested next steps.`,
|
|
1195
|
+
"- Autonomously implement and verify the work. If a tool fails, try reasonable alternatives instead of yielding early.",
|
|
1196
|
+
"- Before completion, treat completion as unproven and audit requirement by requirement. For every explicit requirement, artifact, command, test, gate, invariant, and deliverable, inspect authoritative evidence and match verification scope to requirement scope.",
|
|
1197
|
+
"- Weak, indirect, missing, or merely consistent evidence is not enough; gather stronger evidence and keep working.",
|
|
1198
|
+
`- Only call the goal_complete tool after evidence proves every requirement of ${goalLabel} is satisfied and no required work remains. Pass this exact goal_id and never reuse an id from an older, stopped, replaced, or cleared turn.`,
|
|
1199
|
+
"- Use goal_blocked only at a true impasse after the same blocker recurs for at least three consecutive goal turns, with concrete evidence that user or external action is required. Never use it merely because work is hard, slow, uncertain, incomplete, needs ordinary clarification, or hit a recoverable failure.",
|
|
1200
|
+
"- After a blocked goal is resumed, start a fresh three-turn blocker audit before using goal_blocked again.",
|
|
1201
|
+
"- If the goal is incomplete at the end of a turn, expect automatic continuation and keep working from the current state.",
|
|
1202
|
+
].join("\n");
|
|
778
1203
|
}
|
|
779
1204
|
|
|
780
1205
|
function hasPendingMessages(ctx: StatusContext) {
|
|
@@ -793,6 +1218,20 @@ function blockStaleGoalToolCalls() {
|
|
|
793
1218
|
staleGoalToolCallsBlocked = true;
|
|
794
1219
|
}
|
|
795
1220
|
|
|
1221
|
+
function blocksStaleGoalToolCalls(status: GoalStatus) {
|
|
1222
|
+
return status === "paused" || status === "blocked" || status === "usage_limited";
|
|
1223
|
+
}
|
|
1224
|
+
|
|
1225
|
+
function isResumableGoalStatus(status: GoalStatus) {
|
|
1226
|
+
return blocksStaleGoalToolCalls(status) || status === "budget_limited";
|
|
1227
|
+
}
|
|
1228
|
+
|
|
1229
|
+
function stoppedStatusLabel(status: GoalStatus) {
|
|
1230
|
+
if (status === "usage_limited") return "usage-limited";
|
|
1231
|
+
if (status === "budget_limited") return "budget-limited";
|
|
1232
|
+
return status;
|
|
1233
|
+
}
|
|
1234
|
+
|
|
796
1235
|
function clearStaleGoalToolCallBlock() {
|
|
797
1236
|
staleGoalToolCallsBlocked = false;
|
|
798
1237
|
}
|
|
@@ -801,6 +1240,73 @@ function clearGoalRecovery() {
|
|
|
801
1240
|
goalRecovery = undefined;
|
|
802
1241
|
}
|
|
803
1242
|
|
|
1243
|
+
function clearBudgetWrapUp() {
|
|
1244
|
+
budgetWrapUp = undefined;
|
|
1245
|
+
}
|
|
1246
|
+
|
|
1247
|
+
function keepBudgetWrapUpMessage(message: unknown) {
|
|
1248
|
+
if (!message || typeof message !== "object") return true;
|
|
1249
|
+
const candidate = message as {
|
|
1250
|
+
role?: unknown;
|
|
1251
|
+
customType?: unknown;
|
|
1252
|
+
details?: { goalId?: unknown };
|
|
1253
|
+
};
|
|
1254
|
+
if (candidate.role !== "custom" || candidate.customType !== BUDGET_WRAP_UP_MESSAGE_TYPE) {
|
|
1255
|
+
return true;
|
|
1256
|
+
}
|
|
1257
|
+
return (
|
|
1258
|
+
typeof candidate.details?.goalId === "string" &&
|
|
1259
|
+
candidate.details.goalId === budgetWrapUp?.goalId &&
|
|
1260
|
+
candidate.details.goalId === activeGoal?.id
|
|
1261
|
+
);
|
|
1262
|
+
}
|
|
1263
|
+
|
|
1264
|
+
function queueBudgetWrapUp(pi: ExtensionAPI, ctx: StatusContext, goal: ActiveGoal) {
|
|
1265
|
+
if (!budgetWrapUp || budgetWrapUp.goalId !== goal.id) {
|
|
1266
|
+
budgetWrapUp = { goalId: goal.id, delivered: false };
|
|
1267
|
+
}
|
|
1268
|
+
if (budgetWrapUp.delivered) return true;
|
|
1269
|
+
budgetWrapUp.delivered = true;
|
|
1270
|
+
try {
|
|
1271
|
+
pi.sendMessage(
|
|
1272
|
+
{
|
|
1273
|
+
customType: BUDGET_WRAP_UP_MESSAGE_TYPE,
|
|
1274
|
+
content: BUDGET_WRAP_UP_PROMPT,
|
|
1275
|
+
display: true,
|
|
1276
|
+
details: { goalId: goal.id },
|
|
1277
|
+
},
|
|
1278
|
+
{ deliverAs: "steer" },
|
|
1279
|
+
);
|
|
1280
|
+
return true;
|
|
1281
|
+
} catch (error) {
|
|
1282
|
+
budgetWrapUp.delivered = false;
|
|
1283
|
+
ctx.ui.notify(`Goal budget wrap-up failed: ${formatError(error)}`, "error");
|
|
1284
|
+
return false;
|
|
1285
|
+
}
|
|
1286
|
+
}
|
|
1287
|
+
|
|
1288
|
+
function limitActiveGoalForBudget(pi: ExtensionAPI, ctx: StatusContext, sendWrapUp: boolean) {
|
|
1289
|
+
const goal = activeGoal;
|
|
1290
|
+
if (
|
|
1291
|
+
!goal ||
|
|
1292
|
+
goal.status !== "active" ||
|
|
1293
|
+
goal.tokenBudget === undefined ||
|
|
1294
|
+
goal.tokensUsed < goal.tokenBudget
|
|
1295
|
+
) {
|
|
1296
|
+
return false;
|
|
1297
|
+
}
|
|
1298
|
+
|
|
1299
|
+
cancelContinuationWork();
|
|
1300
|
+
clearGoalRecoveryForGoal(goal.id);
|
|
1301
|
+
clearBudgetWrapUp();
|
|
1302
|
+
activeGoal = transitionGoal(goal, "budget_limited");
|
|
1303
|
+
persistGoal(activeGoal);
|
|
1304
|
+
updateStatus(ctx, activeGoal);
|
|
1305
|
+
ctx.ui.notify(`Goal token budget reached: ${formatBudget(activeGoal)}`, "warning");
|
|
1306
|
+
if (sendWrapUp) queueBudgetWrapUp(pi, ctx, activeGoal);
|
|
1307
|
+
return true;
|
|
1308
|
+
}
|
|
1309
|
+
|
|
804
1310
|
function clearGoalRecoveryForGoal(goalId: string) {
|
|
805
1311
|
if (goalRecovery?.goalId === goalId) goalRecovery = undefined;
|
|
806
1312
|
}
|
|
@@ -819,11 +1325,34 @@ export function isContradictoryCompletionSummary(summary: string) {
|
|
|
819
1325
|
return CONTRADICTORY_COMPLETION_PATTERNS.some((pattern) => pattern.test(summary));
|
|
820
1326
|
}
|
|
821
1327
|
|
|
1328
|
+
function goalIdRejectionReason(goal: ActiveGoal, requestedGoalId: string) {
|
|
1329
|
+
if (!requestedGoalId) return "missing goal_id";
|
|
1330
|
+
if (requestedGoalId !== goal.id) return "goal_id does not match the active goal";
|
|
1331
|
+
return undefined;
|
|
1332
|
+
}
|
|
1333
|
+
|
|
1334
|
+
export function isUsageLimitedGoalInterruption(assistant: AssistantMessageLike) {
|
|
1335
|
+
const errorMessage = assistant.errorMessage;
|
|
1336
|
+
return (
|
|
1337
|
+
assistant.stopReason === "error" &&
|
|
1338
|
+
typeof errorMessage === "string" &&
|
|
1339
|
+
USAGE_LIMIT_GOAL_ERROR_PATTERNS.some((pattern) => pattern.test(errorMessage))
|
|
1340
|
+
);
|
|
1341
|
+
}
|
|
1342
|
+
|
|
822
1343
|
export function isRetryableGoalInterruption(assistant: AssistantMessageLike) {
|
|
823
1344
|
if (assistant.stopReason !== "error") return false;
|
|
824
1345
|
if (!assistant.errorMessage) return false;
|
|
825
|
-
if (
|
|
826
|
-
|
|
1346
|
+
if (
|
|
1347
|
+
isUsageLimitedGoalInterruption(assistant) ||
|
|
1348
|
+
NON_RETRYABLE_GOAL_ERROR_RE.test(assistant.errorMessage)
|
|
1349
|
+
) {
|
|
1350
|
+
return false;
|
|
1351
|
+
}
|
|
1352
|
+
return (
|
|
1353
|
+
isGoalContextOverflow(assistant) ||
|
|
1354
|
+
RETRYABLE_GOAL_ERROR_PATTERNS.some((pattern) => pattern.test(assistant.errorMessage ?? ""))
|
|
1355
|
+
);
|
|
827
1356
|
}
|
|
828
1357
|
|
|
829
1358
|
function isGoalContextOverflow(assistant: AssistantMessageLike) {
|
|
@@ -862,13 +1391,15 @@ function zeroUsage(): Usage {
|
|
|
862
1391
|
}
|
|
863
1392
|
|
|
864
1393
|
function clearContinuationTracking() {
|
|
865
|
-
|
|
1394
|
+
continuationIntent = undefined;
|
|
1395
|
+
continuationDelivery = undefined;
|
|
866
1396
|
cancelledContinuationMarkers.clear();
|
|
867
1397
|
}
|
|
868
1398
|
|
|
869
|
-
function
|
|
870
|
-
if (
|
|
871
|
-
|
|
1399
|
+
function cancelContinuationWork() {
|
|
1400
|
+
if (continuationDelivery) rememberCancelledContinuationMarker(continuationDelivery.marker);
|
|
1401
|
+
continuationIntent = undefined;
|
|
1402
|
+
continuationDelivery = undefined;
|
|
872
1403
|
}
|
|
873
1404
|
|
|
874
1405
|
function rememberCancelledContinuationMarker(marker: string) {
|
|
@@ -883,9 +1414,16 @@ function consumeCancelledContinuationPrompt(prompt: string) {
|
|
|
883
1414
|
return marker ? cancelledContinuationMarkers.delete(marker) : false;
|
|
884
1415
|
}
|
|
885
1416
|
|
|
886
|
-
function
|
|
1417
|
+
function markContinuationStarted(prompt: string) {
|
|
887
1418
|
const marker = extractContinuationMarker(prompt);
|
|
888
|
-
if (marker
|
|
1419
|
+
if (!marker) {
|
|
1420
|
+
// A user, retry, or another extension started newer work. Cancel both an
|
|
1421
|
+
// unsent intent and a delivery that may have lost the non-atomic idle race;
|
|
1422
|
+
// the newer work's agent_end will record a fresh intent.
|
|
1423
|
+
cancelContinuationWork();
|
|
1424
|
+
return;
|
|
1425
|
+
}
|
|
1426
|
+
if (continuationDelivery?.marker === marker) continuationDelivery = undefined;
|
|
889
1427
|
}
|
|
890
1428
|
|
|
891
1429
|
function continuationMarker(goal: ActiveGoal) {
|
|
@@ -940,11 +1478,11 @@ function normalizeUsage(value: unknown): Usage | undefined {
|
|
|
940
1478
|
const usage = value as Partial<Usage>;
|
|
941
1479
|
if (typeof usage.input !== "number" || typeof usage.output !== "number") return undefined;
|
|
942
1480
|
return {
|
|
943
|
-
input: usage.input,
|
|
944
|
-
output: usage.output,
|
|
945
|
-
cacheRead: usage.cacheRead
|
|
946
|
-
cacheWrite: usage.cacheWrite
|
|
947
|
-
totalTokens:
|
|
1481
|
+
input: nonNegativeFiniteNumber(usage.input),
|
|
1482
|
+
output: nonNegativeFiniteNumber(usage.output),
|
|
1483
|
+
cacheRead: nonNegativeFiniteNumber(usage.cacheRead),
|
|
1484
|
+
cacheWrite: nonNegativeFiniteNumber(usage.cacheWrite),
|
|
1485
|
+
totalTokens: assistantUsageTokens(usage),
|
|
948
1486
|
cost: {
|
|
949
1487
|
input: usage.cost?.input ?? 0,
|
|
950
1488
|
output: usage.cost?.output ?? 0,
|
|
@@ -967,21 +1505,67 @@ function truncateNotification(value: string) {
|
|
|
967
1505
|
return value.length > 160 ? `${value.slice(0, 157)}...` : value;
|
|
968
1506
|
}
|
|
969
1507
|
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
1508
|
+
interface AssistantUsageEntryLike {
|
|
1509
|
+
type?: unknown;
|
|
1510
|
+
message?: { role?: unknown; usage?: unknown };
|
|
1511
|
+
}
|
|
1512
|
+
|
|
1513
|
+
function isNonNegativeFiniteNumber(value: unknown): value is number {
|
|
1514
|
+
return typeof value === "number" && Number.isFinite(value) && value >= 0;
|
|
1515
|
+
}
|
|
1516
|
+
|
|
1517
|
+
function nonNegativeFiniteNumber(value: unknown) {
|
|
1518
|
+
return isNonNegativeFiniteNumber(value) ? value : 0;
|
|
1519
|
+
}
|
|
1520
|
+
|
|
1521
|
+
function normalizeTokenBudget(value: unknown) {
|
|
1522
|
+
return typeof value === "number" && Number.isSafeInteger(value) && value > 0
|
|
1523
|
+
? value
|
|
1524
|
+
: undefined;
|
|
1525
|
+
}
|
|
1526
|
+
|
|
1527
|
+
export function assistantUsageTokens(value: unknown) {
|
|
1528
|
+
if (!value || typeof value !== "object") return 0;
|
|
1529
|
+
const usage = value as Partial<Usage>;
|
|
1530
|
+
if (
|
|
1531
|
+
typeof usage.totalTokens === "number" &&
|
|
1532
|
+
Number.isFinite(usage.totalTokens) &&
|
|
1533
|
+
usage.totalTokens >= 0
|
|
1534
|
+
) {
|
|
1535
|
+
return usage.totalTokens;
|
|
1536
|
+
}
|
|
1537
|
+
// Pi providers define the compatibility total as input + output + cache read +
|
|
1538
|
+
// cache write. reasoning is already in output; cacheWrite1h is in cacheWrite.
|
|
1539
|
+
return Math.min(
|
|
1540
|
+
Number.MAX_SAFE_INTEGER,
|
|
1541
|
+
nonNegativeFiniteNumber(usage.input) +
|
|
1542
|
+
nonNegativeFiniteNumber(usage.output) +
|
|
1543
|
+
nonNegativeFiniteNumber(usage.cacheRead) +
|
|
1544
|
+
nonNegativeFiniteNumber(usage.cacheWrite),
|
|
1545
|
+
);
|
|
1546
|
+
}
|
|
1547
|
+
|
|
1548
|
+
export function cumulativeAssistantTokens(entries: unknown[]) {
|
|
975
1549
|
let total = 0;
|
|
976
|
-
for (const
|
|
1550
|
+
for (const candidate of entries) {
|
|
1551
|
+
if (!candidate || typeof candidate !== "object") continue;
|
|
1552
|
+
const entry = candidate as AssistantUsageEntryLike;
|
|
977
1553
|
if (entry.type !== "message" || entry.message?.role !== "assistant") continue;
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
1554
|
+
total = Math.min(
|
|
1555
|
+
Number.MAX_SAFE_INTEGER,
|
|
1556
|
+
total + assistantUsageTokens(entry.message.usage),
|
|
1557
|
+
);
|
|
981
1558
|
}
|
|
982
1559
|
return total;
|
|
983
1560
|
}
|
|
984
1561
|
|
|
1562
|
+
function currentTokenTotal(ctx: StatusContext): number {
|
|
1563
|
+
const sessionManager = ctx.sessionManager as
|
|
1564
|
+
| { getBranch?: () => AssistantUsageEntryLike[] }
|
|
1565
|
+
| undefined;
|
|
1566
|
+
return cumulativeAssistantTokens(sessionManager?.getBranch?.() ?? []);
|
|
1567
|
+
}
|
|
1568
|
+
|
|
985
1569
|
function persistGoal(goal: ActiveGoal) {
|
|
986
1570
|
extensionApi?.appendEntry<GoalStateEntryData>(GOAL_STATE_ENTRY_TYPE, { goal });
|
|
987
1571
|
}
|
|
@@ -1003,12 +1587,29 @@ function loadGoalFromSession(ctx: StatusContext): ActiveGoal | undefined {
|
|
|
1003
1587
|
.filter((entry) => entry.type === "custom" && entry.customType === GOAL_STATE_ENTRY_TYPE)
|
|
1004
1588
|
.pop();
|
|
1005
1589
|
const data = entry?.data as GoalStateEntryData | undefined;
|
|
1006
|
-
|
|
1590
|
+
if (!isGoal(data?.goal) || data.goal.status === "complete") return undefined;
|
|
1591
|
+
return normalizeLoadedGoal(data.goal);
|
|
1592
|
+
}
|
|
1593
|
+
|
|
1594
|
+
function normalizeLoadedGoal(goal: ActiveGoal): ActiveGoal {
|
|
1595
|
+
const now = Date.now();
|
|
1596
|
+
return {
|
|
1597
|
+
...goal,
|
|
1598
|
+
startedAt: isNonNegativeFiniteNumber(goal.startedAt) ? goal.startedAt : now,
|
|
1599
|
+
updatedAt: isNonNegativeFiniteNumber(goal.updatedAt) ? goal.updatedAt : now,
|
|
1600
|
+
iteration: Math.max(0, Math.floor(nonNegativeFiniteNumber(goal.iteration))),
|
|
1601
|
+
tokenBudget: normalizeTokenBudget(goal.tokenBudget),
|
|
1602
|
+
tokensUsed: nonNegativeFiniteNumber(goal.tokensUsed),
|
|
1603
|
+
timeUsedSeconds: nonNegativeFiniteNumber(goal.timeUsedSeconds),
|
|
1604
|
+
baselineTokens: nonNegativeFiniteNumber(goal.baselineTokens),
|
|
1605
|
+
activeStartedAt: goal.status === "active" ? now : undefined,
|
|
1606
|
+
};
|
|
1007
1607
|
}
|
|
1008
1608
|
|
|
1009
1609
|
function clearActiveGoal(ctx: StatusContext) {
|
|
1010
|
-
|
|
1610
|
+
cancelContinuationWork();
|
|
1011
1611
|
clearGoalRecovery();
|
|
1612
|
+
clearBudgetWrapUp();
|
|
1012
1613
|
clearStaleGoalToolCallBlock();
|
|
1013
1614
|
activeGoal = undefined;
|
|
1014
1615
|
clearPersistedGoal(ctx.cwd);
|
|
@@ -1055,19 +1656,21 @@ function clearLegacyPersistedGoal(cwd: string) {
|
|
|
1055
1656
|
writeFileSync(STATE_FILE, `${JSON.stringify(goals, null, 2)}\n`);
|
|
1056
1657
|
}
|
|
1057
1658
|
|
|
1058
|
-
|
|
1059
1659
|
function isGoal(value: unknown): value is ActiveGoal {
|
|
1060
1660
|
if (!value || typeof value !== "object") return false;
|
|
1061
1661
|
const goal = value as Partial<ActiveGoal>;
|
|
1062
1662
|
return (
|
|
1063
1663
|
typeof goal.id === "string" &&
|
|
1064
1664
|
typeof goal.text === "string" &&
|
|
1065
|
-
["active", "paused", "budget_limited", "complete"].includes(
|
|
1665
|
+
["active", "paused", "blocked", "usage_limited", "budget_limited", "complete"].includes(
|
|
1666
|
+
String(goal.status),
|
|
1667
|
+
) &&
|
|
1066
1668
|
typeof goal.startedAt === "number" &&
|
|
1067
1669
|
typeof goal.updatedAt === "number" &&
|
|
1068
1670
|
typeof goal.iteration === "number" &&
|
|
1069
1671
|
typeof goal.tokensUsed === "number" &&
|
|
1070
1672
|
typeof goal.timeUsedSeconds === "number" &&
|
|
1071
|
-
typeof goal.baselineTokens === "number"
|
|
1673
|
+
typeof goal.baselineTokens === "number" &&
|
|
1674
|
+
(goal.activeStartedAt === undefined || typeof goal.activeStartedAt === "number")
|
|
1072
1675
|
);
|
|
1073
1676
|
}
|