@onepointfour-packs/flaredeck-agent 0.1.0

package/dist/githubauth.d.ts

@@ -0,0 +1,21 @@
+/**
+ * GitHub, authorised the same way as Claude and FlareDeck: a code you approve on any device.
+ *
+ * The point is not convenience, it is where the credential lives. Today the agent has `gh` and
+ * could read the token out of it; with this, the harness holds it and the agent has only the
+ * publishing tools. That turns "the agent should not push to dev" from a rule it is asked to
+ * follow into something it has no means to do.
+ *
+ * Device flow suits an agent box for the same reason `--no-browser` does: the machine may have
+ * no browser, and the approval happens wherever you are.
+ */
+/** Public by design — a device-flow client has no secret, which is why it suits an unattended box. */
+export declare const GITHUB_CLIENT_ID = "Ov23liGPUwgxEVJBsYlU";
+export type GitHubTokens = {
+    accessToken: string;
+    refreshToken?: string;
+    /** Epoch ms. Absent expiry means a classic non-expiring token. */
+    expiresAt?: number;
+};
+export declare function authorizeGitHub(say: (s: string) => void): Promise<GitHubTokens>;
+export declare function freshGitHubToken(tokens: GitHubTokens, onRefreshed: (t: GitHubTokens) => void): Promise<string>;

package/dist/githubauth.js

@@ -0,0 +1,90 @@
+/**
+ * GitHub, authorised the same way as Claude and FlareDeck: a code you approve on any device.
+ *
+ * The point is not convenience, it is where the credential lives. Today the agent has `gh` and
+ * could read the token out of it; with this, the harness holds it and the agent has only the
+ * publishing tools. That turns "the agent should not push to dev" from a rule it is asked to
+ * follow into something it has no means to do.
+ *
+ * Device flow suits an agent box for the same reason `--no-browser` does: the machine may have
+ * no browser, and the approval happens wherever you are.
+ */
+/** Public by design — a device-flow client has no secret, which is why it suits an unattended box. */
+export const GITHUB_CLIENT_ID = 'Ov23liGPUwgxEVJBsYlU';
+/** Read/write on the repos you can reach. Broad; a GitHub App would scope it per repo. */
+const SCOPE = 'repo';
+const form = async (url, body) => {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+        body: new URLSearchParams(body).toString(),
+    });
+    return res.json();
+};
+export async function authorizeGitHub(say) {
+    const start = await form('https://github.com/login/device/code', {
+        client_id: GITHUB_CLIENT_ID,
+        scope: SCOPE,
+    });
+    if (!start.device_code) {
+        throw new Error(`GitHub would not start a device login: ${JSON.stringify(start)}. ` +
+            `If this says "device flow disabled", the OAuth App needs Enable Device Flow ticked.`);
+    }
+    say('On any device, open:');
+    say('');
+    say(start.verification_uri);
+    say('');
+    say(`and enter this code:   ${start.user_code}`);
+    say('');
+    say(`Waiting for you to approve it (the code is good for ${Math.round(start.expires_in / 60)} minutes)…`);
+    const deadline = Date.now() + start.expires_in * 1000;
+    // GitHub asks for a minimum gap and will tell us off with slow_down if we ignore it.
+    let wait = Math.max(start.interval, 5) * 1000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, wait));
+        const res = await form('https://github.com/login/oauth/access_token', {
+            client_id: GITHUB_CLIENT_ID,
+            device_code: start.device_code,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        });
+        if (res.access_token) {
+            return {
+                accessToken: res.access_token,
+                refreshToken: res.refresh_token,
+                ...(res.expires_in ? { expiresAt: Date.now() + Number(res.expires_in) * 1000 } : {}),
+            };
+        }
+        if (res.error === 'authorization_pending')
+            continue;
+        if (res.error === 'slow_down') {
+            wait += 5000;
+            continue;
+        }
+        throw new Error(`GitHub login failed: ${res.error_description || res.error}`);
+    }
+    throw new Error('The GitHub code expired before it was approved.');
+}
+/** Refresh a minute early, so a token never expires in the middle of a push. */
+const EARLY_MS = 60_000;
+export async function freshGitHubToken(tokens, onRefreshed) {
+    if (!tokens.expiresAt || Date.now() < tokens.expiresAt - EARLY_MS)
+        return tokens.accessToken;
+    if (!tokens.refreshToken)
+        return tokens.accessToken;
+    const res = await form('https://github.com/login/oauth/access_token', {
+        client_id: GITHUB_CLIENT_ID,
+        grant_type: 'refresh_token',
+        refresh_token: tokens.refreshToken,
+    });
+    if (!res.access_token)
+        throw new Error(`Could not refresh GitHub: ${res.error_description || res.error}`);
+    const next = {
+        accessToken: res.access_token,
+        // GitHub re-issues the refresh token; keeping the old one would strand the agent later.
+        refreshToken: res.refresh_token ?? tokens.refreshToken,
+        ...(res.expires_in ? { expiresAt: Date.now() + Number(res.expires_in) * 1000 } : {}),
+    };
+    onRefreshed(next);
+    return next.accessToken;
+}
+//# sourceMappingURL=githubauth.js.map

