mixdog 0.9.174 → 1.0.0

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

@@ -0,0 +1,145 @@
+// Reasoning-effort catalogs and coercion. Pure helpers.
+import { clean } from './session-text.mjs';
+
+const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
+const ALL_EFFORT_LEVELS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const EFFORT_LABELS = {
+  none: 'None',
+  minimal: 'Minimal',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+  ultra: 'Ultra',
+};
+
+const EFFORT_OPTIONS_BY_PROVIDER = {
+  openai: ['none', 'low', 'medium', 'high', 'xhigh'],
+  // gpt-5.6+ catalogs declare max/ultra; the openai-oauth transport folds
+  // ultra -> max on the wire (openai-oauth.mjs _normalizeReasoningEffort).
+  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
+  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
+  // xAI Grok 4.6+: low/medium/high/xhigh. Reasoning cannot be disabled.
+  xai: ['low', 'medium', 'high', 'xhigh'],
+  'grok-oauth': ['low', 'medium', 'high', 'xhigh'],
+  // Antigravity carries the effort tier inside the wire model id
+  // (gemini-3-pro-high / -low, claude-*-thinking), so the route exposes none.
+  'antigravity-oauth': [],
+  'opencode-go': ['high', 'max'],
+};
+const EFFORT_BY_FAMILY = {
+  opus: ['low', 'medium', 'high', 'xhigh', 'max'],
+  fable: ['low', 'medium', 'high', 'xhigh', 'max'],
+  sonnet: ['low', 'medium', 'high'],
+  haiku: [],
+  'gpt-5.5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.4': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.2': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-mini': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-nano': ['none', 'low', 'medium', 'high'],
+  'gpt-codex': ['none', 'low', 'medium', 'high'],
+  grok: ['low', 'medium', 'high', 'xhigh'],
+};
+const EFFORT_FALLBACKS = {
+  ultra: ['ultra', 'max', 'xhigh', 'high', 'medium', 'low', 'minimal'],
+  max: ['max', 'xhigh', 'high', 'medium', 'low', 'minimal'],
+  xhigh: ['xhigh', 'high', 'medium', 'low', 'minimal'],
+  high: ['high', 'medium', 'low', 'minimal'],
+  medium: ['medium', 'low', 'minimal'],
+  low: ['low', 'minimal'],
+  minimal: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
+  none: ['none'],
+};
+
+export function normalizeToolMode(mode) {
+  const value = String(mode || '')
+    .trim()
+    .toLowerCase();
+  return TOOL_MODES.has(value) ? value : 'full';
+}
+
+export function normalizeEffortInput(value) {
+  const v = clean(value).toLowerCase();
+  if (!v || v === 'auto') return null;
+  if (!ALL_EFFORT_LEVELS.has(v)) {
+    throw new Error(`effort must be one of auto, ${[...ALL_EFFORT_LEVELS].join(', ')}`);
+  }
+  return v;
+}
+
+export function effortOptionsFor(provider, model) {
+  const providerAllowed = EFFORT_OPTIONS_BY_PROVIDER[provider] || null;
+  const normalizeCatalogValues = (values) => {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values || []) {
+      const v = clean(raw).toLowerCase();
+      if (!v || seen.has(v)) continue;
+      seen.add(v);
+      if (ALL_EFFORT_LEVELS.has(v)) out.push(v);
+    }
+    return out;
+  };
+  const family = clean(model?.family).toLowerCase();
+  const reasoningOptionEffort = Array.isArray(model?.reasoningOptions)
+    ? model.reasoningOptions.find((option) => clean(option?.type).toLowerCase() === 'effort')
+    : null;
+  const reasoningOptionValues = Array.isArray(reasoningOptionEffort?.values)
+    ? reasoningOptionEffort.values.map((v) => clean(v).toLowerCase()).filter(Boolean)
+    : [];
+  const declared = Array.isArray(model?.reasoningLevels)
+    ? model.reasoningLevels.map((v) => clean(v).toLowerCase()).filter(Boolean)
+    : [];
+  // Catalog-first: when the catalog (models.dev / native /models) declares
+  // effort values, trust them as-is. Provider/family lists are fallbacks for
+  // catalog-empty models only, never a filter that narrows catalog values.
+  if (reasoningOptionValues.length) return normalizeCatalogValues(reasoningOptionValues);
+  if (declared.length) return normalizeCatalogValues(declared);
+  if (Object.hasOwn(EFFORT_BY_FAMILY, family)) {
+    return [...EFFORT_BY_FAMILY[family]];
+  }
+  return providerAllowed ? [...providerAllowed] : [];
+}
+
+export function coerceEffortFor(provider, model, effort) {
+  if (!effort) return null;
+  const allowed = effortOptionsFor(provider, model);
+  if (!allowed || allowed.length === 0) return null;
+  if (allowed.includes(effort)) return effort;
+  for (const candidate of EFFORT_FALLBACKS[effort] || []) {
+    if (allowed.includes(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function normalizeSavedEffort(value) {
+  try {
+    return normalizeEffortInput(value);
+  } catch {
+    return null;
+  }
+}
+
+export function effortItemsFor(provider, model, activeEffort) {
+  const allowed = effortOptionsFor(provider, model);
+  const items = [];
+  for (const value of allowed || []) {
+    items.push({
+      value,
+      label: EFFORT_LABELS[value] || value,
+      description: value === activeEffort ? 'current' : '',
+    });
+  }
+  return items;
+}
+
+export function toolSpecForMode(mode) {
+  return mode === 'readonly' ? ['tools:readonly'] : 'full';
+}
+
+export function deferredSurfaceModeForLead(mode) {
+  return mode === 'readonly' ? 'readonly' : 'lead';
+}

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/extension-scopes.mjs

@@ -5,15 +5,15 @@ import { readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { pluginMcpServerName, pluginServerMatcher } from './plugin-mcp.mjs';
-import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
-import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+import { loadConfig } from '../config.mjs';
 import {
   extensionAllowedForCwd,
   extensionScopesFromConfig,
   hasExtensionScopes,
   mcpServerNameOfTool,
-} from '../runtime/shared/extension-scopes.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
+} from '../../../shared/extension-scopes.mjs';
+import { clean } from '../../../shared/clean.mjs';
 
 export {
   EXTENSION_SCOPE_KINDS,
@@ -26,7 +26,7 @@ export {
   skillAllowedForCwd,
   mcpServerNameOfTool,
   withExtensionScope,
-} from '../runtime/shared/extension-scopes.mjs';
+} from '../../../shared/extension-scopes.mjs';
 
 /** Plugin id that installed MCP server `serverName`, or ''. Plugin servers are
  *  named `plugin-<name>` or `plugin-<name>--<suffix>` (plugin-mcp.mjs). */

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/fs-utils.mjs

@@ -1,7 +1,7 @@
 // Small filesystem read helpers used by session-runtime submodules.
 import { readdirSync, readFileSync } from 'node:fs';
 
-export { readJsonSafe } from '../runtime/shared/json-file.mjs';
+export { readJsonSafe } from '../../../shared/json-file.mjs';
 
 export function readTextSafe(path) {
   try {

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-control.mjs

@@ -20,10 +20,10 @@ import {
   validateObjective,
 } from './goal-state.mjs';
 import { assertExpectedGoal } from './goal-mutations.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
+import { clean } from '../../../shared/clean.mjs';
 
 /** "12m remaining" for a budgeted Goal, "3m elapsed" for an open-ended one. */
-export function goalTimingLabel(goal) {
+function goalTimingLabel(goal) {
   return Number(goal.timeLimitMs) > 0
     ? `${durationLabel(goal.remainingMs)} remaining`
     : `${durationLabel(goal.timeUsedMs)} elapsed`;

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-mutations.mjs

@@ -23,8 +23,8 @@ import {
   validateGoalBlocker,
   validateObjective,
 } from './goal-state.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
-import { writeJsonAtomicAsync } from '../runtime/shared/atomic-file.mjs';
+import { clean } from '../../../shared/clean.mjs';
+import { writeJsonAtomicAsync } from '../../../shared/atomic-file.mjs';
 
 const FINISHED_STATUSES = ['complete', 'stopped'];
 

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-reminder.mjs

@@ -9,7 +9,7 @@
 // acknowledge on acceptance), so a cancelled or failed turn re-sends it instead
 // of losing it. Request preparation also recovers paused or blocked state
 // directly: intake can precede session hydration or the previous turn's stop.
-import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
+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';

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

@@ -0,0 +1,326 @@
+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;
+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;
+export const SESSION_ID = SESSION_ID_PATTERN;
+export const GOAL_STATUS_VALUES = Object.freeze([
+  'active',
+  'paused',
+  'blocked',
+  'usage_limited',
+  'duration_reached',
+  'complete',
+  'stopped',
+]);
+
+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);
+  if (!SESSION_ID.test(sessionId)) throw new Error(`goal: invalid session id ${JSON.stringify(value)}`);
+  return sessionId;
+}
+
+export function validateObjective(value) {
+  const objective = clean(value);
+  if (!objective) throw new Error('goal objective is required');
+  if ([...objective].length > MAX_OBJECTIVE_LENGTH) {
+    throw new Error(`goal objective exceeds ${MAX_OBJECTIVE_LENGTH} characters`);
+  }
+  return objective;
+}
+
+export function validateGoalBlocker(value) {
+  const blocker = clean(value);
+  if (!blocker) throw new Error('goal block: blocker is required');
+  if ([...blocker].length > MAX_GOAL_BLOCKER_LENGTH) {
+    throw new Error(`goal blocker exceeds ${MAX_GOAL_BLOCKER_LENGTH} characters`);
+  }
+  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');
+    const milliseconds = Math.round(value);
+    if (milliseconds > MAX_GOAL_TIME_LIMIT_MS) throw new Error('goal duration exceeds 7 days');
+    return milliseconds;
+  }
+  const text = clean(value).toLowerCase().replace(/\s+/g, '');
+  if (!text) throw new Error('goal duration is required');
+  let total = 0;
+  let matched = 0;
+  const unitMs = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+  for (const match of text.matchAll(/(\d+(?:\.\d+)?)([smhd])/g)) {
+    if (match.index !== matched) throw new Error(`invalid goal duration: ${value}`);
+    total += Number(match[1]) * unitMs[match[2]];
+    matched += match[0].length;
+  }
+  if (matched !== text.length || !Number.isFinite(total) || total < 60_000) {
+    throw new Error('goal duration must be at least 1 minute (for example 30m, 2h, or 1h30m)');
+  }
+  if (total > MAX_GOAL_TIME_LIMIT_MS) throw new Error('goal duration exceeds 7 days');
+  return Math.round(total);
+}
+
+export function parseUserCommand(command) {
+  const value = clean(command);
+  if (!value) return { action: 'get' };
+  const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(value);
+  const token = clean(match?.[1]).toLowerCase();
+  const rest = clean(match?.[2]);
+  if (['status', 'show', 'current'].includes(token)) return { action: 'get' };
+  if (['pause', 'stop', 'clear', 'complete'].includes(token)) return { action: token };
+  if (token === 'resume') return { action: 'resume', duration: rest || null };
+  if (token === 'edit') return { action: 'edit', objective: rest };
+  if (token === 'time') return { action: 'time', duration: rest };
+
+  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();
+  }
+  const equalsMatch = objective.match(/(?:^|\s)--time=([^\s]+)/i);
+  if (equalsMatch) {
+    duration = equalsMatch[1];
+    objective = objective.replace(equalsMatch[0], ' ').trim();
+  } else {
+    const spacedMatch = objective.match(/(?:^|\s)--time\s+([^\s]+)/i);
+    if (spacedMatch) {
+      duration = spacedMatch[1];
+      objective = objective.replace(spacedMatch[0], ' ').trim();
+    }
+  }
+  return { action: 'create', objective, duration, timeMode };
+}
+
+function storedTimeLimitMs(value) {
+  const stored = Number(value.timeLimitMs);
+  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;
+}
+
+export function normalizeStoredGoal(value, sessionId, resumedAt = Date.now()) {
+  if (!value || typeof value !== 'object') return null;
+  // Version-1 records include this terminal status. Never revive elapsed work.
+  const status = value.status === 'budget_limited' ? 'duration_reached' : value.status;
+  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),
+    status,
+    tasks: normalizeGoalTasks(value.tasks ?? value.criteria ?? []),
+    blocker: clean(value.blocker),
+    pauseReason: ['waiting', 'cancelled'].includes(value.pauseReason) ? value.pauseReason : 'user',
+    blockAudit: value.blockAudit && typeof value.blockAudit === 'object' ? value.blockAudit : null,
+    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),
+    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,
+    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,
+    deadlineWarnedMs: normalizeDeadlineWarnedMs(value.deadlineWarnedMs),
+    warningRevision: Math.max(0, Math.floor(Number(value.warningRevision) || 0)),
+  };
+}
+
+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;
+  return committed + Math.max(0, now - Number(goal.lastStartedAt));
+}
+
+// The smallest delivered threshold is the durable, at-most-once watermark.
+export function normalizeDeadlineWarnedMs(value) {
+  const warned = Number(value);
+  return Number.isFinite(warned) && warned >= 0 ? warned : NO_DEADLINE_WARNING_MS;
+}
+
+export function publicGoal(goal, now = Date.now()) {
+  if (!goal) return null;
+  const timeUsedMs = activeElapsedMs(goal, now);
+  const hasTimeLimit = Number(goal.timeLimitMs) > 0;
+  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.
+    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',
+    blockAudit: goal.blockAudit || null,
+    timeLimitMs: goal.timeLimitMs,
+    timeMode: goal.timeMode,
+    timeUsedMs,
+    remainingMs,
+    deadlineAt: hasTimeLimit && goal.status === 'active' && goal.lastStartedAt ? now + remainingMs : null,
+    snapshotAt: now,
+    createdAt: goal.createdAt,
+    updatedAt: goal.updatedAt,
+    lastStartedAt: goal.lastStartedAt,
+    completedAt: goal.completedAt,
+    stoppedAt: goal.stoppedAt,
+    archivedAt: goal.archivedAt,
+  };
+}
+
+/** The Goal as a published state lane. `publicGoal` answers "how long right
+ *  now", so every read restates timeUsedMs/remainingMs/snapshotAt with a new
+ *  clock reading — and the 2s route pulse republished the whole Goal to every
+ *  desktop and phone while nothing about it had changed. A running clock is
+ *  fully described by its open segment: the time committed before it and the
+ *  moment it started. Anchoring the snapshot at `lastStartedAt` keeps the wire
+ *  shape receivers already read (elapsed = timeUsedMs + (clock - snapshotAt),
+ *  deadlineAt fixed) while every read of an unchanged Goal is equal. A stopped
+ *  clock has no anchor to carry, so its read time is dropped. Returns the
+ *  input itself when nothing needs anchoring. */
+export function goalStateSnapshot(goal) {
+  if (!goal || typeof goal !== 'object') return goal || null;
+  const startedAt = Number(goal.lastStartedAt) || 0;
+  const snapshotAt = Number(goal.snapshotAt) || 0;
+  if (goal.status !== 'active' || startedAt <= 0) {
+    if (!Object.hasOwn(goal, 'snapshotAt')) return goal;
+    const { snapshotAt: _readAt, ...stopped } = goal;
+    return stopped;
+  }
+  if (snapshotAt <= 0 || snapshotAt === startedAt) return goal;
+  const committed = Math.max(0, (Number(goal.timeUsedMs) || 0) - Math.max(0, snapshotAt - startedAt));
+  const limitMs = Number(goal.timeLimitMs) || 0;
+  const remainingMs = limitMs > 0 ? Math.max(0, limitMs - committed) : null;
+  return {
+    ...goal,
+    timeUsedMs: committed,
+    remainingMs,
+    deadlineAt: remainingMs === null ? null : startedAt + remainingMs,
+    snapshotAt: startedAt,
+  };
+}
+
+export function normalizedCompletedGoalTtlMs(value) {
+  const ttlMs = Number(value);
+  return Number.isFinite(ttlMs) && ttlMs >= 0 ? ttlMs : DEFAULT_COMPLETED_GOAL_TTL_MS;
+}
+
+export function completedGoalExpired(goal, at, ttlMs = DEFAULT_COMPLETED_GOAL_TTL_MS) {
+  if (goal?.status !== 'complete') return false;
+  const completedAt = Number(goal.completedAt) || Number(goal.updatedAt) || Number(goal.createdAt) || 0;
+  return completedAt > 0 && at - completedAt >= normalizedCompletedGoalTtlMs(ttlMs);
+}
+
+export function checkpointActiveClock(goal, now = Date.now()) {
+  if (!goal.lastStartedAt) return;
+  goal.timeUsedMs = Math.max(0, Number(goal.timeUsedMs) || 0) + Math.max(0, now - Number(goal.lastStartedAt));
+  goal.lastStartedAt = now;
+}
+
+export function stopActiveClock(goal, now = Date.now()) {
+  checkpointActiveClock(goal, now);
+  goal.lastStartedAt = null;
+}
+
+export function clearTurnFailures(goal) {
+  goal.failureReason = '';
+  goal.failureCount = 0;
+}
+
+export function activateGoal(goal, now = Date.now()) {
+  goal.status = 'active';
+  goal.lastStartedAt = now;
+  goal.completedAt = null;
+  goal.archivedAt = null;
+  goal.blocker = '';
+  goal.blockAudit = null;
+  // A running Goal has no pause to explain. Leaving the previous reason behind
+  // left active records reading as a wait that had already ended.
+  goal.pauseReason = 'user';
+  clearTurnFailures(goal);
+}
+
+export function resumeGoalState(goal, at, added = null) {
+  stopActiveClock(goal, at);
+  if (added != null) {
+    goal.timeLimitMs = parseGoalDuration(goal.timeUsedMs + added);
+    goal.deadlineWarnedMs = NO_DEADLINE_WARNING_MS;
+  }
+  if (goal.timeLimitMs > 0 && goal.timeLimitMs <= goal.timeUsedMs) {
+    throw new Error(
+      'Goal time budget is exhausted; extend the time budget before resuming with user-approved time_limit_minutes'
+    );
+  }
+  activateGoal(goal, at);
+  goal.updatedAt = at;
+}
+
+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/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-storage.mjs

@@ -1,7 +1,7 @@
 import { readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { writeJsonAtomicAsync } from '../runtime/shared/atomic-file.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
+import { writeJsonAtomicAsync } from '../../../shared/atomic-file.mjs';
+import { clean } from '../../../shared/clean.mjs';
 import {
   DEFAULT_COMPLETED_GOAL_TTL_MS,
   GOAL_FILE_VERSION,