@jstn-sdk/ma 0.1.13 → 0.14.1

package/docs/qa/{release-readiness-0.1.13.md → release-readiness-0.14.1.md}

@@ -1,26 +1,26 @@
-# Release Readiness 0.1.13
+# Release Readiness 0.14.1
 
 ## Production bar
 
-`v0.1.13` is treated as production only when:
+`v0.14.1` is treated as production only when:
 - the package installs cleanly from the canonical public install command
 - the Codex-hosted runtime path works end to end
 - the helper flow remains valid for scripted verification
 - the singular `$maestro` umbrella and helper-skill contract stay coherent
-- release docs, package metadata, and workflows all agree on `0.1.13`
+- release docs, package metadata, and workflows all agree on `0.14.1`
 
 Target release state:
-- npm package: `@jstn-sdk/ma@0.1.13`
+- npm package: `@jstn-sdk/ma@0.14.1`
 - npm registry state: pending publish
-- publishability note: `0.1.12` is already published, so `0.1.13` is the next publishable package line
-- git tag: `v0.1.13`
-- GitHub release: pending publish for `v0.1.13`
+- publishability note: `0.14.0` is already published, so `0.14.1` is the next publishable package line
+- git tag: `v0.14.1`
+- GitHub release: pending publish for `v0.14.1`
 
 ## Production checklist
 
 - skills-first product identity: PASS
 - package/plugin identity aligned to `@jstn-sdk/ma`: PASS
-- version/tag alignment `0.1.13` / `v0.1.13`: PASS
+- version/tag alignment `0.14.1` / `v0.14.1`: PASS
 - install/uninstall docs aligned: PASS
 - onboarding is concise and sequential: PASS
 - helper command documented as secondary: PASS
@@ -36,7 +36,7 @@ Target release state:
 - workflow/release/provenance docs aligned: PASS
 - no stale package names remain in tracked repo surfaces: PASS
 - no conflicting CLI-first product story remains in tracked product docs: PASS
-- issue proof gates for `v0.1.13`: PASS; `release-issue-gates-0.1.13.json` marks issues `#13-#29` passed with implementation, verification, and production evidence, so release verification can enforce the gate artifact instead of blocking on pending issue states
+- issue proof gates for `v0.14.1`: PASS; `release-issue-gates-0.14.1.json` marks issues `#13-#29` passed with implementation, verification, and production evidence, so release verification can enforce the gate artifact instead of blocking on pending issue states
 
 ## Automated checks run
 
@@ -71,10 +71,10 @@ That should prove:
 Issue gate artifact:
 
 ```text
-docs/qa/release-issue-gates-0.1.13.json
+docs/qa/release-issue-gates-0.14.1.json
 ```
 
-Every open issue assigned to `v0.1.13` must remain in this file until it is production-passed. A passed issue requires:
+Every open issue assigned to `v0.14.1` must remain in this file until it is production-passed. A passed issue requires:
 - implementation evidence
 - verification evidence
 - production evidence
