wicked-crew 0.8.6 → 0.8.8

package/dist/api/routes.js

@@ -14,12 +14,13 @@ import { detectRefusal } from './gate-cache.js';
 import { acceptanceRequirementOf, buildAcceptanceView } from '../qe/acceptance.js';
 import { runIdentityOf, wireIdentity } from '../core/run-identity.js';
 import { buildEvidenceBundle, coreUnitId, evidenceFilename } from './evidence.js';
-import { outputUnavailableReason, resolveUnit, unitKeysFor } from './unit-output.js';
+import { attemptUnavailableReason, capturedAttempts, outputUnavailableReason, resolveUnit, storedAttempt, unitKeysFor } from './unit-output.js';
 import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
-import { callEstateTool, EstateMcpError } from '../core/estate-mcp-client.js';
+import { callEstateTool, EstateMcpError, memoryStoreInfo } from '../core/estate-mcp-client.js';
 import { SeatHealthTracker } from './seat-health.js';
 import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
 import { chatSeatAdmission } from './seat-standing.js';
+import { seatGovernanceDiagnostics, seatGovernanceWarnings, } from './seat-governance.js';
 import { rosterWithStandingFactory } from './roster-standing.js';
 import { ChatTurnIndex } from './chat-turns.js';
 import { ChatScopeIndex, chatScopeDeps, chatScopeStatement, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
@@ -64,7 +65,7 @@ import { MembershipIndex } from '../projects/membership-index.js';
 import { MEMBERSHIP_ATTACHED, membershipAttachedKey } from '../projects/events.js';
 import { resolveLinkedIssues } from '../core/linked-issues.js';
 import { AuditLog } from './audit.js';
-import { AcpFoldCache, EngineVersionCache, eventsDirOf, installedPackageVersion, listStoreFiles, readStudioBundleVersion, } from './diagnostics.js';
+import { AcpFoldCache, EngineVersionCache, eventsDirOf, installedPackageVersion, hostSandboxLauncher, seatRosterFile, listStoreFiles, readStudioBundleVersion, } from './diagnostics.js';
 import { GovernanceDiagnostics } from './governance-health.js';
 import { governanceStoreFix, legacyHomeOutboxPath } from '../core/governance-store.js';
 import { UsageError, replayOutboxInto } from '../cli/governance.js';
@@ -147,15 +148,28 @@ function message(err) {
  * the caller comparing their JSON against the source, so the unknown keys are named in `error`
  * itself, where a human and a `curl | jq .error` both see it without reading `details`.
  */
-function invalidBody(err, what) {
+export function invalidBody(err, what) {
     const unknown = err.issues.flatMap((i) => (i.code === 'unrecognized_keys' ? i.keys : []));
     const error = unknown.length > 0
         ? `${what}: unknown field${unknown.length > 1 ? 's' : ''} ${unknown
             .map((k) => `\`${k}\``)
             .join(', ')} — this endpoint does not accept ${unknown.length > 1 ? 'them' : 'it'}, and ignoring ${unknown.length > 1 ? 'them' : 'it'} would run a different request than you sent`
-        : what;
+        : namedIssues(what, err.issues);
     return { error, details: err.issues };
 }
+/**
+ * crew#662: a schema rejection that is NOT an unknown key names the field and what was expected —
+ * `Invalid request body: \`revisesPr\` — Expected number, received boolean`. The bare
+ * "Invalid request body" sent a caller off to misdiagnose the contract. Up to three issues are
+ * spelled out; the rest are counted (all of them stay in `details`).
+ */
+function namedIssues(what, issues) {
+    if (issues.length === 0)
+        return what;
+    const shown = issues.slice(0, 3).map((i) => (i.path.length > 0 ? `\`${i.path.join('.')}\` — ${i.message}` : i.message));
+    const more = issues.length > 3 ? `; and ${issues.length - 3} more (see details)` : '';
+    return `${what}: ${shown.join('; ')}${more}`;
+}
 /** First value of a possibly-repeated query param, WITHOUT trimming — `''` is PRESERVED because a
  *  blank `scope`/`scope_prefix` is meaningful to estate (root / whole-subtree), unlike an omitted
  *  one. Returns undefined only when the param is absent. */
@@ -312,6 +326,11 @@ const OnboardBodySchema = z
 // compile time, that every body the published contract (`wicked-crew-api-types`) lets a client
 // send is a body these schemas accept — the request-direction half of the drift guard (task #84).
 export { PlanSchema };
+/** crew#825: the issue refs a launch leaves out of the linked-issue expansion. */
+const ExcludeLinkedIssuesSchema = z
+    .array(z.string().regex(/^\s*(?:\d+|(?:(?:[\w.-]+\/)?[\w.-]+)?#\d+)\s*$/, 'an issue ref: 541, #541, repo#541 or owner/repo#541'))
+    .max(50)
+    .optional();
 export const LaunchSchema = z.object({
     problem: z.string().min(1),
     sessionId: z.string().min(1).optional(),
@@ -374,6 +393,11 @@ export const LaunchSchema = z.object({
      *  launch (e.g. a CI job name or a studio tab id). Persisted on the `run.launched` audit entry
      *  (`detail.actor`) and served on the run DTO; absent = caller omitted it. */
     actor: z.string().min(1).max(256).optional(),
+    /** crew#825 (api-types additive) — issue refs the intent names that the daemon must NOT read and
+     *  append (`541`, `#541`, `repo#541`, `owner/repo#541`): a reference in passing is not a request to inline
+     *  the issue. They are answered as `linkedIssues[].excluded`. Send only when
+     *  `GET /health.capabilities.linkedIssuesExclude === true`. */
+    excludeLinkedIssues: ExcludeLinkedIssuesSchema,
 }).strict().refine((b) => b.plan === undefined || b.workflow === undefined, {
     message: 'plan and workflow are mutually exclusive — a launch carries a plan or names a preset, not both',
     path: ['plan'],
@@ -763,7 +787,8 @@ runtime = {}) {
     /** DES-L9: PR number → head branch, through `gh pr view` unless the runtime injected an answerer. */
     const resolvePullRequest = runtime.resolvePullRequest ?? resolvePullRequestViaGh;
     /** crew#627: the intent's linked issues, read under the daemon's identity at launch. */
-    const readLinkedIssues = runtime.resolveLinkedIssues ?? ((p, root, ref) => resolveLinkedIssues(p, root, ref));
+    const readLinkedIssues = runtime.resolveLinkedIssues ??
+        ((p, root, ref, exclude) => resolveLinkedIssues(p, root, ref, undefined, exclude));
     /** crew#550 P-7: the follow-ups the run's evaluator units flagged, read from their captured output.
      *  A unit whose output cannot be read contributes nothing (the section then says what WAS read);
      *  an adapter without transcripts (a directly-driven route set) reads as "not read" — absent. */
@@ -999,6 +1024,8 @@ 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,
+            // crew#825: `LaunchRunBody.excludeLinkedIssues` + `POST /linked-issues/preview` are served.
+            linkedIssuesExclude: 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.
@@ -1035,6 +1062,9 @@ runtime = {}) {
             ...(adapter.busUnavailable != null ? [busUnavailableWarning(adapter.busUnavailable)] : []),
             // wicked-core#631: the engine has the bus but not the calls crew reaches it through.
             ...(adapter.busSeamsOff != null ? [busSeamsOffWarning(adapter.busSeamsOff)] : []),
+            // crew#742: a seat that runs ungoverned, or floor seats on a host that cannot arm their
+            // boundary, are named before any run starts.
+            ...seatGovernanceWarnings(seatGovernanceNow(), hostSandboxLauncher()),
         ];
         return {
             status: 'ok',
@@ -1100,6 +1130,16 @@ runtime = {}) {
             // who classified (the engine, or crew's registry copy on an older addon) and whether that
             // refuses launches — re-surveyed per read. `null` on a route set booted without the watch.
             stateHome: runtime.stateHome !== undefined ? await runtime.stateHome.refresh() : null,
+            // crew#742: per seat — transport, the record's OS sandbox, the engine's governance class,
+            // input governance enforced / claimed / unenforced, the mode per scope kind; plus the
+            // registry overlay file and this host's OS launcher.
+            seatGovernance: {
+                rosterFile: seatRosterFile(),
+                hostBoundary: hostSandboxLauncher(),
+                seats: seatGovernanceNow(),
+            },
+            // crew#740: which memory store this daemon reads and writes, and the isolation notice.
+            memoryStore: memoryStoreInfo(),
         };
     });
     // Who am I talking to the daemon as? (task #88). In local mode this is
@@ -1161,6 +1201,16 @@ runtime = {}) {
     // disagree about a seat.
     const rosterWithStanding = runtime.rosterWithStanding ?? rosterWithStandingFactory({ seatHealth, signedIn });
     app.get(`${V}/roster`, async () => ({ roster: rosterWithStanding() }));
+    /** crew#742: the seats' governance standing, read from the standing roster (empty when the
+     *  roster cannot be read — the roster route reports that failure itself). */
+    const seatGovernanceNow = () => {
+        try {
+            return seatGovernanceDiagnostics(rosterWithStanding());
+        }
+        catch {
+            return [];
+        }
+    };
     // Each seat's week (studio's weekly 1:1 per agent; api-types 0.52.0): units, first pass, rework,
     // stalls, bench and cost, folded from the runs' durable event logs by `seatRecord` — nothing new
     // is stored. The daemon's remembered stall frames join the engine's, as on `/runs/:id/events`.
@@ -1562,6 +1612,33 @@ runtime = {}) {
         const projectAttachError = await recordOnboardingLaunch(req, runId, repo.id, body.data);
         return reply.code(201).send({ runId, ...(projectAttachError !== undefined ? { projectAttachError } : {}) });
     });
+    // crew#825: what a workflow launch WOULD append — the same reading `POST /runs` does, before Send,
+    // so the composer shows "N linked issues will be appended (≈K chars)" with a way to leave one out
+    // (`excludeLinkedIssues`). Read-only: nothing launches, nothing is stored.
+    const LinkedIssuesPreviewSchema = z
+        .object({
+        problem: z.string().min(1),
+        repoRef: z.string().min(1).optional(),
+        excludeLinkedIssues: ExcludeLinkedIssuesSchema,
+    })
+        .strict();
+    app.post(`${V}/linked-issues/preview`, { config: { manifest: { requestType: 'LinkedIssuesPreviewBody', responseType: 'LinkedIssuesPreviewResponse', statusCodes: [200, 400] } } }, async (req, reply) => {
+        const parsed = LinkedIssuesPreviewSchema.safeParse(req.body);
+        if (!parsed.success)
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        const b = parsed.data;
+        // The launch's own best-effort contract (codex on this PR): a resolver fault launches on the
+        // intent alone, so the preview answers "nothing appended" and says why — never a 500.
+        try {
+            const root = b.repoRef !== undefined ? await repoRootOf(b.repoRef) : undefined;
+            const linked = await readLinkedIssues(b.problem, root, b.repoRef, b.excludeLinkedIssues ?? []);
+            return { issues: linked.issues, appendedChars: linked.block === null ? 0 : linked.block.length + 2 };
+        }
+        catch (err) {
+            req.log.warn(`linked-issue preview failed; a launch would run on the intent alone: ${message(err)}`);
+            return { issues: [], appendedChars: 0, error: `linked issues could not be read: ${message(err)} — a launch now runs on the intent alone` };
+        }
+    });
     // Launch a run (replaces POST /sessions). `clisJson` defaults to the roster;
     // `sessionId` is minted if the client omits it.
     app.post(`${V}/runs`, {
@@ -1774,11 +1851,12 @@ runtime = {}) {
             // fault (the repo list unreadable, say) launches the run on its intent alone and is logged.
             try {
                 const root = b.repoRef !== undefined ? await repoRootOf(b.repoRef) : undefined;
-                const linked = await readLinkedIssues(b.problem, root, b.repoRef);
-                if (linked.block !== null) {
+                const linked = await readLinkedIssues(b.problem, root, b.repoRef, b.excludeLinkedIssues ?? []);
+                if (linked.block !== null)
                     input.problem = `${b.problem.trimEnd()}\n\n${linked.block}`;
+                // crew#825: an all-excluded intent appends nothing but still answers what it left out.
+                if (linked.issues.length > 0)
                     linkedIssues = linked.issues;
-                }
             }
             catch (err) {
                 req.log.warn(`linked-issue resolution failed; launching on the intent alone: ${message(err)}`);
@@ -1875,7 +1953,11 @@ runtime = {}) {
             // planner (one unit, the brief verbatim). Say so in the answer, with how to get work done,
             // instead of letting it pass for a launch of real work.
             const freeText = input.workflow === undefined && input.plan === undefined ? { freeText: { notice: FREE_TEXT_NOTICE } } : {};
-            return reply.code(201).send({ runId, ...(linkedIssues !== undefined ? { linkedIssues } : {}), ...freeText });
+            // crew#874: the run uses the PUBLISHED generation; when the installed garden is not the one it
+            // was built from, the launch answer says so (a recorded proof can disclose which garden ran).
+            const skillsAhead = runtime.skills?.installedAheadFinding({ fresh: true }) ?? null; // fresh: an upgrade just before Send counts (codex r1)
+            const skillsWarning = skillsAhead === null ? {} : { skillsWarning: { kind: skillsAhead.kind, severity: skillsAhead.severity, message: skillsAhead.message } };
+            return reply.code(201).send({ runId, ...(linkedIssues !== undefined ? { linkedIssues } : {}), ...freeText, ...skillsWarning });
         }
         catch (err) {
             const msg = message(err);
@@ -2495,7 +2577,10 @@ runtime = {}) {
                     refused.push({ cliKey: key, reason: `seat '${key}' is not in the roster`, source: 'scope' });
                     continue;
                 }
-                const admission = chatSeatAdmission(seat, seat.auth ?? 'unknown', scoped, admissionKind);
+                const admission = chatSeatAdmission(
+                // IG1-crew-2: the standing seat carries the engine's `governance_class` and the pin
+                // reading, so a scoped ask admits by the seat's governance mode (reason names it).
+                seat, seat.auth ?? 'unknown', scoped, admissionKind);
                 if (admission.ok)
                     clis.push(key);
                 else
@@ -2575,7 +2660,12 @@ runtime = {}) {
                 }
                 // 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);
+                // IG1-crew-1: with the admitted seats' records and the scope kind, so the path's view
+                // names the PA's governance mode.
+                askPaths.open(chatId, clis, b.primary, {
+                    seats: standing.filter((s) => clis.includes(String(s.key))),
+                    scopeKind: !scoped ? 'unscoped' : admissionKind === 'path-bound' ? 'scoped_bound' : 'scoped',
+                });
                 // 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) {
@@ -2896,7 +2986,10 @@ runtime = {}) {
                 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);
+                const admission = chatSeatAdmission(
+                // IG1-crew-2: the standing seat carries the engine's `governance_class` and the pin
+                // reading, so a scoped ask admits by the seat's governance mode (reason names it).
+                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));
@@ -2974,7 +3067,9 @@ runtime = {}) {
                 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.
+                // turn. The file goes with the chat on `chatClosed` UNLESS a run promoted from it is still
+                // live (crew#619 retention — dropped when that run terminals), so a reclaimed id answers
+                // `[]` only once no promoted run holds the old file.
                 ...(chatTranscripts !== undefined ? { messages: chatTranscripts.read(id) } : {}),
             };
         }
@@ -3050,12 +3145,48 @@ runtime = {}) {
                 units: unitKeysFor(run),
             });
         }
