@geraldmaron/construct 1.0.12 → 1.0.15

package/README.md

@@ -85,6 +85,12 @@ Anything dropped into `.cx/inbox/` (a bug report, a customer comment, a competit
 
 Each signal gets a primary owner and a recommended handoff chain. Inspect with `construct intake list` and `construct intake show <id>`. Generate a task graph with `construct graph from-intake <id>`. The classifier runs in the daemon and is deterministic. The agent in your editor does the actual analysis. [Intake and triage](https://geraldmaron.github.io/construct/concepts/intake-and-triage).
 
+### Document ingestion fidelity
+
+`construct ingest <file>` extracts text from PDF, DOCX, XLSX, PPTX, HTML, plain text, email, and audio/video. High-fidelity extraction is the default and routes through a [docling](https://github.com/docling-project/docling) Python sidecar (MIT, IBM, donated to LF AI & Data) provisioned via [`uv`](https://github.com/astral-sh/uv); audio and video route through [`whisper.cpp`](https://github.com/ggml-org/whisper.cpp) (Metal-accelerated on macOS).
+
+First run downloads `uv` and creates `.cx/runtime/docling/.venv` (~1.5 GB including PyTorch). Audio requires a system `whisper-cli` binary — `brew install whisper-cpp` on macOS. Pass `--strict` to fail on any extraction info loss; pass `--legacy-extractor` to use the pre-docling regex path. Any silent drops (image-heavy PDFs, scanned pages with low OCR yield) are surfaced as `droppedInfo` in the CLI output.
+
 ## Hard gates
 
 Every code mutation runs through enforcement. No secrets committed, tests green, docs current, comments lint-clean, CI passes. Gates live in three places: write-time, commit-time, CI safety net. They can only be bypassed with explicit env vars so every exception leaves an audit trail. [Gates and enforcement](https://geraldmaron.github.io/construct/concepts/gates-and-enforcement).
@@ -93,6 +99,12 @@ Every code mutation runs through enforcement. No secrets committed, tests green,
 
 Construct gets smarter on its own. Every session ends with an automatic capture: tools used, files touched, what the final reply said. That goes into `.cx/observations/` and is searchable from the next session. See [`docs/concepts/learning-loops.mdx`](./docs/concepts/learning-loops.mdx) for what's wired, what's coming, and how to turn pieces off.
 
+## `.cx/` is local-only runtime state
+
+`construct init` writes a runtime state tree at `.cx/` inside the project root: observations, sessions, vector index, intake packets, task graphs, and traces. **It's local-only and must never be committed.** `construct init` adds `.cx/` to your project's `.gitignore` automatically (idempotent: it won't double-add if you already have it). Daily trace shards (`.cx/traces/<date>.jsonl`) cap at 100 MB and rotate to `<date>.<n>.jsonl` so a stray commit never crosses GitHub's single-file limit. Override the cap with `CONSTRUCT_TRACE_MAX_MB`.
+
+The embed daemon writes its supervisor stdout log to `~/.cx/runtime/embed-daemon.log`. That log rotates every minute at 50 MB and keeps 5 gzipped segments by default; override via `CONSTRUCT_EMBED_LOG_MAX_MB` and `CONSTRUCT_EMBED_LOG_MAX_SEGMENTS`.
+
 ## Core commands
 
 <!-- AUTO:commands -->
@@ -215,16 +227,16 @@ Construct gets smarter on its own. Every session ends with an automatic capture:
 <!-- AUTO:structure -->
 ```text
 construct/
-├── apps             User-facing apps shipped from this repo (e.g. apps/docs/, the Fumadocs docs site)
+├── apps             User-facing apps shipped from this repo (e.g. apps/docs/, the Next.js docs site)
 ├── bin              CLI entrypoint (`construct`)
 ├── commands         Command prompt assets
 ├── config
-├── dashboard
 ├── db
 ├── deploy
 ├── docs             Architecture notes, runbooks, and documentation contract
 ├── examples
 ├── lib              Core runtime: CLI, hooks, MCP, status, sync, workflow
+├── packages
 ├── personas         Persona prompt definitions
 ├── platforms
 ├── profiles

package/bin/construct

@@ -416,11 +416,190 @@ async function cmdDoctor() {
     return;
   }
 
+  // --fix-* flags drive auto-remediation for legacy state left behind by
+  // pre-2.0 installs. Layer-2 update triggers (npm i -g postinstall, brew
+  // upgrade) normally handle this; --fix-* is the manual recovery path.
+  // --fix-all runs every available fix.
+
+  const wantsFixAll = args.includes('--fix-all') || args.includes('--fix');
+  const wantsFixGitignore = wantsFixAll || args.includes('--fix-gitignore');
+  const wantsFixLegacyAgents = wantsFixAll || args.includes('--fix-legacy-agents');
+  const wantsFixEmbedLog = wantsFixAll || args.includes('--fix-embed-log');
+  const wantsFixMigrateState = wantsFixAll || args.includes('--fix-migrate-state');
+
   const checks = [];
   const add = (label, pass, optional = false) => checks.push({ label, pass, optional });
   add('registry.json exists', fs.existsSync(path.join(ROOT_DIR, 'specialists', 'registry.json')));
   add('sync-specialists.mjs exists', fs.existsSync(path.join(ROOT_DIR, 'scripts', 'sync-specialists.mjs')));
 
+  // Dashboard static build output. The Next.js app under apps/dashboard
+  // emits a static export into lib/server/static/ via its postbuild script;
+  // an empty static dir means lib/server/index.mjs will serve 404s.
+
+  const dashboardIndex = path.join(ROOT_DIR, 'lib', 'server', 'static', 'index.html');
+  add('Dashboard built (lib/server/static/index.html)', fs.existsSync(dashboardIndex));
+
+  // Project .gitignore must cover .cx/. Auto-fix via --fix-gitignore.
+  // Only checks when cwd looks like a Construct project (has .cx/ or
+  // .construct/); non-project cwds get no warning.
+
+  const cwd = process.cwd();
+  const isProject = fs.existsSync(path.join(cwd, '.cx')) || fs.existsSync(path.join(cwd, '.construct'));
+  if (isProject) {
+    const giPath = path.join(cwd, '.gitignore');
+    const giContent = fs.existsSync(giPath) ? fs.readFileSync(giPath, 'utf8') : '';
+    const lines = giContent.split('\n').map((l) => l.trim());
+    const cxIgnored = lines.some((l) => l === '.cx' || l === '.cx/' || l === '.cx/**' || l === '*' || l === '**');
+    if (!cxIgnored && wantsFixGitignore) {
+      const prefix = giContent.length === 0 || giContent.endsWith('\n') ? '' : '\n';
+      fs.writeFileSync(giPath, giContent + `${prefix}\n# Construct runtime state — local-only, never source\n.cx/\n`, 'utf8');
+      println(`  fix: appended .cx/ to ${path.relative(cwd, giPath)}`);
+      add('Project .gitignore covers .cx/', true);
+    } else {
+      add('Project .gitignore covers .cx/' + (cxIgnored ? '' : ' (run `construct doctor --fix-gitignore` to add)'), cxIgnored);
+    }
+  }
+
+  // Legacy cx-* files at user scope. Layer-2 (npm postinstall, brew
+  // upgrade) sweeps these via `construct sync --global`; this check is
+  // the manual safety net. Counts files matching a registered specialist
+  // name across Claude / Codex / Copilot user-scope dirs.
+
+  const userHome = HOME;
+  const registry = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, 'specialists', 'registry.json'), 'utf8'));
+  const specialistSet = new Set((registry.specialists ?? []).map((s) => `cx-${s.name}`));
+  const legacyTargets = [
+    { dir: path.join(userHome, '.claude', 'agents'), ext: '.md' },
+    { dir: path.join(userHome, '.codex', 'agents'), ext: '.toml' },
+    { dir: path.join(userHome, '.github', 'prompts'), ext: '.prompt.md' },
+  ];
+  let legacyCount = 0;
+  for (const t of legacyTargets) {
+    if (!fs.existsSync(t.dir)) continue;
+    for (const f of fs.readdirSync(t.dir)) {
+      if (!f.endsWith(t.ext)) continue;
+      const base = f.slice(0, -t.ext.length);
+      if (specialistSet.has(base)) legacyCount++;
+    }
+  }
+  if (legacyCount > 0 && wantsFixLegacyAgents) {
+    const syncScript = path.join(ROOT_DIR, 'scripts', 'sync-specialists.mjs');
+    const result = spawnSync(process.execPath, [syncScript, '--global'], { stdio: 'pipe', encoding: 'utf8' });
+    if (result.status === 0) {
+      println(`  fix: swept ${legacyCount} legacy cx-* file(s) from user scope via construct sync --global`);
+      add('No legacy cx-* files at user scope', true);
+    } else {
+      add(`Legacy cx-* sweep failed: ${result.stderr?.substring(0, 200)}`, false);
+    }
+  } else {
+    // Soft-warn instead of hard-fail: legacy v1.0.10 cx-* files are an
+    // expected upgrade-state, not real drift. The hint is what matters;
+    // the fix is one --fix-legacy-agents run away and CI never sees this.
+    // Mirrors the parity check's legacy-install reclassification.
+
+    add(
+      legacyCount === 0
+        ? 'No legacy cx-* files at user scope'
+        : `Legacy cx-* files at user scope: ${legacyCount} (run \`construct doctor --fix-legacy-agents\` to sweep)`,
+      true,
+      legacyCount !== 0,
+    );
+  }
+
+  // Pre-push bypass frequency. Every honored CONSTRUCT_SKIP_PREPUSH /
+  // CONSTRUCT_ALLOW_CLAUDE_PUSH / CONSTRUCT_SKIP_PR_LINT writes a JSONL
+  // entry to ~/.construct/audit/prepush-bypass.log. Surfacing frequent
+  // usage here is the early warning that the gate is the wrong shape —
+  // the alternative is letting the bypass quietly become the default.
+
+  const bypassLogPath = path.join(userHome, '.construct', 'audit', 'prepush-bypass.log');
+  if (fs.existsSync(bypassLogPath)) {
+    try {
+      const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+      const recent = fs.readFileSync(bypassLogPath, 'utf8')
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+        .filter((e) => e && Date.parse(e.ts) >= cutoff);
+      const BYPASS_WARN_THRESHOLD = Number(process.env.CONSTRUCT_DOCTOR_BYPASS_WARN) || 3;
+      if (recent.length >= BYPASS_WARN_THRESHOLD) {
+        add(
+          `Pre-push bypasses in last 7 days: ${recent.length} (gate may be wrong-sized — see ${bypassLogPath})`,
+          false,
+          true,
+        );
+      } else {
+        add(`Pre-push bypasses in last 7 days: ${recent.length}`, true);
+      }
+    } catch { /* audit log read is best-effort */ }
+  } else {
+    add('Pre-push bypass log not present (no bypasses honored yet)', true);
+  }
+
+  // Embed daemon log size. The daemon's own scheduler rotates every
+  // minute at 50MB, but a freshly-upgraded install with a 34GB legacy
+  // log shouldn't wait 60s. --fix-embed-log forces rotation now.
+
+  const embedLogPath = path.join(userHome, '.cx', 'runtime', 'embed-daemon.log');
+  if (fs.existsSync(embedLogPath)) {
+    const sizeMb = fs.statSync(embedLogPath).size / 1024 / 1024;
+    const FORCE_THRESHOLD_MB = Number(process.env.CONSTRUCT_DOCTOR_EMBED_LOG_FORCE_MB) || 500;
+    if (sizeMb > FORCE_THRESHOLD_MB && wantsFixEmbedLog) {
+      const { rotateIfOversized } = await import('../lib/logging/rotate.mjs');
+      println(`  fix: rotating ${sizeMb.toFixed(0)}MB embed-daemon.log (gzipping may take a moment)…`);
+      const start = Date.now();
+      const seg = await rotateIfOversized(embedLogPath, { maxBytes: 1, maxSegments: 5, gzip: true });
+      const elapsed = ((Date.now() - start) / 1000).toFixed(0);
+      println(`  fix: rotated to ${path.basename(seg)} in ${elapsed}s`);
+      add('Embed daemon log size sane', true);
+    } else {
+      const label = sizeMb > FORCE_THRESHOLD_MB
+        ? `Embed daemon log oversized: ${sizeMb.toFixed(0)}MB (run \`construct doctor --fix-embed-log\` to rotate now)`
+        : `Embed daemon log size: ${sizeMb.toFixed(1)}MB`;
+      add(label, sizeMb <= FORCE_THRESHOLD_MB);
+    }
+  }
+
+  // Legacy ~/.cx/<project-scoped>.jsonl files left over from before the
+  // cross-project state isolation refactor. Four files moved from user
+  // scope to <project>/.cx/: contract-violations, audit-reads, agent-log,
+  // intent-verifications. Pre-refactor data still sits at ~/.cx/ where it
+  // mixed every project together. --fix-migrate-state archives them to
+  // ~/.cx/legacy/<name>.<ts>.jsonl so the new writers start fresh; the
+  // legacy data stays readable for forensics.
+
+  const projectScopedNames = [
+    'contract-violations.jsonl',
+    'audit-reads.jsonl',
+    'agent-log.jsonl',
+    'intent-verifications.jsonl',
+  ];
+  const legacyState = projectScopedNames
+    .map((name) => ({ name, path: path.join(userHome, '.cx', name) }))
+    .filter((p) => fs.existsSync(p.path) && fs.statSync(p.path).size > 0);
+
+  if (legacyState.length > 0 && wantsFixMigrateState) {
+    const archiveDir = path.join(userHome, '.cx', 'legacy');
+    fs.mkdirSync(archiveDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const moved = [];
+    for (const { name, path: src } of legacyState) {
+      const dest = path.join(archiveDir, `${name.replace('.jsonl', '')}.${ts}.jsonl`);
+      fs.renameSync(src, dest);
+      moved.push(path.basename(dest));
+    }
+    println(`  fix: archived ${moved.length} legacy user-scope file(s) to ~/.cx/legacy/`);
+    for (const m of moved) println(`         → ${m}`);
+    add('No legacy user-scope project-state files', true);
+  } else {
+    add(
+      legacyState.length === 0
+        ? 'No legacy user-scope project-state files'
+        : `Legacy user-scope project-state files: ${legacyState.length} (run \`construct doctor --fix-migrate-state\` to archive)`,
+      legacyState.length === 0,
+    );
+  }
+
   // Tier model selection. Construct ships with no default — at least
   // one tier must be configured (registry.json primary OR CX_MODEL_*
   // env override) before any LLM-backed workflow can run.
@@ -704,7 +883,11 @@ async function cmdDoctor() {
     try {
       const { checkParity } = await import('../lib/parity.mjs');
       const parity = checkParity({ rootDir: ROOT_DIR, homeDir: HOME });
-      add(`Cross-surface adapter parity (${parity.summary.join(' · ')})`, parity.ok);
+      // Legacy-install rolls up to ok (so the gate doesn't hard-fail during
+      // a v1.0.10 → v1.0.13+ upgrade) but renders as a warning so the
+      // --fix-legacy-agents hint stays visible.
+      const hasLegacy = parity.surfaces.some((s) => s.status === 'legacy-install');
+      add(`Cross-surface adapter parity (${parity.summary.join(' · ')})`, parity.ok, hasLegacy);
     } catch {
       add('Cross-surface adapter parity', false);
     }
@@ -734,7 +917,7 @@ async function cmdDoctor() {
     }
 
     try {
-      const { recentViolations } = await import('../lib/specialist-contracts-enforce.mjs');
+      const { recentViolations } = await import('../lib/contracts/violation-log.mjs');
       const violations = recentViolations({ windowMs: 24 * 60 * 60 * 1000 });
       const label = violations.length === 0
         ? 'Contract violations (none in last 24h)'
@@ -1415,12 +1598,12 @@ async function cmdHandoffs(args) {
   }
 
   if (sub === 'validate') {
-    const { parseHandoffFile, validateHandoff } = await import('../lib/handoffs/contract.mjs');
+    const { parseHandoffFile, validateHandoffFile } = await import('../lib/handoffs/contract.mjs');
     if (summary.state === 'empty') { info('No handoffs to validate.'); return; }
     let hasErrors = false;
     for (const f of summary.files) {
       const parsed = parseHandoffFile(f.path);
-      const { valid, errors } = validateHandoff(parsed);
+      const { valid, errors } = validateHandoffFile(parsed);
       if (valid) {
         println(`✓ ${f.filename}`);
       } else {
@@ -1643,6 +1826,10 @@ async function printIntakeHelp() {
   println('  construct intake done <id> [--notes=…] [--output=<path>] [--no-output=<rejected|deferred|merged>]');
   println('                                       Mark a pending packet processed. --output stamps intake_id + confidence into the artifact frontmatter (provenance).');
   println('  construct intake skip <id> [--reason=…]   Mark a pending packet skipped (preserves audit trail).');
+  println('  construct intake process [--dry-run] [--wait[=<sec>]]');
+  println('                                       One-shot inbox sweep — same logic the daemon runs, exits when the queue is empty.');
+  println('                                       Concurrency is controlled by a poll lock — fail-fast by default, --wait[=<sec>] blocks for up to N seconds.');
+  println('                                       --dry-run lists candidate inboxes without ingesting.');
   println('  construct intake reopen <id>         Move a processed or skipped packet back to pending.');
   println('  construct intake quarantine list             List packets held for human review (low confidence or close margin).');
   println('  construct intake quarantine show <id>        Show a quarantined packet with top-3 candidate types and margins.');
@@ -1910,6 +2097,10 @@ async function cmdIntake(args) {
     return await cmdIntakeIntegrate(id, args.slice(2), cwd);
   }
 
+  if (sub === 'process') {
+    return await cmdIntakeProcess(args.slice(1), cwd);
+  }
+
   if (sub === 'config') {
     return await cmdIntakeConfig(args.slice(1));
   }
@@ -1922,10 +2113,75 @@ async function cmdIntake(args) {
     return await cmdIntakeNeedsAsr(args.slice(1));
   }
 
-  errorln(`Unknown intake subcommand: ${sub}. Available: list, show, done, skip, reopen, quarantine, reroute, integrate, config, extraction-warnings, needs-asr`);
+  errorln(`Unknown intake subcommand: ${sub}. Available: list, show, done, skip, reopen, process, quarantine, reroute, integrate, config, extraction-warnings, needs-asr`);
   process.exit(1);
 }
 
+async function cmdIntakeProcess(args, cwd) {
+  const dryRun = args.includes('--dry-run');
+  const waitFlag = args.find((a) => a === '--wait' || a.startsWith('--wait='));
+  const { InboxWatcher, resolveInboxDirs } = await import('../lib/embed/inbox.mjs');
+
+  if (dryRun) {
+    const dirs = resolveInboxDirs(cwd, process.env);
+    if (dirs.length === 0) {
+      println('No inbox directories configured. Run `construct intake config` to add one.');
+      return;
+    }
+    println('Would scan:');
+    for (const d of dirs) println(`  ${d}`);
+    println('');
+    println('(dry-run — no files processed; re-run without --dry-run to actually ingest.)');
+    return;
+  }
+
+  // Concurrency is controlled by the intake poll lock inside
+  // InboxWatcher.poll. Default behavior is fail-fast: if the daemon (or
+  // another CLI invocation) is mid-poll, raise an actionable error rather
+  // than serializing silently. --wait[=<seconds>] opts into blocking for
+  // up to N seconds (default 30s when --wait is bare).
+
+  let waitMs = 0;
+  if (waitFlag) {
+    const m = /^--wait(?:=(\d+))?$/.exec(waitFlag);
+    const seconds = m && m[1] ? Number(m[1]) : 30;
+    waitMs = Math.max(0, seconds) * 1000;
+  }
+
+  const watcher = new InboxWatcher({ rootDir: cwd, env: process.env, cwd });
+  let result;
+  try {
+    result = await watcher.poll({ waitMs, actor: 'construct intake process' });
+  } catch (err) {
+    const { POLL_LOCK_BUSY } = await import('../lib/intake/poll-lock.mjs');
+    if (err && err.code === POLL_LOCK_BUSY) {
+      const holder = err.holder || {};
+      errorln('Another intake poll is in progress.');
+      errorln(`  holder: ${holder.actor || 'unknown'} (pid ${holder.pid})`);
+      errorln(`  started: ${holder.startedAt || 'unknown'}`);
+      errorln('');
+      errorln('Choose one:');
+      errorln('  construct intake process --wait        Block until the holder finishes (default 30s).');
+      errorln('  construct intake process --wait=<sec>  Block for a custom window.');
+      errorln('  construct down                          Stop background services, then retry.');
+      process.exit(2);
+    }
+    throw err;
+  }
+
+  println(`Processed: ${result.processed.length}`);
+  println(`Skipped (unchanged): ${result.skipped}`);
+  if (result.errors.length) {
+    println(`Errors: ${result.errors.length}`);
+    for (const e of result.errors) println(`  ${e.path}: ${e.error}`);
+  }
+  for (const item of result.processed) {
+    const note = item.needsAsr ? ' (queued for ASR)' : '';
+    println(`  + ${item.path}${note}`);
+  }
+  if (result.errors.length) process.exitCode = 1;
+}
+
 async function cmdIntakeQuarantine(args, cwd) {
   const action = args[0];
   const { listQuarantine, readQuarantine } = await import('../lib/intake/quarantine.mjs');
@@ -4584,14 +4840,6 @@ const handlers = new Map([
       process.exit(1);
     }
   }],
-  ['policy:list', async (args) => {
-    const { listPolicies, formatPolicyList } = await import('../lib/policy/unified-gates.mjs');
-    if (args.includes('--json')) {
-      println(JSON.stringify(listPolicies(), null, 2));
-    } else {
-      process.stdout.write(formatPolicyList());
-    }
-  }],
   ['policy', async (args) => {
     const sub = args[0];
     if (!sub || sub === '--help' || sub === '-h') {
@@ -4602,7 +4850,7 @@ const handlers = new Map([
     if (sub === 'show') {
       const { readFileSync, existsSync } = await import('node:fs');
       const { join } = await import('node:path');
-      const inventoryPath = join(ROOT_DIR, 'agents', 'policy-inventory.json');
+      const inventoryPath = join(ROOT_DIR, 'specialists', 'policy-inventory.json');
       if (!existsSync(inventoryPath)) {
         errorln('specialists/policy-inventory.json not found');
         process.exit(1);

package/bin/construct-postinstall.mjs

@@ -58,8 +58,29 @@ try {
   }
 } catch { /* fall through */ }
 
-// Require a package.json at the install target so monorepo nested installs
-// don't accidentally trigger staging in the wrong directory.
+// `npm i -g @geraldmaron/construct` runs the postinstall with
+// npm_config_global=true. Wire the `construct` front-door agent into the
+// user's home directories so it's reachable from every host (Claude Code,
+// Codex, Copilot, OpenCode) immediately after a global install. Specialists
+// stay project-only and land when the user runs `construct init` in a repo.
+
+if (process.env.npm_config_global === 'true' || process.env.npm_config_global === true) {
+  const syncScript = path.join(PKG_ROOT, 'scripts', 'sync-specialists.mjs');
+  if (existsSync(syncScript)) {
+    log('global install detected; syncing front-door agent into ~/');
+    const result = spawnSync(process.execPath, [syncScript, '--global'], {
+      stdio: 'inherit',
+    });
+    if (result.status !== 0) {
+      log(`global sync failed (exit ${result.status}); run \`construct sync --global\` manually`);
+    }
+  }
+  process.exit(0);
+}
+
+// Project install path: require a package.json at the install target so
+// monorepo nested installs don't accidentally trigger staging in the wrong
+// directory.
 
 const consumerPkgPath = path.join(initCwd, 'package.json');
 if (!existsSync(consumerPkgPath)) {

package/commands/build/feature.md

@@ -1,12 +1,6 @@
-<!--
-commands/build/feature.md (Build a feature) implement it end to end, tested and ready to ship
-
-Build a feature: implement it end to end, tested and ready to ship
--->
 ---
 description: "Build a feature: implement it end to end, tested and ready to ship"
 ---
-
 You are Construct. Build the following: $ARGUMENTS
 
 Before writing a line:

package/commands/build/fix.md

@@ -1,12 +1,6 @@
-<!--
-commands/build/fix.md (Fix something broken) reproduce, find the root cause, apply the smallest safe change
-
-Fix something broken: reproduce, find the root cause, apply the smallest safe change
--->
 ---
 description: "Fix something broken: reproduce, find the root cause, apply the smallest safe change"
 ---
-
 You are Construct.
 
 Debugging protocol for: $ARGUMENTS

package/commands/design/access.md

@@ -1,12 +1,6 @@
-<!--
-commands/design/access.md (Accessibility audit) WCAG 2.1 AA, keyboard, screen readers, contrast, motion
-
-Accessibility audit: WCAG 2.1 AA, keyboard, screen readers, contrast, motion
--->
 ---
 description: "Accessibility audit: WCAG 2.1 AA, keyboard, screen readers, contrast, motion"
 ---
-
 You are Construct. Audit: $ARGUMENTS
 
 WCAG 2.1 AA baseline:

package/commands/design/flow.md

@@ -1,12 +1,6 @@
-<!--
-commands/design/flow.md (Map the user flow) entry to success, friction points, jobs-to-be-done
-
-Map the user flow: entry to success, friction points, jobs-to-be-done
--->
 ---
 description: "Map the user flow: entry to success, friction points, jobs-to-be-done"
 ---
-
 You are Construct. Map the user flow for: $ARGUMENTS
 
 Produce:

package/commands/design/ui.md

@@ -1,12 +1,6 @@
-<!--
-commands/design/ui.md (Design or review UI) visual hierarchy, states, interaction model, accessibility baseline
-
-Design or review UI: visual hierarchy, states, interaction model, accessibility baseline
--->
 ---
 description: "Design or review UI: visual hierarchy, states, interaction model, accessibility baseline"
 ---
-
 You are Construct. Design or review the UI for: $ARGUMENTS
 
 Every meaningful UI surface needs:

package/commands/measure/experiment.md

@@ -1,12 +1,6 @@
-<!--
-commands/measure/experiment.md (Design an experiment) hypothesis, test, evidence threshold, go/no-go decision
-
-Design an experiment: hypothesis, test, evidence threshold, go/no-go decision
--->
 ---
 description: "Design an experiment: hypothesis, test, evidence threshold, go/no-go decision"
 ---
-
 You are Construct. Design an experiment for: $ARGUMENTS
 
 Produce:

package/commands/measure/metrics.md

@@ -1,12 +1,6 @@
-<!--
-commands/measure/metrics.md (Define metrics) what to measure, baselines, success thresholds, instrumentation needed
-
-Define metrics: what to measure, baselines, success thresholds, instrumentation needed
--->
 ---
 description: "Define metrics: what to measure, baselines, success thresholds, instrumentation needed"
 ---
-
 You are Construct. Define metrics for: $ARGUMENTS
 
 For each metric:

package/commands/measure/results.md

@@ -1,12 +1,6 @@
-<!--
-commands/measure/results.md (Analyze results) interpret data, separate signal from noise, produce a recommendation
-
-Analyze results: interpret data, separate signal from noise, produce a recommendation
--->
 ---
 description: "Analyze results: interpret data, separate signal from noise, produce a recommendation"
 ---
-
 You are Construct. Analyze: $ARGUMENTS
 
 For each finding:

package/commands/plan/api.md

@@ -1,12 +1,6 @@
-<!--
-commands/plan/api.md (Design an API) contracts, endpoints, error model, data schema
-
-Design an API: contracts, endpoints, error model, data schema
--->
 ---
 description: "Design an API: contracts, endpoints, error model, data schema"
 ---
-
 You are Construct. Design the API for: $ARGUMENTS
 
 Produce:

package/commands/plan/challenge.md

@@ -1,12 +1,6 @@
-<!--
-commands/plan/challenge.md (Challenge a plan) stress-test assumptions, surface failure modes and risks
-
-Challenge a plan: stress-test assumptions, surface failure modes and risks
--->
 ---
 description: "Challenge a plan: stress-test assumptions, surface failure modes and risks"
 ---
-
 You are Construct. Challenge the following: $ARGUMENTS
 
 Challenge in severity order:

package/commands/plan/decide.md

@@ -1,12 +1,6 @@
-<!--
-commands/plan/decide.md (Record a decision) context, options considered, consequences, what it locks in
-
-Record a decision: context, options considered, consequences, what it locks in
--->
 ---
 description: "Record a decision: context, options considered, consequences, what it locks in"
 ---
-
 You are Construct. Document the decision about: $ARGUMENTS
 
 ADR format:

package/commands/plan/feature.md

@@ -1,13 +1,6 @@
-<!--
-commands/plan/feature.md: Plan a feature and turn it into a tracker-linked implementation plan
-
-Produces a structured spec using the canonical Construct plan format, saves it
-to .cx/plans/ as a durable planning artifact linked to the active tracker slice.
--->
 ---
 description: "Plan a feature: produce a structured spec and link it to the active tracker-backed plan"
 ---
-
 You are Construct. Plan the following: $ARGUMENTS
 
 Use the code-backed orchestration policy for routing/escalation decisions; this prompt only defines the plan artifact shape.

package/commands/plan/requirements.md

@@ -1,12 +1,6 @@
-<!--
-commands/plan/requirements.md (Define requirements) what needs to be true for this to be done
-
-Define requirements: what needs to be true for this to be done
--->
 ---
 description: "Define requirements: what needs to be true for this to be done"
 ---
-
 You are Construct. Define requirements for: $ARGUMENTS
 
 Produce:

package/commands/remember/context.md

@@ -1,12 +1,6 @@
-<!--
-commands/remember/context.md (Save project context) update .cx/context.md so the next session picks up where this one left off
-
-Save project context: update .cx/context.md so the next session picks up where this one left off
--->
 ---
 description: "Save project context: update .cx/context.md so the next session picks up where this one left off"
 ---
-
 You are Construct. Save context for: $ARGUMENTS
 
 Update `.cx/context.json` as canonical state and refresh `.cx/context.md` as the readable mirror:

package/commands/remember/handoff.md

@@ -1,12 +1,6 @@
-<!--
-commands/remember/handoff.md (Write a handoff) transfer context so the next session or person can continue without loss
-
-Write a handoff: transfer context so the next session or person can continue without loss
--->
 ---
 description: "Write a handoff: transfer context so the next session or person can continue without loss"
 ---
-
 You are Construct. Write a handoff for: $ARGUMENTS
 
 - CURRENT STATE: what is working, in progress, blocked

package/commands/remember/runbook.md

@@ -1,12 +1,6 @@
-<!--
-commands/remember/runbook.md (Write a runbook) step-by-step procedure for a recurring task or incident
-
-Write a runbook: step-by-step procedure for a recurring task or incident
--->
 ---
 description: "Write a runbook: step-by-step procedure for a recurring task or incident"
 ---
-
 You are Construct. Write a runbook for: $ARGUMENTS
 
 Structure: