wicked-crew 0.16.12 → 0.16.13

package/dist/api/routes.js

@@ -6,9 +6,9 @@ import { z } from 'zod';
 import { listRequirementsRead, getRequirement, patchRequirement, readRequirementsGraph, REQUIREMENTS_NOT_GENERATED, } from './requirements.js';
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, realpathSync } from 'node:fs';
 import { promises as fsp } from 'node:fs';
-import { isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { videoPalette } from '../appearance/video-palette.js';
 import { CampaignsUnsupportedError, ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, GovernanceReplayUnsupportedError, PlanLaunchUnsupportedError, SteeringUnsupportedError, addonSupportsQeOverride, addonSupportsReducedAssurance, humanGatePhaseIds, settingsFilePath } from '../core/adapter.js';
@@ -105,8 +105,13 @@ import { deliverIdentityFor, deliverRepoFor, deliverTargetView, isGitHubLogin, p
 import { credentialsMissingIn, deliverCredentialsProbe, missingCredentials } from '../core/deliver-credentials.js';
 import { codebaseArchiveUrl } from './codebase-archive.js';
 import { projectRepoCandidates } from '../interactive/doc-grounding.js';
-import { artifactStatus, beneathSupported, buildTurnContext, chatMount, ChatMessageContextSchema, contextReadRoots, ensureRealDir, parseArtifactRef, readGroundingBeneath, seatPathOf, UNFILED_MOUNT, } from './chat-context.js';
-import { registerInteractiveProxy } from '../interactive/proxy-routes.js';
+import { artifactStatus, beneathSupported, buildTurnContext, chatMount, ChatMessageContextSchema, contextReadRoots, ensureRealDir, sha256Hex, parseArtifactRef, readGroundingBeneath, seatPathOf, UNFILED_MOUNT, } from './chat-context.js';
+import { createDocInProcess, registerInteractiveProxy } from '../interactive/proxy-routes.js';
+import { CreateLauncher } from '../interactive/proposal-create.js';
+import { buildRunBrief } from './run-brief.js';
+import { readBeneath } from './beneath.js';
+/** A context brief copied into a document's packet, at most (the packet's per-file cap). */
+const BRIEF_COPY_MAX = 512 * 1024;
 import { registerInteractiveDocDelete } from '../interactive/doc-delete-routes.js';
 import { registerInteractiveDocChecks } from '../interactive/doc-checks-routes.js';
 import { crewStateHome, stateHomeOfDb } from '../projects/state-home.js';
@@ -928,15 +933,20 @@ runtime = {}) {
     // off — each later slice turns its own on and registers its launcher. The TEST configuration (§13 A2) turns every
     // operation's resolution on and registers a recording stub that starts nothing.
     const chatArtifactsStub = runtime.chatArtifactsStub === true;
+    // A3: a real `create` exists whenever the draft seam can launch a proposal-bound draft (the launcher is registered
+    // below, once the bridge pool exists). Production advertises it; the test configuration keeps the recording stub only
+    // for the operations whose slices have not landed.
+    const realCreate = runtime.docBindings !== undefined && runtime.launchBoundDraft !== undefined;
+    const stubOps = realCreate ? ['refine', 'theme', 'demo'] : ['create', 'refine', 'theme', 'demo'];
     const chatArtifactFlags = chatArtifactsStub
-        ? { context: true, proposals: true, create: true, refine: true, theme: true, demo: true, stub: true }
-        : { context: true, proposals: true, create: false, refine: false, theme: false, demo: false };
+        ? { context: true, proposals: true, create: true, refine: true, theme: true, demo: true, stub: true, stubOps }
+        : { context: true, proposals: true, create: realCreate, refine: false, theme: false, demo: false };
     const proposalLaunchers = new LaunchOnceRegistry();
     if (chatArtifactsStub) {
         // Under the registered `chats` entry (a new top-level state-home entry would make core refuse every launch), and
         // not a `.jsonl` there (the boot sweep clears orphaned transcripts by that suffix).
         const stub = new RecordingStubDispatcher(join(crewStateHome(), 'chats', 'proposal-stub', 'dispatches.ndjson'));
-        for (const kind of ['create', 'refine', 'theme', 'demo'])
+        for (const kind of stubOps)
             proposalLaunchers.register(kind, stub);
     }
     const deliveryIndex = runtime.deliveryIndex ?? new DeliveryIndex();
@@ -1247,6 +1257,15 @@ runtime = {}) {
         const chatId = runTimingIndex.chatIdFor(view.session.id);
         if (chatId !== undefined)
             view.session.chat_id = chatId;
+        // DES-CHAT-ARTIFACTS-001 (A3): the proposal a run answers, the artifact it makes, and a landing that failed.
+        const proposalOf = runTimingIndex.proposalOf(view.session.id);
+        if (proposalOf !== undefined) {
+            view.session.proposal_id = proposalOf.proposalId;
+            view.session.artifact_ref = proposalOf.artifactRef;
+        }
+        const landingFailed = runTimingIndex.landingFailedOf(view.session.id);
+        if (landingFailed !== undefined)
+            view.session.landing_failed = landingFailed;
         // crew#552: the onboarding run a chained capture was launched from — ABSENT otherwise.
         const chainedFrom = runTimingIndex.chainedFromOf(view.session.id);
         if (chainedFrom !== undefined)
@@ -2452,6 +2471,13 @@ runtime = {}) {
             }
             deliver = 'none';
         }
