spexcode 0.6.7 → 0.7.0-next.0

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/core/stop-gate/spec.md

@@ -18,6 +18,6 @@ The block text is where the declaration ritual is taught, so it is written to be
 
 The clean-done eval nudge is advisory only and must never corrupt the Stop hook protocol. Claude-family hooks can receive it as `hookSpecificOutput.additionalContext`; Codex Stop allows are silent because Codex treats unsupported non-block stdout as invalid hook JSON. Blocking decisions stay shared across harnesses through `{"decision":"block"}` plus the dispatcher’s Codex stderr bridge.
 
-Both gates act ONLY on a GOVERNED (dashboard-launched) session: the gate resolves the session's record in the global store from the payload's `session_id`, and on a non-governed (user-self-launched) record — or none — it exits 0 SILENTLY. A self-launched agent has no board to feed, so the declare-demand must never misfire on it. Its own state writes go through `spex session … --session <id>`, passing the id explicitly since there is no worktree file to read it from.
+Both gates act ONLY on a GOVERNED (dashboard-launched) session: the gate resolves the session's record in the global store from the payload's `session_id`, and on a non-governed (user-self-launched) record — or none — it exits 0 SILENTLY. A self-launched agent has no board to feed, so the declare-demand must never misfire on it. The forced-continuation fallback writes `asking` through `spex internal session-state --session <id>` — the canonical writer, with no delivery or build side effects — passing the id explicitly since there is no worktree file to read it from. Porcelain declarations remain agent-facing; the hook never invokes them to repair its own stop.
 
 It is the enforcement edge of [[core]]: nothing leaves a session except as committed work under a truthful declaration. The freshness it reads is set by [[mark-active]].

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/core/stop-gate/stop-gate.sh

@@ -11,28 +11,20 @@
 #                                          without inventing a completion state.
 # $SPEX is the PATH-independent CLI invocation (abs tsx + cli) injected by settingsArg, so the gate's own
 # auto-default AND the command it shows the agent both work even when `spex` is absent from PATH.
-# @@@ global store + governed gate - state lives in the per-session GLOBAL record session.json (keyed by the
-# harness session_id from the payload, grouped per-project — mirrors spec-cli/src/layout.ts). The gate acts
-# ONLY on a GOVERNED (dashboard-launched) session: a user-self-launched agent has no board to feed, so an
-# undeclared stop is none of our business — we exit 0 SILENTLY (the bug this fixes: the declare-demand
-# misfiring on a self-launched codex/claude). cwd = the session worktree (resolves the project key + the
-# commit-gate's git); state writes go through `$SPEX session … --session <id>` (TS owns the JSON).
+# @@@ governed gate - the session id comes from the payload. The gate acts ONLY on a GOVERNED
+# (dashboard-launched) session: a user-self-launched agent has no board to feed, so an undeclared stop is
+# none of our business. Lifecycle status/proposal come from the canonical session application through one
+# CLI read; this shell never treats runtime.json as a second lifecycle database.
 . "${SPEXCODE_HARNESS_LIB:?harness.sh not exported by dispatch.sh}"
 S="${SPEX:-spex}"
 input=$(cat 2>/dev/null || true)
 sid=$(hp_session_id "$input"); [ -n "$sid" ] || exit 0
 sdir=$(hp_store_dir "$sid") || exit 0
-rec="$sdir/session.json"
-# non-governed (or no record) → silently let the stop through. THIS is the self-launch fix.
-grep -q '^[[:space:]]*"governed"[[:space:]]*:[[:space:]]*true,\?$' "$rec" 2>/dev/null || exit 0
-
-# read a CLOSED-VOCABULARY field (status / proposal) off its OWN line. The record is one-field-per-line from
-# the single writer ([[sessions-core]]), so anchoring to the line start is what keeps a neighbouring note's
-# escaped quote from being read as this field's value — the read half of the same rule that stops shell from
-# ever composing the record.
-jget() { sed -n "s/^[[:space:]]*\"$1\"[[:space:]]*:[[:space:]]*\"\([^\"]*\)\",\?$/\1/p" "$rec" 2>/dev/null | head -1; }
-status=$(jget status)
-proposal=$(jget proposal)
+# non-governed (or no record) → silently let the stop through. THIS is the self-launch fix. The CLI response
+# is governed<TAB>status<TAB>proposal; status/proposal are canonical, while governed is identity metadata.
+hook_state=$($S internal session-hook-state --session "$sid" 2>/dev/null) || exit 0
+IFS=$'\t' read -r governed status proposal <<< "$hook_state"
+[ "$governed" = 1 ] || exit 0
 
 # the value of the payload's structured `stop_hook_active` field (true on the hook-forced continuation),
 # read by field name rather than substring-sniffing the JSON blob. ([a-z]* captures true/false portably —