package/dist/githubauth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"githubauth.js","sourceRoot":"","sources":["../src/githubauth.ts"],"names":[],"mappings":"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"}

package/dist/intake.d.ts

@@ -0,0 +1,124 @@
+import type { Flaredeck } from './flaredeck.js';
+import { type JevVerdict } from './jev.js';
+import { type Providers } from './providers.js';
+import { type CodeSearch } from './codesearch.js';
+/**
+ * Intake: what a card is about, worked out BEFORE the working model is woken.
+ *
+ * A fresh session used to spend ~90k tokens orienting itself — the guide, every comment on the
+ * card, the repo — on the most expensive model available, and did it again on every wake. Two
+ * cheaper steps now come first:
+ *
+ *   1. A digest, in plain code: the card and its thread fetched over REST, HTML stripped, the
+ *      harness's own run-result dumps collapsed to a line, old comments trimmed. Costs nothing.
+ *   2. A brief, from a small model: one tool-less Haiku turn turns the digest into a structured
+ *      requirement — the ask, how to reproduce it, what done looks like, where the evidence is —
+ *      and a classification of how hard the work is and where it lives.
+ *
+ * The classification picks the model for the real turn, so a copy change is not done by the
+ * model that does production data corrections. The working agent still has every tool and can
+ * read the thread itself; the brief is a head start, not a wall.
+ *
+ * The small model is one provider behind an interface. Gemini Flash-Lite or TypeSafe's Jev can
+ * take the same digest and return the same shape; Haiku was first because it runs on the
+ * subscription already paid for and needs no key.
+ */
+export type Brief = {
+    /** What is actually being asked for, in one or two sentences. */
+    ask: string;
+    /** How to see the problem, in order. Empty for a feature. */
+    repro: string[];
+    /** Where the work most likely lives: a layer, module or file area named in the thread. */
+    area: string;
+    /** What a reviewer would check to call it done. */
+    acceptance: string[];
+    /** Pointers worth following: attachment names, URLs, error strings, ids. */
+    evidence: string[];
+    /** Decisions or facts the thread leaves open — what to ask a person about. */
+    open_questions: string[];
+    /** How much work this is, from what the thread shows. */
+    complexity: 'small' | 'medium' | 'large';
+    /** Whether doing it right means reading or changing production data. */
+    touches_production_data: boolean;
+    /** 0–1: how sure the small model is of the classification. */
+    confidence: number;
+};
+export type Intake = {
+    /** The digest the brief was built from — kept so the saving can be measured. */
+    digest: string;
+    brief: Brief | null;
+    /** Jev's reading of the same digest, when an OpenRouter key is configured. */
+    jev: JevVerdict | null;
+    /** Who wrote `brief`. */
+    briefBy: 'haiku' | 'gemini' | null;
+    /** Files in the repo that mention names from the card, when a repo was given. */
+    files: CodeSearch | null;
+    /** The other writer's brief, when the dry run asked for both. */
+    other: {
+        by: 'haiku' | 'gemini';
+        brief: Brief | null;
+        secs: number;
+    } | null;
+    /** Which classifier chose the model. */
+    /** How big the work is, for an engine to map to a model of its own. */
+    size: Size | undefined;
+    routedBy: 'jev' | 'brief' | 'default';
+    /**
+     * Set when the card cannot be worked yet: it links evidence the harness cannot read. The turn
+     * must not start — a model that cannot see the recording will guess at what is in it — and a
+     * person is told what access is missing.
+     */
+    blocked?: string;
+    /** The model the real turn should run on; undefined leaves the SDK default. */
+    model: string | undefined;
+    /** One line for the pane. */
+    summary: string;
+};
+/**
+ * The card and its thread as compact text. Pure code, so it is always available and always
+ * free; the brief step may be skipped, this one never is.
+ */
+export declare function digestCard(deck: Flaredeck, cardIdOrCode: string): Promise<{
+    text: string;
+    comments: number;
+}>;
+/** One tool-less turn on the small model. Returns null rather than throwing: intake is a head start, not a gate. */
+export declare function writeBrief(digest: string, log: (text: string) => void): Promise<Brief | null>;
+/** The same brief from Gemini: one REST call, JSON enforced by schema, free at this volume. */
+export declare function writeBriefGemini(digest: string, providers: Providers, log: (text: string) => void): Promise<Brief | null>;
+/**
+ * Which model does the real work. Production data always gets the best model regardless of
+ * size — the cost of a wrong UPDATE is not measured in tokens. Low confidence is treated as
+ * medium: the small model not knowing is not a reason to go cheap.
+ */
+export type Size = 'small' | 'medium' | 'large';
+/**
+ * How big the work is — the decision itself, separate from any vendor's name for a model that
+ * suits it. A Claude model id handed to a Gemini agent is a 404 and a card that fails forever,
+ * which is exactly what happened; each engine reads the SIZE and picks its own.
+ */
+export declare function sizeFromBrief(brief: Brief | null): Size | undefined;
+export declare function sizeFromJev(jev: JevVerdict | null): Size | undefined;
+export declare function routeModel(brief: Brief | null): string | undefined;
+/**
+ * Jev's answer, read the same way, and it is the one that counts: deciding a typed question is
+ * what a decision model is for, and it costs a thousandth of what the brief does. The brief's
+ * own classification decides only when Jev is not configured or did not answer; when neither
+ * is available, the SDK default stands.
+ */
+export declare function routeModelFromJev(jev: JevVerdict | null): string | undefined;
+/** One line each for the pane, so the two classifiers can be compared on real cards. */
+export declare function compareLine(brief: Brief | null, jev: JevVerdict | null, by?: 'haiku' | 'gemini'): string;
+/** What the working agent is handed in place of "read the card". */
+/** Everything intake can hand the agent: the brief when there is one, the candidate files either way. */
+export declare function intakeText(prepared: Intake | null): string;
+export declare function briefText(brief: Brief, digestChars: number, files?: CodeSearch | null): string;
+/**
+ * The whole step for one card event. Never throws, never blocks the turn for long: a failure
+ * anywhere means the turn runs the old way, on the default model, with the old prompt.
+ */
+export declare function intake(deck: Flaredeck | undefined, cardIdOrCode: string, log: (text: string) => void, 
+/** Dry run: write the brief with BOTH available writers so they can be compared. */
+compare?: boolean, 
+/** The checkout to search for the card's names in. */
+repo?: string): Promise<Intake | null>;

