wicked-crew 0.7.39 → 0.7.45

package/dist/core/adapter.js

@@ -1,4 +1,5 @@
 import { createRequire } from 'node:module';
+import { attachEngineBus, detachEngineBus } from './bus.js';
 import { mkdir, access, readFile, writeFile, chmod, rm } from 'node:fs/promises';
 import { existsSync, readdirSync, readFileSync, renameSync } from 'node:fs';
 import { join, dirname, resolve, isAbsolute, relative, sep } from 'node:path';
@@ -8,11 +9,14 @@ import { randomUUID } from 'node:crypto';
 import { DEFAULT_SETTINGS } from './types.js';
 import { BASE_SKILL_REF_SHAPE } from '../skills/base-skill.js';
 import { execCapped } from './exec.js';
-import { BUG_FIX_SWEEP_INSTRUCTIONS, composeDeliverWorkflow, DELIVER_PHASE_ID, EVIDENCE_FLOOR_PIN } from './deliver.js';
+import { BUG_FIX_SWEEP_INSTRUCTIONS, composeDeliverWorkflow, DELIVER_PHASE_ID, deliverPresetStep, deliverRepoFor, EVIDENCE_FLOOR_PIN, isGitHubLogin, readDeliverOriginUrl } from './deliver.js';
 import { engineCampaignDef, engineRosterJson } from './engine-roster.js';
 import { QE_AUTHOR_TESTS_WORKFLOW_DEF } from '../qe/author-workflow.js';
 import { CAMPAIGN_WORKFLOW_PREFIX } from '../campaigns/plan.js';
-import { composeDeliverableFloor, DELIVERABLE_FLOOR_PHASE_ID } from './deliverable-floor.js';
+import { composeDeliverableFloor } from './deliverable-floor.js';
+import { isSyntheticWorkflowId, resolveRunIdentity, verifiedEvidenceCatalog, wireIdentity, withPresetSystemFlag, withSystemFlag, } from './run-identity.js';
+/** A run in one of these statuses never records another launch frame. */
+const TERMINAL_RUN_STATUSES = new Set(['completed', 'cancelled', 'failed']);
 import { resolveProjectGraphBinding } from '../projects/graph.js';
 import { applyGovernanceStoreEnv, isStoreSpec } from './governance-store.js';
 /** Resolved path under the user's home directory. */
@@ -115,6 +119,44 @@ export function readOverlayWorkflows(dir, builtinIds) {
     }
     return out;
 }