@@ -93,7 +93,7 @@ Helper-path validation:
 
 ```bash
 ma setup
-ma idea "Harden Meta-Architect v0.1.13 semantic core with Obsidian vault context, Ralph execution proof, context economy, and package-gated release evidence"
+ma idea "Harden Meta-Architect v0.14.1 semantic core with Obsidian vault context, Ralph execution proof, context economy, and package-gated release evidence"
 ma run '$arch'
 ma run '$sage'
 ma run '$flow'

package/docs/quality.md

@@ -0,0 +1,24 @@
+# AI quality enforcement
+
+Meta-Architect exposes `AIQualityOrchestrator` as a blocking policy boundary for generated code. It records bounded violation and KPI receipts under `.ma/quality/` and exposes them through the local MCP quality resources.
+
+The default checks are deterministic source checks plus the installed Semgrep CLI. The orchestrator has no external provider or model configuration; security and architecture checks are local, deterministic, and fail closed when Semgrep is unavailable.
+
+Every accepted generation must include approved test evidence. `testDrivenGeneration()` requires test generation, approval, code generation, execution, and at least 80% coverage before returning code.
+
+## Usage
+
+```js
+import { AIQualityOrchestrator } from "@jstn-sdk/ma";
+
+const quality = new AIQualityOrchestrator({ projectRoot: process.cwd() });
+const result = await quality.validate(code, {
+  filePath: "src/example.ts",
+  hasTests: true,
+  testCoverage: 0.9,
+});
+
+if (!result.passed) throw new Error(result.reviewReason);
+```
+
+The tracked Semgrep baseline is `templates/quality/ai-quality-rules.yml`; a project may provide a stricter `.ma/semgrep/ai-quality-rules.yml`.

package/docs/release-spec.md

@@ -1,17 +1,17 @@
-# v0.1.13 Requirements & Rules
+# v0.14.1 Requirements & Rules
 
 ## Production definition
 
-Meta-Architect `v0.1.13` is production only when:
+Meta-Architect `v0.14.1` is production only when:
 1. the package/install surface works
 2. the in-session skill workflow from `$arch` through `$build` works
 3. the release evidence matches the actual package and git tag
 
-## What `v0.1.13` must have
+## What `v0.14.1` must have
 
 ### 1. Canonical package/runtime path
 
-- recommended POSIX one-line install: `curl -fsSL https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@main/scripts/install.sh | sh`
+- recommended POSIX install: download the latest installer and checksum through jsDelivr, verify the downloaded installer with `sha256sum -c`, then run `sh install.sh`
 - install: `npm i -g @openai/codex@latest @jstn-sdk/ma@latest`
 - optional helper launch: `ma --madmax --high`
 - uninstall Meta-Architect only: `npm uninstall -g @jstn-sdk/ma`
@@ -34,6 +34,10 @@ Helper commands remain available for setup and scripted validation:
 - `ma merge`
 - `ma release`
 
+`ma merge` and `ma release` are approval-only by default. `--dry-run` performs
+preflight without changing release state; `--execute` is the only mode that
+runs the displayed `git merge --no-ff --no-edit -- <source>` command.
+
 ### 3. State and gate contract
 
 Canonical runtime namespace:
@@ -50,16 +54,16 @@ Canonical state files:
 
 ### 4. Required release evidence
 
-- `package.json` version `0.1.13`
-- git tag `v0.1.13`
+- `package.json` version `0.14.1`
+- git tag `v0.14.1`
 - `RELEASE.md`
 - `CHANGELOG.md`
-- `docs/qa/release-readiness-0.1.13.md`
-- `docs/qa/release-issue-gates-0.1.13.json`
+- `docs/qa/release-readiness-0.14.1.md`
+- `docs/qa/release-issue-gates-0.14.1.json`
 - green `npm run release:check`
-- GitHub release asset `meta-architect_0.1.13_all.deb`
-- GitHub release asset `meta-architect-0.1.13-1-any.pkg.tar.xz`
-- GitHub release asset `meta-architect-0.1.13-1.noarch.rpm`
+- GitHub release asset `meta-architect_0.14.1_all.deb`
+- GitHub release asset `meta-architect-0.14.1-1-any.pkg.tar.xz`
+- GitHub release asset `meta-architect-0.14.1-1.noarch.rpm`
 - green `npm run linux:packages:build`
 - green `npm run linux:packages:smoke`
 - green `npm run release:assets`
@@ -83,7 +87,9 @@ Canonical state files:
 7. Build and smoke-check the Linux native packages on Linux:
    - `npm run linux:packages:build`
    - `npm run linux:packages:smoke`
-   - `npm run release:assets`
+- `npm run release:assets`
+- `npm run release:assets:generate` creates `dist/SHA256SUMS`, `dist/sbom.spdx.json`, and `dist/release-summary.json`; `release:assets` verifies them.
+- `dist/` is CI-generated and ignored by Git. GitHub Releases are the source of truth for downloadable packages; historical binaries are not retained in the repository.
 8. Create and push tag `v<version>`
 9. Preferred publish path: publish from `.github/workflows/npm-publish.yml` on a supported cloud runner so provenance can be generated
 10. Local shell fallback when not publishing from GitHub Actions or GitLab CI/CD:
@@ -101,11 +107,11 @@ Canonical state files:
 
 ### 6.2 Issue proof gates
 
-Every open next-release issue must be represented in `docs/qa/release-issue-gates-0.1.13.json`.
+Every open next-release issue must be represented in `docs/qa/release-issue-gates-0.14.1.json`.
 
 Production pass rule:
 - issue status must be `passed`
-- issue milestone must match `v0.1.13`
+- issue milestone must match `v0.14.1`
 - implementation evidence must be present
 - verification evidence must be present
 - production evidence must be present
@@ -118,3 +124,10 @@ Production pass rule:
 - `npm publish --provenance` is valid only from a supported cloud CI/CD provider
 - local shell publishes are expected to fail with `Automatic provenance generation not supported for provider: null`
 - use the repository publish workflow when provenance is part of the release bar
+## Package diagnostics
+
+`npm run package:doctor` (or `npm run release:doctor`) checks maintainer-facing
+release and package artifacts. It is distinct from `ma doctor`, which checks
+installed/user environment health.
+It is intentionally separate from `ma doctor`, which checks the installed
+environment, runtime state, MCP readiness, and support bundle health.

package/docs/skills.md

@@ -16,7 +16,7 @@ Recommended CLI install for macOS, Linux, WSL, and Git-Bash:
 
 ```bash
 # One-line install (POSIX shells only; use WSL/Git-Bash on Windows)
