segreant 0.0.0-stage → 0.2.0

package/dist/judge/call.js

@@ -0,0 +1,161 @@
+/**
+ * The actual outbound call to an OpenAI-compatible judge endpoint (local or
+ * hosted — same wire shape either way, only baseUrl/apiKey differ). This module
+ * is deliberately STRICT: it throws JudgeCallError on anything short of a
+ * well-formed judgment, and never guesses. All graceful-degradation behavior
+ * (falling back to the algorithmic signal on failure) lives one layer up in
+ * judge/orchestrate.ts — this file either returns a trustworthy SessionJudgment
+ * or throws, nothing in between.
+ *
+ * See docs/DATA-BOUNDARIES.md for the judge egress and credential boundary:
+ * the judge credential is dedicated, never the metered proxy key.
+ */
+import { egressFetch, EgressError } from '../egress/transport.js';
+import { readBoundedResponseText, ResourceLimitError, RESOURCE_LIMITS } from '../util/resource-limits.js';
+export class JudgeCallError extends Error {
+    reason;
+    egressCode;
+    constructor(message, reason, egressCode) {
+        super(message);
+        this.name = 'JudgeCallError';
+        this.reason = reason;
+        this.egressCode = egressCode;
+    }
+}
+// Matches liftEfficiency.ts's algorithmic bound in spirit but wider, per the
+// design doc's §3 sketch ("bounded to [0.5, 1.5]") — an LLM judge has more
+// signal than the algorithmic pool, so its ceiling on how much it can move Lift
+// is deliberately looser, while still being a REAL bound, never open-ended.
+export const JUDGE_MULTIPLIER_FLOOR = 0.5;
+export const JUDGE_MULTIPLIER_CAP = 1.5;
+const CALL_TIMEOUT_MS = 30_000;
+function judgePrompt(summary, transcript) {
+    const metrics = `Session metrics:\n${JSON.stringify({
+        requestCount: summary.requestCount,
+        proposalCount: summary.proposalCount,
+        proposalCaptureCoverage: summary.proposalCaptureCoverage ?? 'unknown',
+        interTurnGapsSec: summary.interTurnGapsSec,
+        requestSizeTrend: summary.requestSizeTrend,
+        spanMinutes: Math.round(summary.spanMinutes * 10) / 10,
+    }, null, 2)}`;
+    if (!transcript) {
+        return ('You are judging how EFFICIENTLY an AI coding session used its time — not whether the code was good. ' +
+            'You will NOT see any prompt or code content, only structural session metrics. Reply with ONLY a JSON ' +
+            'object of the exact shape {"efficiencyMultiplier": number, "rationale": string}. ' +
+            `efficiencyMultiplier must be between ${JUDGE_MULTIPLIER_FLOOR} and ${JUDGE_MULTIPLIER_CAP}, where 1.0 means ` +
+            'no adjustment, above 1.0 means the session used AI-assisted time unusually well (few turns, tight timing, ' +
+            'proposals converging rather than sprawling), and below 1.0 means it looks like it flailed (many turns, ' +
+            'erratic or growing request sizes, few proposals relative to turns). rationale must be one short sentence.\n\n' +
+            metrics);
+    }
+    // Full-content variant: same task, same JSON contract, same bounds — the
+    // ONLY difference is a bounded transcript excerpt after the metrics, so a
+    // model prompted either way is judging the same question on more evidence.
+    const turnsBlock = transcript.turns.map((t) => `${t.role.toUpperCase()}: ${t.text}`).join('\n');
+    const clipNote = transcript.clippedTurns > 0 || transcript.droppedTurns > 0 || (transcript.truncatedLines ?? 0) > 0
+        ? `\n(Excerpt bounded: ${transcript.clippedTurns} turns clipped, ${transcript.droppedTurns} later turns dropped, ${transcript.truncatedLines ?? 0} oversized source lines skipped.)`
+        : '';
+    return ('You are judging how EFFICIENTLY an AI coding session used its time — not whether the code was good. ' +
+        'You will see structural session metrics AND a bounded excerpt of the actual session transcript. Reply with ' +
+        'ONLY a JSON object of the exact shape {"efficiencyMultiplier": number, "rationale": string}. ' +
+        `efficiencyMultiplier must be between ${JUDGE_MULTIPLIER_FLOOR} and ${JUDGE_MULTIPLIER_CAP}, where 1.0 means ` +
+        'no adjustment, above 1.0 means the session used AI-assisted time unusually well (clear asks, converging work, ' +
+        'little repetition), and below 1.0 means it flailed (re-asking the same thing, going in circles, long confused ' +
+        'stretches). Judge efficiency of the collaboration, not code quality. rationale must be one short sentence.\n\n' +
+        `${metrics}\n\nTranscript excerpt (${transcript.turns.length} turns):\n${turnsBlock}${clipNote}`);
+}
+function clamp(v, lo, hi) {
+    return Math.min(hi, Math.max(lo, v));
+}
+/**
+ * Calls one OpenAI-compatible Chat Completions endpoint and returns a validated
+ * SessionJudgment, or throws JudgeCallError. `apiKey` is null for local calls —
+ * no Authorization header is sent in that case, matching how the reverse proxy's
+ * own local-server support (x-segreant-openai-base) never assumes a key either.
+ */
+export async function callJudgeApi(baseUrl, model, apiKey, summary, confidence, timeoutMs = CALL_TIMEOUT_MS, transcript = null, purpose = 'local_judge') {
+    const controller = new AbortController();
+    const timeoutTimer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await egressFetch(baseUrl.replace(/\/$/, '') + '/chat/completions', {
+            purpose,
+            dataClass: transcript ? 'judge_transcript_excerpt' : 'judge_structural_summary',
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+            },
+            body: JSON.stringify({
+                model,
+                messages: [{ role: 'user', content: judgePrompt(summary, transcript) }],
+                response_format: { type: 'json_object' },
+                temperature: 0,
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const timedOut = controller.signal.aborted;
+        if (err instanceof EgressError && err.code !== 'transport_failed') {
+            const repair = err.code === 'receipt_integrity_failed' || err.code === 'receipt_persistence_failed'
+                ? '; repair/restore the local receipt history before retrying'
+                : '';
+            throw new JudgeCallError(`Segreant egress boundary refused the judge request (${err.code}): ${err.message}${repair}`, 'egress-boundary', err.code);
+        }
+        throw new JudgeCallError(timedOut ? `judge call timed out after ${timeoutMs}ms` : `judge endpoint unreachable: ${String(err)}`, timedOut ? 'timeout' : 'network');
+    }
+    finally {
+        clearTimeout(timeoutTimer);
+    }
+    if (!res.ok) {
+        try {
+            await readBoundedResponseText(res, RESOURCE_LIMITS.judgeResponseBytes, 'judge_response_bytes');
+        }
+        catch {
+            // The status is still the primary failure classification; the body is
+            // drained only up to the same bounded capture policy.
+        }
+        throw new JudgeCallError(`judge endpoint returned HTTP ${res.status}`, 'http-status');
+    }
+    let responseText;
+    try {
+        responseText = await readBoundedResponseText(res, RESOURCE_LIMITS.judgeResponseBytes, 'judge_response_bytes');
+    }
+    catch (error) {
+        if (error instanceof ResourceLimitError) {
+            throw new JudgeCallError('judge endpoint response exceeded the bounded response capture limit', 'malformed-response');
+        }
+        throw new JudgeCallError('judge endpoint response was not valid JSON', 'malformed-response');
+    }
+    let envelope;
+    try {
+        envelope = JSON.parse(responseText);
+    }
+    catch {
+        throw new JudgeCallError('judge endpoint response was not valid JSON', 'malformed-response');
+    }
+    const content = envelope?.choices?.[0]?.message
+        ?.content;
+    if (typeof content !== 'string') {
+        throw new JudgeCallError('judge endpoint response had no choices[0].message.content string', 'malformed-response');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new JudgeCallError('judge model reply was not valid JSON', 'malformed-response');
+    }
+    const rawMultiplier = parsed?.efficiencyMultiplier;
+    const rawRationale = parsed?.rationale;
+    if (typeof rawMultiplier !== 'number' || !Number.isFinite(rawMultiplier)) {
+        throw new JudgeCallError('judge model reply had a non-numeric or non-finite efficiencyMultiplier', 'malformed-response');
+    }
+    return {
+        sessionId: summary.sessionId,
+        efficiencyMultiplier: clamp(rawMultiplier, JUDGE_MULTIPLIER_FLOOR, JUDGE_MULTIPLIER_CAP),
+        confidence,
+        rationale: typeof rawRationale === 'string' && rawRationale.trim() ? rawRationale.trim().slice(0, 500) : '(judge gave no rationale)',
+    };
+}

package/dist/judge/orchestrate.js

@@ -0,0 +1,127 @@
+/**
+ * ISSUANCE CLASS: display_only — see `src/epistemic/issuance-map.ts`. A judge
+ * verdict is one model's opinion under a declared trust tier. It is never
+ * converted into a supported quality Claim, and no canonical issuance boundary
+ * consumes it.
+ *
+ * Ties the trust-ladder gate (tier.ts), the structural payload (payload.ts), and
+ * the outbound call (call.ts) into one entry point: `judgeSession`. This is the
+ * ONLY function anything else in the codebase should call to get a judgment —
+ * it is also the ONLY place that swallows a judge failure into a neutral
+ * result, and it does so visibly (via `rationale`), never silently.
+ *
+ * Safety property this file exists to guarantee: resolveJudgeTier is consulted
+ * BEFORE any payload is built or any network call is attempted. When it returns
+ * 'algorithmic', `judgeSession` returns immediately — no fetch, no summary
+ * construction, nothing. test/judge-orchestrate.test.ts asserts this directly by
+ * pointing an 'algorithmic'-tier config at an endpoint that would throw loudly
+ * if it were ever actually called.
+ */
+import { resolveJudgeTier, hasHostedJudgeApiKey } from './tier.js';
+import { buildStructuralSummary } from './payload.js';
+import { callJudgeApi, JudgeCallError } from './call.js';
+import { loadTranscriptExcerpt, transcriptSupport } from './transcript.js';
+function isSet(s) {
+    return typeof s === 'string' && s.trim().length > 0;
+}
+function neutralJudgment(sessionId, rationale) {
+    return { sessionId, efficiencyMultiplier: 1, confidence: 'algorithmic', rationale };
+}
+/**
+ * Pure except for the outbound HTTP call itself (and reading
+ * SEGREANT_JUDGE_API_KEY, via hasHostedJudgeApiKey). Takes already-fetched rows so
+ * it stays fully testable with synthetic data — see judgeSessionFromStore below
+ * for the store-integrated convenience wrapper.
+ */
+export async function judgeSession(sessionId, requests, proposals, cfg, transcript = null) {
+    const decision = resolveJudgeTier(cfg, hasHostedJudgeApiKey());
+    const notes = [...decision.notes];
+    if (decision.tier === 'algorithmic') {
+        return neutralJudgment(sessionId, notes.join(' ') || 'Judge tier: algorithmic (default).');
+    }
+    const isLocal = decision.tier === 'local-structural' || decision.tier === 'local-full';
+    const localEndpointIsOnDevice = isLocal && !decision.sendsContentOffDevice;
+    const baseUrl = isLocal ? cfg.localBaseUrl : cfg.hostedBaseUrl;
+    const model = isLocal ? cfg.localModel : cfg.hostedModel;
+    const apiKey = isLocal ? null : (process.env.SEGREANT_JUDGE_API_KEY ?? null);
+    if (!isSet(baseUrl) || !isSet(model)) {
+        const field = isLocal ? 'judge.localModel' : 'judge.hostedModel';
+        notes.push(`Judge tier ${decision.tier} is configured but missing a model name (${field}) — falling back to the algorithmic signal.`);
+        return neutralJudgment(sessionId, notes.join(' '));
+    }
+    // Full-content tiers send a real, bounded transcript excerpt when the caller
+    // supplied one (read ephemerally from the tool's own on-disk log — the store
+    // still never persists content). When no transcript exists for this session,
+    // downgrade the ACTUAL payload and the REPORTED confidence together — never
+    // claim a higher-fidelity source than what was truly sent. A transcript
+    // passed to a STRUCTURAL tier is deliberately ignored: the tier the user
+    // consented to caps what may be sent, never the other way around.
+    const wantsFullContent = decision.tier === 'local-full' || decision.tier === 'hosted-full';
+    const sendTranscript = wantsFullContent && transcript !== null && transcript.turns.length > 0 ? transcript : null;
+    const confidence = wantsFullContent
+        ? sendTranscript
+            ? decision.confidence // 'local-llm' or 'hosted-llm-full' — genuinely earned now
+            : isLocal
+                ? 'local-llm'
+                : 'hosted-llm-structural'
+        : decision.confidence;
+    if (wantsFullContent && sendTranscript) {
+        const bounds = sendTranscript.clippedTurns > 0 || sendTranscript.droppedTurns > 0
+            ? ` — bounded: ${sendTranscript.clippedTurns} turns clipped, ${sendTranscript.droppedTurns} dropped`
+            : '';
+        notes.push(`Transcript excerpt (${sendTranscript.turns.length} turns) read ephemerally from the tool's own log${bounds}; nothing was persisted.`);
+    }
+    else if (wantsFullContent) {
+        // decision.notes was seeded by tier.ts based on CONFIGURED intent (before
+        // this function knew the payload would be downgraded) and claims a
+        // fidelity — "full session content" — that never actually gets sent.
+        // Strip that claim rather than merely appending a correction after it, so
+        // the rationale never asserts something that didn't happen even
+        // momentarily within the same string.
+        for (let i = notes.length - 1; i >= 0; i--) {
+            if (/full session content/i.test(notes[i]))
+                notes.splice(i, 1);
+        }
+        notes.push(isLocal
+            ? localEndpointIsOnDevice
+                ? 'Judge tier: local LLM (full-content configured but no on-disk transcript found for this session — the structural-summary request targets the validated loopback endpoint; it stays within the configured loopback boundary).'
+                : 'Judge tier: local LLM (full-content configured but no on-disk transcript found for this session — the structural-summary request targets the configured endpoint; this destination is reported as remote/off-device).'
+            : 'Judge tier: hosted API (full-content configured but no on-disk transcript found for this session — only a structural summary left this machine, never raw content).');
+    }
+    const summary = buildStructuralSummary(requests, proposals, sessionId);
+    try {
+        const judgment = await callJudgeApi(baseUrl, model, apiKey, summary, confidence, undefined, sendTranscript, isLocal ? 'local_judge' : 'hosted_judge');
+        return notes.length ? { ...judgment, rationale: `${judgment.rationale} (${notes.join(' ')})` } : judgment;
+    }
+    catch (err) {
+        const reason = err instanceof JudgeCallError ? err.message : String(err);
+        notes.push(`Judge call failed (${reason}) — falling back to the algorithmic signal (multiplier 1, no adjustment).`);
+        return neutralJudgment(sessionId, notes.join(' '));
+    }
+}
+/**
+ * Store-integrated convenience wrapper, mirroring liftOptionsFromStore's
+ * relationship to liftFromData in src/value/. Project-scoped because the
+ * store's only range query over proposals (Store.proposalsInWindow) is.
+ *
+ * When (and only when) the resolved tier is a full-content one, this attempts
+ * the ephemeral transcript read: the session's recorded tool says whether an
+ * on-disk transcript can exist (claude-code names its files by session id),
+ * and the excerpt — if found — is passed to judgeSession, never persisted.
+ * The tier check happens BEFORE any file is touched, so a structural-tier or
+ * algorithmic-tier run never reads a transcript it would not be allowed to send.
+ */
+export async function judgeSessionFromStore(store, project, sessionId, windowStartMs, windowEndMs, cfg, transcriptRoots) {
+    const requests = store.requestsInRange(windowStartMs, windowEndMs);
+    const proposals = store.proposalsInWindow(project, windowStartMs, windowEndMs);
+    let transcript = null;
+    const decision = resolveJudgeTier(cfg, hasHostedJudgeApiKey());
+    if (decision.tier === 'local-full' || decision.tier === 'hosted-full') {
+        const meta = store.getSessionMeta(sessionId);
+        const tool = meta?.tool ?? null;
+        if (transcriptSupport(tool) === 'supported') {
+            transcript = await loadTranscriptExcerpt(sessionId, tool, transcriptRoots ?? {});
+        }
+    }
+    return judgeSession(sessionId, requests, proposals, cfg, transcript);
+}

package/dist/judge/payload.js

@@ -0,0 +1,47 @@
+/**
+ * The structural payload sent to an LLM judge tier — content-free by construction.
+ * See docs/RETURN-ON-INTELLIGENCE.md for the three signal
+ * types this draws from (proposal counts, turn/timing, request-size trend).
+ *
+ * Pure by design (plain rows in, a plain summary out — no store, no fetch) so it
+ * composes with judge/tier.ts's gate and stays exhaustively unit-testable. The
+ * store-integrated convenience wrapper lives in judge/orchestrate.ts, mirroring
+ * how value/lift.ts stays pure and value/realization.ts bridges it to the store.
+ *
+ * IMPORTANT — what "structural" means here in practice: Segreant's store never
+ * persists prompt text or the AI's response text (src/store/db.ts's RequestRow
+ * has no content field; ProposalRow stores only the proposed file diffs for the
+ * Acceptance lens). So this summary is genuinely ALL the session-level signal
+ * the STORE holds. The full-content judge tiers get more only via
+ * judge/transcript.ts, which reads the tool's own on-disk session log
+ * ephemerally at judge time — still nothing persisted by Segreant.
+ */
+/**
+ * Builds the summary for one session from already-fetched rows. Filters both
+ * arrays to `sessionId` internally, so callers can pass a whole Lift-window's
+ * worth of rows without pre-filtering.
+ */
+export function buildStructuralSummary(requests, proposals, sessionId) {
+    const sessionRequests = requests.filter((r) => r.sessionId === sessionId).sort((a, b) => a.tsEpochMs - b.tsEpochMs);
+    const sessionProposals = proposals.filter((p) => p.sessionId === sessionId);
+    const proposalCount = sessionProposals.filter((proposal) => proposal.captureCoverage === undefined || proposal.captureCoverage === 'complete').length;
+    const proposalCaptureCoverage = sessionProposals.length === 0
+        ? 'unknown'
+        : sessionProposals.some((proposal) => proposal.captureCoverage === 'truncated')
+            ? 'truncated'
+            : sessionProposals.some((proposal) => proposal.captureCoverage === 'legacy_unknown')
+                ? 'legacy_unknown'
+                : sessionProposals.some((proposal) => proposal.captureCoverage === 'unknown')
+                    ? 'unknown'
+                    : 'complete';
+    const interTurnGapsSec = [];
+    for (let i = 1; i < sessionRequests.length; i++) {
+        interTurnGapsSec.push((sessionRequests[i].tsEpochMs - sessionRequests[i - 1].tsEpochMs) / 1000);
+    }
+    const requestSizeTrend = sessionRequests.map((r) => r.inputTokens + r.outputTokens);
+    const totalCostUsd = sessionRequests.reduce((s, r) => s + r.costUsd, 0);
+    const spanMinutes = sessionRequests.length > 1
+        ? (sessionRequests[sessionRequests.length - 1].tsEpochMs - sessionRequests[0].tsEpochMs) / 60_000
+        : 0;
+    return { sessionId, requestCount: sessionRequests.length, proposalCount, proposalCaptureCoverage, interTurnGapsSec, requestSizeTrend, totalCostUsd, spanMinutes };
+}

package/dist/judge/tier.js

@@ -0,0 +1,107 @@
+/**
+ * The Lift judge trust ladder — a single, pure gate deciding which judge tier is
+ * active. See docs/DATA-BOUNDARIES.md for the public egress contract.
+ *
+ * This is the one place that decision gets made. Everything above the always-on
+ * algorithmic default (src/value/liftEfficiency.ts) is off unless the user has
+ * taken an explicit action, and no two tiers can be conflated: local and hosted
+ * are gated independently, and each has its own separate "send full content"
+ * flag so opting one tier into full-content sending can never silently affect
+ * the other. `resolveJudgeTier` takes plain data in and returns plain data out —
+ * no network calls, no file reads, no env access — so the gating logic itself is
+ * exhaustively testable without mocking anything. The one impure fact it needs
+ * (whether SEGREANT_JUDGE_API_KEY is set) is read by the separate
+ * `hasHostedJudgeApiKey` below and passed in by the caller.
+ */
+function isSet(s) {
+    return typeof s === 'string' && s.trim().length > 0;
+}
+/**
+ * A configured URL is treated as on-device only when its parsed host is literal
+ * loopback. A non-loopback or malformed URL remains an explicit local-tier
+ * selection, but its egress bit must warn that the endpoint is off-device.
+ */
+function isValidatedLoopbackEndpoint(value) {
+    if (!isSet(value))
+        return false;
+    try {
+        const parsed = new URL(value.trim());
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return false;
+        const hostname = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+        return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reads SEGREANT_JUDGE_API_KEY — deliberately a DIFFERENT env var than any credential
+ * the reverse proxy forwards. Reusing the metered key would be circular (using the
+ * thing being measured to also measure itself) and would show judge calls up as
+ * confusing extra spend on the same ledger they're supposed to be judging
+ * (see docs/DATA-BOUNDARIES.md). Never logged, never persisted to
+ * config.json, never returned by this function — only whether it's set.
+ */
+export function hasHostedJudgeApiKey(environment = process.env) {
+    return isSet(environment.SEGREANT_JUDGE_API_KEY);
+}
+/**
+ * The trust-ladder gate. Precedence when BOTH local and hosted are fully
+ * configured: local wins. It selects the configured local endpoint and does not
+ * select a hosted judge, so it is the strictly more conservative choice within
+ * the declared Segreant-process egress boundary; the loser is easy to switch (unset
+ * judge.localBaseUrl) — the alternative (silently preferring hosted) would mean
+ * a config that types out to "local is available" can still send content off
+ * the user's machine, which is exactly the silent-escalation shape
+ * the egress contract rules out.
+ */
+export function resolveJudgeTier(cfg, hostedApiKeyPresent) {
+    const notes = [];
+    const localOn = isSet(cfg.localBaseUrl);
+    const localLoopback = isValidatedLoopbackEndpoint(cfg.localBaseUrl);
+    const hostedConsent = cfg.hostedEnabled && hostedApiKeyPresent;
+    const hostedOperational = hostedConsent && isSet(cfg.hostedBaseUrl);
+    if (cfg.hostedEnabled !== hostedApiKeyPresent) {
+        notes.push(cfg.hostedEnabled
+            ? 'Hosted judge tier: judge.hostedEnabled is true but SEGREANT_JUDGE_API_KEY is not set — hosted judging stays off until both are true.'
+            : 'Hosted judge tier: SEGREANT_JUDGE_API_KEY is set but judge.hostedEnabled is false — hosted judging stays off until both are true.');
+    }
+    if (localOn && hostedOperational) {
+        notes.push('Both local and hosted judge tiers are configured; using local endpoint (configured) and no hosted judge call. ' +
+            'Unset judge.localBaseUrl to use the hosted tier instead.');
+    }
+    if (localOn) {
+        const full = cfg.localSendFullContent;
+        if (!localLoopback) {
+            notes.push('Judge tier: configured local endpoint is not a validated loopback URL; report this destination as remote/off-device.');
+        }
+        notes.push(full
+            ? 'Judge tier: local LLM endpoint, full session content; hosted tier is not selected.'
+            : 'Judge tier: local LLM endpoint, structural summary only; hosted tier is not selected.');
+        return {
+            tier: full ? 'local-full' : 'local-structural',
+            confidence: 'local-llm',
+            sendsContentOffDevice: !localLoopback,
+            notes,
+        };
+    }
+    if (hostedConsent && !isSet(cfg.hostedBaseUrl)) {
+        notes.push('Hosted judge tier: consented (hostedEnabled + SEGREANT_JUDGE_API_KEY) but judge.hostedBaseUrl is not ' +
+            'set — falling back to the algorithmic signal.');
+    }
+    if (hostedOperational) {
+        const full = cfg.hostedSendFullContent;
+        notes.push(full
+            ? 'Judge tier: hosted API, FULL session content leaves this machine.'
+            : 'Judge tier: hosted API, a structural proposal-count/timing summary leaves this machine (never raw content).');
+        return {
+            tier: full ? 'hosted-full' : 'hosted-structural',
+            confidence: full ? 'hosted-llm-full' : 'hosted-llm-structural',
+            sendsContentOffDevice: true,
+            notes,
+        };
+    }
+    notes.push('Judge tier: algorithmic (default) — no opt-in judge tier is fully configured.');
+    return { tier: 'algorithmic', confidence: 'algorithmic', sendsContentOffDevice: false, notes };
+}