+/** Ask CORE's parser which drop-in defs it will actually honour (crew#718).
+ *
+ * {@link readOverlayWorkflows} checks a `{id, phases[]}` shape, which is not the engine's contract:
+ * `WorkflowRegistry::load_dir` runs `refuse_reserved_id` + `WorkflowDef::validate()` and SKIPS the
+ * file it rejects, loudly, on the daemon's stderr. So the catalog listed defs the engine had thrown
+ * away at boot and the launch then 400'd `unknown workflow` — the MCP S8 dogfood's F-3, on a
+ * hand-authored drop-in whose `executes_code` phase pinned no validator ("gate evaluates nothing").
+ *
+ * The same doctrine {@link CoreAdapter.registerWorkflow} states for the WRITE path applies here:
+ * core's parser is the authority, so it is what we ask. Enumerating `validate()`'s rules in
+ * TypeScript would be a second copy of core's schema — the drift that produced this defect.
+ * `register` is the engine's `registerWorkflow` binding, which validates before it registers and
+ * is idempotent on id, so re-offering a def the engine already loaded at boot is a same-content
+ * overwrite; a def added to the dir after boot becomes launchable rather than being listed and
+ * refused.
+ *
+ * `is_system` is stripped first, exactly as the two write paths do: it is crew's own display flag
+ * and core's strict def parser rejects the key.
+ *
+ * Pure (no adapter state) so it is unit-testable without spawning a Core, like
+ * {@link readOverlayWorkflows}.
+ */
+export async function judgeOverlayWorkflows(defs, register) {
+    const accepted = [];
+    const refused = [];
+    for (const def of defs) {
+        const overlayDef = { ...def };
+        delete overlayDef.is_system;
+        try {
+            await register(JSON.stringify(overlayDef));
+            accepted.push(def);
+        }
+        catch (err) {
+            refused.push({ id: def.id, reason: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return { accepted, refused };
+}
 // The native addon is a CommonJS cdylib (`index.node`); load it with a CJS
 // require even though this daemon is ESM. This module is the ONLY place that
 // touches wicked-core-ts (DES-STUDIO-001 §5.2/§5.3), so the FINALIZING
@@ -188,6 +230,23 @@ function locateWickedCoreExe() {
     return candidates.find((p) => existsSync(p));
 }
 const { Core } = require('wicked-core-ts');
+/**
+ * Does the linked engine carry DES-TEAMING-002 T3's plan launch (`Core.supportsPlanLaunch`)? A
+ * plan handed to an addon without it would be silently ignored — the run launches as free text,
+ * with no `plan.proposed` and no `plan_approval` gate — so every plan path fails CLOSED on this.
+ * Read at call time (not cached): the addon is resolved once, but tests swap the static.
+ */
+export function engineSupportsPlanLaunch() {
+    return typeof Core.supportsPlanLaunch === 'function' && Core.supportsPlanLaunch() === true;
+}
+/** A plan path on an engine without the plan approval gate (maps to 501 at the HTTP boundary). */
+export class PlanLaunchUnsupportedError extends Error {
+    constructor(what) {
+        super(`${what} needs a wicked-core-ts that carries the plan approval gate (Core.supportsPlanLaunch, ` +
+            `DES-TEAMING-002 T3); the installed addon would drop the plan and run the launch ungated`);
+        this.name = 'PlanLaunchUnsupportedError';
+    }
+}
 /**
  * Does the installed wicked-core-ts addon understand `LaunchOptions.extraWriteRoots` (≥ 0.6.1)?
  *
@@ -267,15 +326,16 @@ function addonAtLeast(maj, min, pat) {
     }
 }
 // ── 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.
+// Static mirrors of wicked-core workflow defs: feature, bug, migration and domain-extraction, plus
+// crew's own defs. `chat` and `onboarding` are engine built-in PRESETS (DES-TEAMING-002 M3/M4),
+// launched by the same name with no def here; `survey-repo`, `memories`, `domain-graph-slice` and
+// `collab` are deleted (nothing launched them).
 // Swap for `this.core.listWorkflowsJson()` / `this.core.getWorkflowJson(id)` once
 // the wicked-core-ts NAPI methods land.
 /**
  * The ids wicked-core seeds itself, in `WorkflowRegistry::with_defaults()`.
  *
- * `launchRun`'s generic drop-in overlay write SKIPS every id in this set (`onboarding` is written
- * by the onboarding path instead — see the end of this comment, it is the one deliberate exception).
+ * `launchRun`'s generic drop-in overlay write SKIPS every id in this set.
  * A file in that dir shadows the compiled built-in
  * *wholesale* — `register` overwrites by id and `load_dir` runs after `with_defaults` — so writing
  * this hand-transcribed mirror over the real def silently replaces it with a copy missing whatever
@@ -284,16 +344,10 @@ function addonAtLeast(maj, min, pat) {
  * `bug.verify` and `migration.verify` — the entire content of core's gate-floor change, undone by a
  * file write, with no error and a workflow still reporting the right id and phases (FINDING-049).
  *
- * The write exists for the ids core does NOT seed (chat, survey-repo, domain-graph-slice,
- * memories, domain-extraction): for those the overlay is the only reason they resolve at all, so
- * it stays.
- *
- * The exception: `onboarding` is core-seeded AND still written, by the onboarding path rather than
- * by the generic one. Deliberate — that def's executor cmds are baked with runtime `--db` paths, so
- * it shadows core's copy with a real customization rather than a stale transcription. It is the one
- * shadow that earns its keep, and the reason this set gates the generic write specifically.
+ * The write exists for the ids core does NOT seed (domain-extraction and crew's own defs): for
+ * those the overlay is the only reason they resolve at all, so it stays.
  */
-const CORE_SEEDED_WORKFLOWS = new Set(['feature', 'bug', 'migration', 'onboarding', 'collab']);
+const CORE_SEEDED_WORKFLOWS = new Set(['feature', 'bug', 'migration']);
 // `EVIDENCE_FLOOR_PIN` (imported from ./deliver.js, defined once) is carried on the Evaluator phase
 // of feature/bug/migration AND, since wicked-core F-039, on their code-writing Creator phases
 // (`build`/`fix`/`execute`) — so the gate that was supposed to make the change re-derives its diff
@@ -305,33 +359,9 @@ const CORE_SEEDED_WORKFLOWS = new Set(['feature', 'bug', 'migration', 'onboardin
 // `tests/armed-workflow-served.test.ts` and `tests/builtin-overlay-shadow.test.ts` fail loudly
 // the moment core's defs move. As of FINDING-049 these defs are never written to core's overlay dir
 // (see CORE_SEEDED_WORKFLOWS).
+// `is_system` is NOT spelled on these defs: `withSystemFlag` stamps it from `SYSTEM_WORKFLOWS`
+// (core/run-identity.ts), the one list keyed by name that also classifies served runs (seam X2).
 export const BUILTIN_WORKFLOWS = [
-    {
-        id: 'chat',
-        is_system: true,
-        phases: [
-            { id: 'explore', kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-        ],
-    },
-    {
-        id: 'onboarding',
-        is_system: true,
-        phases: [
-            { id: 'index', executor: { type: 'tool', cmd: ['wicked-estate', 'index', '{repo_root}', '--db', '{code_graph_db}'] }, kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'annotate', executor: { type: 'tool', cmd: ['wicked-estate', 'clusters', '--annotate', '--db', '{code_graph_db}'] }, kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['index'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            // index → annotate, and NOT a third `domain` phase running `wicked-core domain-graph`. That
-            // phase could never pass: domain-graph fails closed below 1.0 front-half coverage, and nothing
-            // in this workflow annotates a single symbol, so coverage was 0.0 on every repo — every
-            // registration ended sessionFailed after the two phases that matter had both succeeded
-            // (FINDING-068). domain-graph belongs to `domain-extraction`, downstream of the agentic
-            // extract+coverage phases that produce its precondition. Mirrors core's `onboarding_def()`.
-            //
-            // The `{repo_root}` / `{code_graph_db}` placeholders are core's, substituted per run from the
-            // launch's `repoRef` (wicked-core#179). This package used to bake absolute paths in here and
-            // write the result to one shared overlay file per launch — which concurrent registrations
-            // raced, indexing one repo's tree under another repo's name (FINDING-075, #196).
-        ],
-    },
     {
         id: 'feature',
         phases: [
@@ -365,22 +395,6 @@ export const BUILTIN_WORKFLOWS = [
             { id: 'cleanup', kind: 'build', gate_type: null, gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['verify'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
         ],
     },
-    {
-        // MUST stay byte-identical to wicked-core/workflows/survey-repo.json — crew's overlay write is the
-        // ONLY def the engine resolves at runtime (core does not seed survey-repo), so a stale mirror here
-        // silently runs the OLD def. The pre-fix mirror carried 3 phases with no `instructions` and no
-        // `synthesize`, so survey-repo ran 3 near-identical prompts and produced no run-level synthesis —
-        // exactly FINDING-011, still live because the fix only landed in the core JSON the runtime ignores.
-        // Guarded by builtin-overlay-shadow.test.ts (survey-repo is now in MIRRORED_IDS).
-        id: 'survey-repo',
-        is_system: true,
-        phases: [
-            { id: 'structure', kind: 'recon', instructions: 'Map the repository layout only: top-level directories, entry points, and where source, tests, config, and docs live. Do not analyze languages, dependencies, or conventions — later phases cover those.', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'stack', kind: 'recon', instructions: 'Identify the technology stack from the manifests (package.json, Cargo.toml, pyproject.toml, ...): languages, frameworks, build tools, key dependencies. Build on the structure summary provided as prior context; do not re-map the layout.', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['structure'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'conventions', kind: 'recon', instructions: 'Identify the working conventions: naming, module boundaries, test placement and style, lint/format configuration, CI expectations. Build on the prior phases\' outputs provided as context; do not re-survey structure or stack.', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['stack'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'synthesize', kind: 'recon', instructions: 'Do not re-survey the repository. Merge the three prior phase outputs provided as context into one coherent survey — structure, then stack, then conventions — resolving overlaps and flagging any contradictions between them.', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['structure', 'stack', 'conventions'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-        ],
-    },
     {
         // capture-learnings (DES-MEM-FACETED-001 write side, onboarding): survey a just-indexed repo,
         // then propose its durable learnings — BOTH faceted MEMORIES and repo POLICIES — as inert estate
@@ -400,7 +414,7 @@ export const BUILTIN_WORKFLOWS = [
         //     SINGLE `capture` phase emits both from the one shared understanding — splitting derive-
         //     memories / derive-policies would re-run a council over the same context for no new evidence.
         //   • Reuse already lives below the run: the reusable unit is the SKILL (and hotspot-read is
-        //     already a reusable capability via `wicked-garden-search`; survey via `survey-repo`).
+        //     already a reusable capability via `wicked-garden-search`).
         //
         // The METHOD lives in the garden skill `wicked-garden-repo-learn`, referenced per-phase by
         // `skill_ref` — the engine emits only a short `Invoke your skill "wicked-garden:repo-learn"…`
@@ -419,28 +433,16 @@ export const BUILTIN_WORKFLOWS = [
         // so proposals land in the same queue the studio Memories/Policies surfaces review. Onboarding IS
         // about the repo, so the skill tags learnings `repo:`/`project:`.
         id: 'capture-learnings',
-        is_system: true,
         phases: [
             { id: 'churn', kind: 'recon', instructions: "Phase 1/3 CHURN: produce a ranked list of this repo's most actively-changed files and directories over the last ~12 months, plus the repo's real name (manifest or git remote) and parent project. Use the skill's bounded/sampled git-churn method — never stream the whole history. Do not read code deeply yet; the next phase targets these areas.", gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: 'wicked-garden-repo-learn', allowed_skills: [], validator_pin: null },
             { id: 'hotspots', kind: 'recon', instructions: "Phase 2/3 HOTSPOTS: cross-reference the prior churn ranking with wicked-estate hotspot / blast-radius signals to find the load-bearing code, then READ it through the estate shim (`wicked-garden run scripts/_estate_client.py --readonly call …`, the skill's grounding path) to build a real technical understanding of how the system fits together — not a file listing. Reuse wicked-garden-search for the hotspot signals; follow the skill.", gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['churn'], role: 'neutral', skill_ref: 'wicked-garden-repo-learn', allowed_skills: [], validator_pin: null },
-            { id: 'capture', kind: 'build', instructions: "Phase 3/3 CAPTURE: from the prior churn + hotspot understanding, submit durable learnings as estate proposals through the shim's `propose` per the skill's capture contract — BOTH memories (facts / how-it-works) and policies (enforced conventions), one proposal per item, tagged repo/project. Each is inert until human review; never include secrets or personal data; capturing nothing is acceptable.", gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['hotspots'], role: 'creator', skill_ref: 'wicked-garden-repo-learn', allowed_skills: [], validator_pin: null },
-        ],
-    },
-    {
-        id: 'domain-graph-slice',
-        is_system: true,
-        phases: [
-            { id: 'identify', kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'extract', kind: 'build', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['identify'], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'validate', kind: 'review', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['extract'], role: 'evaluator', skill_ref: null, allowed_skills: [], validator_pin: null },
-        ],
-    },
-    {
-        id: 'memories',
-        is_system: true,
-        phases: [
-            { id: 'gather', kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'store', kind: 'build', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['gather'], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
+            // (BC-80, wicked-core#535) `requires_capture_report`: the engine's capture-report floor reads
+            // the phase's output marker, so a capture run whose skill loaded and never ran can no longer
+            // report `completed` with 0 proposals — a missing marker, a failed submission and proposals
+            // derived but never submitted each deny into the human gate. An honest 0 passes. The
+            // instruction MANDATES the marker; garden's repo-learn skill carries the same contract, and
+            // the counts land on the unit (`capture_report`), which `GET /runs/:id` serves.
+            { id: 'capture', kind: 'build', instructions: "Phase 3/3 CAPTURE: from the prior churn + hotspot understanding, submit durable learnings as estate proposals through the shim's `propose` per the skill's capture contract — BOTH memories (facts / how-it-works) and policies (enforced conventions), one proposal per item, tagged repo/project. Each is inert until human review; never include secrets or personal data. END with `wicked-capture-report {\"derived\": N, \"submitted\": M, \"failed\": K}` — always, even on a degrade or a legitimate 0 (which is acceptable).", gate_type: 'value', gate: 'auto', executes_code: false, requires_capture_report: true, verified_evidence: false, required_deliverables: [], depends_on: ['hotspots'], role: 'creator', skill_ref: 'wicked-garden-repo-learn', allowed_skills: [], validator_pin: null },
         ],
     },
     {
@@ -458,26 +460,15 @@ export const BUILTIN_WORKFLOWS = [
         // as the launch's extra write root) — because parsing the proposal out of prose transcript
         // is a fallback, not a design (the landing reads the file first).
         //
-        // Crew-authored drop-in (like `chat`): NOT in CORE_SEEDED_WORKFLOWS, so launchRun's
+        // Crew-authored drop-in: NOT in CORE_SEEDED_WORKFLOWS, so launchRun's
         // `_writeBuiltinOverlay` write is the only way core resolves the id — the same delivery
         // mechanism every crew drop-in uses.
         id: 'steering-author',
-        is_system: true,
         phases: [
             { id: 'analyze', kind: 'recon', instructions: 'Read the operator intent and every file or directory listed in the problem statement. Identify candidate steering rules: durable, prescriptive statements a coding agent must follow, each classified into one steering type (architecture, development, security, testing, operations, compliance, design-ux). For each candidate note the statement, steering type, severity, and the evidence in the source material. Analysis only — do not write any rule to any store, and do not emit final rule JSON yet.', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
             { id: 'propose', kind: 'recon', instructions: 'From the prior analysis, emit the PROPOSED steering rules as one JSON array. Each entry is a conformance-rule object: id (PAT-<digits> for rule_type "pattern", POL-<digits> for "policy"), rule_type, statement, severity (info|warn|error|critical), confidence (a NUMBER 0..1), steering_type (default to the type named in the problem statement), provenance {"source":"chat"}, and — only where the source material supports them — the enforcement fields applies_to (array of phase tokens or globs), excludes, weight, obligations (array of strings), criteria (ONE string, never a list). Omit targets, effect and trigger unless you can express them in the store schema exactly: targets is a {language, layer, framework} facet OBJECT (never a file list — files belong in applies_to), and trigger is a structured condition object (never prose). SAVE that JSON array (bare array, no prose, no code fences) to the absolute proposal file path named in the problem statement (create parent directories if needed, overwrite if present), AND include the same array in your reply for the human reviewer. This output is a PROPOSAL for the human gate: the proposal file is an artifact for review, and rules land in the governance store only after approval, written crew-side — do not write any rule to any store yourself.', gate_type: 'value', gate: { human_confirm: { unconditional: true } }, executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['analyze'], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
         ],
     },
-    {
-        id: 'collab',
-        is_system: true,
-        phases: [
-            { id: 'propose', kind: 'recon', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: [], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'critique', kind: 'review', gate_type: 'value', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['propose'], role: 'evaluator', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'revise', kind: 'recon', gate_type: 'strategy', gate: 'auto', executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['critique'], role: 'creator', skill_ref: null, allowed_skills: [], validator_pin: null },
-            { id: 'verdict', kind: 'review', gate_type: 'value', gate: { human_confirm: { unconditional: false } }, executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['revise'], role: 'evaluator', skill_ref: null, allowed_skills: [], validator_pin: null },
-        ],
-    },
     // The governed test-authoring workflow (wave 6 — F-7R2-003/004/005/012/014/015, R4-r2): recon →
     // author (creator, evidence-floor pinned) → verify (a TOOL phase that RUNS every produced test
     // under the repository's own harness and fails the unit when one fails or never ran) → review
@@ -527,7 +518,7 @@ export const BUILTIN_WORKFLOWS = [
             { id: 'domain-graph', executor: { type: 'tool', cmd: ['wicked-core', 'domain-graph', '--db', '{code_graph_db}', '--out', 'requirements_graph.json'] }, kind: 'build', gate_type: 'strategy', gate: { human_confirm: { unconditional: false } }, executes_code: false, verified_evidence: false, required_deliverables: [], depends_on: ['coverage'], role: 'neutral', skill_ref: null, allowed_skills: [], validator_pin: null },
         ],
     },
-];
+].map(withSystemFlag);
 /**
  * Chat is not available in this deployment at all — a capability gap, never a bad request.
  *
@@ -557,6 +548,26 @@ export class ProjectsUnsupportedError extends Error {
         this.name = 'ProjectsUnsupportedError';
     }
 }
+/**
+ * The preset bindings (DES-TEAMING-002 seam C2) are not in the installed `wicked-core-ts`. The
+ * routes answer 501 ("upgrade the engine"), never 400.
+ */
+export class PresetsUnsupportedError extends Error {
+    constructor(what) {
+        super(`${what} is not supported by this wicked-core build (needs the wicked-core-ts release carrying presets)`);
+        this.name = 'PresetsUnsupportedError';
+    }
+}
+/**
+ * A team binding (DES-TEAMING-002 T8) is not in the installed `wicked-core-ts`. The routes answer
+ * 501 ("upgrade the engine"), never 400.
+ */
+export class TeamUnsupportedError extends Error {
+    constructor(what, binding) {
+        super(`${what} is not supported by this wicked-core build (needs the wicked-core-ts binding Core.${binding})`);
+        this.name = 'TeamUnsupportedError';
+    }
+}
 /**
  * `resolveElicitation` is not available in this deployment — the installed `wicked-core-ts`
  * predates the binding (< 0.7.2). Feature-detected by method presence, the
@@ -704,6 +715,38 @@ function quarantineStaleOnboardingOverlay() {
             `whatever repo the run names (FINDING-075).`);
     }
 }
+/**
+ * The drop-in ids crew wrote into the overlay dir before DES-TEAMING-002 wave 1 retired them:
+ * `chat` is the engine's built-in preset now, and `survey-repo`, `memories` and
+ * `domain-graph-slice` are deleted. Exported for the quarantine test.
+ */
+export const RETIRED_OVERLAY_IDS = ['chat', 'survey-repo', 'memories', 'domain-graph-slice'];
+/**
+ * Park the overlay files older crews wrote for {@link RETIRED_OVERLAY_IDS}.
+ *
+ * `_writeBuiltinOverlay` wrote each of these on first launch, and the overlay dir is PERSISTENT: on
+ * an upgraded host the engine's startup `load_dir` would keep the deleted workflows launchable, and
+ * `hydrateFromOverlay` would serve them on `GET /workflows` as user workflows, where they are no
+ * longer on the system list (review of wicked-crew#688). Renamed, not deleted, like the onboarding
+ * quarantine above: the evidence stays, and a name retired by operator decision (2026-09-26) is
+ * not a workflow any more — save a preset instead.
+ */
+function quarantineRetiredOverlays() {
+    for (const id of RETIRED_OVERLAY_IDS) {
+        const stale = join(workflowOverlayDir(), `${id}.json`);
+        if (!existsSync(stale))
+            continue;
+        const parked = `${stale}.retired-des-teaming-002`;
+        try {
+            renameSync(stale, parked);
+            console.warn(`[workflows] parked ${stale} → ${parked}: \`${id}\` is retired (DES-TEAMING-002 wave 1` +
+                `${id === 'chat' ? '; chat is the engine\'s built-in preset' : '; the workflow is deleted'}).`);
+        }
+        catch (err) {
+            console.error(`[workflows] FAILED to park the retired overlay ${stale}: ${err instanceof Error ? err.message : String(err)}. The engine will keep resolving \`${id}\` from it until it is removed by hand.`);
+        }
+    }
+}
 /** 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.
  *
@@ -737,8 +780,17 @@ export class CoreAdapter {
     dbPath;
     /** `true` when this adapter armed the event-driven exec seam (for readiness/reporting). */
     engineExec;
-    /** The bus db the exec seam runs over when armed (else `undefined`). */
+    /** The bus db handed to the engine (`WICKED_BUS_DB`; exec mediation runs over it when armed), or
+     *  `undefined` when this adapter handed none. */
     busDbPath;
+    /** Why the engine has no usable bus — the boot probe's failure, or the engine could not arm its
+     *  bus bridge on the handed bus within its bound — else `null`. */
+    busUnavailable;
+    /** The bus file whose seams are off because the linked engine has no `Core.busEmit`/`busRead`
+     *  (wicked-core#631) — `/health.warnings` says so — else `null`. */
+    busSeamsOff = null;
+    /** The engine's bus calls, attached for `busDbPath` (core/bus.ts); `null` without a bus. */
+    engineBus = null;
     /**
      * `true` when this adapter drives the DETERMINISTIC OFFLINE engine (`Core.spawnStub`) rather
      * than the production one — i.e. the `StubDispatcher` (every seat votes for the first roster
@@ -797,6 +849,12 @@ export class CoreAdapter {
     launchRoster() {
         return this.rosterProvider !== null ? this.rosterProvider() : CoreAdapter.roster();
     }
+    /** {@link launchRoster} after the seats' login checks answered (bounded, crew#645): an expired
+     *  login reads signed out before the launch routes work to it. */
+    async readyLaunchRoster() {
+        await this.rosterProvider?.ready?.();
+        return this.launchRoster();
+    }
     constructor(opts) {
         // Arm the EVENT-DRIVEN execution-mediation seam BEFORE spawning the Core: the Rust actor reads
         // `WICKED_BUS_EXEC` + `WICKED_BUS_DB` from the process env at spawn time (wicked-core actor::run),
@@ -807,16 +865,29 @@ export class CoreAdapter {
         // BEFORE the Core spawns: the actor reads the overlay dir at startup, so a stale
         // `onboarding.json` has to be out of the way by then or it shadows the built-in def.
         quarantineStaleOnboardingOverlay();
+        quarantineRetiredOverlays();
+        // DES-TEAMING-002 T0: the engine gets the daemon's bus on EVERY boot (`WICKED_BUS_DB`); exec
+        // mediation stays a separate switch (`WICKED_BUS_EXEC`), set only under `engineExec`, and the
+        // engine's bus gate-judge path follows that switch — never the mere presence of a bus.
         const armExec = opts.engineExec === true;
-        if (armExec) {
-            if (!opts.busDbPath || opts.busDbPath.length === 0) {
-                throw new Error('engineExec requires busDbPath (the wicked-bus db to mediate execution over)');
-            }
-            process.env['WICKED_BUS_EXEC'] = '1';
-            process.env['WICKED_BUS_DB'] = opts.busDbPath;
+        const busDbPath = opts.busDbPath !== undefined && opts.busDbPath.length > 0 ? opts.busDbPath : undefined;
+        if (armExec && busDbPath === undefined) {
+            throw new Error('engineExec requires busDbPath (the wicked-bus db to mediate execution over)');
         }
+        // process.env matches the decision EXACTLY before the engine spawns: the engine reads both
+        // variables itself, so an inherited value the decision did not hand it (an unopenable bus crew
+        // declined, an exec switch crew did not arm) would otherwise reach it anyway — fail-open.
+        if (busDbPath !== undefined)
+            process.env['WICKED_BUS_DB'] = busDbPath;
+        else
+            delete process.env['WICKED_BUS_DB'];
+        if (armExec)
+            process.env['WICKED_BUS_EXEC'] = '1';
+        else
+            delete process.env['WICKED_BUS_EXEC'];
         this.engineExec = armExec;
-        this.busDbPath = armExec ? opts.busDbPath : undefined;
+        this.busDbPath = busDbPath;
+        this.busUnavailable = busDbPath === undefined ? (opts.busUnavailable ?? null) : null;
         // Give the Rust actor the path to the wicked-core standalone binary so the gate-hook
         // command works when wicked-core is loaded as a napi-rs addon (where current_exe()
         // returns the Node.js interpreter, not wicked-core). The actor checks WICKED_CORE_EXE
@@ -836,6 +907,34 @@ export class CoreAdapter {
         this.stub = opts.stub === true;
         this.dbPath = opts.dbPath;
         this.core = this.stub ? Core.spawnStub(opts.dbPath) : Core.spawn(opts.dbPath);
+        // DES-TEAMING-002 T0: `spawn` returns only once the engine's bus bridge is armed, or has given up
+        // within its bound. Not armed = the engine launches nothing from the bus: say so on the same
+        // `bus.unavailable` path as a bus crew could not open.
+        if (this.busDbPath !== undefined && typeof this.core.busBridgeState === 'function') {
+            const state = JSON.parse(this.core.busBridgeState());
+            if (state.state === 'not-armed') {
+                const reason = `the engine could not arm its bus bridge: ${state.reason ?? 'no reason given'}`;
+                this.busUnavailable = { dbPath: this.busDbPath, reason: state.reason ?? 'no reason given', kind: 'bridge_not_armed' };
+                console.error(`[crew] bus unavailable: ${this.busDbPath} (${reason}) — the engine launches nothing from the bus`);
+            }
+        }
+        // wicked-core#631: crew's seams write and read this bus through the engine that holds it —
+        // crew opens no SQLite of its own (core/bus.ts). An engine without the bus calls leaves every
+        // seam unarmed (each logs why); crew does not fall back to a second library.
+        if (this.busDbPath !== undefined) {
+            const core = this.core;
+            if (typeof core.busEmit === 'function' && typeof core.busRead === 'function') {
+                this.engineBus = {
+                    busEmit: (eventJson) => core.busEmit(eventJson),
+                    busRead: (afterId, limit, typePrefix, includeExpired) => core.busRead(afterId, limit, typePrefix, includeExpired),
+                };
+                attachEngineBus(this.busDbPath, this.engineBus);
+            }
+            else {
+                this.busSeamsOff = this.busDbPath;
+                console.error(`[crew] the linked wicked-core-ts has no Core.busEmit/busRead (wicked-core#631) — crew's bus seams on ${this.busDbPath} stay off; upgrade the engine`);
+            }
+        }
         // The ONE subscribe() for the process. Error-first callback (index.d.ts:56):
         // one JSON string per CoreEvent, in emission order. A throw in a listener is
         // isolated so one bad consumer can never stall the pump or the others.
@@ -866,6 +965,37 @@ export class CoreAdapter {
      * store FILE that does not exist yet counts as 0: nothing has landed, which is a number, not an
      * unknown (the engine's read-only open refuses a missing file, and that refusal is not "unknown").
      */
+    /**
+     * The engine's MCP broker gate (DES-MCP-TOOLS-001 §6 steps 3 and 8), or `null` on an addon without
+     * BOTH `Core.evaluateMcpCall` and `Core.evaluateMcpOutput`: the broker then refuses every call
+     * (`guard_error`), never runs one unjudged. Read at call time: tests swap the statics.
+     */
+    static mcpEngineGate() {
+        const call = Core.evaluateMcpCall;
+        const output = Core.evaluateMcpOutput;
+        if (typeof call !== 'function' || typeof output !== 'function')
+            return null;
+        return {
+            evaluateCall: (requestJson) => call.call(Core, requestJson),
+            evaluateOutput: (requestJson) => output.call(Core, requestJson),
+        };
+    }
+    /**
+     * The engine's tool list for a token's unit (`Core.listMcpTools`, DES-MCP-TOOLS-001 §8, slice S4),
+     * or `null` on an addon without it: `POST /mcp/tools` then answers 503, never an unjudged list.
+     * Read at call time: tests swap the static.
+     */
+    static mcpToolLister() {
+        const list = Core.listMcpTools;
+        if (typeof list !== 'function')
+            return null;
+        return (requestJson) => list.call(Core, requestJson);
+    }
+    /** Whether the linked engine follows the one-connection bus rule (`Core.busConnectionStats`,
+     *  DES-TEAMING-002 T0) and may therefore be handed the daemon's bus on every boot. */
+    static engineHoldsBusConnection() {
+        return typeof Core.busConnectionStats === 'function';
+    }
     static eventStoreCounter() {
         const fn = Core.eventStoreCount;
         if (typeof fn !== 'function')
@@ -967,21 +1097,36 @@ export class CoreAdapter {
      * never swallowed (codex round 6). A listener failing on `rejected` cannot un-launch anything;
      * the primary error keeps precedence and the secondary one is logged, not lost.
      */
-    async handedToEngine(kind, id, call) {
+    async handedToEngine(kind, id, call, workflow) {
         try {
-            this.notifyLaunch({ kind, id, status: 'handed' });
+            this.notifyLaunch({ kind, id, status: 'handed', ...(workflow !== undefined ? { workflow } : {}) });
         }
         catch (err) {
             this.releaseAfterFailure(kind, id, err);
             throw err;
         }
+        let out;
         try {
-            return await call();
+            out = await call();
         }
         catch (err) {
             this.releaseAfterFailure(kind, id, err);
             throw err;
         }
+        this.announceAccepted({ kind, id, status: 'accepted', ...(workflow !== undefined ? { workflow } : {}) });
+        return out;
+    }
+    /** Deliver `accepted` once the engine TOOK the launch. Never propagates: the launch already happened,
+     *  so a listener failure is logged and must not turn an accepted run into a rejected call. */
+    announceAccepted(notice) {
+        for (const listener of this.launchListeners) {
+            try {
+                listener(notice);
+            }
+            catch (err) {
+                console.warn(`[crew] launch ${notice.kind}:${notice.id} accepted, but a launch listener failed on it: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
     }
     /** Deliver `rejected` while a launch is already failing with `primary`: a secondary listener failure is logged, never masks the primary. */
     releaseAfterFailure(kind, id, primary) {
@@ -1021,8 +1166,84 @@ export class CoreAdapter {
             seatChipOnCreate: true,
         };
     }
+    /** Whether this engine carries the plan approval gate (DES-TEAMING-002 T3) — see
+     *  [`engineSupportsPlanLaunch`]. An instance method so a partial-stub adapter can say either. */
+    supportsPlanLaunch() {
+        return engineSupportsPlanLaunch();
+    }
+    /** (crew#549) The CONFIGURED deliver identity — the `deliverIdentityLogin` setting, read at
+     *  launch. Cached on the instance for the synchronous compose paths (`deliverStep`), refreshed
+     *  by every `launchRun`, so a `PUT /settings` takes effect on the next launch and a settings
+     *  read never sits on the launch path twice. `''` ⇒ nothing configured (`GH_ACCOUNT` decides).
+     *  A LOGIN only: no token is ever read here. */
+    deliverIdentityLogin = '';
+    async refreshDeliverIdentity() {
+        try {
+            this.deliverIdentityLogin = (await this.getSettings()).deliverIdentityLogin ?? '';
+        }
+        catch {
+            // A settings file that cannot be read leaves the identity unconfigured rather than
+            // failing the launch — the deliver script still cross-checks gh against git's credential.
+            this.deliverIdentityLogin = '';
+        }
+    }
+    /**
+     * The origin the deliver push will actually go to (F2) so the deliver GATE CARD says what will
+     * actually happen. The card used to promise "pushes its branch and opens a pull request"
+     * whatever the origin was — on a local path, an SSH, GitLab, ADO or Gitea remote, the phase
+     * pushed the branch and then died on `gh pr create`, so the operator had consented to a pull
+     * request that could not exist.
+     *
+     * RETURNED, never stashed on the adapter (codex review of the F2 PR, HIGH): two concurrent
+     * delivering launches on different repos would otherwise interleave their `await` with the
+     * synchronous composition that reads it, and one launch's card would name the other repo's
+     * origin. The value is launch-local from here on.
+     *
+     * ONE `git remote get-url --push` per delivering launch, in the registered repo's root (a run
+     * worktree shares its repo's remotes, and the worktree does not exist yet at compose time).
+     * `null` for everything that can go wrong — "could not read it" is not a licence to claim
+     * anything about it either way, and the card keeps its generic sentence. Only git's own "no such
+     * remote" becomes `''`, the one answer that licenses "there is no origin".
+     */
+    async resolveDeliverOrigin(repoRef) {
+        if (repoRef === null || repoRef === undefined || repoRef === '')
+            return null;
+        try {
+            const repos = await this.listRepos();
+            const hit = deliverRepoFor(repos, repoRef);
+            if (hit === undefined || hit.root_path === '')
+                return null;
+            return await readDeliverOriginUrl(hit.root_path);
+        }
+        catch {
+            // An engine that cannot list repos leaves the origin UNKNOWN — the card keeps its generic
+            // sentence rather than claim anything. `readDeliverOriginUrl` owns the git-side verdicts.
+            return null;
+        }
+    }
+    /** The launcher's `deliver` step for a plan (`name` null) or a preset launch (DES-TEAMING-002
+     *  §8.5): the engine appends it to the plan and puts it in the floor. */
+    deliverStep(name, phases, input, 
+    /** (F2) The origin this launch resolved — launch-local, never adapter state. */
+    originUrl) {
+        return deliverPresetStep(name, phases, input.sessionId, input.problem, {
+            repoRef: input.repoRef ?? null,
+            apiOrigin: this.deliverApiOrigin?.() ?? null,
+            revisesPr: input.revisesPr ?? null,
+            ghAccount: process.env['GH_ACCOUNT'] ?? null,
+            ghTokenPinned: typeof process.env['GH_TOKEN'] === 'string' && process.env['GH_TOKEN'] !== '',
+            originUrl,
+            deliverIdentity: this.deliverIdentityLogin,
+        });
+    }
     /** Launch an interactive, resumable run → the run id. */
     async launchRun(input) {
+        // (crew#549) Read the configured deliver identity BEFORE anything composes the deliver
+        // phase: the compose paths below are synchronous and bake it into the script.
+        await this.refreshDeliverIdentity();
+        // (F2) And the origin the push would go to — read once, for the gate card's target sentence.
+        // Only a delivering launch composes a deliver phase, so only a delivering launch pays for it.
+        const deliverOriginUrl = input.deliver === 'pr' ? await this.resolveDeliverOrigin(input.repoRef) : null;
         const opts = {
             problem: input.problem,
             sessionId: input.sessionId,
@@ -1117,7 +1338,45 @@ export class CoreAdapter {
             }
             opts.projectGraph = input.projectGraph;
         }
-        if (input.workflow !== undefined) {
+        if (input.plan !== undefined) {
+            // DES-TEAMING-002 T3: a user-composed plan is a COMMAND the engine owns end to end — it
+            // publishes `plan.proposed`, scores, floor-fills and gates it. Crew only forwards it, and
+            // refuses what it cannot forward faithfully rather than dropping it.
+            if (input.workflow !== undefined) {
+                throw new Error('a launch carries a plan or names a workflow (a preset), not both');
+            }
+            if ((input.requireDeliverables ?? []).length > 0) {
+                throw new Error('requireDeliverables with a plan is refused: the deliverable floor has no engine-side ' +
+                    'step yet — launch the plan without it');
+            }
+            if (!this.supportsPlanLaunch())
+                throw new PlanLaunchUnsupportedError('A plan launch');
+            opts.planJson = JSON.stringify(input.plan);
+            // T8: a delivering plan hands the engine its deliver step, exactly as a preset launch does.
+            if (input.deliver === 'pr') {
+                opts.deliverStepJson = JSON.stringify(this.deliverStep(null, [], input, deliverOriginUrl));
+            }
+        }
+        // DES-TEAMING-002 T3: a workflow that names a PRESET is a plan the engine floor-fills and gates.
+        // Crew never composes a per-run def over one (that def is no preset, so the launch would skip
+        // `plan_approval`): delivery rides the launch as the deliver STEP (`deliverStepJson`), and a
+        // deliverable floor — which has no engine-side step yet — is refused rather than composed.
+        const requireDeliverablesAll = input.requireDeliverables ?? [];
+        const namesPreset = input.workflow !== undefined &&
+            (input.deliver === 'pr' || requireDeliverablesAll.length > 0) &&
+            (await this.presetNamed(input.workflow, input.projectId)) !== null;
+        if (namesPreset && input.workflow !== undefined) {
+            if (requireDeliverablesAll.length > 0) {
+                throw new Error(`requireDeliverables on a preset launch ('${input.workflow}') is refused: the deliverable ` +
+                    'floor would have to be composed into a per-run def, which skips the plan_approval gate');
+            }
+            if (!this.supportsPlanLaunch())
+                throw new PlanLaunchUnsupportedError('Delivering a preset launch');
+            const step = this.deliverStep(input.workflow, this.getWorkflow(input.workflow)?.phases ?? [], input, deliverOriginUrl);
+            opts.deliverStepJson = JSON.stringify(step);
+            opts.workflow = input.workflow;
+        }
+        else 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
@@ -1179,6 +1438,12 @@ export class CoreAdapter {
                         revisesPr: input.revisesPr ?? null,
                         ghAccount: process.env['GH_ACCOUNT'] ?? null,
                         ghTokenPinned: typeof process.env['GH_TOKEN'] === 'string' && process.env['GH_TOKEN'] !== '',
+                        // F2 — the origin the push will actually go to, so the gate card cannot promise a
+                        // pull request on a remote that can never carry one.
+                        originUrl: deliverOriginUrl,
+                        // crew#549 — the configured deliver identity, baked into the script so the refusal
+                        // holds on a daemon started without GH_ACCOUNT exported.
+                        deliverIdentity: this.deliverIdentityLogin,
                     });
                 }
             }
@@ -1211,8 +1476,8 @@ export class CoreAdapter {
                 }
             }
         }
-        else if (input.deliver === 'pr') {
-            // Fail loud, not silent: dropping the option would run to completion with the caller
+        else if (input.deliver === 'pr' && input.plan === undefined) {
+            // (A plan carries its deliver step above.) 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');
         }
@@ -1224,7 +1489,7 @@ export class CoreAdapter {
             throw new Error('requireDeliverables requires a workflow — a free-text run has no def to append the ' +
                 'deliverable floor to');
         }
-        return this.handedToEngine('run', input.sessionId, () => this.core.launchRun(opts));
+        return this.handedToEngine('run', input.sessionId, () => this.core.launchRun(opts), input.workflow);
     }
     /** Resume a run from its persisted cursor → the status token. */
     resumeRun(runId) {
@@ -1235,8 +1500,18 @@ export class CoreAdapter {
      *  would silently DROP them — a `request_changes` would run as a plain reject — so they fail
      *  CLOSED on version (the `extraWriteRoots` / `projectGraph` doctrine); absent, the call is the
      *  three-arg one every engine understands. */
-    confirmGate(runId, approve, amend, action, amendScope) {
+    confirmGate(runId, approve, amend, action, amendScope, plan) {
         return this.handedToEngine('run', runId, () => {
+            if (plan !== undefined) {
+                // DES-TEAMING-002 T3: approve a `plan_approval` gate WITH AN EDIT — the engine proposes,
+                // floor-fills and accepts it (or refuses it and re-opens the gate). Fail CLOSED on an
+                // addon without the gate: it would drop the edit and approve the held plan unedited.
+                if (!this.supportsPlanLaunch()) {
+                    return Promise.reject(new PlanLaunchUnsupportedError('An edited plan at the gate'));
+                }
+                const core = this.core;
+                return core.confirmGate(runId, true, undefined, 'edit_plan', undefined, JSON.stringify(plan));
+            }
             if (action === undefined && amendScope === undefined) {
                 return this.core.confirmGate(runId, approve, amend);
             }
@@ -1399,48 +1674,62 @@ export class CoreAdapter {
     async sessions() {
         return JSON.parse(await this.core.sessions());
     }
-    /** Every run + its ordered units. */
+    /**
+     * Each run's launch name as the engine RECORDED it — `sessionStarted.workflowId` from its event
+     * log (the preset, the registered def, `<run>:plan-<rev>`, or `null` for free text). Immutable
+     * once written, so it is read once per run: a run whose log holds no `sessionStarted` is memoized
+     * only once it is terminal (a live run's frame may not be flushed yet; a finished run's never
+     * will be). Seam X2 — the one input `resolveRunIdentity` needs that the session record lacks.
+     */
+    launchedWorkflows = new Map();
+    async launchedWorkflowOf(view) {
+        const id = view.session.id;
+        if (this.launchedWorkflows.has(id))
+            return this.launchedWorkflows.get(id);
+        let events;
+        try {
+            events = await this.runEvents(id);
+        }
+        catch {
+            return undefined;
+        }
+        if (events === null)
+            return undefined;
+        const started = events.find((e) => e.type === 'sessionStarted');
+        // The engine spells it `workflowId` on the frame (core-ts `CoreEventJson`).
+        const raw = started?.['workflowId'];
+        const launched = started === undefined ? undefined : typeof raw === 'string' ? raw : null;
+        if (launched !== undefined || TERMINAL_RUN_STATUSES.has(view.session.status)) {
+            this.launchedWorkflows.set(id, launched);
+        }
+        return launched;
+    }
+    /**
+     * Every run + its ordered units, each with its `run_identity` (seam X2) resolved from the engine's
+     * record — its plan state, else its recorded launch — never from its phase sequence.
+     *
+     * `workflow_id` is still rewritten from the engine's synthetic `wf-<run>` to the resolved NAME
+     * for skins that read it (studio's run-kind list, until it reads `run_identity.system`); a run
+     * with no name (a user plan, free text, unknown) keeps the engine's id.
+     */
     async sessionsDetail() {
         const views = JSON.parse(await this.core.sessionsDetail());
-        // The Rust core always stores workflow_id as 'wf-<session-uuid>' (an instance ID, not the
-        // definition name). Patch it back to the definition name so the studio's chat/work filters work.
-        // phase_ref is only set on executed units and uses format 'wf-<uuid>:unit-N' (not the phase id).
-        // The phase id is reliably embedded in the unit id as '<session-uuid>:<phase-id>'.
+        const needsLaunch = (v) => v.session.team_plan == null &&
+            typeof v.session.workflow_id === 'string' &&
+            isSyntheticWorkflowId(v.session.workflow_id);
+        const pending = views.filter(needsLaunch);
+        const launched = new Map();
+        // Bounded fan-out: the first read after boot visits each such run's log once (memoized after).
+        for (let i = 0; i < pending.length; i += 8) {
+            const batch = pending.slice(i, i + 8);
+            const got = await Promise.all(batch.map((v) => this.launchedWorkflowOf(v)));
+            batch.forEach((v, k) => launched.set(v.session.id, got[k]));
+        }
         for (const view of views) {
-            if (view.session.workflow_id?.startsWith('wf-')) {
-                const phases = [...view.units].sort((a, b) => a.ord - b.ord).map((u) => {
-                    const colonIdx = u.id.indexOf(':');
-                    return colonIdx >= 0 ? u.id.slice(colonIdx + 1) : '';
-                });
-                if (view.units.length === 1) {
-                    // Single-unit chat sessions have phase id 'explore' (from the chat workflow def).
-                    // 'u1' is ambiguous — it appears on any single-unit run without an explicit workflow,
-                    // including Do Work runs, so we leave those unpatched rather than misclassify them.
-                    const phase = phases[0] ?? '';
-                    if (phase === 'explore')
-                        view.session.workflow_id = 'chat';
-                }
-                else {
-                    // Multi-unit: match against builtin workflow defs by phase sequence. A delivered run
-                    // (crew#293, default-on for code-work launches since crew#393) carries run-scoped
-                    // appendages the def never had — [verify-deliverables,] [deliver] at the tail — so
-                    // when the exact sequence matches nothing they are stripped and the match retried:
-                    // a feature run must not lose its name on the wire because it also delivered.
-                    const bySequence = (seq) => BUILTIN_WORKFLOWS.find((def) => def.phases.length === seq.length &&
-                        def.phases.every((p, i) => p.id === seq[i]));
-                    let match = bySequence(phases);
-                    if (!match) {
-                        const stripped = [...phases];
-                        if (stripped[stripped.length - 1] === DELIVER_PHASE_ID)
-                            stripped.pop();
-                        if (stripped[stripped.length - 1] === DELIVERABLE_FLOOR_PHASE_ID)
-                            stripped.pop();
-                        if (stripped.length < phases.length)
-                            match = bySequence(stripped);
-                    }
-                    if (match)
-                        view.session.workflow_id = match.id;
-                }
+            const identity = wireIdentity(resolveRunIdentity(view, launched.get(view.session.id)));
+            view.session.run_identity = identity;
+            if (identity.name !== null && isSyntheticWorkflowId(view.session.workflow_id ?? '')) {
+                view.session.workflow_id = identity.name;
             }
         }
         return views;
@@ -1449,6 +1738,117 @@ export class CoreAdapter {
     async workOutput(unitId) {
         return JSON.parse(await this.core.workOutput(unitId));
     }
+    // ── Presets (DES-TEAMING-002 §8.4, seam C2) ─────────────────────────────────
+    // 1:1 maps of the engine's preset commands. The engine owns the store AND resolution: a launch
+    // naming a preset (`workflow`) is resolved inside the engine, so crew never expands one itself.
+    // Every method throws PresetsUnsupportedError on an addon without the bindings (routes: 501).
+    /** True when the installed addon carries the preset bindings. */
+    presetsSupported() {
+        return typeof this.core.putPreset === 'function';
+    }
+    requirePresets(fn, what) {
+        if (typeof fn !== 'function')
+            throw new PresetsUnsupportedError(what);
+        return fn;
+    }
+    async putPreset(name, steps, projectId, createdBy) {
+        const fn = this.requirePresets(this.core.putPreset, 'Saving a preset');
+        return withPresetSystemFlag(JSON.parse(await fn.call(this.core, name, JSON.stringify(steps), projectId ?? null, createdBy ?? null)));
+    }
+    async deletePreset(name, projectId) {
+        const fn = this.requirePresets(this.core.deletePreset, 'Deleting a preset');
+        return JSON.parse(await fn.call(this.core, name, projectId ?? null));
+    }
+    /** The preset `name` resolves to for a launch in `projectId` (the project's row shadows the
+     *  global one), or `null` — including on an addon without presets, whose engine resolves every
+     *  workflow id as a registered def. */
+    async presetNamed(name, projectId) {
+        try {
+            return (await this.listPresets(projectId)).find((p) => p.name === name) ?? null;
+        }
+        catch (err) {
+            if (err instanceof PresetsUnsupportedError)
+                return null;
+            throw err;
+        }
+    }
+    async listPresets(projectId) {
+        const fn = this.requirePresets(this.core.listPresets, 'Listing presets');
+        return JSON.parse(await fn.call(this.core, projectId ?? null)).map(withPresetSystemFlag);
+    }
+    // ── Team (DES-TEAMING-002 T8) ───────────────────────────────────────────────
+    // Reads and commands over the engine; crew publishes no team fact (§4.0). Every method throws
+    // TeamUnsupportedError on an addon without its binding (routes: 501).
+    requireTeam(fn, what, binding) {
+        if (typeof fn !== 'function')
+            throw new TeamUnsupportedError(what, binding);
+        return fn;
+    }
+    /** The run's team transport and per-unit snapshots, or `null` for a run that is not a team run. */
+    async runTeam(runId) {
+        const fn = this.requireTeam(this.core.runTeam, 'Reading a run\'s team', 'runTeam');
+        return JSON.parse(await fn.call(this.core, runId));
+    }
+    /** Replay `<state home>/team-outbox.ndjson` onto the bus. */
+    async replayTeamOutbox() {
+        const fn = this.requireTeam(this.core.replayTeamOutbox, 'Replaying the team outbox', 'replayTeamOutbox');
+        return JSON.parse(await fn.call(this.core));
+    }
+    /**
+     * The catalog ids whose entry declares `verified_evidence` (seam X2: a plan run's acceptance is
+     * the steps it contains that re-verify evidence). `null` when the engine has no catalog binding
+     * or its catalog does not carry the flag — callers fail closed on it. The catalog is compiled
+     * into the engine, so a known answer is read once.
+     */
+    async verifiedEvidenceCatalog() {
+        if (this._verifiedEvidenceCatalog !== undefined)
+            return this._verifiedEvidenceCatalog;
+        let entries;
+        try {
+            entries = await this.catalog();
+        }
+        catch {
+            return null;
+        }
+        const set = verifiedEvidenceCatalog(entries);
+        if (set !== null)
+            this._verifiedEvidenceCatalog = set;
+        return set;
+    }
+    _verifiedEvidenceCatalog;
+    /** The engine's phase catalog. */
+    async catalog() {
+        const fn = this.requireTeam(this.core.catalog, 'Reading the phase catalog', 'catalog');
+        return JSON.parse(await fn.call(this.core));
+    }
+    /** What a `POST /runs {plan}` launch with the same fields would decide, persisting nothing
+     *  (`Core.previewPlan`): `repoRef` is the repo the launch runs on (its graph scores the touch
+     *  set), and `deliver` hands the engine the launch's deliver step, as `launchRun` does. */
+    async previewPlan(plan, opts = {}) {
+        const fn = this.requireTeam(this.core.previewPlan, 'Previewing a plan', 'previewPlan');
+        // (F2) The preview shows the deliver step's gate-card text, so it reads the same origin the
+        // launch would. Local to this call, like the launch's.
+        const previewOriginUrl = opts.deliver === true ? await this.resolveDeliverOrigin(opts.repoRef) : null;
+        const deliverStep = opts.deliver === true
+            ? JSON.stringify(
+            // The launch's own step for a plan (`deliverStep(null, [], input)`); the run id is a
+            // placeholder: it only shapes the push command, which a preview never runs.
+            this.deliverStep(null, [], {
+                sessionId: 'plan-preview',
+                problem: '',
+                clisJson: '[]',
+                ...(opts.repoRef !== undefined ? { repoRef: opts.repoRef } : {}),
+            }, previewOriginUrl))
+            : null;
+        return JSON.parse(await fn.call(this.core, JSON.stringify(plan), opts.projectId ?? null, opts.humanConfirm ?? null, opts.repoRef ?? null, deliverStep));
+    }
+    /** A mid-run plan edit (`Core.proposePlan`): the steps to add, held for the run's next step
+     *  boundary and approved by its author. Idempotent by `requestId`; rejects with the engine's
+     *  refusal (a plan awaiting approval, a started deliver step, a finished or unplanned run, …). */
+    async proposePlan(runId, plan, requestId) {
+        const fn = this.requireTeam(this.core.proposePlan, 'Editing a running plan', 'proposePlan');
+        return JSON.parse(await fn.call(this.core, runId, JSON.stringify(plan), requestId));
+    }
     // ── 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
@@ -1764,9 +2164,10 @@ export class CoreAdapter {
             problem: `Onboard repository: ${repoName}`,
             sessionId: runId,
             // The run's seat pool is the seats the WORKFLOW can use (F-2R2-010): onboarding is two tool
-            // phases routed to the `wicked-estate` executor, so its pool is empty — not the whole roster
-            // dressed up as a 5-seat run with four signed-out seats.
-            clisJson: JSON.stringify(this.seatsForWorkflow('onboarding')),
+            // steps routed to the `wicked-estate` executor, so its pool is empty — not the whole roster
+            // dressed up as a 5-seat run with four signed-out seats. `onboarding` is the engine's
+            // built-in PRESET (DES-TEAMING-002 M4), read from the engine's store.
+            clisJson: JSON.stringify(await this.seatsForWorkflow('onboarding')),
             workflow: 'onboarding',
             repoRef: repoId,
         });
@@ -1784,20 +2185,24 @@ export class CoreAdapter {
         }
     }
     /**
-     * The roster a run of `workflowId` should carry as its seat pool. A workflow whose every phase
-     * runs a TOOL executor convenes no council and dispatches no seat, so its pool is `[]` — the
-     * engine routes each unit `tool` without consulting the pool (verified against the engine: an
-     * onboarding launch with `clis: []` distributes both units to `wicked-estate`). Any workflow
-     * with an agent phase — or one this daemon cannot read — gets the full roster, as before.
+     * The roster a run of `workflowId` should carry as its seat pool. A workflow or preset whose
+     * every phase (step) runs a TOOL executor convenes no council and dispatches no seat, so its pool
+     * is `[]` — the engine routes each unit `tool` without consulting the pool (verified against the
+     * engine: an onboarding launch with `clis: []` distributes both units to `wicked-estate`). Any
+     * one with an agent phase — or one this daemon cannot read — gets the full roster, as before.
+     * A registered def is read first; otherwise the preset the name launches (the engine resolves a
+     * launch the same way: DES-TEAMING-002 §8.4).
      */
-    seatsForWorkflow(workflowId) {
+    async seatsForWorkflow(workflowId) {
         const def = this.getWorkflow(workflowId);
+        const executors = def !== null
+            ? def.phases.map((p) => p.executor)
+            : ((await this.presetNamed(workflowId))?.steps ?? []).map((s) => s['executor']);
         // The roster WITH standing when the daemon wired one (F-RECON-002/003) — `launchRun` then
         // benches `council_eligible: false` seats through `engineRosterJson`.
-        if (def === null || def.phases.length === 0)
-            return this.launchRoster();
-        const toolOnly = def.phases.every((p) => p.executor?.type === 'tool');
-        return toolOnly ? [] : this.launchRoster();
+        if (executors.length === 0)
+            return this.readyLaunchRoster();
+        return executors.every((e) => e?.type === 'tool') ? [] : this.readyLaunchRoster();
     }
     /** Return the onboarding run id for a repo (undefined if not launched this session). */
     getOnboardRunId(repoId) {
@@ -1951,6 +2356,18 @@ export class CoreAdapter {
     steeringSupported() {
         return typeof this.core.steeringImport === 'function';
     }
+    /**
+     * The MCP policy preview (DES-MCP-TOOLS-001 S6): `{calls, cells}` → `[{subject, cells}]` JSON,
+     * judged by the same evaluation the broker's `evaluateMcpCall` runs, and recorded nowhere.
+     * Throws `mcp_preview_unsupported` on an addon that predates the binding (the route answers 501).
+     */
+    async previewMcpCalls(requestJson) {
+        const preview = this.core.previewMcpCalls;
+        if (typeof preview !== 'function') {
+            throw new Error('mcp_preview_unsupported: the installed wicked-core-ts predates the MCP policy preview; upgrade the engine');
+        }
+        return preview.call(this.core, requestJson);
+    }
     /**
      * Batch-import steering rules (frontmattered markdown docs and/or ready rule JSON) through the
      * engine's ingest normalize/validate path — the SAME path `rules ingest --dir` runs, on the
@@ -2071,6 +2488,47 @@ export class CoreAdapter {
                 this.userWorkflows.set(def.id, def);
         }
     }
+    /** Core's verdict on each hydrated drop-in, run ONCE per process (the same lifetime as
+     *  {@link hydrateFromOverlay} and as core's own boot-time `load_dir`). */
+    overlayVerdicts = null;
+    /** id → core's refusal reason, for the drop-ins `judgeOverlayOnce` dropped. */
+    overlayRefusals = new Map();
+    /** Drop the refused defs from `userWorkflows` and remember why, asking core's parser (crew#718).
+     *
+     * A build with no `registerWorkflow` binding has no validator to ask, so nothing is judged and
+     * the catalog reads exactly as it did before — the same floor {@link registerWorkflow} draws,
+     * on the read side where there is no state to corrupt. `registerWorkflow` has been declared
+     * (non-optional) in wicked-core-ts since 0.4.0. */
+    judgeOverlayOnce() {
+        this.overlayVerdicts ??= (async () => {
+            this.hydrateFromOverlay();
+            const core = this.core;
+            const register = core['registerWorkflow'];
+            if (typeof register !== 'function')
+                return;
+            const { refused } = await judgeOverlayWorkflows([...this.userWorkflows.values()], (json) => register.call(this.core, json));
+            for (const r of refused) {
+                this.userWorkflows.delete(r.id);
+                this.overlayRefusals.set(r.id, r.reason);
+                console.warn(`wicked-crew: drop-in workflow '${r.id}' is NOT in the catalog — the engine refused it: ${r.reason}`);
+            }
+        })();
+        return this.overlayVerdicts;
+    }
+    /** The workflow catalog `GET /workflows` serves: the defs the ENGINE accepted, plus the drop-ins
+     *  it refused with its own reason, so an unlaunchable def is named instead of offered (crew#718). */
+    async workflowCatalog() {
+        await this.judgeOverlayOnce();
+        return {
+            workflows: this.listWorkflows(),
+            unavailable: [...this.overlayRefusals].map(([id, reason]) => ({ id, reason })),
+        };
+    }
+    /** Core's refusal reason for `id`, or `null` when the engine never refused it (crew#718). */
+    async workflowRefusal(id) {
+        await this.judgeOverlayOnce();
+        return this.overlayRefusals.get(id) ?? null;
+    }
     listWorkflows() {
         this.hydrateFromOverlay();
         // Builtins first (stable ordering), but user-registered workflows take precedence when
@@ -2081,20 +2539,21 @@ export class CoreAdapter {
             const override = this.userWorkflows.get(w.id);
             if (!seen.has(w.id)) {
                 seen.add(w.id);
-                result.push(override ?? w);
+                result.push(withSystemFlag(override ?? w));
             }
         }
         for (const w of this.userWorkflows.values()) {
             if (!seen.has(w.id)) {
                 seen.add(w.id);
-                result.push(w);
+                result.push(withSystemFlag(w));
             }
         }
         return result;
     }
     getWorkflow(id) {
         this.hydrateFromOverlay();
-        return this.userWorkflows.get(id) ?? BUILTIN_WORKFLOWS.find((w) => w.id === id) ?? null;
+        const def = this.userWorkflows.get(id) ?? BUILTIN_WORKFLOWS.find((w) => w.id === id) ?? null;
+        return def === null ? null : withSystemFlag(def);
     }
     /** Write a built-in workflow definition to the Rust overlay dir (and hot-register when possible).
      *  Unlike registerWorkflow(), this does NOT touch userWorkflows, avoiding duplicates in listWorkflows(). */
@@ -2201,6 +2660,9 @@ export class CoreAdapter {
         await register.call(this.core, json);
         await writeFile(path, JSON.stringify(overlayDef, null, 2), 'utf8');
         this.userWorkflows.set(def.id, def);
+        // (crew#718) This def just passed core's own validator, so any earlier refusal under the same
+        // id is stale — the catalog must offer the replacement, not keep naming the version it refused.
+        this.overlayRefusals.delete(def.id);
         return def.id;
     }
     /**
@@ -2255,6 +2717,19 @@ export class CoreAdapter {
                 if (typeof v !== 'number' || !Number.isInteger(v) || v < 1 || v > 10000)
                     delete parsed.graphNodeLimit;
             }
+            // deliverIdentityLogin (crew#549): a LOGIN, and the same charset PUT /settings enforces —
+            // a hand-edited settings.json must not enable a value the API rejects (and must never be
+            // able to put anything but a login into the deliver script's shell literal). Anything else
+            // is dropped, which leaves the identity unconfigured rather than unpinned-and-unsaid.
+            if ('deliverIdentityLogin' in parsed) {
+                const v = parsed.deliverIdentityLogin;
+                if (typeof v !== 'string' || (v.trim() !== '' && !isGitHubLogin(v.trim()))) {
+                    delete parsed.deliverIdentityLogin;
+                }
+                else {
+                    parsed.deliverIdentityLogin = v.trim();
+                }
+            }
             // 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) {
@@ -2385,6 +2860,8 @@ export class CoreAdapter {
         if (this.closed)
             return;
         this.closed = true;
+        if (this.engineBus !== null && this.busDbPath !== undefined)
+            detachEngineBus(this.busDbPath, this.engineBus);
         this.listeners.clear();
         this.subscription.close();
     }