@geraldmaron/construct 1.0.23 → 1.1.0

package/scripts/sync-specialists.mjs

@@ -44,6 +44,8 @@ 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 { emitCursorRules } from "../lib/rules-delivery.mjs";
 import { resolvePromptContract } from "../lib/prompt-composer.js";
 import {
   buildClaudeMcpEntry,
@@ -157,6 +159,19 @@ const COMPRESS_PERSONAS = process.argv.includes("--compress-personas");
 const PROJECT_FLAG = process.argv.includes("--project");
 const GLOBAL_FLAG = process.argv.includes("--global");
 
+// --local-surface=on|off|auto controls whether the heavy external MCP servers are
+// disabled to fit a small local-model window. `auto` (default) trims only when the
+// config's own default model is local — so a cloud session keeps context7/github
+// even on a machine that also has Ollama. `on` forces the trim (the lever for users
+// who pick a local model at runtime, leaving the config default unset); `off` keeps
+// every server. CONSTRUCT_LOCAL_SURFACE is the env equivalent.
+
+const LOCAL_SURFACE = (() => {
+  const arg = process.argv.find((a) => a.startsWith("--local-surface="));
+  const raw = (arg ? arg.slice("--local-surface=".length) : process.env.CONSTRUCT_LOCAL_SURFACE || "auto").trim().toLowerCase();
+  return LOCAL_SURFACE_MODES.includes(raw) ? raw : "auto";
+})();
+
 // --quiet suppresses only the closing one-line summary, not the work or any
 // warning. `construct install` runs the global tier twice (plain `sync` then
 // `sync --global`); in a non-project cwd both land in the same global branch and
@@ -173,8 +188,13 @@ const summary = (msg) => { if (!QUIET) console.log(msg); };
 // Absent → null → write every host, preserving `construct sync` back-compat.
 
 import { detectHostCapabilities } from "../lib/host-capabilities.mjs";
-
-const HOST_KEYS = ["claude", "codex", "copilot", "opencode", "vscode", "cursor"];
+import {
+  HOST_KEYS,
+  displayNameToKey,
+  hasNativeSubagents as hostHasNativeSubagents,
+  globalHookAllowlist,
+  globalMcpAllowlist,
+} from "../lib/platforms/capabilities.mjs";
 
 function parseHostSelection() {
   const arg = process.argv.find((a) => a.startsWith("--hosts="));
@@ -182,14 +202,7 @@ function parseHostSelection() {
   if (!raw) {
     // Default to detected hosts if none are explicitly requested.
     const detected = new Set();
-    const nameToKey = {
-      "Claude Code": "claude",
-      "OpenCode": "opencode",
-      "Codex": "codex",
-      "VS Code": "vscode",
-      "Cursor": "cursor",
-      "Copilot": "copilot",
-    };
+    const nameToKey = displayNameToKey();
     try {
       for (const cap of detectHostCapabilities()) {
         if (cap.availability === "installed" && nameToKey[cap.host]) {
@@ -427,7 +440,7 @@ const hardDefaults = {
 // primary's provider. Explicit CX_MODEL_* env wins if set.
 const primaryFromOpenCode = (() => {
   try {
-    const cfg = readOpenCodeConfig(findOpenCodeConfigPath()) ?? {};
+    const cfg = readOpenCodeConfig().config ?? {};
     return cfg.model || cfg.defaultModel || null;
   } catch { return null; }
 })();
@@ -598,9 +611,28 @@ function buildPrompt(entry, allEntries, platform) {
 
   prompt = inlineRoleAntiPatterns(prompt, root, entry.name, console.warn, { preload: entry.preloadRoleGuidance === true });
 
-  if (entry.injectAgentRoster && allEntries) {
+  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,
+  // combined with MCP tool schemas, overruns the model's real context window and
+  // collapses output. Those hosts get a tool-bound micro-prompt instead and resolve
+  // the chain at runtime via the orchestration_policy MCP tool. Hosts without native
+  // routing (Claude Code, Codex) still need the roster to simulate handoffs in text.
+
+  if (entry.injectAgentRoster && allEntries && !capabilities.hasNativeSubagents) {
     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 += buildRoleFooter(entry);
@@ -800,6 +832,58 @@ function makeHooksPortable(hooksJson) {
   return JSON.stringify(walk(hooksJson));
 }
 
+const GLOBAL_CLAUDE_HOOK_IDS = globalHookAllowlist('claude');
+
+const GLOBAL_CLAUDE_MCP_IDS = globalMcpAllowlist('claude');
+
+// Project scope writes only core-category MCP servers (plus construct-mcp, the
+// orchestration server the specialist loop needs). optional/integration servers
+// (memory, github, sequential-thinking, playwright, …) are opt-in via
+// `construct mcp add` so a project does not silently inherit heavy servers it was
+// never asked for (ADR-0031 §Consequences follow-up). A server already present in
+// the project settings is preserved, so a manual opt-in sticks.
+
+const PROJECT_DEFAULT_MCP_IDS = (() => {
+  try {
+    const catalog = JSON.parse(fs.readFileSync(path.join(root, "lib", "mcp-catalog.json"), "utf8"));
+    const arr = catalog.mcps || catalog.servers || [];
+    return new Set([...arr.filter((m) => m.category === "core").map((m) => m.id), "construct-mcp"]);
+  } catch {
+    return new Set(["context7", "construct-mcp"]);
+  }
+})();
+
+function filterGlobalClaudeHooks(hooksJson) {
+  const filtered = {};
+  for (const [event, groups] of Object.entries(hooksJson ?? {})) {
+    const kept = groups.filter((group) => GLOBAL_CLAUDE_HOOK_IDS.has(group.id));
+    if (kept.length > 0) filtered[event] = kept;
+  }
+  return filtered;
+}
+
+function syncGlobalClaudeMcpServers(settings, registryMcp) {
+  settings.mcpServers ??= {};
+  for (const id of Object.keys(settings.mcpServers)) {
+    if (id in registryMcp && !GLOBAL_CLAUDE_MCP_IDS.has(id)) {
+      delete settings.mcpServers[id];
+    }
+  }
+
+  for (const [id, mcpDef] of Object.entries(registryMcp)) {
+    if (!GLOBAL_CLAUDE_MCP_IDS.has(id)) continue;
+    const existingEntry = settings.mcpServers[id];
+    const existing = JSON.stringify(existingEntry ?? "");
+    const hasPlaceholder = existing.includes("__");
+    const hasFloatingVersion = existing.includes("@latest");
+    const registryWantsCommand = !mcpDef.type && Array.isArray(mcpDef.args);
+    const existingIsRemote = existingEntry && (existingEntry.type === 'http' || existingEntry.type === 'remote');
+    const transportMismatch = registryWantsCommand && existingIsRemote;
+    if (existingEntry && !hasPlaceholder && !hasFloatingVersion && !transportMismatch) continue;
+    settings.mcpServers[id] = buildClaudeMcpEntry(id, mcpDef, process.env);
+  }
+}
+
 /**
  * Materialise a project-local `.claude/settings.json` from the home template,
  * with hook commands rewritten to be path-relative to whatever Construct
@@ -827,6 +911,7 @@ function writeProjectClaudeSettings(targetDir) {
     existing.mcpServers ??= {};
     for (const [id, mcpDef] of Object.entries(template.mcpServers)) {
       if (existing.mcpServers[id]) continue;
+      if (!PROJECT_DEFAULT_MCP_IDS.has(id)) continue;
       existing.mcpServers[id] = mcpDef;
     }
   }
@@ -842,6 +927,7 @@ function writeProjectClaudeSettings(targetDir) {
   existing.mcpServers ??= {};
   for (const [id, mcpDef] of Object.entries(registryMcp)) {
     if (existing.mcpServers[id]) continue;
+    if (!PROJECT_DEFAULT_MCP_IDS.has(id)) continue;
     existing.mcpServers[id] = buildClaudeMcpEntry(id, mcpDef, process.env);
   }
 
@@ -908,23 +994,13 @@ ${personaList}
           const constructReal = (() => {
             try { return fs.realpathSync(path.join(home, ".construct")); } catch { return path.join(home, ".construct"); }
           })();
-          const hookStr = JSON.stringify(template.hooks)
+          const hookStr = JSON.stringify(filterGlobalClaudeHooks(template.hooks))
             .replace(/\$HOME\/\.construct/g, constructReal.replace(/\\/g, "/"));
           settings.hooks = JSON.parse(hookStr);
         }
       }
-      if (!settings.mcpServers) settings.mcpServers = {};
       const registryMcp = registry.mcpServers ?? {};
-      for (const [id, mcpDef] of Object.entries(registryMcp)) {
-        const existingEntry = settings.mcpServers[id];
-        const existing = JSON.stringify(existingEntry ?? "");
-        const hasPlaceholder = existing.includes("__");
-        const registryWantsCommand = !mcpDef.type && Array.isArray(mcpDef.args);
-        const existingIsRemote = existingEntry && (existingEntry.type === 'http' || existingEntry.type === 'remote');
-        const transportMismatch = registryWantsCommand && existingIsRemote;
-        if (existingEntry && !hasPlaceholder && !transportMismatch) continue;
-        settings.mcpServers[id] = buildClaudeMcpEntry(id, mcpDef, process.env);
-      }
+      syncGlobalClaudeMcpServers(settings, registryMcp);
       if (!DRY_RUN) fs.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   }
@@ -1313,6 +1389,15 @@ function syncCursor(targetDir = null, wants = true) {
         fs.writeFileSync(rulesPath, body);
       }
     }
+
+    // Glob-scoped language rules land as managed per-rule .mdc files only when
+    // the project's own files match their globs — Cursor's native auto-attach
+    // convention. See docs/concepts/rules-delivery.md.
+    try {
+      emitCursorRules({ rulesDir: path.join(root, "rules"), targetDir, dryRun: DRY_RUN });
+    } catch (err) {
+      console.warn(`[sync] cursor rules delivery skipped: ${err.message}`);
+    }
   }
   return true;
 }
@@ -1328,22 +1413,39 @@ function opencodePermissions(entry) {
     ? Object.fromEntries(Object.entries(entry.permissions).map(([k, v]) => [k, v]))
     : { edit: entry.canEdit === false ? "deny" : "allow", bash: "allow" };
 
-  // The orchestrator is the primary write surface; translate its abstract
-  // bash:allow into OpenCode's scoped permission map so destructive commands are
-  // denied and remote/history rewrites prompt — the commit-approval contract
-  // enforced at the tool layer, not just in the prompt. Subagents keep the
-  // abstract grant. This scoped shape is an OpenCode translation detail and stays
-  // out of the cross-adapter registry.
-
-  if (entry.isOrchestrator && perms.bash === "allow") {
-    perms.bash = {
-      "*": "allow",
-      "rm -rf *": "deny",
-      "git push *": "ask",
-      "git push --force*": "ask",
-      "git reset --hard *": "ask",
-    };
+  // Agentic Scope Reduction (ADR-0002). Serializing 100+ MCP tool schemas into a
+  // small local model's prompt overruns its context window and dilutes attention,
+  // collapsing output. OpenCode's per-agent permission map prunes the surface: the
+  // orchestrator keeps only orchestration + core tools and hands execution to
+  // subagents; subagents keep execution tools but not orchestration.
+
+  if (entry.isOrchestrator) {
+    if (perms.bash === "allow") {
+      perms.bash = {
+        "*": "allow",
+        "rm -rf *": "deny",
+        "git push *": "ask",
+        "git push --force*": "ask",
+        "git reset --hard *": "ask",
+      };
+    }
+    // Heavy execution and external-knowledge tools are denied to the orchestrator so
+    // its serialized tool schema stays small; orchestration_policy drives the handoff.
+
+    perms["mcp__construct-mcp__extract_document_text"] = "deny";
+    perms["mcp__construct-mcp__ingest_document"] = "deny";
+    perms["mcp__construct-mcp__scan_file"] = "deny";
+    perms["mcp__github__*"] = "deny";
+    perms["mcp__context7__*"] = "deny";
+    perms["mcp__sequential-thinking__*"] = "deny";
+    perms["mcp__memory__*"] = "deny";
+  } else {
+    // Subagents shouldn't be orchestrating
+    perms["mcp__construct-mcp__orchestration_policy"] = "deny";
+    perms["mcp__construct-mcp__agent_contract"] = "deny";
+    perms["mcp__construct-mcp__broker_check"] = "deny";
   }
+
   return perms;
 }
 
@@ -1493,6 +1595,34 @@ function syncOpencode(entries, targetDir = null, wants = true) {
         config.mcp[openCodeId] = buildOpenCodeMcpEntry(id, mcpDef, process.env).entry;
       }
     }
+
+    // Heavy external MCP servers serialize ~12k tokens of schema into EVERY
+    // agent's request — including the built-in Build/Plan agents the per-agent
+    // permission prune cannot reach. OpenCode 1.15.4 has no per-session tool
+    // filter (chat.params carries no tool list), so disabling the whole server in
+    // opencode.json is the only lever. The decision is INTENT-driven: trim only
+    // when this config's own default model is local (or a local Ollama provider is
+    // registered in it), so a cloud session on a machine that merely also has
+    // Ollama keeps context7/github. decideTrim centralizes the policy; a manual
+    // enabled:true is preserved so a user can re-enable a server they need.
+
+    // A set default model is explicit intent and wins (local → trim, cloud → keep).
+    // Only when no default is chosen does a registered Ollama provider stand in as
+    // soft local intent — so a cloud-default config is never trimmed for merely
+    // listing local models alongside.
+    const configDefaultModel = config.model || config.defaultModel || "";
+    const registersOllamaProvider = Object.keys(config.provider?.ollama?.models || {}).length > 0;
+    const intentModel = configDefaultModel || (registersOllamaProvider ? "ollama" : "");
+    const trimHeavyServers = decideTrim({ surface: LOCAL_SURFACE, defaultModel: intentModel });
+    for (const id of HEAVY_EXTERNAL_MCP_IDS) {
+      const ocId = getOpenCodeMcpId(id);
+      if (!config.mcp[ocId]) continue;
+      if (trimHeavyServers) {
+        if (config.mcp[ocId].enabled !== true) config.mcp[ocId].enabled = false;
+      } else {
+        delete config.mcp[ocId].enabled;
+      }
+    }
   }
 
   // Sweep cx-* / orchestrator agents that fall outside the current write set.
@@ -1525,12 +1655,16 @@ function syncOpencode(entries, targetDir = null, wants = true) {
     };
   }
 
+  // Pass current Construct model tiers to OpenCode config for native routing.
+  config.construct = config.construct || {};
+  config.construct.models = { ...resolvedModels };
+
   // Seed a cheap auxiliary model for titles and summaries when the user has not
   // chosen one — a cost lever only. The primary `model` stays the user's choice
   // and is never written. Global scope only; project configs inherit it.
 
   if (!targetDir && config.small_model === undefined) {
-    config.small_model = "anthropic/claude-haiku-4-5-20251001";
+    config.small_model = resolvedModels.fast || "anthropic/claude-haiku-4-5-20251001";
   }
 
   writeOpenCodeConfig(config, configPath);

package/specialists/prompts/cx-architect.md

@@ -1,3 +1,23 @@
+---
+name: cx-architect
+role: architect
+version: 1
+perspective:
+  bias: "Designs that emerged from code, missing ADRs, data models that encode assumptions that will change"
+  tension: "cx-engineer"
+  openingQuestion: "What are the invariants, and what breaks if they're violated?"
+  failureMode: "If the ADR has no 'options rejected' section, the decision defaulted — and defaulted decisions bite hardest."
+roleGuidance: roles/architect
+roleOverlays:
+  - architect.platform
+  - architect.integration
+  - architect.data
+  - architect.ai-systems
+  - architect.enterprise
+templates:
+  - adr
+---
+
 You have inherited enough unmaintainable systems to be permanently suspicious of clever solutions. The damage from a bad interface contract compounds silently for years. Your job is to make the right trade-offs explicit before implementation locks them in.
 
 **Anti-fabrication contract**: every load-bearing claim in an ADR, RFC, or design doc cites a source the reader can re-verify (`[source: path#anchor]`, `[source: bd-<id>]`, `[source: <commit-sha>]`). When a fact isn't in the source you have, write `unknown` or `[unverified]`. Don't invent rejected alternatives that were never considered. See `rules/common/no-fabrication.md`.

package/specialists/prompts/cx-qa.md

@@ -18,7 +18,7 @@ You have watched acceptance criteria pass tests that didn't actually test the ac
 **Role guidance**: call `get_skill("roles/qa")` before drafting.
 
 When the verification domain is clear, also load exactly one relevant overlay before drafting:
-- `roles/qa.web-ui` for UI flows, accessibility, responsive states, visual regression, keyboard behavior, and browser automation
+- `roles/qa.web-ui` for UI flows, accessibility, responsive states, visual regression, keyboard behavior, and browser automation. Live-browser automation (driving a real page, screenshots, click/keyboard flows) is not installed by default — opt in with `construct mcp add playwright` when a verification actually needs it.
 - `roles/qa.api-contract` for APIs, SDKs, status codes, error bodies, compatibility, and consumer-driven contracts
 - `roles/qa.data-pipeline` for ETL/ELT, data contracts, freshness, uniqueness, replay, backfills, and data quality checks
 - `roles/qa.ai-eval` for agents, prompts, model changes, retrieval, eval rubrics, golden traces, and promotion gates

package/specialists/prompts/cx-test-automation.md

@@ -1,3 +1,15 @@
+---
+name: cx-test-automation
+role: test-automation
+version: 1
+perspective:
+  bias: "Intermittent tests dismissed as infrastructure, coverage numbers over behavioral coverage, arbitrary sleeps"
+  tension: "cx-qa"
+  openingQuestion: "Is this test deterministic, and does it actually fail when the behavior it's testing breaks?"
+  failureMode: "If the test suite has never caught a production bug, the tests are testing the wrong things."
+roleGuidance: roles/qa.test-automation
+---
+
 You have inherited enough flaky test suites to know that bad automation is worse than no automation: it creates false confidence while hiding real failures. The test that passes intermittently isn't catching bugs; it's teaching the team to ignore red builds.
 
 **Anti-fabrication contract**: every test reliability claim cites the run history (pass rate over N runs). Don't call a test flaky from one failure or stable without the data. Coverage and performance claims cite the report, not an estimate. See `rules/common/no-fabrication.md`.

package/specialists/registry.json

@@ -1467,14 +1467,6 @@
       ],
       "description": "Library and framework documentation lookup"
     },
-    "playwright": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@playwright/mcp@0.0.75"
-      ],
-      "description": "Browser automation and E2E testing"
-    },
     "github": {
       "type": "url",
       "url": "https://api.githubcopilot.com/mcp/",

package/templates/docs/construct_guide.md

@@ -67,7 +67,7 @@ The full list of personas lives in `.claude/agents/`. Run `construct list` to se
 
 Two scopes:
 
-**Per-project** (committed, shared with peers): edit `.claude/settings.json`. Construct owns the `hooks` block and a known set of `mcpServers` keys (memory, context7, playwright, github, sequential-thinking, construct-mcp); your additions are preserved on `npm install`. Other top-level keys are yours to control.
+**Per-project** (committed, shared with peers): edit `.claude/settings.json`. Construct owns the `hooks` block and a known set of `mcpServers` keys (memory, context7, github, sequential-thinking, construct-mcp); your additions — including opt-in MCPs like `playwright` (`construct mcp add playwright`) — are preserved on `npm install`. Other top-level keys are yours to control.
 
 **Per-machine** (private to you): edit `~/.construct/config.env`. This is where your API keys, consent flags, and local-service credentials live. Standard `KEY=value` format.
 

package/db/schema/001_init.sql

@@ -1,40 +0,0 @@
-create extension if not exists vector;
-
-create table if not exists construct_documents (
-  id text primary key,
-  project text not null,
-  kind text not null,
-  title text not null,
-  summary text,
-  body text not null,
-  source_path text,
-  tags jsonb not null default '[]'::jsonb,
-  content_hash text not null,
-  updated_at timestamptz not null default now(),
-  created_at timestamptz not null default now()
-);
-
-create index if not exists construct_documents_project_kind_idx on construct_documents (project, kind);
-create index if not exists construct_documents_content_hash_idx on construct_documents (content_hash);
-
-create table if not exists construct_embeddings (
-  document_id text primary key references construct_documents(id) on delete cascade,
-  model text not null,
-  embedding double precision[] not null,
-  content_hash text not null,
-  updated_at timestamptz not null default now(),
-  created_at timestamptz not null default now()
-);
-
-create index if not exists construct_embeddings_model_idx on construct_embeddings (model);
-
-create table if not exists construct_sync_runs (
-  id bigserial primary key,
-  project text not null,
-  source text not null,
-  documents_synced integer not null default 0,
-  embeddings_synced integer not null default 0,
-  status text not null,
-  note text,
-  created_at timestamptz not null default now()
-);

package/db/schema/002_pgvector.sql

@@ -1,182 +0,0 @@
--- db/schema/002_pgvector.sql
--- Enable pgvector extension and add vector-typed columns for semantic search.
--- This migration is idempotent — safe to run multiple times.
-
--- Enable pgvector extension
-CREATE EXTENSION IF NOT EXISTS vector;
-
--- Add vector column to construct_embeddings if it doesn't exist yet
--- (The original 001_init.sql used double precision[], which we keep for backward compat)
-DO $$
-BEGIN
-  -- Check if embedding column is still array type and needs migration
-  IF EXISTS (
-    SELECT 1 FROM information_schema.columns
-    WHERE table_name = 'construct_embeddings'
-      AND column_name = 'embedding'
-      AND data_type = 'ARRAY'
-  ) THEN
-    -- Add new vector column
-    ALTER TABLE construct_embeddings ADD COLUMN embedding_vec vector(384);
-
-    -- Copy data from old array column to new vector column
-    UPDATE construct_embeddings
-      SET embedding_vec = embedding::vector(384);
-
-    -- Drop old column and rename
-    ALTER TABLE construct_embeddings DROP COLUMN embedding;
-    ALTER TABLE construct_embeddings RENAME COLUMN embedding_vec TO embedding;
-  END IF;
-END $$;
-
--- Ensure embedding column exists as vector type (for fresh installs)
-ALTER TABLE construct_embeddings
-  ALTER COLUMN embedding TYPE vector(384) USING embedding::vector(384);
-
--- Create HNSW index for fast approximate nearest neighbor search
-CREATE INDEX IF NOT EXISTS idx_embeddings_hnsw
-  ON construct_embeddings
-  USING hnsw (embedding vector_cosine_ops)
-  WITH (m = 16, ef_construction = 64);
-
--- Create observations table with vector support
-CREATE TABLE IF NOT EXISTS construct_observations (
-  id text PRIMARY KEY,
-  project text NOT NULL,
-  role text NOT NULL,
-  category text NOT NULL,
-  summary text NOT NULL,
-  content text NOT NULL,
-  tags jsonb NOT NULL DEFAULT '[]'::jsonb,
-  confidence float NOT NULL DEFAULT 0.8,
-  source text,
-  git_sha text,
-  created_at timestamptz NOT NULL DEFAULT now(),
-  updated_at timestamptz NOT NULL DEFAULT now(),
-  embedding vector(384)
-);
-
--- Indexes for observations
-CREATE INDEX IF NOT EXISTS idx_observations_project ON construct_observations(project);
-CREATE INDEX IF NOT EXISTS idx_observations_category ON construct_observations(project, category);
-CREATE INDEX IF NOT EXISTS idx_observations_created_at ON construct_observations(project, created_at DESC);
-CREATE INDEX IF NOT EXISTS idx_observations_vector ON construct_observations USING hnsw (embedding vector_cosine_ops);
-
--- Create sessions table with vector support
-CREATE TABLE IF NOT EXISTS construct_sessions (
-  id text PRIMARY KEY,
-  project text NOT NULL,
-  platform text,
-  summary text,
-  decisions jsonb DEFAULT '[]'::jsonb,
-  files_changed jsonb DEFAULT '[]'::jsonb,
-  open_questions jsonb DEFAULT '[]'::jsonb,
-  task_snapshot jsonb DEFAULT '[]'::jsonb,
-  status text DEFAULT 'active',
-  created_at timestamptz NOT NULL DEFAULT now(),
-  updated_at timestamptz NOT NULL DEFAULT now(),
-  embedding vector(384)
-);
-
-CREATE INDEX IF NOT EXISTS idx_sessions_project ON construct_sessions(project);
-CREATE INDEX IF NOT EXISTS idx_sessions_status ON construct_sessions(project, status);
-CREATE INDEX IF NOT EXISTS idx_sessions_vector ON construct_sessions USING hnsw (embedding vector_cosine_ops);
-
--- Create entities table with vector support
-CREATE TABLE IF NOT EXISTS construct_entities (
-  name text PRIMARY KEY,
-  type text NOT NULL,
-  summary text,
-  project text,
-  observation_ids jsonb DEFAULT '[]'::jsonb,
-  related_entities jsonb DEFAULT '[]'::jsonb,
-  created_at timestamptz NOT NULL DEFAULT now(),
-  updated_at timestamptz NOT NULL DEFAULT now(),
-  last_seen timestamptz,
-  embedding vector(384)
-);
-
-CREATE INDEX IF NOT EXISTS idx_entities_type ON construct_entities(type);
-CREATE INDEX IF NOT EXISTS idx_entities_project ON construct_entities(project);
-CREATE INDEX IF NOT EXISTS idx_entities_vector ON construct_entities USING hnsw (embedding vector_cosine_ops);
-
--- Function for searching documents by embedding
-CREATE OR REPLACE FUNCTION search_documents(
-  project_name text,
-  query_embedding vector(384),
-  match_limit int DEFAULT 10,
-  min_similarity float DEFAULT 0.3
-)
-RETURNS TABLE(
-  id text,
-  title text,
-  summary text,
-  body text,
-  source_path text,
-  tags jsonb,
-  kind text,
-  similarity float
-) AS $$
-BEGIN
-  RETURN QUERY
-  SELECT
-    d.id,
-    d.title,
-    d.summary,
-    d.body,
-    d.source_path,
-    d.tags,
-    d.kind,
-    1 - (e.embedding <=> query_embedding) AS similarity
-  FROM construct_documents d
-  JOIN construct_embeddings e ON d.id = e.document_id
-  WHERE d.project = project_name
-    AND 1 - (e.embedding <=> query_embedding) > min_similarity
-  ORDER BY e.embedding <=> query_embedding
-  LIMIT match_limit;
-END;
-$$ LANGUAGE plpgsql;
-
--- Function for searching observations by embedding
-CREATE OR REPLACE FUNCTION search_observations(
-  project_name text,
-  query_embedding vector(384),
-  match_limit int DEFAULT 10,
-  min_similarity float DEFAULT 0.3,
-  filter_role text DEFAULT NULL,
-  filter_category text DEFAULT NULL
-)
-RETURNS TABLE(
-  id text,
-  role text,
-  category text,
-  summary text,
-  content text,
-  tags jsonb,
-  confidence float,
-  source text,
-  created_at timestamptz,
-  similarity float
-) AS $$
-BEGIN
-  RETURN QUERY
-  SELECT
-    o.id,
-    o.role,
-    o.category,
-    o.summary,
-    o.content,
-    o.tags,
-    o.confidence,
-    o.source,
-    o.created_at,
-    1 - (o.embedding <=> query_embedding) AS similarity
-  FROM construct_observations o
-  WHERE o.project = project_name
-    AND 1 - (o.embedding <=> query_embedding) > min_similarity
-    AND (filter_role IS NULL OR o.role = filter_role)
-    AND (filter_category IS NULL OR o.category = filter_category)
-  ORDER BY o.embedding <=> query_embedding
-  LIMIT match_limit;
-END;
-$$ LANGUAGE plpgsql;

package/db/schema/003_intake.sql

@@ -1,47 +0,0 @@
--- 003_intake.sql — R&D intake queue backing table for team and enterprise mode.
--- Solo mode uses the filesystem under .cx/intake/ instead.
---
--- Worker claim algorithm: SELECT ... FROM construct_intake_items
---   WHERE status = 'pending' ORDER BY created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1;
--- then set status = 'claimed', claimed_by, claimed_at in the same transaction.
---
--- payload jsonb carries the rest of the intake packet (intake, triage,
--- suggestion, related, excerpt, query) so the on-disk shape and the
--- in-table shape stay aligned.
-
-create table if not exists construct_intake_items (
-  id text primary key,
-  project text not null,
-  tenant_id text,
-  status text not null default 'pending',
-  intake_type text,
-  rd_stage text,
-  primary_owner text,
-  recommended_action text,
-  risk text,
-  requires_approval boolean not null default false,
-  confidence double precision,
-  payload jsonb not null,
-  created_at timestamptz not null default now(),
-  updated_at timestamptz not null default now(),
-  claimed_by text,
-  claimed_at timestamptz,
-  processed_at timestamptz,
-  processed_by text,
-  notes text,
-  skipped_at timestamptz,
-  skipped_by text,
-  skip_reason text
-);
-
-create index if not exists construct_intake_items_status_idx
-  on construct_intake_items(status, created_at);
-
-create index if not exists construct_intake_items_owner_idx
-  on construct_intake_items(primary_owner, status, created_at);
-
-create index if not exists construct_intake_items_payload_gin_idx
-  on construct_intake_items using gin(payload);
-
-create index if not exists construct_intake_items_project_tenant_idx
-  on construct_intake_items(project, tenant_id, status);