🤖 fix: stop heartbeats and background wakes from pausing goals

src/cli/run.ts

@@ -832,6 +832,7 @@ async function main(): Promise<number> {
   });
 
   let goalStopReason: string | null = null;
+  let cliGoalId: string | undefined;
   if (hasGoal) {
     const setGoalResult = await workspaceGoalService.setGoal({
       workspaceId,
@@ -843,6 +844,7 @@ async function main(): Promise<number> {
     if (!setGoalResult.success) {
       throw new Error(`Failed to set CLI goal: ${setGoalResult.error.type}`);
     }
+    cliGoalId = setGoalResult.data.goalId;
     const warning =
       goalBudgetCents == null && goalTurnCap == null
         ? "CLI Goal Run has no --goal-budget or --goal-turns limit. It will continue until the goal is complete or another stop condition occurs."
@@ -1023,6 +1025,7 @@ async function main(): Promise<number> {
             synthetic: true,
             agentInitiated: true,
             goalKind: GOAL_CONTINUATION_KIND,
+            goalId: cliGoalId,
             goalContinuation: true,
           }
         : undefined

src/common/orpc/schemas/goal.ts

@@ -26,9 +26,16 @@ export const GoalBudgetLimitOriginKindSchema = z
   .enum(["goal_continuation", "goal_budget_limit", "user", "other"])
   .nullable();
 
+/**
+ * Durable goal identifiers are always UUIDs (`crypto.randomUUID()` at
+ * creation). Share this schema wherever an unchecked value claims to be a
+ * goal ID so validation stays as strict as the persisted record contract.
+ */
+export const GoalIdSchema = z.string().uuid();
+
 export const GoalRecordV1Schema = z.object({
   version: z.literal(1),
-  goalId: z.string().uuid(),
+  goalId: GoalIdSchema,
   objective: z.string().min(1),
   status: GoalStatusSchema,
   budgetCents: z.number().int().nonnegative().nullable(),
@@ -47,6 +54,16 @@ export const GoalRecordV1Schema = z.object({
   budgetLimitOriginKind: GoalBudgetLimitOriginKindSchema.optional(),
   requireUserAcknowledgmentSinceMs: z.number().int().nonnegative().nullable(),
   lastContinuationFiredAtMs: z.number().int().nonnegative().nullable().optional(),
+  // Timestamp of the last EXPLICIT user action that made this goal active
+  // (direct create, Resume, board promote — never model set_goal,
+  // auto-promotion, or accounting re-arms). This is the consent anchor for
+  // the queue-race pause bypasses: a manual message authored before this
+  // moment was visibly pending when the user activated the goal, which is a
+  // genuine opt-in. Optional so legacy records load without migration; goals
+  // without it (including every model-created goal) FAIL CLOSED — a queued
+  // manual message always pauses them (Codex security P2
+  // PRRT_kwDOPxxmWM6cSGrq).
+  lastUserActivationAtMs: z.number().int().nonnegative().nullable().optional(),
   completionSummary: z.string().optional(),
   createdAtMs: z.number().int().nonnegative(),
   updatedAtMs: z.number().int().nonnegative(),

src/common/types/goal.ts

@@ -11,6 +11,25 @@ import type {
   GoalSnapshotSchema,
   GoalStatusSchema,
 } from "@/common/orpc/schemas/goal";
+import { GoalIdSchema } from "@/common/orpc/schemas/goal";
+
+/**
+ * Defensive validation for goal-scoping IDs read from unchecked persisted
+ * metadata (chat.jsonl rows, compaction summaries). Durable goal IDs are
+ * always UUIDs (see GoalIdSchema), so any non-UUID value is corrupt data —
+ * not another goal's identity (Codex P2 PRRT_kwDOPxxmWM6cNxUY,
+ * PRRT_kwDOPxxmWM6cRJEC).
+ *
+ * Callers treat a present-but-invalid ID by failure direction (Codex P2
+ * PRRT_kwDOPxxmWM6cOHpI): a pause BOUNDARY degrades to legacy unscoped
+ * semantics (conservative paused, never scoped), a CONTINUATION row is
+ * skipped outright (corrupt data must not manufacture activity evidence),
+ * and recovery paths discard the row's goal attribution entirely.
+ */
+export function toValidGoalId(value: unknown): string | null {
+  const parsed = GoalIdSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
 
 export type GoalStatus = z.infer<typeof GoalStatusSchema>;
 export type GoalRecordV1 = z.infer<typeof GoalRecordV1Schema>;

src/common/types/message.ts

@@ -103,6 +103,13 @@ export type StartupRetrySendOptions = Pick<
   agentInitiated?: boolean;
   /** Internal goal continuation classification for startup auto-retry accounting. */
   goalKind?: GoalSyntheticMessageKind;
+  /**
+   * Goal identity matching `goalKind`. Not persisted by
+   * pickStartupRetrySendOptions (the user row's own metadata.goalId is the
+   * durable copy); startup recovery re-derives it so resumed streams keep
+   * goal-scoped compaction follow-ups (Codex P2 PRRT_kwDOPxxmWM6cIv2E).
+   */
+  goalId?: string;
 };
 
 /**
@@ -164,6 +171,13 @@ export interface CompactionFollowUpRequest extends CompactionFollowUpInput, Pres
   agentInitiated?: boolean;
   /** Internal goal continuation classification for synthetic follow-up accounting. */
   goalKind?: GoalSyntheticMessageKind;
+  /**
+   * Goal identity matching `goalKind`. Preserved through compaction so the
+   * re-dispatched follow-up row stays goal-scoped for chat-tail
+   * reconciliation instead of degrading to a legacy unscoped row (Codex P2
+   * PRRT_kwDOPxxmWM6cIv2E).
+   */
+  goalId?: string;
   /** Internal dispatch guardrails for crash-safe follow-up recovery. */
   dispatchOptions?: CompactionFollowUpDispatchOptions;
   /**
@@ -598,6 +612,14 @@ export type MuxMessageMetadata = MuxMessageMetadataBase &
       }
     | {
         type: "goal-pause-boundary";
+        /**
+         * Goal this boundary pauses. Chat-tail reconciliation ignores
+         * boundaries stamped for a different goal so a stale pause finalizer
+         * racing a replacement cannot silently pause the newer goal (Codex P2
+         * PRRT_kwDOPxxmWM6cEl4F). Optional for legacy rows, which keep the
+         * old any-goal semantics.
+         */
+        goalId?: string;
       }
     | {
         // Durable, provider-visible summary of an abandoned history branch
@@ -829,6 +851,13 @@ export interface MuxMetadata {
   systemMessageTokens?: number; // Token count for system message sent with this request (calculated by AIService)
   partial?: boolean; // Whether this message was interrupted and is incomplete
   synthetic?: boolean; // Whether this message was synthetically generated (e.g., [CONTINUE] sentinel)
+  /**
+   * For queue-dispatched user turns: when the user last added to the queued
+   * entry. The row `timestamp` is stamped at dispatch (after the blocking turn
+   * ends), so goal safety needs this to durably tell messages typed before a
+   * mid-turn goal existed from genuine interventions against a visible goal.
+   */
+  enqueuedAtMs?: number;
   /**
    * UI hint: show in the chat UI even when synthetic.
    *
@@ -867,6 +896,14 @@ export interface MuxMetadata {
   muxMetadata?: MuxMessageMetadata; // Command metadata used by both frontend and backend message flows
   /** Persisted discriminator for synthetic user turns created by the active-goal loop. */
   kind?: "goal_continuation" | "goal_budget_limit";
+  /**
+   * Goal identity for `kind` rows. Chat-tail reconciliation only accepts a
+   * continuation row as "goal is active" evidence when it was dispatched for
+   * the goal being reconciled — a replaced goal's continuation must not
+   * reactivate its successor (Codex P2 PRRT_kwDOPxxmWM6cH3kV). Legacy rows
+   * without a goalId keep the old any-goal semantics.
+   */
+  goalId?: string;
 
   /**
    * ACP-only correlation id propagated through stream events so prompt() can

src/node/services/agentSession.autoCompaction.test.ts

@@ -303,7 +303,7 @@ describe("AgentSession on-send auto-compaction snapshot deferral", () => {
     expect(unstamped).toBeUndefined();
   });
 
-  test("preserves goal kind on auto-compaction follow-up requests", async () => {
+  test("preserves goal kind and goal identity on auto-compaction follow-up requests", async () => {
     const { session } = await createSessionHarness({
       workspaceId: "ws-auto-compaction-goal-kind",
     });
@@ -315,16 +315,21 @@ describe("AgentSession on-send auto-compaction snapshot deferral", () => {
           options: SendMessageOptions;
           modelForStream: string;
           goalKind?: typeof GOAL_CONTINUATION_KIND;
+          goalId?: string;
         }) => CompactionFollowUpRequest;
       }
     ).buildAutoCompactionFollowUp({
       messageText: "Continue goal",
       options: { model: "openai:gpt-4o", agentId: "exec" },
       modelForStream: "openai:gpt-4o",
       goalKind: GOAL_CONTINUATION_KIND,
+      goalId: "goal-compaction-scope",
     });
 
     expect(followUp.goalKind).toBe(GOAL_CONTINUATION_KIND);
+    // Codex P2 (PRRT_kwDOPxxmWM6cIv2E): the re-dispatched follow-up row must
+    // stay goal-scoped instead of degrading to a legacy unscoped row.
+    expect(followUp.goalId).toBe("goal-compaction-scope");
     session.dispose();
   });
 

src/node/services/agentSession.budgetGate.test.ts

@@ -261,6 +261,46 @@ describe("AgentSession.sendMessage budget gate", () => {
     session.dispose();
   });
 
+  test("rejected queued sends persist authoring metadata and pre-goal rows do not pause the goal", async () => {
+    // Queue race on the rejection path: a message the user typed before the
+    // goal existed can be rejected by the pricing gate when it dispatches
+    // after the goal-creating turn. The persisted row must carry authoring
+    // metadata (timestamp + enqueuedAtMs) so goal-safety reconciliation still
+    // classifies it as pre-goal after a restart, and the dispatch-time hook
+    // must leave the fresh goal active.
+    const workspaceId = "as-budget-gate-queued-pre-goal";
+    const { historyService, session, goalService, cleanup } =
+      await createSessionHarness(workspaceId);
+    cleanups.push(cleanup);
+
+    const enqueuedAtMs = Date.now() - 1;
+    await setGoalOk(goalService, {
+      workspaceId,
+      objective: "Stay under budget",
+      budgetCents: 500,
+    });
+
+    const result = await session.sendMessage("Typed before the goal existed", UNPRICED_OPTIONS, {
+      enqueuedAtMs,
+    });
+    expect(result.success).toBe(false);
+
+    const history = await historyService.getHistoryFromLatestBoundary(workspaceId);
+    expect(history.success).toBe(true);
+    if (history.success) {
+      const userMessage = history.data.find((m) => m.role === "user");
+      expect(typeof userMessage?.metadata?.timestamp).toBe("number");
+      expect(userMessage?.metadata?.enqueuedAtMs).toBe(enqueuedAtMs);
+    }
+
+    // Dispatch-time guard: no pause. getGoal also re-runs chat-tail
+    // reconciliation against the persisted row, exercising the durable
+    // enqueuedAtMs path.
+    expect(await goalService.getGoal(workspaceId)).toMatchObject({ status: "active" });
+
+    session.dispose();
+  });
+
   test("empty manual rejected send does NOT pause an active goal", async () => {
     // Codex P2 (PRRT_kwDOPxxmWM5_tUsx): an accidental blank submit must not
     // silently disable goal continuation. The pre-stream gate runs before the

src/node/services/agentSession.continueMessageAgentId.test.ts

@@ -281,6 +281,33 @@ describe("AgentSession continue-message agentId fallback", () => {
     expect(historyResult.data.map((message) => message.id)).toEqual(["before-reset"]);
   });
 
+  test("dispatchPendingFollowUp rolls back heartbeat boundaries when a service send is in preflight", async () => {
+    // Codex P2 (PRRT_kwDOPxxmWM6cRi_N): a manual service-level send still in
+    // preflight is user contention too — the heartbeat reset boundary must be
+    // rolled back (as for queued input), not left in history with the
+    // follow-up silently cleared.
+    const earlierMessage = createMuxMessage("before-reset", "assistant", "Earlier context");
+    const { session, historyService, internals } = await createSession([
+      earlierMessage,
+      heartbeatBoundaryMessage(),
+    ]);
+    internals.sendMessage = mock(() => Promise.resolve({ success: true as const }));
+    (session as unknown as { hasExternalSendPreflight?: () => boolean }).hasExternalSendPreflight =
+      () => true;
+
+    const dispatched = await internals.dispatchPendingFollowUp();
+
+    expect(dispatched).toBe(false);
+    expect(internals.sendMessage).not.toHaveBeenCalled();
+
+    const historyResult = await historyService.getLastMessages("ws", 10);
+    expect(historyResult.success).toBe(true);
+    if (!historyResult.success) {
+      throw new Error(`Expected history read to succeed: ${historyResult.error}`);
+    }
+    expect(historyResult.data.map((message) => message.id)).toEqual(["before-reset"]);
+  });
+
   test("dispatchPendingFollowUp skips idle-only follow-ups when a new turn is already active", async () => {
     const { historyService, internals } = await createSession([
       compactionSummaryMessage("summary-active-turn", idleFollowUp()),

src/node/services/agentSession.disposeRace.test.ts

@@ -553,7 +553,7 @@ describe("AgentSession disposal race conditions", () => {
       (
         _message: string,
         _options?: { model: string; agentId: string },
-        _internal?: { synthetic?: boolean }
+        _internal?: { synthetic?: boolean; enqueuedAtMs?: number }
       ) => Promise.resolve(Ok(undefined))
     );
 
@@ -567,10 +567,12 @@ describe("AgentSession disposal race conditions", () => {
     session.sendQueuedMessages();
 
     expect(sendMessage).toHaveBeenCalledTimes(1);
-    expect(sendMessage).toHaveBeenCalledWith(
-      "Background compaction request",
-      expect.objectContaining({ model: "anthropic:claude-sonnet-4-5", agentId: "compact" }),
-      { synthetic: true }
-    );
+    const [text, options, internal] = sendMessage.mock.calls[0] ?? [];
+    expect(text).toBe("Background compaction request");
+    expect(options).toMatchObject({ model: "anthropic:claude-sonnet-4-5", agentId: "compact" });
+    // Queue dispatch stamps enqueuedAtMs alongside preserved internal flags
+    // (goal safety uses it to detect messages that predate a fresh goal).
+    expect(internal?.synthetic).toBe(true);
+    expect(typeof internal?.enqueuedAtMs).toBe("number");
   });
 });