drafted 1.24.2 → 1.24.4

package/mcp/active-project-store.mjs

@@ -1,81 +0,0 @@
-/**
- * Active-project persistence for the stdio MCP.
- *
- * The active project lives only in the in-memory sessionStates Map, so a
- * `system restart mode=mcp` / skill-edit pass that re-spawns the stdio MCP
- * wipes it — the recurring "active project keeps resetting, re-open it" churn.
- * Persisting it lets the long-lived stdio process rehydrate transparently after
- * a restart.
- *
- * Keyed by SERVER URL + cwd so two concurrent same-machine agent sessions (each
- * its own stdio MCP, same launch config) don't clobber each other's active
- * project. The server is part of the key because project and org ids are only
- * meaningful within one server's DATABASE: this repo registers both a prod
- * (`https://drafted.live`) and a local-dev (`http://localhost:3477`) stdio MCP,
- * and with a cwd-only key the local MCP's project+boundOrgId were rehydrated by
- * the prod MCP at boot — which pinned the prod session's working org to an org
- * id that exists only in the local dev DB (`get_org` reported a workingOrg with
- * name:null that was in no membership, and every project-less call failed with
- * `not a member of org "<local-uuid>"`). Cross-database state must never share a
- * key. Only the stdio process persists here; HTTP/remote user sessions are keyed
- * by a real Drafted session id and never call into this store.
- *
- * Side-effect-free on import (no network, no eager writes) so it can be unit
- * tested against the real code without booting the MCP server.
- */
-import { readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-
-const DEFAULT_FILE = process.env.DRAFTED_MCP_STATE_FILE || join(homedir(), '.drafted', 'mcp-state.json');
-
-function defaultCwd() {
-  try { return process.cwd(); } catch { return '__default__'; }
-}
-
-// serverUrl first: a URL never contains "|", so the composite key is unambiguous.
-function stateKey(cwd, serverUrl) {
-  return serverUrl ? `${serverUrl}|${cwd}` : cwd;
-}
-
-export function loadPersistedProject({ file = DEFAULT_FILE, cwd = defaultCwd(), serverUrl = '' } = {}) {
-  try {
-    const all = JSON.parse(readFileSync(file, 'utf8'));
-    // Pre-composite-key entries (bare cwd) are NOT read back: they carry no record of
-    // which server minted their ids, and adopting one is exactly the cross-DB bleed
-    // above. Worst case the agent re-opens its project once.
-    const e = all && all[stateKey(cwd, serverUrl)];
-    if (e && e.activeProjectId) {
-      return {
-        activeProjectId: e.activeProjectId,
-        activeProjectMeta: e.activeProjectMeta || null,
-        boundOrgId: e.boundOrgId || null,
-      };
-    }
-  } catch { /* no state file yet / unreadable — start fresh */ }
-  return null;
-}
-
-export function savePersistedProject(entry, { file = DEFAULT_FILE, cwd = defaultCwd(), serverUrl = '' } = {}) {
-  try {
-    let all = {};
-    try { all = JSON.parse(readFileSync(file, 'utf8')) || {}; } catch { /* recreate */ }
-    const key = stateKey(cwd, serverUrl);
-    if (key !== cwd) delete all[cwd]; // drop the un-namespaced legacy entry for this cwd
-    if (entry && entry.activeProjectId) {
-      all[key] = {
-        activeProjectId: entry.activeProjectId,
-        activeProjectMeta: entry.activeProjectMeta || null,
-        boundOrgId: entry.boundOrgId || null,
-      };
-    } else {
-      delete all[key];
-    }
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(all), { mode: 0o600 });
-    return true;
-  } catch {
-    // Best-effort; persistence is an optimization, never block a tool on it.
-    return false;
-  }
-}

package/mcp/gates.mjs

