@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/session-goal/DOCUMENTATION.md

@@ -1,10 +1,43 @@
 # Session Goal
 
 Server-side control loop that keeps a session working toward a user-defined
-objective stored under `metadata.openchamber.goal`, with the small model as
-an independent progress auditor. Built on OpenChamber's backend-driven
-architecture: the loop lives in
-the web server and survives UI disconnects.
+objective. On OpenCode 2.x the goal record lives in the OpenChamber session
+metadata store (`packages/web/server/lib/session-metadata/`), folded back onto
+`session.metadata` by the proxy. Capability is **open** (`supported: true`):
+manual UI, goal routes, and scheduled-task goal create all write the same
+store. The small model is an independent progress auditor. Built on
+OpenChamber's backend-driven architecture: the loop lives in the web server
+and survives UI disconnects.
+
+## v2 storage (OpenChamber session metadata store)
+
+OpenCode 2.x accepts session `metadata` only at create time — there is no
+PATCH. Goal progress therefore belongs in the Host
+`packages/web/server/lib/session-metadata/` store (merge-patched under
+`openchamber.goal`), not an OpenCode `PATCH /session/:id`.
+
+`createSessionGoalRuntime` accepts optional seams:
+
+| Seam | Role |
+|---|---|
+| `readSessionMetadata` | Read Host metadata for the session |
+| `persistSessionGoal` | Full goal replace (routes / scheduled create) |
+| `mutateSessionMetadata` | Preferred conditional commit: `decide(committed) → { ok, patch }` on the store lock |
+
+When `mutateSessionMetadata` is present, runtime goal commits use it exclusively
+(no OpenCode PATCH). When only `readSessionMetadata` + `persistSessionGoal` are
+present, the runtime falls back to read-then-persist. When neither store path is
+wired, the legacy OpenCode PATCH path remains (tests / unwired servers).
+
+Those seams, the proxy overlay, and `PUT /api/openchamber/sessions/:id/metadata`
+are wired in `server/index.js`. A UI metadata write notifies the runtime with
+a synthetic `session.updated` so create/resume can arm the loop. Metadata PUT
+normalizes `executionGeneration` for goal patches inside the store mutate lock.
+
+**Capability is open** (`supported === true`). Scheduled-task goal create and
+`POST /api/goals/:sessionId` persist an active goal into the same store as
+manual UI metadata writes; after first persist they notify the runtime with a
+synthetic `session.updated` so the loop can arm.
 
 ## Goal payload (`metadata.openchamber.goal`)
 
@@ -18,14 +51,52 @@ the web server and survives UI disconnects.
   tokensUsed,              // tokensCommitted + current segment (snapshot - baseline)
   tokensBaseline,          // segment start snapshot (pre-goal turn; 0 after compaction)
   tokensCommitted,         // closed segments' total (one segment per compaction)
-  turnsUsed,               // auto-continuations sent (capped at MAX_AUTO_TURNS)
+  turnsUsed,               // auto-continuation attempts committed (capped at MAX_AUTO_TURNS)
   blockedStreak,           // consecutive blocked audit verdicts
   auditFailStreak,         // consecutive failed/unavailable audit calls
   note,                    // latest audit progress note, <= 280 chars
   statusReason,            // why settled; 'resumed' is a kickoff signal from UI
   lastAccountedMessageID,  // incremental accounting cursor
+  executionGeneration,     // execution permit generation (see pause boundary)
+  pendingContinuation,     // durable admission (ticket 10); null when idle
   createdAt, updatedAt
 }
