@oxygen-agent/cli 1.1013.93 → 1.1014.18

package/node_modules/@oxygen/shared/dist/copilot-questions.d.ts

@@ -0,0 +1,91 @@
+export declare const COPILOT_ASK_USER_TOOL_NAME = "ask_user";
+export declare const COPILOT_QUESTION_LIMITS: {
+    readonly maxQuestions: 4;
+    readonly minOptions: 2;
+    readonly maxOptions: 4;
+    readonly questionChars: 300;
+    readonly headerChars: 24;
+    readonly labelChars: 80;
+    readonly descriptionChars: 200;
+    /** What the user may type into "Other". */
+    readonly otherAnswerChars: 1000;
+};
+export type CopilotQuestionOption = {
+    label: string;
+    description: string | null;
+    recommended: boolean;
+};
+export type CopilotQuestion = {
+    question: string;
+    /** A short chip label, e.g. "Send time". */
+    header: string;
+    multiSelect: boolean;
+    options: CopilotQuestionOption[];
+};
+/** The question a session is waiting on, as every surface reads it. */
+export type CopilotPendingQuestion = {
+    turnId: string;
+    callId: string | null;
+    questions: CopilotQuestion[];
+};
+/** What the user picked for one question, plus anything they typed into "Other". */
+export type CopilotQuestionAnswer = {
+    selected: string[];
+    other: string | null;
+};
+/** The tool's input schema, as the model reads it. */
+export declare const COPILOT_ASK_USER_INPUT_SCHEMA: Record<string, unknown>;
+/**
+ * Validate the model's questions, or a stored copy of them. Strict about what
+ * would make the card unanswerable (no question, fewer than two real options,
+ * duplicates) and forgiving about the rest: an over-long label is shortened, an
+ * "Other" option is dropped because the card adds one, and a second
+ * `recommended` loses its mark. Accepts `multi_select` (the tool's input) and
+ * `multiSelect` (the stored shape) alike.
+ */
+export declare function normalizeCopilotQuestions(raw: unknown): {
+    ok: true;
+    questions: CopilotQuestion[];
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * The questions as the turn's reply: what the CLI and MCP print, what the
+ * session keeps, and what the model reads back on the next turn, which replays
+ * earlier turns as plain text.
+ */
+export declare function renderCopilotQuestionsText(questions: readonly CopilotQuestion[]): string;
+/**
+ * The user's reply to a question card: one line per question, `header: answer`,
+ * so the model can match every answer to what it asked. Picks follow the order
+ * the options were offered in, not the order they were clicked. "Other" text
+ * stands on its own; it is the user's own wording.
+ */
+export declare function formatCopilotQuestionAnswers(questions: readonly CopilotQuestion[], answers: readonly CopilotQuestionAnswer[]): string;
+/** Is every question answered, so the card can be sent? */
+export declare function copilotQuestionAnswersComplete(questions: readonly CopilotQuestion[], answers: readonly CopilotQuestionAnswer[]): boolean;
+type ProjectionTurn = {
+    id: string;
+    status: string;
+    turnIndex: number;
+};
+type ProjectionEvent = {
+    turnId: string | null;
+    kind: string;
+    payload: Record<string, unknown>;
+};
+/**
+ * The question the session is waiting on, or null.
+ *
+ * Only the NEWEST turn can be waiting, and only when it completed by asking: a
+ * newer turn means the user already replied (by the card or by typing), and a
+ * turn that failed or was cancelled after asking is not waiting on anything.
+ * Stored questions are re-validated, so a malformed row renders nothing rather
+ * than a card that cannot be answered.
+ */
+export declare function projectCopilotPendingQuestion(input: {
+    turns: readonly ProjectionTurn[];
+    events: readonly ProjectionEvent[];
+}): CopilotPendingQuestion | null;
+export {};

package/node_modules/@oxygen/shared/dist/copilot-questions.js

@@ -0,0 +1,246 @@
+// The Copilot's questions to the person it works for.
+//
+// When the Copilot needs a decision only the user can make, it calls `ask_user`
+// with a few multiple-choice questions instead of burying them at the end of a
+// reply (Tim, 2026-10-10, after Claude Code's AskUserQuestion). The call ENDS the
+// turn; the web shows the questions as a card above the composer, with an
+// automatic "Other" answer; the user's choice arrives as their next message.
+//
+// Ending the turn rather than parking it is the whole design. A parked turn
+// blocks the session (one live turn per session), runs a wall clock while the
+// human thinks, and needs its own resume route on every surface. A question
+// that ends the turn needs none of that: the CLI and MCP answer it the way they
+// send any message, an ignored card is simply superseded by whatever the user
+// types next, and the model reads the question back from the turn's reply,
+// because prior turns replay as user/assistant text.
+//
+// One owner for the contract because four readers depend on it: the tool that
+// validates the model's input, the reply text the CLI and MCP print, the session
+// read that projects the pending question, and the web card that answers it.
+export const COPILOT_ASK_USER_TOOL_NAME = "ask_user";
+export const COPILOT_QUESTION_LIMITS = {
+    maxQuestions: 4,
+    minOptions: 2,
+    maxOptions: 4,
+    questionChars: 300,
+    headerChars: 24,
+    labelChars: 80,
+    descriptionChars: 200,
+    /** What the user may type into "Other". */
+    otherAnswerChars: 1_000,
+};
+/** The tool's input schema, as the model reads it. */
+export const COPILOT_ASK_USER_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        questions: {
+            type: "array",
+            minItems: 1,
+            maxItems: COPILOT_QUESTION_LIMITS.maxQuestions,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    question: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: COPILOT_QUESTION_LIMITS.questionChars,
+                        description: "The complete question, ending with a question mark.",
+                    },
+                    header: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: COPILOT_QUESTION_LIMITS.headerChars,
+                        description: "A one-to-three word label for the question, e.g. \"Send time\".",
+                    },
+                    multi_select: {
+                        type: "boolean",
+                        description: "True when the user may pick more than one option.",
+                    },
+                    options: {
+                        type: "array",
+                        minItems: COPILOT_QUESTION_LIMITS.minOptions,
+                        maxItems: COPILOT_QUESTION_LIMITS.maxOptions,
+                        items: {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                label: {
+                                    type: "string",
+                                    minLength: 1,
+                                    maxLength: COPILOT_QUESTION_LIMITS.labelChars,
+                                    description: "The choice itself, in one to five words.",
+                                },
+                                description: {
+                                    type: "string",
+                                    maxLength: COPILOT_QUESTION_LIMITS.descriptionChars,
+                                    description: "What picking it means, in one short line.",
+                                },
+                                recommended: {
+                                    type: "boolean",
+                                    description: "Your recommendation; at most one per question, listed first.",
+                                },
+                            },
+                            required: ["label"],
+                        },
+                    },
+                },
+                required: ["question", "header", "options"],
+            },
+        },
+    },
+    required: ["questions"],
+};
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Collapse whitespace and cap at `max` characters, marking a cut with an ellipsis. */
+function clean(value, max) {
+    if (typeof value !== "string")
+        return "";
+    const flat = value.replace(/\s+/g, " ").trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
+}
+/** The automatic answer; an option the model spells this way is redundant. */
+const OTHER_LABEL = /^other\b/i;
+/**
+ * Validate the model's questions, or a stored copy of them. Strict about what
+ * would make the card unanswerable (no question, fewer than two real options,
+ * duplicates) and forgiving about the rest: an over-long label is shortened, an
+ * "Other" option is dropped because the card adds one, and a second
+ * `recommended` loses its mark. Accepts `multi_select` (the tool's input) and
+ * `multiSelect` (the stored shape) alike.
+ */
+export function normalizeCopilotQuestions(raw) {
+    if (!Array.isArray(raw) || raw.length === 0) {
+        return { ok: false, message: "questions must be a non-empty array." };
+    }
+    if (raw.length > COPILOT_QUESTION_LIMITS.maxQuestions) {
+        return { ok: false, message: `Ask at most ${COPILOT_QUESTION_LIMITS.maxQuestions} questions at once.` };
+    }
+    const questions = [];
+    const seenQuestions = new Set();
+    for (const [index, entry] of raw.entries()) {
+        const number = index + 1;
+        if (!isRecord(entry))
+            return { ok: false, message: `Question ${number} must be an object.` };
+        const question = clean(entry.question, COPILOT_QUESTION_LIMITS.questionChars);
+        if (!question)
+            return { ok: false, message: `Question ${number} has no question text.` };
+        if (seenQuestions.has(question.toLowerCase())) {
+            return { ok: false, message: `Question ${number} repeats an earlier question.` };
+        }
+        seenQuestions.add(question.toLowerCase());
+        if (!Array.isArray(entry.options)) {
+            return { ok: false, message: `Question ${number} needs an options array.` };
+        }
+        const options = [];
+        const seenLabels = new Set();
+        let recommended = false;
+        for (const rawOption of entry.options) {
+            const option = isRecord(rawOption) ? rawOption : { label: rawOption };
+            const label = clean(option.label, COPILOT_QUESTION_LIMITS.labelChars);
+            if (!label || OTHER_LABEL.test(label))
+                continue;
+            if (seenLabels.has(label.toLowerCase())) {
+                return { ok: false, message: `Question ${number} lists "${label}" twice.` };
+            }
+            seenLabels.add(label.toLowerCase());
+            const description = clean(option.description, COPILOT_QUESTION_LIMITS.descriptionChars);
+            const isRecommended = option.recommended === true && !recommended;
+            recommended ||= isRecommended;
+            options.push({ label, description: description || null, recommended: isRecommended });
+        }
+        if (options.length < COPILOT_QUESTION_LIMITS.minOptions) {
+            return {
+                ok: false,
+                message: `Question ${number} needs at least ${COPILOT_QUESTION_LIMITS.minOptions} real options; "Other" is added for the user automatically.`,
+            };
+        }
+        if (options.length > COPILOT_QUESTION_LIMITS.maxOptions) {
+            return { ok: false, message: `Question ${number} offers more than ${COPILOT_QUESTION_LIMITS.maxOptions} options.` };
+        }
+        questions.push({
+            question,
+            header: clean(entry.header, COPILOT_QUESTION_LIMITS.headerChars) || `Question ${number}`,
+            multiSelect: entry.multi_select === true || entry.multiSelect === true,
+            options,
+        });
+    }
+    return { ok: true, questions };
+}
+/**
+ * The questions as the turn's reply: what the CLI and MCP print, what the
+ * session keeps, and what the model reads back on the next turn, which replays
+ * earlier turns as plain text.
+ */
+export function renderCopilotQuestionsText(questions) {
+    const blocks = questions.map((question) => {
+        const lines = [`**${question.question}**${question.multiSelect ? " (choose any)" : ""}`];
+        for (const option of question.options) {
+            const mark = option.recommended ? " (recommended)" : "";
+            lines.push(`- ${option.label}${mark}${option.description ? `: ${option.description}` : ""}`);
+        }
+        return lines.join("\n");
+    });
+    return [...blocks, "Pick an option, or answer in your own words."].join("\n\n");
+}
+/**
+ * The user's reply to a question card: one line per question, `header: answer`,
+ * so the model can match every answer to what it asked. Picks follow the order
+ * the options were offered in, not the order they were clicked. "Other" text
+ * stands on its own; it is the user's own wording.
+ */
+export function formatCopilotQuestionAnswers(questions, answers) {
+    return questions
+        .map((question, index) => {
+        const answer = answers[index];
+        const selected = new Set(answer?.selected ?? []);
+        const picked = question.options.map((option) => option.label).filter((label) => selected.has(label));
+        const other = answer?.other?.replace(/\s+/g, " ").trim().slice(0, COPILOT_QUESTION_LIMITS.otherAnswerChars) ?? "";
+        const parts = question.multiSelect ? [...picked, ...(other ? [other] : [])] : [other || picked[0] || ""];
+        return `${question.header}: ${parts.filter(Boolean).join(", ")}`;
+    })
+        .join("\n");
+}
+/** Is every question answered, so the card can be sent? */
+export function copilotQuestionAnswersComplete(questions, answers) {
+    return questions.every((_, index) => {
+        const answer = answers[index];
+        return Boolean(answer && (answer.selected.length > 0 || answer.other?.trim()));
+    });
+}
+/**
+ * The question the session is waiting on, or null.
+ *
+ * Only the NEWEST turn can be waiting, and only when it completed by asking: a
+ * newer turn means the user already replied (by the card or by typing), and a
+ * turn that failed or was cancelled after asking is not waiting on anything.
+ * Stored questions are re-validated, so a malformed row renders nothing rather
+ * than a card that cannot be answered.
+ */
+export function projectCopilotPendingQuestion(input) {
+    const newest = input.turns.reduce((latest, turn) => (latest === null || turn.turnIndex > latest.turnIndex ? turn : latest), null);
+    if (!newest || newest.status !== "completed")
+        return null;
+    for (let index = input.events.length - 1; index >= 0; index -= 1) {
+        const event = input.events[index];
+        if (!event || event.turnId !== newest.id || event.kind !== "tool_call_finished")
+            continue;
+        if (event.payload.tool !== COPILOT_ASK_USER_TOOL_NAME)
+            continue;
+        const result = event.payload.result;
+        if (!isRecord(result) || result.ok === false)
+            continue;
+        const normalized = normalizeCopilotQuestions(result.questions);
+        if (!normalized.ok)
+            return null;
+        return {
+            turnId: newest.id,
+            callId: typeof event.payload.call_id === "string" ? event.payload.call_id : null,
+            questions: normalized.questions,
+        };
+    }
+    return null;
+}

