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

package/server/lib/scheduled-tasks/runtime.js

@@ -1,8 +1,14 @@
 import crypto from 'node:crypto';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
 import { DateTime } from 'luxon';
 import parser from 'cron-parser';
+import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { expandSnippets } from '../opencode/snippets.js';
+import {
+  getSessionGoalCapability,
+  isSessionGoalSupported,
+  sessionGoalUnavailableMessage,
+} from '../session-goal/capability.js';
+import { buildScheduledTaskMetadata } from '../session-metadata/system-session.js';
 import { SCHEDULED_SLOT_CLAIMED_CODE } from './run-history-store.js';
 
 const DEFAULT_GLOBAL_CONCURRENCY = 4;
@@ -15,16 +21,20 @@ const TASK_DUE_SLACK_MS = 5_000;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const PROJECT_SYNC_RETRY_DELAY_MS = 1_000;
 const MAX_PROJECT_SYNC_RETRIES = 3;
-const ARCHIVE_404_RETRY_DELAY_MS = 250;
 /** Poll interval while waiting for the OpenCode session turn (or goal) to settle. */
 const SESSION_SETTLEMENT_POLL_MS = 1_000;
 /**
- * Incomplete assistant tails while idle need a couple of stable polls before we
- * treat them as settled (OpenCode sometimes leaves time.completed unset).
+ * Latest-side message page for settlement. order=desc + bounded limit — never
+ * order=asc page-0 + at(-1), which reads an old page once the session exceeds
+ * the limit.
  */
-const INCOMPLETE_ASSISTANT_SETTLE_PROBES = 2;
+const SESSION_SETTLEMENT_MESSAGE_LIMIT = 50;
 /** Goal terminal statuses — active/paused mean the run is still open. */
 const GOAL_TERMINAL_STATUSES = new Set(['complete', 'blocked', 'budgetLimited']);
+/** Assistant finish values that are real terminal success (not tool-calls mid-loop). */
+const ASSISTANT_SUCCESS_FINISH = new Set(['stop']);
+/** Assistant finish values that are terminal failure without an error object. */
+const ASSISTANT_ERROR_FINISH = new Set(['error', 'length', 'content-filter']);
 
 const buildTaskKey = (projectID, taskID) => `${projectID}:${taskID}`;
 
@@ -235,22 +245,6 @@ export const formatScheduledSessionTitle = (task, nowMs = Date.now()) => {
   return `${SCHEDULED_TITLE_PREFIX}${trimmedName}${suffix}`;
 };
 