+        // DES-CHAT-ARTIFACTS-001 §4.3 (A3): one live job per chat, work and artifact runs together. A work launch filed under
+        // a chat whose proposal's document attempt has no outcome yet is refused, as Go is refused the other way round.
+        if (b.chatId !== undefined && chatArtifactFlags.proposals) {
+            const live = await chatProposals.liveJobOf(b.chatId).catch(() => null);
+            if (live !== null)
+                return reply.code(409).send({ code: 'chat_busy', error: `This chat already has a job running (${live}). Wait, or stop that run.` });
+        }
         try {
             const runId = await adapter.launchRun(input);
             // crew#641/#642 (item 5): when a run is promoted from a chat, record how many seats
@@ -3698,7 +3724,9 @@ runtime = {}) {
         isAskPath: (runId) => runTimingIndex.isAskPath(runId),
         docsRoot: (projectId) => projectDocsRoot(adapter, projectSettings, projectId),
         projectName: async (projectId) => (await adapter.projectGet(projectId).catch(() => null))?.name ?? null,
-        attachments: (chatId) => chatAttachments.list(chatId).map((a) => ({ id: a.id, name: a.name })),
+        projectRepos: async (projectId) => (await projectRepoCandidates(adapter, projectId, (m) => app.log.warn(m))).map((r) => ({ id: r.repoRef, name: r.name })),
+        attachments: (chatId) => chatAttachments.list(chatId).map((a) => ({ id: a.id, name: a.name, bytes: a.bytes, mediaType: a.mediaType })),
+        repoIds: async () => new Set((await adapter.listRepos()).map((r) => r.id)),
         workflowSteps: async (name, projectId) => {
             // The preset a launch in this project resolves first (a project row wins over a global one), then the def.
             const presets = await adapter.listPresets(projectId ?? undefined).catch(() => []);
@@ -5219,6 +5247,15 @@ runtime = {}) {
             // but its work is complete and liftable — normalize to `completed` so the terminal branch
             // below refuses resume with the DELIVER recovery (POST /runs/:id/deliver), not a re-entry.
             const conflictStrand = normalizeStranded(run);
+            // DES-CHAT-ARTIFACTS-001 §6.2 (A3): a chat proposal's FAILED attempt is never resumed from its cursor: its seam flight
+            // is gone (a resume would finish without landing anything) and its retry may already run. Try again is the path.
+            // A still-live bound run's own gate is approved as any run's.
+            if (run.session.status === 'failed' && runtime.docBindings?.isBound(id) === true) {
+                return reply.code(409).send({
+                    error: `run ${id} answered a chat proposal: it cannot be resumed. Use Try again on its card in the chat (a new attempt at the same document).`,
+                    recovery: 'retry',
+                });
+            }
             // A TERMINAL run is refused LOUDLY, with the actual recovery named (crew#311 defect 2).
             // The engine's `resume_run` no-ops on completed/cancelled and answers the status token, so
             // this route used to reply 200 {"status":"cancelled"} — on the exact runs an operator was
@@ -8676,14 +8713,80 @@ runtime = {}) {
             toReview: toReview.kind === 'ok' ? toReview.value : null,
         });
     });
+    // DES-CHAT-ARTIFACTS-001 §5.2 (A3): a create's `chat_id` + `proposal_id` counts only through the caller's accepted record.
+    const proposalGrant = (chatId, pid, actorId) => (CHAT_ID.test(chatId) ? chatProposals.grantFor(chatId, pid, actorId) : null);
     registerInteractiveProxy(app, adapter, {
         settings: projectSettings,
         pool: interactiveBridges,
         ...(runtime.docGrounding !== undefined ? { grounding: runtime.docGrounding } : {}),
         // crew#631: supply the standing roster so doc/demo creates can refuse an unavailable seat.
         roster: () => rosterWithStanding(),
+        proposalGrant,
+        actorOf: (req) => actorOf(req).id,
         log: (m) => app.log.warn(m),
     });
