@geraldmaron/construct 1.0.21 → 1.0.23

package/lib/hooks/stop-typecheck.mjs

@@ -31,8 +31,11 @@ const pending = existsSync(tcPath)
   ? readFileSync(tcPath, 'utf8').split('\n').filter(Boolean)
   : [];
 
+// No files queued means no typecheck ran this turn — record 'unchecked', not a
+// misleading 'pass'. A stale 'pass' here is what made stop-notify fire a bare
+// "TS OK" banner on every no-op turn.
 if (pending.length === 0) {
-  try { writeFileSync(tsResultPath, 'pass'); } catch { /* best effort */ }
+  try { writeFileSync(tsResultPath, 'unchecked'); } catch { /* best effort */ }
   process.exit(0);
 }
 
@@ -55,8 +58,10 @@ function findTsConfig(startDir) {
 const startDir = dirname(pending[0]);
 const tsconfig = findTsConfig(startDir);
 
+// Files were edited but no tsconfig governs them — the typecheck couldn't run,
+// so the honest state is 'unchecked', not 'pass'.
 if (!tsconfig) {
-  try { writeFileSync(tsResultPath, 'pass'); } catch { /* best effort */ }
+  try { writeFileSync(tsResultPath, 'unchecked'); } catch { /* best effort */ }
   process.exit(0);
 }
 

package/lib/host-capabilities.mjs

@@ -118,6 +118,15 @@ function detectCopilotAvailability(homeDir = os.homedir()) {
   return { hasFiles };
 }
 
+// `capability` is the honest, normalized functional classification per host:
+//   full-native      — the host runs a multi-specialist chain itself (native
+//                       dispatch or config-driven agents): Claude Code, OpenCode.
+//   mcp-orchestrated  — no native subagent primitive, but the host calls the
+//                       `orchestration_run` MCP tool to reach the same orchestrated
+//                       outcome via the daemon: Codex, VS Code, Cursor, Copilot.
+//   prompt-only       — neither native dispatch nor MCP; instruction files only.
+//                       No supported 2026 host is prompt-only.
+
 export function detectHostCapabilities() {
   const claudeRaw = commandVersion("claude");
   const claudeVersion = parseClaudeVersion(claudeRaw);
@@ -135,6 +144,7 @@ export function detectHostCapabilities() {
       availability: claudeRaw ? "installed" : "missing",
       version: claudeRaw,
       orchestration: claudeTeamsSupported ? "full-multi-agent" : "primary-plus-subagents",
+      capability: "full-native",
       promptableWorkers: claudeTeamsSupported,
       sharedTaskRuntime: claudeTeamsSupported,
       lifecycleHooks: ["SubagentStop", "TeammateIdle", "TaskCreated", "TaskCompleted", "Stop"],
@@ -151,6 +161,7 @@ export function detectHostCapabilities() {
       availability: opencodeRaw ? "installed" : "missing",
       version: opencodeRaw,
       orchestration: "primary-plus-subagents",
+      capability: "full-native",
       promptableWorkers: false,
       sharedTaskRuntime: "tracker-plus-plan",
       lifecycleHooks: ["session.error", "session.idle", "tool.execute.before", "tool.execute.after"],
@@ -165,12 +176,13 @@ export function detectHostCapabilities() {
       availability: codexRaw ? "installed" : "missing",
       version: codexRaw,
       orchestration: "profile-and-mcp",
+      capability: "mcp-orchestrated",
       promptableWorkers: false,
       sharedTaskRuntime: "tracker-plus-plan",
       lifecycleHooks: [],
       notes: [
-        "Use Construct profiles, MCP project/memory tools, and the active session.",
-        "Native profile switching is not automatic; continue in-session when dispatch is unavailable.",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (start `construct dashboard`).",
+        "Use Construct profiles, MCP project/memory tools, and the active session for single-pass work.",
       ],
     },
     {
@@ -178,12 +190,13 @@ export function detectHostCapabilities() {
       availability: vscode.version || vscode.hasSettings ? "installed" : "missing",
       version: vscode.version,
       orchestration: "copilot-mcp",
+      capability: "mcp-orchestrated",
       promptableWorkers: false,
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Construct manages GitHub Copilot MCP registrations in user settings when a VS Code settings.json already exists.",
-        "VS Code is an editor surface, not Construct's primary multi-agent runtime.",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool in Copilot agent mode (start `construct dashboard`).",
+        "Construct's MCP servers load from `.vscode/mcp.json` (project) and the user-profile `mcp.json` (global, only when it already exists).",
       ],
     },
     {
@@ -191,12 +204,13 @@ export function detectHostCapabilities() {
       availability: cursor.version || cursor.hasConfig ? "installed" : "missing",
       version: cursor.version,
       orchestration: "mcp-only",
+      capability: "mcp-orchestrated",
       promptableWorkers: false,
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Construct manages Cursor MCP registrations in ~/.cursor/mcp.json when that file exists.",
-        "Cursor agent profiles are not generated today; use Construct through MCP-backed tools and shared project state.",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (start `construct dashboard`).",
+        "Construct manages Cursor MCP registrations in `.cursor/mcp.json` (project) and `~/.cursor/mcp.json` (global, when it already exists).",
       ],
     },
     {
@@ -204,12 +218,13 @@ export function detectHostCapabilities() {
       availability: copilot.hasFiles ? "installed" : "missing",
       version: null,
       orchestration: "prompt-profiles",
+      capability: "mcp-orchestrated",
       promptableWorkers: false,
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Construct writes reusable prompt profiles under ~/.github/prompts/ plus a managed block in ~/.github/copilot-instructions.md.",
-        "Copilot does not expose Construct-style subagent dispatch; use the generated profiles for focused passes.",
+        "Copilot agent mode runs Construct's MCP tools — use `orchestration_run` for a real multi-specialist chain (start `construct dashboard`).",
+        "Construct also writes reusable prompt profiles under `.github/prompts/` for single-pass role work.",
       ],
     },
   ];
@@ -224,6 +239,7 @@ export function printHostCapabilities(hosts = detectHostCapabilities()) {
   for (const host of hosts) {
     console.log("");
     console.log(`${host.host}: ${host.availability}${host.version ? ` (${host.version})` : ""}`);
+    console.log(`  capability: ${host.capability}`);
     console.log(`  orchestration: ${host.orchestration}`);
     console.log(`  promptable workers: ${host.promptableWorkers === true ? "yes" : "no"}`);
     console.log(`  shared task runtime: ${host.sharedTaskRuntime === true ? "native" : host.sharedTaskRuntime || "none"}`);

package/lib/host-disposition.mjs

@@ -0,0 +1,76 @@
+/**
+ * lib/host-disposition.mjs — single source of truth for the disposition of
+ * every artifact Construct creates in a host project (ADR-0027 §1).
+ *
+ * `IGNORED_PATTERNS` enumerates machine-specific, sync-regenerated artifacts
+ * that must never be committed; the init `.gitignore` writer and the
+ * `gitignore-coverage` reconciliation both read from here, and uninstall /
+ * adapter-prune consume `ADAPTER_DIRS`. Keep this 1:1 with the host-relevant
+ * subset of Construct's own repo .gitignore so forward-fix and backward-repair
+ * never diverge.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Adapter directories `construct sync` regenerates per host platform. Each
+// carries machine-specific absolute paths (MCP server paths, env-resolved
+// tokens) and is recreated on demand, so none is durable repo state.
+
+export const ADAPTER_DIRS = ['.claude', '.codex', '.cursor', '.vscode', '.opencode'];
+
+// Every artifact whose disposition is `ignored`. A trailing slash marks a
+// directory. `.construct/` is the per-project launcher (host scope only — the
+// Construct repo itself tracks `.construct/version`, hence the divergence from
+// the repo .gitignore for that one entry).
+
+export const IGNORED_PATTERNS = [
+  '.cx/',
+  '.claude/',
+  '.codex/',
+  '.cursor/',
+  '.vscode/',
+  '.opencode/',
+  '.construct/',
+  '.mcp.json',
+  '.github/prompts/',
+  '.github/copilot-instructions.md',
+  'config.env',
+  'embed.yaml',
+  'plan.md',
+  'inbox/',
+];
+
+// A pattern counts as already-ignored when an existing line matches it exactly,
+// matches its bare/slashed form, or is a broader `*` / `**` catch-all.
+
+export function isPatternIgnored(pattern, presentLines) {
+  const present = presentLines instanceof Set ? presentLines : new Set(presentLines);
+  if (present.has('*') || present.has('**')) return true;
+  const bare = pattern.replace(/\/$/, '');
+  return present.has(pattern) || present.has(bare) || present.has(`${bare}/`) || present.has(`${bare}/**`);
+}
+
+// Patterns from IGNORED_PATTERNS not yet covered by `content` (a .gitignore body).
+
+export function missingIgnorePatterns(content) {
+  const present = new Set((content || '').split('\n').map((l) => l.trim()));
+  return IGNORED_PATTERNS.filter((p) => !isPatternIgnored(p, present));
+}
+
+// Detection: a package.json declaring this as the `construct` package. Used
+// to prevent `construct init` and `construct sync` from misapplying host
+// project rules (like ignoring .construct/) to the Construct repository itself.
+
+export function isConstructPackageRepo(dir) {
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (!pkg) return false;
+    if (pkg.name === 'construct' || pkg.name === '@geraldmaron/construct') return true;
+    return pkg.bin && (pkg.bin === 'bin/construct' || (typeof pkg.bin === 'object' && pkg.bin.construct === 'bin/construct'));
+  } catch {
+    return false;
+  }
+}

package/lib/ingest/provider-extract.mjs

@@ -114,7 +114,7 @@ async function callAnthropic({ model, apiKey, content, fetchImpl }) {
 async function callOpenRouter({ model, apiKey, content, fetchImpl }) {
   const res = await fetchImpl('https://openrouter.ai/api/v1/chat/completions', {
     method: 'POST',
-    headers: { Authorization: `Bearer ${apiKey}`, 'content-type': 'application/json', 'HTTP-Referer': 'https://github.com/construct' },
+    headers: { Authorization: `Bearer ${apiKey}`, 'content-type': 'application/json', 'HTTP-Referer': 'https://github.com/geraldmaron/construct' },
     body: JSON.stringify({
       model: model.replace(/^openrouter\//, ''),
       max_tokens: MAX_OUTPUT_TOKENS,

package/lib/init-docs.mjs

@@ -785,7 +785,7 @@ async function main() {
       process.stdout.write(`[init:docs] skipping .cx/inbox/ — ${inboxDecision.reason}. Run with --force to scaffold anyway.\n`);
       skipped.push('.cx/inbox/ (deferred to existing intake)');
     } else {
-      writeIfMissing(path.join(target, '.cx', 'inbox', '.gitkeep'), '');
+      fs.mkdirSync(path.join(target, '.cx', 'inbox'), { recursive: true });
     }
   }