@@ -1,206 +0,0 @@
-// Pure gate logic for the Drafted compounding harness.
-//
-// These helpers are intentionally side-effect free (no `api()`, no network, no
-// module state) so they can be unit tested in isolation. mcp/server.mjs imports
-// them and wires the decisions into the tool handlers + per-session getState().
-//
-// See docs/plans/compounding-harness.md and the Drafted "gates-checklist" frame.
-
-// One combined per-project budget for the auto-injected priming set:
-// attached-skill bodies + project anchor bodies + the active layer's rules.
-// Single source of truth lives in src/shared so the server-side deposit caps
-// enforce the identical limit. Re-exported here for the MCP gate helpers.
-import { PROJECT_CONTEXT_BUDGET_CHARS, selectWithinBudget } from '../src/shared/gate-budget.mjs';
-export { PROJECT_CONTEXT_BUDGET_CHARS, selectWithinBudget };
-
-// ── Per-session gate flags (reset every MCP session) ──────────────────────────
-
-export function createGateState() {
-  return { wikiSearched: false, skillSearched: false, templateSearched: false };
-}
-
-// kind: 'wiki' | 'skill' | 'template'
-export function markSearched(gateState, kind) {
-  if (kind === 'wiki') gateState.wikiSearched = true;
-  else if (kind === 'skill') gateState.skillSearched = true;
-  else if (kind === 'template') gateState.templateSearched = true;
-  return gateState;
-}
-
-// ── Enforce gates (create chain). Return an error string if blocked, else null ─
-
-export function g1Block(gateState, wikiIndex) {
-  if (gateState.wikiSearched) return null;
-  let msg =
-    'G1: search the org wiki before reading or editing anything. ' +
-    'Call fs(search, path="/wiki", query="<relevant terms>") first, then retry. ' +
-    'More knowledge = less searching — start by drawing on what the org already knows.';
-  if (wikiIndex) msg += `\n\nWiki index (what exists to search):\n${wikiIndex}`;
-  return msg;
-}
-
-export function g2Block(gateState) {
-  if (gateState.skillSearched) return null;
-  return (
-    'G2: search for prior-art skills before creating one. ' +
-    'Call fs(search, path="/skills", query="<topic>") first — if a close match exists, improve it ' +
-    '(/drafted:improve-skill) instead of duplicating — then retry skill(action="add").'
-  );
-}
-
-export function g3Block(gateState) {
-  const missing = [];
-  if (!gateState.wikiSearched) missing.push('fs(search, path="/wiki")');
-  if (!gateState.skillSearched) missing.push('fs(search, path="/skills")');
-  if (!gateState.templateSearched) missing.push('fs(ls, path="/skills")');
-  if (missing.length === 0) return null;
-  return (
-    `G3: search before creating a project. Run ${missing.join(', ')} first ` +
-    '(reuse existing knowledge, skills, and templates), then retry project(action="create").'
-  );
-}
-
-// ── Per-project context budget (auto-inject set) ──────────────────────────────
-
-function itemChars(it) {
-  if (typeof it === 'number') return it;
-  if (typeof it === 'string') return it.length;
-  if (it && typeof it === 'object') {
-    if (typeof it.chars === 'number') return it.chars;
-    if (it.content != null) return String(it.content).length;
-  }
-  return 0;
-}
-
-export function sumChars(items) {
-  if (!Array.isArray(items)) return 0;
-  return items.reduce((total, it) => total + itemChars(it), 0);
-}
-
-export function budgetRemaining(currentTotal, budget = PROJECT_CONTEXT_BUDGET_CHARS) {
-  return Math.max(0, budget - currentTotal);
-}
-
-export function wouldExceedBudget(currentTotal, addChars, budget = PROJECT_CONTEXT_BUDGET_CHARS) {
-  return currentTotal + addChars > budget;
-}
-
-export function budgetError(currentTotal, addChars, label, budget = PROJECT_CONTEXT_BUDGET_CHARS) {
-  const remaining = budgetRemaining(currentTotal, budget);
-  return (
-    `Per-project context budget exceeded: ${label} needs ${addChars} chars but only ${remaining} ` +
-    `of ${budget} remain. Tighten existing attached skills / anchors / layer rules first ` +
-    `(see /drafted:improve-project-harness).`
-  );
-}
-
-// ── G6 layer-rule default detection ───────────────────────────────────────────
-
-// A layer prompt is "default" (skip G6 inject) when it is empty or byte-identical
-// to the template's default prompt for that layer key.
-export function isLayerPromptDefault(layerPrompt, templateDefaultPrompt) {
-  const p = (layerPrompt ?? '').trim();
-  if (p === '') return true;
-  const d = (templateDefaultPrompt ?? '').trim();
-  return d !== '' && p === d;
-}
-
-export function shouldInjectLayerPrompt(layerPrompt, templateDefaultPrompt) {
-  return !isLayerPromptDefault(layerPrompt, templateDefaultPrompt);
-}
-
-// ── Wiki index formatting (bounded map injected with the G1 block) ────────────
-
-// `empty` lets a caller say what an empty result MEANS: a zero-hit search or an
-// empty folder is not "the wiki is empty" (that read as a contradiction when other
-// searches of the same org had returned pages).
-export function formatWikiIndex(pages, max = 50, empty = '(wiki is empty — no pages yet)') {
-  if (!Array.isArray(pages) || pages.length === 0) return empty;
-  const lines = pages.slice(0, max).map((p) => {
-    const path = typeof p === 'string' ? p : p.path ?? p.slug ?? '';
-    const title = typeof p === 'object' && p && p.title ? ` — ${p.title}` : '';
-    return `  ${path}${title}`;
-  });
-  const more = pages.length > max ? `\n  …and ${pages.length - max} more` : '';
-  return lines.join('\n') + more;
-}
-
-// A frame read is capped per page, below MAX_TOOL_RESULT_CHARS, because the
-// content is JSON-escaped on its way out (quotes, newlines) and the blunt cap
-// above cuts mid-token with no way back: `lines` cannot split a minified frame
-// that is ONE line, so ~90 KB of it was simply lost. Paging by character gives
-// every byte an address.
-export const READ_PAGE_CHARS = 60_000;
-
-// "start-end" (0-based, end exclusive) or "start" -> the window to return.
-export function charWindow(spec, total) {
-  const m = /^\s*(\d+)\s*(?:-\s*(\d+))?\s*$/.exec(String(spec ?? ''));
-  if (spec != null && spec !== '' && !m) throw new Error(`chars must look like "0-60000" (got "${spec}")`);
-  const start = m ? Math.min(Number(m[1]), total) : 0;
-  const end = Math.min(m?.[2] ? Number(m[2]) : start + READ_PAGE_CHARS, start + READ_PAGE_CHARS, total);
-  return { start, end: Math.max(start, end) };
-}
-
-// ── Project index formatting ──────────────────────────────────────────────────
-// `ls /projects` is an ls, not a stat: one addressable line per project. The
-// previous shape returned the raw /api/projects rows — ~2.4KB each once the
-// per-project `layers` config (912B avg on prod) is pretty-printed — so an org
-// with 180 projects blew the 90KB tool-result cap and came back truncated
-// mid-JSON at 38. Names and paths are what an agent needs to pick one; layers,
-// format, template and share rollups belong on `ls` of the single project.
-
-function relAge(then, now = Date.now()) {
-  const t = then ? new Date(then).getTime() : NaN;
-  if (!Number.isFinite(t)) return '';
-  const d = Math.max(0, Math.floor((now - t) / 86400000));
-  if (d === 0) return 'today';
-  if (d < 7) return `${d}d`;
-  if (d < 60) return `${Math.floor(d / 7)}w`;
-  if (d < 730) return `${Math.floor(d / 30)}mo`;
-  return `${Math.floor(d / 365)}y`;
-}
-
-export function projectPath(p) {
-  const org = p.orgSlug || p.orgId || '';
-  const name = p.slug || p.name || p.id;
-  const folder = p.folder ? `${p.folder}/` : '';
-  return `/o/${org}/projects/${folder}${name}`;
-}
-
-/**
- * One line per project, most-recently-touched first, with a header naming where
- * this session is bound. `boundPath` comes from the MCP session's own state —
- * never the shared active-project row (DRAFT-36: nothing another session can
- * rewrite may drive what this one reports).
- */
-export function formatProjectIndex(projects, { max = 50, boundPath = null, now = Date.now() } = {}) {
-  if (!Array.isArray(projects) || projects.length === 0) {
-    return '(no projects — create one with fs(mkdir, path="/o/<org>/projects/<name>"))';
-  }
-  const sorted = [...projects].sort((a, b) => {
-    const at = new Date(a.updatedAt || a.createdAt || 0).getTime();
-    const bt = new Date(b.updatedAt || b.createdAt || 0).getTime();
-    return bt - at;
-  });
-  const shown = sorted.slice(0, max);
-  const paths = shown.map(projectPath);
-  const width = Math.min(60, Math.max(...paths.map((s) => s.length)));
-  const lines = shown.map((p, i) => {
-    const n = Number(p.frameCount);
-    const frames = Number.isFinite(n) && p.frameCount != null ? `${n} frame${n === 1 ? '' : 's'}` : '';
-    const age = relAge(p.updatedAt || p.createdAt, now);
-    const detail = [frames, age].filter(Boolean).join('  ');
-    return `  ${paths[i].padEnd(width)}  ${detail}`.trimEnd();
-  });
-  const orgs = new Set(projects.map((p) => p.orgSlug || p.orgId).filter(Boolean));
-  const header = [
-    `${projects.length} project${projects.length === 1 ? '' : 's'}`,
-    orgs.size > 1 ? `${orgs.size} orgs` : null,
-    boundPath ? `bound: ${boundPath}` : null,
-  ].filter(Boolean).join(' · ');
-  const more = projects.length > max
-    ? `\n  …and ${projects.length - max} more (recency order — narrow with pattern="<glob>" or fs(search, path="/projects", query="<terms>"))`
-    : '';
-  return `${header}\n\n${lines.join('\n')}${more}`;
-}
-