+    // A3: the real `create` launcher (§4.3 steps 2-3): one document and one run per proposal identity.
+    if (realCreate) {
+        const bindings = runtime.docBindings;
+        proposalLaunchers.register('create', new CreateLauncher({
+            bindings,
+            runExists: async (runId) => (await adapter.sessions()).includes(runId),
+            docsRoot: (projectId) => projectDocsRoot(adapter, projectSettings, projectId),
+            createDoc: (projectId, body, actorId) => createDocInProcess(adapter, {
+                settings: projectSettings,
+                pool: interactiveBridges,
+                ...(runtime.docGrounding !== undefined ? { grounding: runtime.docGrounding } : {}),
+                roster: () => rosterWithStanding(),
+                proposalGrant,
+                log: (m) => app.log.warn(m),
+            }, projectId, body, actorId),
+            launchBound: runtime.launchBoundDraft,
+            ...(runtime.fenceBoundDraft !== undefined ? { fence: runtime.fenceBoundDraft } : {}),
+            records: (chatId) => chatHistory?.messages(chatId) ?? chatTranscripts?.read(chatId) ?? [],
+            instanceOf: (chatId) => chatHistory?.stateOf(chatId)?.instance ?? null,
+            chatIdOf: (chatId, instance) => (chatHistory === null ? chatId : chatHistory.idOfInstance(chatId, instance)),
+            repos: async () => (await adapter.listRepos()).map((r) => ({ id: r.id, name: typeof r.name === 'string' && r.name.trim() !== '' ? r.name.trim() : basename(r.root_path), rootPath: r.root_path })),
+            graphFor: async (projectId, chatId) => {
+                if (projectId === null)
+                    return chatScopes.engineOf(chatId)?.codeGraphDb ?? null;
+                const decision = await resolveProjectGraphBinding(adapter, projectId, undefined).catch(() => ({ binding: null }));
+                return decision.binding?.dbPath ?? null;
+            },
+            clisJsonFor: (seats) => {
+                const roster = rosterWithStanding();
+                const picked = seats.map((k) => roster.find((s) => s.key === k));
+                return picked.some((s) => s === undefined) ? null : JSON.stringify(picked);
+            },
+            styleOf: (entry) => {
+                const seed = CATALOG_SEEDS.find((c) => c.id === entry);
+                return seed !== undefined && seed.launch.kind === 'document' ? seed.launch.style : 'web';
+            },
+            packetDeps: {
+                runs: chatContextDeps.runs,
+                brief: (view) => buildRunBrief(view, { workOutput: chatContextDeps.workOutput, ...(chatContextDeps.acceptanceLine !== undefined ? { acceptanceLine: chatContextDeps.acceptanceLine } : {}) }),
+                docsRoot: chatContextDeps.docsRoot,
+                attachment: (chatId, id) => {
+                    const hit = chatAttachments.resolve(chatId, [id])[0];
+                    return hit === undefined ? null : { name: hit.name, path: hit.path };
+                },
+                // The exact brief a turn was given, from the live chat's scratch root, beneath it (no link followed), only when
+                // its bytes still hash to what the turn recorded (A1's binding). Gone after the chat ends or the daemon restarts.
+                contextBrief: (chatId, relPath, sha) => {
+                    const cwd = chatScopes.get(chatId)?.cwd;
+                    if (cwd === undefined)
+                        return null;
+                    try {
+                        const data = readBeneath(realpathSync(cwd), relPath, BRIEF_COPY_MAX).data;
+                        return sha256Hex(data) === sha ? data : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+            },
+            log: (m) => app.log.warn(m),
+        }));
+    }
     // ── Governed doc delete (crew#338) — the one door that changes BOTH stores ──
     // `DELETE /projects/:id/interactive/docs/:doc` retires the doc on the bridge AND drops crew's
     // handoff-ledger rows for it (the draft leg keys by document id, so a stale row claims the
@@ -8698,6 +8801,13 @@ runtime = {}) {
         // the operator's real ~/.wicked-crew ledgers. The real sweep always arrives from
         // `createServer`.
         dropDocLedgerRows: runtime.dropDocLedgerRows ?? (() => ({ ok: true, removed_keys: [] })),
+        // A3: a document a chat proposal is still drafting (or landing) is not retired under it.
+        busyReason: (projectId, doc) => {
+            const pending = runtime.docBindings?.busy(`${projectId === 'default' ? UNFILED_MOUNT : projectId}/${doc}`) ?? null;
+            return pending !== null && (pending.launchingAt !== undefined || pending.launchedAt !== undefined || pending.emittedAt !== undefined)
+                ? `a chat proposal is still drafting this document (run ${pending.runId.slice(0, 8)}); wait for it to land, or stop that run first`
+                : null;
+        },
         log: (m) => app.log.warn(m),
     });
     // ── A demo run's video as an editable document (the video editor re-cuts it through E1's per-doc API) ──
@@ -8776,6 +8886,6 @@ runtime = {}) {
     const runEvalsPrepare = async (input) => {
         await prepareRunEvalsLaunch(input, () => runAndRecord(defaultEvalDeps, { project: null, baseline: false, id: randomUUID(), now: new Date() }), runtime.evalRunsDir);
     };
-    return { decideGate, decisions, chatRecorder, considerations, search, decorateRun, runEvalsPrepare, chatProposals };
+    return { decideGate, decisions, chatRecorder, considerations, search, decorateRun, runEvalsPrepare, chatProposals, proposalLaunchers };
 }
 //# sourceMappingURL=routes.js.map