package/node_modules/@oxygen/shared/dist/hosted-ai.d.ts

@@ -17,16 +17,15 @@
  *     overrides (`OXYGEN_COPILOT_MODEL_*` / `OXYGEN_COPILOT_FALLBACK_*`) applied
  *     here by `resolveHostedAiModel`.
  *
- * Kept as a leaf module (mirrors ./pricing-sheet.ts): no imports, so any package
- * can re-source the catalog without dragging in the shared barrel.
+ * Kept as a leaf module (mirrors ./pricing-sheet.ts): it imports only the
+ * dependency-free Copilot access leaf, never the shared barrel, so any package
+ * can re-source the catalog without dragging the barrel in.
  */
 export type HostedAiLevel = "low" | "medium" | "high";
 export type HostedAiUseCase = "ai_column" | "copilot" | "agent";
 /**
- * The Copilot's own level set. `auto` is the only tier a customer can land on
- * since 2026-09-21 ("Oxygen Auto"); low/medium/high survive because sessions
- * created before that release carry them in `copilot_sessions.reasoning_level`
- * and must keep resolving to the model they were priced against.
+ * The Copilot's own level set. Balanced is the default; the composer also
+ * offers explicit Auto/Fast/Max choices (Philipp, 2026-10-10).
  *
  * Deliberately NOT folded into `HostedAiLevel`: that type is shared with
  * `AiReasoningLevel` and with the ai_column/agent registries, neither of which
@@ -100,19 +99,14 @@ export declare const MANAGED_AI_TIER_LABELS: Record<HostedAiLevel, string>;
  *
  * Separate from MANAGED_AI_TIER_LABELS rather than folded into it because the
  * Copilot's level set is not the AI column's: only the Copilot has `auto`, and
- * only the Copilot has stopped offering a choice. AI columns and Agents still
- * sell Fast/Balanced/Max and still mean it.
- *
- * Every current session reads "Oxygen Auto". The other three exist so a session
- * created before 2026-09-21 still renders as the thing its owner picked, rather
- * than being relabelled under them.
+ * the Copilot offers Auto alongside Fast/Balanced/Max.
  */
 export declare const COPILOT_TIER_LABELS: Record<CopilotAiLevel, string>;
 /**
- * The tier every new Copilot session gets. There is no longer a picker: "Oxygen
- * Auto" is the whole customer-facing choice (Philipp, 2026-09-21).
+ * The tier a new Copilot session gets unless its owner chooses another.
  *
- * It was `high` until then, which is why 83% of production sessions ran the most
+ * Balanced is the founder-selected default (2026-10-10), replacing Auto.
+ * Historically it was `high`, which is why 83% of production sessions ran the most
  * expensive tier -- 110 of 132 sessions across 69 of 81 tenants -- while the
  * composer's own dropdown told the user that medium was "The default for most
  * GTM work". Nobody chose that; we defaulted them into it.
@@ -161,6 +155,21 @@ export declare const AGENT_DEFAULT_LEVEL: HostedAiLevel;
  * credit reservation for the wrong model and breaks the spend ceiling.
  */
 export declare function findHostedAiModelSpec(model: string, preferredUseCase?: HostedAiUseCase): HostedAiModelSpec | null;