@@ -91,7 +83,10 @@ if [ "${status:-active}" = awaiting ] && { [ "$proposal" = merge ] || [ "$propos
     exit 0   # work is committed and ahead of main -> the proposal is honest, let it stop.
   fi
   if [ "$cont" = true ]; then
-    $S session ask --session "$sid" --note "stopped with uncommitted work — commit your spec+code on the node branch, then re-declare done" >/dev/null 2>&1 || true
+    # The hook is a thin boundary.  Do not call the porcelain declaration here: it may trigger
+    # delivery/build work and can remain running after the harness has already accepted the stop.
+    # The internal writer is the same canonical lifecycle path, with no dispatch side effects.
+    $S internal session-state asking --session "$sid" --note "stopped with uncommitted work — commit your spec+code on the node branch, then re-declare done" >/dev/null 2>&1 || true
     exit 0
   fi
   reason=$($S internal hook-prompt stop-gate --variant commit --reason "$gatemsg" --cli "$S" --propose "$proposal") || exit 1
@@ -106,13 +101,15 @@ fi
 if [ "$cont" = true ]; then
   # The forced continuation also stopped without declaring. Escape into asking: no default may invent a
   # completed lane, and the stopped agent now needs a human prompt to choose merge, close, ask, or park.
-  $S session ask --session "$sid" --note "auto: stopped without declaring — choose merge, close, ask, or park; done --propose nothing records no state" >/dev/null 2>&1 || true
+  # Keep this fallback inside the hook/CLI boundary.  The porcelain `session ask` command can wait on
+  # delivery and workspace builds; a stop hook must settle the canonical state independently of those paths.
+  $S internal session-state asking --session "$sid" --note "auto: stopped without declaring — choose merge, close, ask, or park; done --propose nothing records no state" >/dev/null 2>&1 || true
   exit 0
 fi
 
 # first stop in an undeclared state -> block. The FULL teaching text prints ONCE per session; every later
 # undeclared stop gets a ONE-LINE version (a heavy session hits this gate 15-20x a night — re-printing the
-# full menu each time is pure token noise). The once-sentinel is a plain file beside session.json in the
+# full menu each time is pure token noise). The once-sentinel is a plain file beside runtime.json in the
 # session's global store dir — the same per-session-sentinel mechanism as the CLI's note-echo-taught; $sdir
 # is already alias-resolved here, so a codex thread id lands on the same file, and an unwritable dir just
 # teaches again (never blocks the block). The terse line must stay SELF-EXPLANATORY: an agent whose context

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/skills/merge/spec.md

@@ -0,0 +1,33 @@
+---
+title: merge
+surface: skill, command
+status: active
+hue: 130
+desc: Land this session's completed branch into the repository's source-of-truth branch as one verified no-ff merge, preserve unrelated dirty work, push it, and settle the session honestly. Use when the user says /merge, asks to merge or land this session, or when a supervisor dispatches a merge.
+kind: mutating
+---
+# merge
+
+Land the current SpexCode session's branch; do not dispatch another merge request back to yourself.
+
+1. Inspect the current session, branch, worktree, source-of-truth checkout, and live Git status. Treat every
+   pre-existing dirty or untracked path as user-owned. Record its exact status and diff fingerprint; never
+   discard it, fold it into your commit, or hide it behind an unverified stash.
+2. Commit this session's intended spec and code first. In this worktree, merge the latest source-of-truth
+   head into the session branch. Resolve conflicts here, then rerun the focused proof, build, `spex spec lint`,
+   and `spex eval lint --changed` required by the changed behavior.
+3. Immediately before landing, verify
+   `git merge-base --is-ancestor <source-head> <session-head>`. If it fails, sync again. A clean textual merge
+   is not product proof.
+4. In the source-of-truth checkout, make one `--no-ff` merge of the already-synced session tip. Do not resolve
+   conflicts there. If unrelated dirty work prevents the merge, preserve it byte-for-byte and report the exact
+   overlap rather than forcing, resetting, or committing it.
+5. Verify the source checkout has no `MERGE_HEAD`, the session tip is its ancestor, unrelated dirty
+   fingerprints are unchanged, and the post-merge gates pass. Push the source-of-truth branch only after
+   those checks.
+6. Stop test-owned processes and publish any evidence a human must inspect. If the work is fully landed and
+   no decision remains, run `spex session done --propose close` as the final action. Never close your own
+   session directly. If a real decision or external wake-up remains, declare the truthful alternative instead.
+
+`spex session merge <SEL>` is the supervisor-facing dispatcher that sends this workflow to another session.
+Inside the target session, execute the workflow above; do not call `spex session merge .` recursively.

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/skills/spec.md

@@ -11,9 +11,5 @@ where an agent invokes them on demand, each carrying `surface: skill`. Grouping
 legible at a glance — the skill plugins on this shelf, the command presets on [[commands]], the auxiliary
 system contracts on [[prompts]], with [[core]] a flat child beside them.
 
-This node is a **shelf, not a surface** (the [[prompts]] shape): it declares no `surface` field and
-gathers nothing itself. Discovery is recursive and field-driven (surface), so a resident plugs in
-exactly as it would at the root. A plugin that serves BOTH surfaces — [[distill]] is skill and command —
-shelves here by its primary (skill) identity and still gathers as a command through its field. The init
-templates mirror this layout. The shelf stays pure presentation: moving a resident beneath it changes
-neither that plugin's identity nor the surfaces gathered from its frontmatter.
+This node is a **shelf, not a surface**. Its routing and relocation invariant is owned once by
+[[.plugins]]'s shelf invariant; this node only describes skill-specific materialization and invocation.

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/spec.md

@@ -21,3 +21,10 @@ materialized into the agent's contract.
 Which plugins `spex init` ships is the init-preset rule. `seed: false` excludes a plugin subtree; shared
 plugins have one body and one helper set — there is no separately authored adopter variant. Dogfood eval
 scenarios/readings remain with the implementation and git history they measure.
+
+## shelf invariant
+
+Grouping shelves (`[[commands]]`, `[[skills]]`, `[[review]]`, and `[[prompts]]`) are presentation parents, not
+surfaces. Discovery is recursive and field-driven, so moving a resident under a shelf changes neither its
+identity nor the surfaces gathered from its frontmatter. Each shelf therefore states only its surface-specific
+purpose; it must not copy this routing invariant.

package/node_modules/@spexcode/spec-core/dist/anchors.d.ts

@@ -9,8 +9,8 @@ export type Unit = {
 export type Extractor = {
     id: string;
     claims(ext: string): boolean;
-    ready(): true | string;
-    extract(content: string, filename: string): Unit[];
+    ready(): true | string | Promise<true | string>;
+    extract(content: string, filename: string): Unit[] | Promise<Unit[]>;
     memoKey: (filename: string) => string;
 };
 export type CodeEntry = {
@@ -56,6 +56,16 @@ export type LangSpec = {
 export declare function heuristicExtractor(spec: LangSpec): Extractor;
 export declare const JS_LANG_R5B: LangSpec;
 export declare const PYTHON_LANG: LangSpec;
+type TreeSitterNode = any;
+export type TreeSitterLanguageRow = {
+    id: string;
+    extensions: string[];
+    grammar: string;
+    schema: string;
+    units(root: TreeSitterNode): Unit[];
+};
+export declare const TREE_SITTER_ROWS: TreeSitterLanguageRow[];
+export declare function treeSitterExtractor(row: TreeSitterLanguageRow): Extractor;
 export declare function extractors(root: string): Extractor[];
 export declare function extractorFor(regs: Extractor[], ext: string): Extractor | null;
 export declare const extOf: (path: string) => string;
@@ -92,3 +102,4 @@ export type AnchorHitQuery = {
 export declare function anchorHitQueries(root: string, queries: AnchorHitQuery[], regs: Extractor[]): Promise<AnchorHit[][]>;
 export declare function anchorHitExists(root: string, queries: AnchorHitQuery[], regs: Extractor[]): Promise<boolean[]>;
 export declare function anchorHitCommits(root: string, win: DriftPathEvent[], symbols: string[], regs: Extractor[]): Promise<AnchorHit[]>;
+export {};

package/node_modules/@spexcode/spec-core/dist/anchors.js

@@ -1,4 +1,4 @@
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { gitRequiredA, gitObjectFormat, isGitObjectId, batchRevisionOids, batchBlobTexts, combinedDiffOwnedChanges, driftPathWindow, readImmutableHunkFacts, persistImmutableHunkFacts, withEventLedgerBuild } from './git.js';
 const RS = '\x1e';
@@ -50,7 +50,9 @@ export function parseRelation(raws, relation) {
     }
     return { entries: order.map((p) => ({ path: p, selectors: byPath.get(p).selectors })), problems };
 }
-// ---- extractor: ts-ast (the designated extractor for the JS family) ----
+// ---- legacy extractor: ts-ast ----
+// Kept as a public compatibility helper only. The production language registry below routes every shipped
+// language through Tree-sitter WASM and never selects this host-dependent path.
 // Parse-only via the HOST project's own typescript, so the parse matches what the project itself compiles
 // with. If it cannot resolve, ready() returns a loud unverified verdict and lint skips these anchors
 // without crashing (no bundled compiler, regex fallback, or fake pass for JS).
@@ -310,9 +312,7 @@ export function heuristicExtractor(spec) {
         },
     };
 }
-// The validated JS-family reference row (R5b: name precision 99.7% / recall 100% / range 98.9% on the
-// 41-file oracle) — NOT registered for JS (ts-ast is designated); kept as the engine's reference shape
-// and the benchmark's scoring subject.
+// Historical JS-family reference row retained for compatibility callers; not a production registry row.
 export const JS_LANG_R5B = {
     id: 'heuristic-js',
     extensions: [...JS_EXTS],
@@ -330,9 +330,7 @@ export const JS_LANG_R5B = {
     },
     boundary: /^(?:[A-Za-z_$]|\/\/|\/\*)/,
 };
-// Python is a LangSpec DATA row over the same generic engine: declaration names come from patterns;
-// significant indentation supplies lexical qualification and ranges. It is intentionally structural,
-// not a Python runtime or full grammar (the user-facing boundary is documented by [[code-anchor]]).
+// Historical Python row retained for compatibility callers; Tree-sitter owns shipped Python anchors.
 const PY_ID = String.raw `[\p{ID_Start}_][\p{ID_Continue}_]*`;
 export const PYTHON_LANG = {
     id: 'heuristic-python',
@@ -349,15 +347,313 @@ export const PYTHON_LANG = {
     indentScopes: { decorator: /^\s*@/ },
     boundary: /^\S/,
 };
+let treeSitterModulePromise;
+let treeSitterInitPromise;
+const treeSitterLanguagePromises = new Map();
+function treeSitterRuntimePath() {
+    const require = createRequire(import.meta.url);
+    return require.resolve('@vscode/tree-sitter-wasm');
+}
+async function treeSitterModule() {
+    if (!treeSitterModulePromise)
+        treeSitterModulePromise = import(treeSitterRuntimePath()).then((m) => m.default ?? m);
+    return treeSitterModulePromise;
+}
+async function treeSitterLanguage(row) {
+    const existing = treeSitterLanguagePromises.get(row.grammar);
+    if (existing)
+        return existing;
+    const pending = (async () => {
+        const mod = await treeSitterModule();
+        if (!treeSitterInitPromise) {
+            const runtime = dirname(treeSitterRuntimePath());
+            treeSitterInitPromise = mod.Parser.init({ locateFile: (file) => join(runtime, file) }).then(() => mod);
+        }
+        await treeSitterInitPromise;
+        return mod.Language.load(join(dirname(treeSitterRuntimePath()), `tree-sitter-${row.grammar}.wasm`));
+    })();
+    treeSitterLanguagePromises.set(row.grammar, pending);
+    return pending;
+}
+const nodeField = (node, field) => node?.childForFieldName?.(field) ?? null;
+const nodeChildren = (node) => (node?.namedChildren ?? []).filter(Boolean);
+const nodeAllChildren = (node) => (node?.children ?? []).filter(Boolean);
+const nodeText = (node) => node?.text ?? '';
+const treeHasSyntaxError = (root) => {
+    if (root?.hasError)
+        return true;
+    const pending = [root];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node.isError || node.isMissing)
+            return true;
+        pending.push(...nodeAllChildren(node));
+    }
+    return false;
+};
+const nodeLineRange = (node, start = node.startPosition.row + 1, end = node.endPosition.row + 1) => ({ start, end });
+const simpleName = (node) => nodeText(node).replace(/^\s+|\s+$/g, '');
+const lastTypeName = (text) => {
+    const clean = text.replace(/^\s*\(/, '').replace(/\)\s*$/, '').replace(/^\s*[*&]+/, '');
+    const base = clean.split(/[.[\]<>\s]/, 1)[0];
+    return (base.split('.').pop() ?? base).replace(/[^\p{L}\p{N}_$]/gu, '');
+};
+function tsTreeUnits(root) {
+    const units = [];
+    const add = (name, kind, node, typeOnly = false, start) => {
+        if (!name)
+            return;
+        units.push({ name, kind, ...nodeLineRange(node, start), ...(typeOnly ? { typeOnly: true } : {}) });
+    };
+    const methodUnits = (className, body) => {
+        for (const member of nodeChildren(body)) {
+            if (member.type !== 'method_definition' || !nodeField(member, 'body'))
+                continue;
+            const name = nodeText(nodeField(member, 'name')) || nodeText(member.namedChildren?.[0]) || '(computed)';
+            add(`${className}.${name === 'constructor' ? 'constructor' : name}`, 'method', member);
+        }
+    };
+    for (const raw of nodeChildren(root)) {
+        const top = raw.type === 'export_statement' ? nodeChildren(raw) : [raw];
+        for (const node of top) {
+            if (node.type === 'function_declaration')
+                add(nodeText(nodeField(node, 'name')), 'function', node);
+            else if (node.type === 'class_declaration') {
+                const name = nodeText(nodeField(node, 'name'));
+                add(name, 'class', node);
+                methodUnits(name, nodeField(node, 'body'));
+            }
+            else if (node.type === 'lexical_declaration' || node.type === 'variable_declaration') {
+                for (const decl of nodeChildren(node).filter((child) => child.type === 'variable_declarator')) {
+                    const name = nodeText(nodeField(decl, 'name'));
+                    if (!/^[A-Za-z_$][\w$]*$/u.test(name))
+                        continue;
+                    const value = nodeField(decl, 'value');
+                    add(name, value?.type === 'arrow_function' || value?.type === 'function' ? 'const-fn' : 'const-data', node);
+                }
+            }
+            else if (node.type === 'enum_declaration')
+                add(nodeText(nodeField(node, 'name')), 'enum', node);
+            else if (node.type === 'interface_declaration')
+                add(nodeText(nodeField(node, 'name')), 'interface', node, true);
+            else if (node.type === 'type_alias_declaration')
+                add(nodeText(nodeField(node, 'name')), 'type', node, true);
+        }
+    }
+    return units;
+}
+function pythonTreeUnits(root) {
+    const units = [];
+    const definition = (node) => node.type === 'decorated_definition'
+        ? nodeChildren(node).find((child) => child.type === 'function_definition' || child.type === 'class_definition') ?? null
+        : node;
+    const visitContainer = (container, scopes) => {
+        for (const child of nodeChildren(container)) {
+            const inner = definition(child);
+            if (!inner || (inner.type !== 'function_definition' && inner.type !== 'class_definition')) {
+                visitContainer(child, scopes);
+                continue;
+            }
+            const name = nodeText(nodeField(inner, 'name'));
+            const qualified = [...scopes.map((scope) => scope.name), name].filter(Boolean).join('.');
+            const wrapperStart = child.type === 'decorated_definition' ? child.startPosition.row + 1 : undefined;
+            const kind = inner.type === 'class_definition' ? 'class' : (scopes.at(-1)?.classLike ? 'method' : 'function');
+            units.push({ name: qualified, kind, ...nodeLineRange(inner, wrapperStart) });
+            const body = nodeField(inner, 'body');
+            if (body)
+                visitContainer(body, [...scopes, { name, classLike: inner.type === 'class_definition' }]);
+        }
+    };
+    visitContainer(root, []);
+    return units;
+}
+function goTreeUnits(root) {
+    const units = [];
+    for (const node of root.descendantsOfType?.(['const_declaration', 'function_declaration', 'method_declaration', 'type_declaration']) ?? []) {
+        if (node.type === 'const_declaration') {
+            for (const spec of nodeChildren(node).filter((child) => child.type === 'const_spec')) {
+                const name = nodeText(nodeField(spec, 'name')) || nodeText(nodeChildren(spec)[0]);
+                if (name)
+                    units.push({ name, kind: 'const-data', ...nodeLineRange(spec) });
+            }
+        }
+        else if (node.type === 'function_declaration') {
+            units.push({ name: nodeText(nodeField(node, 'name')), kind: 'function', ...nodeLineRange(node) });
+        }
+        else if (node.type === 'method_declaration') {
+            const receiver = nodeField(node, 'receiver');
+            const parameter = nodeChildren(receiver).find((child) => child.type === 'parameter_declaration');
+            const receiverType = nodeField(parameter, 'type') ?? nodeChildren(parameter)[1];
+            const receiverName = lastTypeName(nodeText(receiverType));
+            const methodName = nodeText(nodeField(node, 'name'));
+            units.push({ name: receiverName ? `${receiverName}.${methodName}` : methodName, kind: 'method', ...nodeLineRange(node) });
+        }
+        else {
+            for (const spec of nodeChildren(node).filter((child) => child.type === 'type_spec')) {
+                const name = nodeText(nodeField(spec, 'name')) || nodeText(nodeChildren(spec)[0]);
+                const shape = nodeChildren(spec).find((child) => ['struct_type', 'interface_type'].includes(child.type));
+                const kind = shape?.type === 'struct_type' ? 'struct' : shape?.type === 'interface_type' ? 'interface' : 'type';
+                if (name)
+                    units.push({ name, kind, ...nodeLineRange(spec) });
+            }
+        }
+    }
+    return units;
+}
+function rustImplName(node) {
+    const header = nodeText(node).split('{', 1)[0];
+    const forMatch = header.match(/\bfor\s+([A-Za-z_][\w:]*)/u);
+    if (forMatch)
+        return forMatch[1].split('::').pop() ?? forMatch[1];
+    const names = nodeChildren(node).filter((child) => child.type === 'type_identifier' || child.type === 'scoped_type_identifier');
+    return lastTypeName(nodeText(names[0]));
+}
+function rustTreeUnits(root) {
+    const units = [];
+    for (const node of root.descendantsOfType?.(['const_item', 'function_item', 'struct_item', 'enum_item', 'trait_item']) ?? []) {
+        const name = nodeText(nodeField(node, 'name')) || nodeText(nodeChildren(node).find((child) => child.type === 'type_identifier'));
+        if (!name)
+            continue;
+        const parent = node.parent;
+        let impl = parent;
+        while (impl && impl.type !== 'impl_item' && impl.type !== 'source_file')
+            impl = impl.parent;
+        const implName = impl?.type === 'impl_item' ? rustImplName(impl) : '';
+        const kind = node.type === 'function_item' ? (implName ? 'method' : 'function')
+            : node.type === 'const_item' ? 'const-data'
+                : node.type === 'struct_item' ? 'struct'
+                    : node.type === 'enum_item' ? 'enum' : 'trait';
+        units.push({ name: implName && node.type === 'function_item' ? `${implName}.${name}` : name, kind, ...nodeLineRange(node) });
+    }
+    return units;
+}
+function javaTreeUnits(root) {
+    const units = [];
+    const visitClass = (node, scopes) => {
+        const name = nodeText(nodeField(node, 'name')) || nodeText(nodeChildren(node).find((child) => child.type === 'identifier'));
+        if (!name)
+            return;
+        const qualified = [...scopes, name].join('.');
+        const kind = node.type === 'class_declaration' ? 'class' : node.type === 'interface_declaration' ? 'interface' : 'enum';
+        units.push({ name: qualified, kind, ...nodeLineRange(node) });
+        const body = nodeField(node, 'body');
+        for (const child of nodeChildren(body)) {
+            if (child.type === 'field_declaration' && /\bfinal\b/u.test(nodeText(child))) {
+                for (const variable of nodeChildren(child).filter((part) => part.type === 'variable_declarator')) {
+                    const field = nodeText(nodeField(variable, 'name')) || nodeText(nodeChildren(variable).find((part) => part.type === 'identifier'));
+                    if (field)
+                        units.push({ name: `${qualified}.${field}`, kind: 'const-data', ...nodeLineRange(child) });
+                }
+            }
+            else if (child.type === 'method_declaration' || child.type === 'constructor_declaration') {
+                const method = nodeText(nodeField(child, 'name')) || nodeText(nodeChildren(child).find((part) => part.type === 'identifier'));
+                if (method)
+                    units.push({ name: `${qualified}.${child.type === 'constructor_declaration' ? 'constructor' : method}`, kind: 'method', ...nodeLineRange(child) });
+            }
+            else if (child.type.endsWith('_declaration') && ['class_declaration', 'interface_declaration', 'enum_declaration'].includes(child.type))
+                visitClass(child, [...scopes, name]);
+        }
+    };
+    const walk = (node) => {
+        for (const child of nodeChildren(node)) {
+            if (['class_declaration', 'interface_declaration', 'enum_declaration'].includes(child.type))
+                visitClass(child, []);
+            else
+                walk(child);
+        }
+    };
+    walk(root);
+    return units;
+}
+function rubyTreeUnits(root) {
+    const units = [];
+    const rubyName = (name) => name.replaceAll('::', '.');
+    const nameOf = (node) => rubyName(nodeText(nodeField(node, 'name')) || nodeText(nodeChildren(node).find((child) => ['constant', 'identifier'].includes(child.type))));
+    const visit = (container, scopes) => {
+        for (const child of nodeChildren(container)) {
+            if (child.type === 'class' || child.type === 'module') {
+                const name = nameOf(child);
+                if (!name)
+                    continue;
+                const qualified = [...scopes.map((scope) => scope.name), name].join('.');
+                units.push({ name: qualified, kind: child.type === 'class' ? 'class' : 'module', ...nodeLineRange(child) });
+                visit(nodeField(child, 'body') ?? child, [...scopes, { name, kind: child.type }]);
+            }
+            else if (child.type === 'assignment' && nodeField(child, 'left')?.type === 'constant') {
+                const name = rubyName(nodeText(nodeField(child, 'left')));
+                if (name)
+                    units.push({ name: [...scopes.map((scope) => scope.name), name].join('.'), kind: 'const-data', ...nodeLineRange(child) });
+            }
+            else if (child.type === 'method' || child.type === 'singleton_method') {
+                const name = nameOf(child);
+                if (!name)
+                    continue;
+                const receiver = child.type === 'singleton_method' ? rubyName(nodeText(nodeField(child, 'object'))) : '';
+                const qualified = receiver && receiver !== 'self' ? `${receiver}.${name}` : [...scopes.map((scope) => scope.name), name].join('.');
+                units.push({ name: qualified, kind: child.type === 'singleton_method' || scopes.length ? 'method' : 'function', ...nodeLineRange(child) });
+            }
+            else
+                visit(child, scopes);
+        }
+    };
+    visit(root, []);
+    return units;
+}
+export const TREE_SITTER_ROWS = [
+    { id: 'tree-sitter-typescript', extensions: ['ts', 'mts', 'cts'], grammar: 'typescript', schema: 'ts-v1', units: tsTreeUnits },
+    { id: 'tree-sitter-tsx', extensions: ['tsx'], grammar: 'tsx', schema: 'tsx-v1', units: tsTreeUnits },
+    { id: 'tree-sitter-javascript', extensions: ['js', 'jsx', 'mjs', 'cjs'], grammar: 'javascript', schema: 'js-v1', units: tsTreeUnits },
+    { id: 'tree-sitter-python', extensions: ['py', 'pyi'], grammar: 'python', schema: 'python-v1', units: pythonTreeUnits },
+    { id: 'tree-sitter-go', extensions: ['go'], grammar: 'go', schema: 'go-v1', units: goTreeUnits },
+    { id: 'tree-sitter-rust', extensions: ['rs'], grammar: 'rust', schema: 'rust-v1', units: rustTreeUnits },
+    { id: 'tree-sitter-java', extensions: ['java'], grammar: 'java', schema: 'java-v1', units: javaTreeUnits },
+    { id: 'tree-sitter-ruby', extensions: ['rb'], grammar: 'ruby', schema: 'ruby-v1', units: rubyTreeUnits },
+];
+export function treeSitterExtractor(row) {
+    let readiness;
+    const getLanguage = () => treeSitterLanguage(row);
+    return {
+        id: row.id,
+        claims: (ext) => row.extensions.includes(ext),
+        async ready() {
+            if (readiness !== undefined)
+                return readiness;
+            try {
+                await getLanguage();
+                readiness = true;
+            }
+            catch (error) {
+                readiness = `Tree-sitter extractor '${row.id}' cannot load grammar '${row.grammar}': ${error?.message ?? String(error)} — reinstall SpexCode or remove the #anchor`;
+            }
+            return readiness;
+        },
+        async extract(content, filename) {
+            const language = await getLanguage();
+            const mod = await treeSitterModule();
+            const parser = new mod.Parser().setLanguage(language);
+            let tree;
+            try {
+                tree = parser.parse(content);
+                if (!tree?.rootNode || treeHasSyntaxError(tree.rootNode))
+                    throw new Error(`${filename} has Tree-sitter syntax errors`);
+                return row.units(tree.rootNode);
+            }
+            finally {
+                tree?.delete?.();
+                parser.delete?.();
+            }
+        },
+        memoKey(filename) { return JSON.stringify({ schema: 'tree-sitter-wasm-v1', row: row.id, grammar: row.grammar, rowSchema: row.schema, filename }); },
+    };
+}
 // ---- registry: extension -> its ONE designated extractor ----
-// The registry's shape is the Extractor INTERFACE, not any engine: a future language row may be a
-// heuristicExtractor(LangSpec) or a web-tree-sitter extractor carrying its own wasm-grammar/query
-// config — whatever the implementation needs rides inside its own factory, never in the registry.
+// The registry is one Tree-sitter language adapter: every shipped extension is a grammar DATA row.
 export function extractors(root) {
-    return [tsAstExtractor(root), ...[PYTHON_LANG].map(heuristicExtractor)];
+    void root;
+    return TREE_SITTER_ROWS.map(treeSitterExtractor);
 }
 // first claiming extractor IS the designation (the registry order defines it); null = no anchor support
-// for this language yet (lint ERRORS — the remedy is a LangSpec data row, or dropping the anchor).
+// for this language yet (lint ERRORS — the remedy is a Tree-sitter language row, or dropping the anchor).
 export function extractorFor(regs, ext) {
     return regs.find((x) => x.claims(ext)) ?? null;
 }
@@ -417,7 +713,7 @@ async function unitsAtFileRevision(commit, path, x, objectFormat, oid, text) {
         throw new Error(`git cat-file --batch omitted object ${oid} for ${commit}:${path}`);
     let result;
     try {
-        result = { units: x.extract(text, path) };
+        result = { units: await x.extract(text, path) };
     }
     catch (e) {
         result = { unparseable: e?.message ?? String(e) };
@@ -626,7 +922,7 @@ async function runAnchorQueriesInLedger(root, queries, regs, stopAtFirstHit) {
                 continue;
             const ref = revisions.get(key), oid = oidByRef.get(key) ?? null;
             const x = extractorFor(regs, extOf(ref.path));
-            const ready = x?.ready();
+            const ready = x ? await x.ready() : undefined;
             if (!x || ready !== true) {
                 units.set(key, { unparseable: !x ? `no designated extractor for ${ref.path}` : String(ready) });
                 continue;

package/node_modules/@spexcode/spec-core/dist/git.d.ts

@@ -153,6 +153,10 @@ export type ReviewDiffFile = {
     additions: number;
     deletions: number;
 };
+export declare function parseStatPath(token: string): {
+    from: string;
+    to: string;
+};
 export declare function mergeBaseDiff(wtPath: string, mainRef?: string, headRef?: string): Promise<ReviewDiffFile[]>;
 export declare function mergeConflicts(wtPath: string, mainRef?: string, headRef?: string): Promise<boolean>;
 type WorktreeSpecDemand = {

package/node_modules/@spexcode/spec-core/dist/git.js

@@ -230,15 +230,15 @@ export async function batchRevisionOids(root, revisions, options = {}) {
     });
 }
 export async function batchBlobTexts(root, oids) {
-    const unique = [...new Set(oids.filter(Boolean))];
+    const objectIds = [...new Set(oids.filter(Boolean))];
     const files = new Map();
-    if (!unique.length)
+    if (!objectIds.length)
         return files;
-    for (const oid of unique)
+    for (const oid of objectIds)
         if (!isGitObjectId(root, oid))
             throw new Error(`invalid object id '${oid}'`);
-    for (let cursor = 0; cursor < unique.length; cursor += BATCH_BLOB_CHUNK) {
-        const chunk = unique.slice(cursor, cursor + BATCH_BLOB_CHUNK);
+    for (let cursor = 0; cursor < objectIds.length; cursor += BATCH_BLOB_CHUNK) {
+        const chunk = objectIds.slice(cursor, cursor + BATCH_BLOB_CHUNK);
         const out = await batchBuffer(['-C', root, 'cat-file', '--batch'], chunk.join('\n') + '\n', BATCH_BLOB_MAX_BUFFER);
         let offset = 0;
         for (const oid of chunk) {
@@ -1609,12 +1609,12 @@ function canonicalPathProjector(renamesByFrom, topology) {
                 continue;
             }
             seen.add(candidate);
-            const unique = new Map();
+            const applicableByIdentity = new Map();
             for (const rename of renamesByFrom.get(candidate) ?? []) {
                 if (!precedes(rename.hash, event))
-                    unique.set(`${rename.hash}\0${rename.to}`, rename);
+                    applicableByIdentity.set(`${rename.hash}\0${rename.to}`, rename);
             }
-            const applicable = [...unique.values()];
+            const applicable = [...applicableByIdentity.values()];
             if (!applicable.length) {
                 resolved.add(candidate);
                 continue;
@@ -2531,7 +2531,7 @@ function parseNameStatus(out) {
     return rows;
 }
 const DIFF_STATUS = { A: 'added', M: 'modified', D: 'deleted', R: 'renamed', C: 'copied', T: 'type-changed' };
-function parseStatPath(token) {
+export function parseStatPath(token) {
     const b = token.indexOf('{'), arrow = token.indexOf(' => ', b), close = token.indexOf('}', arrow);
     if (b >= 0 && arrow > b && close > arrow) {
         const pre = token.slice(0, b), post = token.slice(close + 1);