@ionivetech/mugiwara 0.6.6 → 0.7.0

package/scripts/check-doc-links.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+// scripts/check-doc-links.ts — every relative .md link in README, ROADMAP,
+// docs/, and examples/ must resolve to a file. Born from a shipped defect:
+// glossary linked provenance.md from reference/ and four broken links passed
+// every other gate, because verify-install covers content/ pointers only.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const root = join(import.meta.dirname, "..");
+function walk(d: string, out: string[] = []): string[] {
+  for (const e of readdirSync(d, { withFileTypes: true })) {
+    const p = join(d, e.name);
+    if (e.isDirectory()) walk(p, out);
+    else if (/\.md$/.test(e.name)) out.push(p);
+  }
+  return out;
+}
+const files: string[] = [];
+for (const r of ["docs", "examples"]) files.push(...walk(join(root, r)));
+for (const r of ["README.md", "ROADMAP.md"]) files.push(resolve(root, r));
+
+let bad = 0;
+for (const f of files) {
+  const body = readFileSync(f, "utf8");
+  for (const m of body.matchAll(/\]\(([^)\s]+)\)/g)) {
+    const t = m[1];
+    if (/^(https?:|mailto:|#|\/\/)/.test(t)) continue;
+    const clean = t.split("#")[0];
+    if (!clean.endsWith(".md")) continue;
+    if (!existsSync(resolve(f, "..", clean))) {
+      bad++;
+      console.log(`✗ ${f.replace(root + "/", "")} → ${t}`);
+    }
+  }
+}
+if (bad) {
+  console.log(`check-doc-links: ${bad} broken link(s)`);
+  process.exit(1);
+}
+console.log("check-doc-links: all relative .md links resolve");

package/scripts/conformance.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 // scripts/conformance.ts — C1: cross-platform conformance suite.
 // Every installable target: materialize the standard-feature fixture repo,
-// install the target, run the four core scripts, and compare a normalized
-// snapshot (state fields, report sections, evidence header, gitignore block,
-// file count) against test/golden/<target>.json. Exit 1 on any difference
+// install the target, run the core scripts, and compare a normalized
+// snapshot (state fields, gitignore block, file count) against
+// test/golden/<target>.json. Exit 1 on any difference
 // with a diff; --update-golden regenerates. The snapshots are normalized:
 // timestamps, hashes, and random filenames are excluded so a golden is stable
 // across runs.
@@ -114,19 +114,13 @@ function snapshot(targetId: string): Record<string, unknown> {
       writeFileSync(exclude, (existsSync(exclude) ? readFileSync(exclude, 'utf8') : '') + '\n' + untracked.join('\n') + '\n');
     }
 
-    // 3. run the four core scripts + the gitignore write the CLI does post-install
+    // 3. run the core scripts + the gitignore write the CLI does post-install
     sh(`bash "${root}/scripts/lane.sh" main --json`, dir);
     sh(`bash "${root}/scripts/savepoint.sh" ${MISSION} "" 1 auto`, dir);
-    sh(`bash "${root}/scripts/evidence.sh" ${MISSION} lint -- printf 'ok\\n'`, dir);
-    sh(`bash "${root}/scripts/mission-report.sh" ${MISSION}`, dir);
     ensureProjectGitignore(dir, { dryRun: false });
 
     // 4. normalize + collect
-    const state = JSON.parse(readFileSync(join(dir, '.mugiwara', 'state', MISSION, 'state.json'), 'utf8'));
-    const reportFile = readdirSync(join(dir, '.mugiwara', 'reports')).find(f => f.endsWith(`-${MISSION}.md`));
-    const report = reportFile ? readFileSync(join(dir, '.mugiwara', 'reports', reportFile), 'utf8') : '';
-    const evFile = readdirSync(join(dir, '.mugiwara', 'results', MISSION)).find(f => f.includes('lint-'));
-    const ev = evFile ? readFileSync(join(dir, '.mugiwara', 'results', MISSION, evFile), 'utf8') : '';
+    const state = JSON.parse(readFileSync(join(dir, '.mugiwara', 'missions', MISSION, 'state.json'), 'utf8'));
     const gitignore = existsSync(join(dir, '.gitignore')) ? readFileSync(join(dir, '.gitignore'), 'utf8') : '';
 
     const countFiles = (p: string): number => {
@@ -161,11 +155,7 @@ function snapshot(targetId: string): Record<string, unknown> {
         budget_status: state.budget_status,
         sensitive_paths: state.sensitive_paths,
       },
-      report_sections: [...report.matchAll(/^#{2,3} .*$/gm)].map(m => m[0]),
-      evidence: {
-        header: ev.split('\n').filter(l => l.startsWith('# ') && !l.startsWith('# At:') && !/^# (Exit|Verdict):/.test(l)),
-        trailer: ev.split('\n').filter(l => /^# (Exit|Verdict):/.test(l)),
-      },
+      report_sections: [],
       gitignore_block: gitignore.split('\n').filter(l => l.includes('mugiwara') || l.includes('# ---')),
       file_count: {
         skills: countFiles(target.paths({ scope: 'project', projectDir: dir, home: '' }).skillsDir),

package/scripts/coverage-gate.ts

@@ -75,10 +75,10 @@ const baseArg = process.argv.indexOf('--base');
 let base = baseArg !== -1 ? process.argv[baseArg + 1] : process.env.MUGIWARA_COVERAGE_BASE;
 if (!base) {
   // the mission's own recorded base_sha is the truthful diff origin
-  const stateDir = join(root, '.mugiwara', 'state');
-  if (existsSync(stateDir)) {
-    for (const m of readdirSync(stateDir)) {
-      const f = join(stateDir, m, 'state.json');
+  const missionsDir = join(root, '.mugiwara', 'missions');
+  if (existsSync(missionsDir)) {
+    for (const m of readdirSync(missionsDir)) {
+      const f = join(missionsDir, m, 'state.json');
       if (!existsSync(f)) continue;
       const sha = JSON.parse(readFileSync(f, 'utf8')).base_sha;
       if (sha) { base = sha; break; }
@@ -140,9 +140,23 @@ for (const [k, v] of Object.entries<any>(summary)) {
 }
 
 // ---- 4. apply the two thresholds ------------------------------------------
+// Policy as code: mugiwara.policy.yml gates.coverage can RAISE a
+// threshold — the max of config and policy wins, never lower.
 
-const NEW = threshold('coverage_new', 90);
-const MOD = threshold('coverage_modified', 80);
+const { loadPolicy, effectiveThreshold } = await import('../src/policy.ts');
+let policyCoverage: { new?: number; modified?: number } | undefined;
+try {
+  const policy = loadPolicy(root);
+  policyCoverage = policy?.gates?.coverage;
+  if (policy?.gates?.require_human_approval?.length)
+    console.log(`coverage-gate: policy requires human approval on: ${policy.gates.require_human_approval.join(', ')}`);
+} catch (e) {
+  console.log(`coverage-gate: ${(e as Error).message}`);
+  process.exit(1);
+}
+
+const NEW = effectiveThreshold(threshold('coverage_new', 90), policyCoverage?.new);
+const MOD = effectiveThreshold(threshold('coverage_modified', 80), policyCoverage?.modified);
 
 const rows = changed.map((c) => {
   const isNew = c.status === 'A';

package/scripts/gate-selftest.ts

@@ -12,7 +12,7 @@ let passed = 0;
 let failed = 0;
 
 function run(name: string, cmd: string): boolean {
-  try { execSync(cmd, { cwd: root, stdio: 'pipe', timeout: 60000 }); return true; }
+  try { execSync(cmd, { cwd: root, stdio: 'pipe', timeout: 180000 }); return true; }
   catch { return false; }
 }
 
@@ -82,6 +82,28 @@ console.log('\nG5 — conditional-assertion guard');
   }
 }
 
+// --- Cost gate: prove a drifted stated index size goes red -------------------
+// validate-content fails when docs/concepts/cost.md's "**Current:** N chars"
+// disagrees with the measured skill+agent description total. Without this
+// mutation the gate is unproven — a gate that cannot fail is not a gate.
+console.log('\nCost gate — measured vs stated index chars');
+{
+  const costFile = join(root, 'docs', 'concepts', 'cost.md');
+  const original = readFileSync(costFile, 'utf8');
+  try {
+    const drifted = original.replace(/\*\*Current:\*\* \d[\d,]* chars/, '**Current:** 1 chars');
+    if (drifted === original) {
+      console.log('  ⚠  "**Current:** N chars" pattern not found in cost.md — skipping');
+    } else {
+      writeFileSync(costFile, drifted);
+      assert('drifted stated index chars → exit 1', false, () => run('COST', 'bun scripts/validate-content.ts'));
+    }
+  } finally {
+    writeFileSync(costFile, original);
+    assert('restored → exit 0', true, () => run('COST', 'bun scripts/validate-content.ts'));
+  }
+}
+
 // --- G3: savepoint fixtures — prove test fails when a field is broken ---
 console.log('\nG3 — savepoint fixtures');
 if (!existsSync(join(root, 'test', 'savepoint.test.ts'))) {
@@ -316,19 +338,19 @@ if (!existsSync(skillsDoc)) {
 
 // --- Index budget ---
 console.log('\nIndex budget');
-const usingSkillFile = join(root, 'content', 'skills', 'using-mugiwara', 'SKILL.md');
-if (!existsSync(usingSkillFile)) {
-  console.log('  ⚠  using-mugiwara not found, skipping');
+const budgetSkillFile = join(root, 'content', 'skills', 'mugiwara-workflow', 'SKILL.md');
+if (!existsSync(budgetSkillFile)) {
+  console.log('  ⚠  mugiwara-workflow not found, skipping');
 } else {
-  const original = readFileSync(usingSkillFile, 'utf8');
+  const original = readFileSync(budgetSkillFile, 'utf8');
   try {
     // Push budget way past 5500
     const longDesc = 'A'.repeat(6000);
     const broken = original.replace(/description:.*/, `description: ${longDesc}`);
-    writeFileSync(usingSkillFile, broken);
+    writeFileSync(budgetSkillFile, broken);
     assert('description past budget → exit 1', false, () => run('budget', 'bun scripts/validate-content.ts'));
   } finally {
-    writeFileSync(usingSkillFile, original);
+    writeFileSync(budgetSkillFile, original);
     assert('restored → exit 0', true, () => run('budget', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
   }
 }
@@ -481,5 +503,94 @@ if (!existsSync(countAgent)) {
   }
 }
 
+// --- CI: closure integrity gate — a secret in the trail must fail the archive ---
+console.log('\nCI — closure integrity gate');
+{
+  const tmp = mkdtempSync(join(tmpdir(), 'mugi-ci-'));
+  try {
+    const mdir = join(tmp, '.mugiwara', 'missions', 'selftest-mission');
+    mkdirSync(mdir, { recursive: true });
+    const cli = `bun src/cli.ts archive selftest-mission --project ${tmp}`;
+    // A mission with no trail at all archives fine (stub report path).
+    assert('clean stub → exit 0', true, () => run('CI-clean', cli));
+    // A planted secret must turn the gate red.
+    writeFileSync(join(mdir, 'report.md'), 'token = ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ123456\n');
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-mission' }));
+    assert('planted secret → exit 1', false, () => run('CI-secret', cli));
+    unlinkSync(join(mdir, 'report.md'));
+    unlinkSync(join(mdir, 'state.json'));
+    assert('cleaned → exit 0', true, () => run('CI-clean2', cli));
+
+    // Context-budget gate: a ceiling that the trail exceeds must fail red.
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-mission' }));
+    writeFileSync(join(mdir, 'report.md'), 'x'.repeat(500) + '\n');
+    mkdirSync(join(tmp, '.mugiwara'), { recursive: true });
+    writeFileSync(join(tmp, '.mugiwara', 'config'), 'context_budget_chars=10\n');
+    assert('over context budget → exit 1', false, () => run('CI-budget', cli));
+    unlinkSync(join(tmp, '.mugiwara', 'config'));
+    assert('budget unset → exit 0', true, () => run('CI-budget2', cli));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// --- POLICY: an invalid mugiwara.policy.yml fails lane.sh closed ---
+console.log('\nPOLICY — fail-closed policy parsing');
+{
+  const repo = mkdtempSync(join(tmpdir(), 'mugi-policy-'));
+  // lane.sh must run INSIDE the sandbox repo, not this one
+  const runInRepo = (args: string): boolean => {
+    try { execSync(`bash ${join(root, 'scripts', 'lane.sh')} ${args}`, { cwd: repo, stdio: 'pipe', timeout: 60000 }); return true; }
+    catch { return false; }
+  };
+  try {
+    execSync('git init -q && git config user.email t@t.com && git config user.name T && git commit --allow-empty -qm base', { cwd: repo, stdio: 'pipe' });
+    writeFileSync(join(repo, 'changed.ts'), 'export {};\n');
+    // no policy file → normal behavior
+    assert('no policy → lane runs', true, () => runInRepo('HEAD --json'));
+    // unknown root key must fail loud, not silently disable itself
+    writeFileSync(join(repo, 'mugiwara.policy.yml'), 'lanez:\n  force_full: ["src/**"]\n');
+    assert('bogus policy key → exit 1', false, () => runInRepo('HEAD --json'));
+    // valid policy parses and can force full
+    writeFileSync(join(repo, 'mugiwara.policy.yml'), 'lanes:\n  force_full:\n    - "**/*.ts"\n');
+    assert('valid policy → lane runs', true, () => runInRepo('HEAD --json'));
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+}
+
+// --- T7: evidence-thin — fabricated PASS wave with empty body must fail ---
+console.log('\nT7 — evidence-thin gate');
+{
+  const tmp = mkdtempSync(join(tmpdir(), 'mugi-thin-'));
+  try {
+    const mdir = join(tmp, '.mugiwara', 'missions', 'selftest-thin');
+    mkdirSync(join(mdir, 'flows'), { recursive: true });
+    const cli = `bun src/cli.ts archive selftest-thin --project ${tmp}`;
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-thin', evidence: ['flows/04-gates.md'] }));
+    writeFileSync(join(mdir, 'report.md'), 'Verdict: PASS see [evidence](flows/04-gates.md)');
+    writeFileSync(join(mdir, 'flows', '04-gates.md'), 'all good'); // no command shape → thin
+    assert('fabricated PASS with empty body → exit 1', false, () => run('T7-thin', cli));
+    writeFileSync(join(mdir, 'flows', '04-gates.md'), 'ran `bun run test` → 2 passed, exit 0');
+    assert('with command output → exit 0', true, () => run('T7-good', cli));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// --- DOCLINKS: a relative .md link that does not resolve must fail the gate ---
+console.log('\nDOCLINKS — doc link resolution');
+{
+  const probe = join(root, 'docs', 'tmp-doclinks-probe.md');
+  try {
+    writeFileSync(probe, '[missing](./nowhere-at-all.md)\n');
+    assert('broken doc link → exit 1', false, () => run('DL-bad', 'bun scripts/check-doc-links.ts'));
+    unlinkSync(probe);
+    assert('cleaned → exit 0', true, () => run('DL-good', 'bun scripts/check-doc-links.ts'));
+  } finally {
+    if (existsSync(probe)) unlinkSync(probe);
+  }
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);

package/scripts/lane.sh

@@ -19,17 +19,46 @@ if ! git rev-parse "$BASE" >/dev/null 2>&1; then
   [ -n "$ALT" ] && BASE="$ALT" || BASE="HEAD~1"
 fi
 
+# lane_scope_glob (T5): monorepo scoping — when set, count only files matching the glob
+LANE_SCOPE_GLOB=""
+if [ -f .mugiwara/config ]; then
+  CFG_SCOPE=$(grep -E '^lane_scope_glob=' .mugiwara/config 2>/dev/null | head -1 | cut -d= -f2- | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | tr -d '"' | tr -d "'")
+  [ -n "$CFG_SCOPE" ] && LANE_SCOPE_GLOB="$CFG_SCOPE"
+fi
+
 # union of committed + staged + unstaged + untracked (F) — see patterns.sh
 CHANGED=$(changed_files "$BASE")
-FILE_COUNT=0
-[ -n "$CHANGED" ] && FILE_COUNT=$(echo "$CHANGED" | wc -l | tr -d ' ')
-read -r ADDED_INS ADDED_DEL <<EOF
-$(changed_loc "$BASE")
-EOF
-
+# sensitive-path escalation always evaluates the unfiltered set (safety never shrinks)
 SENSITIVE=$(echo "$CHANGED" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 HAS_SENSITIVE=0
 [ -n "$SENSITIVE" ] && HAS_SENSITIVE=1
+# scoped count for lane sizing (T5)
+SCOPED="$CHANGED"
+if [ -n "$LANE_SCOPE_GLOB" ] && [ -n "$CHANGED" ]; then
+  shopt -s extglob globstar 2>/dev/null || true
+  SCOPED=""
+  while IFS= read -r _f; do
+    [ -z "$_f" ] && continue
+    # shellcheck disable=SC2053
+    if [[ "$_f" == $LANE_SCOPE_GLOB ]]; then
+      SCOPED="${SCOPED}${SCOPED:+
+}$_f"
+    fi
+  done <<< "$CHANGED"
+fi
+FILE_COUNT=0
+[ -n "$SCOPED" ] && FILE_COUNT=$(echo "$SCOPED" | wc -l | tr -d ' ')
+# LOC for the 1-file rule also scopes to the glob (otherwise a single in-scope
+# file with <20 LOC could be inflated by out-of-scope churn)
+if [ -n "$LANE_SCOPE_GLOB" ]; then
+  read -r ADDED_INS ADDED_DEL <<EOF
+$( { echo "$SCOPED" | while IFS= read -r _sf; do [ -n "$_sf" ] && git diff --numstat "$BASE"..HEAD -- "$_sf" 2>/dev/null; git diff --numstat HEAD -- "$_sf" 2>/dev/null; done; echo "$SCOPED" | while IFS= read -r _uf; do [ -z "$_uf" ] && continue; if git ls-files --others --exclude-standard -- "$_uf" 2>/dev/null | grep -qx "$_uf"; then printf '%s\t0\t%s\n' "$(wc -l < "$_uf" 2>/dev/null | tr -d ' ' || echo 0)" "$_uf"; fi; done; } | awk '{ if ($1 ~ /^[0-9]+$/) i+=$1; if ($2 ~ /^[0-9]+$/) d+=$2 } END { print (i+0)" "(d+0) }')
+EOF
+else
+  read -r ADDED_INS ADDED_DEL <<EOF
+$(changed_loc "$BASE")
+EOF
+fi
 
 # lane logic
 LANE="direct"
@@ -71,8 +100,9 @@ fi
 # code surface actually touched. Sensitive-path escalation above still wins.
 # Product surface for mugiwara: content/, src/, scripts/, test/, hooks/,
 # .opencode/, .claude/, evals/ — everything else is docs/config/asset.
-if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$CHANGED" ]; then
-  CODE_COUNT=$(echo "$CHANGED" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
+# With lane_scope_glob the check applies to the scoped set — sensitive still wins unfiltered.
+if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$SCOPED" ]; then
+  CODE_COUNT=$(echo "$SCOPED" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
   if [ -z "$CODE_COUNT" ] || [ "$CODE_COUNT" -eq 0 ] 2>/dev/null; then
     PREV="$LANE"
     LANE="standard"
@@ -80,6 +110,22 @@ if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$CHANGED" ]; then
   fi
 fi
 
+# policy as code: mugiwara.policy.yml lanes.force_full pushes the lane UP to
+# full — always upward, never downward, and it wins over the docs-only
+# downgrade above. Optional by design: no policy file (or no bun) = no-op.
+if command -v bun >/dev/null 2>&1 && { [ -f mugiwara.policy.yml ] || [ -f mugiwara.policy.yaml ]; }; then
+  POLICY_HITS=$(printf '%s\n' "$CHANGED" | bun "$(dirname "$0")/policy-force.ts")
+  RC=$?
+  if [ "$RC" -ne 0 ]; then
+    echo "lane: mugiwara.policy.yml is invalid — fix or remove it (fail-closed)" >&2
+    exit 1
+  fi
+  if [ -n "$POLICY_HITS" ]; then
+    LANE="full"
+    REASON="policy force_full ($POLICY_HITS)"
+  fi
+fi
+
 if [ "$JSON_OUT" -eq 1 ]; then
   SENS_ARR=""
   [ -n "$SENSITIVE" ] && SENS_ARR=$(echo "$SENSITIVE" | tr ',' '\n' | sed 's/^/"/;s/$/"/' | tr '\n' ',' | sed 's/,$//')

package/scripts/lib/patterns.sh

@@ -31,6 +31,11 @@ PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^e
 # (numstat rows).
 HARNESS_PAT="\.claude/|\.opencode/|\.github/(instructions|agents)/|\.gemini/mugiwara/|\.codex/mugiwara/|\.devin/rules/|\.clinerules/|\.kilo/rules/|\.agents/rules/"
 
+# lane_scope_glob — optional monorepo scoping (T5). When set in .mugiwara/config
+# as e.g.  lane_scope_glob=packages/app/**  lane sizing counts only changed
+# files matching the glob; sensitive-path escalation still evaluates the
+# unfiltered set (safety never shrinks).
+
 # harness_excluded — true (exit 0) when harness rules dirs must NOT count
 # toward mission sizing, i.e. this repo is not mugiwara itself. Identity comes
 # from the repo root package.json name ("mugiwara" or "@scope/mugiwara"), the

package/scripts/policy-force.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+// scripts/policy-force.ts — policy-as-code helper for the bash lane logic.
+// Reads changed file paths on stdin, prints the mugiwara.policy.yml
+// `lanes.force_full` globs they match (comma-separated). Empty output = no
+// policy hit. Exits 0 even when nothing matches; a missing bun skips the
+// call site entirely (policy is optional by design).
+import { readFileSync } from 'node:fs';
+import { loadPolicy, matchedGlobs } from '../src/policy.ts';
+
+const input = readFileSync(0, 'utf8');
+const paths = input.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+if (!paths.length) process.exit(0);
+let policy;
+try {
+  policy = loadPolicy(process.cwd());
+} catch (e) {
+  // Fail closed: an unreadable rule must not look like "no rule".
+  console.error(`policy-force: ${(e as Error).message}`);
+  process.exit(2);
+}
+const hits = policy?.lanes?.force_full?.length ? matchedGlobs(paths, policy.lanes.force_full) : [];
+if (hits.length) process.stdout.write(hits.join(','));

package/scripts/retrieval-eval.ts

@@ -18,7 +18,7 @@ function tokenize(text: string): string[] {
   return text.toLowerCase()
     .replace(/[^a-z0-9\s-]/g, ' ')
     .split(/\s+/)
-    .filter(t => t.length > 1 && !['the', 'and', 'for', 'use', 'when', 'that', 'with', 'this', 'from', 'its', 'not', 'are', 'has'].includes(t));
+    .filter(t => t.length > 1 && !['the', 'and', 'for', 'use', 'when', 'that', 'with', 'this', 'from', 'its', 'not', 'are', 'has', 'to', 'is', 'it', 'of', 'in', 'on', 'at', 'be', 'or', 'as', 'an'].includes(t));
 }
 
 function buildIndex(): Index {