toolroll 0.9.56 → 0.9.58

package/dist/toolroll-update.js

@@ -35,7 +35,7 @@ import { processMayBeAlive } from "./process-liveness.js";
 import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, releaseStaleCodingOwner, removeCodingUpdateGate } from "./coding-update.js";
 import { installLaunchdService, launchdPlist, stopLaunchdService, writeFileDurably } from "./daemon.js";
 import { NAME } from "./names.js";
-import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES } from "./store.js";
+import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES, V118_MERGED_TABLES } from "./store.js";
 import { isNewer, REGISTRY } from "./releases.js";
 import { markNeverIndex } from "./never-index.js";
 import { readRuntimeUpdateJournal, RUNTIME_PHASES, RUNTIME_UPDATE_STEPS, stagedStartedAt, updaterStartingOf } from "./contracts/update-journal.js";
@@ -382,6 +382,8 @@ const HISTORY_RULES = {
     // subagent*); a column renamed in a table that keeps its name keeps its values under the new one.
     ...Object.fromEntries(Object.entries(V117_RENAMED_TABLES).map(([old, now]) => [old, { moved: { into: now, where: "1" } }])),
     ...Object.fromEntries(V117_RENAMED_COLUMNS.filter(([table]) => !Object.values(V117_RENAMED_TABLES).includes(table)).map(([table, from, to]) => [table, { renamed: { [from]: to } }])),
+    // v118 (D7): every API token, coordinator and lead token arrives in the one credential table under its kind.
+    ...Object.fromEntries(Object.entries(V118_MERGED_TABLES).map(([table, kind]) => [table, { moved: { into: "credential", where: `kind = '${kind}'` } }])),
 };
 /** The tables a migration may remove whole (v115's removed features). */
 export const RETIRED_TABLES = Object.freeze(Object.keys(HISTORY_RULES).filter(name => HISTORY_RULES[name].retired));

package/dist/work-index.d.ts

@@ -1,5 +1,5 @@
 import { type Store, type TaskState } from './store.js';
-import type { AssignmentSnapshot } from './assignment.js';
+import { type AssignmentSnapshot } from './assignment.js';
 import type { WorkAction, WorkSummaryAccess } from './work-summary.js';
 import type { WorkStatus, WorkView } from './workspace-ui.js';
 import { type Ask, type AskChip } from './needs-you.js';
@@ -37,6 +37,7 @@ export type WorkIndexItem = {
     /** The viewer's own lead took it on (lead-voice.ts): "<name> is on it.", by the name they gave it, read now. */
     lead?: string;
 };
