mixdog 1.4.2 → 1.4.3

package/src/runtime/agent/orchestrator/runtime-core/goal-mutations.mjs

@@ -1,22 +1,18 @@
 /**
  * goal-mutations.mjs — the durable Goal state transitions: create, the
- * model/user status update (complete / blocked), task edits and abandon.
+ * model/user status update (complete / blocked) and abandon.
  * Each takes the shared runtime record (`ctx`) and commits through its store.
  */
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 
 import { compactSessionTitle } from './session-title.mjs';
-import { GOAL_TASK_SETTLED } from './goal-tool-defs.mjs';
-import { applyGoalTaskChanges, normalizeGoalTasks } from './goal-tasks.mjs';
 import {
   GOAL_FILE_VERSION,
   NO_DEADLINE_WARNING_MS,
-  activeElapsedMs,
   assertSessionId,
   checkpointActiveClock,
   clearTurnFailures,
-  goalTimeMode,
   parseGoalDuration,
   publicGoal,
   stopActiveClock,
@@ -33,6 +29,13 @@ export function goalFinished(goal) {
   return FINISHED_STATUSES.includes(goal.status);
 }
 
+/** A Goal that is neither running nor finished (paused, blocked, usage
+ *  limited, time budget reached): it waits for the user, who may clear or
+ *  replace it. */
+export function goalStalled(goal) {
+  return Boolean(goal) && goal.status !== 'active' && !goalFinished(goal);
+}
+
 /** Reject a write aimed at a Goal the caller no longer holds. */
 export function assertExpectedGoal(goal, expectedGoalId, what = 'update') {
   if (clean(expectedGoalId) && clean(expectedGoalId) !== clean(goal.id)) {
@@ -51,32 +54,18 @@ function initialTimeLimitMs(args, defaultTimeLimitMs) {
 function newGoalRecord(id, args, at, defaultTimeLimitMs) {
   const startTurn = args.startInCurrentTurn === true ? 1 : 0;
   const timeLimitMs = initialTimeLimitMs(args, defaultTimeLimitMs);
-  const initialTasks = Array.isArray(args.tasks)
-    ? normalizeGoalTasks(
-        args.tasks.filter((task) => clean(task?.text)),
-        [],
-        { strict: true }
-      )
-    : [];
   return {
     id: randomUUID(),
-    revision: 1,
-    objectiveRevision: 1,
-    tasksObjectiveRevision: 1,
     sessionId: id,
     objective: validateObjective(args.objective),
     title: compactSessionTitle(args.objective),
+    objectiveRevision: 0,
     status: 'active',
-    tasks: initialTasks,
     blocker: '',
     failureReason: '',
     failureCount: 0,
     turnCount: startTurn,
-    lastDropTurn: initialTasks.some((task) => task.status === 'dropped') ? startTurn : -1,
-    tasksUpdatedAt: initialTasks.length > 0 ? at : null,
     timeLimitMs,
-    // A stated budget commits that time; only an explicit cap permits early completion.
-    timeMode: goalTimeMode(args.timeMode, timeLimitMs > 0 ? 'duration' : 'max'),
     timeUsedMs: 0,
     deadlineWarnedMs: NO_DEADLINE_WARNING_MS,
     warningRevision: 0,
@@ -88,37 +77,8 @@ function newGoalRecord(id, args, at, defaultTimeLimitMs) {
   };
 }
 
-// Evidence gates the MODEL's completion claim, never the user's. A user
-// completing their own Goal is an act of authority: without this the only
-// user-side exit was deleting the Goal, which threw the record away.
-// Unfinished rows stay unfinished so the record stays honest.
-function assertCompletionEvidence(goal, at) {
-  if (goal.tasksObjectiveRevision !== goal.objectiveRevision) {
-    throw new Error(
-      'cannot complete Goal: objective changed; read goal status and reconcile the full task list with set_tasks first'
-    );
-  }
-  const tasks = normalizeGoalTasks(goal.tasks || []);
-  const incomplete = tasks.filter((task) => !GOAL_TASK_SETTLED.includes(task.status));
-  if (incomplete.length > 0) {
-    throw new Error(`cannot complete Goal: ${incomplete.length} durable tasks remain incomplete`);
-  }
-  const turnCount = Math.max(0, Math.floor(Number(goal.turnCount) || 0));
-  if (goal.lastDropTurn >= 0 && goal.lastDropTurn === turnCount) {
-    throw new Error(
-      'cannot complete Goal: a task was dropped this turn; only a user scope change retires ' +
-        'requested work, so finish that work or let the user confirm the change first'
-    );
-  }
-  if (goal.timeMode === 'duration' && goal.timeLimitMs > 0 && activeElapsedMs(goal, at) < goal.timeLimitMs) {
-    throw new Error(
-      'cannot complete Goal before the requested duration ends; keep working, or the user may explicitly complete the Goal'
-    );
-  }
-}
-
 export function createGoalMutations(ctx) {
-  const { root, now, defaultTimeLimitMs, turnGoalIds, turnStartedAt } = ctx;
+  const { root, now, defaultTimeLimitMs, turnGoalIds, turnStartedAt, turnObjectiveRevisions } = ctx;
 
   // The Goal owning the current turn keeps its open segment; any other stops.
   const settleActiveClock = (id, goal, at) => {
@@ -140,13 +100,14 @@ export function createGoalMutations(ctx) {
   const createGoal = async (sessionId, args = {}) => {
     const id = assertSessionId(sessionId);
     const record = ctx.readRecord(id);
-    if (record.goal && !goalFinished(record.goal)) {
+    const replaced = goalStalled(record.goal) && args.replace === true;
+    if (record.goal && !goalFinished(record.goal) && !replaced) {
       // Recovery is part of the message on purpose: without it a stopped Goal
       // (paused/blocked/limited) permanently blocked every later Goal in the
       // session, because the model owns no way to retire one.
       throw new Error(
         `cannot create a new Goal while an unfinished Goal exists (status ${record.goal.status}); ` +
-          'resume and finish it, or abandon it if the user redirected away from that objective'
+          'finish it, or ask the user to stop it from the Goal controls'
       );
     }
     const at = now();
@@ -154,17 +115,25 @@ export function createGoalMutations(ctx) {
     if (args.startInCurrentTurn === true) {
       goal.lastStartedAt = record.goal ? at : turnStartedAt.get(id) || at;
     }
+    if (replaced) {
+      // The user confirmed: the stalled Goal retires into history as stopped.
+      record.goal.status = 'stopped';
+      record.goal.stoppedAt = at;
+      record.goal.archivedAt = at;
+      record.goal.updatedAt = at;
+    }
     if (record.goal) await archiveFinishedGoal(id, record.goal);
     const created = await ctx.commit(id, goal);
     if (args.startInCurrentTurn === true) {
       turnGoalIds.set(id, goal.id);
       turnStartedAt.set(id, goal.lastStartedAt);
+      turnObjectiveRevisions.set(id, goal.objectiveRevision);
     }
     ctx.scheduleGoalTitle(id, goal);
     return created;
   };
 
-  const updateGoal = async (sessionId, args = {}, { user = false, expectedGoalId = '' } = {}) => {
+  const updateGoal = async (sessionId, args = {}, { expectedGoalId = '' } = {}) => {
     const id = assertSessionId(sessionId);
     const goal = ctx.requireGoal(id);
     assertExpectedGoal(goal, expectedGoalId, 'update');
@@ -180,7 +149,8 @@ export function createGoalMutations(ctx) {
       throw new Error('a completed Goal cannot change status; edit it or create a new Goal');
     }
     if (status === 'complete') {
-      if (!user) assertCompletionEvidence(goal, at);
+      // Completion is the model's claim after its own evidence audit (or
+      // the user's act of authority); the runtime never completes by itself.
       settleActiveClock(id, goal, at);
       goal.status = 'complete';
       goal.completedAt = at;
@@ -197,14 +167,6 @@ export function createGoalMutations(ctx) {
     return ctx.commit(id, goal);
   };
 
-  const setGoalTasks = async (sessionId, args = {}, { expectedGoalId = '', partial = false } = {}) => {
-    const id = assertSessionId(sessionId);
-    const goal = ctx.requireGoal(id);
-    assertExpectedGoal(goal, expectedGoalId, 'task update');
-    applyGoalTaskChanges(goal, args, { partial, at: now() });
-    return ctx.commit(id, goal);
-  };
-
   // Explicit retirement of a superseded Goal. The create guard stays strict so
   // parallel Goals stay impossible; this is the one way out of it, and it is
   // deliberately an act the model has to take rather than a silent overwrite.
@@ -224,8 +186,9 @@ export function createGoalMutations(ctx) {
     if (archive) goal.archivedAt = goal.stoppedAt;
     await ctx.commit(id, goal);
     turnGoalIds.delete(id);
+    turnObjectiveRevisions.delete(id);
     return publicGoal(goal, now());
   };
 
-  return { createGoal, updateGoal, setGoalTasks, abandonGoal };
+  return { createGoal, updateGoal, abandonGoal };
 }

package/src/runtime/agent/orchestrator/runtime-core/goal-reminder.mjs

@@ -13,6 +13,11 @@ import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { readStoredGoalSnapshot } from './goal-runtime.mjs';
 import { goalStateReminder } from './goal-text.mjs';
 import { clean } from './session-text.mjs';
+import { todoContextBlock } from './todo-list.mjs';
+
+// Stalled states the model is told about when they begin. Time-budget
+// exhaustion has its own one-time closeout notice (deadline-reached).
+const STALL_NOTICE_STATUSES = ['paused', 'blocked', 'usage_limited'];
 
 function pendingRevision(session) {
   return Math.max(0, Number(session?.pendingGoalReminder?.revision) || 0);
@@ -53,18 +58,38 @@ export function snapshotPendingGoalReminder(session, { dataDir = null, readGoal
   } catch {
     goal = null;
   }
+  if (goal?.status === 'complete') goal = null;
+  const marked = clean(session.pendingGoalReminder?.reason);
+  // A Goal that left the stalled states is told afresh if it stalls again.
+  if (!goal || goal.status === 'active') delete session.goalStalledNotice;
+  // A stalled Goal is told once, when it stalls; compaction does not
+  // re-inject it. Only a Goal that keeps running needs its state restored.
+  if (marked === 'compaction' && goal && goal.status !== 'active') goal = null;
+  // Compaction drops the todo tool results too: the open list rides once.
+  const todoBlock =
+    revision && marked === 'compaction'
+      ? todoContextBlock(session, 'Context was compacted; your todo list (exact wordings):')
+      : '';
   // Nothing left to remind about (no Goal, or it already finished): drop the
   // marker instead of re-reading the same file on every later turn.
-  if (!goal || goal.status === 'complete') {
+  if (!goal && !todoBlock) {
     clearPendingGoalReminder(session);
     return null;
   }
   if (!revision) {
-    if (!['paused', 'blocked'].includes(goal.status)) return null;
+    if (!STALL_NOTICE_STATUSES.includes(goal.status)) return null;
+    // One notice per stall: a later pause, block or limit of the same Goal
+    // (a turn ran in between) is a new stall.
+    const stall = `${goal.id}:${goal.status}:${Math.max(0, Number(goal.turnCount) || 0)}`;
+    if (session.goalStalledNotice === stall) return null;
+    session.goalStalledNotice = stall;
     revision = markPendingGoalReminder(session, goal.status).revision;
   }
   const reason = clean(session.pendingGoalReminder?.reason);
-  const content = goalStateReminder(goal, { reason });
+  const goalContent = goal ? goalStateReminder(goal, { reason }) : '';
+  const content = [goalContent, todoBlock ? `<system-reminder>\n${todoBlock}\n</system-reminder>` : '']
+    .filter(Boolean)
+    .join('\n\n');
   if (!content) {
     clearPendingGoalReminder(session);
     return null;

package/src/runtime/agent/orchestrator/runtime-core/goal-runtime.mjs

@@ -29,12 +29,16 @@ export {
   MAX_GOAL_TIME_LIMIT_MS,
   parseGoalDuration,
 };
-export { GOAL_STATUS_VALUES } from './goal-state.mjs';
 export { listStoredActiveGoalSessionIds, readStoredGoalSnapshot } from './goal-storage.mjs';
 
 export function createGoalRuntime({
   dataDir,
-  now = () => Date.now(),
+  now: injectedNow,
+  // Suspend evidence needs a monotonic clock paired with the wall clock. An
+  // injected `now` has no real pair, so a test supplies its own or none. A test
+  // that fakes `Date` must pass `monotonicNow: null` (undefined takes the default).
+  monotonicNow = injectedNow ? null : () => performance.now(),
+  suspendDetectable,
   defaultTimeLimitMs = DEFAULT_GOAL_TIME_LIMIT_MS,
   completedGoalTtlMs = DEFAULT_COMPLETED_GOAL_TTL_MS,
   deadlineWarningMs = DEFAULT_GOAL_DEADLINE_WARNING_MS,
@@ -42,6 +46,7 @@ export function createGoalRuntime({
   writeGoalRecord,
   onStorageError = reportGoalStorageError,
 } = {}) {
+  const now = injectedNow ?? (() => Date.now());
   const ctx = {
     dataDir,
     root: goalsRoot(dataDir),
@@ -55,15 +60,15 @@ export function createGoalRuntime({
     mutationChains: new Map(),
     turnGoalIds: new Map(),
     turnStartedAt: new Map(),
+    // Session -> the objective revision the current turn has seen (turn start,
+    // a status read, or a refusal that showed it). In memory like the turn.
+    turnObjectiveRevisions: new Map(),
     titleJobs: new Map(),
-    observedGoals: new Map(),
-    // Session -> the Goal identity, turn, and revision already answered with
-    // no progress: the one settled-duration review, or an automatic turn that
-    // called no tool. In memory on purpose: a restart is a new chance.
+    // Session -> the Goal identity and turn an automatic turn answered with no
+    // tool call. In memory on purpose: a restart is a new chance.
     idleReviewTurns: new Map(),
-    // Session -> { goalId, revision, quietTurns }: which continuation tier this
-    // context still owes, from the rules and state already delivered into it.
-    // In memory on purpose: a restart is a fresh context that needs them again.
+    // Session -> id of the Goal whose full continuation rules this context
+    // already holds. In memory on purpose: a restart is a fresh context.
     continuationTiers: new Map(),
     // Session -> Goal id whose turn ended in a stop (failed, cancelled, usage
     // limit) the record could not save. The record still reads active, so
@@ -74,11 +79,14 @@ export function createGoalRuntime({
   Object.assign(ctx, createGoalStore(ctx));
   ctx.deadlines = createGoalDeadlines({
     now,
-    readRecord: ctx.readRecord,
+    readRecord: ctx.readStoredRecord,
     withMutation: ctx.withMutation,
     commit: ctx.commit,
+    stampLive: ctx.stampLive,
     onStorageError,
     deadlineWarningMs,
+    monotonicNow,
+    ...(suspendDetectable !== undefined ? { suspendDetectable } : {}),
   });
   ctx.scheduleGoalTitle = createGoalTitleScheduler(ctx);
   Object.assign(ctx, createGoalMutations(ctx));
@@ -109,6 +117,23 @@ export function createGoalRuntime({
       return withMutation(sessionId, () => ctx.control(sessionId, args));
     },
     executeTool: (name, args = {}, context = {}) => executeGoalTool(ctx, name, args, context),
+    // Tasks a legacy record still carries for the session's todo list to
+    // adopt; [] once adopted (clearLegacyTasks).
+    legacyTasks(sessionId) {
+      try {
+        return ctx.readRecord(sessionId).goal?.legacyTasks || [];
+      } catch {
+        return [];
+      }
+    },
+    clearLegacyTasks(sessionId) {
+      return withMutation(sessionId, async (id) => {
+        const goal = ctx.readRecord(id).goal;
+        if (!goal?.legacyTasks?.length) return null;
+        goal.legacyTasks = [];
+        return ctx.commit(id, goal);
+      });
+    },
     ...createGoalTurnLifecycle(ctx),
     close() {
       ctx.closed = true;
@@ -117,7 +142,7 @@ export function createGoalRuntime({
       deadlines.close();
       ctx.turnGoalIds.clear();
       ctx.turnStartedAt.clear();
-      ctx.observedGoals.clear();
+      ctx.turnObjectiveRevisions.clear();
       ctx.idleReviewTurns.clear();
       ctx.continuationTiers.clear();
       ctx.unsavedStops.clear();

package/src/runtime/agent/orchestrator/runtime-core/goal-state.mjs

@@ -2,7 +2,6 @@ import { randomUUID } from 'node:crypto';
 import { clean } from '../../../shared/clean.mjs';
 import { compactSessionTitle } from './session-title.mjs';
 import { MAX_GOAL_TIME_LIMIT_MS } from './goal-tool-defs.mjs';
-import { goalTaskProgress, normalizeGoalTasks } from './goal-tasks.mjs';
 import { SESSION_ID_PATTERN } from './session-id.mjs';
 
 export const DEFAULT_GOAL_TIME_LIMIT_MS = 0;
@@ -10,6 +9,9 @@ export const DEFAULT_COMPLETED_GOAL_TTL_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_GOAL_DEADLINE_WARNING_MS = Object.freeze([10 * 60_000, 5 * 60_000]);
 export const NO_DEADLINE_WARNING_MS = Number.MAX_SAFE_INTEGER;
 export const GOAL_FILE_VERSION = 1;
+// A live runtime re-stamps an active Goal's `liveAt` this often; a longer gap
+// means nothing was running it (app closed, PC asleep).
+export const GOAL_LIVE_HEARTBEAT_MS = 60_000;
 export const SESSION_ID = SESSION_ID_PATTERN;
 export const GOAL_STATUS_VALUES = Object.freeze([
   'active',
@@ -23,14 +25,6 @@ export const GOAL_STATUS_VALUES = Object.freeze([
 
 const MAX_OBJECTIVE_LENGTH = 4_000;
 const MAX_GOAL_BLOCKER_LENGTH = 1_000;
-const ACTIVE_AGENT_STATUSES = new Set([
-  'connecting',
-  'requesting',
-  'streaming',
-  'tool_running',
-  'running',
-  'cancelling',
-]);
 
 export function assertSessionId(value) {
   const sessionId = clean(value);
@@ -56,12 +50,6 @@ export function validateGoalBlocker(value) {
   return blocker;
 }
 
-export function goalTimeMode(value, fallback = 'max') {
-  if (value == null || value === '') return fallback;
-  if (!['max', 'duration'].includes(value)) throw new Error('goal timeMode must be max or duration');
-  return value;
-}
-
 export function parseGoalDuration(value) {
   if (typeof value === 'number') {
     if (!Number.isFinite(value) || value <= 0) throw new Error('goal duration must be positive');
@@ -100,12 +88,10 @@ export function parseUserCommand(command) {
 
   let objective = value;
   let duration = null;
-  let timeMode = null;
-  const modeMatch = objective.match(/(?:^|\s)--time-mode(?:=|\s+)([^\s]+)/i);
-  if (modeMatch) {
-    timeMode = goalTimeMode(modeMatch[1]);
-    objective = objective.replace(modeMatch[0], ' ').trim();
-  }
+  // The user's confirmation that a new Goal replaces a stalled one, naming it:
+  // `--replace=<goal id>`.
+  const replaceMatch = objective.match(/(?:^|\s)--replace(?:=(\S+))?(?=\s|$)/i);
+  if (replaceMatch) objective = objective.replace(replaceMatch[0], ' ').trim();
   const equalsMatch = objective.match(/(?:^|\s)--time=([^\s]+)/i);
   if (equalsMatch) {
     duration = equalsMatch[1];
@@ -117,7 +103,12 @@ export function parseUserCommand(command) {
       objective = objective.replace(spacedMatch[0], ' ').trim();
     }
   }
-  return { action: 'create', objective, duration, timeMode };
+  return {
+    action: 'create',
+    objective,
+    duration,
+    ...(replaceMatch ? { replace: true, ...(replaceMatch[1] ? { expectedGoalId: replaceMatch[1] } : {}) } : {}),
+  };
 }
 
 function storedTimeLimitMs(value) {
@@ -125,11 +116,19 @@ function storedTimeLimitMs(value) {
   return Number.isFinite(stored) && stored > 0 ? Math.min(MAX_GOAL_TIME_LIMIT_MS, Math.max(60_000, stored)) : 0;
 }
 
-// Dropped work must survive the turn that removed it before completion.
-function storedLastDropTurn(value) {
-  const dropped =
-    value.revision != null || value.lastDropTurn !== 0 || (value.tasks || []).some((task) => task.status === 'dropped');
-  return Number.isInteger(value.lastDropTurn) && dropped ? value.lastDropTurn : -1;
+// Tasks a record written before the todo list carried: kept on the record
+// only until the session's todo list adopts them (todo-list.mjs).
+function storedLegacyTasks(value) {
+  const tasks = value.legacyTasks ?? value.tasks ?? value.criteria;
+  return Array.isArray(tasks) && tasks.length
+    ? tasks
+        .filter((task) => task && typeof task === 'object' && clean(task.text ?? task.content))
+        .map((task) => ({
+          text: clean(task.text ?? task.content),
+          // A criterion written before task statuses carried `satisfied`.
+          status: clean(task.status) || (task.satisfied === true ? 'completed' : 'pending'),
+        }))
+    : [];
 }
 
 export function normalizeStoredGoal(value, sessionId, resumedAt = Date.now()) {
@@ -139,31 +138,35 @@ export function normalizeStoredGoal(value, sessionId, resumedAt = Date.now()) {
   if (!GOAL_STATUS_VALUES.includes(status)) throw new Error(`invalid stored Goal status: ${status}`);
   return {
     id: clean(value.id) || randomUUID(),
-    revision: Math.max(1, Math.floor(Number(value.revision) || 1)),
-    objectiveRevision: Math.max(1, Math.floor(Number(value.objectiveRevision) || 1)),
-    tasksObjectiveRevision: Math.max(1, Math.floor(Number(value.tasksObjectiveRevision) || 1)),
     sessionId,
     objective: validateObjective(value.objective),
     title: compactSessionTitle(value.title || value.objective),
+    // Advances on every objective edit, so a settlement can tell whether the
+    // turn it answers saw the current wording.
+    objectiveRevision: Math.max(0, Math.floor(Number(value.objectiveRevision) || 0)),
     status,
-    tasks: normalizeGoalTasks(value.tasks ?? value.criteria ?? []),
+    legacyTasks: storedLegacyTasks(value),
     blocker: clean(value.blocker),
     pauseReason: ['waiting', 'cancelled'].includes(value.pauseReason) ? value.pauseReason : 'user',
     failureReason: clean(value.failureReason),
     failureCount: Math.max(0, Math.floor(Number(value.failureCount) || 0)),
     // Observations report progress; they never decide when work is complete.
     turnCount: Math.max(0, Math.floor(Number(value.turnCount) || 0)),
-    lastDropTurn: storedLastDropTurn(value),
-    tasksUpdatedAt: Number(value.tasksUpdatedAt) > 0 ? Number(value.tasksUpdatedAt) : null,
     timeLimitMs: storedTimeLimitMs(value),
-    // Unversioned durations retain their original full-period commitment.
-    timeMode: goalTimeMode(value.timeMode, 'duration'),
-    timeUsedMs: Math.max(0, Number(value.timeUsedMs) || 0),
+    // Time is an upper bound only: a legacy `duration` record reads as a cap.
+    // A record exhausted by an older build may carry wall-clock time past its
+    // cap; the cap is what was spent.
+    timeUsedMs: cappedTimeUsedMs(
+      status === 'duration_reached' ? storedTimeLimitMs(value) : 0,
+      Math.max(0, Number(value.timeUsedMs) || 0)
+    ),
     createdAt: Math.max(0, Number(value.createdAt) || Date.now()),
     updatedAt: Math.max(0, Number(value.updatedAt) || Date.now()),
     // Preserve the open segment across task writes, eviction, and restart.
     lastStartedAt:
       status === 'active' ? Math.max(0, Number(value.lastStartedAt) || Number(resumedAt) || Date.now()) : null,
+    // The last moment a live runtime was running this Goal's open segment.
+    liveAt: Math.max(0, Number(value.liveAt) || 0),
     completedAt: Number(value.completedAt) > 0 ? Number(value.completedAt) : null,
     stoppedAt: Number(value.stoppedAt) > 0 ? Number(value.stoppedAt) : null,
     archivedAt: Number(value.archivedAt) > 0 ? Number(value.archivedAt) : null,
@@ -172,6 +175,51 @@ export function normalizeStoredGoal(value, sessionId, resumedAt = Date.now()) {
   };
 }
 
+function cappedTimeUsedMs(limitMs, usedMs) {
+  return limitMs > 0 ? Math.min(limitMs, usedMs) : usedMs;
+}
+
+/** Drop the part of an active Goal's open segment that no live runtime ran
+ *  (the app was closed, the PC slept): the segment start moves forward by the
+ *  unobserved gap. Returns whether anything was dropped. */
+export function discardUnobservedTime(goal, at, toleranceMs = 0) {
+  if (goal?.status !== 'active' || !(Number(goal.lastStartedAt) > 0)) return false;
+  const seenAt = Math.max(Number(goal.lastStartedAt), Number(goal.liveAt) || 0);
+  const gap = at - seenAt;
+  // The tolerance covers heartbeat jitter inside a live runtime only; a load
+  // after downtime passes none, so no closed-app interval is ever credited.
+  if (gap <= toleranceMs) return false;
+  goal.lastStartedAt = Number(goal.lastStartedAt) + gap;
+  goal.liveAt = at;
+  return true;
+}
+
+/** Drop `suspendedMs` — time a live runtime provably did not run (the OS was
+ *  suspended) — from an active Goal's open segment, never more than the gap
+ *  since it was last seen. Returns whether anything was dropped. */
+export function discardSuspendedTime(goal, at, suspendedMs) {
+  if (goal?.status !== 'active' || !(Number(goal.lastStartedAt) > 0)) return false;
+  const seenAt = Math.max(Number(goal.lastStartedAt), Number(goal.liveAt) || 0);
+  const dropped = Math.min(Math.floor(Number(suspendedMs) || 0), Math.max(0, at - seenAt));
+  if (!(dropped > 0)) return false;
+  goal.lastStartedAt = Number(goal.lastStartedAt) + dropped;
+  goal.liveAt = at;
+  return true;
+}
+
+/** The Goal as a reader without a runtime sees it. Such a reader cannot know
+ *  whether anything is running the Goal, so it uses no clock: the open
+ *  segment counts only up to `liveAt`, the last moment a runtime persisted as
+ *  having run it (at most one heartbeat behind). That makes the usage a pure
+ *  function of the record — never above what the runtime has stored, never
+ *  charging downtime, never moving backward between reads. */
+export function freezeUnobservedSegment(goal) {
+  if (goal?.status !== 'active' || !(Number(goal.lastStartedAt) > 0)) return;
+  const observedMs = Math.max(0, (Number(goal.liveAt) || 0) - Number(goal.lastStartedAt));
+  goal.timeUsedMs = Math.max(0, Number(goal.timeUsedMs) || 0) + observedMs;
+  goal.lastStartedAt = null;
+}
+
 export function activeElapsedMs(goal, now = Date.now()) {
   const committed = Math.max(0, Number(goal?.timeUsedMs) || 0);
   if (goal?.status !== 'active' || !(Number(goal?.lastStartedAt) > 0)) return committed;
@@ -186,28 +234,23 @@ export function normalizeDeadlineWarnedMs(value) {
 
 export function publicGoal(goal, now = Date.now()) {
   if (!goal) return null;
-  const timeUsedMs = activeElapsedMs(goal, now);
   const hasTimeLimit = Number(goal.timeLimitMs) > 0;
+  // Never above the cap: a read that lands after the deadline but before the
+  // expiry commit reports the cap, not the overshoot.
+  const timeUsedMs = cappedTimeUsedMs(Number(goal.timeLimitMs) || 0, activeElapsedMs(goal, now));
   const remainingMs = hasTimeLimit ? Math.max(0, Number(goal.timeLimitMs) - timeUsedMs) : null;
-  const tasks = normalizeGoalTasks(goal.tasks || []);
   return {
     id: goal.id,
-    revision: goal.revision,
-    // Warning delivery does not invalidate the actionable task revision.
+    // Advances once per delivered deadline warning (deadline-delivery.mjs).
     warningRevision: Math.max(0, Math.floor(Number(goal.warningRevision) || 0)),
-    needsTaskReview: goal.tasksObjectiveRevision !== goal.objectiveRevision,
     sessionId: goal.sessionId,
     objective: goal.objective,
     title: goal.title || compactSessionTitle(goal.objective),
     status: goal.status,
-    tasks,
     turnCount: Math.max(0, Math.floor(Number(goal.turnCount) || 0)),
-    tasksUpdatedAt: Number(goal.tasksUpdatedAt) > 0 ? Number(goal.tasksUpdatedAt) : null,
-    ...goalTaskProgress(tasks),
     blocker: goal.blocker || '',
     pauseReason: goal.pauseReason || 'user',
     timeLimitMs: goal.timeLimitMs,
-    timeMode: goal.timeMode,
     timeUsedMs,
     remainingMs,
     deadlineAt: hasTimeLimit && goal.status === 'active' && goal.lastStartedAt ? now + remainingMs : null,
@@ -310,14 +353,3 @@ export function resumeGoalState(goal, at, added = null) {
 export function startActiveClock(goal, now = Date.now()) {
   if (goal.status === 'active' && !goal.lastStartedAt) goal.lastStartedAt = now;
 }
-
-export function runningAgentWork(agentStatus) {
-  const jobs = Array.isArray(agentStatus?.agentJobs) ? agentStatus.agentJobs : [];
-  if (jobs.some((job) => clean(job?.status).toLowerCase() === 'running')) return true;
-  const workers = Array.isArray(agentStatus?.agentWorkers) ? agentStatus.agentWorkers : [];
-  return workers.some((worker) => {
-    const status = clean(worker?.status).toLowerCase();
-    const stage = clean(worker?.stage || worker?.worker_stage).toLowerCase();
-    return ACTIVE_AGENT_STATUSES.has(status) || ACTIVE_AGENT_STATUSES.has(stage);
-  });
-}

package/src/runtime/agent/orchestrator/runtime-core/goal-storage.mjs

@@ -15,6 +15,7 @@ import {
   SESSION_ID,
   assertSessionId,
   completedGoalExpired,
+  freezeUnobservedSegment,
   normalizeStoredGoal,
   publicGoal,
 } from './goal-state.mjs';
@@ -40,7 +41,9 @@ export function deleteStoredGoalFile(dataDir, sessionId) {
 function readStoredGoalFile(dataDir, sessionId, at = Date.now()) {
   const id = assertSessionId(sessionId);
   try {
-    return readGoalRecordFile(goalFilePath(dataDir, id), id, normalizeStoredGoal, at).goal;
+    const goal = readGoalRecordFile(goalFilePath(dataDir, id), id, normalizeStoredGoal, at).goal;
+    freezeUnobservedSegment(goal);
+    return goal;
   } catch (error) {
     reportGoalStorageError(error);
     return null;