@astrosheep/pi-goal-next 0.1.6 → 0.1.8

package/README.md

@@ -29,13 +29,13 @@ For a project-local extension, add the package path to the project's Pi extensio
 /goal clear
 ```
 
-Creating a goal is refused while an unfinished goal exists. `edit` clears the current goal and creates a new active goal with its limits preserved. `pause` and `resume` are user commands; `clear` removes the goal semantically from the journal. Token suffixes accepted by create are `k` and `M` (for example, `200k` and `2M`).
+With no goal, or when the current goal is complete, `/goal <objective>` creates a fresh goal. With an unfinished goal it instead updates the objective in place (Codex `thread/goal/set` semantics): same goal id, status, token budget, and cumulative usage are preserved, and an `objective_updated` steering message is sent. `/goal edit <objective>` performs the same in-place update. The model-facing `create_goal` tool still refuses while an unfinished goal exists. `pause` and `resume` are user commands; `clear` removes the goal semantically from the journal. Token suffixes accepted by create are `k` and `M` (for example, `200k` and `2M`).
 
 ## Model tools
 
 - `get_goal` returns the current snapshot plus `remainingBudget` and `elapsedSeconds`, or reports that no goal exists.
 - `create_goal` creates an active goal after an explicit request. It accepts `objective` and optional `token_budget` (a positive integer).
-- `update_goal` accepts only `complete` or `blocked` after the model's self-audit. The host does not validate the declaration; on `complete` the result reports the final token usage.
+- `update_goal` accepts only `complete` or `blocked` after the model's self-audit. `complete` is permitted from `active` and `budget_limited`, not `paused` or `blocked`; the host does not validate the declaration. On `complete` the result reports the final token usage.
 
 The prompt text is copied byte-for-byte from Codex Goal (`continuation.md`, `budget_limit.md`, `objective_updated.md`); the only deletion is Codex's `update_plan` "Progress visibility" paragraph, because Pi has no `update_plan` tool. Continuation prompts state the objective inside `<objective>` as user-provided data and carry the budget, evidence, fidelity, completion-audit, and blocked-audit rules. The three-consecutive-turn blocked audit is prompt-level guidance; the runtime does not enforce it.
 
@@ -53,24 +53,24 @@ The prompt text is copied byte-for-byte from Codex Goal (`continuation.md`, `bud
                                              ^
                          update_goal blocked|
 