+
+### Durable continuation admission (`pendingContinuation`)
+
+Minimal Host-metadata field (not a parallel store). Written only through the
+same conditional goal owner as other goal commits:
+
+```
+{
+  messageID,     // msg_goalc_<goalId>_<generation>_<turnsUsed>
+  goalId, generation, turnsUsed,
+  phase,         // reserved | transport | uncertain | accepted
+  text,          // fixed prompt payload for legal same-id re-dispatch
+  providerID, modelID, variant?, agent?,
+  error?, at
+}
+```
+
+Rules:
+
+1. **Reserve before send** — persist fixed `messageID` + prompt/selection
+   identity with `phase: reserved` **without** bumping `turnsUsed`.
+2. **Accept commit** — `turnsUsed` increment and `pendingContinuation: null`
+   share one conditional write after upstream accept (or reconcile `found`).
+3. **Selection / pre-prompt drop** — pause or switchAgent/switchModel failure
+   clears reserved pending; **0 count**.
+4. **Uncertain transport** — keep durable identity; pause auto-continue with a
+   user-visible `statusReason` (reuses blocked/pause reason UI). Reconcile via
+   official `session.inbox.list` / `session.message.get` (or projected list);
+   fetch failure is **unavailable**, never authoritative empty.
+5. **Already received** — count once, clear pending; do not invent a new id.
+6. **pause → resume / goal replace** — reserved pending cleared on pause;
+   transport/uncertain/accepted identity retained (no claim of upstream revoke).
+   Stale `goalId` / superseded `generation` never overwrite newer user ops;
+   found-under-stale-gen still counts once.
+7. **Reboot** — restore pending from metadata, reconcile first, then same-id
+   fixed-payload re-dispatch only when still absent and generation matches.
 ```
 
 The UI writes goals (create/edit/pause/resume/clear) by patching this
@@ -38,8 +109,49 @@ content, since "Implement this plan: X" alone gives the audit nothing to
 judge against. The armed send also attaches a synthetic system-reminder
 part telling the agent goal mode is active and that each turn should end
 with a factual done/verified/remaining statement for the independent audit.
-Freshness/stale-write protection is by `id`: every runtime write re-reads the
-session and drops the write when the stored goal id no longer matches.
+
+### Execution generation and pause/commit boundary
+
+`executionGeneration` is the durable execution permit. It starts at `0` on
+create and advances on:
+
+- pause (user, abort, question) while status was `active`
+- resume (`paused`/`blocked`/… → `active`)
+- execution-condition edits (`tokenBudget`, `objective`, `objectiveFile`)
+
+Settle paths (`active` → `complete` / `blocked` / `budgetLimited`) keep the
+same generation. Writers go through `withGoalExecutionGeneration` (metadata
+PUT, `persistSessionGoal` Host wiring) or the runtime's `advanceGeneration`
+flag so UI patches that omit the field still bump correctly.
+
+Runtime commits (continue accounting, settle, pause) validate **goal id +
+expected generation + applicable status** on one serial boundary when the
+Host `mutateSessionMetadata` seam is wired. A late audit that returns
+`continue` / `complete` / `blocked` after pause cannot overwrite the paused
+snapshot or start a new `session.prompt` continuation.
+
+Local (in-process) ordering:
+
+1. Pause / stop / `session.updated` paused → bump dispatch epoch + abort
+   in-flight audit controller + clear idle timer (**before** awaiting durable
+   write).
+2. Tick captures epoch at start; re-checks before continue commit and before
+   dispatch.
+3. `sendContinuation` re-validates **epoch + shutdown recovery + stopped** after
+   every await (`switchAgent` / `switchModel` / generation re-read) and again
+   immediately before `session.prompt`. It also re-reads durable goal
+   generation/status at the prompt boundary. A pause or shutdown that lands
+   during selection must drop with `uncertain: false` and **zero** prompt.
+4. Continuation identity `{ goalId, generation, turnsUsed }` and
+   `phase: transport` are recorded **only at the actual prompt boundary** —
+   not before selection. Selection failures (agent/model switch) must **not**
+   be reported as prompt-uncertain. Uncertain applies only after prompt left
+   the process and transport failed; the identity is kept for reconcile. The
+   runtime does **not** claim full revoke of a request already handed upstream.
+   Explicit stop of the upstream turn remains the existing abort/stop operation.
+
+Public seams for tests / controlled async: `runTick`, `pauseGoal`,
+`getDispatchEpoch`, `getDispatchedContinuation`.
 
 ## File-backed objectives
 
@@ -53,11 +165,16 @@ before touching the filesystem). Rationale: metadata rides every
 `session.updated`, so multi-KB objectives must not live there.
 
 - `objectives.js` — write/read/delete, 5000-char clamp.
-- `routes.js` — `PUT/GET/DELETE /api/goals/objective/:sessionId`
-  (OpenChamber-owned, registered before the generic proxy; JSON parsing via
-  the `/api/goals` family in core-routes). The UI writes the file BEFORE
-  patching the goal metadata and falls back to an inline objective when the
-  write fails; `clearSessionGoal` deletes the file best-effort.
+- `capability.js` — `getSessionGoalCapability()` / `assertSessionGoalSupported()`
+  (single source; currently `{ supported: true }`).
+- `routes.js` — `GET /api/goals/capability`, create/resume endpoints,
+  `PUT/GET/DELETE /api/goals/objective/:sessionId` (OpenChamber-owned,
+  registered before the generic proxy; JSON parsing via the `/api/goals`
+  family in core-routes). Create / resume require an injected
+  `persistSessionGoal` (503 when missing); objective PUT writes the file when
+  supported. The UI writes the file BEFORE patching the goal metadata and
+  falls back to an inline objective when the write fails;
+  `clearSessionGoal` deletes the file best-effort.
 - The tick resolves the effective objective fresh on every cycle (the file
   is live-editable mid-goal) and falls back to the inline `objective` when
   the file is unreadable — a goal never dies because a file went away.
@@ -139,11 +256,23 @@ before touching the filesystem). Rationale: metadata rides every
      audit unavailable") — resumable, and settling resets the streak so
      Resume gets fresh tolerance. A dead small model can never drive the
      loop blind to the turn cap;
-   - continue: persist accounting + `turnsUsed` first (a crash after the
-     write just waits for the next idle tick; the reverse could double-send),
-     re-check the tail, then `POST /session/:id/prompt_async` with the
-     continuation prompt using the last assistant message's
-     provider/model/agent — the goal spends the session's own subscription.
+    - continue (ticket 10 durable admission): persist accounting +
+       `pendingContinuation` (`phase: reserved`, fixed `msg_goalc_…` id +
+       prompt/selection payload) **without** bumping `turnsUsed`; re-check
+       tail; then `session.switchAgent` / `session.switchModel` +
+       `session.prompt` with that stable id. Accept → one conditional commit
+       of `turnsUsed + 1` and clear pending. Selection/pre-prompt pause or
+       failure clears reserved pending (0 count). Uncertain transport keeps
+       durable identity and pauses auto-continue with a readable
+       `statusReason`; next tick / reboot reconciles via inbox / exact
+       message (fail ≠ empty) before any new id. Already-received counts
+       once. Synthetic is metadata-only (`goalContinuation`).
+    - **Shutdown recovery (ticket 07):** `session.execution.interrupted` with
+      `reason: shutdown` clears the idle timer and sets a **local** recovery
+      pending marker (not a parallel durable store). Auto-continue / tick stay
+      gated until authoritative `session.status` idle or a non-shutdown
+      execution terminal clears the marker. Goal status itself is unchanged.
+
 4. Settling (`complete`/`blocked`/`budgetLimited`) fires the injected
    `emitGoalNotification` so the user hears about it even with the UI closed.
    The same settle also notifies a registered Assistant contact reporter
@@ -183,13 +312,35 @@ sees only that final turn, so the report is its evidence.
   (edit/pause/resume/complete/clear).
 - Sidebar glyph next to the date in `SessionNodeItem`.
 
+## Capability (Host goal state)
+
+`capability.js` is the single source for whether Host goal state is available:
+
+```
+getSessionGoalCapability() → { supported: true }
+```
+
+Goal records live in the OpenChamber session-metadata store (not OpenCode
+SessionInfo). Routes, scheduled tasks, and the proxy overlay share that store.
+
+| Surface | While supported |
+|---|---|
+| `GET /api/goals/capability` | `{ supported: true }` |
+| `POST /api/goals/:sessionId` (create) | Write objective + persist active goal (503 if persist missing) |
+| `POST /api/goals/:sessionId/resume` | Set status active / statusReason resumed (404 if no goal) |
+| `PUT /api/goals/objective/:sessionId` | Writes the objective file |
+| `GET` / `DELETE` objective | Allowed |
+| Scheduled `goalEnabled` create/edit | Allowed |
+| Existing `goalEnabled` task run | Persist goal after session create; fail before create if persist unwired |
+
 ## Scheduled goals
 
-Scheduled tasks can run as goals: `execution.goalEnabled` (+ optional
-`execution.goalTokenBudget`) on a task makes the scheduled-tasks runtime
-stamp `metadata.openchamber.goal` onto the fresh session (objective = the
-expanded task prompt) and attach the goal-mode intro part to the prompt.
-The loop here picks it up from session events like any other goal.
+Scheduled tasks with `execution.goalEnabled` (+ optional
+`execution.goalTokenBudget`) write the objective file, persist an active goal
+into the Host store (same shape as manual create), notify the goal runtime to
+arm, and attach the goal-mode intro to the prompt. Without
+`persistSessionGoal` injected, runs fail **before** session create (no
+create/distill/prompt side effects).
 
 ## Limitations
 

package/server/lib/session-goal/capability.js

@@ -0,0 +1,57 @@
+/**
+ * Session-goal Host capability for the current OpenCode surface.
+ *
+ * Goal records live in the OpenChamber session-metadata store
+ * (`packages/web/server/lib/session-metadata/`), not OpenCode SessionInfo.
+ * When the store + scheduled-task / route persist seams are wired, advertise
+ * supported so create·resume·edit paths write trackable goal state.
+ *
+ * `SESSION_GOAL_UNSUPPORTED_REASON` remains for structured refusals if a
+ * future surface must advertise unsupported again.
+ */
+
+export const SESSION_GOAL_UNSUPPORTED_REASON = 'v2_goal_state_unavailable';
+
+/**
+ * @returns {{ supported: false, reason: typeof SESSION_GOAL_UNSUPPORTED_REASON }
+ *   | { supported: true, reason?: undefined }}
+ */
+export function getSessionGoalCapability() {
+  return {
+    supported: true,
+  };
+}
+
+export function isSessionGoalSupported() {
+  return getSessionGoalCapability().supported === true;
+}
+
+/**
+ * Human-readable refusal for APIs / run history when goal state is unavailable.
+ * @param {{ supported: boolean, reason?: string }} [capability]
+ */
+export function sessionGoalUnavailableMessage(capability = getSessionGoalCapability()) {
+  const reason = typeof capability?.reason === 'string' && capability.reason.trim()
+    ? capability.reason.trim()
+    : SESSION_GOAL_UNSUPPORTED_REASON;
+  return `session goal is unavailable (${reason})`;
+}
+
+/**
+ * Throw a structured refusal for create / edit / resume / objective-write paths.
+ * @param {{ operation?: string }} [options]
+ */
+export function assertSessionGoalSupported(options = {}) {
+  const capability = getSessionGoalCapability();
+  if (capability.supported) {
+    return capability;
+  }
+  const operation = typeof options.operation === 'string' && options.operation.trim()
+    ? options.operation.trim()
+    : 'goal';
+  const error = new Error(`${sessionGoalUnavailableMessage(capability)}: cannot ${operation}`);
+  error.statusCode = 501;
+  error.code = capability.reason || SESSION_GOAL_UNSUPPORTED_REASON;
+  error.capability = capability;
+  throw error;
+}

package/server/lib/session-goal/capability.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import {
+  SESSION_GOAL_UNSUPPORTED_REASON,
+  assertSessionGoalSupported,
+  getSessionGoalCapability,
+  isSessionGoalSupported,
+  sessionGoalUnavailableMessage,
+} from './capability.js';
+
+describe('session-goal capability', () => {
+  it('advertises supported Host goal state (session-metadata store)', () => {
+    expect(getSessionGoalCapability()).toEqual({
+      supported: true,
+    });
+    expect(SESSION_GOAL_UNSUPPORTED_REASON).toBe('v2_goal_state_unavailable');
+    expect(isSessionGoalSupported()).toBe(true);
+  });
+
+  it('formats a stable unavailable message for run history and APIs', () => {
+    expect(sessionGoalUnavailableMessage({
+      supported: false,
+      reason: SESSION_GOAL_UNSUPPORTED_REASON,
+    })).toBe(
+      'session goal is unavailable (v2_goal_state_unavailable)',
+    );
+  });
+
+  it('assertSessionGoalSupported returns when supported', () => {
+    expect(assertSessionGoalSupported({ operation: 'create' })).toEqual({
+      supported: true,
+    });
+  });
+});

package/server/lib/session-goal/routes.js

@@ -1,12 +1,243 @@
+import crypto from 'node:crypto';
+import {
+  assertSessionGoalSupported,
+  getSessionGoalCapability,
+  isSessionGoalSupported,
+  sessionGoalUnavailableMessage,
+} from './capability.js';
 import { deleteObjective, readObjective, writeObjective } from './objectives.js';
 
+const asNonEmptyString = (value) => {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const refuseGoalMutation = (res, operation) => {
+  try {
+    assertSessionGoalSupported({ operation });
+    return false;
+  } catch (error) {
+    const capability = error?.capability || getSessionGoalCapability();
+    res.status(Number(error?.statusCode) || 501).json({
+      error: error?.message || sessionGoalUnavailableMessage(capability),
+      reason: capability.reason,
+      capability,
+      operation,
+    });
+    return true;
+  }
+};
+
+const resolveTokenBudget = (value) => {
+  if (Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return null;
+};
+
+/**
+ * Build an active goal record accepted by parseGoalMetadata.
+ * File-backed: objectiveFile true (objective may be empty).
+ * Inline fallback: objective text required.
+ */
+const buildActiveGoalRecord = ({
+  objective = '',
+  objectiveFile = false,
+  tokenBudget = null,
+  statusReason = '',
+  id = null,
+} = {}) => {
+  const now = Date.now();
+  const inline = typeof objective === 'string' ? objective.trim() : '';
+  return {
+    id: typeof id === 'string' && id ? id : crypto.randomUUID(),
+    status: 'active',
+    objective: objectiveFile ? '' : inline,
+    objectiveFile: objectiveFile === true,
+    tokenBudget: resolveTokenBudget(tokenBudget),
+    tokensUsed: 0,
+    turnsUsed: 0,
+    blockedStreak: 0,
+    note: '',
+    statusReason: typeof statusReason === 'string' ? statusReason : '',
+    lastAccountedMessageID: '',
+    // Fresh goal starts a new execution generation (0). Resume / pause bump it.
+    executionGeneration: 0,
+    createdAt: now,
+    updatedAt: now,
+  };
+};
+
 // OpenChamber-owned routes for file-backed goal objectives, keyed by session
 // id (one goal per session; a new goal overwrites the old file). The UI
 // writes the objective file before stamping the goal metadata (which only
 // carries an `objectiveFile: true` flag), reads it back for display, and
 // deletes it when the goal is removed.
-export function registerSessionGoalRoutes(app) {
+//
+// Host goal state lives in the session-metadata store. Create / resume need
+// an injected persistSessionGoal; without it they return 503 rather than
+// pretending success. GET remains readable for leftover files.
+export function registerSessionGoalRoutes(app, deps = {}) {
+  const {
+    persistSessionGoal = null,
+    readSessionMetadata = null,
+    /** After create/resume persist — arm the goal loop (synthetic session.updated). */
+    onGoalPersisted = null,
+  } = deps;
+
+  const notifyGoalPersisted = (sessionID, directory, persisted, goal) => {
+    if (typeof onGoalPersisted !== 'function') return;
+    try {
+      const metadata = persisted
+        && typeof persisted === 'object'
+        && !Array.isArray(persisted)
+        && persisted.openchamber
+        ? persisted
+        : { openchamber: { goal } };
+      onGoalPersisted({ sessionID, directory: directory || '', metadata });
+    } catch (error) {
+      console.warn('[session-goal] onGoalPersisted failed:', error?.message || error);
+    }
+  };
+
+  app.get('/api/goals/capability', (_req, res) => {
+    res.json(getSessionGoalCapability());
+  });
+
+  app.post('/api/goals/:sessionId', async (req, res) => {
+    if (refuseGoalMutation(res, 'create')) return;
+    if (typeof persistSessionGoal !== 'function') {
+      res.status(503).json({
+        error: 'session goal persist is not configured',
+        operation: 'create',
+        capability: getSessionGoalCapability(),
+      });
+      return;
+    }
+
+    const sessionId = asNonEmptyString(req.params?.sessionId);
+    if (!sessionId) {
+      res.status(400).json({ error: 'a session id is required' });
+      return;
+    }
+
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    const directory = asNonEmptyString(body.directory) || '';
+    const objectiveText = typeof body.objective === 'string' ? body.objective : '';
+    const tokenBudget = body.tokenBudget ?? body.goalTokenBudget ?? null;
+
+    let objectiveFile = false;
+    let inlineObjective = objectiveText;
+    try {
+      await writeObjective(sessionId, objectiveText);
+      objectiveFile = true;
+      inlineObjective = '';
+    } catch (error) {
+      console.warn('[session-goal] objective file write failed, using inline objective:', error?.message || error);
+      if (!asNonEmptyString(inlineObjective)) {
+        res.status(400).json({ error: 'objective is required when the objective file cannot be written' });
+        return;
+      }
+    }
+
+    const goal = buildActiveGoalRecord({
+      objective: inlineObjective,
+      objectiveFile,
+      tokenBudget,
+    });
+
+    let persisted;
+    try {
+      persisted = await persistSessionGoal(sessionId, directory, goal);
+    } catch (error) {
+      const message = error?.message || 'Failed to persist session goal';
+      console.error('[session-goal] create persist failed:', message);
+      res.status(500).json({ error: message, operation: 'create' });
+      return;
+    }
+
+    notifyGoalPersisted(sessionId, directory, persisted, goal);
+    res.json({ ok: true, goal });
+  });
+
+  app.post('/api/goals/:sessionId/resume', async (req, res) => {
+    if (refuseGoalMutation(res, 'resume')) return;
+    if (typeof persistSessionGoal !== 'function') {
+      res.status(503).json({
+        error: 'session goal persist is not configured',
+        operation: 'resume',
+        capability: getSessionGoalCapability(),
+      });
+      return;
+    }
+    if (typeof readSessionMetadata !== 'function') {
+      res.status(503).json({
+        error: 'session goal metadata read is not configured',
+        operation: 'resume',
+        capability: getSessionGoalCapability(),
+      });
+      return;
+    }
+
+    const sessionId = asNonEmptyString(req.params?.sessionId);
+    if (!sessionId) {
+      res.status(400).json({ error: 'a session id is required' });
+      return;
+    }
+
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+    const directory = asNonEmptyString(body.directory) || '';
+
+    let metadata;
+    try {
+      metadata = await readSessionMetadata(sessionId);
+    } catch (error) {
+      const message = error?.message || 'Failed to read session metadata';
+      console.error('[session-goal] resume read failed:', message);
+      res.status(503).json({ error: message, operation: 'resume' });
+      return;
+    }
+
+    const currentGoal = metadata?.openchamber?.goal;
+    if (!currentGoal || typeof currentGoal !== 'object') {
+      res.status(404).json({ error: 'goal not found', operation: 'resume' });
+      return;
+    }
+
+    const now = Date.now();
+    const priorGeneration = Number.isFinite(currentGoal.executionGeneration)
+      && currentGoal.executionGeneration >= 0
+      ? Math.floor(currentGoal.executionGeneration)
+      : 0;
+    const goal = {
+      ...currentGoal,
+      status: 'active',
+      statusReason: 'resumed',
+      // Resume opens a new execution generation so late audits from the prior
+      // active period cannot commit continue/settle.
+      executionGeneration: priorGeneration + 1,
+      updatedAt: now,
+    };
+
+    let persisted;
+    try {
+      persisted = await persistSessionGoal(sessionId, directory, goal);
+    } catch (error) {
+      const message = error?.message || 'Failed to persist session goal';
+      console.error('[session-goal] resume persist failed:', message);
+      res.status(500).json({ error: message, operation: 'resume' });
+      return;
+    }
+
+    notifyGoalPersisted(sessionId, directory, persisted, goal);
+    res.json({ ok: true, goal });
+  });
+
   app.put('/api/goals/objective/:sessionId', async (req, res) => {
+    // Objective write is part of manual goal create — refuse while unsupported
+    // so create cannot partial-succeed on the file alone.
+    if (refuseGoalMutation(res, 'create')) return;
     try {
       const { content } = req.body || {};
       await writeObjective(req.params.sessionId, content);
@@ -30,7 +261,14 @@ export function registerSessionGoalRoutes(app) {
   });
 
   app.delete('/api/goals/objective/:sessionId', async (req, res) => {
+    // Clear is allowed even when create is unsupported so leftover files from
+    // prior experiments can be removed without implying goal Host support.
     await deleteObjective(req.params.sessionId);
-    res.json({ ok: true });
+    res.json({
+      ok: true,
+      ...(isSessionGoalSupported() ? {} : {
+        capability: getSessionGoalCapability(),
+      }),
+    });
   });
 }