@geraldmaron/construct 1.1.0 → 1.1.1

package/scripts/sync-specialists.mjs

@@ -44,9 +44,11 @@ import {
   writeCodexConfig,
 } from "../lib/codex-config.mjs";
 import { findOpenCodeConfigPath, readOpenCodeConfig, writeOpenCodeConfig } from "../lib/opencode-config.mjs";
-import { HEAVY_EXTERNAL_MCP_IDS, LOCAL_SURFACE_MODES, decideTrim } from "../lib/mcp/tool-budget.mjs";
+import { HEAVY_EXTERNAL_MCP_IDS, LOCAL_SURFACE_MODES, decideTrim, isLocalModel } from "../lib/mcp/tool-budget.mjs";
 import { emitCursorRules } from "../lib/rules-delivery.mjs";
-import { resolvePromptContract } from "../lib/prompt-composer.js";
+import { resolvePromptContract, readPromptBody } from "../lib/prompt-composer.js";
+import { renderPersonaForTier } from "../lib/persona-sections.mjs";
+import { getModelVerdict } from "../lib/ollama/capability-store.mjs";
 import {
   buildClaudeMcpEntry,
   buildOpenCodeMcpEntry,
@@ -56,7 +58,7 @@ import { loadConstructEnv } from "../lib/env-config.mjs";
 import { inlineRoleAntiPatterns, PROMPT_WORD_CAP } from "../lib/role-preload.mjs";
 import { loadManifest } from "../lib/roles/manifest.mjs";
 import { resolveActiveProfile } from "../lib/profiles/loader.mjs";
-import { resolveTiersForPrimary } from "../lib/model-router.mjs";
+import { resolveTiersForPrimary, resolveCapabilityTier, selectLocalEditorModel } from "../lib/model-router.mjs";
 import { stampFrontmatter } from "../lib/doc-stamp.mjs";
 import { buildSkillFrontmatter, stripLeadingFrontmatter } from "../lib/sync/skill-frontmatter.mjs";
 
@@ -602,7 +604,83 @@ export function renderRoleFrameworkSection(entry) {
   return `\n\n${lines.join("\n")}`;
 }
 
-function buildPrompt(entry, allEntries, platform) {
+// The native-subagent orchestration micro-prompt. A worked tool-call example lifts
+// small local models' tool-use reliability sharply (bead construct-c16l). Shared by the
+// full path and the capability-tiered local path so both stay in sync.
+
+const ORCHESTRATION_MICRO_PROMPT =
+  `You are the primary orchestrator. To discover available specialist agents, you MUST call the \`orchestration_policy\` MCP tool. Do not guess agent names.\n\n` +
+  `Example — the user says "add rate limiting to the API". Your first action is a tool call, not prose:\n` +
+  `  call orchestration_policy { "task": "add rate limiting to the API" }\n` +
+  `Then dispatch the specialists it returns. Always call the tool before answering.`;
+
+// Directive for the local editor agent (construct-local). It executes bounded work on
+// the cheap local model and hands planning/reasoning back to the construct architect —
+// the aider architect/editor split. Kept short: a small model must actually obey it.
+
+const LOCAL_EDITOR_DIRECTIVE =
+  `You are a focused execution agent running on a local model, dispatched by construct to do one bounded job. Do well-scoped edits for the current task and verify them; make the smallest correct change, never a broad rewrite.\n` +
+  `You do NOT plan, classify, orchestrate, or spawn other agents. For anything needing multi-file design, architecture or security judgment, dependency or contract changes, or research, STOP and return control to construct — report what needs deeper work and why, rather than attempting it yourself.`;
+
+// Warn-and-emit capability advisory. Sizing already consumes the probe verdict
+// (COLLAPSED → floor tier via resolveCapabilityTier); this only nudges the user toward a
+// measured verdict and never suppresses emission. Notice-only, so it auto-suppresses in
+// CI / test / non-TTY per the repo's wrong-context rule — no skip env var.
+
+const localAdvisorySeen = new Set();
+function adviseLocalModelCapability(model) {
+  if (!model || !isLocalModel(model)) return;
+  if (process.env.CI === "true" || process.env.NODE_ENV === "test" || !process.stderr.isTTY) return;
+  if (localAdvisorySeen.has(model)) return;
+  localAdvisorySeen.add(model);
+  const verdict = getModelVerdict(model)?.verdict ?? null;
+  if (verdict === "COLLAPSED") {
+    console.warn(`[sync] ${model} probed COLLAPSED — emitting at the floor tier with escalation to construct. Re-probe after a Modelfile change: construct doctor --probe-local`);
+  } else if (!verdict) {
+    console.warn(`[sync] ${model} is local with no coherence verdict — tier inferred from parameter count. For a measured tier: construct doctor --probe-local`);
+  }
+}
+
+function enforcePromptWordCap(prompt, entry) {
+  const wordCount = prompt.split(/\s+/).filter(Boolean).length;
+  const effectiveCap = Number(entry.wordCapOverride) > 0 ? entry.wordCapOverride : PROMPT_WORD_CAP;
+  if (wordCount > effectiveCap) {
+    const msg = `[sync] ${entry.name}: prompt is ${wordCount} words (cap ${effectiveCap})`;
+    if (process.env.CONSTRUCT_SYNC_FORCE === '1' || process.argv.includes('--force')) {
+      console.warn(`${msg} — proceeding due to --force / CONSTRUCT_SYNC_FORCE=1.`);
+    } else {
+      console.error(`${msg}`);
+      console.error(
+        `[sync] Hard cap exceeded. Options:\n` +
+        `   - trim the prompt body or move detail to a skill (preferred)\n` +
+        `   - set "wordCapOverride": <N> on this entry in specialists/registry.json with a written reason\n` +
+        `   - re-run with --force or CONSTRUCT_SYNC_FORCE=1 as a temporary escape hatch\n` +
+        `Prompt budget is a hard contract because every over-cap agent degrades every session that dispatches it.`,
+      );
+      process.exit(1);
+    }
+  }
+  return prompt;
+}
+
+function buildPrompt(entry, allEntries, platform, { capabilityTier = 'full' } = {}) {
+  const capabilities = { hasNativeSubagents: HOST_KEYS.includes(platform) ? hostHasNativeSubagents(platform) : false };
+
+  // Capability-tiered local path. A small local model follows a long multi-instruction
+  // persona poorly (instruction-following degrades before the window fills), so emit
+  // only the persona sections at/below its tier plus the orchestration micro-prompt, and
+  // skip the role footer, role-framework, operating-guidance, and model-family blocks —
+  // those add instruction load the model cannot track. Cloud models resolve to 'full'
+  // and take the unchanged path below, so cloud configs are never slimmed.
+
+  if (capabilityTier && capabilityTier !== 'full' && entry.promptFile) {
+    let slim = renderPersonaForTier(readPromptBody(entry.promptFile, root), capabilityTier);
+    if (entry.injectAgentRoster && capabilities.hasNativeSubagents) {
+      slim = `${ORCHESTRATION_MICRO_PROMPT}\n\n${slim}`;
+    }
+    return enforcePromptWordCap(slim, entry);
+  }
+
   let prompt = resolvePromptContract(entry, {
     rootDir: root,
     registry,
@@ -611,8 +689,6 @@ function buildPrompt(entry, allEntries, platform) {
 
   prompt = inlineRoleAntiPatterns(prompt, root, entry.name, console.warn, { preload: entry.preloadRoleGuidance === true });
 
-  const capabilities = { hasNativeSubagents: HOST_KEYS.includes(platform) ? hostHasNativeSubagents(platform) : false };
-
   // Platform-Native Orchestration Alignment (ADR-0002). Hosts with native subagent
   // routing (OpenCode, VS Code, Cursor) do not get the static specialist roster
   // injected — on a small-context local model the roster alone is ~3-4k tokens and,
@@ -625,14 +701,7 @@ function buildPrompt(entry, allEntries, platform) {
     const roster = buildAgentRoster(allEntries);
     prompt = `Available specialist agents:\n${roster}\n\n${prompt}`;
   } else if (entry.injectAgentRoster && capabilities.hasNativeSubagents) {
-    // A worked tool-call example lifts small local models' tool-use reliability
-    // sharply (bead construct-c16l). Keep it to one compact turn so it stays within
-    // the prompt word cap; native-subagent hosts are exactly where local models run.
-
-    prompt = `You are the primary orchestrator. To discover available specialist agents, you MUST call the \`orchestration_policy\` MCP tool. Do not guess agent names.\n\n` +
-      `Example — the user says "add rate limiting to the API". Your first action is a tool call, not prose:\n` +
-      `  call orchestration_policy { "task": "add rate limiting to the API" }\n` +
-      `Then dispatch the specialists it returns. Always call the tool before answering.\n\n${prompt}`;
+    prompt = `${ORCHESTRATION_MICRO_PROMPT}\n\n${prompt}`;
   }
 
   prompt += buildRoleFooter(entry);
@@ -648,26 +717,7 @@ function buildPrompt(entry, allEntries, platform) {
 
   prompt += buildModelGuidanceBlock(entry);
 
-  const wordCount = prompt.split(/\s+/).filter(Boolean).length;
-  const effectiveCap = Number(entry.wordCapOverride) > 0 ? entry.wordCapOverride : PROMPT_WORD_CAP;
-  if (wordCount > effectiveCap) {
-    const msg = `[sync] ${entry.name}: prompt is ${wordCount} words (cap ${effectiveCap})`;
-    if (process.env.CONSTRUCT_SYNC_FORCE === '1' || process.argv.includes('--force')) {
-      console.warn(`${msg} — proceeding due to --force / CONSTRUCT_SYNC_FORCE=1.`);
-    } else {
-      console.error(`${msg}`);
-      console.error(
-        `[sync] Hard cap exceeded. Options:\n` +
-        `   - trim the prompt body or move detail to a skill (preferred)\n` +
-        `   - set "wordCapOverride": <N> on this entry in specialists/registry.json with a written reason\n` +
-        `   - re-run with --force or CONSTRUCT_SYNC_FORCE=1 as a temporary escape hatch\n` +
-        `Prompt budget is a hard contract because every over-cap agent degrades every session that dispatches it.`,
-      );
-      process.exit(1);
-    }
-  }
-
-  return prompt;
+  return enforcePromptWordCap(prompt, entry);
 }
 
 function escapeRegExp(value) { return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); }
@@ -1638,6 +1688,20 @@ function syncOpencode(entries, targetDir = null, wants = true) {
   }
 
   // Write agents — no model/modelFallback set; agents inherit the global model.
+  //
+  // Capability tier for the orchestrator prompt. Keyed ONLY to an EXPLICIT local default
+  // model — that is a clear intent signal we can size against at sync time. With no
+  // explicit default (the orchestrator runs whatever model the user picks at runtime) or
+  // a cloud default, resolveCapabilityTier returns 'full', so cloud configs and unknown
+  // selections are never slimmed. Per-model slimming of a known pinned model lands on the
+  // construct-local editor agent.
+
+  const orchestratorDefaultModel = config.model || config.defaultModel || "";
+  adviseLocalModelCapability(orchestratorDefaultModel);
+  const orchestratorTier = resolveCapabilityTier({
+    model: orchestratorDefaultModel,
+    verdict: orchestratorDefaultModel ? (getModelVerdict(orchestratorDefaultModel)?.verdict ?? null) : null,
+  });
 
   for (const entry of writeEntries) {
     const name = adapterName(entry);
@@ -1647,7 +1711,9 @@ function syncOpencode(entries, targetDir = null, wants = true) {
         ? `${entry.role} — ${entry.description}`
         : entry.description,
       mode: entry.isOrchestrator ? "all" : "subagent",
-      prompt: buildPrompt(entry, entries, "opencode"),
+      prompt: buildPrompt(entry, entries, "opencode", {
+        capabilityTier: entry.isOrchestrator ? orchestratorTier : "full",
+      }),
       permission: {
         ...perms,
         task: opencodeTaskPermissions(entry),
@@ -1655,6 +1721,54 @@ function syncOpencode(entries, targetDir = null, wants = true) {
     };
   }
 
+  // Hybrid split (aider architect/editor). When the fast tier is a LOCAL model, emit a
+  // narrow `construct-local` editor: it does bounded edits on a cheap local model and hands
+  // planning/reasoning back to `construct` (the architect, which stays on the user's chosen
+  // model — we never pin it). The editor's model is NOT the generic fast-tier default
+  // (which for an Ollama family resolves to a non-code generalist); it is the best-installed
+  // CODE model from this config's DECLARED local inventory (OpenCode only uses declared
+  // models), excluding probe-COLLAPSED ones, with the fast tier as a last resort. Its prompt
+  // is sized to the chosen model's capability tier. Deterministic name, so manage it
+  // explicitly: emit when fast is local, delete otherwise, so switching to cloud cleans up.
+
+  const orchestratorEntry = writeEntries.find((e) => e.isOrchestrator) || registry.orchestrator;
+  const orchestratorName = orchestratorEntry ? adapterName(orchestratorEntry) : "construct";
+  const localEditorName = `${orchestratorName}-local`;
+  if (orchestratorEntry?.promptFile && isLocalModel(resolvedModels.fast)) {
+    const declaredLocal = Object.entries(config.provider || {})
+      .flatMap(([pid, pv]) => Object.keys(pv?.models || {}).map((mk) => `${pid}/${mk}`))
+      .filter((id) => isLocalModel(id) && getModelVerdict(id)?.verdict !== "COLLAPSED");
+    const editorModel = selectLocalEditorModel(declaredLocal) || resolvedModels.fast;
+    adviseLocalModelCapability(editorModel);
+    const editorVerdict = getModelVerdict(editorModel)?.verdict ?? null;
+    const editorTier = resolveCapabilityTier({ model: editorModel, verdict: editorVerdict });
+    const editorBody = renderPersonaForTier(readPromptBody(orchestratorEntry.promptFile, root), editorTier);
+    config.agent[localEditorName] = {
+      description: "Local execution agent — bounded edits on the local model; escalates planning and reasoning to construct.",
+      mode: "subagent",
+      model: editorModel,
+      prompt: `${LOCAL_EDITOR_DIRECTIVE}\n\n${editorBody}`,
+      permission: {
+        edit: "allow",
+        bash: { "*": "allow", "rm -rf *": "deny", "git push *": "ask", "git push --force*": "ask", "git reset --hard *": "ask" },
+        "mcp__construct-mcp__orchestration_policy": "deny",
+        "mcp__construct-mcp__agent_contract": "deny",
+        "mcp__construct-mcp__broker_check": "deny",
+        "mcp__github__*": "deny",
+        "mcp__context7__*": "deny",
+        "mcp__sequential-thinking__*": "deny",
+        "mcp__memory__*": "deny",
+        // OpenCode 1.15.4 disables the `task` tool entirely for any restrictive task map
+        // (verified in a sterile run). For an editor that is exactly right: it spawns no
+        // subagents and escalates by RETURNING to the construct agent that dispatched it,
+        // not by dispatching. Deny-all states that intent directly.
+        task: { "*": "deny" },
+      },
+    };
+  } else {
+    delete config.agent[localEditorName];
+  }
+
   // Pass current Construct model tiers to OpenCode config for native routing.
   config.construct = config.construct || {};
   config.construct.models = { ...resolvedModels };

package/skills/docs/init-project.md

@@ -32,7 +32,7 @@ docs/                   ← human-readable project documentation
 1. Treat `.cx/context.md`, `.cx/context.json`, `.cx/workflow.json`, `docs/README.md`, and `docs/architecture.md` as required project state.
 2. Read them at the start of every meaningful session.
 3. Update them whenever work changes active reality: decisions, workflow phase, architecture assumptions, or documentation contract.
-4. Run `construct serve` to see the project in the dashboard.
+4. Run `construct dashboard` to see the project in the dashboard.
 
 ## For cx-docs-keeper
 At session start, check the core docs set. If missing, suggest running `construct init-docs`.

package/templates/docs/construct_guide.md

@@ -109,7 +109,7 @@ All ports bind to `127.0.0.1` only; nothing is reachable from other machines on
 | `construct config [mode <m>]` | Show active deployment mode (solo / team / enterprise) or set a new one |
 | `construct doctor` | Health check across config, services, agents, hooks |
 | `construct sync` | Regenerate platform adapters (Claude Code, OpenCode, Codex, Cursor) |
-| `construct up` / `construct down` | Start / stop local services |
+| `construct dev` / `construct stop` | Start / stop local services |
 | `construct status` | Live runtime status (services, providers, daemons) |
 | `construct intake list / show / done / skip / reopen` | Drive the R&D intake queue produced from `.cx/inbox/` |
 | `construct graph from-intake <id>` | Generate a task graph from a triaged intake packet |
@@ -131,7 +131,7 @@ That refreshes the agents, hooks, and slash commands in `.claude/` and `.constru
 
 ```bash
 construct doctor              # most issues surface here with a fix hint
-construct down && construct up  # restart local services
+construct stop && construct dev  # restart local services
 ```
 
 Troubleshooting guide: <https://geraldmaron.github.io/construct/docs/operations/troubleshooting>

package/lib/ingest/chunker.mjs

@@ -1,94 +0,0 @@
-/**
- * lib/ingest/chunker.mjs — paragraph-boundary chunker with sentence overlap.
- *
- * 2026-06 best practice notes:
- *   - Recursive/sentence chunking remains the high-recall default (~85-90%
- *     on 2026 RAG benchmarks). Semantic chunking gains only ~2-3% recall at
- *     ~14× the embedding cost and only matters above ~5k token docs.
- *   - Parent-document retrieval is the meaningful 2026 upgrade beyond
- *     paragraph chunking — track separately if recall plateaus.
- *
- * Strategy:
- *   1. Split markdown by blank-line paragraph boundaries.
- *   2. Pack paragraphs into chunks under maxChars (default 1500 ≈ 375 tokens).
- *   3. Add 1-2 sentence overlap between consecutive chunks to preserve
- *      cross-chunk anchors.
- *   4. Preserve markdown structure: never split inside a fenced code block.
- */
-
-const DEFAULT_MAX_CHARS = 1500;
-const DEFAULT_OVERLAP_SENTENCES = 2;
-const SENTENCE_RE = /[^.!?]+[.!?]+["')\]]*\s*/g;
-
-export function splitSentences(text) {
-  const matches = text.match(SENTENCE_RE);
-  if (matches && matches.length) return matches.map((s) => s.trim()).filter(Boolean);
-  return text.split('\n').map((s) => s.trim()).filter(Boolean);
-}
-
-function tailSentences(text, count) {
-  const sentences = splitSentences(text);
-  return sentences.slice(-count).join(' ');
-}
-
-function splitParagraphs(markdown) {
-  const blocks = [];
-  let buffer = '';
-  let inFence = false;
-  for (const line of markdown.split('\n')) {
-    if (/^```/.test(line.trim())) inFence = !inFence;
-    if (!inFence && line.trim() === '' && buffer.trim()) {
-      blocks.push(buffer.trim());
-      buffer = '';
-      continue;
-    }
-    buffer += line + '\n';
-  }
-  if (buffer.trim()) blocks.push(buffer.trim());
-  return blocks;
-}
-
-export function chunkMarkdown(markdown, { maxChars = DEFAULT_MAX_CHARS, overlapSentences = DEFAULT_OVERLAP_SENTENCES } = {}) {
-  const paragraphs = splitParagraphs(markdown || '');
-  if (paragraphs.length === 0) return [];
-
-  const chunks = [];
-  let current = '';
-  let chunkIndex = 0;
-  const flushChunk = () => {
-    if (!current.trim()) return;
-    const text = current.trim();
-    chunks.push({
-      index: chunkIndex++,
-      text,
-      chars: text.length,
-    });
-    const overlap = overlapSentences > 0 ? tailSentences(text, overlapSentences) : '';
-    current = overlap ? overlap + '\n\n' : '';
-  };
-
-  for (const para of paragraphs) {
-    if (current.length + para.length + 2 > maxChars && current.trim()) {
-      flushChunk();
-    }
-    if (para.length > maxChars) {
-      flushChunk();
-      const sentences = splitSentences(para);
-      let buf = '';
-      for (const s of sentences) {
-        if (buf.length + s.length + 1 > maxChars && buf.trim()) {
-          chunks.push({ index: chunkIndex++, text: buf.trim(), chars: buf.trim().length });
-          buf = (overlapSentences > 0 ? tailSentences(buf, overlapSentences) : '') + (overlapSentences > 0 ? ' ' : '');
-        }
-        buf += s + ' ';
-      }
-      if (buf.trim()) {
-        current = buf.trim() + '\n\n';
-      }
-      continue;
-    }
-    current += (current ? '\n\n' : '') + para;
-  }
-  flushChunk();
-  return chunks;
-}

package/lib/ingest/pipeline.mjs

@@ -1,53 +0,0 @@
-/**
- * lib/ingest/pipeline.mjs — orchestrate the content-hashed ingest pipeline.
- *
- * Flow: hash → de-dup → extract via docling/whisper → chunk → write to
- * .cx/ingest/<sha>/. Returns a record describing what was stored along
- * with any droppedInfo surfaced by the extractor.
- *
- * Idempotent: re-ingesting the same content (by sha256) returns the
- * existing record without re-extracting.
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { extractDocumentTextAsync } from '../document-extract.mjs';
-import { hashFile, defaultIngestRoot, readRecord, writeRecord } from './store.mjs';
-import { chunkMarkdown } from './chunker.mjs';
-
-export async function ingestFile(filePath, { cwd = process.cwd(), force = false } = {}) {
-  const absPath = path.resolve(filePath);
-  const stat = await fs.stat(absPath);
-  if (!stat.isFile()) throw new Error(`not a regular file: ${absPath}`);
-
-  const root = defaultIngestRoot(cwd);
-  const sha256 = await hashFile(absPath);
-
-  if (!force) {
-    const existing = await readRecord(root, sha256);
-    if (existing) return { ...existing, status: 'cached' };
-  }
-
-  const extracted = await extractDocumentTextAsync(absPath);
-  const markdown = extracted.markdown ?? extracted.text ?? '';
-  const chunks = chunkMarkdown(markdown);
-
-  const source = {
-    sourcePath: absPath,
-    fileName: path.basename(absPath),
-    extension: extracted.extension,
-    bytes: stat.size,
-    sha256,
-    ingestedAt: new Date().toISOString(),
-  };
-
-  const meta = {
-    extractionMethod: extracted.extractionMethod,
-    extractorMetadata: extracted.metadata ?? null,
-    droppedInfo: extracted.droppedInfo ?? [],
-    chunkCount: chunks.length,
-    chunkChars: chunks.reduce((a, c) => a + c.chars, 0),
-  };
-
-  const record = await writeRecord(root, { sha256, source, meta, markdown });
-  return { ...record, status: 'ingested', droppedInfo: meta.droppedInfo, chunks };
-}

package/lib/ingest/store.mjs

@@ -1,82 +0,0 @@
-/**
- * lib/ingest/store.mjs — content-addressed ingest store at .cx/ingest/<hash>/.
- *
- * Each ingested document is stored under its SHA-256 content hash:
- *   .cx/ingest/<sha256>/source.json   — original path, size, sha256, ingestedAt
- *   .cx/ingest/<sha256>/markdown.md   — extracted markdown body
- *   .cx/ingest/<sha256>/meta.json     — extractor metadata, droppedInfo, chunks
- *
- * Idempotent: re-ingesting a file with the same content is a no-op (returns
- * the existing record). Re-running ingestion is the safe default.
- *
- * 2026-06 best practice notes:
- *   - SHA-256 is still the universal content-addressing primitive. BLAKE3 is
- *     ~2.3× faster on M-series and worth considering at multi-GB scale,
- *     but is not the industry default and adds an unfamiliar dependency.
- *     Revisit if ingest throughput becomes a measured bottleneck.
- *   - Storing markdown body separately from metadata keeps the embedding
- *     and search paths simple: they only read markdown.md and look up
- *     provenance from meta.json on demand.
- */
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-export function defaultIngestRoot(cwd = process.cwd()) {
-  return path.join(cwd, '.cx', 'ingest');
-}
-
-export async function hashFile(filePath) {
-  return new Promise((resolveHash, reject) => {
-    const hash = createHash('sha256');
-    const stream = createReadStream(filePath);
-    stream.on('data', (chunk) => hash.update(chunk));
-    stream.on('error', reject);
-    stream.on('end', () => resolveHash(hash.digest('hex')));
-  });
-}
-
-function recordDirFor(root, sha256) {
-  return path.join(root, sha256);
-}
-
-export async function readRecord(root, sha256) {
-  const dir = recordDirFor(root, sha256);
-  try {
-    const [source, meta, markdown] = await Promise.all([
-      fs.readFile(path.join(dir, 'source.json'), 'utf8').then(JSON.parse),
-      fs.readFile(path.join(dir, 'meta.json'), 'utf8').then(JSON.parse),
-      fs.readFile(path.join(dir, 'markdown.md'), 'utf8'),
-    ]);
-    return { sha256, source, meta, markdown, dir };
-  } catch {
-    return null;
-  }
-}
-
-export async function writeRecord(root, { sha256, source, meta, markdown }) {
-  const dir = recordDirFor(root, sha256);
-  await fs.mkdir(dir, { recursive: true });
-  await Promise.all([
-    fs.writeFile(path.join(dir, 'source.json'), JSON.stringify(source, null, 2) + '\n', 'utf8'),
-    fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2) + '\n', 'utf8'),
-    fs.writeFile(path.join(dir, 'markdown.md'), markdown, 'utf8'),
-  ]);
-  return { sha256, dir, source, meta, markdown };
-}
-
-export async function listRecords(root) {
-  let entries;
-  try { entries = await fs.readdir(root, { withFileTypes: true }); }
-  catch { return []; }
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const sha = entry.name;
-    if (!/^[a-f0-9]{64}$/.test(sha)) continue;
-    const record = await readRecord(root, sha);
-    if (record) records.push(record);
-  }
-  return records;
-}

package/lib/mode-commands.mjs

@@ -1,122 +0,0 @@
-/**
- * lib/mode-commands.mjs — Standardized command contracts across deployment modes.
- *
- * Provides mode-aware command execution for intake, memory, and workflow operations.
- * Routes to file-based implementations in solo mode, Postgres in team/enterprise mode.
- */
-
-// lib/mode-commands.mjs
-// Standardized command contracts across deployment modes
-
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
-
-export const MODE_COMMANDS = {
-  // Intake queue operations
-  intake: {
-    list: async (options = {}) => {
-      const mode = getDeploymentMode();
-      
-      if (mode === 'solo') {
-        // File-based intake
-        const result = spawnSync('find', ['.cx/intake/pending', '-name', '*.json', '-type', 'f'], 
-          { encoding: 'utf8', cwd: options.cwd });
-        return parseIntakeFiles(result.stdout);
-      } else {
-        // Postgres-based intake
-        return queryPostgresIntake(options);
-      }
-    },
-    
-    show: async (id, options = {}) => {
-      const mode = getDeploymentMode();
-      
-      if (mode === 'solo') {
-        return readIntakeFile(id, options);
-      } else {
-        return queryPostgresIntakeItem(id, options);
-      }
-    },
-  },
-  
-  // Storage operations
-  storage: {
-    sync: async (options = {}) => {
-      const mode = getDeploymentMode();
-      
-      // Same interface, different implementation
-      if (mode === 'solo') {
-        return syncToFileStorage(options);
-      } else {
-        return syncToPostgresStorage(options);
-      }
-    },
-    
-    query: async (criteria, options = {}) => {
-      // Unified query interface
-      return queryStorage(criteria, options);
-    },
-  },
-};
-
-function getDeploymentMode() {
-  return process.env.CONSTRUCT_DEPLOYMENT_MODE || 'solo';
-}
-
-function parseIntakeFiles(stdout) {
-  return stdout.split('\n')
-    .filter(Boolean)
-    .map(f => ({ id: basename(f, '.json'), source: 'file' }));
-}
-
-function readIntakeFile(id, options) {
-  const filePath = join(options.cwd || process.cwd(), '.cx/intake/pending', `${id}.json`);
-  if (!existsSync(filePath)) {
-    return { error: `Intake item ${id} not found` };
-  }
-  return JSON.parse(readFileSync(filePath, 'utf8'));
-}
-
-async function queryPostgresIntake(options) {
-  // Would use SQL client
-  return { items: [], mode: 'postgres' };
-}
-
-async function queryPostgresIntakeItem(id, options) {
-  return { id, mode: 'postgres' };
-}
-
-async function syncToFileStorage(options) {
-  return { 
-    success: true, 
-    mode: 'solo',
-    backend: 'file',
-  };
-}
-
-async function syncToPostgresStorage(options) {
-  return {
-    success: true,
-    mode: 'team',
-    backend: 'postgres',
-  };
-}
-
-async function queryStorage(criteria, options) {
-  // Unified query - works across modes
-  return {
-    results: [],
-    mode: getDeploymentMode(),
-  };
-}
-
-export function getCommandInterface(command, operation) {
-  const cmd = MODE_COMMANDS[command];
-  if (!cmd) return null;
-  
-  const fn = cmd[operation];
-  if (!fn) return null;
-  
-  return fn;
-}