-const buildScheduledTaskMetadata = ({ projectID, taskID, runID, name }) => ({
-  openchamber: {
-    scheduledTask: {
-      projectID,
-      taskID,
-      runID,
-      name,
-    },
-  },
-});
-
-const isMissingSessionError = (result) => {
-  const status = result?.error?.status ?? result?.error?.statusCode ?? result?.status;
-  return status === 404 || result?.error?.code === 'not_found';
-};
-
 const sleep = (ms, signal) => new Promise((resolve, reject) => {
   if (signal?.aborted) {
     reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
@@ -273,9 +267,11 @@ const sleep = (ms, signal) => new Promise((resolve, reject) => {
 
 const readMessageInfo = (entry) => {
   if (!entry || typeof entry !== 'object') return null;
-  const info = entry.info && typeof entry.info === 'object' ? entry.info : entry;
-  if (!info || typeof info !== 'object') return null;
-  return info;
+  // SessionMessageInfo is the entry itself; tolerate projected { info, parts }.
+  if (entry.info && typeof entry.info === 'object') {
+    return entry.info;
+  }
+  return entry;
 };
 
 const formatAssistantError = (error) => {
@@ -291,6 +287,79 @@ const formatAssistantError = (error) => {
   return 'assistant error';
 };
 
+const isAssistantMessage = (info) => (
+  info
+  && typeof info === 'object'
+  && (info.type === 'assistant' || info.role === 'assistant')
+);
+
+const isUserMessage = (info) => (
+  info
+  && typeof info === 'object'
+  && (info.type === 'user' || info.role === 'user')
+);
+
+/**
+ * Classify the newest message on a latest-side page.
+ * - finish tool-calls is mid-loop, never success
+ * - incomplete (no time.completed) is never success
+ * - model-switched / non-assistant tails are not success
+ * - only a completed assistant with a real terminal finish succeeds
+ */
+const classifyMessageTail = (messages) => {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { outcome: 'unknown' };
+  }
+  // order=desc contract: index 0 is the newest message on this page.
+  // Do not re-rank by time.created — that reintroduces the old-page bug when
+  // a bounded page mixes ages (and fixtures / clock skew can invert created).
+  const latest = readMessageInfo(messages[0]);
+  if (!latest) {
+    return { outcome: 'unknown' };
+  }
+  if (isAssistantMessage(latest)) {
+    if (latest.error) {
+      return {
+        outcome: 'error',
+        error: formatAssistantError(latest.error),
+      };
+    }
+    const finish = typeof latest.finish === 'string' ? latest.finish.trim() : '';
+    if (finish === 'tool-calls') {
+      // Model paused for tools — not a successful run terminal.
+      return { outcome: 'busy' };
+    }
+    if (ASSISTANT_ERROR_FINISH.has(finish)) {
+      return {
+        outcome: 'error',
+        error: finish === 'error' ? 'assistant error' : `assistant finish ${finish}`,
+      };
+    }
+    if (latest.time?.completed && (!finish || ASSISTANT_SUCCESS_FINISH.has(finish))) {
+      return { outcome: 'success' };
+    }
+    // Incomplete assistant (no completed, or unknown finish) — not success.
+    return { outcome: 'busy' };
+  }
+  if (isUserMessage(latest)) {
+    return { outcome: 'awaiting_assistant', lastInfo: latest };
+  }
+  // model-switched, compaction, system, etc. — not a success terminal.
+  return { outcome: 'busy' };
+};
+
+const listLatestMessages = async (client, sessionID, requestOptions) => {
+  if (typeof client?.message?.list !== 'function') {
+    return null;
+  }
+  const messagesResult = await client.message.list({
+    sessionID,
+    limit: SESSION_SETTLEMENT_MESSAGE_LIMIT,
+    order: 'desc',
+  }, requestOptions);
+  return Array.isArray(messagesResult?.data) ? messagesResult.data : null;
+};
+
 const extractGoalFromSession = (session) => {
   const metadata = session?.metadata;
   if (!metadata || typeof metadata !== 'object') return null;
@@ -308,9 +377,13 @@ const extractGoalFromSession = (session) => {
 
 /**
  * Single-shot session outcome for post-run continuation (no polling).
- * Goal-enabled: terminal complete → success; blocked/budgetLimited → error;
- * otherwise not-yet-success. Non-goal: busy/retry, assistant error, or
- * completed assistant; incomplete/empty tails are not treated as success.
+ * Goal-enabled + supported: terminal complete → success; blocked/budgetLimited
+ * → error; otherwise not-yet-success. Goal unsupported: never invent success.
+ * Prefer Host `readSessionMetadata` over OpenCode `session.get` (direct clients
+ * do not see the Host store). Store read failure is never empty-goal success.
+ * Non-goal: session.active failure stays unknown; latest-side assistant tail
+ * must be a real terminal (finish tool-calls / incomplete / model-switch ≠
+ * success). History rows are never rewritten here.
  */
 const snapshotSessionOutcome = async ({
   client,
@@ -318,74 +391,90 @@ const snapshotSessionOutcome = async ({
   projectPath,
   goalEnabled,
   signal,
+  readSessionMetadata = null,
 }) => {
   const requestOptions = signal ? { signal } : undefined;
 
-  if (goalEnabled && typeof client?.session?.get === 'function') {
-    try {
-      const sessionResult = await client.session.get({
-        sessionID,
-        directory: projectPath,
-      }, requestOptions);
-      if (!sessionResult?.error) {
-        const goal = extractGoalFromSession(sessionResult?.data);
-        if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
-          if (goal.status === 'complete') {
-            return { outcome: 'success' };
-          }
-          return {
-            outcome: 'error',
-            error: goal.note || `goal ${goal.status}`,
-          };
+  if (goalEnabled) {
+    if (!isSessionGoalSupported()) {
+      // Host goal state unavailable — do not promote assistant-tail idle to success.
+      return { outcome: 'busy' };
+    }
+
+    const classifyGoal = (goal) => {
+      if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
+        if (goal.status === 'complete') {
+          return { outcome: 'success' };
         }
+        return {
+          outcome: 'error',
+          error: goal.note || `goal ${goal.status}`,
+        };
       }
-    } catch (error) {
-      if (signal?.aborted) throw error;
+      return null;
+    };
+
+    // Prefer Host store: OpenCode session.get cannot see openchamber.goal.
+    if (typeof readSessionMetadata === 'function') {
+      try {
+        const metadata = await readSessionMetadata(sessionID);
+        const classified = classifyGoal(extractGoalFromSession({ metadata }));
+        if (classified) return classified;
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        // Store read failure must not masquerade as empty goal / success.
+        return { outcome: 'busy' };
+      }
+      return { outcome: 'busy' };
     }
-    return { outcome: 'busy' };
-  }
 
-  if (typeof client?.session?.status === 'function') {
-    try {
-      const statusResult = await client.session.status({
-        directory: projectPath,
-      }, requestOptions);
-      if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
-        const statusValue = statusResult.data[sessionID];
-        const type = statusValue?.type ?? statusValue?.status;
-        if (type === 'busy' || type === 'retry') {
-          return { outcome: 'busy' };
+    if (typeof client?.session?.get === 'function') {
+      try {
+        const sessionResult = await client.session.get({
+          sessionID,
+          directory: projectPath,
+        }, requestOptions);
+        if (!sessionResult?.error) {
+          const classified = classifyGoal(
+            extractGoalFromSession(sessionResult?.data ?? sessionResult),
+          );
+          if (classified) return classified;
         }
+      } catch (error) {
+        if (signal?.aborted) throw error;
       }
-    } catch (error) {
-      if (signal?.aborted) throw error;
     }
+    return { outcome: 'busy' };
   }
 
-  if (typeof client?.session?.messages === 'function') {
+  if (typeof client?.session?.active === 'function') {
     try {
-      const messagesResult = await client.session.messages({
-        sessionID,
-        directory: projectPath,
-        limit: 50,
-      }, requestOptions);
-      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
-        const lastInfo = readMessageInfo(messagesResult.data.at(-1));
-        if (lastInfo?.role === 'assistant') {
-          if (lastInfo.error) {
-            return {
-              outcome: 'error',
-              error: formatAssistantError(lastInfo.error),
-            };
-          }
-          if (lastInfo.time?.completed) {
-            return { outcome: 'success' };
-          }
-        }
+      const activeMap = await client.session.active(requestOptions);
+      if (!(activeMap && typeof activeMap === 'object' && !Array.isArray(activeMap))) {
+        // Malformed active payload is unknown — never idle-success.
+        return { outcome: 'busy' };
+      }
+      if (Object.prototype.hasOwnProperty.call(activeMap, sessionID)) {
+        return { outcome: 'busy' };
       }
     } catch (error) {
       if (signal?.aborted) throw error;
+      // active failure = unknown; do not fall through to message.list success.
+      return { outcome: 'busy' };
+    }
+  }
+
+  try {
+    const messages = await listLatestMessages(client, sessionID, requestOptions);
+    if (!messages) {
+      return { outcome: 'busy' };
+    }
+    const classified = classifyMessageTail(messages);
+    if (classified.outcome === 'success' || classified.outcome === 'error') {
+      return classified;
     }
+  } catch (error) {
+    if (signal?.aborted) throw error;
   }
 
   return { outcome: 'busy' };
@@ -393,12 +482,26 @@ const snapshotSessionOutcome = async ({
 
 const parseSessionEventPhase = (event) => {
   const payload = event?.payload?.payload ?? event?.payload;
-  const properties = payload?.properties;
+  // Accept bridge `{ properties }` and native v2 `{ data }` envelopes.
+  const properties = (payload?.properties && typeof payload.properties === 'object')
+    ? payload.properties
+    : ((payload?.data && typeof payload.data === 'object') ? payload.data : null);
   const sessionID = typeof properties?.sessionID === 'string' ? properties.sessionID : '';
   if (!sessionID) {
     return { phase: '', sessionID: '' };
   }
-  if (payload?.type === 'session.idle') {
+  // Ticket 07: shutdown interrupt is not an idle terminal — keep run open.
+  if (payload?.type === 'session.execution.interrupted' && properties?.reason === 'shutdown') {
+    return { phase: 'busy', sessionID };
+  }
+  if (payload?.type === 'session.idle' || payload?.type === 'session.execution.succeeded') {
+    return { phase: 'idle', sessionID };
+  }
+  if (payload?.type === 'session.execution.failed') {
+    return { phase: 'error', sessionID };
+  }
+  if (payload?.type === 'session.execution.interrupted') {
+    // user / superseded / inactivity — claim released; treat as idle for settlement.
     return { phase: 'idle', sessionID };
   }
   if (payload?.type === 'session.status') {
@@ -428,6 +531,25 @@ export const createScheduledTasksRuntime = (deps) => {
     maxGlobalConcurrency = DEFAULT_GLOBAL_CONCURRENCY,
     maxProjectConcurrency = DEFAULT_PROJECT_CONCURRENCY,
     maxRunDurationMs = DEFAULT_MAX_RUN_MS,
+    /** Host store write: (sessionId, directory, goal) => Promise */
+    persistSessionGoal = null,
+    /** Host store write: (sessionId, patch) => Promise — required for sidebar isolation */
+    persistSessionMetadata = null,
+    /**
+     * After Host isolation metadata is committed. Used to drop the session
+     * from the sidebar index immediately (do not wait for the next list sync).
+     * @type {null | ((event: { sessionID: string, directory?: string, metadata: object }) => void)}
+     */
+    onSystemSessionPersisted = null,
+    /** Host store read: (sessionId) => Promise<metadata|null> */
+    readSessionMetadata = null,
+    /**
+     * After a scheduled goal is first persisted, arm the session-goal loop.
+     * (session-goal runtime's own progress writes only broadcast — do not
+     * feed those back here.)
+     * @type {null | ((event: { sessionID: string, directory: string, metadata: object }) => void)}
+     */
+    onGoalPersisted = null,
   } = deps;
 
   let started = false;
@@ -702,44 +824,56 @@ export const createScheduledTasksRuntime = (deps) => {
       + '\n</system-reminder>';
   };
 
-  const buildPromptAsyncPayload = (task, projectPath) => ({
+  const buildSessionCreateInput = (task, projectPath, title, metadata) => ({
+    title,
+    location: { directory: projectPath },
+    metadata,
+    ...(task.execution.agent ? { agent: task.execution.agent } : {}),
     model: {
+      id: task.execution.modelID,
       providerID: task.execution.providerID,
-      modelID: task.execution.modelID,
+      ...(task.execution.variant ? { variant: task.execution.variant } : {}),
     },
-    ...(task.execution.agent ? { agent: task.execution.agent } : {}),
-    ...(task.execution.variant ? { variant: task.execution.variant } : {}),
-    parts: [
-      {
-        type: 'text',
-        text: expandSnippets(task.execution.prompt, projectPath),
-      },
-      ...(task.execution.goalEnabled
-        ? [{ type: 'text', text: buildGoalIntroText(task.execution.goalTokenBudget), synthetic: true }]
-        : []),
-    ],
   });
 
-  // Scheduled goal runs: stamp the goal onto the fresh session's metadata
-  // before the prompt goes out; the session-goal runtime picks the loop up
-  // from session events like any other goal.
+  const persistScheduledTaskIsolation = async (sessionID, directory, metadata) => {
+    if (typeof persistSessionMetadata !== 'function') {
+      throw new Error('scheduled-task session metadata persist is not configured');
+    }
+    await persistSessionMetadata(sessionID, metadata);
+    try {
+      onSystemSessionPersisted?.({ sessionID, directory, metadata });
+    } catch {
+      // Index/live hide is compensatory; Host persist is the authority.
+    }
+  };
+
+  const buildPromptText = (task, projectPath) => {
+    const promptText = expandSnippets(task.execution.prompt, projectPath);
+    if (!task.execution.goalEnabled) {
+      return promptText;
+    }
+    return `${promptText}\n${buildGoalIntroText(task.execution.goalTokenBudget)}`;
+  };
+
+  // Scheduled goal runs: write the file-backed objective, then persist a
+  // trackable goal record into the Host session-metadata store (same seam as
+  // manual UI goals). OpenCode SessionInfo has no openchamber.goal channel.
   const createTaskGoal = async ({
-    baseUrl,
-    authHeaders,
     sessionID,
     projectPath,
     task,
-    scheduledTaskMarker,
     signal,
   }) => {
     signal?.throwIfAborted?.();
-    const now = Date.now();
-    // File-backed objective keyed by session id: metadata stays light, the
-    // full expanded prompt lives under the OpenChamber data dir. If the file
-    // write fails, fall back to an inline (clamped) objective.
-    // Oversized prompts are distilled into audit criteria by the small model
-    // (the working agent gets the full prompt in chat anyway); on distill
-    // failure a head+tail excerpt keeps intent and acceptance criteria.
+    if (typeof persistSessionGoal !== 'function') {
+      throw new Error('session goal persist is not configured');
+    }
+    // File-backed objective keyed by session id: the full expanded prompt
+    // lives under the OpenChamber data dir. If the file write fails, fall
+    // back to an inline objective so parseGoalMetadata still accepts the
+    // record. Oversized prompts are distilled into audit criteria by the
+    // small model; on distill failure a head+tail excerpt keeps intent.
     let objectiveText = expandSnippets(task.execution.prompt, projectPath);
     if (objectiveText.length > 5000) {
       let distilled = null;
@@ -788,205 +922,142 @@ export const createScheduledTasksRuntime = (deps) => {
     try {
       const { writeObjective } = await import('../session-goal/objectives.js');
       await writeObjective(sessionID, objectiveText);
-      signal?.throwIfAborted?.();
       objectiveFile = true;
+      signal?.throwIfAborted?.();
     } catch (error) {
       if (signal?.aborted) {
         throw error;
       }
-      console.warn('[scheduled-tasks] goal objective file write failed, falling back to inline:', error?.message || error);
+      console.warn('[scheduled-tasks] goal objective file write failed, continuing with inline objective:', error?.message || error);
     }
     signal?.throwIfAborted?.();
+
+    const budgetRaw = task.execution?.goalTokenBudget;
+    const tokenBudget = Number.isFinite(budgetRaw) && budgetRaw > 0
+      ? Math.floor(budgetRaw)
+      : null;
+    const now = Date.now();
     const goal = {
-      id: `${now.toString(36)}${Math.random().toString(36).slice(2, 8)}`,
-      objective: objectiveFile ? '' : objectiveText.slice(0, 5000),
-      objectiveFile,
+      id: crypto.randomUUID(),
       status: 'active',
-      tokenBudget: task.execution.goalTokenBudget || null,
+      // File-backed: flag only (text lives under goals/<sessionId>.md).
+      // Inline fallback: full objective text when the file write failed.
+      objective: objectiveFile ? '' : objectiveText,
+      objectiveFile,
+      tokenBudget,
       tokensUsed: 0,
       turnsUsed: 0,
       blockedStreak: 0,
       note: '',
       statusReason: '',
       lastAccountedMessageID: '',
+      executionGeneration: 0,
       createdAt: now,
       updatedAt: now,
     };
-    const url = new URL(`${baseUrl}/session/${encodeURIComponent(sessionID)}`);
-    url.searchParams.set('directory', projectPath);
-    // Preserve the scheduledTask marker when goal metadata is patched; a full
-    // openchamber replace would otherwise drop ownership for history/UI.
-    const response = await fetch(url.toString(), {
-      method: 'PATCH',
-      headers: {
-        ...authHeaders,
-        'content-type': 'application/json',
-        accept: 'application/json',
-      },
-      body: JSON.stringify({
-        metadata: {
-          openchamber: {
-            ...(scheduledTaskMarker ? { scheduledTask: scheduledTaskMarker } : {}),
-            goal,
-          },
-        },
-      }),
-      ...(signal ? { signal } : {}),
-    });
-    if (!response.ok) {
-      throw new Error(`goal metadata patch failed (${response.status})`);
-    }
-  };
 
-  const archiveSessionBeforePrompt = async ({ client, sessionID, projectPath, signal }) => {
-    const archivePayload = {
-      sessionID,
-      directory: projectPath,
-      time: { archived: Date.now() },
-    };
-    const requestOptions = signal ? { signal } : undefined;
-    let result = await client.session.update(archivePayload, requestOptions);
-    if (isMissingSessionError(result)) {
-      await sleep(ARCHIVE_404_RETRY_DELAY_MS, signal);
-      signal?.throwIfAborted?.();
-      result = await client.session.update(archivePayload, requestOptions);
-    }
-    if (result?.error || (result?.data == null && result?.response?.ok === false)) {
-      const status = result?.error?.status ?? result?.error?.statusCode ?? result?.status;
-      const message = result?.error?.message || result?.error?.data?.message || 'session archive failed';
-      throw new Error(`session archive failed${status ? ` (${status})` : ''}: ${message}`);
+    // Persist failure must throw — never prompt as if the goal was registered.
+    const persisted = await persistSessionGoal(sessionID, projectPath, goal);
+    signal?.throwIfAborted?.();
+
+    if (typeof onGoalPersisted === 'function') {
+      try {
+        // Prefer full metadata when the seam returns the store object; otherwise
+        // synthesize the openchamber.goal shape the session-goal loop expects.
+        const metadata = persisted
+          && typeof persisted === 'object'
+          && !Array.isArray(persisted)
+          && persisted.openchamber
+          ? persisted
+          : { openchamber: { goal } };
+        onGoalPersisted({
+          sessionID,
+          directory: projectPath,
+          metadata,
+        });
+      } catch (error) {
+        console.warn('[scheduled-tasks] onGoalPersisted failed:', error?.message || error);
+      }
     }
   };
 
-  const runPromptAsync = async ({ baseUrl, authHeaders, sessionID, projectPath, task, signal }) => {
+  const runSessionPrompt = async ({ client, sessionID, projectPath, task, signal }) => {
     signal?.throwIfAborted?.();
-    const promptUrl = new URL(`${baseUrl}/session/${encodeURIComponent(sessionID)}/prompt_async`);
-    promptUrl.searchParams.set('directory', projectPath);
-    const response = await fetch(promptUrl.toString(), {
-      method: 'POST',
-      headers: {
-        ...authHeaders,
-        'content-type': 'application/json',
-        accept: 'application/json',
-      },
-      body: JSON.stringify(buildPromptAsyncPayload(task, projectPath)),
-      ...(signal ? { signal } : {}),
-    });
-
-    if (!response.ok) {
-      const body = await response.text().catch(() => '');
-      throw new Error(`prompt_async failed (${response.status})${body ? `: ${body}` : ''}`);
-    }
+    const requestOptions = signal ? { signal } : undefined;
+    await client.session.prompt({
+      sessionID,
+      text: buildPromptText(task, projectPath),
+    }, requestOptions);
   };
 
   /**
-   * prompt_async / command return when the turn is *admitted*, not when the
-   * agent finishes. History must reflect the real session (or goal) outcome and
-   * wall-clock duration — poll OpenCode until idle+settled or a terminal goal.
+   * session.prompt / command return when the turn is *admitted*, not when the
+   * agent finishes. History must reflect the real session outcome and
+   * wall-clock duration — poll until idle+settled on a latest-side message
+   * page (order=desc). finish tool-calls and incomplete assistants never
+   * succeed; two incomplete idle probes must not invent success.
+   * session.active / message.list failures stay unknown — never idle or empty
+   * success. Goal-enabled runs that passed admission still settle on the
+   * assistant tail here when Host goal state is unavailable.
    */
   const waitForRunOutcome = async ({
     client,
     sessionID,
-    projectPath,
-    goalEnabled,
     signal,
   }) => {
     const requestOptions = signal ? { signal } : undefined;
-    let incompleteAssistantProbes = 0;
     let emptyIdleProbes = 0;
 
     for (;;) {
       signal?.throwIfAborted?.();
 
-      if (goalEnabled && typeof client?.session?.get === 'function') {
+      let sessionBusy = null;
+      if (typeof client?.session?.active === 'function') {
         try {
-          const sessionResult = await client.session.get({
-            sessionID,
-            directory: projectPath,
-          }, requestOptions);
-          if (!sessionResult?.error) {
-            const goal = extractGoalFromSession(sessionResult?.data);
-            if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
-              if (goal.status === 'complete') {
-                return { outcome: 'success' };
-              }
-              return {
-                outcome: 'error',
-                error: goal.note || `goal ${goal.status}`,
-              };
-            }
+          const activeMap = await client.session.active(requestOptions);
+          if (activeMap && typeof activeMap === 'object' && !Array.isArray(activeMap)) {
+            sessionBusy = Object.prototype.hasOwnProperty.call(activeMap, sessionID);
           }
+          // Malformed / thrown active stays null → unknown, keep polling.
         } catch (error) {
           if (signal?.aborted) throw error;
-          // Transient get failures: keep polling until watchdog aborts.
         }
       }
 
-      let sessionBusy = false;
-      if (typeof client?.session?.status === 'function') {
-        try {
-          const statusResult = await client.session.status({
-            directory: projectPath,
-          }, requestOptions);
-          if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
-            const statusValue = statusResult.data[sessionID];
-            const type = statusValue?.type ?? statusValue?.status;
-            sessionBusy = type === 'busy' || type === 'retry';
-          }
-        } catch (error) {
-          if (signal?.aborted) throw error;
+      if (sessionBusy !== false) {
+        if (sessionBusy === true) {
+          emptyIdleProbes = 0;
         }
-      }
-
-      if (sessionBusy) {
-        incompleteAssistantProbes = 0;
-        emptyIdleProbes = 0;
         await sleep(SESSION_SETTLEMENT_POLL_MS, signal);
         continue;
       }
 
-      // Non-goal runs settle on the first idle assistant tail. Goal runs only
-      // finish via terminal goal status above — idle between goal turns is normal.
-      if (!goalEnabled && typeof client?.session?.messages === 'function') {
-        try {
-          const messagesResult = await client.session.messages({
-            sessionID,
-            directory: projectPath,
-            limit: 50,
-          }, requestOptions);
-          if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
-            const lastInfo = readMessageInfo(messagesResult.data.at(-1));
-            if (lastInfo?.role === 'assistant') {
-              emptyIdleProbes = 0;
-              if (lastInfo.error) {
-                return {
-                  outcome: 'error',
-                  error: formatAssistantError(lastInfo.error),
-                };
-              }
-              if (lastInfo.time?.completed) {
-                return { outcome: 'success' };
-              }
-              incompleteAssistantProbes += 1;
-              if (incompleteAssistantProbes >= INCOMPLETE_ASSISTANT_SETTLE_PROBES) {
-                return { outcome: 'success' };
-              }
-            } else {
-              incompleteAssistantProbes = 0;
-              emptyIdleProbes += 1;
-              // Prompt admitted but no assistant yet, or aborted before reply.
-              // Allow several idle probes so we don't race the first token.
-              if (emptyIdleProbes >= 5 && lastInfo?.role === 'user') {
-                return {
-                  outcome: 'error',
-                  error: 'session ended without assistant response',
-                };
-              }
+      try {
+        const messages = await listLatestMessages(client, sessionID, requestOptions);
+        if (messages) {
+          const classified = classifyMessageTail(messages);
+          if (classified.outcome === 'success' || classified.outcome === 'error') {
+            return classified;
+          }
+          if (classified.outcome === 'awaiting_assistant') {
+            emptyIdleProbes += 1;
+            // Prompt admitted but no assistant yet, or aborted before reply.
+            // Allow several idle probes so we don't race the first token.
+            if (emptyIdleProbes >= 5) {
+              return {
+                outcome: 'error',
+                error: 'session ended without assistant response',
+              };
             }
+          } else {
+            // busy / unknown tails (tool-calls, incomplete, model-switch, …)
+            // keep polling — never promote incomplete idle to success.
+            emptyIdleProbes = 0;
           }
-        } catch (error) {
-          if (signal?.aborted) throw error;
         }
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        // message.list failure stays unknown — keep polling under the watchdog.
       }
 
       await sleep(SESSION_SETTLEMENT_POLL_MS, signal);
@@ -1003,7 +1074,9 @@ export const createScheduledTasksRuntime = (deps) => {
     const requestOptions = signal ? { signal } : undefined;
     let commands = [];
     try {
-      const response = await client.command.list({ directory: projectPath }, requestOptions);
+      const response = await client.command.list({
+        location: { directory: projectPath },
+      }, requestOptions);
       commands = Array.isArray(response?.data) ? response.data : [];
     } catch (error) {
       if (signal?.aborted) {
@@ -1020,28 +1093,30 @@ export const createScheduledTasksRuntime = (deps) => {
 
     await client.session.command({
       sessionID,
-      directory: projectPath,
       command: parsed.command,
       arguments: parsed.arguments,
       ...(task.execution.agent ? { agent: task.execution.agent } : {}),
-      model: `${task.execution.providerID}/${task.execution.modelID}`,
-      ...(task.execution.variant ? { variant: task.execution.variant } : {}),
+      model: {
+        id: task.execution.modelID,
+        providerID: task.execution.providerID,
+        ...(task.execution.variant ? { variant: task.execution.variant } : {}),
+      },
     }, requestOptions);
 
     return true;
   };
 
-  const abortCreatedSessionBestEffort = async ({ client, sessionID, projectPath }) => {
-    if (!sessionID || !client?.session?.abort) {
+  const interruptCreatedSessionBestEffort = async ({ client, sessionID }) => {
+    if (!sessionID || typeof client?.session?.interrupt !== 'function') {
       return;
     }
     try {
-      await client.session.abort({
+      await client.session.interrupt({
         sessionID,
-        directory: projectPath,
+        continue: false,
       });
     } catch {
-      // Never let upstream abort failure replace the watchdog timeout error.
+      // Never let upstream interrupt failure replace the watchdog timeout error.
     }
   };
 
@@ -1055,6 +1130,24 @@ export const createScheduledTasksRuntime = (deps) => {
 
     signal?.throwIfAborted?.();
 
+    // Goal-enabled tasks: refuse before session create / objective write /
+    // prompt when Host goal state is unavailable OR persist is not wired.
+    // Config + run-history stay; only this run is recorded as error (no
+    // false first-turn success / no create·distill·prompt side effects).
+    if (task.execution?.goalEnabled) {
+      const capability = getSessionGoalCapability();
+      if (!capability.supported) {
+        throw new Error(sessionGoalUnavailableMessage(capability));
+      }
+      if (typeof persistSessionGoal !== 'function') {
+        throw new Error('session goal persist is not configured');
+      }
+    }
+
+    if (typeof persistSessionMetadata !== 'function') {
+      throw new Error('scheduled-task session metadata persist is not configured');
+    }
+
     if (typeof waitForOpenCodeReady === 'function') {
       await waitForOpenCodeReady(10_000, 250);
       signal?.throwIfAborted?.();
@@ -1062,26 +1155,16 @@ export const createScheduledTasksRuntime = (deps) => {
 
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
     const authHeaders = getOpenCodeAuthHeaders();
-    const client = createOpencodeClient({
+    const client = makeOpenCodeV2Client({
       baseUrl,
-      headers: authHeaders,
+      authHeaders,
     });
     const requestOptions = signal ? { signal } : undefined;
 
-    const taskName = typeof task?.name === 'string' && task.name.trim().length > 0
-      ? task.name.trim()
-      : 'Schedule';
-    const scheduledTaskMarker = {
-      projectID,
-      taskID: task.id,
-      runID,
-      name: taskName,
-    };
-
     let sessionID;
-    // Watchdog abort must fire session.abort even while awaiting non-cancellable
-    // work (small-model distill / writeObjective). Register once after create;
-    // never on ordinary non-timeout failures or success.
+    // Watchdog abort must fire session.interrupt even while awaiting
+    // non-cancellable work (small-model distill / writeObjective). Register
+    // once after create; never on ordinary non-timeout failures or success.
     let sessionAbortStarted = false;
     let onWatchdogAbort = null;
     const triggerSessionAbortOnce = () => {
@@ -1089,7 +1172,7 @@ export const createScheduledTasksRuntime = (deps) => {
         return;
       }
       sessionAbortStarted = true;
-      void abortCreatedSessionBestEffort({ client, sessionID, projectPath });
+      void interruptCreatedSessionBestEffort({ client, sessionID });
     };
     const clearWatchdogAbortListener = () => {
       if (onWatchdogAbort && signal) {
@@ -1099,15 +1182,21 @@ export const createScheduledTasksRuntime = (deps) => {
     };
 
     try {
-      const sessionResponse = await client.session.create({
-        directory: projectPath,
-        title,
-        metadata: buildScheduledTaskMetadata(scheduledTaskMarker),
-      }, requestOptions);
-      sessionID = sessionResponse?.data?.id;
+      const isolationMetadata = buildScheduledTaskMetadata({
+        projectID,
+        taskID: task.id,
+        runID,
+        name: task.name,
+      });
+      const session = await client.session.create(
+        buildSessionCreateInput(task, projectPath, title, isolationMetadata),
+        requestOptions,
+      );
+      sessionID = session?.id;
       if (!sessionID) {
         throw new Error('failed to create session');
       }
+      await persistScheduledTaskIsolation(sessionID, projectPath, isolationMetadata);
 
       if (signal) {
         if (signal.aborted) {
@@ -1130,19 +1219,6 @@ export const createScheduledTasksRuntime = (deps) => {
         }
       }
 
-      try {
-        // Archive must succeed before any goal/prompt/command work. A 404 gets
-        // one short bounded retry; any other failure aborts without prompting.
-        await archiveSessionBeforePrompt({ client, sessionID, projectPath, signal });
-      } catch (archiveError) {
-        if (attachFailed) {
-          throw new Error(
-            `attachSession failed (${safeErrorMessage(attachFailed)}); archive also failed: ${safeErrorMessage(archiveError)}`,
-          );
-        }
-        throw archiveError;
-      }
-
       if (attachFailed) {
         throw new Error(`attachSession failed: ${safeErrorMessage(attachFailed)}`);
       }
@@ -1162,12 +1238,9 @@ export const createScheduledTasksRuntime = (deps) => {
 
       if (task.execution.goalEnabled) {
         await createTaskGoal({
-          baseUrl,
-          authHeaders,
           sessionID,
           projectPath,
           task,
-          scheduledTaskMarker,
           signal,
         });
       }
@@ -1182,9 +1255,8 @@ export const createScheduledTasksRuntime = (deps) => {
         signal,
       });
       if (!executedAsCommand) {
-        await runPromptAsync({
-          baseUrl,
-          authHeaders,
+        await runSessionPrompt({
+          client,
           sessionID,
           projectPath,
           task,
@@ -1192,13 +1264,11 @@ export const createScheduledTasksRuntime = (deps) => {
         });
       }
 
-      // Do not finalize on admission alone — wait for the real agent turn (or
-      // goal loop) so history status/duration match what the user sees in chat.
+      // Do not finalize on admission alone — wait for the real agent turn so
+      // history status/duration match what the user sees in chat.
       const settlement = await waitForRunOutcome({
         client,
         sessionID,
-        projectPath,
-        goalEnabled: Boolean(task.execution?.goalEnabled),
         signal,
       });
 
@@ -1369,8 +1439,8 @@ export const createScheduledTasksRuntime = (deps) => {
 
           if (raced.timedOut) {
             // Bound: do not await uncancellable steps (distill / writeObjective).
-            // session.abort is started by the signal listener on create; later
-            // throwIfAborted gates stop goal PATCH / command / prompt.
+            // session.interrupt is started by the signal listener on create;
+            // later throwIfAborted gates stop goal write / command / prompt.
             throw timeoutError;
           }
 
@@ -1701,15 +1771,16 @@ export const createScheduledTasksRuntime = (deps) => {
 
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
     const authHeaders = getOpenCodeAuthHeaders();
-    const client = createOpencodeClient({
+    const client = makeOpenCodeV2Client({
       baseUrl,
-      headers: authHeaders,
+      authHeaders,
     });
     const snapshot = await snapshotSessionOutcome({
       client,
       sessionID,
       projectPath,
       goalEnabled: Boolean(task.execution?.goalEnabled),
+      readSessionMetadata,
     });
     if (snapshot.outcome !== 'success') {
       return;