-curl -fsSL https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@main/scripts/install.sh | sh
+curl -fsSLo install.sh https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@latest/scripts/install.sh && curl -fsSLo install.sh.sha256 https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@latest/scripts/install.sh.sha256 && sed 's#scripts/install.sh#install.sh#' install.sh.sha256 | sha256sum -c - && sh install.sh
 ```
 
 ```bash

package/docs/vendor-plugin-publishing.md

@@ -0,0 +1,49 @@
+# Vendor Plugin Publishing
+
+The existing `plugins/meta-architect` directory is the only hand-authored plugin source. Build vendor outputs from it:
+
+```bash
+npm run plugin:build -- --targets all --output ./dist/vendor-plugins
+```
+
+Publishing is explicit and one host at a time. It is a dry run unless `--execute` is supplied:
+
+```bash
+npm run plugin:publish -- --target pi
+```
+
+Pi consumes the existing `@jstn-sdk/ma` package; no second npm package is created. Claude Code, Cursor, Antigravity, Gemini CLI, OpenCode, Cline, Continue, Goose, and OpenClaw use host-specific Git, marketplace, extension, or workspace distribution flows; `plugin:publish` prepares those native inputs and does not pretend a local npm command publishes them.
+
+The builder produces one directory per host. It copies the existing lane skills and adds only the host manifest, rules, context file, or package metadata required by that host. It never creates a second workflow or changes the canonical skills.
+
+ChatGPT is not included as a generated local plugin target. ChatGPT
+publication requires a deployed HTTPS MCP backend, authentication, privacy
+materials, and OpenAI review. See [ChatGPT Integration](./chatgpt-integration.md)
+for the exact readiness contract.
+
+## Outputs
+
+| Target | Output | Mode |
+| --- | --- | --- |
+| `codex` | `.codex-plugin/`, `skills/`, app and MCP metadata | native |
+| `claude-code` | Claude marketplace plus plugin source | native |
+| `cursor` | Cursor marketplace plus plugin source and rules | native |
+| `antigravity` | `plugin.json`, `skills/`, `rules/` | native |
+| `gemini-cli` | `gemini-extension.json`, `GEMINI.md`, `skills/` | native |
+| `opencode` | `.opencode/skills/`, `AGENTS.md` | native |
+| `pi` | `@jstn-sdk/ma` package with `pi.skills` metadata | native |
+| `cline` | `.clinerules`, `.cline/skills/` | native |
+| `openclaw` | workspace `skills/` and `AGENTS.md` | portable |
+| `continue` | `.continue/rules/` and portable skills | portable |
+| `goose` | workspace `skills/` and `AGENTS.md` | portable |
+
+Portable means the generated bundle is usable as project context and skills, but this repository does not invent a host runtime plugin or claim marketplace publication. A host-specific publisher still requires the host account, repository, or review process.
+
+## Verification
+
+```bash
+npm test -- test/plugin-build.test.js
+npm run plugin:verify
+```
+
+Inspect `BUILD-MANIFEST.json` in each output before publishing. It records the generated version, source, support mode, and the host-specific install/publish action.