package/mcp/gws-status.mjs

@@ -1,31 +0,0 @@
-// Local-capability probe for the Get set up page (see mcp/server.mjs, agent-capabilities).
-// Its own module so tests can import it without opening the MCP WebSocket.
-import { execFile } from 'child_process';
-import { homedir } from 'os';
-import { join } from 'path';
-
-/**
- * Is Google's Workspace CLI signed in for this user, with Gmail readable?
- * 'ready' | 'signed_out' | 'absent'. Checks the Drafted npm prefix first (where
- * `drafted google-setup` installs it, and which a GUI-launched agent's PATH may
- * lack), then PATH. Anything that is not Google's gws (Homebrew's `gws` is an
- * unrelated tool) prints non-JSON and reads as 'absent'.
- */
-export function gwsStatusFromJson(stdout) {
-  try {
-    const j = JSON.parse(stdout);
-    return j.has_refresh_token && (j.scopes || []).some((x) => String(x).includes('/auth/gmail')) ? 'ready' : 'signed_out';
-  } catch {
-    return 'absent';
-  }
-}
-export function detectGwsStatus({ candidates = [join(homedir(), '.drafted', 'npm-global', 'bin', 'gws'), 'gws'] } = {}) {
-  const tryOne = (i) => new Promise((resolve) => {
-    if (i >= candidates.length) return resolve('absent');
-    execFile(candidates[i], ['auth', 'status'], { timeout: 5000, windowsHide: true }, (err, stdout) => {
-      if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) return resolve(tryOne(i + 1));
-      resolve(gwsStatusFromJson(String(stdout || '')));
-    });
-  });
-  return tryOne(0).catch(() => 'absent');
-}