package/dist/intake.js

@@ -0,0 +1,383 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { subscriptionEnv } from './agent.js';
+import { classifyWithJev } from './jev.js';
+import { geminiBriefText, GEMINI_DEFAULT_MODEL } from './gemini.js';
+import { jamEvidence, jamLinks, loadJam } from './jam.js';
+import { loadProviders } from './providers.js';
+import { codeSearch, codeSearchText } from './codesearch.js';
+/** Cheapest model that can write a structured brief. */
+const INTAKE_MODEL = 'claude-haiku-4-5-20251001';
+/**
+ * What the classification buys. Opus 5.5 outscores Fable 5.1 on Anthropic's coding and agentic
+ * benchmarks at 40% of the price, so large work stays on Opus; Fable is for a card Opus has
+ * already failed, and is chosen by a person, not by the router.
+ */
+const ROUTE = {
+    small: 'claude-sonnet-5-5',
+    medium: 'claude-opus-5-5',
+    large: 'claude-opus-5-5',
+};
+const MAX_COMMENTS = 25;
+const MAX_COMMENT_CHARS = 1500;
+const MAX_DESCRIPTION_CHARS = 6000;
+const MAX_NOTES_CHARS = 4000;
+/**
+ * The card and its thread as compact text. Pure code, so it is always available and always
+ * free; the brief step may be skipped, this one never is.
+ */
+export async function digestCard(deck, cardIdOrCode) {
+    const card = await deck.card(cardIdOrCode);
+    const comments = Array.isArray(card.comments) ? card.comments : [];
+    const recent = comments.slice(-MAX_COMMENTS);
+    const lines = [];
+    lines.push(`# ${card.code ?? ''} ${card.name ?? ''}`.trim());
+    const meta = [
+        card.board_name && `board ${card.board_name}`,
+        card.lane?.name && `lane ${card.lane.name}`,
+        card.type && `type ${card.type}`,
+        card.priority != null && `priority ${card.priority}`,
+        card.assigned_to?.name && `assigned to ${card.assigned_to.name}`,
+        card.reporter?.name && `reported by ${card.reporter.name}`,
+        Array.isArray(card.labels) && card.labels.length && `labels ${card.labels.join(', ')}`,
+    ].filter(Boolean);
+    if (meta.length)
+        lines.push(meta.join(' · '));
+    if (card.url)
+        lines.push(String(card.url));
+    if (card.description)
+        lines.push('', '## Description', clip(String(card.description), MAX_DESCRIPTION_CHARS));
+    // The previous session's handover. Entries are appended oldest first, so a long scratchpad keeps its tail.
+    const notes = typeof card.agent_notes === 'string' ? card.agent_notes.trim() : '';
+    if (notes) {
+        const tail = notes.length > MAX_NOTES_CHARS ? `[… earlier notes on the card]\n${notes.slice(-MAX_NOTES_CHARS)}` : notes;
+        lines.push('', '## Agent notes (a previous session\'s handover on this card)', tail);
+    }
+    const files = comments.map((c) => c.file).filter(Boolean);
+    if (files.length)
+        lines.push('', '## Attachments', ...files.map((f) => `- ${attachmentName(f)}`));
+    if (recent.length) {
+        lines.push('', `## Thread (${recent.length} of ${comments.length} comments, oldest first)`);
+        for (const c of recent) {
+            const who = c.sender_name ?? 'someone';
+            const when = c.created_at ? String(c.created_at).slice(0, 16).replace('T', ' ') : '';
+            lines.push('', `### ${who}${when ? ` · ${when}` : ''}`, collapse(String(c.message ?? '')));
+            if (c.approval) {
+                const a = c.approval;
+                lines.push(`[approval: ${a.state}${a.outcome ? ` · ${a.outcome}` : ''}${a.ran_at ? ' · ran' : ''}]`);
+            }
+        }
+    }
+    return { text: lines.join('\n'), comments: comments.length };
+}
+/**
+ * A run result is a header line and then the raw output — hundreds of rows, sometimes. The next
+ * session needs to know it ran and what it was, not every row; the card still holds the rows.
+ */
+function collapse(message) {
+    const m = message.trim();
+    const fence = m.indexOf('```');
+    if (/^\*\*Production run/.test(m) && fence > 0) {
+        const head = m.slice(0, fence).trim();
+        const body = m.slice(fence);
+        const rows = (body.match(/\n/g) || []).length;
+        return `${head}\n[output: ${rows} lines, on the card]`;
+    }
+    return clip(m, MAX_COMMENT_CHARS);
+}
+function clip(text, max) {
+    return text.length > max ? `${text.slice(0, max)}\n[… ${text.length - max} more characters on the card]` : text;
+}
+function attachmentName(file) {
+    const url = typeof file === 'string' ? file : file?.url ?? file?.name ?? '';
+    const name = typeof file === 'object' && file?.name ? String(file.name) : decodeURIComponent((String(url).split('?')[0] ?? '').split('/').pop() || '');
+    return name.replace(/^\d{13}-/, '') || 'attachment';
+}
+const BRIEF_PROMPT = [
+    'You are the intake step for a software engineering agent. Below is a Kanban card and its',
+    'comment thread. Produce ONE JSON object, and nothing else — no prose, no code fence — with',
+    'exactly these keys:',
+    '',
+    '  ask: string — what is being asked for, one or two sentences, in your own words',
+    '  repro: string[] — steps to see the problem, in order; [] for a feature or a question',
+    '  area: string — where the work most likely lives (layer, service, module, file area), from clues in the thread',
+    '  acceptance: string[] — what a reviewer would check to call it done',
+    '  evidence: string[] — pointers worth following: attachment names, URLs, error strings, ids, dates',
+    '  open_questions: string[] — decisions or facts the thread leaves open that a person would have to answer',
+    '  complexity: "small" | "medium" | "large" — small: a contained change or a lookup, one file or one query;',
+    '      medium: a real fix across a few files with tests; large: cross-layer, a design choice, a migration, or anything touching production data',
+    '  touches_production_data: boolean — true if doing it right means reading or changing a production database',
+    '  confidence: number 0-1 — how sure you are of complexity and area',
+    '',
+    'If the latest comments show the work is already done or waiting on a person, say so in `ask`.',
+    'If there are agent notes, they are a previous session\'s handover: say in `ask` what was already tried or found, and put the places they name in `area` and `evidence`.',
+    'Be concrete and short. Quote identifiers exactly.',
+    '',
+    '----- CARD -----',
+].join('\n');
+/** One tool-less turn on the small model. Returns null rather than throwing: intake is a head start, not a gate. */
+export async function writeBrief(digest, log) {
+    return writeBriefHaiku(digest, log);
+}
+/** The same brief from Gemini: one REST call, JSON enforced by schema, free at this volume. */
+export async function writeBriefGemini(digest, providers, log) {
+    if (!providers.gemini)
+        return null;
+    const started = Date.now();
+    try {
+        const ask = () => geminiBriefText(`${BRIEF_PROMPT}\n${digest}`, providers.gemini.apiKey, providers.gemini.model ?? GEMINI_DEFAULT_MODEL);
+        // Overloaded or rate-limited: one more try after a pause, then give the job to Haiku.
+        const { text, usage, model } = await ask().catch(async (e) => {
+            if ([429, 503].includes(Number(e?.status))) {
+                await new Promise((r) => setTimeout(r, 3000));
+                return ask();
+            }
+            throw e;
+        });
+        const brief = parseBrief(text);
+        if (!brief) {
+            log(`intake: gemini did not return a usable brief (${Math.round((Date.now() - started) / 1000)}s)`);
+            return null;
+        }
+        log(`intake: gemini ${model} · ${usage.input_tokens} in / ${usage.output_tokens} out · ${Math.round((Date.now() - started) / 1000)}s`);
+        return brief;
+    }
+    catch (e) {
+        log(`intake: gemini brief failed — ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+async function writeBriefHaiku(digest, log) {
+    const started = Date.now();
+    try {
+        let text = '';
+        const running = query({
+            prompt: `${BRIEF_PROMPT}\n${digest}`,
+            options: {
+                model: INTAKE_MODEL,
+                systemPrompt: 'You answer with a single JSON object and nothing else.',
+                tools: [],
+                allowedTools: [],
+                maxTurns: 1,
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                settingSources: [],
+                env: subscriptionEnv(),
+                managedSettings: { disableClaudeAiConnectors: true },
+            },
+        });
+        for await (const message of running) {
+            if (message?.type === 'assistant') {
+                for (const block of message.message?.content ?? [])
+                    if (block?.type === 'text')
+                        text += block.text;
+            }
+            if (message?.type === 'result' && typeof message.result === 'string' && !text)
+                text = message.result;
+        }
+        const brief = parseBrief(text);
+        if (!brief) {
+            log(`intake: the small model did not return a usable brief (${Math.round((Date.now() - started) / 1000)}s)`);
+            return null;
+        }
+        return brief;
+    }
+    catch (e) {
+        log(`intake: brief failed — ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+function parseBrief(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start < 0 || end <= start)
+        return null;
+    try {
+        const raw = JSON.parse(text.slice(start, end + 1));
+        const arr = (v) => (Array.isArray(v) ? v.map(String) : []);
+        const complexity = ['small', 'medium', 'large'].includes(raw.complexity) ? raw.complexity : 'medium';
+        return {
+            ask: String(raw.ask ?? ''),
+            repro: arr(raw.repro),
+            area: String(raw.area ?? ''),
+            acceptance: arr(raw.acceptance),
+            evidence: arr(raw.evidence),
+            open_questions: arr(raw.open_questions),
+            complexity,
+            touches_production_data: !!raw.touches_production_data,
+            confidence: Math.max(0, Math.min(1, Number(raw.confidence) || 0)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * How big the work is — the decision itself, separate from any vendor's name for a model that
+ * suits it. A Claude model id handed to a Gemini agent is a 404 and a card that fails forever,
+ * which is exactly what happened; each engine reads the SIZE and picks its own.
+ */
+export function sizeFromBrief(brief) {
+    if (!brief)
+        return undefined;
+    if (brief.touches_production_data)
+        return 'large';
+    if (brief.confidence < 0.5)
+        return 'medium';
+    return brief.complexity;
+}
+export function sizeFromJev(jev) {
+    if (!jev)
+        return undefined;
+    if (jev.production_data >= 0.5)
+        return 'large';
+    return jev.complexity;
+}
+export function routeModel(brief) {
+    const size = sizeFromBrief(brief);
+    return size ? ROUTE[size] : undefined;
+}
+/**
+ * Jev's answer, read the same way, and it is the one that counts: deciding a typed question is
+ * what a decision model is for, and it costs a thousandth of what the brief does. The brief's
+ * own classification decides only when Jev is not configured or did not answer; when neither
+ * is available, the SDK default stands.
+ */
+export function routeModelFromJev(jev) {
+    if (!jev)
+        return undefined;
+    if (jev.production_data >= 0.5)
+        return ROUTE.large;
+    // Jev decides whenever it answers. Its confidence is logged beside the brief's reading so a
+    // person can see where it was unsure, but a low number is not a reason to hand the choice to
+    // a model that costs a thousand times more to ask.
+    return ROUTE[jev.complexity];
+}
+/** One line each for the pane, so the two classifiers can be compared on real cards. */
+export function compareLine(brief, jev, by = 'haiku') {
+    const b = brief ? `${by}: ${brief.complexity}${brief.touches_production_data ? ' · prod data' : ''} · ${Math.round(brief.confidence * 100)}%` : `${by}: no brief`;
+    const j = jev
+        ? `jev: ${jev.complexity} (${jev.score.toFixed(2)}) · prod ${Math.round(jev.production_data * 100)}% · settled ${Math.round(jev.settled * 100)}% · ${jev.kind} · ${Math.round(jev.confidence * 100)}% · $${jev.cost_usd.toFixed(5)}`
+        : 'jev: off';
+    return `${b} | ${j}`;
+}
+/** What the working agent is handed in place of "read the card". */
+/** Everything intake can hand the agent: the brief when there is one, the candidate files either way. */
+export function intakeText(prepared) {
+    if (!prepared)
+        return '';
+    if (prepared.brief)
+        return briefText(prepared.brief, prepared.digest.length, prepared.files);
+    const files = codeSearchText(prepared.files);
+    return files ? `\n## Intake (no brief could be written for this card)\n${files}\n` : '';
+}
+export function briefText(brief, digestChars, files = null) {
+    const list = (title, items) => (items.length ? [`${title}:`, ...items.map((i) => `  - ${i}`)] : []);
+    return [
+        '',
+        '## Intake brief (prepared from the card and its thread before you started)',
+        '',
+        `Ask: ${brief.ask}`,
+        `Likely area: ${brief.area || 'not clear from the thread'}`,
+        `Size: ${brief.complexity}${brief.touches_production_data ? ' · touches production data' : ''} (confidence ${Math.round(brief.confidence * 100)}%)`,
+        ...list('Reproduce', brief.repro),
+        ...list('Done means', brief.acceptance),
+        ...list('Evidence to follow', brief.evidence),
+        ...list('Open questions', brief.open_questions),
+        codeSearchText(files),
+        '',
+        `This brief is a head start, not the card. Anything the brief does not cover is still yours to`,
+        `read with get-card-details — but you`,
+        `do not need to re-read a ${Math.round(digestChars / 1000)}k-character thread to find out what the card is about.`,
+    ].join('\n');
+}
+/**
+ * The whole step for one card event. Never throws, never blocks the turn for long: a failure
+ * anywhere means the turn runs the old way, on the default model, with the old prompt.
+ */
+export async function intake(deck, cardIdOrCode, log, 
+/** Dry run: write the brief with BOTH available writers so they can be compared. */
+compare = false, 
+/** The checkout to search for the card's names in. */
+repo) {
+    if (!deck)
+        return null;
+    const started = Date.now();
+    try {
+        const digested = await digestCard(deck, cardIdOrCode);
+        const comments = digested.comments;
+        let text = digested.text;
+        // A Jam link on the card is evidence the agent would otherwise have to go and watch. Read it
+        // here, as text, so the brief and the classification see it too. Two at most: a card with
+        // more is a thread of attempts, and the latest two are the ones that matter.
+        const links = jamLinks(text).slice(-2);
+        if (links.length) {
+            const jam = loadJam();
+            const blocked = (why) => ({
+                digest: text, brief: null, jev: null, briefBy: null, other: null, files: null, model: undefined, size: undefined, routedBy: 'default',
+                summary: `intake: blocked — ${why}`, blocked: why,
+            });
+            if (!jam) {
+                return blocked(`this card links a Jam recording (${links.join(', ')}) and this machine has no Jam login, so the recording cannot be read. ` +
+                    'On the agent\'s machine run `flaredeck-agent login --jam` in a workspace that can see it, then clear needs-human to retry.');
+            }
+            const evidence = await Promise.all(links.map((u) => jamEvidence(u, jam, log)));
+            const unreadable = evidence.map((e, i) => ({ e, url: links[i] })).filter((x) => !x.e.ok);
+            if (unreadable.length) {
+                return blocked(`the Jam recording${unreadable.length > 1 ? 's' : ''} on this card cannot be read with the Jam login on the agent's machine: ` +
+                    unreadable.map((x) => `${x.url} (${x.e.error})`).join('; ') +
+                    '. Share the recording with that Jam workspace, or sign the machine into the workspace that owns it (`flaredeck-agent login --jam`), then clear needs-human to retry.');
+            }
+            text += `\n\n## Jam recordings (read by the harness)\n\n${evidence.map((e) => e.text).join('\n\n')}`;
+        }
+        const providers = loadProviders();
+        const briefBy = providers.brief === 'gemini' && providers.gemini ? 'gemini' : 'haiku';
+        const otherBy = briefBy === 'gemini' ? 'haiku' : 'gemini';
+        const write = (by) => (by === 'gemini' ? writeBriefGemini(text, providers, log) : writeBriefHaiku(text, log));
+        const timed = async (by) => { const t = Date.now(); const b = await write(by); return { by, brief: b, secs: Math.round((Date.now() - t) / 1000) }; };
+        // All at once: the brief takes tens of seconds, Jev about one, the code search a second or two.
+        const [mine, other, jev, files] = await Promise.all([
+            timed(briefBy),
+            compare && (otherBy === 'haiku' || providers.gemini) ? timed(otherBy) : Promise.resolve(null),
+            providers.openrouter
+                ? classifyWithJev(text, providers.openrouter.apiKey).catch((e) => { log(`intake: jev failed — ${e instanceof Error ? e.message : String(e)}`); return null; })
+                : Promise.resolve(null),
+            repo ? codeSearch(repo, text).catch(() => null) : Promise.resolve(null),
+        ]);
+        if (files)
+            log(`intake: code search — ${files.files.length} candidate files from ${files.terms.length} names in ${files.ms}ms`);
+        let brief = mine.brief;
+        let briefWrittenBy = briefBy;
+        // The chosen writer failed and the comparison did not already run the other one: Haiku is
+        // always there, so a live card never goes to the agent without a brief over a 503.
+        if (!brief && !other && briefBy === 'gemini') {
+            log('intake: gemini gave no brief — falling back to haiku');
+            brief = await writeBriefHaiku(text, log);
+            briefWrittenBy = 'haiku';
+        }
+        else if (!brief && other?.brief) {
+            brief = other.brief;
+            briefWrittenBy = other.by;
+        }
+        const fromJev = routeModelFromJev(jev);
+        const fromBrief = routeModel(brief);
+        const model = fromJev ?? fromBrief;
+        const size = sizeFromJev(jev) ?? sizeFromBrief(brief);
+        const routedBy = fromJev ? 'jev' : fromBrief ? 'brief' : 'default';
+        const secs = Math.round((Date.now() - started) / 1000);
+        log(compareLine(brief, jev, briefWrittenBy));
+        if (other)
+            log(compareLine(other.brief, null, other.by).replace(' | jev: off', ` · ${other.secs}s (comparison only)`));
+        // The SIZE, not a model name. Routing decides how big the work is; each engine maps that to
+        // its own model, so printing one vendor's name told a Gemini agent it was about to run on
+        // claude-opus-5-5 — on the line directly after one saying the intake ran on gemini-3.5-flash-lite.
+        // It is the line you would read to reason about cost, so it should say the thing that is true
+        // whichever engine is about to run.
+        const summary = `intake: ${comments} comments → ${Math.round(text.length / 1000)}k chars · ${size ?? 'unsized'}${size ? ` by ${routedBy}` : ''} · ${secs}s`;
+        return { digest: text, brief, jev, briefBy: brief ? briefWrittenBy : null, other, files, model, size, routedBy, summary };
+    }
+    catch (e) {
+        log(`intake: skipped — ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+//# sourceMappingURL=intake.js.map