package/index.js

@@ -1,8 +1,28 @@
+export { qualityResources, queryQualityStatus, readQualityResource } from "./mcp/local/quality.js";
+export {
+  agentRegistry as agentSurfaceRegistry,
+  detectInstalled,
+  getAgent,
+  getAgentInvocation,
+  getNonUniversalAgents,
+  isUniversalAgent as isUniversalAgentSurface,
+  listAgents,
+  resolveAgentCommand,
+} from "./src/agents.js";
 export {
   evaluateBuildGate,
   formatBuildBlockers,
   formatNextAllowedTriggers,
 } from "./src/build-gate.js";
+export {
+  CodexAppServerClient,
+  CodexRpcError,
+  createStdioTransport,
+  generateCodexBindings,
+  parseCodexJsonl,
+  runCodexExec,
+  validateStructuredResult,
+} from "./src/codex-app-server.js";
 export {
   appendDecision,
   loadDecisionLog,
@@ -22,6 +42,11 @@ export {
   validateMergeTarget,
   validateReleaseOrigin,
 } from "./src/policy.js";
+export {
+  AIQualityOrchestrator,
+  calculateQualityScore,
+  staticViolations,
+} from "./src/quality/ai-quality-orchestrator.js";
 export { loadReleaseState, saveReleaseState, validateReleaseState } from "./src/release-state.js";
 export {
   classifyAutonomyBranch,
@@ -30,6 +55,14 @@ export {
   loadActiveAutonomyCore,
   validateActiveAutonomyCore,
 } from "./src/runtime/active-autonomy-core.js";
+export {
+  agentCompatPackage,
+  agentCompatVersion,
+  compileAgentIntegrations,
+  detectAgentEnvironments,
+  listAgentCompatAdapters,
+  validateAgentIntegrations,
+} from "./src/runtime/agent-compat.js";
 export {
   createAlignmentRecoveryPlan,
   createDefaultAlignmentSentinelReport,
@@ -37,6 +70,20 @@ export {
   loadAlignmentSentinelReportOrDefault,
   saveAlignmentSentinelReport,
 } from "./src/runtime/alignment-sentinel.js";
+export {
+  autonomousTaskSchemaVersion,
+  cancelAutonomousTask,
+  createTaskQueue,
+  enqueueAutonomousTasks,
+  getAutonomousTaskQueuePath,
+  loadTaskQueue,
+  parseTaskInput,
+  runAutonomousTasks,
+  saveTaskQueue,
+  seedAutonomousTaskArtifacts,
+  summarizeTasks,
+  validateTaskQueue,
+} from "./src/runtime/autonomous-tasks.js";
 export {
   createCodeGraphTouchpoint,
   createCodeGraphTouchpointFromFile,
@@ -55,6 +102,15 @@ export {
   shouldBypassContextEconomy,
   validateContextEconomyCore,
 } from "./src/runtime/context-economy-core.js";
+export {
+  continuityGraphSchemaVersion,
+  createDefaultContinuityGraph,
+  getContinuityGraphPath,
+  loadContinuityGraph,
+  mergeContinuityGraph,
+  queryContinuityGraph,
+  validateContinuityGraph,
+} from "./src/runtime/continuity-graph.js";
 export {
   coreSourceDefinitions,
   createDefaultCoreSourceIngest,
@@ -99,6 +155,7 @@ export {
   loadLearningLoopCore,
   validateLearningLoopCore,
 } from "./src/runtime/learning-loop-core.js";
+export { verifyLiveAgentMatrix } from "./src/runtime/live-agent-verification.js";
 export {
   validateRuntimeMcpPolicy,
   validateRuntimeMcpPolicyFile,
@@ -147,6 +204,14 @@ export {
   renameObsidianFileSafely,
   writeObsidianAttachment,
 } from "./src/runtime/obsidian-plugin-bridge.js";
+export {
+  assertPiMaestroToolAllowed,
+  createPiMaestroCapabilityMapping,
+  createPiMaestroToolSurface,
+  isPiMaestroEnabled,
+  maestroGateLanes,
+  runPiMaestroExperimental,
+} from "./src/runtime/pi-maestro-core.js";
 export {
   createDefaultPromptStrategyCore,
   loadPromptStrategyCore,
@@ -246,3 +311,11 @@ export {
   runVibe,
 } from "./src/skills.js";
 export { loadCombinedState, syncStatusUpdates } from "./src/state-sync.js";
+export {
+  measureWidth,
+  padCell,
+  renderGrid,
+  renderRow,
+  renderSeparatorLine,
+} from "./src/tui/grid.js";
+export { renderCheckGrid, renderReleaseGrid } from "./src/tui/status-grid.js";

package/mcp/local/code-intel.js

@@ -1,39 +1,187 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
 import { getRepoRoot } from "../../src/paths.js";
+import { safeExecFile } from "../../src/process-utils.js";
 
-const ignoredDirs = new Set([".git", ".ma", ".omx", "node_modules"]);
+const execFileAsync = promisify(safeExecFile);
+const MAX_SCAN_BYTES = 1024 * 1024;
+const ignoredDirs = new Set([
+  ".git",
+  ".ma",
+  ".omx",
+  ".next",
+  ".turbo",
+  ".vercel",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
+const artifactExtensions = new Set([
+  ".7z",
+  ".bin",
+  ".bmp",
+  ".class",
+  ".dll",
+  ".dylib",
+  ".gif",
+  ".gz",
+  ".ico",
+  ".jar",
+  ".jpeg",
+  ".jpg",
+  ".lockb",
+  ".mp3",
+  ".mp4",
+  ".o",
+  ".pdf",
+  ".png",
+  ".so",
+  ".svg",
+  ".tar",
+  ".tgz",
+  ".wasm",
+  ".webp",
+  ".woff",
+  ".woff2",
+  ".zip",
+  ".zst",
+]);
+const ignoredFiles = new Set([".active"]);
 const codeIntelTools = [
   "code_intel.list_files",
   "code_intel.search_text",
   "code_intel.read_excerpt",
 ];
 
-async function walk(rootDir, currentDir = rootDir, files = [], limit = Number.POSITIVE_INFINITY) {
-  if (files.length >= limit) {
-    return files;
+function normalizeRelative(relativePath) {
+  const normalized = path.posix.normalize(relativePath.replaceAll(path.sep, "/"));
+  if (
+    normalized === "." ||
+    normalized === ".." ||
+    normalized.startsWith("../") ||
+    normalized.includes("\0")
+  ) {
+    throw new Error("code_intel path must stay inside the repository");
   }
+  return normalized;
+}
 
-  const entries = await fs.readdir(currentDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (files.length >= limit) {
-      break;
-    }
+function isArtifactPath(relativePath) {
+  const segments = relativePath.split("/");
+  return (
+    ignoredFiles.has(segments.at(-1)) ||
+    segments.some((segment) => ignoredDirs.has(segment)) ||
+    artifactExtensions.has(path.extname(relativePath).toLowerCase())
+  );
+}
+
+async function isReadableTextFile(absolutePath) {
+  const stat = await fs.lstat(absolutePath);
+  if (stat.isSymbolicLink()) return false;
+  if (!stat.isFile() || stat.size > MAX_SCAN_BYTES) return false;
+  const sample = await fs.readFile(absolutePath, { encoding: null, flag: "r" });
+  return !sample.subarray(0, Math.min(sample.length, 8192)).includes(0);
+}
+
+async function assertSafeRepoPath(rootDir, relativePath) {
+  let current = rootDir;
+  for (const component of relativePath.split("/")) {
+    current = path.join(current, component);
+    const stat = await fs.lstat(current).catch((error) => {
+      if (error?.code === "ENOENT") return null;
+      throw error;
+    });
+    if (stat?.isSymbolicLink()) throw new Error("code_intel cannot follow symlinks");
+  }
+  return path.join(rootDir, relativePath);
+}
+
+async function listGitFiles(rootDir) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
+      {
+        cwd: rootDir,
+        encoding: "buffer",
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 10_000,
+        shell: false,
+      },
+    );
+    return stdout
+      .toString("utf8")
+      .split("\0")
+      .filter(Boolean)
+      .map((file) => file.replaceAll("\\", "/"));
+  } catch {
+    return null;
+  }
+}
+
+async function loadFallbackIgnorePatterns(rootDir) {
+  const content = await fs.readFile(path.join(rootDir, ".gitignore"), "utf8").catch(() => "");
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
+}
+
+function isFallbackIgnored(relativePath, patterns) {
+  const normalized = relativePath.split(path.sep).join("/");
+  return patterns.some((pattern) => {
+    const directoryPattern = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+    const escaped = directoryPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const expression = escaped
+      .replaceAll("**", ".*")
+      .replaceAll("*", "[^/]*")
+      .replaceAll("?", "[^/]");
+    const matcher = new RegExp(`(?:^|/)${expression}(?:/|$)`);
+    return (
+      matcher.test(normalized) ||
+      (!pattern.includes("/") && new RegExp(`(^|/)${expression}$`).test(normalized))
+    );
+  });
+}
 
+async function walkFallback(rootDir, currentDir = rootDir, files = [], limit = 200, patterns = []) {
+  if (files.length >= limit) return files;
+  const entries = await fs.readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (files.length >= limit) break;
+    const absolutePath = path.join(currentDir, entry.name);
+    const relativePath = path.relative(rootDir, absolutePath);
+    if (isFallbackIgnored(relativePath, patterns)) continue;
     if (entry.isDirectory()) {
-      if (ignoredDirs.has(entry.name)) {
-        continue;
+      if (!ignoredDirs.has(entry.name)) {
+        await walkFallback(rootDir, absolutePath, files, limit, patterns);
       }
-      await walk(rootDir, path.join(currentDir, entry.name), files, limit);
-      continue;
+    } else if (entry.isFile() && !isArtifactPath(relativePath)) {
+      files.push(relativePath.split(path.sep).join("/"));
     }
+  }
+  return files;
+}
 
-    if (!entry.isFile()) {
-      continue;
+async function listSafeFiles(rootDir, limit = 200) {
+  const gitFiles = await listGitFiles(rootDir);
+  const candidates =
+    gitFiles ??
+    (await walkFallback(rootDir, rootDir, [], limit, await loadFallbackIgnorePatterns(rootDir)));
+  const files = [];
+  for (const relativePath of candidates) {
+    if (files.length >= limit) break;
+    const normalized = normalizeRelative(relativePath);
+    if (isArtifactPath(normalized)) continue;
+    try {
+      const absolute = await assertSafeRepoPath(rootDir, normalized);
+      if (await isReadableTextFile(absolute)) files.push(normalized);
+    } catch {
+      // Ignore files that disappear or cannot be inspected.
     }
-    files.push(path.relative(rootDir, path.join(currentDir, entry.name)));
   }
-
   return files;
 }
 
@@ -42,52 +190,49 @@ export function listCodeIntelTools() {
 }
 
 export async function listRepoFiles(limit = 200) {
-  const repoRoot = getRepoRoot();
-  return walk(repoRoot, repoRoot, [], limit);
+  return listSafeFiles(getRepoRoot(), Math.max(1, Math.min(Number(limit) || 200, 2000)));
 }
 
 export async function searchRepoText(query, limit = 20) {
   const repoRoot = getRepoRoot();
   const files = await listRepoFiles(500);
   const matches = [];
-
+  const boundedLimit = Math.max(1, Math.min(Number(limit) || 20, 100));
   for (const relativePath of files) {
-    if (matches.length >= limit) {
-      break;
-    }
-
+    if (matches.length >= boundedLimit) break;
     try {
       const content = await fs.readFile(path.join(repoRoot, relativePath), "utf8");
-      const lines = content.split("\n");
-      lines.forEach((line, index) => {
-        if (matches.length < limit && line.includes(query)) {
+      content.split("\n").forEach((line, index) => {
+        if (matches.length < boundedLimit && line.includes(query)) {
           matches.push({ file: relativePath, line: index + 1, text: line.trim() });
         }
       });
     } catch {
-      // Skip non-text files.
+      // Skip files that disappear or fail the text boundary.
     }
   }
-
   return matches;
 }
 
 export async function readRepoExcerpt(relativePath, line = 1, context = 2) {
   const repoRoot = getRepoRoot();
-  const content = await fs.readFile(path.join(repoRoot, relativePath), "utf8");
+  const normalized = normalizeRelative(relativePath);
+  if (isArtifactPath(normalized))
+    throw new Error("code_intel cannot read generated or binary artifacts");
+  const absolutePath = await assertSafeRepoPath(repoRoot, normalized);
+  if (!(await isReadableTextFile(absolutePath)))
+    throw new Error("code_intel can only read bounded text files");
+  const content = await fs.readFile(absolutePath, "utf8");
+  const safeLine = Math.max(1, Number(line) || 1);
+  const safeContext = Math.max(0, Math.min(Number(context) || 2, 20));
   const lines = content.split("\n");
-  const start = Math.max(0, line - context - 1);
-  const end = Math.min(lines.length, line + context);
-  return lines.slice(start, end).map((text, index) => ({
-    line: start + index + 1,
-    text,
-  }));
+  const start = Math.max(0, safeLine - safeContext - 1);
+  const end = Math.min(lines.length, safeLine + safeContext);
+  return lines.slice(start, end).map((text, index) => ({ line: start + index + 1, text }));
 }
 
 export async function callCodeIntelTool(name, args = {}) {
-  if (name === "code_intel.list_files") {
-    return listRepoFiles(args.limit);
-  }
+  if (name === "code_intel.list_files") return listRepoFiles(args.limit);
   if (name === "code_intel.search_text") {
     if (typeof args.query !== "string" || args.query.trim() === "") {
       throw new Error("code_intel.search_text requires a non-empty query");
@@ -100,7 +245,6 @@ export async function callCodeIntelTool(name, args = {}) {
     }
     return readRepoExcerpt(args.file, args.line, args.context);
   }
-
   throw new Error(`Unknown code_intel tool: ${name}`);
 }
 
@@ -108,6 +252,6 @@ export async function checkCodeIntelCapability() {
   const files = await listRepoFiles(10);
   return {
     ready: files.length > 0,
-    detail: `code intel indexed ${files.length} repo file(s) in the readiness sample`,
+    detail: `code intel indexed ${files.length} bounded text file(s) with Git-ignore and artifact filtering`,
   };
 }