package/mcp/repo-address.mjs

@@ -1,215 +0,0 @@
-/**
- * What Drafted address does this working directory name?
- *
- * The MCP runs as a stdio process spawned in the user's repo. Until now it had
- * no idea whether that repo was linked to a Drafted folder, so an agent working
- * in a linked checkout would write to whatever org the session happened to
- * inherit. The comment above `workingOrgId()` in server.mjs records where that
- * ends: "trusting it is what wrote a Beoflow-bound agent's wiki page into
- * Personal."
- *
- * Two rules shape this module:
- *
- * 1. It answers a PATH (/o/<org>/<folder>), never an orgId to stash. A stored
- *    org becomes an inherited default, which is the bug we are fixing, not a
- *    fix for it.
- * 2. It does NOT normalize git URLs. Remotes go to the server raw and
- *    parseGitHubUrl (server/lib/repo-ingest.mjs) stays the single normalizer.
- *    A second normalizer that drifts from the first would reintroduce the
- *    split-master problem inside the fix itself.
- *
- * Side-effect free and network-free: probe() shells out to git, resolve() is
- * pure. That split is what makes this testable without a repo or a server.
- */
-
-import { execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/** Run a git command in `cwd`, or null if git fails for any reason. Never
- *  throws: not-a-repo, no git binary, and a detached HEAD are all ordinary. */
-function git(args, cwd) {
-  try {
-    const out = execFileSync('git', args, {
-      cwd,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2000,
-    });
-    return out.trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read the git identity of a working directory.
- *
- * `--show-toplevel` is what makes a monorepo subdirectory and a worktree behave:
- * any cwd inside the tree normalizes to the repo root, and a worktree reports
- * its own root while sharing the remote.
- *
- * Every remote is returned, origin first. A fork whose `origin` Drafted has
- * never seen may still have an `upstream` that is linked, and resolving that is
- * strictly better than reporting nothing.
- */
-export function probeRepo(cwd = process.cwd()) {
-  const root = git(['rev-parse', '--show-toplevel'], cwd);
-  if (!root) return null;
-  const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
-  const remotes = parseRemotes(git(['remote', '-v'], cwd));
-  return {
-    root,
-    // A detached HEAD reports the literal "HEAD"; that is not a branch name and
-    // must not be matched against repos.branch.
-    branch: branch && branch !== 'HEAD' ? branch : null,
-    remotes,
-    declared: readDeclaration(root),
-  };
-}
-
-/** `git remote -v` → [{ name, url }], deduped, origin first then upstream. */
-export function parseRemotes(text) {
-  const seen = new Map();
-  for (const line of String(text || '').split('\n')) {
-    const m = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/);
-    if (m && !seen.has(m[1])) seen.set(m[1], m[2]);
-  }
-  const rank = (n) => (n === 'origin' ? 0 : n === 'upstream' ? 1 : 2);
-  return [...seen.entries()]
-    .map(([name, url]) => ({ name, url }))
-    .sort((a, b) => rank(a.name) - rank(b.name) || a.name.localeCompare(b.name));
-}
-
-/**
- * The optional committed declaration, `<repo root>/.drafted/config.json`.
- *
- * This file SELECTS among candidates the server returned; it never grants
- * access to anything. That distinction is the whole reason it is safe to
- * commit: "which org is this repo?" is a per-USER question (membership differs
- * per collaborator) and a committed file is a per-REPO answer. As a filter it
- * is correct; as an authority it would be a way for a forked repo to point your
- * session at someone else's org.
- *
- * Malformed or missing is not an error — it is the normal case.
- */
-export function readDeclaration(root) {
-  try {
-    const raw = readFileSync(join(root, '.drafted', 'config.json'), 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object') return null;
-    const pick = (v) => (typeof v === 'string' && v.trim() ? v.trim() : null);
-    const declared = { org: pick(parsed.org), folder: pick(parsed.folder), gitUrl: pick(parsed.gitUrl) };
-    return declared.org || declared.folder ? declared : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Turn the server's candidate list into one address, or an honest non-answer.
- *
- * States, and why each exists:
- *   none      — not a git repo. Behaves exactly as today.
- *   unlinked  — a remote exists and matched nothing. An EXPLICIT negative: a
- *               bare "not linked" is indistinguishable from "I failed to parse
- *               your remote", and that ambiguity is this feature's most likely
- *               silent failure, so the probed URLs are always echoed.
- *   linked    — exactly one candidate, or the declaration picked one.
- *   ambiguous — several member orgs link this repo. Adopt NOTHING. This is the
- *               case where a wrong write is both most plausible and least
- *               detectable, so it is never guessed.
- */
-export function resolveAddress(probe, matches = []) {
-  if (!probe) return { state: 'none' };
-  const base = {
-    root: probe.root,
-    branch: probe.branch,
-    remote: probe.remotes[0]?.url ?? null,
-  };
-  if (!matches.length) {
-    return { ...base, state: 'unlinked', probed: probe.remotes.map((r) => r.url) };
-  }
-
-  const picked = matches.length === 1 ? matches[0] : selectByDeclaration(probe.declared, matches);
-  if (!picked) {
-    return { ...base, state: 'ambiguous', candidates: matches.map((m) => m.path) };
-  }
-
-  // The branch is reported, never enforced: reading a folder whose index tracks
-  // another branch is legitimate, it just has to be visible.
-  const onTrackedBranch = !probe.branch || picked.branch === probe.branch;
-  return {
-    ...base,
-    state: 'linked',
-    path: picked.path,
-    org: picked.orgName,
-    orgId: picked.orgId,
-    orgSlug: picked.orgSlug,
-    folder: picked.folderName,
-    trackedBranch: picked.branch,
-    onTrackedBranch,
-    viaDeclaration: matches.length > 1,
-  };
-}
-
-/** Match a declaration against candidates by org name/slug and folder name.
- *  Returns null unless it selects exactly one — an ambiguous declaration is no
- *  better than no declaration, and must not break the tie by accident. */
-function selectByDeclaration(declared, matches) {
-  if (!declared) return null;
-  const eq = (a, b) => typeof a === 'string' && typeof b === 'string' && a.toLowerCase() === b.toLowerCase();
-  const hits = matches.filter(
-    (m) =>
-      (!declared.org || eq(declared.org, m.orgName) || eq(declared.org, m.orgSlug)) &&
-      (!declared.folder || eq(declared.folder, m.folderName))
-  );
-  return hits.length === 1 ? hits[0] : null;
-}
-
-/** The prose an agent reads. Written to TEACH, like the 409 repo_owned gate:
- *  it names the address to use and the fact that other orgs stay reachable. */
-export function addressNote(address, workingOrgId) {
-  if (!address || address.state === 'none') return null;
-  if (address.state === 'unknown') {
-    // Say WHICH question went unanswered. "Not linked" and "could not ask" look
-    // identical to an agent, and only one of them means it is safe to proceed.
-    return `This is a git checkout (${address.remote || 'no remote'}) but Drafted could not be asked whether it is linked (${address.reason}). Nothing is defaulted — address writes explicitly, and re-check with whoami once signed in.`;
-  }
-  if (address.state === 'unlinked') {
-    return `This checkout (${address.probed.join(', ') || 'no remote'}) is not linked to any Drafted folder you can see. Nothing is defaulted — address writes explicitly.`;
-  }
-  if (address.state === 'ambiguous') {
-    return `This checkout is linked in more than one org you belong to (${address.candidates.join(', ')}). Nothing is defaulted — pass org= or an absolute /o/<org>/... path.`;
-  }
-  const parts = [`Your working directory is the repo linked to ${address.path}.`];
-  if (workingOrgId && workingOrgId !== address.orgId) {
-    parts.push(`This session's working org is a DIFFERENT org — address work under ${address.path}/... unless the user asked for another org.`);
-  }
-  if (!address.onTrackedBranch) {
-    parts.push(`Note: that folder tracks branch ${address.trackedBranch} and you are on ${address.branch}, so its index describes another branch.`);
-  }
-  parts.push(`That folder's wiki and skills are git-owned: writes return 409 repo_owned and belong in a commit. Other orgs stay reachable with org= or /o/<org>/... .`);
-  return parts.join(' ');
-}
-
-// Self-check: parsing and resolution, no git and no network.
-export function demo() {
-  const ok = (c, m) => { if (!c) throw new Error(m); };
-  const remotes = parseRemotes('upstream\tgit@github.com:a/b.git (fetch)\nupstream\tx (push)\norigin\thttps://github.com/c/d (fetch)');
-  ok(remotes[0].name === 'origin', 'origin ranks first');
-  ok(remotes.length === 2, 'deduped to two remotes');
-
-  ok(resolveAddress(null).state === 'none', 'no repo -> none');
-  const probe = { root: '/r', branch: 'main', remotes: [{ name: 'origin', url: 'u' }], declared: null };
-  ok(resolveAddress(probe, []).state === 'unlinked', 'no matches -> unlinked');
-
-  const one = { path: '/o/x/F', orgName: 'X', orgSlug: 'x', orgId: 'o1', folderName: 'F', branch: 'main' };
-  ok(resolveAddress(probe, [one]).state === 'linked', 'single match -> linked');
-
-  const two = { ...one, path: '/o/y/G', orgName: 'Y', orgSlug: 'y', orgId: 'o2', folderName: 'G' };
-  ok(resolveAddress(probe, [one, two]).state === 'ambiguous', 'two matches -> ambiguous');
-  ok(resolveAddress({ ...probe, declared: { org: 'Y' } }, [one, two]).path === '/o/y/G', 'declaration breaks the tie');
-  ok(resolveAddress({ ...probe, declared: { org: 'Z' } }, [one, two]).state === 'ambiguous', 'declaration naming a non-candidate grants nothing');
-  console.log('repo-address self-check OK');
-}

package/mcp/test-file-path-text.mjs

@@ -1,58 +0,0 @@
-/**
- * Regression for textFromLocalFile() — the `file_path` text seam used by
- * fs(write) on /wiki and /skills.
- *
- *   node mcp/test-file-path-text.mjs
- *
- * Why this exists: /projects uploads bytes (base64 + contentType), /wiki and
- * /skills take markdown text. Routing a file down the wrong seam stores
- * mojibake that only surfaces when someone reads the page back, so the binary
- * guard below is the load-bearing assertion, not a nicety.
- */
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { textFromLocalFile } from './server.mjs';
-
-const dir = mkdtempSync(join(tmpdir(), 'drafted-filepath-'));
-
-// Plain markdown round-trips byte-for-byte.
-const md = join(dir, 'page.md');
-const body = '# Title\n\nBody with a UTF-8 em dash — and an accent é.\n';
-writeFileSync(md, body, 'utf8');
-assert.equal(textFromLocalFile(md), body);
-
-// Multi-byte characters survive — a latin1 read would mangle these.
-assert.ok(textFromLocalFile(md).includes('—'));
-assert.ok(textFromLocalFile(md).includes('é'));
-
-// Empty file returns '' rather than throwing. The caller decides: both write
-// sites treat falsy text as "no content supplied" and error with guidance.
-const empty = join(dir, 'empty.md');
-writeFileSync(empty, '');
-assert.equal(textFromLocalFile(empty), '');
-
-// Binary is refused. A PNG header contains NUL bytes.
-const png = join(dir, 'shot.png');
-writeFileSync(png, Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00]));
-assert.throws(() => textFromLocalFile(png), /looks binary/);
-
-// Directories are refused with a clear message, not an EISDIR stack trace.
-const sub = join(dir, 'nested');
-mkdirSync(sub);
-assert.throws(() => textFromLocalFile(sub), /is a directory/);
-
-// Missing files name the path the caller passed, not the resolved one.
-assert.throws(() => textFromLocalFile(join(dir, 'nope.md')), /file not found/);
-
-// Relative paths resolve against cwd rather than being read blindly.
-assert.throws(() => textFromLocalFile('definitely-not-here-xyz.md'), /file not found/);
-
-console.log('file_path text seam ok — utf8 preserved, binary and dirs refused');
-
-// Importing server.mjs opens the MCP WebSocket at module scope, which pins the
-// event loop open forever. mcp/test-org-guards.mjs only exits because it
-// finishes in ~176ms — before the socket connects — so it passes on a race
-// rather than by design. Exit explicitly instead of inheriting that luck.
-process.exit(0);