@desplega.ai/agent-swarm 2.7.6 → 2.7.7

package/src/utils/internal-ai/credentials.ts

@@ -108,6 +108,30 @@ export interface ResolveCredentialOptions {
   _persistCodexOAuth?: typeof persistCodexOAuth;
 }
 
+/**
+ * Credential kinds in precedence order. `resolveCredentials` walks this list;
+ * `resolveCredential` returns the first hit.
+ */
+export const CREDENTIAL_KIND_PRECEDENCE: readonly CredentialKind[] = [
+  "openrouter",
+  "anthropic",
+  "openai",
+  "openai-codex",
+  "claude-cli",
+];
+
+export interface ResolveCredentialsOptions extends ResolveCredentialOptions {
+  /**
+   * Only resolve these kinds (in precedence order). Lets a caller probe one
+   * provider at a time, so the codex OAuth lookup (an HTTP call that can
+   * rotate a refresh token) runs only when that kind is actually needed.
+   * Default: every kind.
+   */
+  kinds?: readonly CredentialKind[];
+  /** Stop after this many credentials. Default: no limit. */
+  limit?: number;
+}
+
 /**
  * Resolve a credential according to the documented precedence. Returns `null`
  * if no credential could be resolved — callers MUST treat null as a graceful
@@ -125,112 +149,141 @@ export interface ResolveCredentialOptions {
 export async function resolveCredential(
   opts: ResolveCredentialOptions = {},
 ): Promise<ResolvedCredential | null> {
+  const [first] = await resolveCredentials({ ...opts, limit: 1 });
+  return first ?? null;
+}
+
+/**
+ * Every credential the environment offers, in the precedence order documented
+ * on {@link resolveCredential}. Callers that can fall back across providers
+ * (task titles) walk the list; `resolveCredential` is the `limit: 1` case.
+ * The codex OAuth probe runs only when `openai-codex` is reached, so an env
+ * key ahead of it (or `kinds` that exclude it) never triggers the HTTP call.
+ */
+export async function resolveCredentials(
+  opts: ResolveCredentialsOptions = {},
+): Promise<ResolvedCredential[]> {
   const env = opts.env ?? process.env;
   const getEnvKey = opts._getEnvApiKey ?? getEnvApiKey;
-  const getCodex = opts._getValidCodexOAuth ?? getValidCodexOAuth;
-  const getOAuth = opts._getOAuthApiKey ?? resolveOAuthApiKey;
-  const persistCodex = opts._persistCodexOAuth ?? persistCodexOAuth;
+  const wanted = opts.kinds ?? CREDENTIAL_KIND_PRECEDENCE;
+  const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+  const found: ResolvedCredential[] = [];
 
-  // 1. OpenRouter.
-  const openrouterKey = env.OPENROUTER_API_KEY ?? getEnvKey("openrouter");
-  if (openrouterKey) {
-    return {
-      kind: "openrouter",
-      apiKey: selectCredential(openrouterKey, undefined, "OPENROUTER_API_KEY").selected,
-      modelDefault: resolveRaterModelString("openrouter"),
-    };
+  for (const kind of CREDENTIAL_KIND_PRECEDENCE) {
+    if (found.length >= limit) break;
+    if (!wanted.includes(kind)) continue;
+    const cred = await resolveKind(kind, opts, env, getEnvKey);
+    if (cred) found.push(cred);
   }
+  return found;
+}
 
-  // 2. Anthropic. pi-ai sends this key to api.anthropic.com, so skip it when
-  // ANTHROPIC_BASE_URL names a gateway: the key belongs to the gateway (#1800).
-  const anthropicBaseUrl = env.ANTHROPIC_BASE_URL?.trim();
-  const anthropicKeyIsForGateway =
-    Boolean(anthropicBaseUrl) && !isFirstPartyAnthropicUrl(anthropicBaseUrl ?? "");
-  const anthropicKey = anthropicKeyIsForGateway
-    ? undefined
-    : (env.ANTHROPIC_API_KEY ?? getEnvKey("anthropic"));
-  if (anthropicKey) {
-    return {
-      kind: "anthropic",
-      apiKey: selectCredential(anthropicKey, undefined, "ANTHROPIC_API_KEY").selected,
-      modelDefault: resolveRaterModelString("anthropic"),
-    };
+async function resolveKind(
+  kind: CredentialKind,
+  opts: ResolveCredentialOptions,
+  env: NodeJS.ProcessEnv,
+  getEnvKey: typeof getEnvApiKey,
+): Promise<ResolvedCredential | null> {
+  switch (kind) {
+    case "openrouter": {
+      const key = env.OPENROUTER_API_KEY ?? getEnvKey("openrouter");
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "OPENROUTER_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "anthropic": {
+      // pi-ai sends this key to api.anthropic.com, so skip it when
+      // ANTHROPIC_BASE_URL names a gateway: the key belongs to the gateway (#1800).
+      const anthropicBaseUrl = env.ANTHROPIC_BASE_URL?.trim();
+      const keyIsForGateway =
+        Boolean(anthropicBaseUrl) && !isFirstPartyAnthropicUrl(anthropicBaseUrl ?? "");
+      const key = keyIsForGateway ? undefined : (env.ANTHROPIC_API_KEY ?? getEnvKey("anthropic"));
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "ANTHROPIC_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "openai": {
+      const key = env.OPENAI_API_KEY ?? getEnvKey("openai");
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "OPENAI_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "openai-codex":
+      // Only if we have apiUrl + apiKey to probe the config store.
+      if (!opts.apiUrl || !opts.apiKey) return null;
+      return resolveCodexOAuthCredential(opts, opts.apiUrl, opts.apiKey);
+    case "claude-cli":
+      // `AGENT_SWARM_CLAUDE_OAUTH_TOKEN` is the mirror set by claude-adapter.ts
+      // before spawning `claude` — the CLI strips `CLAUDE_CODE_OAUTH_TOKEN` from
+      // hook subprocesses (security), so the hook reads the mirror instead.
+      if (!env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN && !env.CLAUDE_CODE_OAUTH_TOKEN) return null;
+      return { kind, modelDefault: resolveRaterModelString(kind) };
   }
+}
 
-  // 3. OpenAI.
-  const openaiKey = env.OPENAI_API_KEY ?? getEnvKey("openai");
-  if (openaiKey) {
-    return {
-      kind: "openai",
-      apiKey: selectCredential(openaiKey, undefined, "OPENAI_API_KEY").selected,
-      modelDefault: resolveRaterModelString("openai"),
+async function resolveCodexOAuthCredential(
+  opts: ResolveCredentialOptions,
+  apiUrl: string,
+  apiKey: string,
+): Promise<ResolvedCredential | null> {
+  const getCodex = opts._getValidCodexOAuth ?? getValidCodexOAuth;
+  const getOAuth = opts._getOAuthApiKey ?? resolveOAuthApiKey;
+  const persistCodex = opts._persistCodexOAuth ?? persistCodexOAuth;
+  try {
+    const codexCreds = await getCodex(apiUrl, apiKey);
+    if (!codexCreds) return null;
+    // pi-ai expects a Record<providerID, OAuthCredentials>.
+    const credMap: Record<string, OAuthCredentials> = {
+      "openai-codex": {
+        access: codexCreds.access,
+        refresh: codexCreds.refresh,
+        expires: codexCreds.expires,
+      },
     };
-  }
-
-  // 4. Codex OAuth — only if we have apiUrl + apiKey to probe the config store.
-  if (opts.apiUrl && opts.apiKey) {
-    try {
-      const codexCreds = await getCodex(opts.apiUrl, opts.apiKey);
-      if (codexCreds) {
-        // pi-ai expects a Record<providerID, OAuthCredentials>.
-        const credMap: Record<string, OAuthCredentials> = {
-          "openai-codex": {
-            access: codexCreds.access,
-            refresh: codexCreds.refresh,
-            expires: codexCreds.expires,
-          },
-        };
-        const oauthResult = await getOAuth("openai-codex", credMap);
-        if (oauthResult) {
-          // Persist any rotated refresh token — best-effort, must not block.
-          // Wrap defensively here even though the production helper already
-          // swallows; tests may inject a throwing hook, and persistence
-          // failure must never prevent the current call from succeeding.
-          if (oauthResult.newCredentials) {
-            const updated = oauthResult.newCredentials;
-            try {
-              await persistCodex(opts.apiUrl, opts.apiKey, {
-                access: String(updated.access),
-                refresh: String(updated.refresh),
-                expires: Number(updated.expires),
-                accountId: codexCreds.accountId,
-              });
-            } catch (err) {
-              console.error(
-                `internal-ai: persistCodexOAuth failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
-                err,
-              );
-            }
-          }
-          return {
-            kind: "openai-codex",
-            apiKey: oauthResult.apiKey,
-            modelDefault: resolveRaterModelString("openai-codex"),
-          };
-        }
+    const oauthResult = await getOAuth("openai-codex", credMap);
+    if (!oauthResult) return null;
+    // Persist any rotated refresh token — best-effort, must not block.
+    // Wrap defensively here even though the production helper already
+    // swallows; tests may inject a throwing hook, and persistence
+    // failure must never prevent the current call from succeeding.
+    if (oauthResult.newCredentials) {
+      const updated = oauthResult.newCredentials;
+      try {
+        await persistCodex(apiUrl, apiKey, {
+          access: String(updated.access),
+          refresh: String(updated.refresh),
+          expires: Number(updated.expires),
+          accountId: codexCreds.accountId,
+        });
+      } catch (err) {
+        console.error(
+          `internal-ai: persistCodexOAuth failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
+          err,
+        );
       }
-    } catch (err) {
-      console.error(
-        `internal-ai: codex OAuth probe failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
-        err,
-      );
-      // Fall through to claude-cli fallback below.
     }
-  }
-
-  // 5. CLAUDE_CODE_OAUTH_TOKEN → claude-cli fallback.
-  // `AGENT_SWARM_CLAUDE_OAUTH_TOKEN` is the mirror set by claude-adapter.ts
-  // before spawning `claude` — the CLI strips `CLAUDE_CODE_OAUTH_TOKEN` from
-  // hook subprocesses (security), so the hook reads the mirror instead.
-  if (env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN || env.CLAUDE_CODE_OAUTH_TOKEN) {
     return {
-      kind: "claude-cli",
-      modelDefault: resolveRaterModelString("claude-cli"),
+      kind: "openai-codex",
+      apiKey: oauthResult.apiKey,
+      modelDefault: resolveRaterModelString("openai-codex"),
     };
+  } catch (err) {
+    console.error(
+      `internal-ai: codex OAuth probe failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
+      err,
+    );
+    // The caller falls through to the claude-cli fallback.
+    return null;
   }
-
-  // 6. No creds.
-  return null;
 }
 
 // Re-export for convenience to keep imports flat.

package/src/utils/internal-ai/index.ts

@@ -19,11 +19,14 @@ export {
   completeStructuredWithModel,
 } from "./complete-structured.js";
 export {
+  CREDENTIAL_KIND_PRECEDENCE,
   type CredentialKind,
   DEFAULT_MODEL,
   type ResolveCredentialOptions,
+  type ResolveCredentialsOptions,
   type ResolvedCredential,
   resolveCredential,
+  resolveCredentials,
 } from "./credentials.js";
 export {
   MEMORY_RATER_DEFAULT_MODEL,
@@ -36,3 +39,10 @@ export {
   summarizeSession,
   summaryToolSchema,
 } from "./summarize-session.js";
+export {
+  type GenerateTaskTitleOptions,
+  type GenerateTaskTitleResult,
+  generateTaskTitle,
+  TASK_TITLE_MODEL_CANDIDATES,
+  TASK_TITLE_MODEL_ENV,
+} from "./task-title.js";

package/src/utils/internal-ai/models.ts

@@ -59,6 +59,24 @@ export function resolveRaterModelString(kind: CredentialKind): string {
   return process.env.MEMORY_RATER_MODEL ?? MEMORY_RATER_DEFAULT_MODEL[kind];
 }
 
+const PROVIDER_TO_KIND: Record<string, CredentialKind> = {
+  openrouter: "openrouter",
+  anthropic: "anthropic",
+  openai: "openai",
+  "openai-codex": "openai-codex",
+};
+
+/**
+ * Credential kind a model string belongs to. `provider/model-id` maps through
+ * the provider prefix; a bare alias (`haiku`) is a `claude -p` model. `null`
+ * for a provider the internal-ai layer cannot call.
+ */
+export function kindForModelString(modelStr: string): CredentialKind | null {
+  const slash = modelStr.indexOf("/");
+  if (slash < 0) return "claude-cli";
+  return PROVIDER_TO_KIND[modelStr.slice(0, slash)] ?? null;
+}
+
 /**
  * Split a `provider/model-id` string on the FIRST `/` so that OpenRouter
  * compound IDs like `openrouter/deepseek/deepseek-v4.1-flash` parse as

package/src/utils/internal-ai/task-title.ts

@@ -0,0 +1,282 @@
+/**
+ * Task title generation: a short display title for a task prompt.
+ *
+ * Consumer of `completeStructuredWithModel`. Walks `TASK_TITLE_MODEL_CANDIDATES`
+ * (provider order, then model order) and returns the first title a configured
+ * credential produces. Every candidate is a cheap, fast model: one title costs
+ * well under a tenth of a cent, so thousands of weekly tasks stay in cents.
+ *
+ * Worker-safe: no bun:sqlite import. The API server wires it to task creation
+ * in `src/be/task-auto-title-listener.ts`.
+ */
+
+import { Type } from "typebox";
+import { z } from "zod";
+import { scrubSecrets } from "../secret-scrubber.js";
+import { completeStructuredWithModel } from "./complete-structured.js";
+import { type CredentialKind, type ResolvedCredential, resolveCredentials } from "./credentials.js";
+import { kindForModelString } from "./models.js";
+
+/** Longest generated title. The PATCH /api/tasks/{id}/title route allows 120. */
+export const TASK_TITLE_MAX_CHARS = 100;
+/** Prompts shorter than this keep the prompt itself as the display title. */
+export const TASK_TITLE_MIN_TASK_CHARS = 48;
+/** Prompt text sent to the model is cut here. Keeps every call small. */
+export const TASK_TITLE_MAX_TASK_CHARS = 2000;
+/** Whole generation, across every candidate. */
+export const TASK_TITLE_TIMEOUT_MS = 20_000;
+
+/** Env var that pins one model (`provider/model-id`, or a `claude -p` alias). */
+export const TASK_TITLE_MODEL_ENV = "TASK_AUTO_TITLE_MODEL";
+
+export interface TaskTitleCandidateGroup {
+  kind: CredentialKind;
+  /** Full model strings for this credential kind, best first. */
+  models: readonly string[];
+}
+
+/**
+ * Provider order, then model order within a provider. Cheapest and fastest
+ * first: pay-per-token API keys before subscription OAuth, and the `claude -p`
+ * shellout last (it spawns a full CLI process per call).
+ *
+ * Model prices (input / output, USD per million tokens, models.dev snapshot):
+ *   deepseek-v4.1-flash 0.034 / 0.137 · claude-haiku-5.5 0.10 / 0.50 ·
+ *   gpt-6-luna 0.10 / 0.50 · gpt-5-nano 0.05 / 0.40
+ */
+export const TASK_TITLE_MODEL_CANDIDATES: readonly TaskTitleCandidateGroup[] = [
+  {
+    kind: "openrouter",
+    models: [
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "openrouter/anthropic/claude-haiku-5.5",
+      "openrouter/openai/gpt-6-luna",
+    ],
+  },
+  { kind: "anthropic", models: ["anthropic/claude-haiku-5-5"] },
+  { kind: "openai", models: ["openai/gpt-6-luna", "openai/gpt-5-nano"] },
+  { kind: "openai-codex", models: ["openai-codex/gpt-6-luna"] },
+  { kind: "claude-cli", models: ["haiku"] },
+];
+
+export { kindForModelString };
+
+/**
+ * The candidate list for one environment. `TASK_AUTO_TITLE_MODEL` moves its
+ * provider to the front and puts the pinned model first inside it; the rest of
+ * the list stays as fallback. An unknown provider is ignored with a warning.
+ */
+export function buildTaskTitlePlan(
+  env: Record<string, string | undefined> = process.env,
+): readonly TaskTitleCandidateGroup[] {
+  const pinned = env[TASK_TITLE_MODEL_ENV]?.trim();
+  if (!pinned) return TASK_TITLE_MODEL_CANDIDATES;
+  const kind = kindForModelString(pinned);
+  if (!kind) {
+    console.warn(
+      `[task-title] ${TASK_TITLE_MODEL_ENV}=${pinned} names an unsupported provider; ignored`,
+    );
+    return TASK_TITLE_MODEL_CANDIDATES;
+  }
+  const own = TASK_TITLE_MODEL_CANDIDATES.find((group) => group.kind === kind);
+  const rest = TASK_TITLE_MODEL_CANDIDATES.filter((group) => group.kind !== kind);
+  const models = [pinned, ...(own?.models ?? []).filter((model) => model !== pinned)];
+  return [{ kind, models }, ...rest];
+}
+
+const SIBLING_OPEN = "<sibling_tasks_in_progress>";
+const SIBLING_CLOSE = "</sibling_tasks_in_progress>";
+
+/**
+ * Task text as the model should see it: without the sibling-awareness block
+ * the API prepends to child tasks, with runs of blank lines collapsed, and cut
+ * to `TASK_TITLE_MAX_TASK_CHARS`.
+ */
+export function prepareTaskTextForTitle(task: string): string {
+  let text = task;
+  if (text.startsWith(SIBLING_OPEN)) {
+    const close = text.indexOf(SIBLING_CLOSE);
+    if (close !== -1) text = text.slice(close + SIBLING_CLOSE.length);
+  }
+  text = text
+    .replace(/\r\n?/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  if (text.length > TASK_TITLE_MAX_TASK_CHARS) {
+    text = `${text.slice(0, TASK_TITLE_MAX_TASK_CHARS).trimEnd()} …`;
+  }
+  return text;
+}
+
+const WRAPPING_QUOTES: ReadonlyArray<[string, string]> = [
+  ['"', '"'],
+  ["'", "'"],
+  ["“", "”"],
+  ["‘", "’"],
+  ["`", "`"],
+  ["«", "»"],
+];
+
+/**
+ * Clean a model-produced title: one line, no wrapping quotes or `Title:`
+ * prefix, no markdown emphasis, no trailing sentence punctuation, at most
+ * `TASK_TITLE_MAX_CHARS` (cut at a word boundary). Empty string when nothing
+ * usable remains.
+ */
+export function normalizeTaskTitle(raw: string): string {
+  let title = raw.replace(/\s+/g, " ").trim();
+  title = title.replace(/^title\s*:\s*/i, "");
+  title = title.replace(/\*\*|__|^#+\s*/g, "");
+  const stripTrailingPunctuation = () => {
+    title = title.replace(/[.!…]+$/u, "").trim();
+  };
+  // Quotes can sit inside or outside the trailing punctuation: `"Title".` and `"Title…"`.
+  stripTrailingPunctuation();
+  for (const [open, close] of WRAPPING_QUOTES) {
+    if (title.length >= 2 && title.startsWith(open) && title.endsWith(close)) {
+      title = title.slice(open.length, title.length - close.length).trim();
+    }
+  }
+  stripTrailingPunctuation();
+  if (title.length > TASK_TITLE_MAX_CHARS) {
+    const cut = title.slice(0, TASK_TITLE_MAX_CHARS);
+    const lastSpace = cut.lastIndexOf(" ");
+    title = (lastSpace >= TASK_TITLE_MAX_CHARS / 2 ? cut.slice(0, lastSpace) : cut).trimEnd();
+    title = title.replace(/[,;:\-–—]+$/u, "").trimEnd();
+  }
+  return title;
+}
+
+export const TASK_TITLE_SYSTEM_PROMPT = [
+  "You write titles for tasks on a software team's dashboard.",
+  "Rules:",
+  "- 3 to 8 words, at most 80 characters.",
+  "- Sentence case. No trailing period. No quotes, markdown, emoji, or task ids.",
+  "- Name the concrete subject (feature, bug, repo, file, system, person), not a generic verb alone.",
+  "- Keep the language of the request.",
+  "- Ignore pasted logs, code, and context blocks; title the request itself.",
+  "Call the set_title tool with the title.",
+].join("\n");
+
+export const TASK_TITLE_TOOL_NAME = "set_title";
+
+const TaskTitleZodSchema = z.object({ title: z.string().trim().min(1).max(200) });
+const TaskTitleToolSchema = Type.Object({
+  title: Type.String({ minLength: 1, maxLength: 200, description: "The task title." }),
+});
+
+export interface GenerateTaskTitleOptions {
+  /** Full task prompt as stored on the task. */
+  task: string;
+  /** Credential lookup env. Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+  /** Optional loopback context for the codex OAuth probe (see `resolveCredentials`). */
+  apiUrl?: string;
+  apiKey?: string;
+  signal?: AbortSignal;
+  /** Diagnostic tag forwarded to `completeStructured` logs. */
+  callerTag?: string;
+  // Test injection points:
+  _resolveCredentials?: typeof resolveCredentials;
+  _completeStructured?: typeof completeStructuredWithModel;
+}
+
+export type GenerateTaskTitleResult =
+  | { ok: true; title: string; model: string; kind: CredentialKind }
+  | { ok: false; reason: "short-task" | "no-credentials" | "all-models-failed" };
+
+/**
+ * Generate a title for `task`. Never throws: a provider error moves on to the
+ * next candidate, and exhausting the list returns `{ ok: false }`.
+ */
+export async function generateTaskTitle(
+  opts: GenerateTaskTitleOptions,
+): Promise<GenerateTaskTitleResult> {
+  const text = prepareTaskTextForTitle(opts.task);
+  if (text.length < TASK_TITLE_MIN_TASK_CHARS) return { ok: false, reason: "short-task" };
+
+  const env = opts.env ?? process.env;
+  const resolve = opts._resolveCredentials ?? resolveCredentials;
+  const complete = opts._completeStructured ?? completeStructuredWithModel;
+  const callerTag = opts.callerTag ?? "task-title";
+  const plan = buildTaskTitlePlan(env);
+
+  // One lookup per kind, on demand, so the codex OAuth probe (an HTTP call
+  // that can rotate a refresh token) runs only when its turn comes.
+  const credentialCache = new Map<CredentialKind, ResolvedCredential | null>();
+  const credentialFor = async (kind: CredentialKind): Promise<ResolvedCredential | null> => {
+    const cached = credentialCache.get(kind);
+    if (cached !== undefined) return cached;
+    const [cred] = await resolve({
+      env,
+      apiUrl: opts.apiUrl,
+      apiKey: opts.apiKey,
+      callerTag,
+      kinds: [kind],
+      limit: 1,
+    });
+    credentialCache.set(kind, cred ?? null);
+    return cred ?? null;
+  };
+
+  let sawCredential = false;
+  for (const group of plan) {
+    if (opts.signal?.aborted) break;
+    const cred = await credentialFor(group.kind);
+    if (!cred) continue;
+    sawCredential = true;
+    for (const model of group.models) {
+      if (opts.signal?.aborted) break;
+      const title = await attemptTitle(complete, {
+        cred,
+        model,
+        text,
+        env,
+        callerTag,
+        signal: opts.signal,
+      });
+      if (title) return { ok: true, title, model, kind: cred.kind };
+    }
+  }
+  return { ok: false, reason: sawCredential ? "all-models-failed" : "no-credentials" };
+}
+
+interface TitleAttempt {
+  cred: ResolvedCredential;
+  model: string;
+  text: string;
+  env: Record<string, string | undefined>;
+  callerTag: string;
+  signal?: AbortSignal;
+}
+
+/** One model call. `completeStructuredWithModel` swallows provider errors; a throw here is still just a miss. */
+async function attemptTitle(
+  complete: typeof completeStructuredWithModel,
+  attempt: TitleAttempt,
+): Promise<string> {
+  try {
+    const result = await complete({
+      zodSchema: TaskTitleZodSchema,
+      toolSchema: TaskTitleToolSchema,
+      toolName: TASK_TITLE_TOOL_NAME,
+      toolDescription: "Record the title for this task.",
+      systemPrompt: TASK_TITLE_SYSTEM_PROMPT,
+      userPrompt: `Task request:\n\n${attempt.text}`,
+      env: attempt.env,
+      retries: 1,
+      signal: attempt.signal,
+      callerTag: `${attempt.callerTag}:${attempt.model}`,
+      _credentialOverride: { ...attempt.cred, modelDefault: attempt.model },
+    });
+    return result ? normalizeTaskTitle(result.data.title) : "";
+  } catch (error) {
+    // Provider errors can echo request fragments; scrub before logging.
+    console.error(
+      scrubSecrets(
+        `[task-title] ${attempt.model} threw: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+    return "";
+  }
+}

package/src/utils/page-session.ts

@@ -27,7 +27,9 @@
  */
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import type { IncomingHttpHeaders } from "node:http";
 import path from "node:path";
+import { isDevOrTestNodeEnv } from "./node-env";
 
 const ENV_SECRET = "PAGE_SESSION_SECRET";
 const ENV_SECRET_FILE = "PAGE_SESSION_SECRET_FILE";
@@ -336,6 +338,41 @@ export async function extractAndVerifyCookie(
  */
 const PAGE_SESSION_TTL_SECONDS = 3600;
 
+const LOCAL_DEV_HOSTNAMES = new Set(["localhost", "127.0.0.1"]);
+
+/** True only for a parsed `http:` URL whose hostname is exactly a loopback dev name. */
+function isLocalHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && LOCAL_DEV_HOSTNAMES.has(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Decide the `dev` flag for `issuePageSessionCookie`. Shared by the launch
+ * endpoint (`src/http/pages.ts`) and the password flow on `/p/:id`
+ * (`src/http/pages-public.ts`) so both issue the same cookie.
+ *
+ * Fails closed: only an explicit development or test NODE_ENV can soften the
+ * cookie. Deployed images leave NODE_ENV unset and get `SameSite=None; Secure`.
+ * In dev, the request must come from `http://localhost` or `http://127.0.0.1`
+ * (parsed, so `http://localhost.evil.example` does not match). Without an
+ * Origin, the Host header decides; a missing Host counts as local.
+ * Anything else, including portless `https://*.localhost`, keeps
+ * `SameSite=None; Secure` so the cookie travels on cross-site fetches.
+ * Chrome treats localhost as a secure context, so Secure also works over http.
+ */
+export function isLocalDevPageRequest(req: { headers: IncomingHttpHeaders }): boolean {
+  if (!isDevOrTestNodeEnv()) return false;
+  const origin = req.headers.origin ?? "";
+  if (origin !== "") return isLocalHttpUrl(origin);
+  const host = req.headers.host;
+  if (!host) return true;
+  return isLocalHttpUrl(`http://${host}`);
+}
+
 /**
  * Mint a signed page-session token + build the `Set-Cookie` header value for
  * `pageId`. Shared by the bearer-authed launch endpoint (`src/http/pages.ts`)