+/**
+ * The models the registry runs (a tier's model or fallback, or a retained
+ * Copilot spec) that accept image input: OpenRouter lists "image" in their
+ * `architecture.input_modalities` (read 2026-10-10).
+ *
+ * Whether a model can look at a rendered page belongs to the model, so it is
+ * kept here beside it. It used to be only the deploy allowlist
+ * OXYGEN_VISUAL_VISION_MODELS, which named the Kimi models alone while the
+ * Copilot moved to Sol and then to Haiku on 2026-10-10. The Copilot then stopped
+ * seeing its own renders without an error anywhere, and production never set
+ * the allowlist at all (Tim, 2026-10-10: the model catalog decides). The
+ * allowlist still adds exact model ids.
+ */
+export declare const IMAGE_INPUT_MODELS: ReadonlySet<string>;
+export declare function modelAcceptsImages(model: string): boolean;
 export declare function resolveHostedAiModel(input: {
     useCase: HostedAiUseCase;
     level: CopilotAiLevel;
@@ -222,9 +231,10 @@ export declare function redactManagedModelIds<T>(value: T, options?: {
  */
 export declare function hostedAiDefaultModels(useCase: HostedAiUseCase): Record<HostedAiLevel, string>;
 /**
- * Staff dev experiment: only the authoritative selfhost-dev deployment and an
- * explicit enable flag can run Copilot. NODE_ENV and request hosts cannot open
- * it; production and shadow remain closed even with an enabled flag.
+ * Whether this deployment runs the Copilot for anyone. Who may use it is
+ * `copilotAudience` / `isCopilotAvailableTo` in `./copilot-access.ts`; only the
+ * self-hosted dev and production deployments read the flag, and NODE_ENV or a
+ * request host can never open it.
  */
 export declare function isCopilotEnabled(env?: Record<string, string | undefined>): boolean;
 /** Historical cost reconciliation may settle receipts without running Copilot. */

package/node_modules/@oxygen/shared/dist/hosted-ai.js

@@ -17,9 +17,11 @@
  *     overrides (`OXYGEN_COPILOT_MODEL_*` / `OXYGEN_COPILOT_FALLBACK_*`) applied
  *     here by `resolveHostedAiModel`.
  *
- * Kept as a leaf module (mirrors ./pricing-sheet.ts): no imports, so any package
- * can re-source the catalog without dragging in the shared barrel.
+ * Kept as a leaf module (mirrors ./pricing-sheet.ts): it imports only the
+ * dependency-free Copilot access leaf, never the shared barrel, so any package
+ * can re-source the catalog without dragging the barrel in.
  */
+import { copilotAudience, isCopilotFlagOn } from "./copilot-access.js";
 export const HOSTED_AI_MODEL_REGISTRY = {
     /**
      * Historical calibration of the September AI-column tiers, re-picked
@@ -112,8 +114,8 @@ export const HOSTED_AI_MODEL_REGISTRY = {
     },
     copilot: {
         /**
-         * "Oxygen Auto" -- the only tier a new session gets, and the one the main
-         * conversation thread runs on for its whole life. It is NOT a router: the
+         * "Oxygen Auto" -- the earlier default, retained as an explicit choice.
+         * Its conversation thread stays fixed for its whole life. It is NOT a router: the
          * model never changes mid-session, because an OpenRouter prompt cache is
          * model-scoped and a mid-turn switch would turn a ~66% cache HIT rate into a
          * cache WRITE on a fresh model, ten times a turn. Models only change below
@@ -138,12 +140,16 @@ export const HOSTED_AI_MODEL_REGISTRY = {
             model: "openai/gpt-6.1-sol",
             displayName: "Oxygen Auto",
             // Approved 2026-10-10 for NEW sessions. Existing sessions retain their
-            // persisted resolved_model; Kimi's priced spec survives under high.
+            // persisted resolved_model; Kimi's priced spec survives in the legacy map.
             fallbackModels: ["anthropic/claude-sonnet-5.5"],
             reasoningEffort: "medium",
             estPromptUsdPerM: 2,
             estCompletionUsdPerM: 10,
-            maxOutputTokens: 8192,
+            // Reasoning tokens count against this cap, so 8,192 left a long tool call
+            // (a full sequence draft, a wide table write) to be cut off mid-argument,
+            // which fails the turn on the second time. Credit holds are sized from the
+            // expected output (billing.ts), so this moves only the conservative clamp.
+            maxOutputTokens: 16_384,
         },
         low: {
             // The errand model: sub-agents, compaction summaries and auto-titles. A
@@ -177,29 +183,24 @@ export const HOSTED_AI_MODEL_REGISTRY = {
             maxOutputTokens: 8192,
         },
         medium: {
-            model: "deepseek/deepseek-v4-pro",
+            model: "anthropic/claude-haiku-5.5",
             displayName: "Oxygen Balanced",
-            fallbackModels: [],
-            reasoningEffort: "high",
-            estPromptUsdPerM: 0.435,
-            estCompletionUsdPerM: 0.87,
-            maxOutputTokens: 8192,
+            fallbackModels: ["deepseek/deepseek-v4.1-flash"],
+            reasoningEffort: "medium",
+            estPromptUsdPerM: 0.1,
+            estCompletionUsdPerM: 0.5,
+            // A conversation tier (the default since #5225), so Auto's cap (see Auto).
+            maxOutputTokens: 16_384,
         },
-        /**
-         * Retained only for sessions created before "Oxygen Auto" shipped, whose
-         * `reasoning_level` is already 'high' on the row, and for Auto sessions
-         * pinned to Kimi before the 2026-10-10 refresh. Keep its pricing, effort
-         * and GLM fallback so changing the new-session default never switches an
-         * existing conversation's model or loses its prompt cache.
-         */
         high: {
-            model: "moonshotai/kimi-k3",
+            model: "openai/gpt-6.1-sol",
             displayName: "Oxygen Max",
-            fallbackModels: ["z-ai/glm-5.3"],
+            fallbackModels: ["anthropic/claude-sonnet-5.5"],
             reasoningEffort: "medium",
-            estPromptUsdPerM: 1.7,
-            estCompletionUsdPerM: 8.5,
-            maxOutputTokens: 8192,
+            estPromptUsdPerM: 2,
+            estCompletionUsdPerM: 10,
+            // A conversation tier, so Auto's cap (see Auto).
+            maxOutputTokens: 16_384,
         },
     },
     agent: {
@@ -231,6 +232,27 @@ export const HOSTED_AI_MODEL_REGISTRY = {
         },
     },
 };
+/** Persisted conversations keep their original pricing, effort and fallbacks. */
+const LEGACY_COPILOT_MODEL_SPECS = [
+    {
+        model: "deepseek/deepseek-v4-pro",
+        displayName: "Oxygen Balanced",
+        fallbackModels: [],
+        reasoningEffort: "high",
+        estPromptUsdPerM: 0.435,
+        estCompletionUsdPerM: 0.87,
+        maxOutputTokens: 8192,
+    },
+    {
+        model: "moonshotai/kimi-k3",
+        displayName: "Oxygen Max",
+        fallbackModels: ["z-ai/glm-5.3"],
+        reasoningEffort: "medium",
+        estPromptUsdPerM: 1.7,
+        estCompletionUsdPerM: 8.5,
+        maxOutputTokens: 8192,
+    },
+];
 /**
  * Managed AI-column model ids that USED to back a tier, mapped to the tier they
  * billed at. A managed column saved with one of these pinned keeps validating
@@ -293,27 +315,22 @@ export const MANAGED_AI_TIER_LABELS = {
  *
  * Separate from MANAGED_AI_TIER_LABELS rather than folded into it because the
  * Copilot's level set is not the AI column's: only the Copilot has `auto`, and
- * only the Copilot has stopped offering a choice. AI columns and Agents still
- * sell Fast/Balanced/Max and still mean it.
- *
- * Every current session reads "Oxygen Auto". The other three exist so a session
- * created before 2026-09-21 still renders as the thing its owner picked, rather
- * than being relabelled under them.
+ * the Copilot offers Auto alongside Fast/Balanced/Max.
  */
 export const COPILOT_TIER_LABELS = {
     ...MANAGED_AI_TIER_LABELS,
     auto: "Oxygen Auto",
 };
 /**
- * The tier every new Copilot session gets. There is no longer a picker: "Oxygen
- * Auto" is the whole customer-facing choice (Philipp, 2026-09-21).
+ * The tier a new Copilot session gets unless its owner chooses another.
  *
- * It was `high` until then, which is why 83% of production sessions ran the most
+ * Balanced is the founder-selected default (2026-10-10), replacing Auto.
+ * Historically it was `high`, which is why 83% of production sessions ran the most
  * expensive tier -- 110 of 132 sessions across 69 of 81 tenants -- while the
  * composer's own dropdown told the user that medium was "The default for most
  * GTM work". Nobody chose that; we defaulted them into it.
  */
-export const COPILOT_DEFAULT_LEVEL = "auto";
+export const COPILOT_DEFAULT_LEVEL = "medium";
 /**
  * The tier the Copilot's ERRANDS run at: sub-agent children, compaction
  * summaries, and auto-titles.
@@ -385,9 +402,40 @@ export function findHostedAiModelSpec(model, preferredUseCase) {
             if (spec.model === model)
                 return spec;
         }
+        if (useCase === "copilot") {
+            const legacy = LEGACY_COPILOT_MODEL_SPECS.find((spec) => spec.model === model);
+            if (legacy)
+                return legacy;
+        }
     }
     return null;
 }
+/**
+ * The models the registry runs (a tier's model or fallback, or a retained
+ * Copilot spec) that accept image input: OpenRouter lists "image" in their
+ * `architecture.input_modalities` (read 2026-10-10).
+ *
+ * Whether a model can look at a rendered page belongs to the model, so it is
+ * kept here beside it. It used to be only the deploy allowlist
+ * OXYGEN_VISUAL_VISION_MODELS, which named the Kimi models alone while the
+ * Copilot moved to Sol and then to Haiku on 2026-10-10. The Copilot then stopped
+ * seeing its own renders without an error anywhere, and production never set
+ * the allowlist at all (Tim, 2026-10-10: the model catalog decides). The
+ * allowlist still adds exact model ids.
+ */
+export const IMAGE_INPUT_MODELS = new Set([
+    "openai/gpt-6.1-sol",
+    "openai/gpt-6-luna",
+    "anthropic/claude-sonnet-5.5",
+    "anthropic/claude-haiku-5.5",
+    "moonshotai/kimi-k3",
+    "moonshotai/kimi-k2.6",
+    "deepseek/deepseek-v4.1-flash",
+    "google/gemini-3.8-flash",
+]);
+export function modelAcceptsImages(model) {
+    return IMAGE_INPUT_MODELS.has(model);
+}
 export function resolveHostedAiModel(input) {
     // `auto` exists only on the copilot registry. Asking ai_column or agent for it
     // is a caller bug, and resolving `undefined` here would hand the request
@@ -485,6 +533,14 @@ function managedModelLabels(preferredUseCase, env = typeof process === "undefine
             }
         }
     }
+    for (const spec of LEGACY_COPILOT_MODEL_SPECS) {
+        if (!labels.has(spec.model))
+            labels.set(spec.model, spec.displayName);
+        for (const fallback of spec.fallbackModels) {
+            if (!labels.has(fallback))
+                labels.set(fallback, BACKUP_MODEL_LABEL);
+        }
+    }
     return labels;
 }
 /**
@@ -590,20 +646,15 @@ export function hostedAiDefaultModels(useCase) {
     };
 }
 /**
- * Staff dev experiment: only the authoritative selfhost-dev deployment and an
- * explicit enable flag can run Copilot. NODE_ENV and request hosts cannot open
- * it; production and shadow remain closed even with an enabled flag.
+ * Whether this deployment runs the Copilot for anyone. Who may use it is
+ * `copilotAudience` / `isCopilotAvailableTo` in `./copilot-access.ts`; only the
+ * self-hosted dev and production deployments read the flag, and NODE_ENV or a
+ * request host can never open it.
  */
 export function isCopilotEnabled(env = process.env) {
-    if (env.OXYGEN_DEPLOY_ENV?.trim().toLowerCase() !== "selfhost-dev")
-        return false;
-    return isCopilotAccountingEnabled(env);
+    return copilotAudience(env) !== "off";
 }
 /** Historical cost reconciliation may settle receipts without running Copilot. */
 export function isCopilotAccountingEnabled(env = process.env) {
-    const raw = env.OXYGEN_COPILOT_ENABLED;
-    if (typeof raw !== "string")
-        return false;
-    const normalized = raw.trim().toLowerCase();
-    return normalized === "1" || normalized === "true";
+    return isCopilotFlagOn(env);
 }

package/node_modules/@oxygen/shared/dist/langfuse.d.ts

@@ -110,7 +110,7 @@ export type LlmTracingClient = {
 };
 /**
  * FAIL CLOSED: LLM tracing is on only when OXYGEN_LLM_TRACING_ENABLED is exactly
- * "1"/"true" (trimmed, case-insensitive) AND both Langfuse keys are present.
+ * "1"/"true" (trimmed, case-insensitive), both keys and an explicit self-hosted URL.
  */
 export declare function isLlmTracingEnabled(env?: EnvMap): boolean;
 export declare function resolveLlmTracingEnvironment(env?: EnvMap): string;