+        const rawAttempt = req.query.attempt;
+        const attemptArg = Array.isArray(rawAttempt) ? rawAttempt[0] : rawAttempt;
+        const wanted = attemptArg === undefined || attemptArg === '' ? undefined : /^\d{1,9}$/.test(attemptArg) ? Number(attemptArg) : NaN;
+        if (wanted !== undefined && !Number.isSafeInteger(wanted)) {
+            return reply.code(400).send({ error: '`attempt` must be a non-negative integer' });
+        }
         // Keyed off the unit RECORD (the same derivation the evidence bundle uses), not off the
         // caller's path segment — the two disagreeing is what made a resolvable unit unreadable.
         const output = await adapter.workOutput(coreUnitId(id, unit));
-        if (output !== null)
-            return reply.send({ output });
-        return reply.send({ output: null, outputUnavailable: outputUnavailableReason(unit) });
+        // crew#848: which attempt those bytes are. The engine keeps one transcript per unit (the last
+        // attempt that folded ok); the durable log has one `unitOutputCaptured` per attempt.
+        const events = typeof adapter.runEvents === 'function' ? await adapter.runEvents(id).catch(() => null) : null;
+        const attempts = capturedAttempts((events ?? []), unit.ord);
+        const served = output !== null ? storedAttempt(attempts, output) : null;
+        const latest = attempts[attempts.length - 1];
+        const meta = {
+            ...(served !== null ? { attempt: served } : {}),
+            ...(latest !== undefined ? { latestAttempt: latest.attempt } : {}),
+            ...(events !== null ? { attempts } : {}),
+        };
+        if (served !== null)
+            void reply.header('x-wicked-unit-attempt', String(served));
+        if (wanted !== undefined) {
+            const rec = attempts.find((a) => a.attempt === wanted);
+            if (rec === undefined) {
+                return reply.code(404).send({
+                    error: `Unit ${unit.ord} of run ${id} has no attempt ${wanted} on record`,
+                    attempts: attempts.map((a) => a.attempt),
+                });
+            }
+            if (output !== null && served === wanted)
+                return reply.send({ output, ...meta });
+            return reply.send({ output: null, ...meta, attempt: wanted, outputUnavailable: attemptUnavailableReason(unit, rec, served) });
+        }
+        if (output !== null) {
+            // A later attempt that left no transcript: the stored bytes are SUPERSEDED — say so, and why.
+            if (served !== null && latest !== undefined && latest.attempt > served) {
+                return reply.send({ output, ...meta, superseded: true, latestUnavailable: attemptUnavailableReason(unit, latest, served) });
+            }
+            return reply.send({ output, ...meta });
+        }
+        return reply.send({ output: null, ...meta, outputUnavailable: outputUnavailableReason(unit) });
     });
     // DC-S7 (§4.6): what the seats considered, set aside and cited for one chat turn or one unit
     // attempt. Operator+ (the rules are the project's doctrine). A cited rule is "unchecked", never
@@ -3150,6 +3281,26 @@ runtime = {}) {
             claims: () => adapter.listConformanceClaims(),
             events: (rid) => adapter.runEvents(rid),
             ...(walkthroughs.gates.length > 0 || walkthroughs.ownedByYou ? { walkthroughs } : {}),
+            // IG1-crew-2: what fenced each unit — the run's binding and the roster's seat records.
+            enforcementContext: {
+                bound: run.session.repo_ref !== null,
+                worktree: run.session.workdir,
+                extraWriteRoots: run.session.extra_write_roots ?? [],
+                seatOf: (() => {
+                    let seats = null;
+                    return (cli) => {
+                        if (seats === null) {
+                            try {
+                                seats = rosterWithStanding();
+                            }
+                            catch {
+                                seats = [];
+                            }
+                        }
+                        return seats.find((seat) => seat.key === cli);
+                    };
+                })(),
+            },
         });
     });
     /**
@@ -5201,7 +5352,8 @@ runtime = {}) {
             }
             if (limit !== undefined)
                 memories = memories.slice(0, limit);
-            const body = { memories };
+            // crew#740: the store the list came from (path, source, the isolation notice when it applies).
+            const body = { memories, store: memoryStoreInfo() };
             return body;
         }
         catch (err) {