orizu 0.5.49 → 0.5.50

package/src/auth-commands.ts

@@ -11,20 +11,18 @@ import {
   resolveLogoutTarget,
   assertSecureTokenTransport,
   authedFetch,
-  credentialRequestRedirectPolicy,
 } from './http.js'
 import {
+  clearUnreadableServerCredentials,
   hasResolvableAuth,
   rememberProcessSecret,
   saveServerCredentials,
   getServerCredentials,
-  clearServerCredentials,
   resolveAuthTokenForBaseUrl,
 } from './credentials.js'
 import { printJson, printLine, printLoginProgress } from './cli-console-output.js'
 import { shouldUseHeadlessLogin, waitForHeadlessAuthorization } from './headless-login.js'
 import { renderCliAuthBrowserPage } from './cli-auth-browser-page.js'
-import { describeLogoutHttpFailure, describeLogoutTransportFailure } from './logout-diagnostic.js'
 import { resolveProjectSelection } from './account-directory.js'
 
 import type { LoginResponse } from './types.js'
@@ -312,6 +310,15 @@ async function logout(baseUrlOverride?: string) {
   const { baseUrl, credentialBaseUrl } = resolveLogoutTarget(baseUrlOverride)
   const credentials = getServerCredentials(credentialBaseUrl)
   if (!credentials) {
+    // A saved sign-in this CLI cannot read is removed: it may be a pasted token (ORI-2675).
+    if (clearUnreadableServerCredentials(credentialBaseUrl)) {
+      if (hasJsonFlag()) {
+        printJson({ status: 'removed-unreadable', server: baseUrl })
+        return
+      }
+      printLine(`Removed the saved sign-in for ${sanitizeTerminalText(baseUrl)}, which this CLI could not read.`)
+      return
+    }
     if (hasJsonFlag()) {
       printJson({ status: 'already-logged-out', server: baseUrl })
       return
@@ -319,34 +326,18 @@ async function logout(baseUrlOverride?: string) {
     printLine(`Already logged out for ${sanitizeTerminalText(baseUrl)}.`)
     return
   }
-  const authorizationToken = 'accessToken' in credentials
-    ? credentials.accessToken
-    : credentials.apiKey
-  const logoutSecrets = [
-    authorizationToken,
-    ...('refreshToken' in credentials ? [credentials.refreshToken] : []),
-  ]
-  let remoteLogoutError: string | null = null
-  try {
-    assertSecureTokenTransport(baseUrl)
-    const response = await fetch(`${baseUrl}/api/cli/auth/logout`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${authorizationToken}`,
-      },
-      body: 'refreshToken' in credentials
-        ? JSON.stringify({ refreshToken: credentials.refreshToken })
-        : undefined,
-      ...credentialRequestRedirectPolicy(),
-    })
-    if (!response.ok) {
-      remoteLogoutError = await describeLogoutHttpFailure(response, logoutSecrets)
+  const { storedLogout } = await import('./stored-session-requests.js')
+  const { remoteError: remoteLogoutError, localCredentialCleared } = await storedLogout(baseUrl, credentialBaseUrl, credentials)
+  // Another login saved for this server while logout was out is kept.
+  if (!localCredentialCleared && getServerCredentials(credentialBaseUrl)) {
+    if (hasJsonFlag()) {
+      printJson({ status: 'changed', server: baseUrl, remoteLogoutError })
+      process.exitCode = 1
+      return
     }
-  } catch (error) {
-    remoteLogoutError = describeLogoutTransportFailure(error, logoutSecrets)
+    if (remoteLogoutError) console.warn(`Warning: remote logout failed: ${remoteLogoutError}`)
+    throw new Error(`ORIZU_CREDENTIALS_CHANGED: another login was saved for ${sanitizeTerminalText(baseUrl)} during logout; it was kept. Run orizu logout again to remove it.`)
   }
-  clearServerCredentials(credentialBaseUrl)
   if (hasJsonFlag()) {
     printJson({ status: 'logged-out', server: baseUrl, remoteLogoutError })
     return

package/src/credentials.ts

@@ -387,6 +387,30 @@ export function loadCredentialsConfig(): StoredCredentialsV2 | StoredCredentials
   return null
 }
 
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0
+}
+
+/**
+ * A saved sign-in this CLI can use: a session (it has an access token) or an
+ * API key. Plain code, not Effect Schema: this file is loaded by every
+ * command, including hosted sessions signed with ORIZU_TOKEN, which must never
+ * load Effect.
+ */
+function isServerCredentials(value: unknown): value is ServerCredentials {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const entry = value as Record<string, unknown>
+  if ('accessToken' in entry) {
+    return isNonEmptyString(entry.accessToken)
+      && isNonEmptyString(entry.refreshToken)
+      && typeof entry.expiresAt === 'number'
+      && Number.isFinite(entry.expiresAt)
+  }
+  return isNonEmptyString(entry.apiKey)
+}
+
+const warnedUnreadableServers = new Set<string>()
+
 export function getServerCredentials(baseUrl: string): ServerCredentials | null {
   const config = loadCredentialsConfig()
   if (!config) {
@@ -397,7 +421,19 @@ export function getServerCredentials(baseUrl: string): ServerCredentials | null
     return null
   }
 
-  return config.servers[baseUrl] || null
+  const entry: unknown = config.servers[baseUrl]
+  if (entry === null || entry === undefined) return null
+  if (!isServerCredentials(entry)) {
+    // Never the value: a hand-edited file may hold a token here (ORI-2675).
+    if (!warnedUnreadableServers.has(baseUrl)) {
+      warnedUnreadableServers.add(baseUrl)
+      console.warn(
+        `Warning: the saved sign-in for ${baseUrl} is not in a format this CLI understands. Run \`orizu login --server ${baseUrl}\` to replace it, or \`orizu logout --server ${baseUrl}\` to remove it.`
+      )
+    }
+    return null
+  }
+  return entry
 }
 
 export function saveServerCredentials(baseUrl: string, credentials: ServerCredentials) {
@@ -433,6 +469,8 @@ export function updateServerCredentials(baseUrl: string, credentials: ServerCred
 }
 
 export function credentialsEqual(left: ServerCredentials, right: ServerCredentials): boolean {
+  // Entries read straight from the file may be malformed; those never match.
+  if (!isServerCredentials(left) || !isServerCredentials(right)) return false
   if ('apiKey' in left || 'apiKey' in right) {
     return 'apiKey' in left && 'apiKey' in right && left.apiKey === right.apiKey
   }
@@ -457,9 +495,29 @@ export function updateServerCredentialsIfCurrent(
   })
 }
 
+function isServerAddress(value: unknown): value is string {
+  if (typeof value !== 'string') return false
+  try {
+    normalizeBaseUrl(value)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Never the value: the "Invalid server URL" error would print it (ORI-2675).
+// No fallback to the default server either: with an app.orizu.ai sign-in
+// saved, that would run the command as a different account.
+function unreadableActiveServerError(): Error {
+  return new Error('The saved server in credentials.json isn\'t a valid address. Run `orizu login --server <url>`.')
+}
+
 export function getActiveBaseUrl(): string | null {
   const config = loadCredentialsConfig()
-  return config?.activeBaseUrl || null
+  const active: unknown = config?.activeBaseUrl
+  if (active === null || active === undefined || active === '') return null
+  if (isServerAddress(active)) return active
+  throw unreadableActiveServerError()
 }
 
 /** Resolve the selected server and move a retired production credential atomically. */
@@ -476,7 +534,11 @@ export function resolveCredentialServer(selected?: string): string | null {
   return withCredentialsTransactionLock(() => {
     const config = loadCredentialsConfig()
     // Another process may have selected a different server while we waited.
-    const currentSource = selected ?? config?.activeBaseUrl
+    const storedSource: unknown = config?.activeBaseUrl
+    if (!selected && storedSource !== null && storedSource !== undefined && storedSource !== '' && !isServerAddress(storedSource)) {
+      throw unreadableActiveServerError()
+    }
+    const currentSource = selected ?? (isServerAddress(storedSource) ? storedSource : null)
     if (!currentSource) return null
     const currentTarget = canonicalServerUrl(currentSource)
     if (!config || normalizeBaseUrl(currentSource) === currentTarget) return currentTarget
@@ -645,6 +707,24 @@ export function clearServerCredentials(baseUrl: string): boolean {
   })
 }
 
+/**
+ * Remove a saved sign-in this CLI cannot read (it may be a pasted token).
+ * Returns false when there is none, or when it has become readable since.
+ */
+export function clearUnreadableServerCredentials(baseUrl: string): boolean {
+  return withCredentialsTransactionLock(() => {
+    const config = loadCredentialsConfig()
+    if (!config || !Object.hasOwn(config.servers, baseUrl)) return false
+    const entry: unknown = config.servers[baseUrl]
+    if (entry === null || entry === undefined || isServerCredentials(entry)) return false
+
+    delete config.servers[baseUrl]
+    if (config.activeBaseUrl === baseUrl) config.activeBaseUrl = null
+    writeCredentials(config)
+    return true
+  })
+}
+
 export function clearCredentialsFile() {
   return withCredentialsTransactionLock(() => {
     const path = getCredentialsPath()

package/src/dataset-transfer-upload.ts

@@ -52,6 +52,12 @@ function isAuthContextChange(cause: unknown) {
   return cause instanceof Error && cause.message.startsWith('ORIZU_AUTH_CONTEXT_CHANGED:')
 }
 
+// authedFetch sets this when the server answered 401 and the sign-in refresh
+// then failed, so the request was not sent again: nothing was written.
+function isRequestRejected(cause: unknown) {
+  return cause instanceof Error && (cause as { requestRejected?: unknown }).requestRejected === true
+}
+
 // Only the existing authentication client's rejected-token refresh may replay a
 // request. No transient/transport retries belong around these non-idempotent writes.
 function post<T>(path: string, body: unknown, context: string, prefix: string, timeoutMs: number): Effect.Effect<T, DatasetWriteFailure> {
@@ -69,7 +75,7 @@ function post<T>(path: string, body: unknown, context: string, prefix: string, t
         return await parseJsonResponse<T>(response, context)
       },
       catch: cause => cause instanceof DatasetWriteFailure ? cause : new DatasetWriteFailure(
-        cause instanceof Error ? cause.message : String(cause), requestStarted && !isAuthContextChange(cause) ? 'unknown' : 'rejected', { cause },
+        cause instanceof Error ? cause.message : String(cause), requestStarted && !isAuthContextChange(cause) && !isRequestRejected(cause) ? 'unknown' : 'rejected', { cause },
       ),
     }).pipe(Effect.timeoutOrElse({
       duration: timeoutMs,

package/src/directory-list-read.ts

@@ -0,0 +1,123 @@
+// The team and project lists that setup, `teams list` and `projects list`
+// read. Plain TypeScript on purpose: hosted sessions list teams and projects
+// with ORIZU_TOKEN or ORIZU_TOKEN_FILE set, and that path loads no Effect.
+import { parseJsonResponse } from './json-response.js'
+
+type ListRequest = (path: string, init: RequestInit) => Promise<Response>
+
+interface ListShape<T> {
+  /** How the list is named in messages: "team list". */
+  what: string
+  /** The words before a refused reply's text, as before: "Failed to fetch teams". */
+  failed: string
+  /** The label for a reply that isn't JSON: "Teams list". */
+  label: string
+  /** The reply's field holding the list: "teams". */
+  field: string
+  /** The item with any missing optional field filled in, or null when the CLI can't use it. */
+  read: (value: unknown) => T | null
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value)
+
+// Every command that names a project reads these lists, and none of them read
+// ORIZU_DATASET_TRANSFER_TIMEOUT_MS before, so they get a fixed limit. Setup
+// passes the setting, as its team and project creates already use it.
+const DEFAULT_LIST_TIMEOUT_MS = 120_000
+
+const isNonEmptyString = (value: unknown): value is string => typeof value === 'string' && value.length > 0
+
+/** A field the CLI only shows: absent, null or a string. */
+const isOptionalString = (value: unknown): value is string | null | undefined =>
+  value === undefined || value === null || typeof value === 'string'
+
+export interface ListedTeam {
+  id: string
+  name: string
+  slug: string
+  role: string
+}
+
+export interface ListedProject {
+  id: string
+  name: string
+  slug: string
+  teamId: string
+  teamName: string
+  teamSlug: string
+  role: string
+}
+
+// The CLI needs a team's id and slug. Its name and role are only shown, and a
+// missing role was already shown as "-", so those may be missing; any other
+// field the server sends is kept as it came.
+export const TEAM_LIST: ListShape<ListedTeam> = {
+  what: 'team list',
+  failed: 'Failed to fetch teams',
+  label: 'Teams list',
+  field: 'teams',
+  read: value => {
+    if (!isRecord(value) || !isNonEmptyString(value.id) || !isNonEmptyString(value.slug)) return null
+    if (!isOptionalString(value.name) || !isOptionalString(value.role)) return null
+    return { ...value, id: value.id, slug: value.slug, name: value.name ?? value.slug, role: value.role ?? '' }
+  },
+}
+
+// Setup files each project by its slug and records its id, under its team's
+// slug, so those three must be there; the rest are only shown.
+export const PROJECT_LIST: ListShape<ListedProject> = {
+  what: 'project list',
+  failed: 'Failed to fetch projects',
+  label: 'Projects list',
+  field: 'projects',
+  read: value => {
+    if (!isRecord(value) || !isNonEmptyString(value.id) || !isNonEmptyString(value.slug) || !isNonEmptyString(value.teamSlug)) return null
+    if (!isOptionalString(value.name) || !isOptionalString(value.teamId) || !isOptionalString(value.teamName) || !isOptionalString(value.role)) return null
+    return {
+      ...value,
+      id: value.id,
+      slug: value.slug,
+      teamSlug: value.teamSlug,
+      name: value.name ?? value.slug,
+      teamId: value.teamId ?? '',
+      teamName: value.teamName ?? value.teamSlug,
+      role: value.role ?? '',
+    }
+  },
+}
+
+/**
+ * One request with a time limit, its reply read under the same limit. A list
+ * Orizu can't read stops here, before any caller writes a file.
+ */
+export async function readDirectoryList<T>(
+  request: ListRequest,
+  path: string,
+  shape: ListShape<T>,
+  timeoutMs = DEFAULT_LIST_TIMEOUT_MS,
+): Promise<T[]> {
+  const controller = new AbortController()
+  let timedOut = false
+  const timer = setTimeout(() => { timedOut = true; controller.abort() }, timeoutMs)
+  try {
+    const response = await request(path, { signal: controller.signal })
+    if (!response.ok) throw new Error(`${shape.failed}: ${await response.text()}`)
+    const data = await parseJsonResponse<unknown>(response, shape.label)
+    const list = isRecord(data) ? data[shape.field] : undefined
+    const unreadable = new Error(`The server sent a ${shape.what} Orizu can't read. Run \`orizu update\` and try again; if it still fails, the server may be having trouble.`)
+    if (!Array.isArray(list)) throw unreadable
+    const items: T[] = []
+    for (const value of list) {
+      const item = shape.read(value)
+      if (item === null) throw unreadable
+      items.push(item)
+    }
+    return items
+  } catch (error: unknown) {
+    if (timedOut) throw new Error(`Orizu didn't get the ${shape.what} within ${timeoutMs / 1000} s. Check your connection and try again.`)
+    throw error
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/src/hosted-boot.ts

@@ -50,6 +50,8 @@ import {
 import {
   INJECTED_ENV_VARS_ENV,
   closeHostedLoopSession,
+  hostedSessionOpenCodeLogPath,
+  prestartHostedOpenCode,
   runHostedLoop,
   runHostedLoopTurn,
   startHostedLoopSession,
@@ -973,16 +975,20 @@ export async function runHostedBoot(opts: RunHostedBootOptions): Promise<HostedB
   // work and closed however the boot ends.
   const liveChannels: HostedLiveChannel[] = []
   const idleWait = new AbortController()
+  // ORI-2512: stops anything the boot started in the background.
+  const bootCleanups: Array<() => void> = []
   try {
-    return await runHostedBootWithLive(opts, liveChannels, idleWait.signal)
+    return await runHostedBootWithLive(opts, liveChannels, idleWait.signal, bootCleanups)
   } finally {
     idleWait.abort()
     for (const channel of liveChannels) channel.close()
+    for (const cleanup of bootCleanups) cleanup()
   }
 }
 
 async function runHostedBootWithLive(
-  opts: RunHostedBootOptions, liveChannels: HostedLiveChannel[], idleWaitSignal: AbortSignal
+  opts: RunHostedBootOptions, liveChannels: HostedLiveChannel[], idleWaitSignal: AbortSignal,
+  bootCleanups: Array<() => void>
 ): Promise<HostedBootResult> {
   const env = opts.env
   const processEnv = opts.processEnv ?? process.env
@@ -1223,6 +1229,46 @@ async function runHostedBootWithLive(
 
   const helperValue = `!node ${helperScriptAbs} ${bootContextAbs}`
 
+  // The loop's context (step 6), built before the clone so the background
+  // start below uses the same settings. The bearer PROVIDER keeps the event
+  // sink's bearer fresh from the same pull-mode source; the DO-provisioned
+  // sandbox always runs the pre-baked image under an enforced egress policy, so
+  // the loop's startup egress canary + deferred setup hook are both armed.
+  const model = session.model ?? DEFAULT_HOSTED_MODEL
+  const configuredOpenCodePort = resolveTestPositiveInteger(
+    processEnv, 'ORIZU_HOSTED_TEST_OPENCODE_PORT', 65_535
+  ) ?? (processEnv.ORIZU_OPENCODE_PORT
+    ? Number(processEnv.ORIZU_OPENCODE_PORT)
+    : undefined)
+  if (configuredOpenCodePort !== undefined && (!Number.isInteger(configuredOpenCodePort) || configuredOpenCodePort < 1 || configuredOpenCodePort > 65_535)) {
+    throw new Error('ORIZU_OPENCODE_PORT must be a valid TCP port')
+  }
+  const loopContext: HostedLoopContext = {
+    apiBaseUrl: env.baseUrl,
+    runId,
+    bearerFile: bearerFileAbs,
+    taskFile: taskFileAbs,
+    workspaceDir,
+    sessionBranch: session.repoBranch,
+    repositoryRemote: repo.cloneUrl,
+    repositoryCredentialHelper: helperValue,
+    model,
+    reasoningEffort: session.reasoningEffort ?? undefined,
+    sessionOrigin: session.surface === 'hosted-web' ? 'hosted-web' : 'cli',
+    messageId: `${runId}:task`,
+    resumeAgentSessionId: session.agentSessionId ?? undefined,
+    author: AGENT_GIT_IDENTITY,
+    anthropicDummyKey: env.anthropicDummyKey ?? ANTHROPIC_DUMMY_KEY,
+    // Derive the per-prompt max-duration cap from the session duration so a long
+    // run is not killed at the hard-coded 90-min prompt cap (ALI-1061). Unset →
+    // the harness default (5400s) floor holds.
+    sandboxBudgetMs: session.durationMinutes != null ? session.durationMinutes * 60 * 1000 : undefined,
+    prebaked: true,
+    egressCanaryHost: (processEnv.NODE_ENV === 'test' ? processEnv.ORIZU_HOSTED_TEST_EGRESS_CANARY_HOST : undefined) ?? DEFAULT_EGRESS_CANARY_HOST,
+    runSetupHook: true,
+    opencodePort: configuredOpenCodePort,
+  }
+
   // 4b — ORI-2118: a hosted session's Artifacts copy is created empty (forks
   // of a busy team copy cannot be cloned). Fill it from the server-selected
   // origin before cloning. Selected saved history is checked on retries too.
@@ -1231,6 +1277,20 @@ async function runHostedBootWithLive(
   }
   // ORI-2520: a woken sandbox boots on the disk it slept with (see step 5).
   const wokenDisk = existsSync(workspaceDir) && readdirSync(workspaceDir).length > 0
+  // ORI-2512 cut 3: start the egress canary and then OpenCode while the
+  // repository clones. OpenCode runs in the (empty) working folder, which the
+  // clone fills in place, and is asked nothing until after the clone. The
+  // one-shot test seam (opts.runLoop) starts nothing early, but makes the
+  // folder the same way, so it takes production's fill.
+  mkdirp(workspaceDir)
+  const prestart = opts.runLoop
+    ? null
+    : prestartHostedOpenCode(
+        { ...loopContext, projectId: session.projectId },
+        { logPath: hostedSessionOpenCodeLogPath({ sessionDir: sessionDirAbs, sessionId: env.sessionId }) }
+      )
+  // However the boot ends, nothing it started outlives it.
+  if (prestart) bootCleanups.push(prestart.stop)
   // Set when the working folder came from the team copy (ORI-2512); settles
   // when the background fill of the session copy ends, and never rejects.
   let sessionCopyFilled: Promise<void> | null = null
@@ -1355,7 +1415,8 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
     const checkedOut = assertWokenRepo(exec, workspaceDir, repo.cloneUrl)
     log(`woken disk: reusing the repo (checked out: ${checkedOut})`)
   } else {
-    const clone = exec('git', [
+    // Not blocking, so the background start above keeps running (ORI-2512).
+    const clone = await execAsync('git', [
       'clone',
       '--depth',
       '1',
@@ -1430,45 +1491,6 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
     log,
   })
 
-  // 6 — Launch the hosted loop, reused in-process. The bearer PROVIDER keeps the
-  // event sink's bearer fresh from the same pull-mode source; the DO-provisioned
-  // sandbox always runs the pre-baked image under an enforced egress policy, so
-  // the loop's startup egress canary + deferred setup hook are both armed.
-  const model = session.model ?? DEFAULT_HOSTED_MODEL
-  const configuredOpenCodePort = resolveTestPositiveInteger(
-    processEnv, 'ORIZU_HOSTED_TEST_OPENCODE_PORT', 65_535
-  ) ?? (processEnv.ORIZU_OPENCODE_PORT
-    ? Number(processEnv.ORIZU_OPENCODE_PORT)
-    : undefined)
-  if (configuredOpenCodePort !== undefined && (!Number.isInteger(configuredOpenCodePort) || configuredOpenCodePort < 1 || configuredOpenCodePort > 65_535)) {
-    throw new Error('ORIZU_OPENCODE_PORT must be a valid TCP port')
-  }
-  const loopContext: HostedLoopContext = {
-    apiBaseUrl: env.baseUrl,
-    runId,
-    bearerFile: bearerFileAbs,
-    taskFile: taskFileAbs,
-    workspaceDir,
-    sessionBranch: session.repoBranch,
-    repositoryRemote: repo.cloneUrl,
-    repositoryCredentialHelper: helperValue,
-    model,
-    reasoningEffort: session.reasoningEffort ?? undefined,
-    sessionOrigin: session.surface === 'hosted-web' ? 'hosted-web' : 'cli',
-    messageId: `${runId}:task`,
-    resumeAgentSessionId: session.agentSessionId ?? undefined,
-    author: AGENT_GIT_IDENTITY,
-    anthropicDummyKey: env.anthropicDummyKey ?? ANTHROPIC_DUMMY_KEY,
-    // Derive the per-prompt max-duration cap from the session duration so a long
-    // run is not killed at the hard-coded 90-min prompt cap (ALI-1061). Unset →
-    // the harness default (5400s) floor holds.
-    sandboxBudgetMs: session.durationMinutes != null ? session.durationMinutes * 60 * 1000 : undefined,
-    prebaked: true,
-    egressCanaryHost: DEFAULT_EGRESS_CANARY_HOST,
-    runSetupHook: true,
-    opencodePort: configuredOpenCodePort,
-  }
-
   const runLoop =
     opts.runLoop ??
     ((input): Promise<HostedLoopResult> =>
@@ -1523,7 +1545,7 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
     projectId: session.projectId,
     sessionDir: sessionDirAbs,
   }
-  const hostedLoopSession = await startHostedLoopSession(sessionContext)
+  const hostedLoopSession = await startHostedLoopSession(sessionContext, { prestart })
   let current = session.pendingTurn?.runId === runId
     ? { runId, ordinal: session.pendingTurn.ordinal, body: promptForPendingHostedTurn(session.pendingTurn) }
     : { runId, ordinal: 1, body: session.task }

package/src/hosted-harness-opencode.ts

@@ -1150,7 +1150,7 @@ export interface SpawnOpenCodeOptions extends OpenCodeConfigOptions {
   spawn?: (
     cmd: string[],
     opts: { cwd?: string; env: Record<string, string>; logPath?: string }
-  ) => { kill: () => void }
+  ) => { kill: () => void; hasExited?: () => boolean; exitReason?: () => string | null }
   /** File the spawner should append opencode's stdout/stderr to. On readiness
    *  timeout its tail is included in the thrown error — the bare "fetch failed"
    *  this replaces was undiagnosable (ALI-1034). */
@@ -1203,6 +1203,33 @@ function readLogTail(logPath: string | undefined): string | null {
  * (see the SSE-fragility note on that constant).
  */
 export async function spawnOpenCode(opts: SpawnOpenCodeOptions): Promise<SpawnedOpenCode> {
+  return waitOpenCodeReady(await startOpenCodeProcess(opts), opts)
+}
+
+/** A started `opencode serve` that has not been asked anything yet. */
+export interface StartedOpenCode {
+  baseUrl: string
+  port: number
+  stop: () => void
+  /** True once the process has exited (when the spawner can tell). */
+  hasExited: () => boolean
+  /** Why it could not be started (for example ENOENT), when known. */
+  exitReason: () => string | null
+  startedAt: number
+}
+
+/** `waitOpenCodeReady` found the process already gone; nothing answered. */
+export class OpenCodeExitedError extends Error {}
+
+/**
+ * The first half of `spawnOpenCode`: refresh the model catalog and start the
+ * process, without asking it anything. ORI-2512: the hosted boot calls this
+ * while the repository is still cloning. OpenCode ties its folder to a project
+ * on the first request it gets, so nothing may ask it anything until the
+ * folder holds the repository (measured on 1.18.35: a request into an empty
+ * folder binds it to the `global` project for good).
+ */
+export async function startOpenCodeProcess(opts: SpawnOpenCodeOptions): Promise<StartedOpenCode> {
   const port = opts.port ?? DEFAULT_OPENCODE_PORT
   const env: Record<string, string> = {
     OPENCODE_CONFIG_CONTENT: buildOpenCodeConfigContent(opts),
@@ -1226,16 +1253,34 @@ export async function spawnOpenCode(opts: SpawnOpenCodeOptions): Promise<Spawned
         stderr: 'ignore',
       })
     })
-  const child = spawnImpl(cmd, { cwd: opts.cwd, env, logPath: opts.logPath })
-  const baseUrl = `http://localhost:${port}`
+  const child: { kill: () => void; hasExited?: () => boolean; exitReason?: () => string | null } = spawnImpl(cmd, { cwd: opts.cwd, env, logPath: opts.logPath })
+  return {
+    baseUrl: `http://localhost:${port}`,
+    port,
+    stop: () => child.kill(),
+    hasExited: () => child.hasExited?.() ?? false,
+    exitReason: () => child.exitReason?.() ?? null,
+    startedAt: Date.now(),
+  }
+}
 
+/**
+ * The second half of `spawnOpenCode`: poll until the started server answers.
+ * The budget counts from this call, not from the start, so a long clone
+ * before it cannot use the budget up. `readyAfterMs` is from the start.
+ */
+export async function waitOpenCodeReady(
+  started: StartedOpenCode,
+  opts: Pick<SpawnOpenCodeOptions, 'readyTimeoutMs' | 'readyPollMs' | 'signal' | 'fetchImpl' | 'logPath'>
+): Promise<SpawnedOpenCode> {
+  const { baseUrl, port } = started
   const fetchImpl = opts.fetchImpl ?? (globalThis.fetch as typeof fetch)
   const timeoutMs = opts.readyTimeoutMs ?? OPENCODE_READY_TIMEOUT_MS
   const pollMs = opts.readyPollMs ?? OPENCODE_READY_POLL_MS
-  const startedAt = Date.now()
+  const waitStartedAt = Date.now()
   for (;;) {
     if (opts.signal?.aborted) {
-      child.kill()
+      started.stop()
       throw new Error('opencode serve readiness wait aborted')
     }
     try {
@@ -1253,12 +1298,23 @@ export async function spawnOpenCode(opts: SpawnOpenCodeOptions): Promise<Spawned
         clearTimeout(timer)
       }
     } catch {
-      // not listening yet — fall through to the timeout check + sleep
+      // not listening yet — fall through to the exit and timeout checks + sleep
+    }
+    // A process that already exited will never answer: say so now rather
+    // than at the end of the budget.
+    if (started.hasExited()) {
+      const tail = readLogTail(opts.logPath)
+      const reason = started.exitReason()
+      throw new OpenCodeExitedError(
+        `opencode serve exited before it answered on ${baseUrl}` +
+          (reason ? `: ${reason}` : '') +
+          (tail ? ` — log tail: ${tail}` : ' (no log output captured)')
+      )
     }
     // Soft budget: checked between probes, so the total wait can overrun by up
     // to one probe timeout + poll interval. Negligible against the default.
-    if (Date.now() - startedAt >= timeoutMs) {
-      child.kill()
+    if (Date.now() - waitStartedAt >= timeoutMs) {
+      started.stop()
       const tail = readLogTail(opts.logPath)
       throw new Error(
         `opencode serve did not become ready on ${baseUrl} within ${timeoutMs}ms` +
@@ -1268,5 +1324,5 @@ export async function spawnOpenCode(opts: SpawnOpenCodeOptions): Promise<Spawned
     await new Promise(resolve => setTimeout(resolve, pollMs))
   }
 
-  return { baseUrl, port, stop: () => child.kill(), readyAfterMs: Date.now() - startedAt }
+  return { baseUrl, port, stop: started.stop, readyAfterMs: Date.now() - started.startedAt }
 }