+/** `root`: the evidence root, so a result whose checks were Off can read the release check that covers it. */
 export type WorkIndexOptions = {
     view?: WorkView;
     limit?: number;
@@ -44,6 +45,7 @@ export type WorkIndexOptions = {
     project?: string | null;
     state?: TaskState;
     leadId?: string;
+    root?: string;
 };
 /** How the list is grouped: the Needs you rows by their ask, then building, then the rest. */
 export type WorkIndexGroup = Ask | 'building' | 'rest';
@@ -78,6 +80,9 @@ export declare class WorkIndexCursorError extends Error {
  * Project counters share the page's admitted project/state filter.
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export declare function workIndexPage(store: Store, now: Date, access: WorkSummaryAccess, options?: WorkIndexOptions): WorkIndexPage;
+/** An exact family lookup through the list's saved-fact projection. It remains
+ * permission-bound and bypasses pagination, never action-time verification. */
+export declare function workIndexTask(store: Store, taskId: string, now: Date, access: WorkSummaryAccess, root?: string): WorkIndexItem | null;
 export declare function workCountsByProject(store: Store, now: Date, access: WorkSummaryAccess): WorkProjectCounts[];
 /** Families whose headline is Ready for review, newest first: the Tasks
  * list's own rows, so a completed family (root or any revision), a failed

package/dist/work-index.js

@@ -8,8 +8,12 @@ import { join } from 'node:path';
 import { readProjectAccess } from './project-access.js';
 import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
 import { scopeTermsProblem, stopFactOf } from './store.js';
-import { leadOnIt, plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
-import { isCheckLevel } from './check-levels.js';
+import { assignmentChecksForRun } from './assignment.js';
+import { checkBackingOf, completionBlockersOf, leadOnIt, plainReasonOf, replacedWords, requirementsOf, stageOfCode, taskStatusOf, unverifiedWhenRefuted, workToneOf } from './task-status.js';
+import { releaseCoverageOf } from './release-coverage.js';
+import { buildReviewOf } from './review-switch.js';
+import { shownVerdictOf } from './proof.js';
+import { isCheckLevel, requiredCheckCommandFor } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
 import { ASKS, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, processNeedOf, resultHoldUpSentence } from './needs-you.js';
@@ -359,6 +363,14 @@ function readCursor(value, scope) {
  * Project counters share the page's admitted project/state filter.
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export function workIndexPage(store, now, access, options = {}) {
+    return readWorkIndexPage(store, now, access, options);
+}
+/** An exact family lookup through the list's saved-fact projection. It remains
+ * permission-bound and bypasses pagination, never action-time verification. */
+export function workIndexTask(store, taskId, now, access, root) {
+    return readWorkIndexPage(store, now, access, { limit: 1, ...(root === undefined ? {} : { root }) }, taskId).items[0] ?? null;
+}
+function readWorkIndexPage(store, now, access, options, taskId = null) {
     const projection = registerValidators(store);
     const custody = custodyReadings(store);
     const view = VIEWS.includes(options.view ?? 'all') ? options.view ?? 'all' : 'all';
@@ -366,7 +378,7 @@ export function workIndexPage(store, now, access, options = {}) {
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
     const filter = view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1' : view === 'completed' ? "code='complete'" : '1';
     const rows = prepared(store, `${projection}, selected_page AS MATERIALIZED (
-    SELECT * FROM ranked WHERE ${filter} AND ($cursorRoot=0 OR
+    SELECT * FROM ranked WHERE ${filter} AND ($taskId IS NULL OR root_ref IN (SELECT root_ref FROM members WHERE id=$taskId)) AND ($cursorRoot=0 OR
       ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
     ORDER BY ${ORDER},sort_at DESC,root_ref DESC LIMIT $limit
   ), page AS (SELECT p.*,COALESCE(p.result_id,(SELECT id FROM run WHERE task_ref=p.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1)) page_result_id FROM selected_page p), totals AS (SELECT ${TOTALS},${GROUP_TOTALS} FROM ranked), project_totals AS (
@@ -379,7 +391,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
-    'result_role',(SELECT role FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
+    'result_role',(SELECT role FROM run WHERE id=page_result_id),'result_head',(SELECT head_revision FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
     'check_status',(SELECT status FROM run_check WHERE run=page_result_id),
     'check_level',(SELECT outcome FROM action_ledger WHERE repo IS page.repo AND run_id=page_result_id AND action='checks used' ORDER BY id DESC LIMIT 1),
     'check_follows',(SELECT json_group_array(q.outcome||' '||COALESCE((SELECT substr(f.outcome,instr(f.outcome,':')+1) FROM action_ledger f WHERE f.repo IS page.repo AND f.run_id=page_result_id
@@ -392,7 +404,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
     'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),
     'question_task',(SELECT r.external_id FROM decision d JOIN run ON run.id=d.run JOIN task_ref r ON r.id=run.task_ref WHERE d.id=page.question_id)) FROM page`)
-        .all({ ...parameters(now, access, options, custody), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
+        .all({ ...parameters(now, access, options, custody), $taskId: taskId, $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
     const selected = rows.slice(1).map(row => JSON.parse(String(row['row_json'])));
     const page = selected.slice(0, limit), last = page.at(-1);
     const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 2, scope,
@@ -405,7 +417,11 @@ export function workIndexPage(store, now, access, options = {}) {
     };
     // A claimed row says the viewer's own name for their lead.
     const leadName = page.some(row => n(row, 'lead_claim') !== 0) && access.principal === 'operator' && access.viewer != null ? leadNameOf(store, access.viewer) : undefined;
-    return { items: page.map(row => itemOf(row, access.principal, probe, leadName)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
+    // A finished result reads the same readiness the task page does (task-status.ts): its requirements, acceptance,
+    // automatic review and, with checks Off, the release check that covers it.
+    const memo = new Map();
+    const readiness = (row, checks) => resultReadinessFacts(store, now, options.root, row, checks, memo);
+    return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
         groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
@@ -451,7 +467,30 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-function itemOf(row, principal, probe, leadName) {
+/** A ready result's requirements, acceptance and completion blockers from its saved records, as assignmentOf reads them. */
+function resultReadinessFacts(store, now, root, row, recorded, memo) {
+    const run = n(row, 'result_id'), repo = s(row, 'repo');
+    if (!run)
+        return { checks: recorded };
+    const report = s(row, 'result_role') === 'scout';
+    // No recorded check result (a build from before results were recorded, or none ran): read its saved receipt, as the page does.
+    const saved = root !== undefined && (recorded === null || recorded.status === 'not-run') ? assignmentChecksForRun(store, root, run, now) : null;
+    const listed = saved === null ? recorded : { status: saved.status, exitCode: saved.exitCode, head: s(row, 'result_head'),
+        ...(saved.level == null ? {} : { level: saved.level }), ...(saved.running == null ? {} : { running: saved.running }), ...(saved.batch == null ? {} : { batch: saved.batch }) };
+    const checks = listed?.level === 'off' && listed.status !== 'passed' && listed.status !== 'failed'
+        ? { ...listed, release: releaseCoverageOf(store, root, repo, s(row, 'result_head'), { memo }) } : listed;
+    const proof = store.proofVerdictFor(run), accepted = store.proofAcceptance(run) !== null;
+    const review = buildReviewOf(store, run);
+    const high = review === null || review.sentBackAs !== null || review.state !== 'reviewed' ? 0 : review.high.length;
+    const checkRequired = requiredCheckCommandFor(store, repo, String(row['id']), checks?.level) !== null;
+    const backing = checkBackingOf(checks);
+    const requirements = requirementsOf(proof?.matrix, backing);
+    const verdict = shownVerdictOf(proof?.verdict ?? null, { checkFailed: !report && checks?.status === 'failed', highFindings: high, reviewPending: review?.state === 'pending',
+        criteriaPassed: requirements === null || requirements.met === requirements.total });
+    const blockers = completionBlockersOf({ report, checks, checkRequired, matrix: proof?.matrix, verdict: proof?.verdict ?? null, accepted, high });
+    return { checks, requirements: unverifiedWhenRefuted(requirements, verdict), ...(accepted ? { accepted } : {}), ...(blockers.length === 0 ? {} : { blockers }) };
+}
+function itemOf(row, principal, probe, leadName, readiness) {
     const code = String(row['code']), id = String(row['id']);
     const custody = code === 'process-needs-attention' || (code === 'result-needs-attention' && n(row, 'custody_unresolved') === 1);
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
@@ -564,10 +603,13 @@ function itemOf(row, principal, probe, leadName) {
     const checkStatus = s(row, 'check_status'), verdict = s(row, 'proof_verdict');
     const finished = reading.stage === 'finished' || reading.stage === 'complete';
     const own = checkStatus === 'failed' || n(row, 'proof_failed_check') === 1 ? 'failed' : checkStatus === 'passed' || verdict === 'verified' ? 'passed' : null;
+    const listedChecks = !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']);
+    const ready = reading.stage === 'finished' && readiness !== undefined ? readiness(row, listedChecks) : null;
     const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }), ...(reading.wait === undefined ? {} : { wait: reading.wait }),
         ...(process === null ? {} : { needContext: { build: process.build } }),
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
-        checks: !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']),
+        checks: ready?.checks ?? listedChecks,
+        ...(ready === null ? {} : { requirements: ready.requirements ?? null, ...(ready.accepted ? { accepted: true } : {}), ...(ready.blockers === undefined ? {} : { blockers: ready.blockers }) }),
         completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, ''),
         ...(lead === null ? {} : { lead, ...(leadName === undefined ? {} : { leadName }) }) });
     label = shared.headline;

package/dist/workspace-ui.js

@@ -395,7 +395,8 @@ export function acceptWordsOf(facts) {
     const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
     const parts = [
         ...(facts.proof ? [] : ["nothing on record says what was met"]),
-        ...(facts.checks === "passed" ? [] : [facts.checks === "failed" ? "checks failed" : facts.checks === "off" ? "checks are off for this project"
+        // Checks deliberately Off are checked at release (task-status.ts): not a gap here.
+        ...(facts.checks === "passed" || facts.checks === "off" ? [] : [facts.checks === "failed" ? "checks failed"
                 : facts.checks === "running" ? "checks are still running" : facts.checks === "unavailable" ? "saved checks can't be read" : "checks didn't run"]),
         ...(facts.unmet > 0 ? [`${plural(facts.unmet, "requirement isn't", "requirements aren't")} met`] : []),
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.56",
+  "version": "0.9.58",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"

package/dist/session-http.d.ts

@@ -1,24 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { type SessionOperation, type SessionRequests, type SessionResponse } from './session-contract.js';
-import { type Admission } from './request-budget.js';
-export type SessionHttpActor = {
-    name: string;
-    generation: number;
-};
-export type SessionHttpExecute = <O extends SessionOperation>(actor: SessionHttpActor, operation: O, request: SessionRequests[O]) => Promise<SessionResponse>;
-export type SessionHttpOptions = {
-    /** Verify the bearer against the current account and installation-wide
-     * operator role. Derive both fields here, never from the JSON request.
-     * Host, TLS and other server admission checks remain with the caller. */
-    authenticate: (request: IncomingMessage) => SessionHttpActor | null | Promise<SessionHttpActor | null>;
-    /** The existing live owner's operation. Null means no owner is ready.
-     * The service rechecks actor generation and project access at execution. */
-    execute: SessionHttpExecute | null;
-    /** The bearer request's budget by source (request-budget.ts): charged once, before the credential is checked or a body read. */
-    admit?: (request: IncomingMessage) => Admission;
-    /** Account admission after successful authentication, before any body read or owner call. */
-    admitAuthenticated?: (request: IncomingMessage, actor: SessionHttpActor) => Admission;
-};
-/** Handle this API family before the browser's form parser or login redirects.
- * This adapter dispatches at most once. It owns no catalog, database or provider. */
-export declare function handleSessionHttp(request: IncomingMessage, response: ServerResponse, options: SessionHttpOptions): Promise<boolean>;

package/dist/session-http.js

@@ -1,170 +0,0 @@
-import { adapterPolicy } from "./server/route-policy.js";
-import { SESSION_REQUEST_BYTES, SESSION_RESPONSE_BYTES, isSessionResponse, sessionDescriptor, validateSessionRequest, } from './session-contract.js';
-import { limitWords } from './request-budget.js';
-function readBody(request) {
-    return new Promise(resolve => {
-        let size = 0;
-        let chunks = [];
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            chunks = [];
-            resolve(result);
-        };
-        const cleanup = () => {
-            request.off('data', onData);
-            request.off('end', onEnd);
-            request.off('aborted', onAborted);
-            request.off('error', onError);
-            request.off('close', onClose);
-        };
-        const onData = (chunk) => {
-            // After rejecting an oversized request, drain without retaining it.
-            if (settled)
-                return;
-            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            size += bytes.length;
-            if (size > SESSION_REQUEST_BYTES)
-                finish({ ok: false, status: 413, reason: 'request-too-large', message: 'The session request is too large.' });
-            else
-                chunks.push(bytes);
-        };
-        const onEnd = () => {
-            cleanup();
-            if (settled)
-                return;
-            try {
-                const value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
-                finish({ ok: true, value });
-            }
-            catch {
-                finish({ ok: false, status: 400, reason: 'invalid-json', message: 'Send a valid UTF-8 JSON request.' });
-            }
-        };
-        const onAborted = () => {
-            finish({ ok: false, status: 400, reason: 'incomplete-request', message: 'The session request did not finish arriving.' });
-        };
-        const onError = () => { onAborted(); cleanup(); };
-        const onClose = () => { onAborted(); cleanup(); };
-        request.on('data', onData);
-        request.once('end', onEnd);
-        request.once('aborted', onAborted);
-        request.once('error', onError);
-        request.once('close', onClose);
-        if (request.aborted)
-            onAborted();
-    });
-}
-/** Handle this API family before the browser's form parser or login redirects.
- * This adapter dispatches at most once. It owns no catalog, database or provider. */
-export async function handleSessionHttp(request, response, options) {
-    const path = (request.url ?? '').split('?')[0] ?? '';
-    if (path !== '/api/sessions' && !path.startsWith('/api/sessions/'))
-        return false;
-    const match = /^\/api\/sessions\/([a-z]+)$/.exec(request.url ?? '');
-    const spec = match?.[1] === undefined ? undefined : sessionDescriptor(match[1]);
-    const operation = spec?.operation;
-    const write = (status, body, notSent = false) => {
-        if (response.destroyed || response.writableEnded)
-            return;
-        response.statusCode = status;
-        response.setHeader('content-type', 'application/json; charset=utf-8');
-        response.setHeader('content-length', Buffer.byteLength(body));
-        response.setHeader('cache-control', 'no-store');
-        response.setHeader('x-content-type-options', 'nosniff');
-        if (notSent)
-            response.setHeader('x-standing-orders-session-delivery', 'not-sent');
-        else
-            response.removeHeader('x-standing-orders-session-delivery');
-        response.end(body);
-    };
-    const reject = (status, reason, message) => {
-        // No owner call has occurred. This marker is never inferred from an
-        // exception, a lost response, or a response too large to deliver.
-        const reply = { version: 1, ...(operation === undefined ? {} : { operation }), ok: false,
-            status: 'rejected', delivery: 'not-sent', retry: spec?.mutation === false ? 'safe-read' : 'never', reason, message, nextActions: [] };
-        write(status, JSON.stringify(reply), true);
-        request.resume();
-        return true;
-    };
-    if (!spec || operation === undefined)
-        return reject(404, 'unsupported-operation', 'This session operation is not supported.');
-    if (request.method !== 'POST') {
-        response.setHeader('allow', 'POST');
-        return reject(405, 'method-not-allowed', 'Session operations require POST.');
-    }
-    if (request.headers.origin !== undefined)
-        return reject(403, 'browser-request', 'Use the authenticated session client for this operation.');
-    const authorizationCount = request.rawHeaders.filter((_, index) => index % 2 === 0 && request.rawHeaders[index]?.toLowerCase() === 'authorization').length;
-    if (authorizationCount !== 1 || !/^Bearer (.+):(.+)$/.test(request.headers.authorization ?? '')) {
-        return reject(401, 'unauthenticated', 'Current operator bearer credentials are required.');
-    }
-    const refuseAdmission = (admitted) => {
-        if (admitted.ok)
-            return false;
-        if (admitted.status === 503)
-            return reject(503, 'limits-unavailable', 'Request limits could not be checked; nothing ran. Try again shortly.');
-        response.setHeader('retry-after', String(admitted.retryAfter));
-        return reject(429, 'rate-limited', limitWords(admitted.limit, admitted.retryAfter));
-    };
-    if (options.admit && refuseAdmission(options.admit(request)))
-        return true;
-    let actor;
-    try {
-        actor = await options.authenticate(request);
-    }
-    catch {
-        return reject(503, 'authentication-unavailable', 'Operator access could not be checked. Try again after the service is ready.');
-    }
-    if (actor === null || typeof actor.name !== 'string' || !actor.name.trim() || !Number.isSafeInteger(actor.generation) || actor.generation < 1) {
-        return reject(401, 'unauthenticated', 'Current operator bearer credentials are required.');
-    }
-    if (options.admitAuthenticated && refuseAdmission(options.admitAuthenticated(request, actor)))
-        return true;
-    if (!adapterPolicy({ caller: "bearer", capability: "act" }, spec.mutation ? "act" : "read").ok)
-        return reject(403, "forbidden", "Current operator access is required.");
-    const media = request.headers['content-type']?.split(';')[0]?.trim().toLowerCase();
-    if (media !== 'application/json')
-        return reject(415, 'unsupported-media-type', 'Send the session request as application/json.');
-    const length = request.headers['content-length'];
-    if (length !== undefined && Number(length) > SESSION_REQUEST_BYTES)
-        return reject(413, 'request-too-large', 'The session request is too large.');
-    if (options.execute === null)
-        return reject(503, 'session-unavailable', 'The session owner is not ready.');
-    const body = await readBody(request);
-    if (!body.ok)
-        return reject(body.status, body.reason, body.message);
-    const validated = validateSessionRequest(operation, body.value);
-    if (!validated.ok)
-        return reject(400, 'invalid-request', validated.message);
-    if (request.aborted || response.destroyed)
-        return true;
-    const uncertain = (reason, message) => {
-        const sessionId = 'sessionId' in validated.request ? validated.request.sessionId : undefined;
-        return { version: 1, operation, ok: false, status: 'uncertain', delivery: 'unknown', retry: 'inspect-first', reason, message,
-            nextActions: [{ operation: sessionId ? 'show' : 'list', label: sessionId ? 'Inspect session' : 'Inspect saved sessions', ...(sessionId ? { sessionId } : {}) }] };
-    };
-    let reply;
-    let encoded;
-    let status;
-    try {
-        reply = await options.execute(actor, operation, validated.request);
-        if (!isSessionResponse(reply, operation))
-            throw new Error('Invalid owner response');
-        encoded = JSON.stringify(reply);
-        if (Buffer.byteLength(encoded) > SESSION_RESPONSE_BYTES) {
-            reply = uncertain('response-too-large', 'The owner response is too large to deliver. Inspect saved activity before continuing; this request was not retried.');
-            encoded = JSON.stringify(reply);
-        }
-        status = reply.status === 'rejected' ? 409 : reply.status === 'uncertain' ? 502 : reply.status === 'pending' ? 202 : 200;
-    }
-    catch {
-        reply = uncertain('unconfirmed-response', 'The owner response could not be confirmed. Inspect saved activity before continuing; this request was not retried.');
-        encoded = JSON.stringify(reply);
-        status = 502;
-    }
-    write(status, encoded);
-    return true;
-}

package/dist/session-server.d.ts

@@ -1,17 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Store } from './store.js';
-import type { CodingWorkspace } from './coding-workspace.js';
-import { type SessionHttpActor } from './session-http.js';
-import type { Admission } from './request-budget.js';
-/** Bind the transport to createDecisionServer's existing catalog owner and
- * live project admission. No cookie, coordinator token or caller-supplied actor
- * can acquire installation-wide native coding authority through this adapter. */
-export declare function createSessionEndpoint(options: {
-    store: Store;
-    workspace: CodingWorkspace | null;
-    projects: () => readonly string[];
-    projectAllowed: (repo: string) => boolean;
-    /** The request's source budget (request-budget.ts), charged once before the password is checked. */
-    admit?: (request: IncomingMessage) => Admission;
-    admitAuthenticated?: (request: IncomingMessage, actor: SessionHttpActor) => Admission;
-}): (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;

package/dist/session-server.js

@@ -1,39 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { authenticateAccount } from './scope.js';
-import { handleSessionHttp } from './session-http.js';
-import { SessionService } from './session-service.js';
-/** Bind the transport to createDecisionServer's existing catalog owner and
- * live project admission. No cookie, coordinator token or caller-supplied actor
- * can acquire installation-wide native coding authority through this adapter. */
-export function createSessionEndpoint(options) {
-    const { store } = options;
-    const authorized = (actor, repo) => {
-        const account = store.accountOf(actor.name);
-        return account !== null && account.revokedAt === null && account.generation === actor.generation && store.isInstanceOperator(actor.name)
-            && (repo === undefined || (options.projectAllowed(repo) && options.projects().includes(repo)));
-    };
-    const service = options.workspace === null || store.isDemo() ? null : new SessionService({ workspace: options.workspace, authorized,
-        project: (actor, input) => {
-            const path = realpathSync(input);
-            if (!authorized(actor, path) || !options.projects().includes(path))
-                throw Error('Choose a project already admitted to this installation.');
-            return path;
-        },
-    });
-    return (request, response) => handleSessionHttp(request, response, {
-        ...(options.admit === undefined ? {} : { admit: options.admit }),
-        ...(options.admitAuthenticated === undefined ? {} : { admitAuthenticated: options.admitAuthenticated }),
-        authenticate: request => {
-            const bearer = /^Bearer (.+):(.+)$/.exec(request.headers.authorization ?? '');
-            if (!bearer)
-                return null;
-            const name = bearer[1];
-            const authentication = authenticateAccount(store, name, bearer[2]);
-            if (!authentication.ok)
-                return null;
-            const actor = { name, generation: authentication.generation };
-            return authorized(actor) ? actor : null;
-        },
-        execute: service === null ? null : (actor, operation, request) => service.execute(actor, operation, request),
-    });
-}