wicked-crew 0.8.0 → 0.8.2

package/dist/api/routes.js

@@ -19,10 +19,11 @@ import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
 import { callEstateTool, EstateMcpError } from '../core/estate-mcp-client.js';
 import { SeatHealthTracker } from './seat-health.js';
 import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
-import { chatSeatAdmission, noCredentialCause } from './seat-standing.js';
+import { chatSeatAdmission } from './seat-standing.js';
 import { rosterWithStandingFactory } from './roster-standing.js';
 import { ChatTurnIndex } from './chat-turns.js';
-import { ChatScopeIndex, chatScopeDeps, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
+import { ChatScopeIndex, chatScopeDeps, chatScopeStatement, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
+import { AskPathIndex, answerStep } from './ask-paths.js';
 import { allowedRootsFor, isInsideRoot, openWithSystemDefault } from './open-path.js';
 import { InvalidDiffBaseError, MERGE_BASE_LITERAL, NotARegularFileError, UnresolvableDiffBaseError, branchDiff, isGitStopped, isPlainRef, readFileCapped, worktreeDiff, } from './run-files.js';
 import { DocRunIndex } from '../interactive/doc-run-index.js';
@@ -538,6 +539,8 @@ export const ChatOpenSchema = z.object({
     /** The scope the caller NAMES (studio#323 R4) — omitted ⇒ the legacy inference. Shape rules
      *  (which kinds need / refuse `projectId` / `repoRefs`) are the resolver's (`chat-scope.ts`). */
     scopeKind: z.enum(['system', 'everything', 'project', 'repo', 'repos', 'none']).optional(),
+    /** (ASK-C1) The seat the operator chose as the primary agent; omitted ⇒ the engine picks at random. */
+    primary: z.string().min(1).optional(),
 }).strict();
 /**
  * The `singleSeat` disclosure (crew#641, hole closed in crew#650) — built in ONE place so the 201
@@ -606,7 +609,7 @@ at) {
         refusalsKnown: known,
         message: 
         // "warm" on a turn: the claim is about the roster as it stands, not about how it got there.
-        `This chat has one ${at === 'open' ? 'seat' : 'warm seat'} (${warmed}); it cannot disagree with itself. ` +
+        `This chat has one eligible seat (${warmed}); it cannot disagree with itself. ` +
             refusalClause +
             'The single-seat root cause is tracked as wicked-core#563; this chat makes it visible.',
     };
@@ -641,6 +644,7 @@ runtime = {}) {
     const guidanceIndex = runtime.guidanceIndex ?? new GuidanceIndex();
     const chatScopes = runtime.chatScopes ?? new ChatScopeIndex();
     const chatTurns = runtime.chatTurns ?? new ChatTurnIndex();
+    const askPaths = runtime.askPaths ?? new AskPathIndex();
     const chatTranscripts = runtime.chatTranscripts;
     const deliveryIndex = runtime.deliveryIndex ?? new DeliveryIndex();
     // Wave 6: the doc↔run binding and the registered test sets — `createServer` injects the real
@@ -962,6 +966,10 @@ runtime = {}) {
                 : { deliverGate: false, revisesPr: false, chatIdOnLaunch: false, seatChipOnCreate: false }),
             // C1: `AgentSession.chat_id` is served from the daemon's own launch index, whatever the engine.
             runChatId: true,
+            // ASK-C1 (DES-ASK-TEAM-CHAT-001 §5.1): an ask starts a path — the whole contract is the
+            // pinned core-ts floor the adapter reports; an older studio reads ABSENT as "every helper
+            // answers", a newer one renders the one PA voice.
+            askPath: typeof adapter.engineCapabilities === 'function' ? adapter.engineCapabilities().askPath : false,
             // WT-W1: repo-bound launches mint an evidence root only on an addon that takes the field.
             walkthroughRoots: typeof adapter.evidenceRootsSupported === 'function' ? adapter.evidenceRootsSupported() : false,
         };
@@ -1754,7 +1762,8 @@ runtime = {}) {
             // always has at least one warm seat (`crew-api-types` ChatOpenResponse), so 0 is not a value
             // `chat_seat_count` can honestly hold.
             if (b.chatId !== undefined) {
-                const promotedFrom = await adapter.chatSeats(b.chatId).catch(() => null);
+                // ASK-C1: a chat's seats are its eligible roster (no warm pool to ask the engine about).
+                const promotedFrom = askPaths.get(b.chatId)?.eligible ?? null;
                 const scope = chatScopes.engineOf(b.chatId);
                 if (promotedFrom !== null && promotedFrom.length > 0 && scope !== undefined) {
                     chatSeatCount = promotedFrom.length;
@@ -2355,9 +2364,11 @@ runtime = {}) {
         if (token === null) {
             const state = chatScopes.stateOf(chatId);
             return reply.code(409).send({
-                error: state === 'closing'
-                    ? `chat ${chatId} is closing; wait for its chatClosed (a few seconds at most) before reusing the id, or omit chatId to mint a fresh one`
-                    : `chat ${chatId} is already open on this daemon; DELETE /chats/${chatId} first, or omit chatId to mint a fresh one`,
+                error: state === 'held'
+                    ? `chat ${chatId} is closing (its DELETE is still settling); retry in a moment, or omit chatId to mint a fresh one`
+                    : state === 'closing'
+                        ? `chat ${chatId} is closing; wait for its chatClosed (a few seconds at most) before reusing the id, or omit chatId to mint a fresh one`
+                        : `chat ${chatId} is already open on this daemon; DELETE /chats/${chatId} first, or omit chatId to mint a fresh one`,
             });
         }
         // DC-S7: the in-force rules the statement lists; recorded as "told" only once the open succeeds.
@@ -2391,9 +2402,17 @@ runtime = {}) {
                 // DC-S7: the seats learn the project's in-force rules from the statement (cap 20, severity
                 // order); the service remembers what they were told so a later landing can be prefaced.
                 inForceAtOpen = (await considerations.inForceFor(scope.projectId ?? null)).rules;
+                // The scratch root is shared by id: an open whose reservation a DELETE cancelled while it
+                // was resolving must not write (or later remove) the root a newer open now holds
+                // (codex on #808 r3, 3).
+                if (!chatScopes.owns(chatId, token)) {
+                    return reply.code(409).send({ error: `chat ${chatId} was closed while it was being opened; open it again` });
+                }
                 prepareChatScratch(chatId, scope, inForceAtOpen);
             }
             catch (err) {
+                // The helper removes only what it created itself (a pre-existing root is preserved) —
+                // nothing more is removed here (codex on #808 r4, 3).
                 chatScopes.release(chatId, token);
                 return reply
                     .code(500)
@@ -2412,135 +2431,80 @@ runtime = {}) {
             // and `system` (studio#323 R4: the platform itself, no repository) read none, so they take the
             // unscoped admission and open on an engine that predates chat scope.
             const scoped = scope.kind !== 'none' && scope.kind !== 'system';
+            // ASK-C2: a single-repo ask launches BOUND (the run holds the repository read-only), so every
+            // seat in standing is eligible; a wider repository scope keeps the structural rule.
+            const admissionKind = scope.kind === 'repos' && scope.repos.length === 1 ? 'path-bound' : 'path';
             const refused = [];
             // The standing roster, read ONCE: the default admission below and the engine-drop
             // attribution after `chatOpen` both consult it (F-A45-011).
             const standing = rosterWithStanding();
-            const standingOf = (key) => standing.find((s) => String(s.key) === key);
-            let clis;
-            if (b.clis !== undefined) {
-                clis = b.clis;
-            }
-            else {
-                clis = [];
-                for (const seat of standing) {
-                    const key = String(seat.key);
-                    const admission = chatSeatAdmission(seat, seat.auth ?? 'unknown', scoped);
-                    if (admission.ok)
-                        clis.push(key);
-                    else
-                        refused.push({ cliKey: key, reason: admission.reason, source: admission.source });
+            // ASK-C1: admission applies to the DEFAULT roster and to seats NAMED in `clis` alike — the
+            // engine no longer refuses a seat at open (nothing is warmed), so this is the only gate
+            // between a request and the eligible roster the path launches with. The sign-in standing
+            // is part of it for a named seat too: the launch hands the engine the same standing roster,
+            // which benches a signed-out seat (codex on #808 r2, 5) — admitting it here would only move
+            // the refusal to a launch that cannot start. An unknown key is refused by name.
+            const candidates = b.clis !== undefined
+                ? b.clis.map((key) => standing.find((s) => String(s.key) === key) ?? { key })
+                : standing;
+            const clis = [];
+            for (const seat of candidates) {
+                const key = String(seat.key);
+                if (!('auth' in seat)) {
+                    refused.push({ cliKey: key, reason: `seat '${key}' is not in the roster`, source: 'scope' });
+                    continue;
                 }
+                const admission = chatSeatAdmission(seat, seat.auth ?? 'unknown', scoped, admissionKind);
+                if (admission.ok)
+                    clis.push(key);
+                else
+                    refused.push({ cliKey: key, reason: admission.reason, source: admission.source });
             }
             if (clis.length === 0) {
-                chatScopes.release(chatId, token);
-                removeChatScratch(scope.cwd, chatScopes.base);
+                if (chatScopes.release(chatId, token))
+                    removeChatScratch(scope.cwd, chatScopes.base);
                 return reply.code(409).send({
-                    error: (scoped
-                        ? 'no seat in the roster can be held to a scoped chat (an ACP adapter admitted to input ' +
-                            'governance, or `os_sandbox = true` on its [cli.acp] record) and take a turn; open the ' +
-                            'chat unscoped, sign a seat in, or name seats with `clis`'
-                        : 'no seat in the roster can take a turn (every seat is signed out); sign a seat in from ' +
-                            'the System page, or name seats with `clis`') + ' — see refused',
+                    error: (scoped && admissionKind === 'path'
+                        ? 'no seat in standing can be held to an ask that reads several repositories (or a project) ' +
+                            'the run cannot bind; scope the ask to one repository, sign a seat in, or open it unscoped'
+                        : 'no seat in the roster can take a turn (every seat is signed out or disabled); sign a seat ' +
+                            'in from the System page, or name seats with `clis`') + ' — see refused',
                     refused,
                 });
             }
             try {
-                const seats = await adapter.chatOpen(chatId, clis, engine.cwd, {
-                    codeGraphDb: engine.codeGraphDb,
-                    readRoots: engine.readRoots,
-                });
-                // A REQUESTED seat the engine refused joins the same list, with the engine's reason.
-                for (const s of seats) {
-                    if (!s.ok)
-                        refused.push({ cliKey: s.cliKey, reason: s.error ?? 'the engine refused the seat', source: 'engine' });
-                }
-                // F-A45-011 (F-2R2-007 still open): a seat the engine DROPPED — absent from `seats`
-                // altogether, neither ok nor refused — used to vanish without a trace (the fresh rig's pi:
-                // default chips claude·pi·opencode, 201 `seats:[claude, opencode]`, `refused: []`). It was
-                // taken out by the council-bench / dispatch-timeout path, not by admission, so admission's
-                // list never named it. Every requested-or-defaulted seat that is not in `seats` is named
-                // here with the most specific cause the daemon knows: its own "no credential" report
-                // (`auth`), else the dispatch budget (`budget`). (R5b: crew keeps no council bench of its
-                // own any more — the engine benches per run and says so in `unitDistributed.degradedReason`.)
-                for (const key of clis) {
-                    if (seats.some((s) => s.cliKey === key) || refused.some((r) => r.cliKey === key))
-                        continue;
-                    const st = standingOf(key);
-                    const authFailure = seatHealth.authFailureFor(key);
-                    if (authFailure !== null || st?.auth === 'signed_out') {
-                        refused.push({
-                            cliKey: key,
-                            reason: authFailure !== null
-                                ? `not seated — the seat itself reported no credential (${noCredentialCause(authFailure)}); sign it in from the System page`
-                                : 'not seated — signed out; sign it in from the System page',
-                            source: 'auth',
-                        });
-                    }
-                    else {
-                        refused.push({
-                            cliKey: key,
-                            reason: 'not seated — the engine did not warm it within its dispatch budget (the seat timed out or ' +
-                                'was dropped at dispatch); check GET /roster and try again, or name seats with `clis`',
-                            source: 'budget',
-                        });
-                    }
-                }
-                // Nothing warmed (independent review, W1): the engine holds no pool row and has dropped the
-                // scope itself (no `chatClosed` will come) — report the PER-SEAT reasons, never an
-                // engine-version guess; the root goes, the id is free again.
-                if (seats.every((s) => !s.ok)) {
-                    chatScopes.release(chatId, token);
-                    removeChatScratch(scope.cwd, chatScopes.base);
-                    return reply.code(409).send({
-                        error: `chat ${chatId}: no seat warmed (${seats.length} failed) — see seats`,
-                        seats,
+                // DES-ASK-TEAM-CHAT-001 §5.1 (ASK-C1): an open resolves the scope and ELIGIBILITY and warms
+                // nothing — the chat is a path its first message launches, and the engine picks the PA
+                // then (`path.started.selection`). Crew owns eligibility; the engine owns the pick.
+                if (b.primary !== undefined && !clis.includes(b.primary)) {
+                    if (chatScopes.release(chatId, token))
+                        removeChatScratch(scope.cwd, chatScopes.base);
+                    return reply.code(400).send({
+                        error: `primary names a seat that is not eligible for this chat: ${b.primary}` +
+                            ` (eligible: ${clis.join(', ')})`,
                         refused,
                     });
                 }
-                // Honest scope (Copilot, #518): a SCOPED chat is a promise — the roots are read-only, the
-                // graph is attached, the seats see nothing else — and only an engine that CONFIRMS it
-                // recorded the scope (its `chatList` row carries the scope fields) can keep it. An engine
-                // predating chat scope (wicked-core#410) dropped `scopeJson` and runs the seats unbounded in
-                // the scratch root; an engine that cannot be asked has confirmed nothing. Neither may hold a
-                // scoped chat: it is closed again, its root removed, and the caller gets a 501 naming the
-                // remedy — never a chat whose statement promises what its seats do not enforce. An UNSCOPED
-                // chat (`kind: 'none'`) promises nothing beyond its scratch root and proceeds.
-                const applied = await adapter.chatScopeApplied(chatId);
-                if (applied !== true && scoped) {
-                    await adapter.chatClose(chatId).catch(() => undefined);
-                    // The engine's `chatClosed` for this id is still on its way: park, do not release
-                    // (Copilot, #518), so a reuse cannot have its root removed by the late event.
-                    chatScopes.abortToClosing(chatId, token);
-                    removeChatScratch(scope.cwd, chatScopes.base);
-                    if (applied === false) {
-                        // A row WITHOUT the scope fields: the engine predates chat scope (wicked-core#410).
-                        return reply.code(501).send({
-                            error: 'the installed wicked-core-ts predates chat scope (wicked-core#410): it cannot ground ' +
-                                'a scoped chat or hold its read roots read-only — upgrade the engine, or open the ' +
-                                'chat without projectId/repoRefs.',
-                            seats,
-                        });
-                    }
-                    // NO row although a seat reported warm: nothing is actually held for this chat.
-                    return reply.code(409).send({
-                        error: `chat ${chatId}: a seat reported warm but the engine holds no row for the chat — ` +
-                            'nothing warmed; open it again (see seats)',
-                        seats,
-                    });
-                }
-                // File the chat into its project WHILE the id is still reserved (Copilot, #518): publishing
-                // first would let a concurrent DELETE / engine `chatClosed` land during this await and leave
-                // a 201 with a stale scope and a membership attached to a closed chat.
+                const seats = clis.map((cliKey) => ({
+                    cliKey,
+                    ok: true,
+                }));
                 let projectAttachError;
                 let attachedMemberId;
+                // Whether THIS open wrote the chat → project index entry (so its cleanup removes only its
+                // own — a newer open of the id may hold one; codex on #808 r4, 2).
+                let indexedHere = false;
                 if (b.projectId !== undefined) {
                     try {
                         const { member, created } = await adapter.projectMemberAttach(b.projectId, 'crew.chat', chatId);
                         if (created)
                             attachedMemberId = member.id;
-                        if (created) {
+                        // The attach awaited: publish the membership only while this open still holds the id —
+                        // a cancelled open's filing would overwrite the replacement's (the failed `set` below
+                        // detaches what was created).
+                        if (created && chatScopes.owns(chatId, token)) {
                             projects.index.set(chatId, b.projectId);
+                            indexedHere = true;
                             projects.bus?.emit(MEMBERSHIP_ATTACHED, { project_id: b.projectId, member: { kind: 'crew.chat', ref: chatId }, actor: actorOf(req).id }, membershipAttachedKey(b.projectId, 'crew.chat', chatId, member.attached_at));
                         }
                     }
@@ -2552,18 +2516,25 @@ runtime = {}) {
                 }
                 if (!chatScopes.set(chatId, scope, token, refused, engine)) {
                     // The reservation was cancelled while the open was in flight — an engine `chatClosed` or a
-                    // `DELETE` for this id (Copilot, #518). Nothing was recorded; tear the chat down (engine
-                    // session, scratch root, and the filing just made) instead of returning a stale 201.
-                    await adapter.chatClose(chatId).catch(() => undefined);
-                    removeChatScratch(scope.cwd, chatScopes.base);
+                    // `DELETE` for this id (Copilot, #518). Nothing was recorded; tear the chat down (scratch
+                    // root and the filing just made) instead of returning a stale 201. No path record exists
+                    // yet (it is published below, after the scope is committed), and the scratch root is this
+                    // open's only while no newer open holds the id — a replacement opened meanwhile shares the
+                    // directory (codex on #808 r2, 3).
+                    if (!chatScopes.has(chatId))
+                        removeChatScratch(scope.cwd, chatScopes.base);
                     if (b.projectId !== undefined && attachedMemberId !== undefined) {
                         await adapter.projectMemberDetach(b.projectId, attachedMemberId).catch(() => false);
-                        projects.index.delete(chatId);
+                        if (indexedHere)
+                            projects.index.delete(chatId);
                     }
                     return reply.code(409).send({
                         error: `chat ${chatId} was closed while it was being opened; open it again`,
                     });
                 }
+                // ASK-C1: the path record — published only now, with the scope committed, so a message
+                // cannot launch against a scope that is still being filed (codex on #808 r2, 4).
+                askPaths.open(chatId, clis, b.primary);
                 // Register roots for path rewriting (crew#618): absolute host paths in seat replies are
                 // rewritten to repo-relative form before being stored in the transcript.
                 if (chatTranscripts !== undefined && scope.repos.length > 0) {
@@ -2601,9 +2572,10 @@ runtime = {}) {
             }
             catch (err) {
                 // Nothing warmed: the scratch root prepared above must not linger — removed under the SAME
-                // base the resolver created it in (Copilot, #518), fail-closed like every removal.
-                chatScopes.release(chatId, token);
-                removeChatScratch(scope.cwd, chatScopes.base);
+                // base the resolver created it in (Copilot, #518), fail-closed like every removal; only
+                // while the root is still this open's (codex on #808 r3, 3).
+                if (chatScopes.release(chatId, token))
+                    removeChatScratch(scope.cwd, chatScopes.base);
                 return reply.code(400).send({ error: message(err) });
             }
         }
@@ -2643,73 +2615,170 @@ runtime = {}) {
         if (!parsed.success) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
-        // DES-L5 §5-c (F-E2E-041): the audience is decided HERE — the named targets, else the engine's
-        // warm seats — so the turn can be opened BEFORE the engine call, in the same tick as the
-        // predicate below: two racing sends can no longer both pass `inFlight` during the await, and a
-        // `chatDelta` that lands before `chatSend` resolves is already stamped with its `turn_id`.
-        // crew#641 (review): the ROSTER and the AUDIENCE are different things and only one of them can
-        // answer "can this chat disagree with itself". Resolved ONCE here: `audience` is who this turn
-        // goes to (the named targets, else everyone warm), `warmRoster` is who is warm at all. A
-        // targeted send to one seat of a two-seat chat is not a degraded chat.
-        const warmRoster = await adapter.chatSeats(id);
-        const audience = parsed.data.targets ?? warmRoster;
-        if (audience.length === 0) {
-            return reply.code(409).send({ error: `chat '${id}' has no warm seats — open it first` });
-        }
-        const inFlight = chatTurns.inFlight(id, audience);
-        if (inFlight !== null) {
-            return reply.code(409).send(turnInFlightBody(id, inFlight, 'Nothing was sent.'));
+        // DES-ASK-TEAM-CHAT-001 §3, §5.1 (ASK-C1): the first message of a chat LAUNCHES one team path
+        // — a user-composed plan of one `understand` step with its gate raised to the turn gate, one
+        // reviewer asked for, the eligible roster as `clis`, the operator's choice as `primary`; every
+        // later message CONTINUES the same path: `propose_plan(answer-N)` then `confirm_gate(Approve)`
+        // at the turn gate the previous answer paused on. Nothing is fanned out: the PA is the one
+        // voice, helpers talk to the PA, the reviewer raises quiet findings — all on the bus.
+        const path = askPaths.get(id);
+        if (path === undefined) {
+            return reply.code(409).send({ error: `chat '${id}' is not open on this daemon — open it first (POST /chats)` });
+        }
+        if (path.eligible.length === 0) {
+            return reply.code(409).send({ error: `chat '${id}' has no eligible seat — sign a seat in and re-seat it (POST /chats/:id/seats)` });
+        }
+        const text = parsed.data.text;
+        const scope = chatScopes.get(id);
+        // A repo-bound path: exactly one repo in scope grounds the run (`repoRef`) and makes it
+        // deliverable; a project or a multi-repo scope binds the project graph only (§5.1 Grounding).
+        const repoRef = scope !== undefined && scope.kind === 'repos' && scope.repos.length === 1 ? scope.repos[0].id : undefined;
+        const projectId = scope?.projectId;
+        const voice = path.pa !== null ? [path.pa] : [];
+        // The turn is reserved for the voice — or, for a random pick (no PA yet), for the whole
+        // eligible roster: the relay narrows it to the PA when `path.started` names one (ASK-C2), so
+        // the PA's frames are stamped with this turn and a second message is refused meanwhile.
+        const audience = voice.length > 0 ? voice : path.eligible;
+        // crew#641/#650 re-stated for a path: ONE eligible seat means no distinct reviewer and no
+        // helper — said on every turn (the engine's `member.joined{seat:null}` says it on the bus).
+        const singleSeat202 = path.eligible.length === 1
+            ? { singleSeat: singleSeatDisclosure(path.eligible[0], chatScopes.refusedOf(id), 'turn') }
+            : {};
+        // F6: a message while the PA is still answering — the previous turn has no reply yet (the
+        // run may already wait at its gate while the relay's reply is a bus poll away; codex on #810
+        // r1, 3) — is refused: nothing is sent, the composer keeps the draft.
+        const pendingTurn = chatTurns.inFlight(id);
+        if (pendingTurn !== null) {
+            return reply.code(409).send(turnInFlightBody(id, pendingTurn, 'Nothing was sent.'));
+        }
+        // One message at a time per chat, on this daemon: the reservation covers the launch, and a
+        // continuation's status read → proposal → approval (two continuations racing would both
+        // read `awaiting_human` and both hold an edit; the second's approval then fails).
+        const lease = askPaths.reserve(id);
+        if (lease === null) {
+            return reply.code(409).send({
+                code: 'turn_in_flight',
+                error: `${path.pa ?? 'the primary agent'} is still answering the previous message in this chat — wait for the reply. Nothing was sent.`,
+                chatId: id,
+                ...(path.runId !== undefined ? { runId: path.runId } : {}),
+            });
         }
-        // Sync, same tick as `inFlight`: the window is closed before anything yields.
-        const turn = chatTurns.begin(id, audience, parsed.data.text);
-        try {
-            // DC-S7: a rule remembered since the seats last heard from crew rides this send as a
-            // crew-authored preface — disclosed below as a `system` transcript record; the `user` record
-            // keeps the operator's own words.
-            const preface = await considerations.prefaceForSend(id);
-            const seats = await adapter.chatSend(id, preface !== null ? `${preface}\n\n${parsed.data.text}` : parsed.data.text, parsed.data.targets);
-            if (turn !== null) {
-                // The engine's answer is the truth: the reserved audience is squared with the seats it
-                // reached, and the operator's message joins the transcript with exactly those seats.
-                chatTurns.reconcile(id, turn.turnId, seats);
-                chatTranscripts?.appendUser(id, turn.turnId, parsed.data.text, seats);
-                // DC-S4b: who said it, to whom — the recorder matches the seats' quotes against THIS message.
-                chatRecorder?.noteSend(id, turn.turnId, actorOf(req), parsed.data.text, seats);
+        const turn = chatTurns.begin(id, audience, text);
+        const turnId = turn?.turnId ?? randomUUID();
+        // What an ACCEPTED message records — the engine has it, so a persistence failure here is
+        // logged, never a retraction of a turn that is already being answered (codex on #808 r2, 9).
+        const persistAccepted = (preface, after) => {
+            try {
+                after();
                 if (preface !== null)
-                    chatTranscripts?.appendSystem(id, turn.turnId, preface);
+                    chatTranscripts?.appendSystem(id, turnId, preface);
+                chatTranscripts?.appendUser(id, turnId, text, voice);
+                // The recorder's audience is the turn's AS THE TURN INDEX HOLDS IT NOW: the eligible roster
+                // for a random pick, or the PA the relay narrowed it to during the engine awaits above
+                // (`path.started` / `path.repicked` may land before this record exists — ASK-C2, codex on
+                // #810 r2, 3).
+                const settled = chatTurns.turnsOf(id).find((t) => t.turnId === turnId)?.seats;
+                const pa = askPaths.get(id)?.pa ?? null;
+                chatRecorder?.noteSend(id, turnId, actorOf(req), text, 
+                // The turn index's voice; a turn already ended by an early reply names none, so the
+                // path's PA stands in; the reserved audience last.
+                settled !== undefined && settled.length > 0 ? settled : pa !== null ? [pa] : audience);
             }
-            // crew#641: re-state single-seat degradation on every turn so it is visible in the transcript.
-            // Decided from `warmRoster` — the seats that are WARM — never from `seats`, which is only the
-            // seats this turn reached: a targeted send to one seat of a two-seat chat would otherwise
-            // announce a degradation that does not exist, and a false "you are degraded" sends an operator
-            // after a problem they do not have.
-            // crew#650: `refusedOf` is `undefined` for a chat THIS daemon did not open (a restart drops
-            // the index) — that is "the refusals are unknown", not "the chat gained a seat". The
-            // disclosure is decided by the warm roster alone, and the `undefined` is handed STRAIGHT to
-            // the builder (never `?? []`, review of #658): only it may decide what an unknown record is
-            // allowed to claim.
-            const singleSeat202 = warmRoster.length === 1 ? singleSeatDisclosure(warmRoster[0], chatScopes.refusedOf(id), 'turn') : undefined;
-            return reply.code(202).send({
-                seats,
-                ...(turn !== null ? { turnId: turn.turnId } : {}),
-                ...(singleSeat202 !== undefined ? { singleSeat: singleSeat202 } : {}),
-            });
+            catch (err) {
+                app.log.warn(`chat ${id}: turn ${turnId} was accepted by the engine but not fully recorded: ${message(err)}`);
+            }
+        };
+        // DC-S7: the rules the chat's seats were told about ride the step's instructions, as the
+        // preface rode a pool send; told only once the send is accepted (`commit`).
+        const withPreface = (preface) => (preface !== null ? `${preface}\n\n${text}` : text);
+        try {
+            if (path.runId === undefined) {
+                const stepId = 'answer-1';
+                const generation = path.generation;
+                const roster = rosterWithStanding().filter((seat) => path.eligible.includes(String(seat.key)));
+                const rules = (await considerations.inForceFor(scope?.projectId ?? null)).rules;
+                const pending = await considerations.pendingPreface(id, { inForce: rules });
+                const instructions = withPreface(pending.preface);
+                const input = {
+                    problem: scope !== undefined ? chatScopeStatement(id, scope, rules) : text,
+                    sessionId: randomUUID(),
+                    clisJson: JSON.stringify(roster),
+                    plan: { steps: [answerStep(stepId, instructions)], monitors: { asked: 1 } },
+                    ...(path.primary !== undefined ? { primary: path.primary } : {}),
+                    ...(repoRef !== undefined ? { repoRef, deliver: 'pr' } : {}),
+                    ...(projectId !== undefined ? { projectId } : {}),
+                };
+                const runId = await adapter.launchRun(input);
+                if (!askPaths.started(id, generation, runId, stepId)) {
+                    // The chat was closed (End) while the launch was in flight: the run must not outlive it.
+                    await adapter.cancelRun(runId).catch(() => undefined);
+                    if (turn !== null)
+                        chatTurns.abort(id, turn.turnId);
+                    return reply.code(409).send({ error: `chat '${id}' was closed while its path was launching; the run was cancelled` });
+                }
+                pending.commit();
+                persistAccepted(pending.preface, () => {
+                    runtime.linkChatRun?.(id, runId);
+                    recordRunLaunched(audit, runTimingIndex, actorOf(req), runId, {
+                        chatId: id,
+                        askPath: true,
+                        ...(repoRef !== undefined ? { repoRef } : {}),
+                        ...(projectId !== undefined ? { projectId } : {}),
+                        deliver: repoRef !== undefined ? 'pr' : 'none',
+                    });
+                });
+                return reply.code(202).send({ seats: voice, turnId, runId, stepId, ...singleSeat202 });
+            }
+            const view = (await adapter.sessionsDetail()).find((v) => v.session.id === path.runId);
+            if (view === undefined) {
+                askPaths.release(id, lease);
+                if (turn !== null)
+                    chatTurns.abort(id, turn.turnId);
+                return reply.code(409).send({ error: `chat '${id}': its path ${path.runId} is gone — open a new chat` });
+            }
+            const status = String(view.session.status);
+            if (status !== 'awaiting_human') {
+                askPaths.release(id, lease);
+                if (turn !== null)
+                    chatTurns.abort(id, turn.turnId);
+                const who = path.pa ?? 'the primary agent';
+                return reply.code(409).send({
+                    code: 'turn_in_flight',
+                    error: status === 'executing' || status === 'running'
+                        ? `${who} is still answering the previous message in this chat — wait for the reply. Nothing was sent.`
+                        : `chat '${id}': its path ${path.runId} is ${status}, not waiting for your turn — nothing was sent`,
+                    chatId: id,
+                    runId: path.runId,
+                    status,
+                });
+            }
+            // The status read awaited: the chat may have been closed (and its id reopened) meanwhile —
+            // nothing of this message may land on the newcomer (codex on #808 r3, 2).
+            if (askPaths.get(id)?.generation !== lease) {
+                if (turn !== null)
+                    chatTurns.abort(id, turn.turnId);
+                return reply.code(409).send({ error: `chat '${id}' was closed while the message was in flight; nothing was sent` });
+            }
+            const stepId = askPaths.nextStep(id);
+            const pending = await considerations.pendingPreface(id);
+            await adapter.proposePlan(path.runId, { steps: [answerStep(stepId, withPreface(pending.preface))] }, turnId);
+            await adapter.confirmGate(path.runId, true);
+            askPaths.release(id, lease);
+            if (!askPaths.continued(id, lease, stepId)) {
+                // Closed between the proposal and here: the DELETE cancelled the run this was accepted on.
+                return reply.code(409).send({ error: `chat '${id}' was closed while the message was in flight; its path was cancelled` });
+            }
+            pending.commit();
+            persistAccepted(pending.preface, () => undefined);
+            return reply.code(202).send({ seats: voice, turnId, runId: path.runId, stepId, ...singleSeat202 });
         }
         catch (err) {
-            // Nothing went out: the reservation is retracted so the next send is not refused for it.
+            askPaths.release(id, lease);
             if (turn !== null)
                 chatTurns.abort(id, turn.turnId);
-            const msg = message(err);
-            return reply.code(/no warm seats/.test(msg) ? 409 : 400).send({ error: msg });
+            return reply.code(400).send({ error: message(err) });
         }
     });
-    // F-W1-005 (wave-1 P6): re-seat NAMED seats on a LIVE chat — the retry lever for a seat the open
-    // refused (or whose session died). Re-runs the engine's per-seat `chat_ensure` through `chatOpen`
-    // with the IDENTICAL scope recorded at open (a different scope would evict every warm seat —
-    // Copilot, #426; the index retains what the engine was handed). Explicit seats bypass the daemon's
-    // default pre-filter exactly as `clis` on `POST /chats` does: the engine refuses per seat and its
-    // reason rides the outcome, then `refused[]` and a `chatSeatRefused` frame — the same shapes the
-    // 201 carries, so the thread and the picker read one story. Never a new chat, never a new pool key.
     const ChatSeatsSchema = z.object({
         clis: z.array(z.string().min(1)).min(1).max(8),
     }).strict();
@@ -2732,7 +2801,10 @@ runtime = {}) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
         const engine = chatScopes.engineOf(id);
-        if (engine === undefined) {
+        // ASK-C1: a chat is open here when it has a path record (every open leaves one, scoped or
+        // not) — the engine scope alone is the pool-era test.
+        const launched = askPaths.get(id);
+        if (engine === undefined && launched === undefined) {
             return reply.code(404).send({
                 error: `chat ${id} is not open on this daemon — open a chat first, then re-seat into it`,
             });
@@ -2743,25 +2815,40 @@ runtime = {}) {
         if (inFlight !== null) {
             return reply.code(409).send(turnInFlightBody(id, inFlight, 'No seat was re-warmed.'));
         }
+        // ASK-C1: the path's roster is handed to the engine at launch and never updated after —
+        // a seat admitted later would be reported eligible and never reach the run (codex on #808
+        // r2, 6). Re-seat before the first message; after it, a new chat.
+        if (launched?.runId !== undefined) {
+            return reply.code(409).send({
+                error: `chat '${id}' has launched its path (${launched.runId}); its seats are fixed for this ask — open a new chat to seat ${clis.join(', ')}`,
+                chatId: id,
+                runId: launched.runId,
+            });
+        }
+        if (launched?.busy === true) {
+            // The first message is launching with the roster as it stands (codex on #808 r3, 4).
+            return reply.code(409).send({
+                code: 'turn_in_flight',
+                error: `chat '${id}' is launching its path with the seats as they stand — a seat added now would never reach the run. Nothing was re-seated.`,
+                chatId: id,
+            });
+        }
         try {
-            const seats = await adapter.chatOpen(id, clis, engine.cwd, {
-                codeGraphDb: engine.codeGraphDb,
-                readRoots: engine.readRoots,
+            // ASK-C1: a re-seat re-admits the named seats that pass admission NOW (a sign-in fixed)
+            // into the path's eligible roster; nothing is warmed and the engine is not called.
+            const scopeNow = chatScopes.get(id);
+            const scopedChat = (scopeNow?.kind ?? 'none') !== 'none' && scopeNow?.kind !== 'system';
+            const reseatKind = scopeNow?.kind === 'repos' && scopeNow.repos.length === 1 ? 'path-bound' : 'path';
+            const standingNow = rosterWithStanding();
+            const seats = clis.map((cliKey) => {
+                const seat = standingNow.find((s) => String(s.key) === cliKey);
+                if (seat === undefined)
+                    return { cliKey, ok: false, error: `seat '${cliKey}' is not in the roster` };
+                const admission = chatSeatAdmission(seat, seat.auth ?? 'unknown', scopedChat, reseatKind);
+                return admission.ok ? { cliKey, ok: true } : { cliKey, ok: false, error: admission.reason };
             });
+            askPaths.admit(id, seats.filter((s) => s.ok).map((s) => s.cliKey));
             const refused = chatScopes.foldSeats(id, seats);
-            const projectId = projects.index.projectOf(id) ?? undefined;
-            for (const s of seats) {
-                if (s.ok)
-                    continue;
-                runtime.broadcast?.({
-                    type: 'chatSeatRefused',
-                    chat: id,
-                    cliKey: s.cliKey,
-                    reason: s.error ?? 'the engine refused the seat',
-                    source: 'engine',
-                    ...(projectId !== undefined ? { project_id: projectId } : {}),
-                });
-            }
             return { chatId: id, seats, refused };
         }
         catch (err) {
@@ -2775,7 +2862,24 @@ runtime = {}) {
     // segment first), but the order reads the way the routes nest.
     app.get(`${V}/chats`, { config: { manifest: { responseType: 'ChatListResponse', statusCodes: [200, 400, 501] } } }, async (_req, reply) => {
         try {
-            return { chats: await adapter.chatList() };
+            const pool = await adapter.chatList().catch((err) => {
+                if (err instanceof ChatUnsupportedError)
+                    return [];
+                throw err;
+            });
+            // ASK-C1: an ask path is a chat of this daemon with no engine pool row — listed from the
+            // ask-path index (the pool entries stay until ASK-K4 deletes the pool).
+            const paths = askPaths.list().map((p) => {
+                const engine = chatScopes.engineOf(p.chatId);
+                return {
+                    chatId: p.chatId,
+                    seats: [...p.eligible],
+                    idleSecs: null,
+                    ...(engine !== undefined ? { cwd: engine.cwd, codeGraphDb: engine.codeGraphDb ?? null, readRoots: [...engine.readRoots] } : {}),
+                };
+            });
+            const seen = new Set(paths.map((p) => p.chatId));
+            return { chats: [...paths, ...pool.filter((c) => !seen.has(c.chatId))] };
         }
         catch (err) {
             // A build that cannot do chat is a capability gap, not a bad request: 501 tells an operator to
@@ -2811,9 +2915,12 @@ runtime = {}) {
             // the seats refused at open (F-A45-011), so the studio's admission copy survives a reload.
             return {
                 chatId: id,
-                seats: await adapter.chatSeats(id),
+                // ASK-C1: the eligible roster is the chat's seats (no warm pool); a chat this daemon
+                // did not open answers `[]`.
+                seats: askPaths.get(id)?.eligible ?? [],
                 scope: chatScopes.get(id) ?? null,
                 refused: chatScopes.refusedOf(id) ?? null,
+                ...(askPaths.view(id) !== undefined ? { path: askPaths.view(id) } : {}),
                 // DES-L5 (D-13): the transcript so far, append order — `[]` before the first persisted
                 // turn; the file goes with the chat on `chatClosed`, so a reclaimed id answers `[]` too.
                 ...(chatTranscripts !== undefined ? { messages: chatTranscripts.read(id) } : {}),
@@ -2826,17 +2933,49 @@ runtime = {}) {
     app.delete(`${V}/chats/:id`, async (req, reply) => {
         const { id } = req.params;
         // The scratch root goes with the chat at once, whether or not the engine still knew it
-        // (crew#502); the id stays parked until the engine's `chatClosed` is observed, so a delayed
-        // close can never land on a chat that reused it (Copilot, #518).
-        chatScopes.beginClose(id);
+        // (crew#502). ASK-C1: the daemon owns the close, so the id is HELD — no grace timer — until
+        // this close settles below; a reopen meanwhile is refused and a second DELETE joins this one
+        // (nothing of the closed chat can land on a reuse — codex on #808 r5).
+        const ticket = chatScopes.holdClose(id);
+        if (ticket === null)
+            return { ok: true };
         chatTurns.closed(id);
+        // ASK-C1: End cancels the path (`path.ended{status:"cancelled"}`); the engine holds no chat
+        // row for an ask, so the daemon closes the id itself and the transcript follows the chat
+        // through the same `chatClosed` fold a pool chat used (dropped unless a promoted run retains it).
+        const path = askPaths.close(id);
         try {
-            await adapter.chatClose(id);
+            const projectId = projects.index.projectOf(id) ?? undefined;
+            const frame = {
+                type: 'chatClosed',
+                chat: id,
+                reason: 'closed',
+                ...(projectId !== undefined ? { project_id: projectId } : {}),
+            };
+            // The server's fold (scope slot, decisions, considerations, retention-aware transcript
+            // drop) and the /ws fan-out — the same path an engine `chatClosed` took. Folded BEFORE the
+            // awaited cancel: a close that lands after an await can land on a chat that reused the id
+            // meanwhile (codex on #808 r2, 2). AWAITED: the decision recorder settles the chat's open
+            // turns under the chat's own project before the id is free (the slot is parked `closing`
+            // meanwhile, so a reopen waits), and only then is nothing of the closed chat pending
+            // (codex on #808 r4, 1).
+            if (runtime.closeChat !== undefined)
+                await runtime.closeChat(frame, path?.runId, ticket);
+            else {
+                chatScopes.closeHeld(id, ticket);
+                runtime.broadcast?.(frame);
+            }
+            if (path?.runId !== undefined)
+                await adapter.cancelRun(path.runId).catch(() => undefined);
             return { ok: true };
         }
         catch (err) {
             return reply.code(400).send({ error: message(err) });
         }
+        finally {
+            // Never left held: a fold that threw frees the id here (its own close settles it otherwise).
+            chatScopes.closeHeld(id, ticket);
+        }
     });
     // A unit's captured transcript. `unitKey` accepts the fully-qualified id (`run-1:survey`),
     // the id suffix (`survey`, `u3`), or the ordinal (`u3`, `3`) — see `resolveUnit`.