@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-VYI4DSZP.js

@@ -0,0 +1,2017 @@
+import {
+  CONTEXT_DIR,
+  KNOWLEDGE_BLOCK_BEGIN,
+  knowledgeManifestPath
+} from "./chunk-BQ3VAGXH.js";
+import {
+  FRAMEWORK_LABELS,
+  collectFiles,
+  dependencyNameSet,
+  detectFrameworks,
+  extractDirectDependencies,
+  isFrameworkDependency,
+  isSkippedDirectory
+} from "./chunk-PFCXFO7A.js";
+import {
+  atomicWriteJsonSync,
+  atomicWriteText
+} from "./chunk-RFDVSI4N.js";
+import {
+  PROJECT_LANGUAGES,
+  detectProjectCapabilities,
+  isIgnoredProjectPath
+} from "./chunk-AHU3FKPA.js";
+
+// src/core/knowledge/detect.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync as readFileSync2, statSync } from "fs";
+import path2 from "path";
+
+// src/core/stack/vocabulary.ts
+var STACK_DIMENSIONS = ["lang", "sdk", "fw", "domain", "tool"];
+var DECLARABLE_LANGUAGES = PROJECT_LANGUAGES.filter(
+  (language) => language !== "docs" && language !== "unknown"
+);
+var DECLARABLE_LANGUAGE_SET = new Set(DECLARABLE_LANGUAGES);
+var TOKEN_SHAPE_PATTERN = /^[a-z][a-z0-9.+-]{0,39}$/;
+var SDK_TARGET_PATTERN = /^[a-z][a-z0-9]*-\d+(?:\.\d+)*$/;
+function normalizeSdkToken(token) {
+  const dashIndex = token.search(/-\d/);
+  if (dashIndex <= 0) return token;
+  const platform = token.slice(0, dashIndex);
+  let version = token.slice(dashIndex + 1);
+  while (version.endsWith(".0")) version = version.slice(0, -2);
+  return `${platform}-${version}`;
+}
+var CLASSIFICATION_HINTS = {
+  terraform: "tool",
+  dbt: "tool",
+  docker: "tool",
+  kubernetes: "tool",
+  ansible: "tool",
+  pulumi: "tool",
+  bazel: "tool",
+  cmake: "tool",
+  gradle: "tool",
+  maven: "tool",
+  aws: "domain",
+  gcp: "domain",
+  azure: "domain",
+  snowflake: "domain",
+  databricks: "domain",
+  // arduino/latex are ecosystems/toolchains for classification purposes:
+  // `lang`/`sdk` hints are FORBIDDEN here because those dimensions carry
+  // extra validation (canonical ProjectLanguage / <platform>-<version>) that
+  // a hint must never bypass — enforced again in classifyStackToken.
+  arduino: "tool",
+  latex: "tool",
+  openapi: "domain",
+  graphql: "domain"
+};
+var TOOL_MARKERS = {
+  terraform: ["*.tf"],
+  dbt: ["dbt_project.yml", "dbt_project.yaml"],
+  docker: [
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml"
+  ],
+  kubernetes: ["kustomization.yml", "kustomization.yaml"],
+  ansible: ["ansible.cfg"],
+  pulumi: ["Pulumi.yaml", "Pulumi.yml"],
+  bazel: ["WORKSPACE", "MODULE.bazel"],
+  cmake: ["CMakeLists.txt"],
+  gradle: ["build.gradle", "build.gradle.kts"],
+  maven: ["pom.xml"],
+  arduino: ["*.ino"],
+  latex: ["*.tex"]
+};
+var DIMENSION_SET = new Set(STACK_DIMENSIONS);
+function classifyStackToken(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  if (!trimmed) return { ok: false, error: "Empty stack token." };
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex > 0) {
+    const dim = trimmed.slice(0, colonIndex);
+    const token = trimmed.slice(colonIndex + 1);
+    if (!DIMENSION_SET.has(dim)) {
+      return {
+        ok: false,
+        error: `Unknown dimension prefix "${dim}:" in "${raw}". Valid prefixes: ${STACK_DIMENSIONS.map((d) => `${d}:`).join(" ")}`
+      };
+    }
+    if (!TOKEN_SHAPE_PATTERN.test(token)) {
+      return {
+        ok: false,
+        error: `Invalid token "${token}" in "${raw}": tokens are lowercase words of letters/digits/./+/- (max 40 chars).`
+      };
+    }
+    const dimension = dim;
+    if (dimension === "lang" && !DECLARABLE_LANGUAGE_SET.has(token)) {
+      return {
+        ok: false,
+        error: `"${token}" is not a known project language. Known: ${DECLARABLE_LANGUAGES.join(", ")}. For frameworks/tools/domains use fw:/tool:/domain: prefixes.`
+      };
+    }
+    if (dimension === "sdk" && !SDK_TARGET_PATTERN.test(token)) {
+      return {
+        ok: false,
+        error: `sdk: tokens must be <platform>-<version> (e.g. macos-26, ios-17, k8s-1.31); got "${token}".`
+      };
+    }
+    const normalized = dimension === "sdk" ? normalizeSdkToken(token) : token;
+    return { ok: true, token: { token: normalized, dimension, explicit: true } };
+  }
+  if (!TOKEN_SHAPE_PATTERN.test(trimmed)) {
+    return {
+      ok: false,
+      error: `Unrecognized stack token: "${raw}". Tokens are lowercase words of letters/digits/./+/- (max 40 chars), optionally prefixed with ${STACK_DIMENSIONS.map((d) => `${d}:`).join("/")}.`
+    };
+  }
+  if (DECLARABLE_LANGUAGE_SET.has(trimmed)) {
+    return { ok: true, token: { token: trimmed, dimension: "lang", explicit: false } };
+  }
+  if (SDK_TARGET_PATTERN.test(trimmed)) {
+    return {
+      ok: true,
+      token: { token: normalizeSdkToken(trimmed), dimension: "sdk", explicit: false }
+    };
+  }
+  const hinted = Object.hasOwn(CLASSIFICATION_HINTS, trimmed) ? CLASSIFICATION_HINTS[trimmed] : void 0;
+  if (hinted && hinted !== "lang" && hinted !== "sdk") {
+    return { ok: true, token: { token: trimmed, dimension: hinted, explicit: false } };
+  }
+  return { ok: true, token: { token: trimmed, dimension: "fw", explicit: false } };
+}
+function hasStrongAnchor(tokens) {
+  return tokens.some((t) => t.dimension === "lang" || t.dimension === "sdk" || t.explicit === true);
+}
+var DETECTABLE_FRAMEWORKS = FRAMEWORK_LABELS;
+var DETECTABLE_SDK_PLATFORMS = /* @__PURE__ */ new Set([
+  "ios",
+  "macos",
+  "watchos",
+  "tvos",
+  "visionos"
+]);
+function isGatingToken(token) {
+  switch (token.dimension) {
+    case "lang":
+      return true;
+    case "sdk":
+      return DETECTABLE_SDK_PLATFORMS.has(sdkPlatform(token.token));
+    case "fw":
+      return DETECTABLE_FRAMEWORKS.has(token.token);
+    case "tool":
+      return Object.hasOwn(TOOL_MARKERS, token.token);
+    case "domain":
+      return false;
+  }
+}
+function sdkPlatform(token) {
+  const dashIndex = token.search(/-\d/);
+  return dashIndex > 0 ? token.slice(0, dashIndex) : token;
+}
+function sdkVersion(token) {
+  const dashIndex = token.search(/-\d/);
+  return dashIndex > 0 ? token.slice(dashIndex + 1) : "";
+}
+
+// src/core/knowledge/service-signals.ts
+var SERVICE_SIGNALS = [
+  // Payments
+  {
+    token: "stripe",
+    category: "Payments",
+    envKeys: ["STRIPE_SECRET_KEY"],
+    packages: [
+      "stripe",
+      "@stripe/stripe-js",
+      "stripe-ios",
+      "stripe-python",
+      "stripe-go",
+      "stripe-php"
+    ],
+    hostnames: ["api.stripe.com"],
+    docsUrl: "https://docs.stripe.com/api",
+    docDomain: "stripe.com",
+    description: "Stripe payments API \u2014 official API reference"
+  },
+  {
+    token: "paypal",
+    category: "Payments",
+    envKeys: ["PAYPAL_CLIENT_ID", "PAYPAL_CLIENT_SECRET"],
+    packages: ["@paypal/checkout-server-sdk", "@paypal/paypal-server-sdk"],
+    hostnames: ["api-m.paypal.com"],
+    docsUrl: "https://developer.paypal.com/api/rest/",
+    docDomain: "developer.paypal.com",
+    description: "PayPal REST API \u2014 official developer documentation"
+  },
+  // AI / LLM
+  {
+    token: "openai",
+    category: "AI/LLM",
+    envKeys: ["OPENAI_API_KEY"],
+    // SwiftPM repo slugs: MacPaw/OpenAI => `openai`; openai-swift community slug.
+    packages: ["openai", "openai-swift"],
+    hostnames: ["api.openai.com"],
+    docsUrl: "https://platform.openai.com/docs",
+    docDomain: "platform.openai.com",
+    description: "OpenAI API \u2014 official platform documentation"
+  },
+  {
+    token: "anthropic",
+    category: "AI/LLM",
+    envKeys: ["ANTHROPIC_API_KEY"],
+    // npm `@anthropic-ai/sdk`, PyPI `anthropic`; SwiftPM slugs anthropic-sdk-*.
+    packages: ["@anthropic-ai/sdk", "anthropic", "anthropic-sdk-swift", "swift-anthropic"],
+    hostnames: ["api.anthropic.com"],
+    docsUrl: "https://docs.anthropic.com",
+    docDomain: "anthropic.com",
+    description: "Anthropic Claude API \u2014 official documentation"
+  },
+  // Communications
+  {
+    token: "twilio",
+    category: "Communications",
+    envKeys: ["TWILIO_ACCOUNT_SID", "TWILIO_AUTH_TOKEN"],
+    packages: ["twilio"],
+    hostnames: ["api.twilio.com"],
+    docsUrl: "https://www.twilio.com/docs",
+    docDomain: "twilio.com",
+    description: "Twilio SMS/voice API \u2014 official documentation"
+  },
+  {
+    token: "sendgrid",
+    category: "Email",
+    envKeys: ["SENDGRID_API_KEY"],
+    packages: ["@sendgrid/mail", "@sendgrid/client"],
+    hostnames: ["api.sendgrid.com"],
+    docsUrl: "https://www.twilio.com/docs/sendgrid",
+    docDomain: "twilio.com",
+    description: "Twilio SendGrid email API \u2014 official documentation"
+  },
+  {
+    token: "resend",
+    category: "Email",
+    envKeys: ["RESEND_API_KEY"],
+    packages: ["resend"],
+    hostnames: ["api.resend.com"],
+    docsUrl: "https://resend.com/docs",
+    docDomain: "resend.com",
+    description: "Resend transactional email API \u2014 official documentation"
+  },
+  // Auth
+  {
+    token: "auth0",
+    category: "Authentication",
+    // AUTH0_DOMAIN alone is app-configurable; the secret is the strong signal.
+    envKeys: ["AUTH0_CLIENT_SECRET"],
+    packages: ["auth0", "express-openid-connect", "@auth0/auth0-react", "@auth0/nextjs-auth0"],
+    hostnames: [],
+    docsUrl: "https://auth0.com/docs",
+    docDomain: "auth0.com",
+    description: "Auth0 identity platform \u2014 official documentation"
+  },
+  {
+    token: "clerk",
+    category: "Authentication",
+    envKeys: ["CLERK_SECRET_KEY"],
+    packages: ["@clerk/nextjs", "@clerk/backend", "@clerk/clerk-sdk-node"],
+    hostnames: ["api.clerk.com"],
+    docsUrl: "https://clerk.com/docs",
+    docDomain: "clerk.com",
+    description: "Clerk authentication \u2014 official documentation"
+  },
+  // Backend / data platform
+  {
+    token: "supabase",
+    category: "Backend",
+    // Score on the service-role (secret) key, not the public anon key.
+    envKeys: ["SUPABASE_SERVICE_ROLE_KEY"],
+    packages: ["@supabase/supabase-js"],
+    hostnames: [],
+    docsUrl: "https://supabase.com/docs",
+    docDomain: "supabase.com",
+    description: "Supabase backend platform \u2014 official documentation"
+  },
+  // Fintech
+  {
+    token: "plaid",
+    category: "Fintech",
+    envKeys: ["PLAID_CLIENT_ID", "PLAID_SECRET"],
+    packages: ["plaid"],
+    hostnames: ["api.plaid.com", "sandbox.plaid.com", "production.plaid.com"],
+    docsUrl: "https://plaid.com/docs",
+    docDomain: "plaid.com",
+    description: "Plaid financial data API \u2014 official documentation"
+  },
+  // Datastores
+  {
+    token: "mongodb",
+    category: "Datastore",
+    envKeys: ["MONGODB_URI", "MONGO_URL"],
+    packages: ["mongodb", "mongoose"],
+    hostnames: [],
+    docsUrl: "https://www.mongodb.com/docs/drivers/",
+    docDomain: "mongodb.com",
+    description: "MongoDB drivers \u2014 official documentation"
+  },
+  {
+    token: "redis",
+    category: "Datastore",
+    envKeys: ["REDIS_URL"],
+    packages: ["redis", "ioredis"],
+    hostnames: [],
+    docsUrl: "https://redis.io/docs/latest/develop/",
+    docDomain: "redis.io",
+    description: "Redis \u2014 official developer documentation"
+  },
+  // Search
+  {
+    token: "algolia",
+    category: "Search",
+    envKeys: ["ALGOLIA_ADMIN_API_KEY", "ALGOLIA_API_KEY"],
+    packages: ["algoliasearch"],
+    hostnames: [],
+    docsUrl: "https://www.algolia.com/doc/",
+    docDomain: "algolia.com",
+    description: "Algolia search API \u2014 official documentation"
+  }
+];
+var SERVICE_DOC_DOMAINS = Array.from(
+  new Set(SERVICE_SIGNALS.map((s) => s.docDomain))
+);
+function serviceSignalForToken(token) {
+  return SERVICE_SIGNALS.find((s) => s.token === token);
+}
+
+// src/core/knowledge/long-tail.ts
+var MAX_LONG_TAIL_LIBRARIES = 6;
+var PUBLIC_NAME_SHAPE = /^[a-z0-9@][a-z0-9@._/:+-]{0,99}$/;
+var SERVICE_PACKAGE_NAMES = new Set(
+  SERVICE_SIGNALS.flatMap((signal) => signal.packages.map((pkg) => pkg.toLowerCase()))
+);
+function namespaceOf(ecosystem, name) {
+  switch (ecosystem) {
+    case "npm":
+      return /^(@[^/]+)\//.exec(name)?.[1];
+    case "packagist":
+      return name.includes("/") ? name.split("/")[0] : void 0;
+    case "maven": {
+      const group = name.split(":")[0];
+      return group.split(".").slice(0, 2).join(".");
+    }
+    case "go": {
+      const segments = name.split("/");
+      return segments.length >= 3 ? segments.slice(0, 2).join("/") : void 0;
+    }
+    case "nuget":
+      return name.includes(".") ? name.split(".")[0] : void 0;
+    default:
+      return void 0;
+  }
+}
+function privateNamespaces(localPackages) {
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const local of localPackages) {
+    const namespace = namespaceOf(local.ecosystem, local.name);
+    if (namespace) namespaces.add(`${local.ecosystem}|${namespace}`);
+  }
+  return namespaces;
+}
+function isPrivateName(dependency, localNames, namespaces) {
+  if (localNames.has(`${dependency.ecosystem}|${dependency.name}`)) return true;
+  const namespace = namespaceOf(dependency.ecosystem, dependency.name);
+  return namespace !== void 0 && namespaces.has(`${dependency.ecosystem}|${namespace}`);
+}
+function selectLongTailLibraries(extracted, max = MAX_LONG_TAIL_LIBRARIES) {
+  const localNames = new Set(extracted.localPackages.map((p) => `${p.ecosystem}|${p.name}`));
+  const namespaces = privateNamespaces(extracted.localPackages);
+  const depthOf = (manifestPath) => manifestPath.split("/").length;
+  const eligible = extracted.dependencies.map((dependency, index) => ({ dependency, index })).filter(
+    ({ dependency }) => dependency.registry && dependency.kind === "runtime" && PUBLIC_NAME_SHAPE.test(dependency.name) && !dependency.name.includes("//") && !isFrameworkDependency(dependency) && !SERVICE_PACKAGE_NAMES.has(dependency.name) && !isPrivateName(dependency, localNames, namespaces)
+  ).sort(
+    (a, b) => depthOf(a.dependency.manifestPath) - depthOf(b.dependency.manifestPath) || a.index - b.index
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const selected = [];
+  for (const { dependency } of eligible) {
+    const key = `${dependency.ecosystem}|${dependency.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    selected.push({ ecosystem: dependency.ecosystem, name: dependency.name });
+    if (selected.length >= max) break;
+  }
+  return selected;
+}
+
+// src/core/knowledge/service-candidates.ts
+import { readdirSync, readFileSync } from "fs";
+import path from "path";
+
+// src/core/knowledge/service-candidates-contract.ts
+var CANDIDATE_KEY_SUFFIXES = [
+  "CLIENT_SECRET",
+  "CLIENT_ID",
+  "ACCOUNT_SID",
+  "SECRET_KEY",
+  // AUTH_TOKEN before TOKEN (longest-first): TWILIO_AUTH_TOKEN must extract
+  // `twilio` (matching the curated token), not a bogus `twilio_auth`.
+  "AUTH_TOKEN",
+  "API_KEY",
+  "SECRET",
+  "TOKEN",
+  "DSN"
+];
+var DEMOTED_SOURCE_SUFFIXES = /* @__PURE__ */ new Set([
+  "TOKEN",
+  "AUTH_TOKEN",
+  "SECRET"
+]);
+var STRIPPED_KEY_PREFIXES = [
+  "NEXT_PUBLIC_",
+  "REACT_APP_",
+  "VITE_",
+  "EXPO_PUBLIC_",
+  "NUXT_PUBLIC_"
+];
+var SUPPRESSED_TOKENS = /* @__PURE__ */ new Set([
+  "jwt",
+  "session",
+  "csrf",
+  "cookie",
+  "encryption",
+  "auth",
+  "oauth",
+  "refresh",
+  "bearer",
+  "access",
+  "id",
+  "signing",
+  "admin",
+  "db",
+  "database",
+  "fake",
+  "example",
+  "mock",
+  "dummy",
+  "test",
+  "your",
+  "my",
+  "sample",
+  // App/framework-internal secret owners — APP_SECRET, DJANGO_SECRET_KEY,
+  // NEXTAUTH_SECRET, FLASK_SECRET_KEY, RAILS_SECRET_KEY_BASE etc. are signing
+  // secrets for the app itself, never an external API service.
+  "app",
+  "server",
+  "api",
+  "web",
+  "client",
+  "django",
+  "flask",
+  "rails",
+  "laravel",
+  "express",
+  "nextauth",
+  "next_auth",
+  "devise",
+  "webhook",
+  "deploy",
+  "build",
+  "ci"
+]);
+var SUPPRESSED_TOKEN_PREFIXES = [
+  "fake_",
+  "example_",
+  "mock_",
+  "dummy_",
+  "test_",
+  "your_",
+  "my_",
+  "sample_"
+];
+var LLM_PROVIDER_KEY_NAMES = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "XAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "KIRO_API_KEY",
+  "ANTIGRAVITY_API_KEY",
+  "CURSOR_API_KEY",
+  "CODEX_API_KEY",
+  "CODEX_TOKEN",
+  "ZAI_API_KEY",
+  "GITHUB_TOKEN"
+]);
+var ENV_TEMPLATE_BASENAMES = /* @__PURE__ */ new Set([
+  ".env.example",
+  ".env.sample",
+  ".env.template",
+  ".env.dist"
+]);
+function envTemplateKeyNames(content) {
+  const keys = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const withoutExport = trimmed.replace(/^export\s+/, "");
+    const eq = withoutExport.indexOf("=");
+    const key = (eq >= 0 ? withoutExport.slice(0, eq) : withoutExport).trim();
+    if (/^[A-Z][A-Z0-9_]*$/.test(key)) keys.push(key);
+  }
+  return keys;
+}
+var CONFIG_BASENAMES = /* @__PURE__ */ new Set([".mcp.json"]);
+var CONFIG_EXTENSIONS = [".yaml", ".yml", ".toml", ".json"];
+var CANDIDATE_SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".swift",
+  ".py",
+  ".go",
+  ".rb",
+  ".java",
+  ".kt",
+  ".kts",
+  ".cs",
+  ".php",
+  ".rs",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".m",
+  ".mm",
+  ".dart",
+  ".scala",
+  ".ps1",
+  ".r",
+  ".sql",
+  ".pl",
+  ".ex",
+  ".exs"
+];
+var CANDIDATE_SCAN_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "test",
+  "tests",
+  "__tests__",
+  "spec",
+  "fixture",
+  "fixtures",
+  "mock",
+  "mocks",
+  "example",
+  "examples",
+  "sample",
+  "samples",
+  "vendor",
+  "third_party",
+  "third-party",
+  "docs",
+  "templates",
+  "backups"
+]);
+var API_ISH_SUBDOMAINS = /* @__PURE__ */ new Set(["api", "data"]);
+var MIN_PLAIN_HOST_OCCURRENCES = 3;
+var HOSTNAME_NOISE_PATTERNS = [
+  /(^|\.)example\.(com|org|net)$/i,
+  /^localhost$/i,
+  /^127\.0\.0\.1$/,
+  /(^|\.)local$/i,
+  /^(custom|env|your|foo|bar)\.api\./i,
+  /\.api\.com$/i,
+  /^(github|raw\.githubusercontent|gist\.github)\.com$/i,
+  /^(en\.)?wikipedia\.org$/i,
+  /^json-schema\.org$/i,
+  /^(cdn|fonts|ajax)\./i
+];
+var MAX_CANDIDATE_SCAN_FILES = 5e3;
+var MAX_CANDIDATE_CONTENT_SAMPLES = 120;
+var CANDIDATE_ITEM_ID_PREFIX = "docs:candidate:";
+var CANDIDATE_SEARCH_PRIORITY = [
+  "env-template",
+  "package",
+  "source",
+  "config",
+  "script",
+  "hostname"
+];
+var MAX_UNRESOLVED_LINES = 5;
+function candidateSetSignature(candidates) {
+  return candidates.map((c) => {
+    const evidence = Array.from(new Set(c.evidence.map((ev) => `${ev.class}=${ev.matched}`))).sort().join("+");
+    const safety = isCandidateQuerySafe(c) ? "q1" : "q0";
+    return `${c.token}:${c.confidence}:${evidence}:${safety}`;
+  }).sort().join(",");
+}
+var QUERY_SAFE_EVIDENCE_CLASSES = /* @__PURE__ */ new Set([
+  "env-template",
+  "package",
+  "config"
+]);
+var QUERY_SAFE_TLDS = /* @__PURE__ */ new Set([
+  "com",
+  "org",
+  "net",
+  "io",
+  "dev",
+  "ai",
+  "co",
+  "gov",
+  "edu",
+  "app",
+  "sh",
+  "us",
+  "uk",
+  "de",
+  "fr",
+  "jp",
+  "in",
+  "ca",
+  "au",
+  "nl",
+  "se",
+  "ch",
+  "eu"
+]);
+function isQuerySafeHostname(host) {
+  const labels = host.split(".").filter(Boolean);
+  if (labels.length < 2 || labels.length > 3) return false;
+  if (labels.some((label) => ["corp", "internal", "intranet", "local", "lan"].includes(label))) {
+    return false;
+  }
+  const tld = labels[labels.length - 1];
+  return QUERY_SAFE_TLDS.has(tld);
+}
+function isCandidateQuerySafe(candidate) {
+  return candidate.evidence.some(
+    (ev) => QUERY_SAFE_EVIDENCE_CLASSES.has(ev.class) || ev.class === "hostname" && isQuerySafeHostname(ev.matched.toLowerCase())
+  );
+}
+
+// src/core/knowledge/service-candidates.ts
+var MAX_CANDIDATE_CONTENT_BYTES = 64 * 1024;
+var SUFFIXES_LONGEST_FIRST = [...CANDIDATE_KEY_SUFFIXES].sort(
+  (a, b) => b.length - a.length
+);
+var GENERIC_TLDS = /* @__PURE__ */ new Set(["com", "net", "org", "io"]);
+var CURATED_TOKENS = new Set(SERVICE_SIGNALS.map((s) => s.token));
+var CURATED_ENV_KEY_TO_TOKEN = new Map(
+  SERVICE_SIGNALS.flatMap((s) => s.envKeys.map((key) => [key, s.token]))
+);
+function readTextSafe(filePath, maxBytes = MAX_CANDIDATE_CONTENT_BYTES) {
+  try {
+    return readFileSync(filePath, "utf8").slice(0, maxBytes);
+  } catch {
+    return "";
+  }
+}
+var TEST_FILE_BASENAME = /(\.test\.|\.spec\.|_test\.|^test_|^conftest\.py$|Tests?\.swift$|Spec\.swift$)/;
+function classifySurface(basename) {
+  if (ENV_TEMPLATE_BASENAMES.has(basename)) return "env-template";
+  if (TEST_FILE_BASENAME.test(basename)) return null;
+  if (basename.endsWith(".sh")) return "script";
+  if (CONFIG_BASENAMES.has(basename)) return "config";
+  const ext = path.extname(basename).toLowerCase();
+  if (CONFIG_EXTENSIONS.includes(ext)) return "config";
+  if (CANDIDATE_SOURCE_EXTENSIONS.includes(ext)) return "source";
+  return null;
+}
+function hasExcludedSegment(relativePath) {
+  return relativePath.split(path.sep).some((segment) => CANDIDATE_SCAN_EXCLUDED_DIRS.has(segment.toLowerCase()));
+}
+function collectClassifiedFiles(root) {
+  const collected = [];
+  const stack = [""];
+  let visited = 0;
+  while (stack.length > 0 && visited < MAX_CANDIDATE_SCAN_FILES) {
+    const relativeDirectory = stack.pop() ?? "";
+    let entries;
+    try {
+      entries = readdirSync(path.join(root, relativeDirectory), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const relativePath = path.join(relativeDirectory, entry.name);
+      if (isIgnoredProjectPath(relativePath)) continue;
+      if (entry.isDirectory()) {
+        if (CANDIDATE_SCAN_EXCLUDED_DIRS.has(entry.name.toLowerCase())) continue;
+        stack.push(relativePath);
+      } else if (entry.isFile()) {
+        visited += 1;
+        if (hasExcludedSegment(relativePath)) continue;
+        const surface = classifySurface(entry.name);
+        if (surface && collected.length < MAX_CANDIDATE_CONTENT_SAMPLES) {
+          collected.push({ relativePath, surface });
+        }
+      }
+      if (visited >= MAX_CANDIDATE_SCAN_FILES) break;
+    }
+  }
+  return collected;
+}
+function stripKeyPrefix(upperKey) {
+  for (const prefix of STRIPPED_KEY_PREFIXES) {
+    if (upperKey.startsWith(prefix)) return upperKey.slice(prefix.length);
+  }
+  return upperKey;
+}
+function extractToken(upperKey) {
+  const name = stripKeyPrefix(upperKey);
+  for (const suffix of SUFFIXES_LONGEST_FIRST) {
+    if (name === suffix) return null;
+    if (name.endsWith(`_${suffix}`)) {
+      const remainder = name.slice(0, name.length - suffix.length - 1);
+      if (!remainder) return null;
+      return { token: remainder.toLowerCase(), suffix };
+    }
+  }
+  return null;
+}
+function uppercaseKeyIdentifiers(content) {
+  return content.match(/\b[A-Z][A-Z0-9_]*\b/g) ?? [];
+}
+function configKeyIdentifiers(content) {
+  const keys = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("//")) continue;
+    const lhs = trimmed.match(/^["']?([A-Za-z][A-Za-z0-9_]*)["']?\s*[:=]/);
+    if (lhs?.[1]) keys.push(lhs[1]);
+    for (const jsonKey of trimmed.matchAll(/"([A-Za-z][A-Za-z0-9_]*)"\s*:/g)) {
+      if (jsonKey[1]) keys.push(jsonKey[1]);
+    }
+    for (const ref of trimmed.matchAll(/\$\{([A-Z][A-Z0-9_]*)\}/g)) {
+      if (ref[1]) keys.push(ref[1]);
+    }
+  }
+  return keys;
+}
+function extractHostnames(content) {
+  const hosts = [];
+  for (const match of content.toLowerCase().matchAll(/\bhttps?:\/\/([a-z0-9.-]+)/g)) {
+    const host = match[1];
+    if (host) hosts.push(host);
+  }
+  return hosts;
+}
+function isNoiseHost(host) {
+  return HOSTNAME_NOISE_PATTERNS.some((pattern) => pattern.test(host));
+}
+function stripHostPrefix(host) {
+  return host.replace(/^(?:api|data|www)\./, "");
+}
+function hostSlug(host) {
+  const labels = stripHostPrefix(host).split(".").filter(Boolean);
+  if (labels.length >= 2) {
+    const last = labels[labels.length - 1];
+    if (last && GENERIC_TLDS.has(last)) labels.pop();
+  }
+  return labels.join("-").toLowerCase();
+}
+function hostPrimaryLabel(host) {
+  return (stripHostPrefix(host).split(".")[0] ?? "").toLowerCase();
+}
+function newAccumulator() {
+  return {
+    evidence: /* @__PURE__ */ new Map(),
+    hasEnvTemplate: false,
+    hasCuratedEnvKey: false,
+    hasSourceNonDemoted: false,
+    hasSourceDemoted: false,
+    hasScript: false,
+    hasConfig: false,
+    hasHostname: false,
+    hasApiIshHostname: false,
+    hasRepeatedHostname: false
+  };
+}
+function addEvidence(acc, cls, matched) {
+  const key = `${cls}|${matched}`;
+  if (!acc.evidence.has(key)) acc.evidence.set(key, { class: cls, matched });
+}
+function isSuppressedToken(token) {
+  if (SUPPRESSED_TOKENS.has(token)) return true;
+  return SUPPRESSED_TOKEN_PREFIXES.some(
+    (prefix) => token.startsWith(prefix)
+  );
+}
+function detectServiceCandidates(root, dependencyNames = dependencyNameSet(extractDirectDependencies(root), {
+  npmScopes: true
+})) {
+  const accumulators = /* @__PURE__ */ new Map();
+  const getAcc = (token) => {
+    let acc = accumulators.get(token);
+    if (!acc) {
+      acc = newAccumulator();
+      accumulators.set(token, acc);
+    }
+    return acc;
+  };
+  const files = collectClassifiedFiles(root);
+  const hostCounts = /* @__PURE__ */ new Map();
+  for (const { relativePath, surface } of files) {
+    const content = readTextSafe(path.join(root, relativePath));
+    if (!content) continue;
+    if (surface === "source" || surface === "script") {
+      for (const host of extractHostnames(content)) {
+        hostCounts.set(host, (hostCounts.get(host) ?? 0) + 1);
+      }
+    }
+    let keyNames;
+    if (surface === "env-template") keyNames = envTemplateKeyNames(content);
+    else if (surface === "config") keyNames = configKeyIdentifiers(content);
+    else keyNames = uppercaseKeyIdentifiers(content);
+    for (const rawKey of keyNames) {
+      const upperKey = rawKey.toUpperCase();
+      const extracted = extractToken(upperKey);
+      if (!extracted) continue;
+      const strippedKey = stripKeyPrefix(upperKey);
+      const curatedToken = CURATED_ENV_KEY_TO_TOKEN.get(upperKey) ?? CURATED_ENV_KEY_TO_TOKEN.get(strippedKey);
+      const token = curatedToken ?? extracted.token;
+      const suffix = extracted.suffix;
+      if (isSuppressedToken(token)) continue;
+      if (LLM_PROVIDER_KEY_NAMES.has(upperKey) && surface !== "source" && surface !== "env-template") {
+        continue;
+      }
+      const acc = getAcc(token);
+      const cls = surface;
+      const evidenceText = surface === "source" || surface === "script" ? `*_${suffix} (redacted)` : rawKey;
+      addEvidence(acc, cls, evidenceText);
+      if (surface === "env-template") {
+        acc.hasEnvTemplate = true;
+        if (CURATED_ENV_KEY_TO_TOKEN.has(upperKey)) acc.hasCuratedEnvKey = true;
+      } else if (surface === "script") acc.hasScript = true;
+      else if (surface === "config") acc.hasConfig = true;
+      else if (DEMOTED_SOURCE_SUFFIXES.has(suffix)) acc.hasSourceDemoted = true;
+      else acc.hasSourceNonDemoted = true;
+    }
+  }
+  const squash = (s) => s.replace(/[-_.]/g, "");
+  const existingTokens = Array.from(accumulators.keys());
+  for (const [host, count] of hostCounts) {
+    if (isNoiseHost(host)) continue;
+    const firstLabel = host.split(".")[0] ?? "";
+    const apiIsh = API_ISH_SUBDOMAINS.has(firstLabel);
+    const primary = hostPrimaryLabel(host);
+    const squashedHost = squash(host);
+    const matchingTokens = existingTokens.filter((token) => {
+      const squashedToken = squash(token);
+      return squashedToken.length > 0 && (squashedHost.includes(squashedToken) || primary.length > 0 && squashedToken.includes(squash(primary)));
+    });
+    const containsExistingToken = matchingTokens.length > 0;
+    const repeated = count >= MIN_PLAIN_HOST_OCCURRENCES;
+    const qualifies = apiIsh || repeated || containsExistingToken;
+    if (!qualifies) continue;
+    const attach = (acc) => {
+      addEvidence(acc, "hostname", host);
+      acc.hasHostname = true;
+      if (apiIsh) acc.hasApiIshHostname = true;
+      if (repeated) acc.hasRepeatedHostname = true;
+    };
+    if (matchingTokens.length > 0) {
+      for (const token of matchingTokens) attach(getAcc(token));
+    } else {
+      const token = hostSlug(host);
+      if (!token || isSuppressedToken(token)) continue;
+      attach(getAcc(token));
+    }
+  }
+  const candidates = [];
+  for (const [token, acc] of accumulators) {
+    if (acc.evidence.size === 0) continue;
+    const hasSourceKey = acc.hasSourceNonDemoted || acc.hasSourceDemoted;
+    const hasManifestDep = dependencyNames.has(token);
+    const curatedWillOffer = acc.hasCuratedEnvKey || hasManifestDep;
+    if (CURATED_TOKENS.has(token) && curatedWillOffer && !hasSourceKey) continue;
+    const confidence = computeConfidence(acc, hasManifestDep) ? "confirmed" : "unconfirmed";
+    if (hasManifestDep) {
+      addEvidence(acc, "package", token);
+    }
+    const evidence = Array.from(acc.evidence.values()).sort(
+      (a, b) => a.class === b.class ? a.matched.localeCompare(b.matched) : a.class.localeCompare(b.class)
+    );
+    candidates.push({ token, confidence, evidence });
+  }
+  return candidates.sort((a, b) => a.token.localeCompare(b.token));
+}
+function computeConfidence(acc, hasManifestDep) {
+  if (acc.hasEnvTemplate || acc.hasSourceNonDemoted || acc.hasApiIshHostname || acc.hasRepeatedHostname) {
+    return true;
+  }
+  const lowClasses = /* @__PURE__ */ new Set();
+  if (acc.hasScript) lowClasses.add("script");
+  if (acc.hasConfig) lowClasses.add("config");
+  if (acc.hasHostname) lowClasses.add("hostname");
+  if (acc.hasSourceDemoted) lowClasses.add("demoted-source");
+  const corroborators = /* @__PURE__ */ new Set();
+  if (acc.hasHostname) corroborators.add("hostname");
+  if (hasManifestDep) corroborators.add("manifest-dep");
+  for (const low of lowClasses) {
+    for (const corroborator of corroborators) {
+      if (corroborator !== low) return true;
+    }
+  }
+  return false;
+}
+
+// src/core/knowledge/detect.ts
+var MAX_SAMPLE_BYTES = 16e3;
+var MAX_SERVICE_HOSTNAME_SAMPLES = 60;
+var MAX_SERVICE_SCAN_FILES = 5e3;
+var SERVICE_SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".swift",
+  ".py",
+  ".go",
+  ".rb",
+  ".java",
+  ".kt",
+  ".cs",
+  ".php",
+  ".rs"
+];
+var MCP_CONFIG_CANDIDATES = [".mcp.json", ".cursor/mcp.json", ".vscode/mcp.json"];
+function readTextSafe2(filePath, maxBytes = MAX_SAMPLE_BYTES) {
+  try {
+    return readFileSync2(filePath, "utf8").slice(0, maxBytes);
+  } catch {
+    return "";
+  }
+}
+function fileSizeBytes(filePath) {
+  try {
+    const stat = statSync(filePath);
+    return stat.isFile() ? stat.size : 0;
+  } catch {
+    return 0;
+  }
+}
+function detectSdkTargets(root) {
+  const targets = /* @__PURE__ */ new Set();
+  const packageSwift = readTextSafe2(path2.join(root, "Package.swift"), 32e3);
+  if (packageSwift) {
+    const platformPattern = /\.(iOS|macOS|watchOS|tvOS|visionOS)\s*\(\s*(?:\.v(\d+)(?:_\d+)?|"(\d+)(?:\.\d+)*")\s*\)/g;
+    for (const match of packageSwift.matchAll(platformPattern)) {
+      const platform = (match[1] ?? "").toLowerCase();
+      const version = match[2] ?? match[3];
+      if (platform && version) targets.add(`${platform}-${version}`);
+    }
+  }
+  const pbxprojFiles = collectFiles(
+    root,
+    (relativePath, basename) => basename === "project.pbxproj" && relativePath.includes(".xcodeproj"),
+    3
+  );
+  for (const relativePath of pbxprojFiles) {
+    const content = readTextSafe2(path2.join(root, relativePath), 256e3);
+    const ios = content.match(/IPHONEOS_DEPLOYMENT_TARGET\s*=\s*(\d+)(?:\.\d+)*/);
+    if (ios?.[1]) targets.add(`ios-${ios[1]}`);
+    const macos = content.match(/MACOSX_DEPLOYMENT_TARGET\s*=\s*(\d+)(?:\.\d+)*/);
+    if (macos?.[1]) targets.add(`macos-${macos[1]}`);
+  }
+  return Array.from(targets).sort();
+}
+var MAX_TOOL_SCAN_FILES = 5e3;
+function detectTools(root) {
+  const exactNames = /* @__PURE__ */ new Map();
+  const suffixes = /* @__PURE__ */ new Map();
+  for (const [tool, markers] of Object.entries(TOOL_MARKERS)) {
+    for (const marker of markers) {
+      if (marker.startsWith("*.")) suffixes.set(marker.slice(1), tool);
+      else exactNames.set(marker, tool);
+    }
+  }
+  const found = /* @__PURE__ */ new Set();
+  let visited = 0;
+  collectFiles(
+    root,
+    (_relativePath, basename) => {
+      visited += 1;
+      const exact = exactNames.get(basename);
+      if (exact) found.add(exact);
+      for (const [suffix, tool] of suffixes) {
+        if (basename.endsWith(suffix)) found.add(tool);
+      }
+      return visited >= MAX_TOOL_SCAN_FILES;
+    },
+    1,
+    // Fixture, example, test, and vendored trees are not the user's tooling.
+    { skipDirectory: isSkippedDirectory }
+  );
+  return Array.from(found).sort();
+}
+function collectEnvKeyNames(root) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const candidate of ENV_TEMPLATE_BASENAMES) {
+    const content = readTextSafe2(path2.join(root, candidate), 32e3);
+    if (!content) continue;
+    for (const key of envTemplateKeyNames(content)) keys.add(key);
+  }
+  return keys;
+}
+function isExcludedServicePath(relativePath) {
+  const segments = relativePath.toLowerCase().split(path2.sep);
+  return segments.some((segment) => CANDIDATE_SCAN_EXCLUDED_DIRS.has(segment));
+}
+function detectServices(root, dependencyNames) {
+  const envKeyNames = collectEnvKeyNames(root);
+  const anyHostnames = SERVICE_SIGNALS.some((s) => s.hostnames.length > 0);
+  const sourceHostnames = anyHostnames ? collectServiceHostnames(root) : /* @__PURE__ */ new Set();
+  const detected = [];
+  for (const signal of SERVICE_SIGNALS) {
+    const evidence = [];
+    if (signal.envKeys.some((key) => envKeyNames.has(key))) evidence.push("env-key");
+    if (signal.packages.some((pkg) => dependencyNames.has(pkg.toLowerCase()))) {
+      evidence.push("package");
+    }
+    if (signal.hostnames.some((host) => sourceHostnames.has(host.toLowerCase()))) {
+      evidence.push("hostname");
+    }
+    if (evidence.length === 0) continue;
+    const strong = evidence.includes("env-key") || evidence.includes("package");
+    const confidence = strong ? evidence.length >= 2 ? "high" : "medium" : "low";
+    detected.push({ token: signal.token, confidence, evidence });
+  }
+  return detected.sort((a, b) => a.token.localeCompare(b.token));
+}
+function collectServiceHostnames(root) {
+  const wanted = /* @__PURE__ */ new Set();
+  for (const signal of SERVICE_SIGNALS) {
+    for (const host of signal.hostnames) wanted.add(host.toLowerCase());
+  }
+  const found = /* @__PURE__ */ new Set();
+  if (wanted.size === 0) return found;
+  let visited = 0;
+  const sourceFiles = collectFiles(
+    root,
+    (relativePath, basename) => {
+      if (visited >= MAX_SERVICE_SCAN_FILES) return true;
+      visited += 1;
+      return !isExcludedServicePath(relativePath) && SERVICE_SOURCE_EXTENSIONS.some((ext) => basename.endsWith(ext));
+    },
+    MAX_SERVICE_HOSTNAME_SAMPLES
+  );
+  for (const relativePath of sourceFiles) {
+    const content = readTextSafe2(path2.join(root, relativePath)).toLowerCase();
+    if (!content) continue;
+    for (const host of wanted) {
+      if (!found.has(host) && content.includes(host)) found.add(host);
+    }
+    if (found.size === wanted.size) break;
+  }
+  return found;
+}
+function auditAgentConfig(root) {
+  const agentsPath = path2.join(root, "AGENTS.md");
+  const agentsPresent = existsSync(agentsPath);
+  const agentsContent = agentsPresent ? readTextSafe2(agentsPath, 512e3) : "";
+  const claudePath = path2.join(root, "CLAUDE.md");
+  return {
+    agentsMd: {
+      present: agentsPresent,
+      sizeBytes: agentsPresent ? fileSizeBytes(agentsPath) : 0,
+      hasKnowledgeBlock: agentsContent.includes(KNOWLEDGE_BLOCK_BEGIN)
+    },
+    claudeMd: {
+      present: existsSync(claudePath),
+      sizeBytes: existsSync(claudePath) ? fileSizeBytes(claudePath) : 0
+    },
+    mcpConfigs: MCP_CONFIG_CANDIDATES.filter((candidate) => existsSync(path2.join(root, candidate))),
+    knowledgeManifest: { present: existsSync(knowledgeManifestPath(root)) }
+  };
+}
+function computeStackFingerprint(detection) {
+  const payload = {
+    languages: [...detection.languages].sort(),
+    frameworks: [...detection.frameworks].sort(),
+    sdkTargets: [...detection.sdkTargets].sort()
+  };
+  if (detection.tools && detection.tools.length > 0) payload.tools = [...detection.tools].sort();
+  if (detection.domains && detection.domains.length > 0)
+    payload.domains = [...detection.domains].sort();
+  return createHash("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
+}
+function detectStack(cwd, options = {}) {
+  const root = path2.resolve(cwd);
+  const capabilities = options.capabilities ?? detectProjectCapabilities(root);
+  const extracted = extractDirectDependencies(root);
+  const frameworks = detectFrameworks(root, { languages: capabilities.languages, extracted });
+  const sdkTargets = capabilities.languages.includes("swift") ? detectSdkTargets(root) : [];
+  const tools = detectTools(root);
+  const partial = {
+    languages: capabilities.languages,
+    frameworks,
+    sdkTargets,
+    tools
+  };
+  const detectedServices = detectServices(root, dependencyNameSet(extracted));
+  const serviceCandidates = detectServiceCandidates(
+    root,
+    dependencyNameSet(extracted, { npmScopes: true })
+  );
+  const libraryCandidates = selectLongTailLibraries(extracted);
+  return {
+    root,
+    ...partial,
+    ...detectedServices.length > 0 ? { detectedServices } : {},
+    ...serviceCandidates.length > 0 ? { serviceCandidates } : {},
+    ...libraryCandidates.length > 0 ? { libraryCandidates } : {},
+    agentConfig: auditAgentConfig(root),
+    fingerprint: computeStackFingerprint(partial)
+  };
+}
+
+// src/core/stack/declare-hint.ts
+function isPlaceholderLanguage(language) {
+  return language === "unknown" || language === "docs";
+}
+var DECLARE_STACK_EXAMPLE_SPEC = "python,fw:fastapi";
+var DECLARE_STACK_COMMAND = 'build init knowledge declare "<spec>"';
+var DECLARE_STACK_BLOCK_HINT = `If the intended stack is already decided, declare it with \`${DECLARE_STACK_COMMAND}\` (for example "${DECLARE_STACK_EXAMPLE_SPEC}"). Optional; this line disappears once a stack is detected or declared.`;
+
+// src/core/knowledge/intent.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, unlinkSync } from "fs";
+import path3 from "path";
+import { z } from "zod";
+var IntentDimensionStatus = z.enum(["active", "satisfied", "conflict", "retired"]);
+var IntentDimensionSchema = z.object({
+  token: z.string().min(1),
+  dimension: z.enum(STACK_DIMENSIONS),
+  status: IntentDimensionStatus,
+  statusChangedAt: z.string().min(1),
+  /** Present only in `conflict` status. */
+  conflict: z.object({
+    detectedToken: z.string().min(1),
+    acknowledged: z.boolean()
+  }).optional()
+});
+var StackIntentContractSchema = z.object({
+  schemaVersion: z.literal(1),
+  /** Verbatim user spec (provenance for notices and doctor). */
+  spec: z.string().min(1),
+  declaredAt: z.string().min(1),
+  /** Optional free-text rationale (`--reason`). */
+  rationale: z.string().optional(),
+  /** Derived, stored for greppability: retired | conflict | active. */
+  status: z.enum(["active", "conflict", "retired"]),
+  dimensions: z.array(IntentDimensionSchema),
+  retiredAt: z.string().nullable()
+});
+function stackIntentPath(cwd) {
+  return path3.join(cwd, ".build-project", "context", "knowledge", "stack-intent.json");
+}
+function legacyDeclaredStackPath(cwd) {
+  return path3.join(cwd, ".build-project", "state", "declared-stack.json");
+}
+function parseIntentSpec(spec) {
+  const rawTokens = spec.split(/[,\s]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+  if (rawTokens.length === 0) {
+    return {
+      ok: false,
+      error: "Empty --stack spec. Example: --stack swift,swiftui,macos-26 or --stack tool:terraform,domain:aws"
+    };
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const raw of rawTokens) {
+    const result = classifyStackToken(raw);
+    if (!result.ok) return { ok: false, error: result.error };
+    const key = `${result.token.dimension}:${result.token.token}`;
+    const existing = byKey.get(key);
+    if (!existing || result.token.explicit && !existing.explicit) {
+      byKey.set(key, result.token);
+    }
+  }
+  const tokens = Array.from(byKey.values());
+  if (!hasStrongAnchor(tokens)) {
+    return {
+      ok: false,
+      error: "--stack needs at least one strong anchor: a known language (swift, python, ...), a versioned platform (macos-26, k8s-1.31), or an explicitly prefixed token (tool:terraform, domain:aws, fw:htmx)."
+    };
+  }
+  return { ok: true, tokens };
+}
+function deriveContractStatus(dimensions) {
+  if (dimensions.every((d) => d.status === "retired")) {
+    return "retired";
+  }
+  if (dimensions.some((d) => d.status === "conflict" && d.conflict?.acknowledged !== true)) {
+    return "conflict";
+  }
+  return "active";
+}
+function createIntentContract(spec, tokens, options = {}) {
+  const nowIso = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const dimensions = tokens.map((token) => ({
+    token: token.token,
+    dimension: token.dimension,
+    status: "active",
+    statusChangedAt: nowIso
+  }));
+  return {
+    schemaVersion: 1,
+    spec,
+    declaredAt: nowIso,
+    ...options.rationale ? { rationale: options.rationale } : {},
+    status: deriveContractStatus(dimensions),
+    dimensions,
+    retiredAt: null
+  };
+}
+function readIntentContract(cwd) {
+  const filePath = stackIntentPath(cwd);
+  if (!existsSync2(filePath)) return { status: "absent" };
+  try {
+    const parsed = StackIntentContractSchema.safeParse(JSON.parse(readFileSync3(filePath, "utf8")));
+    if (!parsed.success) {
+      return { status: "invalid", error: parsed.error.issues[0]?.message ?? "schema mismatch" };
+    }
+    return { status: "ok", contract: parsed.data };
+  } catch (error) {
+    return { status: "invalid", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function writeIntentContract(cwd, contract) {
+  const filePath = stackIntentPath(cwd);
+  atomicWriteJsonSync(filePath, contract);
+}
+function removeIntentContract(cwd) {
+  try {
+    unlinkSync(stackIntentPath(cwd));
+  } catch {
+  }
+}
+var LegacyDeclaredSchema = z.object({
+  schemaVersion: z.literal(1),
+  spec: z.string().min(1),
+  declaredAt: z.string().min(1),
+  languages: z.array(z.string()),
+  frameworks: z.array(z.string()),
+  sdkTargets: z.array(z.string())
+});
+function migrateLegacyDeclaration(cwd, options = {}) {
+  const legacyPath = legacyDeclaredStackPath(cwd);
+  if (!existsSync2(legacyPath)) return void 0;
+  const existing = readIntentContract(cwd);
+  if (existing.status !== "absent") {
+    if (existing.status === "ok") {
+      try {
+        unlinkSync(legacyPath);
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  let legacy;
+  try {
+    const parsed = LegacyDeclaredSchema.safeParse(JSON.parse(readFileSync3(legacyPath, "utf8")));
+    if (!parsed.success) return void 0;
+    legacy = parsed.data;
+  } catch {
+    return void 0;
+  }
+  const rawTokens = [...legacy.languages, ...legacy.sdkTargets, ...legacy.frameworks];
+  const tokens = [];
+  for (const raw of rawTokens) {
+    const result = classifyStackToken(raw);
+    if (result.ok) tokens.push(result.token);
+  }
+  if (tokens.length === 0) return void 0;
+  const contract = createIntentContract(legacy.spec, tokens, { now: options.now });
+  const migrated = { ...contract, declaredAt: legacy.declaredAt };
+  writeIntentContract(cwd, migrated);
+  try {
+    unlinkSync(legacyPath);
+  } catch {
+  }
+  return migrated;
+}
+function resolveIntent(detection, contract, options = {}) {
+  const nowIso = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const detectedLanguages = new Set(detection.languages);
+  const detectedFrameworks = new Set(detection.frameworks);
+  const detectedSdk = new Set(detection.sdkTargets);
+  const detectedTools = new Set(detection.tools ?? []);
+  const detectedDomains = new Set(detection.domains ?? []);
+  const detectedSdkByPlatform = /* @__PURE__ */ new Map();
+  for (const target of detection.sdkTargets) {
+    detectedSdkByPlatform.set(sdkPlatform(target), target);
+  }
+  const languages = new Set(detection.languages);
+  const frameworks = new Set(detection.frameworks);
+  const sdkTargets = new Set(detection.sdkTargets);
+  const tools = new Set(detection.tools ?? []);
+  const domains = new Set(detection.domains ?? []);
+  const acknowledgedSdkPairs = [...detection.acknowledgedSdkPairs ?? []];
+  const conflicts = [];
+  let contractChanged = false;
+  let declaredRealLanguage = false;
+  const dimensions = contract.dimensions.map((dim) => {
+    if (dim.status === "retired") return dim;
+    const setStatus = (status, conflict) => {
+      const unchanged = dim.status === status && dim.conflict?.detectedToken === conflict?.detectedToken && dim.conflict?.acknowledged === conflict?.acknowledged;
+      if (unchanged) return dim;
+      contractChanged = true;
+      return {
+        ...dim,
+        status,
+        statusChangedAt: nowIso,
+        ...conflict ? { conflict } : { conflict: void 0 }
+      };
+    };
+    switch (dim.dimension) {
+      case "lang": {
+        declaredRealLanguage = true;
+        if (detectedLanguages.has(dim.token)) {
+          return setStatus("satisfied");
+        }
+        languages.add(dim.token);
+        return setStatus("active");
+      }
+      case "fw": {
+        if (detectedFrameworks.has(dim.token)) return setStatus("satisfied");
+        frameworks.add(dim.token);
+        return setStatus("active");
+      }
+      case "tool": {
+        if (detectedTools.has(dim.token)) return setStatus("satisfied");
+        tools.add(dim.token);
+        return setStatus("active");
+      }
+      case "domain": {
+        if (detectedDomains.has(dim.token)) return setStatus("satisfied");
+        domains.add(dim.token);
+        return setStatus("active");
+      }
+      case "sdk": {
+        if (detectedSdk.has(dim.token)) return setStatus("satisfied");
+        const platform = sdkPlatform(dim.token);
+        const detectedSame = detectedSdkByPlatform.get(platform);
+        if (!detectedSame) {
+          sdkTargets.add(dim.token);
+          return setStatus("active");
+        }
+        const acknowledged = dim.conflict?.acknowledged === true && dim.conflict.detectedToken === detectedSame;
+        if (acknowledged) {
+          sdkTargets.add(dim.token);
+          acknowledgedSdkPairs.push({
+            platform,
+            sdkVersion: sdkVersion(dim.token),
+            deploymentVersion: sdkVersion(detectedSame)
+          });
+          return setStatus("conflict", { detectedToken: detectedSame, acknowledged: true });
+        }
+        const next = setStatus("conflict", { detectedToken: detectedSame, acknowledged: false });
+        conflicts.push({ dimension: next, detectedToken: detectedSame });
+        return next;
+      }
+      default: {
+        const exhaustive = dim.dimension;
+        return exhaustive;
+      }
+    }
+  });
+  if (declaredRealLanguage) {
+    languages.delete("docs");
+    languages.delete("unknown");
+    if (languages.size === 0) {
+      for (const dim of dimensions) {
+        if (dim.dimension === "lang") {
+          languages.add(dim.token);
+        }
+      }
+    }
+  }
+  const partial = {
+    languages: Array.from(languages).sort(),
+    frameworks: Array.from(frameworks).sort(),
+    sdkTargets: Array.from(sdkTargets).sort(),
+    tools: Array.from(tools).sort(),
+    domains: Array.from(domains).sort()
+  };
+  const updatedContract = {
+    ...contract,
+    status: deriveContractStatus(dimensions),
+    dimensions
+  };
+  if (updatedContract.status !== contract.status) contractChanged = true;
+  const effective = {
+    ...detection,
+    ...partial,
+    ...acknowledgedSdkPairs.length > 0 ? { acknowledgedSdkPairs } : {},
+    fingerprint: computeStackFingerprint(partial)
+  };
+  const dimensionDone = (d) => d.status === "satisfied" || d.status === "retired" || d.status === "conflict" && d.conflict?.acknowledged === true;
+  const allCovered = dimensions.every(dimensionDone);
+  const allSatisfied = allCovered || dimensions.every(
+    (d) => dimensionDone(d) || !isGatingToken({ token: d.token, dimension: d.dimension, explicit: true })
+  );
+  return {
+    effective,
+    contract: updatedContract,
+    contractChanged,
+    conflicts,
+    allSatisfied,
+    allCovered
+  };
+}
+function retireContract(contract, options = {}) {
+  const nowIso = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...contract,
+    status: "retired",
+    retiredAt: nowIso,
+    dimensions: contract.dimensions.map(
+      (dim) => dim.status === "retired" ? dim : { ...dim, status: "retired", statusChangedAt: nowIso }
+    )
+  };
+}
+function acknowledgeConflicts(contract, options = {}) {
+  const nowIso = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const dimensions = contract.dimensions.map((dim) => {
+    if (dim.status !== "conflict" || dim.conflict?.acknowledged === true) return dim;
+    return {
+      ...dim,
+      statusChangedAt: nowIso,
+      conflict: {
+        ...dim.conflict,
+        acknowledged: true
+      }
+    };
+  });
+  return { ...contract, status: deriveContractStatus(dimensions), dimensions };
+}
+function acceptDetectedReality(contract, options = {}) {
+  const nowIso = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const dimensions = contract.dimensions.map((dim) => {
+    if (dim.status !== "conflict") return dim;
+    return { ...dim, status: "retired", statusChangedAt: nowIso, conflict: void 0 };
+  });
+  return { ...contract, status: deriveContractStatus(dimensions), dimensions };
+}
+function describeDimension(dim) {
+  const base = `${dim.token.padEnd(12)} ${dim.dimension.padEnd(6)} ${dim.status}`;
+  if (dim.status === "conflict" && dim.conflict) {
+    const ack = dim.conflict.acknowledged ? " (acknowledged)" : "";
+    return `${base}${ack} \u2014 detected ${dim.conflict.detectedToken}`;
+  }
+  if (dim.status === "active") return `${base} (not yet in code)`;
+  return base;
+}
+
+// src/core/knowledge/resolved-detection.ts
+import { existsSync as existsSync3 } from "fs";
+function emptyStackDetection(root) {
+  return {
+    root,
+    languages: [],
+    frameworks: [],
+    sdkTargets: [],
+    tools: [],
+    domains: [],
+    fingerprint: "",
+    agentConfig: {
+      agentsMd: { present: false, sizeBytes: 0, hasKnowledgeBlock: false },
+      claudeMd: { present: false, sizeBytes: 0 },
+      mcpConfigs: [],
+      knowledgeManifest: { present: false }
+    }
+  };
+}
+function resolvedStackDetection(cwd, options = {}) {
+  let detection;
+  try {
+    detection = detectStack(cwd, options);
+  } catch {
+    return emptyStackDetection(cwd);
+  }
+  try {
+    const stored = readIntentContract(cwd);
+    if (stored.status !== "ok" || stored.contract.status === "retired") {
+      return detection;
+    }
+    return resolveIntent(detection, stored.contract).effective;
+  } catch {
+    return detection;
+  }
+}
+function isStackUndetectedAndUndeclared(cwd) {
+  try {
+    const d = detectStack(cwd);
+    const detected = d.languages.filter((language) => !isPlaceholderLanguage(language)).length + d.frameworks.length + d.sdkTargets.length + (d.tools ?? []).length + (d.domains ?? []).length;
+    if (detected > 0) return false;
+    if (existsSync3(legacyDeclaredStackPath(cwd))) return false;
+    const stored = readIntentContract(cwd);
+    return !(stored.status === "ok" && stored.contract.status !== "retired");
+  } catch {
+    return false;
+  }
+}
+
+// src/core/init-drift/state.ts
+import fs from "fs";
+import path5 from "path";
+
+// src/core/init-drift/fingerprint.ts
+import { createHash as createHash2 } from "crypto";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import path4 from "path";
+var STACK_FINGERPRINT_VERSION = 1;
+var STACK_FILE_NAMES = [
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "pyproject.toml",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile",
+  "Pipfile.lock",
+  "go.mod",
+  "go.sum",
+  "Cargo.toml",
+  "Cargo.lock",
+  "Package.swift",
+  "Package.resolved",
+  "Gemfile",
+  "Gemfile.lock",
+  "composer.json",
+  "composer.lock",
+  "Dockerfile"
+];
+var REQUIREMENTS_PATTERN = /^requirements[\w.-]*\.(?:txt|in)$/i;
+var FRAMEWORK_SIGNAL_KEYS = [
+  "tsconfig",
+  "gradle",
+  "pomXml",
+  "cmakeLists",
+  "mesonBuild",
+  "dotnetSolution",
+  "dotnetProject",
+  "pubspecYaml",
+  "dbtProject",
+  "terraform",
+  "kubernetesManifests"
+];
+function hashFileContent(filePath) {
+  try {
+    const content = readFileSync4(filePath);
+    return createHash2("sha256").update(content).digest("hex");
+  } catch {
+    return void 0;
+  }
+}
+function listRootEntries(root) {
+  try {
+    return readdirSync2(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function isDirectoryEntry(root, entry) {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  try {
+    return statSync2(path4.join(root, entry.name)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function sortedRecord(record) {
+  const out = {};
+  for (const key of Object.keys(record).sort()) {
+    const value = record[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function computeStackFingerprint2(cwd) {
+  const root = path4.resolve(cwd);
+  const manifests = {};
+  const fileHashes = {};
+  const recordFile = (relativeName) => {
+    const hash = hashFileContent(path4.join(root, relativeName));
+    if (hash === void 0) return;
+    manifests[relativeName] = true;
+    fileHashes[relativeName] = hash;
+  };
+  for (const name of STACK_FILE_NAMES) {
+    recordFile(name);
+  }
+  const rootEntries = listRootEntries(root);
+  for (const entry of rootEntries) {
+    if (REQUIREMENTS_PATTERN.test(entry.name) && !manifests[entry.name]) {
+      recordFile(entry.name);
+      continue;
+    }
+    if (/\.xcodeproj$/i.test(entry.name) && isDirectoryEntry(root, entry)) {
+      manifests[entry.name] = true;
+      const pbxprojRelative = path4.join(entry.name, "project.pbxproj");
+      const hash = hashFileContent(path4.join(root, pbxprojRelative));
+      if (hash !== void 0) fileHashes[pbxprojRelative] = hash;
+      continue;
+    }
+    if (/\.xcworkspace$/i.test(entry.name) && isDirectoryEntry(root, entry)) {
+      manifests[entry.name] = true;
+    }
+  }
+  const capabilities = detectProjectCapabilities(root);
+  const languages = [...capabilities.languages].sort();
+  const capabilityManifests = capabilities.manifests;
+  const frameworks = [
+    ...FRAMEWORK_SIGNAL_KEYS.filter((key) => capabilityManifests[key] === true),
+    ...detectFrameworks(root, { languages: capabilities.languages })
+  ].sort();
+  return {
+    version: STACK_FINGERPRINT_VERSION,
+    languages,
+    frameworks,
+    manifests: sortedRecord(manifests),
+    fileHashes: sortedRecord(fileHashes)
+  };
+}
+function fingerprintDigest(fingerprint) {
+  return createHash2("sha256").update(JSON.stringify(fingerprint)).digest("hex");
+}
+
+// src/core/init-drift/state.ts
+var DEFAULT_NUDGE_CAP = 100;
+var DELIVERED_NUDGE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+function isStackDriftKind(kind) {
+  return kind !== "ci-setup" && kind !== "context-blocks-stale";
+}
+function resolveStateDir(cwd) {
+  return path5.join(path5.resolve(cwd), ".build-project", "state");
+}
+function resolveInitFingerprintPath(cwd) {
+  return path5.join(resolveStateDir(cwd), "init-fingerprint.json");
+}
+function resolveInitNudgesPath(cwd) {
+  return path5.join(resolveStateDir(cwd), "init-nudges.json");
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeJsonFile(filePath, value) {
+  fs.mkdirSync(path5.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readStoredFingerprint(cwd) {
+  const parsed = readJsonFile(resolveInitFingerprintPath(cwd));
+  if (!isRecord(parsed)) return void 0;
+  const fingerprint = parsed.fingerprint;
+  if (!isRecord(fingerprint)) return void 0;
+  if (!Array.isArray(fingerprint.languages) || !Array.isArray(fingerprint.frameworks) || !isRecord(fingerprint.manifests) || !isRecord(fingerprint.fileHashes)) {
+    return void 0;
+  }
+  const stored = fingerprint;
+  return {
+    fingerprint: stored,
+    digest: typeof parsed.digest === "string" ? parsed.digest : fingerprintDigest(stored),
+    recordedAtMs: typeof parsed.recordedAtMs === "number" ? parsed.recordedAtMs : 0
+  };
+}
+function writeStoredFingerprint(cwd, fingerprint, options = {}) {
+  const now = options.now ?? Date.now;
+  const file = {
+    version: 1,
+    digest: fingerprintDigest(fingerprint),
+    recordedAtMs: now(),
+    fingerprint
+  };
+  writeJsonFile(resolveInitFingerprintPath(cwd), file);
+}
+function isDriftRecord(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.key === "string" && typeof value.kind === "string" && typeof value.subject === "string" && (value.change === "added" || value.change === "removed") && Array.isArray(value.evidence) && typeof value.detectedAtMs === "number";
+}
+function isDeliveryRecord(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.key === "string" && typeof value.deliveredAtMs === "number" && typeof value.driftDetectedAtMs === "number";
+}
+function readNudgeState(cwd) {
+  const parsed = readJsonFile(resolveInitNudgesPath(cwd));
+  const state = { version: 1, drift: {}, deliveries: {} };
+  if (!isRecord(parsed)) return state;
+  if (isRecord(parsed.drift)) {
+    for (const [key, value] of Object.entries(parsed.drift)) {
+      if (isDriftRecord(value)) state.drift[key] = value;
+    }
+  }
+  if (isRecord(parsed.deliveries)) {
+    for (const [key, value] of Object.entries(parsed.deliveries)) {
+      if (isDeliveryRecord(value)) state.deliveries[key] = value;
+    }
+  }
+  return state;
+}
+function isDelivered(record, deliveries) {
+  const delivery = deliveries[record.key];
+  return delivery !== void 0 && delivery.driftDetectedAtMs === record.detectedAtMs;
+}
+function pruneNudgeState(state, nowMs, cap, ttlMs) {
+  const drift = {};
+  for (const [key, record] of Object.entries(state.drift)) {
+    if (isDelivered(record, state.deliveries)) {
+      const delivery = state.deliveries[key];
+      const age = nowMs - (delivery?.deliveredAtMs ?? nowMs);
+      if (age >= ttlMs && record.kind !== "ci-setup") continue;
+    }
+    drift[key] = record;
+  }
+  const entries = Object.entries(drift);
+  if (entries.length > cap) {
+    const byOldestFirst = (a, b) => a[1].detectedAtMs - b[1].detectedAtMs;
+    const delivered = entries.filter(([, r]) => isDelivered(r, state.deliveries));
+    const undelivered = entries.filter(([, r]) => !isDelivered(r, state.deliveries));
+    delivered.sort(byOldestFirst);
+    undelivered.sort(byOldestFirst);
+    let excess = entries.length - cap;
+    for (const [key] of delivered) {
+      if (excess <= 0) break;
+      delete drift[key];
+      excess -= 1;
+    }
+    for (const [key] of undelivered) {
+      if (excess <= 0) break;
+      delete drift[key];
+      excess -= 1;
+    }
+  }
+  const deliveries = {};
+  for (const [key, delivery] of Object.entries(state.deliveries)) {
+    if (drift[key] !== void 0) deliveries[key] = delivery;
+  }
+  return { version: 1, drift, deliveries };
+}
+function writeNudgeState(cwd, state, options) {
+  const now = options.now ?? Date.now;
+  const cap = options.cap ?? DEFAULT_NUDGE_CAP;
+  const ttlMs = options.ttlMs ?? DELIVERED_NUDGE_TTL_MS;
+  writeJsonFile(resolveInitNudgesPath(cwd), pruneNudgeState(state, now(), cap, ttlMs));
+}
+function recordDriftRecords(cwd, records, options = {}) {
+  if (records.length === 0) return;
+  const state = readNudgeState(cwd);
+  for (const record of records) {
+    state.drift[record.key] = record;
+  }
+  writeNudgeState(cwd, state, options);
+}
+function readDriftRecord(cwd, key) {
+  const state = readNudgeState(cwd);
+  const record = state.drift[key];
+  return record ? { record, delivered: isDelivered(record, state.deliveries) } : void 0;
+}
+function forgetDriftRecord(cwd, key) {
+  const state = readNudgeState(cwd);
+  if (!state.drift[key]) return;
+  delete state.drift[key];
+  delete state.deliveries[key];
+  writeNudgeState(cwd, state, {});
+}
+function listPendingDrift(cwd, options = {}) {
+  const now = options.now ?? Date.now;
+  const nowMs = now();
+  const state = readNudgeState(cwd);
+  return Object.values(state.drift).filter((record) => !isDelivered(record, state.deliveries)).sort((a, b) => a.detectedAtMs - b.detectedAtMs).map((record) => ({ ...record, ageMs: Math.max(0, nowMs - record.detectedAtMs) }));
+}
+function recordDelivery(cwd, keys, options = {}) {
+  if (keys.length === 0) return;
+  const now = options.now ?? Date.now;
+  const nowMs = now();
+  const state = readNudgeState(cwd);
+  let changed = false;
+  for (const key of keys) {
+    const record = state.drift[key];
+    if (record === void 0) continue;
+    state.deliveries[key] = {
+      key,
+      deliveredAtMs: nowMs,
+      driftDetectedAtMs: record.detectedAtMs
+    };
+    changed = true;
+  }
+  if (changed) writeNudgeState(cwd, state, options);
+}
+
+// src/core/context/render-stack-block.ts
+var STACK_BLOCK_MARKERS = {
+  begin: "<!-- build-context-stack:begin -->",
+  end: "<!-- build-context-stack:end -->"
+};
+var IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9.+-]*$/i;
+var MAX_IDENTIFIER_LENGTH = 64;
+function isSafeStackIdentifier(value) {
+  return value.length > 0 && value.length <= MAX_IDENTIFIER_LENGTH && IDENTIFIER_PATTERN.test(value);
+}
+function renderStackContextBlock(input) {
+  const lines = ["## Detected stack (managed by Build)", ""];
+  const languages = input.languages.filter(isSafeStackIdentifier);
+  const frameworks = input.frameworks.filter(isSafeStackIdentifier);
+  const tools = (input.tools ?? []).filter(isSafeStackIdentifier);
+  const domains = (input.domains ?? []).filter(isSafeStackIdentifier);
+  const sdkTargets = (input.sdkTargets ?? []).filter(isSafeStackIdentifier);
+  const dimensions = [
+    ["Languages", languages],
+    ["Frameworks", frameworks],
+    ["Tools", tools],
+    ["Domains", domains],
+    ["SDK targets", sdkTargets]
+  ];
+  const present = dimensions.filter(([, values]) => values.length > 0);
+  if (present.length === 0) {
+    lines.push("No stack dimensions detected.");
+  } else {
+    for (const [label, values] of present) {
+      lines.push(`${label}: ${values.join(", ")}`);
+    }
+  }
+  const stackKnown = languages.some((language) => !isPlaceholderLanguage(language)) || frameworks.length + tools.length + domains.length + sdkTargets.length > 0;
+  if (!stackKnown) lines.push(DECLARE_STACK_BLOCK_HINT);
+  lines.push(
+    "",
+    "Do not edit inside this block \u2014 it is regenerated by `build init`. Full detail lives in .build-project/context/stack.md."
+  );
+  return lines.join("\n");
+}
+
+// src/core/knowledge/sdk-pair.ts
+function renderAcknowledgedSdkPair(pair) {
+  if (!isSafeStackIdentifier(pair.platform) || !isSafeStackIdentifier(pair.sdkVersion) || !isSafeStackIdentifier(pair.deploymentVersion)) {
+    return "";
+  }
+  return `${pair.platform} ${pair.sdkVersion} SDK targeting ${pair.platform} ${pair.deploymentVersion} deployment`;
+}
+
+// src/core/context/stack.ts
+import path6 from "path";
+
+// src/core/context/render-stack-md.ts
+var STACK_MD_GENERATED_HEADER = "<!-- Generated by build init. Do not edit; re-run build init to regenerate. -->";
+function renderStackMarkdown(input) {
+  const lines = [
+    STACK_MD_GENERATED_HEADER,
+    "",
+    "# Stack",
+    "",
+    `Fingerprint: ${input.fingerprint}`,
+    "",
+    "## Languages",
+    ""
+  ];
+  if (input.languages.length === 0) {
+    lines.push("None detected.");
+  } else {
+    for (const language of [...input.languages].sort()) {
+      lines.push(`- ${language}`);
+    }
+  }
+  lines.push("", "## Frameworks", "");
+  if (input.frameworks.length === 0) {
+    lines.push("None detected.");
+  } else {
+    for (const framework of [...input.frameworks].sort()) {
+      lines.push(`- ${framework}`);
+    }
+  }
+  if (input.tools.length > 0) {
+    lines.push("", "## Tools", "");
+    for (const tool of [...input.tools].sort()) {
+      lines.push(`- ${tool}`);
+    }
+  }
+  if (input.domains.length > 0) {
+    lines.push("", "## Domains", "");
+    for (const domain of [...input.domains].sort()) {
+      lines.push(`- ${domain}`);
+    }
+  }
+  if (input.sdkTargets.length > 0) {
+    lines.push("", "## SDK targets", "");
+    for (const target of [...input.sdkTargets].sort()) {
+      lines.push(`- ${target}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/core/context/stack.ts
+var STACK_MD_FILENAME = "stack.md";
+function stackMarkdownPath(root) {
+  return path6.join(root, CONTEXT_DIR, STACK_MD_FILENAME);
+}
+function stackDimensions(detection) {
+  return {
+    languages: [...detection.languages],
+    frameworks: [...detection.frameworks],
+    tools: [...detection.tools ?? []],
+    domains: [...detection.domains ?? []],
+    sdkTargets: [...detection.sdkTargets]
+  };
+}
+function renderStackAgentsBlock(detection) {
+  return renderStackContextBlock(stackDimensions(detection));
+}
+async function writeStackContext(root, detection) {
+  const markdown = renderStackMarkdown({
+    ...stackDimensions(detection),
+    fingerprint: detection.fingerprint
+  });
+  const target = stackMarkdownPath(root);
+  await atomicWriteText(target, markdown, { trailingNewline: false });
+  return target;
+}
+
+// src/core/ci/integration/messages.ts
+var MESSAGES = {
+  pending: "CI setup remains pending because a reviewed prerequisite was unavailable.",
+  unchosen: "CI has not been reviewed with Build for this repository.",
+  existing: "GitHub workflows are present; their CI coverage and required checks have not been reviewed with Build.",
+  intent: "Build could not read the saved CI choice.",
+  repository: "The CI repository is ambiguous or no longer matches the saved choice.",
+  hook: "The selected local CI hook is missing or is not executable in this checkout.",
+  workflow: "A selected GitHub CI workflow is missing or cannot cover every pull request."
+};
+function ciAdvisoryMessage(code) {
+  if (!Object.hasOwn(MESSAGES, code)) return "Info: Run build ci status to inspect CI.";
+  return `Info: ${MESSAGES[code]} Run build init to review local or GitHub CI and preview any changes; build ci status inspects the current setup.`;
+}
+
+export {
+  SERVICE_DOC_DOMAINS,
+  serviceSignalForToken,
+  CANDIDATE_ITEM_ID_PREFIX,
+  CANDIDATE_SEARCH_PRIORITY,
+  MAX_UNRESOLVED_LINES,
+  candidateSetSignature,
+  QUERY_SAFE_EVIDENCE_CLASSES,
+  isQuerySafeHostname,
+  isCandidateQuerySafe,
+  detectStack,
+  DECLARE_STACK_EXAMPLE_SPEC,
+  DECLARE_STACK_COMMAND,
+  STACK_BLOCK_MARKERS,
+  isSafeStackIdentifier,
+  renderAcknowledgedSdkPair,
+  stackIntentPath,
+  legacyDeclaredStackPath,
+  parseIntentSpec,
+  createIntentContract,
+  readIntentContract,
+  writeIntentContract,
+  removeIntentContract,
+  migrateLegacyDeclaration,
+  resolveIntent,
+  retireContract,
+  acknowledgeConflicts,
+  acceptDetectedReality,
+  describeDimension,
+  emptyStackDetection,
+  resolvedStackDetection,
+  isStackUndetectedAndUndeclared,
+  renderStackAgentsBlock,
+  writeStackContext,
+  computeStackFingerprint2 as computeStackFingerprint,
+  fingerprintDigest,
+  isStackDriftKind,
+  readStoredFingerprint,
+  writeStoredFingerprint,
+  recordDriftRecords,
+  readDriftRecord,
+  forgetDriftRecord,
+  listPendingDrift,
+  recordDelivery,
+  ciAdvisoryMessage
+};
+//# sourceMappingURL=chunk-VYI4DSZP.js.map