@geraldmaron/construct 1.4.2 → 1.5.0

package/lib/embed/capability-loader.mjs

@@ -0,0 +1,303 @@
+/**
+ * lib/embed/capability-loader.mjs — embed-capability manifest loader (ADR-0061, LMCP-P2).
+ *
+ * An embed capability is a workflow manifest (lib/workflows/loader.mjs, D1)
+ * with `type: "embed"` and an `embed` block. This module discovers those
+ * manifests across the three D1 tiers (builtin, pack, project), validates
+ * the `embed` block against the ADR-0061 shape — including provider
+ * bindings (E4) and the ADR-0060 filter block (reused read-only from
+ * lib/providers/filter-schema.mjs / lib/providers/contract.mjs) — and
+ * exposes the per-project enable/disable lifecycle described in the ADR:
+ * pack tiers ship *available* defaults, `.cx/embed/<id>.manifest.json`
+ * (project tier) makes a capability *active*.
+ *
+ * Every validation failure returns a JSON-schema-style field path
+ * (`embed.providerBindings[1]`, `embed.filter.scope.repos`, …) so a failed
+ * `enable` names exactly what is wrong — this is a fail-closed surface, not
+ * best-effort: an invalid manifest is never silently accepted or partially
+ * applied.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { loadWorkflowManifestsFromDir, mergeWorkflowManifests, resolveWorkflowManifestDirs } from '../workflows/loader.mjs';
+import { validateWorkflowManifest } from '../workflows/validate.mjs';
+import { loadAllPacks } from '../packs/loader.mjs';
+import { validateFilterConfig } from '../providers/contract.mjs';
+import { TOP_LEVEL_KEYS as FILTER_TOP_LEVEL_KEYS, SCOPE_KEYS as FILTER_SCOPE_KEYS, PREDICATE_KEYS as FILTER_PREDICATE_KEYS } from '../providers/filter-schema.mjs';
+
+export const EMBED_MANIFEST_TYPE = 'embed';
+
+export const RUNTIME_VALUES = Object.freeze(['in-process', 'external', 'auto', 'none']);
+
+export const PROPOSAL_AUTHORITY_VALUES = Object.freeze(['propose-only', 'governed-write']);
+
+const REQUIRED_EMBED_FIELDS = Object.freeze([
+  'specialist', 'providerBindings', 'framework', 'outputContract', 'proposalAuthority', 'runtime',
+]);
+
+/**
+ * Directory holding per-project embed enable/override manifests
+ * (project tier of the D1 loader, mirrored under `.cx/embed/`).
+ */
+export function embedProjectDir(rootDir = process.cwd()) {
+  return join(rootDir, '.cx', 'embed');
+}
+
+function fieldError(filePath, fieldPath, message) {
+  const prefix = filePath ? `${filePath}: ` : '';
+  return `${prefix}${fieldPath}: ${message}`;
+}
+
+/**
+ * Validate the `embed` block of a `type: "embed"` workflow manifest against
+ * the ADR-0061 shape. Returns `{ valid: true }` or `{ valid: false, errors }`
+ * where every error string is prefixed with its JSON-schema-style field path
+ * (e.g. `embed.providerBindings[0]`) so a caller can point at exactly what
+ * broke. Never throws.
+ *
+ * `knownSpecialists` — merged E1 pack registry specialist ids; when supplied,
+ * an unresolvable `embed.specialist` is a hard error (fail closed rather than
+ * silently accepting a typo'd persona reference).
+ */
+export function validateEmbedBlock(manifest, { filePath, knownSpecialists } = {}) {
+  const errors = [];
+
+  if (manifest.type !== EMBED_MANIFEST_TYPE) {
+    return { valid: false, errors: [fieldError(filePath, 'type', `must be "${EMBED_MANIFEST_TYPE}" (got '${manifest.type}')`)] };
+  }
+
+  const embed = manifest.embed;
+  if (embed === undefined || embed === null || typeof embed !== 'object' || Array.isArray(embed)) {
+    return { valid: false, errors: [fieldError(filePath, 'embed', 'must be an object present on every type:"embed" manifest')] };
+  }
+
+  for (const field of REQUIRED_EMBED_FIELDS) {
+    if (!(field in embed) || embed[field] === undefined || embed[field] === null) {
+      errors.push(fieldError(filePath, `embed.${field}`, 'missing required field'));
+    }
+  }
+
+  if ('specialist' in embed && embed.specialist !== undefined && embed.specialist !== null) {
+    if (typeof embed.specialist !== 'string' || embed.specialist.length === 0) {
+      errors.push(fieldError(filePath, 'embed.specialist', 'must be a non-empty string'));
+    } else if (Array.isArray(knownSpecialists) && knownSpecialists.length > 0 && !knownSpecialists.includes(embed.specialist)) {
+      errors.push(fieldError(filePath, 'embed.specialist', `unresolvable specialist id '${embed.specialist}' (not present in the merged pack registry)`));
+    }
+  }
+
+  if ('providerBindings' in embed && embed.providerBindings !== undefined && embed.providerBindings !== null) {
+    if (!Array.isArray(embed.providerBindings)) {
+      errors.push(fieldError(filePath, 'embed.providerBindings', 'must be an array of provider ids'));
+    } else if (embed.providerBindings.length === 0) {
+      errors.push(fieldError(filePath, 'embed.providerBindings', 'must declare at least one provider id'));
+    } else {
+      embed.providerBindings.forEach((binding, idx) => {
+        if (typeof binding !== 'string' || binding.length === 0) {
+          errors.push(fieldError(filePath, `embed.providerBindings[${idx}]`, 'must be a non-empty string'));
+        }
+      });
+    }
+  }
+
+  if ('framework' in embed && embed.framework !== undefined && embed.framework !== null) {
+    if (typeof embed.framework !== 'string' || embed.framework.length === 0) {
+      errors.push(fieldError(filePath, 'embed.framework', 'must be a non-empty string'));
+    }
+  }
+
+  if ('outputContract' in embed && embed.outputContract !== undefined && embed.outputContract !== null) {
+    if (typeof embed.outputContract !== 'string' || embed.outputContract.length === 0) {
+      errors.push(fieldError(filePath, 'embed.outputContract', 'must be a non-empty string'));
+    }
+  }
+
+  if ('proposalAuthority' in embed && embed.proposalAuthority !== undefined && embed.proposalAuthority !== null) {
+    if (!PROPOSAL_AUTHORITY_VALUES.includes(embed.proposalAuthority)) {
+      errors.push(fieldError(filePath, 'embed.proposalAuthority', `must be one of: ${PROPOSAL_AUTHORITY_VALUES.join(', ')} (got '${embed.proposalAuthority}')`));
+    }
+  }
+
+  if ('runtime' in embed && embed.runtime !== undefined && embed.runtime !== null) {
+    if (!RUNTIME_VALUES.includes(embed.runtime)) {
+      errors.push(fieldError(filePath, 'embed.runtime', `must be one of: ${RUNTIME_VALUES.join(', ')} (got '${embed.runtime}')`));
+    }
+  }
+
+  if ('cadence' in embed && embed.cadence !== undefined && embed.cadence !== null) {
+    if (typeof embed.cadence !== 'object' || Array.isArray(embed.cadence)) {
+      errors.push(fieldError(filePath, 'embed.cadence', 'must be an object (e.g. { "every": "PT15M" })'));
+    } else if ('every' in embed.cadence && typeof embed.cadence.every !== 'string') {
+      errors.push(fieldError(filePath, 'embed.cadence.every', 'must be a string (ISO-8601 duration)'));
+    }
+  }
+
+  if ('filter' in embed && embed.filter !== undefined && embed.filter !== null) {
+    errors.push(...validateEmbedFilterBlock(embed.filter, embed.providerBindings, filePath));
+  }
+
+  if (errors.length > 0) return { valid: false, errors };
+  return { valid: true };
+}
+
+/**
+ * Validate the ADR-0060 filter block carried at `embed.filter`, field-path
+ * prefixed for the embed-manifest context. Structural checks mirror
+ * lib/providers/filter-schema.mjs; per-provider-kind scope legality is
+ * re-checked with the read-only lib/providers/contract.mjs
+ * `validateFilterConfig` against every bound provider id so a filter that
+ * is legal for one binding but not another is caught here rather than at
+ * daemon runtime.
+ */
+function validateEmbedFilterBlock(filter, providerBindings, filePath) {
+  const errors = [];
+
+  if (typeof filter !== 'object' || filter === null || Array.isArray(filter)) {
+    return [fieldError(filePath, 'embed.filter', 'must be an object')];
+  }
+
+  for (const key of Object.keys(filter)) {
+    if (!FILTER_TOP_LEVEL_KEYS.includes(key)) {
+      errors.push(fieldError(filePath, `embed.filter.${key}`, `unknown filter key; allowed: ${FILTER_TOP_LEVEL_KEYS.join(', ')}`));
+    }
+  }
+
+  if (filter.scope !== undefined) {
+    if (typeof filter.scope !== 'object' || filter.scope === null || Array.isArray(filter.scope)) {
+      errors.push(fieldError(filePath, 'embed.filter.scope', 'must be an object'));
+    } else {
+      for (const key of Object.keys(filter.scope)) {
+        if (!FILTER_SCOPE_KEYS.includes(key)) {
+          errors.push(fieldError(filePath, `embed.filter.scope.${key}`, `unknown scope key; allowed: ${FILTER_SCOPE_KEYS.join(', ')}`));
+        } else if (!Array.isArray(filter.scope[key])) {
+          errors.push(fieldError(filePath, `embed.filter.scope.${key}`, 'must be an array'));
+        }
+      }
+    }
+  }
+
+  if (filter.predicates !== undefined) {
+    if (typeof filter.predicates !== 'object' || filter.predicates === null || Array.isArray(filter.predicates)) {
+      errors.push(fieldError(filePath, 'embed.filter.predicates', 'must be an object'));
+    } else {
+      for (const key of Object.keys(filter.predicates)) {
+        if (!FILTER_PREDICATE_KEYS.includes(key)) {
+          errors.push(fieldError(filePath, `embed.filter.predicates.${key}`, `unknown predicate key; allowed: ${FILTER_PREDICATE_KEYS.join(', ')}`));
+        }
+      }
+    }
+  }
+
+  // Structural errors already found: skip the per-provider re-check, its
+  // messages would only restate the same problem under a different path.
+  if (errors.length > 0) return errors;
+
+  // Fail closed per bound provider: a filter valid for "github" but not
+  // "jira" must not silently apply to jira's snapshot with github's rules.
+  for (const providerId of Array.isArray(providerBindings) ? providerBindings : []) {
+    try {
+      validateFilterConfig(providerId, filter);
+    } catch (err) {
+      errors.push(fieldError(filePath, 'embed.filter', `invalid for bound provider '${providerId}': ${err.message}`));
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Discover embed-capability manifests across the D1 three-tier loader
+ * (builtin, every pack root's workflows/ dir, project .cx/embed/), validate
+ * the base workflow-manifest shape via lib/workflows/validate.mjs and the
+ * ADR-0061 `embed` block via validateEmbedBlock, and merge by id with
+ * project overriding pack overriding builtin. Non-`type:"embed"` workflow
+ * manifests present in the same directories are silently excluded — this
+ * loader is embed-capability-scoped, not a general workflow loader.
+ *
+ * @param {{ rootDir?: string, packRoots?: string[], knownSpecialists?: string[] }} [opts]
+ * @returns {{ capabilities: object[], errors: string[] }}
+ */
+export function loadEmbedCapabilities(opts = {}) {
+  const { rootDir = process.cwd() } = opts;
+  const errors = [];
+
+  let packRoots = opts.packRoots;
+  let knownSpecialists = opts.knownSpecialists;
+  if (!packRoots || !knownSpecialists) {
+    const { packs, errors: packErrors } = loadAllPacks({ rootDir });
+    errors.push(...packErrors);
+    if (!packRoots) packRoots = packs.map((p) => p._packDir).filter(Boolean);
+    if (!knownSpecialists) knownSpecialists = [...new Set(packs.flatMap((p) => p.specialists ?? []))];
+  }
+
+  const dirs = resolveWorkflowManifestDirs({ rootDir, packRoots });
+
+  // Project-tier embed manifests live under .cx/embed/ (not .cx/workflows/,
+  // which is D1's general workflow project tier) — see embedProjectDir().
+  const projectDir = embedProjectDir(rootDir);
+
+  const builtin = loadWorkflowManifestsFromDir(dirs.builtin);
+  errors.push(...builtin.errors);
+
+  const packManifests = [];
+  for (const packDir of dirs.pack) {
+    const result = loadWorkflowManifestsFromDir(packDir);
+    packManifests.push(...result.manifests);
+    errors.push(...result.errors);
+  }
+
+  const project = loadWorkflowManifestsFromDir(projectDir);
+  errors.push(...project.errors);
+
+  const merged = mergeWorkflowManifests(builtin.manifests, packManifests, project.manifests);
+
+  const capabilities = [];
+  for (const manifest of merged) {
+    if (manifest.type !== EMBED_MANIFEST_TYPE) continue;
+
+    const result = validateEmbedBlock(manifest, { filePath: manifest._filePath, knownSpecialists });
+    if (!result.valid) {
+      errors.push(...result.errors);
+      continue;
+    }
+    capabilities.push(manifest);
+  }
+
+  return { capabilities, errors };
+}
+
+/**
+ * Validate a single candidate manifest object end to end (base workflow
+ * shape + ADR-0061 embed block) without touching disk, so an `enable` call
+ * can reject a bad manifest before any project-tier file is written.
+ */
+export function validateEmbedManifest(manifest, { filePath, knownSpecialists } = {}) {
+  const base = validateWorkflowManifest(manifest, { filePath });
+  if (!base.valid) return base;
+  return validateEmbedBlock(manifest, { filePath, knownSpecialists });
+}
+
+/**
+ * Read the project-tier enable/override manifest for `id`, if present.
+ * Returns null when the capability has never been enabled in this project.
+ */
+export function readProjectEmbedManifest(id, rootDir = process.cwd()) {
+  const filePath = join(embedProjectDir(rootDir), `${id}.manifest.json`);
+  if (!existsSync(filePath)) return null;
+  return { manifest: JSON.parse(readFileSync(filePath, 'utf8')), filePath };
+}
+
+/**
+ * Write the project-tier enable/override manifest for `id`, creating
+ * `.cx/embed/` on demand. Callers must validate before calling — the
+ * function performs no validation, matching the D1 loader's separation
+ * between building a manifest object and validating one.
+ */
+export function writeProjectEmbedManifest(id, manifest, rootDir = process.cwd()) {
+  const dir = embedProjectDir(rootDir);
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, `${id}.manifest.json`);
+  writeFileSync(filePath, `${JSON.stringify(manifest, null, 2)}\n`);
+  return filePath;
+}

package/lib/embed/capability-runtime.mjs

@@ -0,0 +1,58 @@
+/**
+ * lib/embed/capability-runtime.mjs — ADR-0061 §3 runtime selector resolution.
+ *
+ * Resolves an embed capability's `runtime` field (`in-process` | `external`
+ * | `auto` | `none`) to the runtime that will actually execute reasoning,
+ * without performing that reasoning. `auto` resolves to `in-process` when a
+ * model provider is configured (the existing model-resolution path,
+ * lib/model-router.mjs `readCurrentModels`), else `external` when an
+ * external host is configured (`CONSTRUCT_EXTERNAL_AGENT_HOST`), else
+ * `none`. `none` is an honest, visible skip — never a fabricated result —
+ * per the workflow-invoke.mjs no-fabrication invariant this ADR preserves.
+ */
+
+export const SKIP_REASON_NO_RUNTIME = 'no-runtime';
+
+/**
+ * True when the existing model-resolution path has a model configured for
+ * any tier. Reuses lib/model-router.mjs so this module adds no new
+ * dependency — it is a read-only probe of state Construct already resolves.
+ */
+async function hasConfiguredModelProvider(env) {
+  try {
+    const { readCurrentModels } = await import('../model-router.mjs');
+    const models = readCurrentModels(null, {}, env);
+    return Boolean(models?.fast || models?.standard || models?.reasoning);
+  } catch {
+    return false;
+  }
+}
+
+function hasExternalRuntimeConfigured(env) {
+  return Boolean((env.CONSTRUCT_EXTERNAL_AGENT_HOST ?? '').trim());
+}
+
+/**
+ * Resolve the declared `runtime` selector to the runtime that will actually
+ * execute reasoning.
+ *
+ * @param {'in-process'|'external'|'auto'|'none'} runtime
+ * @param {object} [env] - env object (default: process.env)
+ * @returns {Promise<{ resolved: 'in-process'|'external'|'none', reason?: string }>}
+ */
+export async function resolveRuntime(runtime, env = process.env) {
+  if (runtime === 'in-process') return { resolved: 'in-process' };
+  if (runtime === 'external') {
+    if (!hasExternalRuntimeConfigured(env)) {
+      return { resolved: 'none', reason: SKIP_REASON_NO_RUNTIME };
+    }
+    return { resolved: 'external' };
+  }
+  if (runtime === 'none') return { resolved: 'none', reason: SKIP_REASON_NO_RUNTIME };
+
+  // auto: in-process if a model provider is configured, else external if a
+  // host is configured, else none.
+  if (await hasConfiguredModelProvider(env)) return { resolved: 'in-process' };
+  if (hasExternalRuntimeConfigured(env)) return { resolved: 'external' };
+  return { resolved: 'none', reason: SKIP_REASON_NO_RUNTIME };
+}

package/lib/embed/cli.mjs

@@ -7,14 +7,25 @@
  *   status                       Print daemon status + last snapshot summary
  *   snapshot [--config <path>]   Run a one-shot snapshot and print to stdout
  *
+ * Embed-capability lifecycle (ADR-0061, LMCP-P2) — per-specialist capability
+ * manifests, distinct from the daemon process above:
+ *   list                         Available capabilities + per-project enabled state
+ *   enable  <id>                 Write .cx/embed/<id>.manifest.json, validate, activate
+ *   disable <id>                 Mark a capability disabled (scheduled job stops)
+ *   status  <id> [--json]        Bindings/filter/runtime/last-tick for one capability
+ *   dry-run <id> [--json]        Resolve the binding chain; no side effects
+ *
  * Exports:
  *   resolveEmbedStatus(env, homeDir) — returns { level, label, detail }
  *     level: 'running' | 'stopped' | 'none'
  *     Consumed by session-start hook and `construct embed status`.
  *
- *   autoStartEmbedIfNeeded(env, rootDir, homeDir) — spawns daemon when
- *     provider credentials are present but daemon is stopped. No-op if already
- *     running or no credentials. Returns { started: bool, pid?, reason? }.
+ *   autoStartEmbedIfNeeded(env, rootDir, homeDir, cwd) — spawns daemon when
+ *     provider credentials are present but daemon is stopped, gated by
+ *     CX_AUTO_EMBED (env, wins) or construct.config.json `autoEmbed` (config
+ *     fallback, same env > config > default precedence as deployment mode).
+ *     No-op if already running or no credentials. Returns
+ *     { started: bool, pid?, reason? }.
  */
 
 import fs from 'node:fs';
@@ -23,6 +34,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { configDir } from '../config/xdg.mjs';
 import { doctorRoot } from '../config/xdg.mjs';
+import { loadProjectConfig } from '../config/project-config.mjs';
 
 const STATE_FILE = 'embed-daemon.json';
 const LOG_FILE   = 'embed-daemon.log';
@@ -202,10 +214,17 @@ export function resolveEmbedStatus(env = process.env, homeDir = os.homedir()) {
  * @param {object} [env]      - Env object (default: process.env)
  * @param {string} [rootDir]  - Construct root dir (where lib/embed/worker.mjs lives)
  * @param {string} [homeDir]  - Home dir override
+ * @param {string} [cwd]      - Project dir for the construct.config.json `autoEmbed` fallback
  * @returns {{ started: boolean, pid?: number, reason?: string }}
  */
-export async function autoStartEmbedIfNeeded(env = process.env, rootDir, homeDir = os.homedir()) {
-  if (!env.CX_AUTO_EMBED && env.CX_AUTO_EMBED !== '1') {
+export async function autoStartEmbedIfNeeded(env = process.env, rootDir, homeDir = os.homedir(), cwd = process.cwd()) {
+  let configEnabled = false;
+  try {
+    const { config } = loadProjectConfig(cwd, env);
+    configEnabled = config?.autoEmbed === true;
+  } catch { /* loader is best-effort — falls through to env-only gating */ }
+
+  if (env.CX_AUTO_EMBED !== '1' && !configEnabled) {
     return { started: false, reason: 'CX_AUTO_EMBED not set' };
   }
 
@@ -420,6 +439,152 @@ async function cmdEmbedSnapshot(args, { homeDir = os.homedir() } = {}) {
   process.stderr.write(`\n${snapshot.summary.totalItems} items, ${snapshot.summary.errorCount} errors\n`);
 }
 
+// ---------------------------------------------------------------------------
+// Embed-capability lifecycle subcommands (ADR-0061, LMCP-P2)
+// ---------------------------------------------------------------------------
+
+function jsonFlag(args) {
+  return args.includes('--json');
+}
+
+function positionalId(args) {
+  return args.find((a) => !a.startsWith('--'));
+}
+
+async function cmdCapabilityList(args, { rootDir = process.cwd() } = {}) {
+  const { listCapabilities } = await import('./capability-lifecycle.mjs');
+  const { capabilities, errors } = listCapabilities({ rootDir });
+
+  if (jsonFlag(args)) {
+    process.stdout.write(`${JSON.stringify({ capabilities: capabilities.map((c) => ({
+      id: c.id, available: c.available, enabled: c.enabled, source: c.source,
+      runtime: c.manifest.embed.runtime, specialist: c.manifest.embed.specialist,
+    })), errors }, null, 2)}\n`);
+    if (errors.length) process.exitCode = 1;
+    return;
+  }
+
+  if (!capabilities.length) {
+    process.stdout.write('No embed capabilities discovered (pack defaults or .cx/embed/).\n');
+  }
+  for (const c of capabilities) {
+    process.stdout.write(`${c.id}${c.enabled ? ' [enabled]' : ' [available]'} — specialist=${c.manifest.embed.specialist} runtime=${c.manifest.embed.runtime}\n`);
+  }
+  for (const err of errors) {
+    process.stderr.write(`error: ${err}\n`);
+  }
+  if (errors.length) process.exitCode = 1;
+}
+
+async function cmdCapabilityEnable(args, { rootDir = process.cwd() } = {}) {
+  const id = positionalId(args);
+  if (!id) {
+    process.stderr.write('Usage: construct embed enable <id>\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  // --dry-run resolves the binding chain and writes nothing: enable preview
+  // must never touch .cx/embed/, matching the ADR "execute nothing" rule.
+  if (args.includes('--dry-run')) {
+    return cmdCapabilityDryRun(args, { rootDir });
+  }
+
+  const { enableCapability } = await import('./capability-lifecycle.mjs');
+  const result = enableCapability(id, { rootDir });
+
+  if (!result.ok) {
+    process.stderr.write(`embed enable ${id}: invalid manifest\n`);
+    for (const err of result.errors) process.stderr.write(`  ${err}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  process.stdout.write(`embed capability '${id}' enabled → ${result.filePath}\n`);
+}
+
+async function cmdCapabilityDisable(args, { rootDir = process.cwd() } = {}) {
+  const id = positionalId(args);
+  if (!id) {
+    process.stderr.write('Usage: construct embed disable <id>\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  const { disableCapability } = await import('./capability-lifecycle.mjs');
+  const result = disableCapability(id, { rootDir });
+  process.stdout.write(result.wasEnabled
+    ? `embed capability '${id}' disabled\n`
+    : `embed capability '${id}' was not enabled (no-op)\n`);
+}
+
+async function cmdCapabilityStatus(args, { rootDir = process.cwd() } = {}) {
+  const id = positionalId(args);
+  const { capabilityStatus } = await import('./capability-lifecycle.mjs');
+  const result = await capabilityStatus(id, { rootDir });
+
+  if (!result.ok) {
+    if (jsonFlag(args)) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      for (const err of result.errors) process.stderr.write(`error: ${err}\n`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  if (jsonFlag(args)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`embed capability '${id}': ${result.enabled ? 'enabled' : 'available (not enabled)'}\n`);
+  process.stdout.write(`  specialist:  ${result.chain.specialist}\n`);
+  process.stdout.write(`  providers:   ${result.chain.providerBindings.join(', ')}\n`);
+  process.stdout.write(`  filter:      ${result.chain.filter ? JSON.stringify(result.chain.filter) : '(none)'}\n`);
+  process.stdout.write(`  framework:   ${result.chain.framework}\n`);
+  process.stdout.write(`  authority:   ${result.chain.proposalAuthority}\n`);
+  process.stdout.write(`  runtime:     declared=${result.chain.runtime.declared} resolved=${result.chain.runtime.resolved}${result.chain.runtime.reason ? ` (${result.chain.runtime.reason})` : ''}\n`);
+  process.stdout.write(`  last tick:   ${result.lastTick ? `${result.lastTick.status}${result.lastTick.reason ? ` (${result.lastTick.reason})` : ''} at ${result.lastTick.tickedAt}` : '(never ticked)'}\n`);
+}
+
+async function cmdCapabilityDryRun(args, { rootDir = process.cwd() } = {}) {
+  const id = positionalId(args);
+  if (!id) {
+    process.stderr.write('Usage: construct embed dry-run <id>\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  const { resolveCapabilityChain } = await import('./capability-lifecycle.mjs');
+  const result = await resolveCapabilityChain(id, { rootDir });
+
+  if (!result.ok) {
+    if (jsonFlag(args)) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      for (const err of result.errors) process.stderr.write(`error: ${err}\n`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  if (jsonFlag(args)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`dry-run '${id}' — resolved chain (no side effects):\n`);
+  process.stdout.write(`  specialist        → ${result.chain.specialist}\n`);
+  process.stdout.write(`  providerBindings  → ${result.chain.providerBindings.join(', ')}\n`);
+  process.stdout.write(`  filter            → ${result.chain.filter ? JSON.stringify(result.chain.filter) : '(none)'}\n`);
+  process.stdout.write(`  framework         → ${result.chain.framework}\n`);
+  process.stdout.write(`  outputContract    → ${result.chain.outputContract}\n`);
+  process.stdout.write(`  proposalAuthority → ${result.chain.proposalAuthority}\n`);
+  process.stdout.write(`  cadence           → ${result.chain.cadence ? JSON.stringify(result.chain.cadence) : '(event-driven only)'}\n`);
+  process.stdout.write(`  runtime           → declared=${result.chain.runtime.declared} resolved=${result.chain.runtime.resolved}${result.chain.runtime.reason ? ` (${result.chain.runtime.reason})` : ''}\n`);
+}
+
 // ---------------------------------------------------------------------------
 // Main export
 // ---------------------------------------------------------------------------
@@ -435,12 +600,23 @@ export async function runEmbedCli(args, opts = {}) {
   const homeDir = opts.homeDir ?? os.homedir();
   const rootDir = opts.rootDir ?? new URL('../..', import.meta.url).pathname;
 
+  // Capability-lifecycle subcommands (ADR-0061) resolve manifests against the
+  // project the operator is standing in, not the Construct package root the
+  // daemon-process subcommands above use for locating worker.mjs.
+  const capabilityRootDir = opts.capabilityRootDir ?? process.cwd();
+
   switch (sub) {
     case 'start':       return cmdEmbedStart(subArgs, { homeDir, rootDir, _workerPath: opts._workerPath, _livenessCheckMs: opts._livenessCheckMs });
     case 'stop':        return cmdEmbedStop(subArgs, { homeDir });
-    case 'status':      return cmdEmbedStatus(subArgs, { homeDir });
+    case 'status':
+      if (positionalId(subArgs)) return cmdCapabilityStatus(subArgs, { rootDir: capabilityRootDir });
+      return cmdEmbedStatus(subArgs, { homeDir });
     case 'snapshot':    return cmdEmbedSnapshot(subArgs, { homeDir });
     case 'migrate-model': return cmdEmbedMigrateModel(subArgs);
+    case 'list':        return cmdCapabilityList(subArgs, { rootDir: capabilityRootDir });
+    case 'enable':      return cmdCapabilityEnable(subArgs, { rootDir: capabilityRootDir });
+    case 'disable':     return cmdCapabilityDisable(subArgs, { rootDir: capabilityRootDir });
+    case 'dry-run':     return cmdCapabilityDryRun(subArgs, { rootDir: capabilityRootDir });
     case 'supervise': {
       const { installSupervision } = await import('./supervision.mjs');
       const result = await installSupervision();
@@ -460,7 +636,8 @@ export async function runEmbedCli(args, opts = {}) {
     }
     default:
       process.stderr.write(
-        `Usage: construct embed <start|stop|status|snapshot|migrate-model|supervise|unsupervise> [--config <path>]\n`,
+        `Usage: construct embed <start|stop|status|snapshot|migrate-model|supervise|unsupervise> [--config <path>]\n` +
+        `       construct embed <list|enable|disable|status|dry-run> <id> [--json]\n`,
       );
       if (sub && sub !== '--help' && sub !== '-h') {
         process.stderr.write(`Unknown subcommand: ${sub}\n`);
@@ -495,7 +672,7 @@ async function cmdEmbedMigrateModel(args) {
 
   const client = createSqlClient(process.env);
   if (!client) {
-    process.stderr.write('No DATABASE_URL configured — nothing to migrate.\n');
+    process.stderr.write('Postgres was removed; nothing to migrate.\n');
     process.exit(1);
   }
 

package/lib/embed/config.mjs

@@ -31,6 +31,10 @@
  *       projects: [PROJ, INFRA]    # OR list
  *       refs: [issues, sprints]
  *       jql: "project = PROJ AND sprint in openSprints()"  # override JQL
+ *       filter:                    # ADR-0060 filter block (LMCP-B11)
+ *         scope: { projects: [PROJ] }
+ *         predicates: { statusCategory: [in-progress], updatedSince: P14D }
+ *         nativeQuery: "sprint in openSprints()"   # optional passthrough
  *
  *   outputs:
  *     - type: markdown            # write snapshot to a file