wicked-crew 0.5.0 → 0.7.0

package/dist/core/adapter.js

@@ -7,6 +7,8 @@ import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { DEFAULT_SETTINGS } from './types.js';
 import { execCapped } from './exec.js';
+import { composeDeliverWorkflow, DELIVER_PHASE_ID } from './deliver.js';
+import { composeDeliverableFloor } from './deliverable-floor.js';
 /** Resolved path under the user's home directory. */
 function wickedDir(...parts) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? '/tmp';
@@ -43,7 +45,9 @@ function workflowOverlayDir() {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? '/tmp';
     return join(home, '.config', 'wicked-core', 'workflows');
 }
-function settingsFilePath() {
+/** Where the daemon persists system settings. Exported so tests write fixtures to the ONE
+ *  spelling of this path (the tests/ tree is audited against spelling core paths itself). */
+export function settingsFilePath() {
     return join(homedir(), '.config', 'wicked-core', 'settings.json');
 }
 /** Read user-registered workflow overlays from `dir` (the same dir `registerWorkflow` writes to).
@@ -109,6 +113,58 @@ function locateWickedCoreExe() {
 // `subscribe` seam has a blast radius of exactly one file.
 const require = createRequire(import.meta.url);
 const { Core } = require('wicked-core-ts');
+/**
+ * Does the installed wicked-core-ts addon understand `LaunchOptions.extraWriteRoots` (≥ 0.6.1)?
+ *
+ * A napi object silently IGNORES fields the addon doesn't declare, so passing the option to an
+ * older addon would launch a run whose boundary never widened — the worker then gets a boundary
+ * deny on the very deliverable path the caller declared (the crew#263 failure, resurrected
+ * silently). Fail CLOSED on version instead: same doctrine as the `projectId` guard below.
+ */
+function addonSupportsExtraWriteRoots() {
+    return addonAtLeast(0, 6, 1);
+}
+/**
+ * Does the installed addon understand `LaunchOptions.projectGraph` (≥ 0.7.1)?
+ *
+ * Same doctrine, different cost of being wrong. A silently-dropped binding does not deny anything —
+ * it launches a run whose workers quietly see one repo while the launcher recorded that they see
+ * the project. The daemon would then log "bound to the project graph as 'wicked-core'" for a run
+ * that never was, which is worse than not binding at all: the operator's evidence about what the
+ * run could see becomes false. Fail closed and keep the log honest.
+ */
+function addonSupportsProjectGraph() {
+    return addonAtLeast(0, 7, 1);
+}
+/**
+ * Is the installed `wicked-core-ts` at least `maj.min.pat`?
+ *
+ * ONE version reader for every capability gate, because the parsing rule here is load-bearing and
+ * was already got wrong once: `split('.').map(Number)` returns NaN on a pre-release or build suffix
+ * (`0.6.1-beta.1`), which fails a perfectly capable addon closed (Copilot on #263). Matching only
+ * the numeric MAJOR.MINOR.PATCH prefix fixes that, and a second copy of the fix is a second chance
+ * to lose it. No match ⇒ unparseable ⇒ fail closed.
+ */
+function addonAtLeast(maj, min, pat) {
+    try {
+        const pkg = require('wicked-core-ts/package.json');
+        const m = /^(\d+)\.(\d+)\.(\d+)/.exec(pkg.version ?? '');
+        if (!m)
+            return false;
+        const got = [Number(m[1]), Number(m[2]), Number(m[3])];
+        const want = [maj, min, pat];
+        for (let i = 0; i < 3; i += 1) {
+            if (got[i] > want[i])
+                return true;
+            if (got[i] < want[i])
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // ── Built-in workflow definitions (crew#44) ──────────────────────────────────
 // Static mirrors of wicked-core workflow defs: feature, bug, migration, survey-repo,
 // domain-graph-slice, memories, collab, onboarding, chat, and domain-extraction.
@@ -149,7 +205,7 @@ const CORE_SEEDED_WORKFLOWS = new Set(['feature', 'bug', 'migration', 'onboardin
  * moves. This is display only: as of FINDING-049 these defs are never written to core's overlay dir
  * (see CORE_SEEDED_WORKFLOWS), so a stale value here cannot reach the engine.
  */
-const EVIDENCE_FLOOR_PIN = '2fcde907d57f3ee2';
+const EVIDENCE_FLOOR_PIN = 'e2e7af1db9e48454';
 export const BUILTIN_WORKFLOWS = [
     {
         id: 'chat',
@@ -184,7 +240,7 @@ export const BUILTIN_WORKFLOWS = [
             { id: 'design', kind: 'recon', gate_type: 'strategy', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['clarify'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
             { id: 'build', kind: 'build', gate_type: 'execution', gate: 'auto', executes_code: true, verified_evidence: false, required_deliverables: [], depends_on: ['design'], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
             { id: 'adversarial-review', kind: 'review', gate_type: 'execution', gate: { human_confirm: { unconditional: false } }, executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['build'], role: 'evaluator', skill_ref: null, allowed_skills: [], validator_pin: EVIDENCE_FLOOR_PIN },
-            { id: 'test', kind: 'test', gate_type: 'execution', gate: { human_confirm_if: 'verdict_not_pass' }, executes_code: false, verified_evidence: true, required_deliverables: [], depends_on: ['build'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
+            { id: 'test', kind: 'test', gate_type: 'execution', gate: { human_confirm_if: 'verdict_not_pass' }, executes_code: false, verified_evidence: true, required_deliverables: [], depends_on: ['build'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: EVIDENCE_FLOOR_PIN },
             { id: 'review', kind: 'review', gate_type: 'execution', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['test'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
         ],
     },
@@ -278,7 +334,7 @@ export const BUILTIN_WORKFLOWS = [
             { id: 'survey', kind: 'recon', gate_type: null, gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: 'wicked-garden-domain', allowed_skills: [], validator_pin: null },
             { id: 'analyze', kind: 'recon', gate_type: null, gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['survey'], role: 'neutral', skill_ref: 'wicked-garden-domain', allowed_skills: [], validator_pin: null },
             { id: 'extract', kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['analyze'], role: 'creator', skill_ref: 'wicked-garden-domain-extractor', allowed_skills: [], validator_pin: null },
-            { id: 'coverage', kind: 'test', gate_type: 'execution', gate: { human_confirm_if: 'verdict_not_pass' }, executes_code: false, verified_evidence: true, required_deliverables: ['coverage-report.json'], depends_on: ['extract'], role: 'evaluator', skill_ref: 'wicked-garden-domain-coverage', allowed_skills: [], validator_pin: '49b61ba3ab5264e4' },
+            { id: 'coverage', kind: 'test', gate_type: 'execution', gate: { human_confirm_if: 'verdict_not_pass' }, executes_code: false, verified_evidence: true, required_deliverables: ['coverage-report.json'], depends_on: ['extract'], role: 'evaluator', skill_ref: 'wicked-garden-domain-coverage', allowed_skills: [], validator_pin: 'bfe4020a365c598b' },
             // domain-graph is a DETERMINISTIC Tool that runs `wicked-core domain-graph`, which PERSISTS the
             // domain/requirement/rule graph into the repo store (core#237) — not an LLM skill that could hit
             // a non-persisting hermetic fallback. Mirrors wicked-core/workflows/domain-extraction.json.
@@ -304,6 +360,17 @@ export class ChatUnsupportedError extends Error {
         this.name = 'ChatUnsupportedError';
     }
 }
+/**
+ * The project surface (DES-PROJECT-001) is not available in this deployment — the installed
+ * wicked-core-ts predates 0.6.0. Typed for the same reason as `ChatUnsupportedError`: the routes
+ * answer 501 ("upgrade the engine") on this, never 400 ("fix your request").
+ */
+export class ProjectsUnsupportedError extends Error {
+    constructor(what) {
+        super(`${what} is not supported by this wicked-core build (needs wicked-core-ts >= 0.6.0)`);
+        this.name = 'ProjectsUnsupportedError';
+    }
+}
 /**
  * `resolveElicitation` is not available in this deployment — the NAPI binding has not
  * landed in the installed `wicked-core-ts` yet (DES-002 §4 P-1 stub).
@@ -376,13 +443,6 @@ function quarantineStaleOnboardingOverlay() {
             `whatever repo the run names (FINDING-075).`);
     }
 }
-/**
- * The single isolation boundary over wicked-core-ts. It holds the ONE `Core`
- * handle, makes the ONE `subscribe()` call for the whole process, parses each
- * CoreEvent, and re-emits it to registered in-daemon listeners. Every REST
- * endpoint and the WS fan-out funnel through this stable API — so when the
- * in-flight core-ts subscribe/teardown signature lands, only this file changes.
- */
 /** The ids of a workflow's phases that carry a HUMAN gate (`human_confirm` unconditional, or the
  * conditional `human_confirm_if`) — i.e. the phases that will PAUSE for a person.
  *
@@ -398,6 +458,13 @@ export function humanGatePhaseIds(wf) {
         ('human_confirm' in p.gate || 'human_confirm_if' in p.gate))
         .map((p) => p.id);
 }
+/**
+ * The single isolation boundary over wicked-core-ts. It holds the ONE `Core`
+ * handle, makes the ONE `subscribe()` call for the whole process, parses each
+ * CoreEvent, and re-emits it to registered in-daemon listeners. Every REST
+ * endpoint and the WS fan-out funnel through this stable API — so when the
+ * in-flight core-ts subscribe/teardown signature lands, only this file changes.
+ */
 export class CoreAdapter {
     core;
     subscription;
@@ -490,25 +557,138 @@ export class CoreAdapter {
             opts.humanConfirm = input.humanConfirm;
         if (input.repoRef !== undefined)
             opts.repoRef = input.repoRef;
-        if (input.workflow !== undefined) {
-            opts.workflow = input.workflow;
-            // Ensure DROP-IN workflow definitions are present in the Rust overlay dir on first use.
-            // Uses a dedicated helper (not registerWorkflow) to avoid adding built-ins to userWorkflows,
-            // which would duplicate them in listWorkflows(). The write is skipped after the first call
-            // per process lifetime.
+        if (input.projectId !== undefined) {
+            // Fail CLOSED on an old addon: silently dropping projectId would launch an unfiled run the
+            // caller believed was filed — the exact failure §2.2 exists to prevent.
+            if (typeof this.core.projectCreate !== 'function') {
+                throw new ProjectsUnsupportedError('Filing a run into a project');
+            }
+            opts.projectId = input.projectId;
+        }
+        if (input.extraWriteRoots !== undefined && input.extraWriteRoots.length > 0) {
+            // Fail CLOSED on an old addon (napi ignores undeclared fields): a silently-dropped
+            // widening resurrects the crew#263 boundary deny on the declared deliverable path.
+            if (!addonSupportsExtraWriteRoots()) {
+                throw new Error('extraWriteRoots needs wicked-core-ts >= 0.6.1; the installed addon would silently ' +
+                    'ignore it and the run would be denied writing its own deliverable');
+            }
+            opts.extraWriteRoots = input.extraWriteRoots;
+        }
+        if (input.projectGraph !== undefined) {
+            // Fail CLOSED on an old addon (napi ignores undeclared fields): the run would silently get
+            // its repo's graph while everything on this side recorded that it got the project's.
+            if (!addonSupportsProjectGraph()) {
+                throw new Error('projectGraph needs wicked-core-ts >= 0.7.1; the installed addon would silently ignore ' +
+                    'it and the run would see one repo while the daemon logged that it saw the project');
+            }
+            // The two invariants the TYPE cannot express, enforced where the launch is actually
+            // assembled (Copilot on #327). Both are cross-field, so `projectGraph`'s own shape can never
+            // carry them, and `core/types.ts` says as much rather than pretending the compiler helps.
             //
-            // Ids core seeds itself are excluded: writing them shadows the real def with this stale
-            // mirror — see CORE_SEEDED_WORKFLOWS. Core resolves those from its own registry, so there is
-            // nothing to write and never was.
-            const builtinDef = CORE_SEEDED_WORKFLOWS.has(input.workflow)
-                ? undefined
-                : BUILTIN_WORKFLOWS.find((w) => w.id === input.workflow);
-            if (builtinDef && !this._builtinOverlayWritten.has(input.workflow)) {
-                // Mark before await so concurrent launchRun() calls for the same builtin
-                // don't both pass the has() check and race to write the same file.
-                this._builtinOverlayWritten.add(input.workflow);
-                await this._writeBuiltinOverlay(builtinDef);
+            // Loud, not lenient. Every one of these is a CALLER bug, and the failure it would otherwise
+            // produce is the silent kind this whole slice exists to end: a run that reports one thing
+            // about what it could see and observes another. `resolveProjectGraphBinding` — the only
+            // producer today — satisfies both on every arm, so a throw here means a new caller got it
+            // wrong, which is exactly when you want to hear about it.
+            if (input.projectId === undefined) {
+                throw new Error('projectGraph is the PROJECT\'s graph, so the run must be filed into that project: ' +
+                    'pass projectId alongside it, or omit projectGraph and let the run use its repo graph');
+            }
+            if (input.repoRef !== undefined && input.projectGraph.repoLabel === undefined) {
+                throw new Error(`a repo-bound run needs projectGraph.repoLabel: without it the engine cannot confirm the ` +
+                    `project graph holds '${input.repoRef}', and a graph that does not would answer ` +
+                    `"not found" about the run's own worktree`);
+            }
+            opts.projectGraph = input.projectGraph;
+        }
+        if (input.workflow !== undefined) {
+            let workflowId = input.workflow;
+            // Both per-run compositions (deliver + deliverable floor) fold into ONE def and ONE
+            // registration: composing twice would arm two ids and launch the second, leaving the
+            // first as engine litter. `composed` stays null until something actually composes, which
+            // is what keeps the undelivered/unfloored launch byte-for-byte the old path.
+            const requireDeliverables = input.requireDeliverables ?? [];
+            let composed = null;
+            if (input.deliver === 'pr' || requireDeliverables.length > 0) {
+                const base = this.getWorkflow(input.workflow);
+                if (base === null) {
+                    throw new Error(input.deliver === 'pr'
+                        ? `deliver: "pr" needs a registered workflow to append the deliver phase to — ` +
+                            `'${input.workflow}' is not registered`
+                        : `requireDeliverables needs a registered workflow to append the deliverable ` +
+                            `floor to — '${input.workflow}' is not registered`);
+                }
+                composed = base;
+            }
+            if (composed !== null && requireDeliverables.length > 0) {
+                // THE DELIVERABLE FLOOR (crew#311): "done" is re-derived from the artifact. The
+                // launcher declared what this run must produce, so a deterministic Tool phase appended
+                // here re-verifies that those files EXIST and carry bytes, and fails the run naming
+                // what was expected and what was found when they do not. Composed BEFORE the deliver
+                // phase below so the floor sits ahead of it: a run that produced nothing must fail
+                // rather than open a pull request over an empty branch.
+                composed = composeDeliverableFloor(composed, input.sessionId, requireDeliverables);
             }
+            if (composed !== null && input.deliver === 'pr') {
+                // First-class delivery (crew#293): compose a PER-RUN def — the selected workflow's
+                // phases plus the hardened deliver Tool phase appended last — and arm it with the
+                // engine under a run-scoped id. The shared def is NEVER mutated, and the composed def
+                // is hot-registered only (no overlay file, no userWorkflows entry): it exists for this
+                // launch, not for the catalog.
+                if (composed.phases.some((p) => p.id === DELIVER_PHASE_ID)) {
+                    // The def already delivers (an operator's own feature-pr-style overlay). Appending a
+                    // second `deliver` phase would collide on id — launch the def as-is; the intent
+                    // ("this run opens its PR") is already satisfied.
+                }
+                else {
+                    // The run's intent rides along so the commit the deliver phase makes NAMES what it
+                    // delivered (`wicked-crew run <id>: <intent>`, #318) instead of being an anonymous
+                    // blob. Composition stays DEFERRED (#319): deliver and the deliverable floor fold
+                    // into one def and one registration below, never two armed ids.
+                    composed = composeDeliverWorkflow(composed, input.sessionId, input.problem);
+                }
+            }
+            if (composed !== null && composed.id !== input.workflow) {
+                await this._armPerRunWorkflow(composed);
+                workflowId = composed.id;
+            }
+            opts.workflow = workflowId;
+            if (workflowId === input.workflow) {
+                // Ensure DROP-IN workflow definitions are present in the Rust overlay dir on first use.
+                // Uses a dedicated helper (not registerWorkflow) to avoid adding built-ins to userWorkflows,
+                // which would duplicate them in listWorkflows(). The write is skipped after the first call
+                // per process lifetime.
+                //
+                // Ids core seeds itself are excluded: writing them shadows the real def with this stale
+                // mirror — see CORE_SEEDED_WORKFLOWS. Core resolves those from its own registry, so there is
+                // nothing to write and never was.
+                //
+                // Skipped entirely on the per-run deliver path above (workflowId !== input.workflow):
+                // the composed def carries the base's full phase list, so the run resolves its own
+                // registration and the base drop-in is not consulted.
+                const builtinDef = CORE_SEEDED_WORKFLOWS.has(input.workflow)
+                    ? undefined
+                    : BUILTIN_WORKFLOWS.find((w) => w.id === input.workflow);
+                if (builtinDef && !this._builtinOverlayWritten.has(input.workflow)) {
+                    // Mark before await so concurrent launchRun() calls for the same builtin
+                    // don't both pass the has() check and race to write the same file.
+                    this._builtinOverlayWritten.add(input.workflow);
+                    await this._writeBuiltinOverlay(builtinDef);
+                }
+            }
+        }
+        else if (input.deliver === 'pr') {
+            // Fail loud, not silent: dropping the option would run to completion with the caller
+            // believing a PR opens at the end — the exact operator gap crew#293 closes.
+            throw new Error('deliver: "pr" requires a workflow — a free-text run has no def to append the deliver phase to');
+        }
+        else if ((input.requireDeliverables ?? []).length > 0) {
+            // Same rule for the floor (Copilot, #319): a caller that declares what a run MUST produce
+            // and gets no enforcement is worse off than one that never declared it — it would watch a
+            // free-text run complete and believe the artifacts were re-derived. There is no def to
+            // append the floor phase to, so refuse the launch instead of silently ignoring the option.
+            throw new Error('requireDeliverables requires a workflow — a free-text run has no def to append the ' +
+                'deliverable floor to');
         }
         return this.core.launchRun(opts);
     }
@@ -524,6 +704,20 @@ export class CoreAdapter {
     cancelRun(runId) {
         return this.core.cancelRun(runId);
     }
+    /**
+     * Archive (or unarchive) a TERMINAL run (crew#265) — write-off, not delete. Resolves `true`
+     * when the session existed, `false` for an unknown id (→ 404); REJECTS when the run is
+     * non-terminal (the route answers 409). Fail-closed on an old addon: method-presence guard,
+     * same doctrine as `injectWorkerMessage`.
+     */
+    async archiveRun(runId, archived, note) {
+        const archive = this.core.archiveRun;
+        if (typeof archive !== 'function') {
+            throw new Error('Run archival needs wicked-core-ts >= 0.6.2; this build does not support it');
+        }
+        // JSON-encoded bool by contract (parse, never truthiness-test — 'false' is truthy).
+        return JSON.parse(await archive.call(this.core, runId, archived, note ?? null));
+    }
     /** Inject an operator message into a run's active PTY worker(s). target="all" or a CLI key. */
     injectWorkerMessage(runId, message, target) {
         if (typeof this.core.injectWorkerMessage !== 'function') {
@@ -588,6 +782,87 @@ export class CoreAdapter {
     async workOutput(unitId) {
         return JSON.parse(await this.core.workOutput(unitId));
     }
+    // ── Projects (DES-PROJECT-001) ──────────────────────────────────────────────
+    // 1:1 maps of the 0.6.0 engine surface. Writes ride the single-writer actor;
+    // reads are read-only store opens inside the addon. Every method throws
+    // ProjectsUnsupportedError on a pre-0.6.0 addon (routes answer 501).
+    /** True when the installed addon carries the project surface (0.6.0+). */
+    projectsSupported() {
+        return typeof this.core.projectCreate === 'function';
+    }
+    requireProjects(fn, what) {
+        if (typeof fn !== 'function')
+            throw new ProjectsUnsupportedError(what);
+        return fn;
+    }
+    async projectCreate(name, description) {
+        const fn = this.requireProjects(this.core.projectCreate, 'Creating a project');
+        return JSON.parse(await fn.call(this.core, name, description ?? null));
+    }
+    async projectUpdate(id, patch) {
+        const fn = this.requireProjects(this.core.projectUpdate, 'Updating a project');
+        return JSON.parse(await fn.call(this.core, id, patch.name ?? null, patch.description ?? null, patch.status ?? null));
+    }
+    /** Every stored project (all statuses, newest first). The `default` project is NOT here — the
+     *  route layer synthesizes it (ADR §7: computed, never stored). */
+    async projectList() {
+        const fn = this.requireProjects(this.core.projectList, 'Listing projects');
+        return JSON.parse(await fn.call(this.core));
+    }
+    async projectGet(id) {
+        const fn = this.requireProjects(this.core.projectGet, 'Reading a project');
+        return JSON.parse(await fn.call(this.core, id));
+    }
+    async projectMembers(projectId) {
+        const fn = this.requireProjects(this.core.projectMembers, 'Listing project members');
+        return JSON.parse(await fn.call(this.core, projectId));
+    }
+    /** Attach a member. `created:false` = the idempotent duplicate hit (emit no event for it). */
+    async projectMemberAttach(projectId, kind, ref, meta, attachedBy) {
+        const fn = this.requireProjects(this.core.projectMemberAttach, 'Attaching a project member');
+        return JSON.parse(await fn.call(this.core, projectId, kind, ref, meta !== undefined ? JSON.stringify(meta) : null, attachedBy ?? null));
+    }
+    /** Detach (tombstone). `false` = no such live member on that project (the route's 404). */
+    async projectMemberDetach(projectId, memberId) {
+        const fn = this.requireProjects(this.core.projectMemberDetach, 'Detaching a project member');
+        return JSON.parse(await fn.call(this.core, projectId, memberId));
+    }
+    /** The projects holding a live `(kind, ref)` membership — the run→project reverse read. */
+    async memberProjects(kind, ref) {
+        const fn = this.requireProjects(this.core.memberProjects, 'Resolving a member’s projects');
+        return JSON.parse(await fn.call(this.core, kind, ref));
+    }
+    /**
+     * Durable interaction requests (ADR §5.3), newest first — or `null` when this addon predates
+     * the binding (the `runEvents` convention: a missing capability must stay distinguishable from
+     * "no open prompts", or the caches' fallback chain misreports upgrades as empty inboxes).
+     */
+    async interactionRequests(sessionId, status) {
+        if (typeof this.core.interactionRequests !== 'function')
+            return null;
+        return JSON.parse(await this.core.interactionRequests(sessionId ?? null, status ?? null));
+    }
+    // ── The foundation record (ADR §3.2): charter writes + record probes ────────
+    /** Capture a memory at a STRICT `kind:id[/…]` scope (the engine refuses malformed segments). */
+    async captureMemory(content, scope) {
+        const fn = this.requireProjects(this.core.captureMemory, 'Capturing a memory');
+        await fn.call(this.core, content, scope);
+    }
+    /** Memories within `scope`'s subtree, newest first — the ADR's memory.coverage probe. */
+    async listMemories(scope, limit) {
+        const fn = this.requireProjects(this.core.listMemories, 'Listing memories');
+        return JSON.parse(await fn.call(this.core, scope, limit));
+    }
+    /** Ingest a document (title + chunks) into the knowledge store. Returns the chunk count. */
+    async ingestKnowledge(title, chunks) {
+        const fn = this.requireProjects(this.core.ingestKnowledge, 'Ingesting knowledge');
+        return JSON.parse(await fn.call(this.core, title, JSON.stringify(chunks)));
+    }
+    /** Recall up to `k` knowledge chunks relevant to `query`. */
+    async recallKnowledge(query, k) {
+        const fn = this.requireProjects(this.core.recallKnowledge, 'Recalling knowledge');
+        return JSON.parse(await fn.call(this.core, query, k));
+    }
     // ── Chat sessions (core#134 / crew#165) ────────────────────────────────────
     async chatOpen(chatId, clis, cwd) {
         const raw = await this.core.chatOpen(chatId, JSON.stringify(clis), cwd ?? null);
@@ -968,6 +1243,32 @@ export class CoreAdapter {
         // regression FINDING-084's first attempted fix caused.
         await writeFile(join(dir, `${def.id}.json`), JSON.stringify(overlayDef, null, 2), 'utf8');
     }
+    /**
+     * Arm a PER-RUN composed workflow def (crew#293 deliver, crew#311 deliverable floor) with the
+     * engine — hot registration
+     * ONLY. Deliberately neither of the other two paths:
+     *   - not `registerWorkflow()`: the composed def must not enter `userWorkflows` or the overlay
+     *     dir — it is launch input for one run, and persisting it would grow the catalog and the
+     *     overlay dir by one entry per delivered run;
+     *   - not `_writeBuiltinOverlay()`: same reason, no file.
+     * The engine's `registerWorkflow` binding validates the def server-side and makes it visible
+     * to the next `launchRun` with no restart — exactly the lifetime a per-run def needs. (The
+     * def is consumed at PLANNING time; a later daemon restart resumes the run from its persisted
+     * units, so the in-memory registration expiring with the process is fine.)
+     */
+    async _armPerRunWorkflow(def) {
+        const core = this.core;
+        const register = core['registerWorkflow'];
+        if (typeof register !== 'function') {
+            // Same doctrine as registerWorkflow(): no validator ⇒ refuse loudly. Silently launching
+            // the BASE workflow instead would drop the delivery the caller explicitly asked for —
+            // and, for crew#311, would drop the deliverable floor, launching a run that can once
+            // again report done over an artifact that was never written.
+            throw new Error('deliver: "pr" / requireDeliverables need a wicked-core build with the registerWorkflow ' +
+                'binding — the per-run workflow cannot be armed');
+        }
+        await register.call(this.core, JSON.stringify(def));
+    }
     /**
      * Register a user-authored workflow: persist to the Rust workflow overlay dir
      * (`~/.config/wicked-core/workflows/<id>.json` or `$WICKED_WORKFLOWS_DIR`),
@@ -1070,6 +1371,24 @@ export class CoreAdapter {
                 if (typeof v !== 'number' || !Number.isInteger(v) || v < 1 || v > 10000)
                     delete parsed.graphNodeLimit;
             }
+            // workerStallMinutes (crew#287): positive minutes; a hand-edited zero/negative/NaN would
+            // make the stall watchdog fire on every sweep, so drop it and fall back to the default.
+            if ('workerStallMinutes' in parsed) {
+                // Same bounds the PUT /settings route enforces (integer, 1..1440) — a hand-edited
+                // settings.json must not enable values the API rejects (Copilot on #301).
+                const v = parsed.workerStallMinutes;
+                if (typeof v !== 'number' || !Number.isInteger(v) || v < 1 || v > 1440) {
+                    delete parsed.workerStallMinutes;
+                }
+            }
+            // worker_config_root (seat sign-in): absolute path or "" (= engine default). A hand-edited
+            // relative path is dropped rather than exported as WICKED_WORKER_HOME, where the engine
+            // would resolve it against an arbitrary spawn cwd.
+            if ('worker_config_root' in parsed) {
+                const r = parsed.worker_config_root;
+                if (typeof r !== 'string' || (r !== '' && !isAbsolute(r)))
+                    delete parsed.worker_config_root;
+            }
             return { ...DEFAULT_SETTINGS, ...parsed };
         }
         catch {