knodin 0.5.0 → 0.6.0

package/dist/src/init.js

@@ -5,7 +5,6 @@ import { configureProjectAgents, } from "./agent-integration.js";
 import { isIndexableSourcePath } from "./engine/source-policy.js";
 import { registerInitializedWorktree } from "./worktree-lifecycle.js";
 const MANAGED_MARKER = "KNODIN MANAGED HOOK";
-const LEGACY_MANAGED_MARKER = "RECKON-GRAPH MANAGED HOOK";
 const HOOK_NAMES = ["post-commit", "post-checkout", "post-merge", "post-rewrite"];
 const HOOK_LOG_MAX_BYTES = 1_048_576;
 const HOOK_FAILURE_FILE = "last-refresh-failure";
@@ -78,14 +77,14 @@ export async function refreshFromGitEvent(repo, event, index) {
             changed = diffPaths(resolvedRepo, event.before, event.after);
         }
         else {
-            const hooksRoot = path.join(resolvedRepo, ".reckon", "hooks");
+            const hooksRoot = path.join(resolvedRepo, ".knodin", "hooks");
             const inputPath = path.resolve(event.inputPath);
             const relativeInput = path.relative(hooksRoot, inputPath);
             if (relativeInput === "" ||
                 relativeInput === ".." ||
                 relativeInput.startsWith(`..${path.sep}`) ||
                 path.isAbsolute(relativeInput)) {
-                throw new Error("knodin hook refresh: rewrite input must be inside .reckon/hooks");
+                throw new Error("knodin hook refresh: rewrite input must be inside .knodin/hooks");
             }
             const [realHooksRoot, realInputPath, inputStat] = await Promise.all([
                 fs.promises.realpath(hooksRoot),
@@ -99,7 +98,7 @@ export async function refreshFromGitEvent(repo, event, index) {
                 realRelativeInput === ".." ||
                 realRelativeInput.startsWith(`..${path.sep}`) ||
                 path.isAbsolute(realRelativeInput)) {
-                throw new Error("knodin hook refresh: rewrite input must be a regular file inside .reckon/hooks");
+                throw new Error("knodin hook refresh: rewrite input must be a regular file inside .knodin/hooks");
             }
             rewriteInputToRemove = inputPath;
             const pairs = (await fs.promises.readFile(inputPath, "utf-8"))
@@ -130,11 +129,11 @@ set -u
 REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
 [ -n "$REPO_ROOT" ] || exit 0
 cd "$REPO_ROOT" || exit 0
-mkdir -p "$REPO_ROOT/.reckon"
-LOCK_DIR="$REPO_ROOT/.reckon/hooks/refresh.lock"
-EVENT_DIR="$REPO_ROOT/.reckon/hooks/events"
-LAST_EVENT_PATH="$REPO_ROOT/.reckon/hooks/last-refresh-event"
-FAILURE_PATH="$REPO_ROOT/.reckon/hooks/${HOOK_FAILURE_FILE}"
+mkdir -p "$REPO_ROOT/.knodin"
+LOCK_DIR="$REPO_ROOT/.knodin/hooks/refresh.lock"
+EVENT_DIR="$REPO_ROOT/.knodin/hooks/events"
+LAST_EVENT_PATH="$REPO_ROOT/.knodin/hooks/last-refresh-event"
+FAILURE_PATH="$REPO_ROOT/.knodin/hooks/${HOOK_FAILURE_FILE}"
 FAILURE_TMP="$FAILURE_PATH.$$"
 mkdir -p "$EVENT_DIR"
 if [ "$#" -gt 0 ]; then
@@ -165,7 +164,7 @@ if ! mkdir "$LOCK_DIR" 2>/dev/null; then
 fi
 printf '%s\\n' "$$" > "$LOCK_DIR/pid"
 trap 'rm -rf "$LOCK_DIR"; rm -f "$FAILURE_TMP"' EXIT HUP INT TERM
-LOG_PATH="$REPO_ROOT/.reckon/indexer.log"
+LOG_PATH="$REPO_ROOT/.knodin/indexer.log"
 if [ -f "$LOG_PATH" ]; then
   LOG_BYTES="$(wc -c < "$LOG_PATH" 2>/dev/null | tr -d '[:space:]')"
   case "$LOG_BYTES" in ''|*[!0-9]*) LOG_BYTES=0 ;; esac
@@ -197,7 +196,7 @@ while :; do
     {
       printf 'knodin background refresh failed with exit code %s.\\n' "$STATUS"
       printf 'Pending event retained at %s.\\n' "$EVENT"
-      printf 'See .reckon/indexer.log for details.\\n'
+      printf 'See .knodin/indexer.log for details.\\n'
     } > "$FAILURE_TMP"
     mv -f "$FAILURE_TMP" "$FAILURE_PATH"
     exit "$STATUS"
@@ -206,7 +205,7 @@ done
 `;
 }
 function queuedLifecycleEvents(repo) {
-    const eventDirectory = path.join(repo, ".reckon", "hooks", "events");
+    const eventDirectory = path.join(repo, ".knodin", "hooks", "events");
     try {
         return fs.readdirSync(eventDirectory).filter((entry) => entry.endsWith(".event"));
     }
@@ -216,7 +215,7 @@ function queuedLifecycleEvents(repo) {
 }
 function refreshProcessorIsRunning(repo) {
     try {
-        const pid = Number(fs.readFileSync(path.join(repo, ".reckon", "hooks", "refresh.lock", "pid"), "utf-8"));
+        const pid = Number(fs.readFileSync(path.join(repo, ".knodin", "hooks", "refresh.lock", "pid"), "utf-8"));
         if (!Number.isInteger(pid) || pid <= 0)
             return false;
         process.kill(pid, 0);
@@ -238,7 +237,7 @@ function drainQueuedLifecycleEvents(repo, backgroundPath) {
     });
     if (result.status !== 0) {
         const detail = result.error?.message || result.stderr.trim() || `exit ${result.status ?? "unknown"}`;
-        throw new Error(`knodin init: queued lifecycle refresh could not be drained (${detail}); run ${backgroundPath} after resolving .reckon/hooks/last-refresh-failure`);
+        throw new Error(`knodin init: queued lifecycle refresh could not be drained (${detail}); run ${backgroundPath} after resolving .knodin/hooks/last-refresh-failure`);
     }
     const remaining = queuedLifecycleEvents(repo);
     if (remaining.length === 0)
@@ -279,7 +278,7 @@ AFTER="$(git rev-parse HEAD 2>/dev/null || true)"
         ? `if [ ! -x "$BACKGROUND" ]; then
   ${rewriteWithoutIndexer}
 fi
-REWRITE_INPUT="$(mktemp "$REPO_ROOT/.reckon/hooks/rewrite-input.XXXXXX")" || exit 0
+REWRITE_INPUT="$(mktemp "$REPO_ROOT/.knodin/hooks/rewrite-input.XXXXXX")" || exit 0
 cat > "$REWRITE_INPUT"
 `
         : "";
@@ -289,7 +288,7 @@ cat > "$REWRITE_INPUT"
 # ${MANAGED_MARKER}: ${hookName}
 REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
 [ -n "$REPO_ROOT" ] || exit 0
-BACKGROUND="$REPO_ROOT/.reckon/hooks/background-index.sh"
+BACKGROUND="$REPO_ROOT/.knodin/hooks/background-index.sh"
 ORIGINAL_STATUS=0
 trigger_knodin() {
   [ -x "$BACKGROUND" ] || return 0
@@ -304,7 +303,7 @@ trigger_knodin() {
     EVENT_BEFORE="$(sed -n '1{s/ .*//;p;}' "$2")"
     EVENT_AFTER="$(sed -n '1{s/^[^ ]* //;s/ .*//;p;}' "$2")"
   fi
-  EVENT_DIR="$REPO_ROOT/.reckon/hooks/events"
+  EVENT_DIR="$REPO_ROOT/.knodin/hooks/events"
   mkdir -p "$EVENT_DIR" || return 0
   EVENT_TMP="$EVENT_DIR/$(date +%s).$$.$PPID.tmp"
   EVENT_PATH="$EVENT_TMP.event"
@@ -319,7 +318,7 @@ trigger_knodin() {
       "$EVENT_SEQUENCE" "$EVENT_WORKTREE" "$EVENT_AT" "$EVENT_BEFORE" "$EVENT_AFTER"
   } > "$EVENT_TMP" || return 0
   mv "$EVENT_TMP" "$EVENT_PATH" || return 0
-  if [ "\${RECKON_HOOK_FOREGROUND:-0}" = "1" ]; then
+  if [ "\${KNODIN_HOOK_FOREGROUND:-0}" = "1" ]; then
     "$BACKGROUND"
   else
     nohup "$BACKGROUND" >/dev/null 2>&1 &
@@ -346,13 +345,12 @@ async function installManagedHook(hooksDir, hookName, preservedOriginal = undefi
     let originalPath = preservedOriginal ?? null;
     if (preservedOriginal === undefined && fs.existsSync(hookPath)) {
         const content = await fs.promises.readFile(hookPath, "utf-8");
-        if (content.startsWith(`#!/bin/sh\n# ${MANAGED_MARKER}: ${hookName}\n`) ||
-            content.startsWith(`#!/bin/sh\n# ${LEGACY_MANAGED_MARKER}: ${hookName}\n`)) {
+        if (content.startsWith(`#!/bin/sh\n# ${MANAGED_MARKER}: ${hookName}\n`)) {
             const match = content.match(/^# knodin original: (.+)$/m);
             originalPath = match?.[1] ?? null;
         }
         else {
-            const backupPath = `${hookPath}.reckon-original`;
+            const backupPath = `${hookPath}.knodin-original`;
             const mode = (await fs.promises.stat(hookPath)).mode;
             await fs.promises.copyFile(hookPath, backupPath);
             await fs.promises.rm(hookPath, { force: true });
@@ -365,9 +363,7 @@ async function installManagedHook(hooksDir, hookName, preservedOriginal = undefi
                 if (!fs.existsSync(candidate))
                     break;
                 const candidateContent = await fs.promises.readFile(candidate, "utf-8");
-                if (candidateContent === canonical ||
-                    candidateContent.includes(MANAGED_MARKER) ||
-                    candidateContent.includes(LEGACY_MANAGED_MARKER))
+                if (candidateContent === canonical || candidateContent.includes(MANAGED_MARKER))
                     await fs.promises.rm(candidate, { force: true });
             }
             // Match Git's semantics: preserve inactive hook files as backups, but
@@ -388,7 +384,6 @@ async function installManagedHook(hooksDir, hookName, preservedOriginal = undefi
     await fs.promises.chmod(hookPath, 0o755);
 }
 const ORIGINAL_HOOKS_CONFIG = "knodin.originalHooksPath";
-const LEGACY_ORIGINAL_HOOKS_CONFIG = "reckon.originalHooksPath";
 function effectiveHooksDirectory(repo) {
     let raw;
     try {
@@ -405,15 +400,10 @@ function configuredHooksPath(repo) {
     }
     catch {
         try {
-            return (runGit(repo, ["config", "--local", "--get", LEGACY_ORIGINAL_HOOKS_CONFIG]).trim() || null);
+            return runGit(repo, ["config", "--local", "--get", "core.hooksPath"]).trim() || null;
         }
         catch {
-            try {
-                return runGit(repo, ["config", "--local", "--get", "core.hooksPath"]).trim() || null;
-            }
-            catch {
-                return null;
-            }
+            return null;
         }
     }
 }
@@ -494,7 +484,7 @@ export const SETTINGS_TEMPLATE = `{
   }
 }
 `;
-const RECKON_AGENT_INSTRUCTIONS = `<!-- knodin:start -->
+const KNODIN_AGENT_INSTRUCTIONS = `<!-- knodin:start -->
 ## knodin — Local Code Intelligence
 
 This repository is indexed locally by knodin. Start with \`knodin status\`; if it reports \`repair-needed\`, run \`knodin repair\` before relying on graph evidence.
@@ -540,24 +530,19 @@ async function installManagedAgentInstructions(repo, fileName = "AGENTS.md") {
     }
     const canonicalStart = "<!-- knodin:start -->";
     const canonicalEnd = "<!-- knodin:end -->";
-    const legacyStart = "<!-- reckon-graph:start -->";
-    const legacyEnd = "<!-- reckon-graph:end -->";
-    const usesCanonical = existing.includes(canonicalStart);
-    const startMarker = usesCanonical ? canonicalStart : legacyStart;
-    const endMarker = usesCanonical ? canonicalEnd : legacyEnd;
-    const start = existing.indexOf(startMarker);
-    const end = existing.indexOf(endMarker);
+    const start = existing.indexOf(canonicalStart);
+    const end = existing.indexOf(canonicalEnd);
     const next = start >= 0 && end >= start
-        ? `${existing.slice(0, start)}${RECKON_AGENT_INSTRUCTIONS}${existing.slice(end + endMarker.length).replace(/^\r?\n/, "")}`
+        ? `${existing.slice(0, start)}${KNODIN_AGENT_INSTRUCTIONS}${existing.slice(end + canonicalEnd.length).replace(/^\r?\n/, "")}`
         : existing.length > 0
-            ? `${existing.replace(/\s*$/, "")}\n\n${RECKON_AGENT_INSTRUCTIONS}`
-            : RECKON_AGENT_INSTRUCTIONS;
+            ? `${existing.trimEnd()}\n\n${KNODIN_AGENT_INSTRUCTIONS}`
+            : KNODIN_AGENT_INSTRUCTIONS;
     if (next !== existing)
         await fs.promises.writeFile(instructionsPath, next, "utf-8");
 }
 async function hasManagedAgentInstructions(repo, fileName = "AGENTS.md") {
     try {
-        return (await fs.promises.readFile(path.join(repo, fileName), "utf-8")).includes(RECKON_AGENT_INSTRUCTIONS);
+        return (await fs.promises.readFile(path.join(repo, fileName), "utf-8")).includes(KNODIN_AGENT_INSTRUCTIONS);
     }
     catch {
         return false;
@@ -589,9 +574,7 @@ async function excludeUntrackedPaths(repo, candidates) {
     }
     const startMarker = "# knodin:start";
     const endMarker = "# knodin:end";
-    const outside = existing
-        .replace(/(?:^|\n)# knodin:start\n[\s\S]*?\n# knodin:end\n?/, "\n")
-        .replace(/(?:^|\n)# reckon-graph:start\n[\s\S]*?\n# reckon-graph:end\n?/, "\n");
+    const outside = existing.replace(/(?:^|\n)# knodin:start\n[\s\S]*?\n# knodin:end\n?/, "\n");
     const outsideLines = new Set(outside.split(/\r?\n/));
     const owned = safe.filter((candidate) => !outsideLines.has(candidate));
     const prefix = outside && !outside.endsWith("\n") ? `${outside}\n` : outside;
@@ -666,7 +649,7 @@ async function removeManagedPersonalArtifacts(repo, allowTrackedTransition = fal
     try {
         const current = await fs.promises.readFile(gitIgnorePath, "utf-8");
         const next = current
-            .replace(/(?:^|\n)# knodin:start\n\.reckon\/\n# knodin:end\n?/g, "\n")
+            .replace(/(?:^|\n)# knodin:start\n\.knodin\/\n# knodin:end\n?/g, "\n")
             .trim();
         if (isTracked(repo, ".gitignore")) {
             const head = runGit(repo, ["show", "HEAD:.gitignore"]);
@@ -702,7 +685,7 @@ async function removeManagedPersonalArtifacts(repo, allowTrackedTransition = fal
 }
 export function readRepositoryIntegrationConfig(repo) {
     try {
-        const value = JSON.parse(fs.readFileSync(path.join(repo, ".reckon", "integration.json"), "utf-8"));
+        const value = JSON.parse(fs.readFileSync(path.join(repo, ".knodin", "integration.json"), "utf-8"));
         if ((value.scope === "personal" || value.scope === "team" || value.scope === "cli-only") &&
             Array.isArray(value.agents))
             return { scope: value.scope, agents: value.agents };
@@ -745,10 +728,10 @@ export function inspectRepositoryIntegrationStatus(repo) {
     };
 }
 async function writeRepositoryIntegrationConfig(repo, config) {
-    await fs.promises.writeFile(path.join(repo, ".reckon", "integration.json"), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    await fs.promises.writeFile(path.join(repo, ".knodin", "integration.json"), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
 }
 async function ensureTeamGitIgnore(repo) {
-    if (isTracked(repo, ".reckon"))
+    if (isTracked(repo, ".knodin"))
         return;
     await assertSafeRepositoryFile(repo, ".gitignore");
     const ignorePath = path.join(repo, ".gitignore");
@@ -760,10 +743,10 @@ async function ensureTeamGitIgnore(repo) {
         if (error.code !== "ENOENT")
             throw error;
     }
-    if (existing.split(/\r?\n/).includes(".reckon/"))
+    if (existing.split(/\r?\n/).includes(".knodin/"))
         return;
     const prefix = existing && !existing.endsWith("\n") ? `${existing}\n` : existing;
-    await fs.promises.writeFile(ignorePath, `${prefix}# knodin:start\n.reckon/\n# knodin:end\n`, "utf-8");
+    await fs.promises.writeFile(ignorePath, `${prefix}# knodin:start\n.knodin/\n# knodin:end\n`, "utf-8");
 }
 export function detectTrackedTeamIntegration(repo) {
     const checks = [
@@ -802,7 +785,7 @@ export async function initializeRepository(repo, options) {
         detectTrackedTeamIntegration(resolvedRepo)) {
         throw new Error("knodin init: tracked team integration is active; use `knodin configure --scope personal` or `--scope cli-only` for an explicit commit-ready transition");
     }
-    const knodinHooksDir = path.join(resolvedRepo, ".reckon", "hooks");
+    const knodinHooksDir = path.join(resolvedRepo, ".knodin", "hooks");
     const hookInstallation = await prepareHookInstallation(resolvedRepo);
     const hooksDir = hookInstallation.hooksDir;
     await Promise.all([
@@ -908,15 +891,15 @@ export async function initializeRepository(repo, options) {
     const excluded = scope === "team"
         ? []
         : await excludeUntrackedPaths(resolvedRepo, [
-            ...(isTracked(resolvedRepo, ".reckon") ? [] : [".reckon/"]),
+            ...(isTracked(resolvedRepo, ".knodin") ? [] : [".knodin/"]),
             ...agentIntegration.projectFiles,
         ]);
     registerInitializedWorktree(resolvedRepo);
     return {
         scope,
-        knodin: ".reckon",
-        database: ".reckon/db.sqlite",
-        backgroundIndexer: ".reckon/hooks/background-index.sh",
+        knodin: ".knodin",
+        database: ".knodin/db.sqlite",
+        backgroundIndexer: ".knodin/hooks/background-index.sh",
         hooksDirectory: path.relative(resolvedRepo, hooksDir) || ".",
         gitHooks: [...HOOK_NAMES],
         claudeSettings: null,
@@ -979,7 +962,7 @@ export async function isRepositoryInitializationCurrent(repo, command, scope = "
         ((await hasManagedAgentInstructions(resolvedRepo, "AGENTS.md")) &&
             (await hasManagedAgentInstructions(resolvedRepo, "GEMINI.md")));
     const integrationCurrent = readRepositoryIntegrationConfig(resolvedRepo)?.scope === scope;
-    return ((await matchesManagedFile(path.join(resolvedRepo, ".reckon", "hooks", "background-index.sh"), backgroundScript(command), true)) &&
+    return ((await matchesManagedFile(path.join(resolvedRepo, ".knodin", "hooks", "background-index.sh"), backgroundScript(command), true)) &&
         sharedFilesCurrent &&
         integrationCurrent);
 }

package/dist/src/lifecycle-health.js

@@ -1,7 +1,7 @@
 import childProcess from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-const MANAGED_MARKERS = ["KNODIN MANAGED HOOK", "RECKON-GRAPH MANAGED HOOK"];
+const MANAGED_MARKER = "KNODIN MANAGED HOOK";
 const HOOK_NAMES = ["post-commit", "post-checkout", "post-merge", "post-rewrite"];
 const HOOK_FAILURE_FILE = "last-refresh-failure";
 function readEvent(target) {
@@ -35,11 +35,11 @@ function readEvent(target) {
     }
 }
 function readLastEvent(repo) {
-    return readEvent(path.join(repo, ".reckon", "hooks", "last-refresh-event"));
+    return readEvent(path.join(repo, ".knodin", "hooks", "last-refresh-event"));
 }
 function readPendingEvent(repo) {
     try {
-        const directory = path.join(repo, ".reckon", "hooks", "events");
+        const directory = path.join(repo, ".knodin", "hooks", "events");
         const next = fs
             .readdirSync(directory)
             .filter((entry) => entry.endsWith(".event"))
@@ -51,7 +51,7 @@ function readPendingEvent(repo) {
     }
 }
 function processorState(repo) {
-    const pidPath = path.join(repo, ".reckon", "hooks", "refresh.lock", "pid");
+    const pidPath = path.join(repo, ".knodin", "hooks", "refresh.lock", "pid");
     if (!fs.existsSync(path.dirname(pidPath)))
         return { state: "idle", pid: null };
     let pid = null;
@@ -78,7 +78,7 @@ function processorState(repo) {
 function queuedEventCount(repo) {
     try {
         return fs
-            .readdirSync(path.join(repo, ".reckon", "hooks", "events"))
+            .readdirSync(path.join(repo, ".knodin", "hooks", "events"))
             .filter((entry) => entry.endsWith(".event")).length;
     }
     catch {
@@ -97,8 +97,7 @@ function inspectManagedHooks(hooksDirectory) {
             const hookPath = path.join(hooksDirectory, hookName);
             const content = fs.readFileSync(hookPath, "utf-8");
             const mode = fs.statSync(hookPath).mode;
-            const active = (mode & 0o111) !== 0 &&
-                MANAGED_MARKERS.some((marker) => content.startsWith(`#!/bin/sh\n# ${marker}: ${hookName}\n`));
+            const active = (mode & 0o111) !== 0 && content.startsWith(`#!/bin/sh\n# ${MANAGED_MARKER}: ${hookName}\n`);
             (active ? activeHooks : missingHooks).push(hookName);
         }
         catch {
@@ -108,7 +107,7 @@ function inspectManagedHooks(hooksDirectory) {
     return { activeHooks, missingHooks };
 }
 function readRefreshFailure(repo) {
-    const failurePath = path.join(repo, ".reckon", "hooks", HOOK_FAILURE_FILE);
+    const failurePath = path.join(repo, ".knodin", "hooks", HOOK_FAILURE_FILE);
     if (!fs.existsSync(failurePath))
         return null;
     try {
@@ -122,7 +121,7 @@ function readRefreshFailure(repo) {
 /** Read-only proof that committed Git activity can still reach knodin's indexer. */
 export function inspectLifecycleHealth(repoPath) {
     const repo = path.resolve(repoPath);
-    if (!fs.existsSync(path.join(repo, ".reckon", "db.sqlite"))) {
+    if (!fs.existsSync(path.join(repo, ".knodin", "db.sqlite"))) {
         return {
             status: "unconfigured",
             refreshCapable: false,
@@ -157,14 +156,14 @@ export function inspectLifecycleHealth(repoPath) {
         };
     }
     const { activeHooks, missingHooks } = inspectManagedHooks(hooksDirectory);
-    const background = path.join(repo, ".reckon", "hooks", "background-index.sh");
+    const background = path.join(repo, ".knodin", "hooks", "background-index.sh");
     const backgroundReady = fs.existsSync(background) && (fs.statSync(background).mode & 0o111) !== 0;
     const issues = missingHooks.map((hook) => `${hook} no longer routes through knodin's active Git hook path`);
     if (!backgroundReady)
         issues.push("background indexer is missing or not executable");
     const lastError = readRefreshFailure(repo);
     if (lastError)
-        issues.push(`${lastError} See .reckon/indexer.log for details`);
+        issues.push(`${lastError} See .knodin/indexer.log for details`);
     const refreshCapable = missingHooks.length === 0 && backgroundReady && issues.length === 0;
     return {
         status: refreshCapable ? "healthy" : "degraded",

package/dist/src/lsp-readonly.js

@@ -59,7 +59,7 @@ function filesForService(repoPath, ts) {
     const files = [];
     const visit = (directory) => {
         for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".reckon")
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".knodin")
                 continue;
             const candidate = path.join(directory, entry.name);
             if (entry.isDirectory())

package/dist/src/output-compression.js

@@ -335,7 +335,7 @@ function percentReduction(input, output) {
 }
 function artifactDirectory(repo) {
     const resolvedRepo = fs.realpathSync(repo);
-    const knodinDirectory = path.join(resolvedRepo, ".reckon");
+    const knodinDirectory = path.join(resolvedRepo, ".knodin");
     const outputDirectory = path.join(knodinDirectory, "output");
     for (const candidate of [knodinDirectory, outputDirectory]) {
         if (fs.existsSync(candidate) && fs.lstatSync(candidate).isSymbolicLink())

package/dist/src/output-telemetry.js

@@ -5,7 +5,7 @@ import { encode } from "gpt-tokenizer/encoding/o200k_base";
 export const TELEMETRY_TOKENIZER = "gpt-tokenizer@3.4.0:o200k_base";
 export const countOutputTokens = (value) => encode(value).length;
 export const DEFAULT_TELEMETRY_RETENTION_DAYS = 30;
-const DEFAULT_INPUT = ".reckon-telemetry.jsonl";
+const DEFAULT_INPUT = ".knodin-telemetry.jsonl";
 function lineCount(value) {
     return value.length === 0 ? 0 : value.split(/\r?\n/).length;
 }
@@ -104,7 +104,7 @@ export function measureOutput(options) {
     const availability = options.output.availability;
     const freshness = options.output.freshness;
     const fidelity = options.output.fidelity;
-    const database = path.join(fs.realpathSync(options.repo), ".reckon", "db.sqlite");
+    const database = path.join(fs.realpathSync(options.repo), ".knodin", "db.sqlite");
     const latencyMs = Math.round((performance.now() - options.startedAt) * 100) / 100;
     const outcome = (status !== undefined &&
         ["error", "failed", "unavailable", "blocked", "timeout"].includes(status)) ||
@@ -180,7 +180,7 @@ function telemetrySummary(records) {
         indexingMs: records.reduce((sum, record) => sum + (record.indexingMs ?? 0), 0),
     };
 }
-export function writeTelemetryReport(repoPath, records, outputPath = ".reckon/telemetry-report.html") {
+export function writeTelemetryReport(repoPath, records, outputPath = ".knodin/telemetry-report.html") {
     const { repo, target: output } = privatePath(repoPath, outputPath, "report");
     const groups = new Map();
     for (const record of records) {
@@ -326,7 +326,7 @@ export function telemetryStatus(repoPath, inputPath = DEFAULT_INPUT, retentionDa
         tokenizer: TELEMETRY_TOKENIZER,
     };
 }
-export function exportTelemetry(repoPath, records, outputPath = ".reckon/telemetry-export.json") {
+export function exportTelemetry(repoPath, records, outputPath = ".knodin/telemetry-export.json") {
     const { repo, target } = privatePath(repoPath, outputPath, "export");
     const bundle = {
         schemaVersion: 1,

package/dist/src/pr-triage.js

@@ -12,10 +12,10 @@
  * than `ensureGhAvailable()` (throwing, still used by the CLI's hard-fail).
  */
 import child_process from "node:child_process";
-/** Resolve the `gh` binary to invoke. Tests override via `RECKON_GH_BIN` to
+/** Resolve the `gh` binary to invoke. Tests override via `KNODIN_GH_BIN` to
  * point at a stub script fixture — no network in tests. */
 function ghBin() {
-    return process.env.RECKON_GH_BIN || "gh";
+    return process.env.KNODIN_GH_BIN || "gh";
 }
 const STALE_DAYS = 30;
 const PR_LIST_FIELDS = "number,title,updatedAt,reviewDecision,statusCheckRollup,files,headRefName";

package/dist/src/repair-progress-worker.js

@@ -3,7 +3,7 @@ import { clearLine as clearTerminalLine, moveCursor as moveTerminalCursor, curso
 import ora from "ora";
 import { normalizeTerminalDimension } from "./init-progress.js";
 import { formatRepairProgress } from "./repair-progress.js";
-const terminalEnabled = process.stderr.isTTY === true || process.env.RECKON_FORCE_PROGRESS_TTY === "1";
+const terminalEnabled = process.stderr.isTTY === true || process.env.KNODIN_FORCE_PROGRESS_TTY === "1";
 const progressStream = {
     isTTY: terminalEnabled,
     columns: normalizeTerminalDimension(process.stderr.columns, 80),

package/dist/src/repository-init-process.js

@@ -68,7 +68,7 @@ export async function runRepositoryInitializationProcess(options) {
             detached: process.platform !== "win32",
             env: {
                 ...process.env,
-                RECKON_INTERNAL_INIT_MEMORY_LIMIT_BYTES: String(memoryLimitBytes),
+                KNODIN_INTERNAL_INIT_MEMORY_LIMIT_BYTES: String(memoryLimitBytes),
             },
             stdio: ["ignore", "ignore", "pipe", "ipc"],
         });

package/dist/src/repository-management.js

@@ -10,7 +10,7 @@ const MAX_DEPTH = 32;
 const MAX_GIT_ERROR_BYTES = 16 * 1024;
 const MAX_TRACKED_PATH_BYTES = 1024 * 1024;
 const MAX_DOCUMENT_CANDIDATES = 20;
-const SKIPPED_DIRECTORIES = new Set([".git", ".reckon", "node_modules"]);
+const SKIPPED_DIRECTORIES = new Set([".git", ".knodin", "node_modules"]);
 function gitTopLevel(directory) {
     return child_process
         .execFileSync(gitExecutable(), ["rev-parse", "--show-toplevel"], {
@@ -650,7 +650,7 @@ function inventoryFreshness(lastIndexedHead, head) {
 export async function inventoryRepository(record, options) {
     const id = repositoryIdentity(record.path);
     const mainWorktreeId = repositoryIdentity(record.mainWorktree);
-    const databaseExists = fs.existsSync(path.join(record.path, ".reckon", "db.sqlite"));
+    const databaseExists = fs.existsSync(path.join(record.path, ".knodin", "db.sqlite"));
     const head = gitValue(record.path, ["rev-parse", "HEAD"]);
     let tracked;
     try {
@@ -946,7 +946,7 @@ async function initializeOneRepository(repository, options) {
         if (!options.dryRun && options.isolatedInitialize) {
             return await options.isolatedInitialize(repository);
         }
-        const databaseExists = fs.existsSync(path.join(repository, ".reckon", "db.sqlite"));
+        const databaseExists = fs.existsSync(path.join(repository, ".knodin", "db.sqlite"));
         const integration = readRepositoryIntegrationConfig(repository);
         const scope = integration?.scope ?? "personal";
         const agents = [...new Set([...(options.agents ?? []), ...(integration?.agents ?? [])])];

package/dist/src/server.js

@@ -23,7 +23,7 @@ export function createServer() {
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
-        if (name !== "knodin" && name !== "reckon") {
+        if (name !== "knodin") {
             throw new Error(`unknown tool: ${name}`);
         }
         const result = await handleKnodinTool(args);

package/dist/src/system-config.js

@@ -78,7 +78,7 @@ function configuredRepository(value, index) {
         id: stringValue(record.id, `repositories[${index}].id`),
         role,
         indexMode: explicitIndex ?? (derived ? "provenance-only" : "full"),
-        policySource: explicitIndex ? "reckon.yaml" : "role-default",
+        policySource: explicitIndex ? "knodin.yaml" : "role-default",
     };
 }
 function configuredSystem(value, systemIndex) {
@@ -97,7 +97,7 @@ function configuredSystem(value, systemIndex) {
     };
 }
 function applyLegacyFederation(repo, repositories, relationships) {
-    const legacyPath = path.join(repo, ".reckon", "federation.json");
+    const legacyPath = path.join(repo, ".knodin", "federation.json");
     let legacy;
     try {
         legacy = asRecord(JSON.parse(fs.readFileSync(legacyPath, "utf-8")));
@@ -146,7 +146,7 @@ function applyLegacyFederation(repo, repositories, relationships) {
             to: id,
             targetIdentity: id,
             evidence: {
-                location: ".reckon/federation.json",
+                location: ".knodin/federation.json",
                 adapter: "legacy-federation",
                 kind: "compatibility",
                 confidence: 1,
@@ -165,7 +165,7 @@ function applyPersonalMappings(repositories, xdgConfigHome) {
         if (typeof checkout !== "string")
             continue;
         if (!path.isAbsolute(checkout)) {
-            throw new Error(`personal repository path for ${repository.id} must be absolute; team config keeps paths out of reckon.yaml`);
+            throw new Error(`personal repository path for ${repository.id} must be absolute; team config keeps paths out of knodin.yaml`);
         }
         repository.path = path.normalize(checkout);
         repository.pathSource = "personal-config";
@@ -303,7 +303,7 @@ function declaredRelationship(value, index) {
         to,
         targetIdentity: to,
         evidence: {
-            location: typeof source.location === "string" && source.location ? source.location : "reckon.yaml",
+            location: typeof source.location === "string" && source.location ? source.location : "knodin.yaml",
             adapter: "knodin-yaml",
             kind: "declared",
             confidence,
@@ -314,9 +314,9 @@ function declaredRelationship(value, index) {
 }
 export function loadSystemConfiguration(repoPath, options = {}) {
     const repo = path.resolve(repoPath);
-    const team = asRecord(optionalYaml(path.join(repo, "reckon.yaml")));
+    const team = asRecord(optionalYaml(path.join(repo, "knodin.yaml")));
     if (team.schemaVersion !== undefined && team.schemaVersion !== 1) {
-        throw new Error("reckon.yaml: schemaVersion must be 1");
+        throw new Error("knodin.yaml: schemaVersion must be 1");
     }
     const repositories = (Array.isArray(team.repositories) ? team.repositories : []).map((value, index) => configuredRepository(value, index));
     const systems = (Array.isArray(team.systems) ? team.systems : []).map((value, index) => configuredSystem(value, index));

package/dist/src/tools/knodin-tools.js

@@ -163,7 +163,7 @@ function buildDocumentedKnodinTools() {
                             "system",
                             "telemetry",
                         ],
-                        description: "Which knodin capability to run. context: call this FIRST when starting any investigation and unsure which operation to reach for — one ultra-compact orientation (repo stats + top subsystems/hubs/flows + a risk score if there's a diff + a heuristic next-operation suggestion); the suggestion is only a hint and never blocks calling any operation directly. explain: use when orienting on a symbol/file or before editing it — returns edit-ready source + call paths + blast radius. review: use before writing a PR description or approving a diff — risk-scored context (changed symbols, affected flows, test gaps). map: use before a cross-cutting refactor or to understand subsystem boundaries — communities + hub/bridge nodes + confidence-tagged edges. search: use when you don't know the exact symbol name — hybrid semantic + keyword lookup over code symbols. query: use for a structured question about a known symbol — callers_of, tests_for, shortest_path, dead_code, rename_preview, flows, and more (see `pattern`). pack: create deterministic Markdown/JSON/XML source context under hard budgets, or bounded-read/exact-regex-grep a saved artifact. compress: reduce already-produced diagnostic text under exact line/content-byte budgets, preserve exit metadata and detected signals, retain private local drill-down data by default, and never label insufficient-fidelity output complete. prs: use to triage open GitHub PRs (via your local authenticated `gh`) — per-PR status, CI, and blast radius sorted ready-small-impact first; pass `prNumber` for one PR's impacted files + community names. wiki: write a static markdown documentation site for the repository's logical subsystems to `.reckon/wiki/`. Generates an index plus one page per mapped community. Reuses the `map` output. Idempotent: unchanged pages are untouched on disk unless `force` is true. docs: call this to retrieve curated, focused markdown usage guidance directly over MCP.",
+                        description: "Which knodin capability to run. context: call this FIRST when starting any investigation and unsure which operation to reach for — one ultra-compact orientation (repo stats + top subsystems/hubs/flows + a risk score if there's a diff + a heuristic next-operation suggestion); the suggestion is only a hint and never blocks calling any operation directly. explain: use when orienting on a symbol/file or before editing it — returns edit-ready source + call paths + blast radius. review: use before writing a PR description or approving a diff — risk-scored context (changed symbols, affected flows, test gaps). map: use before a cross-cutting refactor or to understand subsystem boundaries — communities + hub/bridge nodes + confidence-tagged edges. search: use when you don't know the exact symbol name — hybrid semantic + keyword lookup over code symbols. query: use for a structured question about a known symbol — callers_of, tests_for, shortest_path, dead_code, rename_preview, flows, and more (see `pattern`). pack: create deterministic Markdown/JSON/XML source context under hard budgets, or bounded-read/exact-regex-grep a saved artifact. compress: reduce already-produced diagnostic text under exact line/content-byte budgets, preserve exit metadata and detected signals, retain private local drill-down data by default, and never label insufficient-fidelity output complete. prs: use to triage open GitHub PRs (via your local authenticated `gh`) — per-PR status, CI, and blast radius sorted ready-small-impact first; pass `prNumber` for one PR's impacted files + community names. wiki: write a static markdown documentation site for the repository's logical subsystems to `.knodin/wiki/`. Generates an index plus one page per mapped community. Reuses the `map` output. Idempotent: unchanged pages are untouched on disk unless `force` is true. docs: call this to retrieve curated, focused markdown usage guidance directly over MCP.",
                     },
                     symbol: {
                         type: "string",
@@ -610,7 +610,7 @@ function buildDocumentedKnodinTools() {
                     },
                     persistTelemetry: {
                         type: "boolean",
-                        description: "Opt in to local metadata-only JSONL persistence at .reckon-telemetry.jsonl; never records source.",
+                        description: "Opt in to local metadata-only JSONL persistence at .knodin-telemetry.jsonl; never records source.",
                     },
                 },
                 required: ["operation"],

package/dist/src/update-policy.js

@@ -100,8 +100,8 @@ export function claimScheduledUpdateCheck(options) {
     if (!config ||
         !config.enabled ||
         config.offline ||
-        env.RECKON_UPDATE_CHECK === "0" ||
-        env.RECKON_OFFLINE === "1")
+        env.KNODIN_UPDATE_CHECK === "0" ||
+        env.KNODIN_OFFLINE === "1")
         return false;
     const now = options.now?.() ?? new Date();
     const checkedAt = readTrustedUpdateState(options.stateHome)?.checkedAt;
@@ -474,9 +474,9 @@ async function checkedUpdate(options) {
     if (!config)
         return baseResult(options, "trust-unconfigured");
     const env = options.env ?? process.env;
-    if (!config.enabled || env.RECKON_UPDATE_CHECK === "0")
+    if (!config.enabled || env.KNODIN_UPDATE_CHECK === "0")
         return baseResult(options, "disabled");
-    if (config.offline || env.RECKON_OFFLINE === "1")
+    if (config.offline || env.KNODIN_OFFLINE === "1")
         return baseResult(options, "offline");
     const now = options.now?.() ?? new Date();
     const previous = readTrustedUpdateState(options.stateHome);