- active --accounting limit--> budget_limited
+ active --accounting limit--> budget_limited --update_goal complete--> complete
  any unfinished --/goal clear--> no goal
 ```
 
-`complete` is terminal. A goal is one journal-folded goal per session branch; a new goal cannot be created until the prior one is complete (or cleared). `blocked` is a model declaration, not an automatic retry decision. Codex's three-consecutive-turn blocker guard lives verbatim in the continuation prompt and the `update_goal` description; it is prompt-level only, not enforced in runtime code.
+`complete` is terminal. It may be declared from `active` or `budget_limited`, never from `paused` or `blocked`. A goal is one journal-folded goal per session branch; a new goal cannot be created until the prior one is complete (or cleared). `blocked` is a model declaration, not an automatic retry decision. Codex's three-consecutive-turn blocker guard lives verbatim in the continuation prompt and the `update_goal` description; it is prompt-level only, not enforced in runtime code.
 
 ## Limits and accounting
 
 - The default maximum is 25 continuation turns (`maxContinuations`) per run. Change it with `/goal turns N`. `/goal resume` resets the run's continuation count and immediately schedules work when idle. It preserves the objective, journal history, cumulative usage, and token budget. If the token budget is exhausted or the continuation allowance is zero, resume reports the limit instead of claiming success.
 - A token budget is unset by default. Set one at creation with `/goal --tokens N[k|M] ...` or later with `/goal budget N`.
 - Usage comes directly from each completed assistant/tool-result event. Repeated delivery of the same live message object is deduplicated. Pi has not assigned a session entry id at this event boundary; historical messages are not re-accounted on reload.
-- Missing provider usage is recorded as unknown, never treated as confirmed zero.
+- In usage journal intents, omitted usage fields serialize as zero; an explicit `null` preserves existing unknown semantics. An absent entire Pi usage object remains unknown.
 - Nested or subagent usage is counted only when Pi exposes it as `toolResult.usage` data; see [limits](docs/limits.md).
-- The final completing turn is included in accounting.
+- Usage is attributed to the goal that owns the run. The final completing turn remains charged; runs begun after a goal is complete, paused, or blocked are unrelated and are not charged to it.
 
 ## Completion and blocking contract
 
-The model calls `update_goal` after auditing the current goal against the Codex completion audit carried in every continuation prompt. The host accepts `complete` and `blocked` at face value and performs no independent verification; the prompt is the only guard. `complete` reports final token usage in the tool result, and `blocked` is meant to follow three consecutive turns with the same blocker. `paused` is user-only (`/goal pause`). Runtime accounting may instead move an active goal to `budget_limited`; the model cannot declare that state, and the transition triggers one `budget_limit.md` steering message.
+The model calls `update_goal` after auditing the current goal against the Codex completion audit carried in every continuation prompt. The host accepts `complete` and `blocked` at face value and performs no independent verification; the prompt is the only guard. `complete` may transition an `active` or `budget_limited` goal and reports final token usage; it is prohibited from `paused` and `blocked`. `blocked` is meant to follow three consecutive turns with the same blocker. `paused` is user-only (`/goal pause`). Runtime accounting may instead move an active goal to `budget_limited`; the model cannot declare that state, and the transition triggers one `budget_limit.md` steering message.
 
 Automatic continuation waits for a fresh normal assistant completion and for the entire Pi run to settle, including tools, retries, compaction, and queued input. Errors, cancellation (including cancellation after text finishes), and runs ending at a tool boundary do not trigger continuation or budget steering. Ordinary user input has no continuation attached; once the response to that input finishes normally, an active goal may continue.
 

package/docs/architecture.md

@@ -10,7 +10,7 @@ Pi 0.85.1 extension package adding a long-running `/goal`. Behavior follows Code
 
 `active | paused | blocked | budget_limited | complete`
 
-- Model's `update_goal` accepts only: `complete` | `blocked`. The model self-audits; the host does not validate the declaration.
+- Model's `update_goal` accepts only: `complete` | `blocked`. `complete` is permitted from `active` and `budget_limited`, but not from `paused` or `blocked`. The model self-audits; the host does not validate the declaration.
 - `budget_limited` is set only by runtime/system paths (accounting).
 - `clear` is a journal entry `goal.cleared`; `fold()` yields null. Deletion is semantic.
 - One goal per session branch. `create_goal` refuses when an unfinished goal exists.
@@ -37,11 +37,12 @@ Dependency direction: `index → {tools, commands, lifecycle, ui} → {goal-comm
 
 ```ts
 current(): GoalSnapshot | null            // { goal, revision }
+getRevision(): number                     // available even when current() is null
 commit(intent, expectedRevision): Promise<{ ok, snapshot } | { conflict, snapshot }>
 subscribe(fn): unsubscribe
 ```
 
-Internally: check `revision === expectedRevision` and no pending → mark pending → `await store.append` → success: swap in, revision+1, notify; failure: release pending, report. Critical section wraps one append only — never verification, prompt building, or sendMessage.
+Internally: check `revision === expectedRevision` and no pending → mark pending → `await store.append` → success: swap in, revision+1, notify; failure: release pending, report. `getRevision()` remains available after a clear, so a clear→create sequence can use the current CAS revision. Critical section wraps one append only — never verification, prompt building, or sendMessage.
 
 ## Two counters
 
@@ -62,7 +63,7 @@ User messages win: `input` invalidates outstanding continuation attempts before
 
 1. `session_start`: invalidate pending work, rebuild, and transition any restored `active` goal to `paused`. Never silently resume.
 2. `session_before_tree`: invalidate pending work; the next event rebuilds from the selected branch.
-3. `session_before_compact`: provide `goal.summarize()` text if the hook supports the required fields.
+3. Pi generates its normal conversation summary without a goal override. Goal state remains in its separate journal; `get_goal` and continuation prompts restore the relevant goal context.
 4. `agent_start`: reset completion state and capture `ctx.signal`. Retain that signal after Pi clears its current signal at idle, so cancellation during message/agent-end handlers still suppresses continuation.
 5. `message_end`: account the current message and capture its stop reason. Pi dispatches this hook **before** appending the message to SessionManager; never substitute the last persisted same-role message.
 6. `input` / user `message_start`: invalidate old scheduling and track input receipt through delivery.
@@ -72,8 +73,9 @@ Retry messages are separately accounted because each response costs real tokens.
 
 ## accounting rules
 
-- Dedup key: an in-memory ID assigned by WeakMap to each assistant/toolResult event message object. Session entry IDs do not yet exist at `message_end`. Usage deltas are journaled immediately; historical messages are not replayed into accounting on reload.
-- Only count usage Pi reports. Missing usage → recorded as `unknown`, never assumed zero.
+- Dedup key: an in-memory ID assigned by WeakMap to each assistant/toolResult event message object. Session entry IDs do not yet exist at `message_end`. Usage deltas are journaled immediately; historical messages are not replayed into accounting on reload. A message is acknowledged only after its usage commit succeeds. Failed writes remain pending for the next message or settled event; unresolved writes suppress automatic continuation.
+- Usage is attributed to the goal that owns the run. The final run completing a goal remains charged; later unrelated runs after complete, pause, or block do not charge that goal.
+- In usage journal intents, omitted usage fields serialize as zero; an explicit `null` preserves existing unknown semantics. An absent entire Pi usage object remains unknown.
 - toolResult.usage (nested/subagent usage) counts only when present; the coverage gap is disclosed in UI + limits.md.
 - Final completing turn IS accounted (same as both reference implementations).
 
@@ -83,7 +85,7 @@ Retry messages are separately accounted because each response costs real tokens.
 
 - `continuationPrompt(goal)` (`continuation.md`): the objective inside `<objective>` as user-provided data; budget block; "Work from evidence"; "Fidelity"; completion audit; blocked audit (three consecutive goal turns); closing rules.
 - `budgetLimitPrompt(goal)` (`budget_limit.md`): sent once per goal instance when the status flips to `budget_limited`.
-- `objectiveUpdatedPrompt(goal)` (`objective_updated.md`): sent after a successful `/goal edit`; uses `<untrusted_objective>` and reports remaining tokens as `unknown` when no budget is set.
+- `objectiveUpdatedPrompt(goal)` (`objective_updated.md`): sent after a successful in-place objective update (`/goal <new>` or `/goal edit` on an unfinished goal); uses `<untrusted_objective>` and reports remaining tokens as `unknown` when no budget is set.
 
 Substitution is trivial `{{ name }}` replacement. `escapeXmlText` (`&`→`&amp;`, `<`→`&lt;`, `>`→`&gt;`) is applied to the objective only. `tokens_used` is `input+output+cacheRead+cacheWrite`; `token_budget` is the budget or `none`; `remaining_tokens` is `max(0, budget-used)`, or `unbounded` (continuation) / `unknown` (objective update) without a budget; `time_used_seconds` is `floor((Date.now()-createdAt)/1000)`.
 
@@ -91,9 +93,9 @@ The blocked audit is prompt-level only: the runtime does not count blocking turn
 
 ## Commands
 
-`/goal` or `/goal status` · `/goal [--tokens N[k|M]] <objective>` (create; refuses while unfinished) · `/goal edit <objective>` · `/goal pause` · `/goal resume` · `/goal clear` · `/goal budget <tokens|none>` · `/goal turns <max-continuations>`.
+`/goal` or `/goal status` · `/goal [--tokens N[k|M]] <objective>` (create, or in-place objective update while unfinished — Codex `thread/goal/set` semantics) · `/goal edit <objective>` (same in-place update) · `/goal pause` · `/goal resume` · `/goal clear` · `/goal budget <tokens|none>` · `/goal turns <max-continuations>`.
 
-A successful `resume` atomically journals `resetContinuations: true` on the user transition to active, resetting the run's continuation count while preserving the objective, usage, budget, and historical entries. It also accepts an already-active goal. Exhausted token budgets and zero continuation allowances are reported without resuming. A successful `create` or `resume` calls `continuation.onSettled()` so an idle session starts pursuing immediately (Codex starts the turn directly). A successful `edit` sends `objectiveUpdatedPrompt(goal)` with `triggerTurn: true`; `pause` and `clear` send nothing (the active-status check stops continuation).
+A successful `resume` atomically journals `resetContinuations: true` on the user transition to active, resetting the run's continuation count while preserving the objective, usage, budget, and historical entries. It also accepts an already-active goal. Exhausted token budgets and zero continuation allowances are reported without resuming. A successful `create` or `resume` calls `continuation.onSettled()` so an idle session starts pursuing immediately (Codex starts the turn directly). A successful in-place objective update atomically appends `goal.objective_updated`, preserving the goal id, status, limits, and cumulative usage, then sends `objectiveUpdatedPrompt(goal)` with `triggerTurn: true`; `pause` and `clear` send nothing (the active-status check stops continuation).
 
 ## Defaults
 
@@ -104,7 +106,7 @@ max continuations (turns): 25 · token budget: unset (opt-in) · the blocked-loo
 1. Stale already-sent continuation runs one more turn (no retraction, no selective abort).
 2. Subagent/nested tokens counted only when toolResult.usage present.
 3. Stale identity rides on continuation custom messages observed via `message_start`; if those events disappear, prompt self-termination is the fallback.
-4. Whether compaction hook accepts appended summary needs verification; harmless if not.
+4. Pi owns normal conversation-summary generation; goal context is restored separately from the journal through `get_goal` and continuation prompts.
 
 ## Testing
 

package/docs/limits.md

@@ -16,9 +16,17 @@ The extension uses the public Pi 0.85.1 event, session, message, and send APIs.
 
 **Cannot guarantee:** Pi does not expose nested or subagent token usage consistently for every tool result.
 
-**What it does:** Counts nested usage only when it is present in `toolResult.usage`; missing usage is recorded as unknown. Top-level assistant and tool-result events are deduplicated by live message-object identity, since their session entry IDs do not yet exist during `message_end`. Journaled usage survives reload; historical events are not counted again.
+**What it does:** Counts nested usage only when it is present in `toolResult.usage`. In usage journal intents, omitted usage fields serialize as zero; an explicit `null` preserves existing unknown semantics. An absent entire Pi usage object remains unknown. Top-level assistant and tool-result events are deduplicated by live message-object identity, since their session entry IDs do not yet exist during `message_end`. Journaled usage survives reload; historical events are not counted again.
 
-**User sees:** The status line can show `unknown messages=N`, and budget totals can be lower than provider-side totals when nested usage was not reported.
+**User sees:** The status line can show `unknown messages=N`, and budget totals can be lower than provider-side totals when nested usage was not reported. If a usage journal write fails, automatic continuation is suppressed and the next message or settled event retries it. Pending, uncommitted usage is held in memory and cannot survive a reload or branch change.
+
+### Goal-owned run usage
+
+**Cannot guarantee:** Usage for an in-flight response cannot be split precisely at the instant a user pauses or replaces a goal.
+
+**What it does:** Attributes usage to the goal that owns a run. A goal's final completing run remains charged; later unrelated runs after it is complete, paused, or blocked do not charge that goal.
+
+**User sees:** Finishing, pausing, or blocking a goal does not cause later unrelated conversation usage to accumulate against it.
 
 ### Continuation message identity
 
@@ -28,13 +36,13 @@ The extension uses the public Pi 0.85.1 event, session, message, and send APIs.
 
 **User sees:** If Pi stops emitting custom-message events, stale turns degrade to prompt self-termination only; subsequent continuation remains subject to normal checks.
 
-### Compaction extension content
+### Compaction and goal context
 
-**Cannot guarantee:** Pi may not accept extension-provided appended compaction content on every hook/version path.
+**Cannot guarantee:** Pi controls the content and timing of its normal conversation summary.
 
-**What it does:** The 0.85.1 hook accepts a `CompactionResult`; it returns the goal summary when the hook provides `preparation.firstKeptEntryId` and numeric `tokensBefore`. The defensive field check remains for older/newer hook variants. Continuation prompts remain self-contained.
+**What it does:** Does not override Pi's compaction summary. Goal state remains in a separate journal and is restored through `get_goal` and self-contained continuation prompts.
 
-**User sees:** After some compactions the normal goal summary may be absent from the compaction context, while the goal itself remains in the journal.
+**User sees:** Normal conversation compaction proceeds under Pi's standard behavior; the goal remains available independently of that summary.
 
 ## Additional implementation boundaries
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/pi-goal-next",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Persistent autonomous goals for pi, with Codex-verbatim goal semantics: continuation prompts, self-audited completion, budgets, and CAS-journaled state.",
   "type": "module",
   "files": [

package/src/accounting.ts

@@ -19,6 +19,11 @@ export function createAccounting() {
   const unknown = new Set<string>();
   const deltas = new Map<string, Delta>();
 
+  function previewMessage(message: Message): Omit<Delta, "stale"> {
+    const u = message.usage;
+    return { input: n(u?.input) ?? 0, output: n(u?.output) ?? 0, cacheRead: n(u?.cacheRead) ?? 0, cacheWrite: n(u?.cacheWrite) ?? 0, unknownMessages: u ? 0 : 1 };
+  }
+
   function recordMessage(message: Message): { duplicate: boolean; delta: Delta } | null {
     if (!message || typeof message.entryId !== "string" || !message.entryId) return null;
     if (seen.has(message.entryId)) return { duplicate: true, delta: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, unknownMessages: 0, stale: stale.has(message.entryId) } };
@@ -51,5 +56,5 @@ export function createAccounting() {
     const unknownText = u.unknownMessages || unknown.size ? `, unknown messages=${u.unknownMessages + unknown.size}` : "";
     return `usage input=${u.input} output=${u.output} cacheRead=${u.cacheRead} cacheWrite=${u.cacheWrite}${unknownText}${staleText}`;
   }
-  return { recordMessage, recordStale, settleTurn, summary };
+  return { previewMessage, hasMessage: (id: string) => seen.has(id), recordMessage, recordStale, settleTurn, summary };
 }

package/src/commands.ts

@@ -28,21 +28,26 @@ export function registerGoalCommands(piLike: CommandPiLike, deps: CommandDeps):
   piLike.registerCommand("goal", { description: "Manage the current goal", handler: async (raw: string, ctx?: { ui?: { notify(message: string, level?: string): void } }) => {
     const run = async (cmd: ReturnType<typeof parseGoalCommand>): Promise<string> => {
       const current = goalCommit.current();
-      const revision = current?.revision ?? 0;
+      const revision = current?.revision ?? goalCommit.getRevision();
       const finish = (r: Awaited<ReturnType<GoalCommitLike["commit"]>>, ok: string) => r.kind === "ok" ? ok : "Goal update failed.";
       switch (cmd.kind) {
         case "status": return summarize(current);
         case "create": {
-          if (current && current.goal.status !== "complete") return "Cannot create goal: an unfinished goal already exists.";
+          // Codex thread/goal/set semantics: an unfinished goal's objective is
+          // updated in place (same goal id, usage/budget preserved); a missing
+          // or complete goal starts a fresh one.
+          if (current && current.goal.status !== "complete") {
+            const r = await goalCommit.commit({ type: "update_objective", objective: cmd.objective as string, ...(cmd.tokenBudget === undefined || cmd.tokenBudget === null ? {} : { tokenBudget: cmd.tokenBudget }) }, revision);
+            if (r.kind === "ok" && r.snapshot) deps.send({ customType: "pi-goal-next/objective_updated", content: objectiveUpdatedPrompt(r.snapshot.goal), display: false, details: { goalId: r.snapshot.goal.id } }, { triggerTurn: true });
+            return r.kind === "ok" ? "Goal updated." : "Goal update failed.";
+          }
           const r = await goalCommit.commit({ type: "create", id: newGoalId(), objective: cmd.objective as string, tokenBudget: cmd.tokenBudget ?? null }, revision);
           if (r.kind === "ok") await deps.kick();
           return r.kind === "ok" ? "Goal created." : "Goal update failed.";
         }
         case "edit": {
-          const previous = current;
-          const cleared = await goalCommit.commit({ type: "clear" }, revision);
-          if (cleared.kind !== "ok") return "Goal update failed.";
-          const r = await goalCommit.commit({ type: "create", id: newGoalId(), objective: cmd.objective as string, tokenBudget: previous?.goal.tokenBudget, maxContinuations: previous?.goal.maxContinuations }, cleared.snapshot?.revision ?? revision);
+          if (!current) return "Goal update failed.";
+          const r = await goalCommit.commit({ type: "update_objective", objective: cmd.objective as string }, revision);
           if (r.kind === "ok" && r.snapshot) deps.send({ customType: "pi-goal-next/objective_updated", content: objectiveUpdatedPrompt(r.snapshot.goal), display: false, details: { goalId: r.snapshot.goal.id } }, { triggerTurn: true });
           return r.kind === "ok" ? "Goal edited." : "Goal update failed.";
         }

package/src/goal-commit.ts

@@ -10,7 +10,7 @@ export type CommitResult =
   | { kind: "ok"; snapshot: GoalSnapshot | null }
   | { kind: "conflict"; snapshot: GoalSnapshot | null }
   | { kind: "error"; error: unknown };
-export type GoalCommitLike = Pick<ReturnType<typeof createGoalCommit>, "current" | "commit">;
+export type GoalCommitLike = Pick<ReturnType<typeof createGoalCommit>, "current" | "commit" | "getRevision">;
 
 export function createGoalCommit(store: GoalStore) {
   let bootstrapped = false;
@@ -34,13 +34,17 @@ export function createGoalCommit(store: GoalStore) {
     return goal ? { goal, revision } : null;
   }
 
+  function getRevision(): number { bootstrap(); return revision; }
+
   function entryFor(intent: Intent, next: Goal | null, previous: Goal | null): Entry {
     const seq = ++sequence;
     switch (intent.type) {
       case "create": return { type: "goal.created", version: 1, seq, goal: next! };
+      case "replace": return { type: "goal.replaced", version: 1, seq, goal: next! };
+      case "update_objective": return { type: "goal.objective_updated", version: 1, seq, objective: intent.objective };
       case "clear": return { type: "goal.cleared", version: 1, seq };
       case "transition": return { type: "goal.transition", version: 1, seq, from: previous!.status, to: intent.to, by: intent.by, ...(intent.userRequest ? { userRequest: intent.userRequest } : {}), ...(intent.resetContinuations ? { resetContinuations: true } : {}) };
-      case "usage": return { type: "goal.usage", version: 1, seq, input: intent.input ?? null, output: intent.output ?? null, cacheRead: intent.cacheRead ?? null, cacheWrite: intent.cacheWrite ?? null, unknownMessages: intent.unknownMessages ?? 0 };
+      case "usage": return { type: "goal.usage", version: 1, seq, input: intent.input === undefined ? 0 : intent.input, output: intent.output === undefined ? 0 : intent.output, cacheRead: intent.cacheRead === undefined ? 0 : intent.cacheRead, cacheWrite: intent.cacheWrite === undefined ? 0 : intent.cacheWrite, unknownMessages: intent.unknownMessages ?? 0 };
       case "continuation_sent": return { type: "goal.continuation_sent", version: 1, seq, generation: intent.generation };
       case "stale_turn": return { type: "goal.stale_turn", version: 1, seq, generation: intent.generation };
       case "limit_config": return { type: "goal.limit_config", version: 1, seq, tokenBudget: intent.tokenBudget, maxContinuations: intent.maxContinuations };
@@ -89,5 +93,5 @@ export function createGoalCommit(store: GoalStore) {
     for (const subscriber of subscribers) subscriber(snapshot);
   }
 
-  return { current, commit, subscribe, rebuild };
+  return { current, getRevision, commit, subscribe, rebuild };
 }

package/src/goal.ts

@@ -7,6 +7,8 @@ export type Goal = {
 };
 export type Entry =
   | { type: "goal.created"; version: 1; seq: number; goal: Goal }
+  | { type: "goal.replaced"; version: 1; seq: number; goal: Goal }
+  | { type: "goal.objective_updated"; version: 1; seq: number; objective: string }
   | { type: "goal.transition"; version: 1; seq: number; from: Status; to: Status; by: Actor; userRequest?: string; resetContinuations?: boolean }
   | { type: "goal.cleared"; version: 1; seq: number }
   | { type: "goal.usage"; version: 1; seq: number; input: number | null; output: number | null; cacheRead: number | null; cacheWrite: number | null; unknownMessages: number }
@@ -15,6 +17,8 @@ export type Entry =
   | { type: "goal.limit_config"; version: 1; seq: number; tokenBudget: number | null; maxContinuations: number };
 export type Intent =
   | { type: "create"; id: string; objective: string; tokenBudget?: number | null; maxContinuations?: number }
+  | { type: "replace"; id: string; objective: string }
+  | { type: "update_objective"; objective: string; tokenBudget?: number | null }
   | { type: "transition"; to: Status; by: Actor; userRequest?: string; resetContinuations?: boolean }
   | { type: "clear" }
   | { type: "usage"; input?: number | null; output?: number | null; cacheRead?: number | null; cacheWrite?: number | null; unknownMessages?: number }
@@ -40,6 +44,10 @@ function safeAdd(a: number, b: number, name: string): number {
   return result;
 }
 export function transition(state: Goal | null, intent: Intent): Goal | null {
+  if (intent.type === "replace") {
+    if (!state) throw new GoalError("missing", "no goal exists");
+    return transition(null, { type: "create", id: intent.id, objective: intent.objective, tokenBudget: state.tokenBudget, maxContinuations: state.maxContinuations });
+  }
   if (intent.type === "create") {
     if (state && unfinished(state.status)) throw new GoalError("unfinished", "an unfinished goal already exists");
     if (typeof intent.objective !== "string" || !intent.objective.trim() || !intent.id) throw new GoalError("invalid", "objective and id are required");
@@ -50,11 +58,18 @@ export function transition(state: Goal | null, intent: Intent): Goal | null {
   }
   if (!state) throw new GoalError("missing", "no goal exists");
   if (intent.type === "clear") return null;
+  if (intent.type === "update_objective") {
+    if (typeof intent.objective !== "string" || !intent.objective.trim()) throw new GoalError("invalid", "objective is required");
+    if (intent.tokenBudget !== undefined && intent.tokenBudget !== null && (!Number.isFinite(intent.tokenBudget) || intent.tokenBudget < 0)) throw new GoalError("invalid", "invalid limits");
+    // Codex thread/goal/set semantics: update the objective in place, preserving
+    // status, limits, and cumulative usage on the same goal id.
+    return { ...state, objective: intent.objective.trim(), ...(intent.tokenBudget !== undefined ? { tokenBudget: intent.tokenBudget } : {}) };
+  }
   if (intent.type === "transition") {
     if (!statuses.includes(intent.to)) throw new GoalError("invalid", "unknown status");
     if (intent.to === "paused" && !intent.userRequest?.trim()) throw new GoalError("forbidden", "paused requires user request evidence");
     if (intent.by === "agent" && !["complete", "blocked"].includes(intent.to)) throw new GoalError("forbidden", "agent cannot set this status");
-    if (intent.by === "agent" && intent.to === "complete" && state.status !== "active") throw new GoalError("forbidden", "agent can complete only an active goal");
+    if (intent.by === "agent" && intent.to === "complete" && !["active", "budget_limited"].includes(state.status)) throw new GoalError("forbidden", "agent can complete only an active or budget-limited goal");
     const reset = intent.resetContinuations === true;
     if (reset && (intent.by !== "user" || intent.to !== "active")) throw new GoalError("forbidden", "only user resume can reset continuations");
     if (reset && state.tokenBudget !== null && usageKeys.reduce((sum, key) => sum + state.usage[key], 0) >= state.tokenBudget) throw new GoalError("budget", "token budget exhausted; adjust /goal budget before resuming");
@@ -96,8 +111,9 @@ export function fold(entries: readonly Entry[]): Goal | null {
   let state: Goal | null = null;
   for (const entry of entries) {
     if (!entry.type.startsWith("goal.")) continue;
-    if (entry.type === "goal.created") state = { ...entry.goal };
+    if (entry.type === "goal.created" || entry.type === "goal.replaced") state = { ...entry.goal };
     else if (entry.type === "goal.cleared") state = null;
+    else if (state && entry.type === "goal.objective_updated") state = transition(state, { type: "update_objective", objective: entry.objective });
     else if (state && entry.type === "goal.transition") state = transition(state, { type: "transition", to: entry.to, by: entry.by, userRequest: entry.userRequest, resetContinuations: entry.resetContinuations });
     else if (state && entry.type === "goal.limit_config") state = transition(state, { type: "limit_config", tokenBudget: entry.tokenBudget, maxContinuations: entry.maxContinuations });
     else if (state && entry.type === "goal.continuation_sent") state = transition(state, { type: "continuation_sent", generation: entry.generation });

package/src/lifecycle.ts

@@ -1,11 +1,10 @@
-import { summarize } from "./goal.ts";
 import { budgetLimitPrompt } from "./prompts.ts";
 import type { Message } from "./accounting.ts";
 import type { GoalSnapshot, CommitResult } from "./goal-commit.ts";
 import type { Intent } from "./goal.ts";
 import { createAccounting } from "./accounting.ts";
 import type { Continuation } from "./continuation.ts";
-import type { SessionBeforeCompactEvent, MessageEndEvent, MessageStartEvent, InputEvent, AgentSettledEvent, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import type { MessageEndEvent, MessageStartEvent, InputEvent, AgentSettledEvent, SessionStartEvent } from "@earendil-works/pi-coding-agent";
 
 export type LifecycleDeps = {
   goalCommit: { current(): GoalSnapshot | null; commit(intent: Intent, expectedRevision: number): Promise<CommitResult> };
@@ -17,13 +16,15 @@ export type LifecycleDeps = {
 
 export type PiEvents = { on(name: string, handler: (event: any, ctx: any) => unknown): void };
 export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
-  async function commitWithRetry(intent: Intent, attempts = 3): Promise<void> {
+  async function commitWithRetry(intent: Intent, attempts = 3, expectedGoalId?: string): Promise<boolean> {
     for (let i = 0; i < attempts; i++) {
       const snapshot = deps.goalCommit.current();
-      if (!snapshot) return;
+      if (!snapshot || (expectedGoalId !== undefined && snapshot.goal.id !== expectedGoalId)) return false;
       const result = await deps.goalCommit.commit(intent, snapshot.revision);
-      if (result.kind !== "conflict") return;
+      if (result.kind === "ok") return true;
+      if (result.kind === "error") return false;
     }
+    return false;
   }
   let pendingRebuild = false;
   const bootstrap = () => deps.rebuild();
@@ -35,6 +36,30 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   let epoch = 0;
   let inputPending = false;
   let runSignal: AbortSignal | undefined;
+  // Keep ownership through completion so its remaining tool results/final reply
+  // count, but never transfer an old run's usage to a replacement goal.
+  let accountingGoalId: string | null = null;
+  let startGoalId: string | null = null;
+  const pendingUsage = new Map<string, { goalId: string; message: Message }>();
+  let usageFlush: Promise<boolean> | undefined;
+  async function flushUsage(): Promise<boolean> {
+    if (usageFlush) return usageFlush;
+    usageFlush = (async () => {
+      for (const [id, item] of pendingUsage) {
+        if (deps.goalCommit.current()?.goal.id !== item.goalId) { pendingUsage.delete(id); continue; }
+        const delta = deps.accounting.previewMessage(item.message);
+        if (!await commitWithRetry({ type: "usage", ...delta }, 3, item.goalId)) return false;
+        deps.accounting.recordMessage(item.message);
+        pendingUsage.delete(id);
+      }
+      return true;
+    })();
+    try { return await usageFlush; } finally { usageFlush = undefined; }
+  }
+  const eligibleGoalId = () => {
+    const goal = deps.goalCommit.current()?.goal;
+    return goal && (goal.status === "active" || goal.status === "budget_limited") ? goal.id : null;
+  };
   // message_end precedes SessionManager.appendMessage. Its object is authoritative;
   // no persisted entry ID exists yet. Deduplicate live events by object identity.
   const messageIds = new WeakMap<object, string>();
@@ -49,11 +74,16 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
     lastAssistantStop = undefined;
     // Retain the signal: ctx.signal becomes undefined once the run is idle.
     runSignal = ctx.signal;
+    startGoalId = deps.goalCommit.current()?.goal.id ?? null;
+    accountingGoalId = eligibleGoalId();
   });
 
   pi.on("session_start", async (_event: SessionStartEvent, ctx: any) => {
     invalidate();
     inputPending = false;
+    accountingGoalId = null;
+    startGoalId = null;
+    pendingUsage.clear();
     await bootstrap();
     const snapshot = deps.goalCommit.current();
     if (snapshot?.goal?.status === "active") {
@@ -64,38 +94,34 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
   pi.on("session_before_tree", async (_event: any, ctx: any) => {
     invalidate();
     inputPending = false;
+    accountingGoalId = null;
+    startGoalId = null;
+    pendingUsage.clear();
     pendingRebuild = true;
     // Pi's tree hook does not expose the post-navigation branch; rebuild on the next event.
     void ctx;
   });
 
-  pi.on("session_before_compact", async (event: SessionBeforeCompactEvent, _ctx: any) => {
-    const snapshot = deps.goalCommit.current();
-    if (!snapshot) return;
-    if (event?.preparation?.firstKeptEntryId && Number.isFinite(event.preparation.tokensBefore)) {
-      return { compaction: { summary: summarize(snapshot.goal), firstKeptEntryId: event.preparation.firstKeptEntryId, tokensBefore: event.preparation.tokensBefore } };
-    }
-    // Older Pi hooks may not support extension-provided compaction content.
-    return;
-  });
-
   const before = async (_ctx: any) => { if (pendingRebuild) { pendingRebuild = false; await bootstrap(); } };
   pi.on("message_end", async (event: MessageEndEvent, ctx: any) => {
     await before(ctx);
     const m = event.message;
     if (m.role !== "assistant" && m.role !== "toolResult") return;
     if (m.role === "assistant") lastAssistantStop = m.stopReason;
+    // A create_goal tool can establish ownership after agent_start.
+    const eligible = eligibleGoalId();
+    if (!accountingGoalId && (!startGoalId || startGoalId === eligible)) accountingGoalId = eligible;
+    if (!accountingGoalId || deps.goalCommit.current()?.goal.id !== accountingGoalId) return;
     let entryId = messageIds.get(m);
     if (!entryId) { entryId = `live-message:${++messageSeq}`; messageIds.set(m, entryId); }
     const message: Message = { ...m, entryId };
-    const recorded = deps.accounting.recordMessage(message);
-    if (recorded && !recorded.duplicate) {
-      const delta = recorded.delta;
-      await commitWithRetry({ type: "usage", input: delta.input, output: delta.output, cacheRead: delta.cacheRead, cacheWrite: delta.cacheWrite, unknownMessages: delta.unknownMessages });
-    }
+    if (!deps.accounting.hasMessage(entryId)) pendingUsage.set(entryId, { goalId: accountingGoalId, message });
+    await flushUsage();
   });
   pi.on("agent_settled", async (_event: AgentSettledEvent, ctx: any) => {
     await before(ctx);
+    if (!await flushUsage()) return; // No automatic work while usage persistence is unresolved.
+    accountingGoalId = null;
     const snapshot = deps.goalCommit.current();
     if (!snapshot) { steeredGoalId = null; steered = false; return; }
     const settledEpoch = epoch;
@@ -124,7 +150,12 @@ export function registerLifecycle(pi: PiEvents, deps: LifecycleDeps): void {
     await deps.continuation.onSettled(canSend);
   });
   pi.on("message_start", async (event: MessageStartEvent, ctx: any) => {
-    if (event.message.role === "user") { inputPending = false; invalidate(); }
+    if (event.message.role === "user") {
+      inputPending = false;
+      invalidate();
+      startGoalId = deps.goalCommit.current()?.goal.id ?? null;
+      accountingGoalId = eligibleGoalId();
+    }
     await before(ctx);
     await deps.continuation.onMessageStart(event.message);
   });

package/src/store.ts

@@ -3,7 +3,7 @@ export type BranchContext = { sessionManager: { getBranch(): readonly unknown[]
 export type PiCustomEntry = { type: "custom"; customType: string; data: unknown };
 export type PiAppender = { appendEntry(customType: string, data: unknown): unknown };
 export const VERSION = 1 as const;
-const entryTypes = new Set(["goal.created", "goal.transition", "goal.cleared", "goal.usage", "goal.continuation_sent", "goal.stale_turn", "goal.limit_config"]);
+const entryTypes = new Set(["goal.created", "goal.replaced", "goal.objective_updated", "goal.transition", "goal.cleared", "goal.usage", "goal.continuation_sent", "goal.stale_turn", "goal.limit_config"]);
 export function isEntry(entry: unknown): entry is Entry { return !!entry && typeof entry === "object" && (entry as { version?: unknown }).version === VERSION && entryTypes.has((entry as { type?: unknown }).type as string) && Number.isSafeInteger((entry as { seq?: unknown }).seq); }
 export function readBranch(ctx: BranchContext): Entry[] { return ctx.sessionManager.getBranch().filter((item): item is PiCustomEntry => { if (!item || typeof item !== "object") return false; const wrapped = item as Partial<PiCustomEntry>; return wrapped.type === "custom" && wrapped.customType === "pi-goal-next"; }).map(item => item.data).filter(isEntry); }
 export async function append(pi: PiAppender, entry: Entry): Promise<void> { if (!isEntry(entry)) throw new Error("unsupported journal version"); await pi.appendEntry("pi-goal-next", entry); }

package/src/tools.ts

@@ -40,7 +40,7 @@ export function registerGoalTools(piLike: PiLike, deps: GoalToolDeps): void {
       if (!params || typeof params.objective !== "string" || !params.objective.trim()) return result("Invalid objective: a non-empty objective is required.");
       const current = goalCommit.current();
       if (current && current.goal.status !== "complete") return result("Cannot create goal: an unfinished goal already exists.");
-      const revision = current?.revision ?? 0;
+      const revision = current?.revision ?? goalCommit.getRevision();
       const intent: Intent = { type: "create", id: newGoalId(), objective: params.objective, tokenBudget: params.token_budget ?? null };
       const r = await goalCommit.commit(intent, revision);
       return result(r.kind === "ok" ? "Goal created." : commitMessage(r));