@planu/cli 4.12.3 → 4.14.1

package/dist/types/validate-worker.d.ts

@@ -0,0 +1,44 @@
+import type { ToolResult, ValidateInput } from './index.js';
+export interface ValidateWorkerRequest {
+    readonly kind: 'validate-request';
+    readonly schemaVersion: 1;
+    readonly secret: string;
+    readonly requestId: string;
+    readonly deadlineAt: number;
+    readonly input: ValidateInput;
+}
+export type ValidateWorkerResponse = {
+    readonly kind: 'ready';
+    readonly schemaVersion: 1;
+} | {
+    readonly kind: 'validate-progress';
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly progress: ValidateWorkerProgress;
+} | {
+    readonly kind: 'validate-result';
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly result: ToolResult;
+} | {
+    readonly kind: 'validate-error';
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly message: string;
+};
+export interface ValidateWorkerCall {
+    readonly requestId: string;
+    readonly input: ValidateInput;
+    readonly deadlineAt: number;
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (progress: ValidateWorkerProgress) => void;
+}
+export interface ValidateWorkerProgress {
+    readonly phase: string;
+    readonly command: string;
+    readonly durationMs: number;
+    readonly filesScanned?: number;
+    readonly status: 'running' | 'passed' | 'failed' | 'cancelled';
+    readonly remediation?: string;
+}
+//# sourceMappingURL=validate-worker.d.ts.map

package/dist/types/validate-worker.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate-worker.js.map

package/dist/types/validation-evidence.d.ts

@@ -1,5 +1,5 @@
 export declare const VALIDATION_EVIDENCE_SCHEMA_VERSION: '1.0.0';
-export type ValidationGateCapability = 'typecheck' | 'lint' | 'test-related' | 'test-full' | 'security' | 'native' | 'website' | 'reproducibility';
+export type ValidationGateCapability = 'typecheck' | 'lint' | 'test-related' | 'test-full' | 'contract' | 'coverage' | 'migration' | 'fault-injection' | 'security' | 'native' | 'website' | 'reproducibility';
 export type ValidationEvidenceStatus = 'passed' | 'failed' | 'cancelled' | 'invalidated';
 export interface ValidationEvidenceKeyInput {
     projectPath: string;

package/dist/types/validation-receipt.d.ts

@@ -0,0 +1,104 @@
+import type { FSWatcher } from 'node:fs';
+export interface ValidationReceiptBindings {
+    readonly projectId: string;
+    readonly specId: string;
+    readonly sourceDigest: string;
+    readonly specDigest: string;
+    readonly policyDigest: string;
+    readonly toolchainDigest: string;
+    readonly artifactDigests: ValidationArtifactDigests;
+}
+export interface ValidationArtifactDigests {
+    readonly approvedSpec: string;
+    readonly discovery: string;
+    readonly taskPlan: string;
+    readonly traceability: string;
+    readonly contractValidation: string;
+}
+export interface ValidationArtifactProvenance {
+    readonly receiptId: string;
+    /** Digest of canonical artifact content excluding this provenance envelope. */
+    readonly artifactDigest: string;
+    readonly specId: string;
+    readonly issuerId: string;
+}
+export interface ValidationFreshnessLease {
+    readonly projectId: string;
+    readonly specId: string;
+    readonly epoch: string;
+    readonly generation: number;
+}
+export interface ValidationFreshnessWatchState {
+    readonly epoch: string;
+    readonly expiresAt: number;
+    readonly generation: number;
+    readonly healthy: boolean;
+    readonly projectPath: string;
+    readonly handoffPath: string;
+    readonly evidenceFingerprint: string;
+    readonly bindings?: ValidationReceiptBindings;
+    readonly invalidating: Promise<void>;
+    readonly watchers: readonly FSWatcher[];
+}
+export interface ValidationCommandInput {
+    readonly executable: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+}
+export interface ValidationGateResult {
+    readonly gate: string;
+    readonly status: 'passed' | 'failed';
+    readonly durationMs: number;
+}
+export interface ValidationReceiptIssueInput {
+    readonly bindings: ValidationReceiptBindings;
+    readonly command: ValidationCommandInput;
+    readonly versions: Readonly<Record<string, string>>;
+    readonly exitCode: number;
+    readonly durationMs: number;
+    readonly log: string | Buffer;
+    readonly gates: readonly ValidationGateResult[];
+    readonly issuedAt?: string;
+}
+export interface ValidationReceipt {
+    readonly schemaVersion: 1;
+    readonly receiptId: string;
+    readonly issuer: string;
+    readonly issuedAt: string;
+    readonly bindings: ValidationReceiptBindings;
+    readonly normalizedCommand: string;
+    readonly versions: Readonly<Record<string, string>>;
+    readonly exitCode: number;
+    readonly durationMs: number;
+    readonly logDigest: string;
+    readonly gates: readonly ValidationGateResult[];
+    readonly authenticity: {
+        readonly algorithm: 'hmac-sha256';
+        readonly proof: string;
+    };
+}
+export interface ValidationReceiptIssuerOptions {
+    readonly issuerId: string;
+    readonly signingKeyReference: string;
+    readonly store: ValidationReceiptPersistence;
+}
+export interface ValidationReceiptVerificationOptions {
+    readonly bindings: ValidationReceiptBindings;
+    readonly trustedIssuers: Readonly<Record<string, string>>;
+    readonly store: ValidationReceiptPersistence;
+}
+export interface ValidationReceiptPersistence {
+    persist(receipt: ValidationReceipt, log: Buffer): Promise<void>;
+    readReceipt(projectId: string, receiptId: string): Promise<ValidationReceipt | undefined>;
+    readCurrent(projectId: string, specId: string): Promise<ValidationReceipt | undefined>;
+    readCurrentBindings(projectId: string, specId: string): Promise<ValidationReceiptBindings | undefined>;
+    projectCurrentBindings(bindings: ValidationReceiptBindings): Promise<void>;
+    invalidateCurrentBindings(projectId: string, specId: string): Promise<void>;
+    readLog(logDigest: string): Promise<Buffer | undefined>;
+    logPath(logDigest: string): string;
+}
+export interface ValidationReceiptVerification {
+    readonly valid: boolean;
+    readonly reason?: 'invalid-schema' | 'unsupported-version' | 'unknown-issuer' | 'invalid-authenticity' | 'stale-bindings' | 'missing-receipt' | 'missing-log' | 'invalid-log';
+}
+//# sourceMappingURL=validation-receipt.d.ts.map

package/dist/types/validation-receipt.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation-receipt.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.12.3",
+  "version": "4.14.1",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -22,26 +22,26 @@
   "napi": {
     "binaryName": "planu-core",
     "targets": [
-      "x86_64-apple-darwin",
       "aarch64-apple-darwin",
-      "x86_64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
       "aarch64-unknown-linux-gnu",
-      "x86_64-unknown-linux-musl",
       "aarch64-unknown-linux-musl",
-      "x86_64-pc-windows-msvc",
-      "aarch64-pc-windows-msvc"
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
     ],
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.12.3",
-    "@planu/core-darwin-x64": "4.12.3",
-    "@planu/core-linux-arm64-gnu": "4.12.3",
-    "@planu/core-linux-arm64-musl": "4.12.3",
-    "@planu/core-linux-x64-gnu": "4.12.3",
-    "@planu/core-linux-x64-musl": "4.12.3",
-    "@planu/core-win32-arm64-msvc": "4.12.3",
-    "@planu/core-win32-x64-msvc": "4.12.3"
+    "@planu/core-darwin-arm64": "4.14.1",
+    "@planu/core-darwin-x64": "4.14.1",
+    "@planu/core-linux-arm64-gnu": "4.14.1",
+    "@planu/core-linux-arm64-musl": "4.14.1",
+    "@planu/core-linux-x64-gnu": "4.14.1",
+    "@planu/core-linux-x64-musl": "4.14.1",
+    "@planu/core-win32-arm64-msvc": "4.14.1",
+    "@planu/core-win32-x64-msvc": "4.14.1"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -51,6 +51,8 @@
     "build:rust": "bash scripts/build-rust-local.sh --host",
     "build:rust:all": "bash scripts/build-rust-local.sh --all",
     "build:rust:check-tools": "bash scripts/build-rust-local.sh --check-tools",
+    "check:native-version-parity": "node scripts/check-native-version-parity.mjs",
+    "check:release-authorities": "node scripts/check-release-authorities.mjs",
     "release:local": "bash scripts/release-local.sh",
     "release:local:all": "bash scripts/release-local.sh --all",
     "release:publish": "bash scripts/release-local.sh --all --publish",
@@ -70,18 +72,26 @@
     "verify:typescript-migration": "node scripts/verify-typescript-migration.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage --exclude 'tests/integration/**'",
+    "test:coverage": "vitest run --coverage --testTimeout=60000 --maxWorkers=4",
     "test:integration": "vitest run tests/integration",
     "test:website:unit": "vitest run tests/website tests/scripts/generate-website-proof.test.ts tests/scripts/website-tool-counts.test.ts",
     "test:website:browser": "playwright test --config playwright.website.config.ts",
     "test:website:lighthouse": "lhci autorun --config=.lighthouserc.cjs",
     "test:website:lighthouse:production": "PLANU_LIGHTHOUSE_PRODUCTION=1 lhci autorun --config=.lighthouserc.cjs",
     "native:project-graph:e2e": "PLANU_NATIVE_E2E=1 vitest run tests/integration/native-project-graph-e2e.test.ts",
-    "native:project-graph:benchmark": "node scripts/benchmark-native-performance.mjs --operation project_graph_query --samples 5 --project-path . --spec-id SPEC-1119 --json",
-    "check": "pnpm typecheck && pnpm lint && pnpm format:check && pnpm check:public-privacy && pnpm check:website-proof && pnpm check:donation-assets && pnpm check:website-public-assets",
-    "check:strict": "pnpm check && pnpm audit:deadcode && pnpm audit:circular && pnpm audit:types && pnpm audit:security && pnpm audit:licenses && pnpm audit:i18n",
+    "native:project-graph:benchmark": "node scripts/benchmark-native-performance.mjs --operation project_graph_query --samples 30 --warmups 5 --project-path . --spec-id SPEC-1119 --json",
+    "benchmark:execution-kernel": "pnpm build && node scripts/benchmark-execution-kernel.mjs",
+    "check": "pnpm typecheck && pnpm lint && pnpm format:check && pnpm check:release-authorities && pnpm check:public-privacy && pnpm check:website-proof && pnpm check:donation-assets && pnpm check:website-public-assets",
+    "check:strict": "pnpm check && pnpm check:environment-schema && pnpm audit:hardcodes && pnpm audit:deadcode && pnpm audit:circular && pnpm audit:types && pnpm audit:security && pnpm audit:licenses && pnpm audit:i18n",
+    "check:reliability": "node scripts/check-reliability-policies.mjs",
+    "check:environment-schema": "node scripts/check-environment-schema.mjs",
+    "test:contracts": "vitest run tests/contracts tests/integration/package-consumer-hono.test.ts",
+    "test:migrations": "vitest run tests/storage/corruption-contract.test.ts tests/integration/runtime-storage.test.ts tests/integration/canonical-storage-migration.test.ts",
+    "test:fault-injection": "vitest run tests/engine/auto-updater/atomic-upgrade.test.ts tests/integration/durable-job-runtime.test.ts tests/integration/idempotent-operations.test.ts",
     "check:website-public-assets": "node scripts/check-website-public-assets.mjs",
-    "check:public-privacy": "node scripts/check-public-privacy.mjs",
+    "check:public-privacy": "node scripts/check-public-privacy.mjs && node scripts/check-native-signing-privacy.mjs",
+    "check:readme-parity": "node scripts/check-readme-parity.mjs --package-root .",
+    "privacy:prepublish": "node scripts/check-prepublish-privacy.mjs --package-root .",
     "generate:website-proof": "node scripts/generate-website-proof.mjs",
     "generate:donation-assets": "node scripts/generate-crypto-donation-assets.mjs",
     "check:donation-assets": "node scripts/generate-crypto-donation-assets.mjs --check",
@@ -96,6 +106,7 @@
     "audit:licenses": "bash scripts/audit-licenses.sh",
     "audit:size": "bash scripts/audit-package-size.sh",
     "audit:i18n": "bash scripts/audit-i18n.sh",
+    "audit:hardcodes": "node scripts/check-hardcodes.mjs",
     "audit:mutation": "stryker run",
     "setup:protection": "bash scripts/setup-branch-protection.sh",
     "prepare": "husky || true",
@@ -157,7 +168,7 @@
     "@commitlint/config-conventional": "^21.2.0",
     "@eslint/js": "^10.0.1",
     "@lhci/cli": "0.15.1",
-    "@napi-rs/cli": "^3.7.4",
+    "@napi-rs/cli": "3.7.4",
     "@noble/hashes": "2.2.0",
     "@playwright/test": "1.62.0",
     "@scure/base": "2.2.0",

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.12.3",
+  "version": "4.14.1",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "4.12.3",
+  "version": "4.14.1",
   "icon": "assets/plugin/icon.svg",
   "command": [
     "npx",

package/dist/engine/telemetry/geo-resolver.d.ts

@@ -1,9 +0,0 @@
-import type { GeoData } from '../../types/index.js';
-/**
- * Returns geo data for the current machine IP.
- * Cached after the first successful call; null if the lookup fails or times out.
- */
-export declare function resolveGeo(): Promise<GeoData | null>;
-/** Reset cache — used in tests. */
-export declare function resetGeoCache(): void;
-//# sourceMappingURL=geo-resolver.d.ts.map

package/dist/engine/telemetry/geo-resolver.js

@@ -1,43 +0,0 @@
-// engine/telemetry/geo-resolver.ts — Cached geo-IP lookup for telemetry enrichment.
-// Uses ip-api.com (free, no API key, 45 req/min). Called once per process lifecycle.
-// Never throws — geo enrichment is purely best-effort.
-let cachedGeo = null;
-let lookupAttempted = false;
-/**
- * Returns geo data for the current machine IP.
- * Cached after the first successful call; null if the lookup fails or times out.
- */
-export async function resolveGeo() {
-    if (lookupAttempted) {
-        return cachedGeo;
-    }
-    lookupAttempted = true;
-    try {
-        const res = await fetch('http://ip-api.com/json/?fields=country,countryCode,city,timezone', {
-            signal: AbortSignal.timeout(2_000),
-        });
-        if (!res.ok) {
-            return null;
-        }
-        const data = (await res.json());
-        if (typeof data.countryCode !== 'string') {
-            return null;
-        }
-        cachedGeo = {
-            country: typeof data.country === 'string' ? data.country : '',
-            countryCode: data.countryCode,
-            city: typeof data.city === 'string' ? data.city : '',
-            timezone: typeof data.timezone === 'string' ? data.timezone : '',
-        };
-        return cachedGeo;
-    }
-    catch {
-        return null;
-    }
-}
-/** Reset cache — used in tests. */
-export function resetGeoCache() {
-    cachedGeo = null;
-    lookupAttempted = false;
-}
-//# sourceMappingURL=geo-resolver.js.map

package/dist/storage/data-dir-discovery.d.ts

@@ -1,31 +0,0 @@
-/** Clear the resolution cache — TEST USE ONLY. */
-export declare function clearDataDirCache(): void;
-/**
- * Resolve the data dir for `projectId`, walking ancestors of cwd and of the
- * registered projectPath when the cwd-relative dir lacks the anchor file.
- *
- * Result is cached per session: the first successful (or unsuccessful)
- * resolution sticks, so repeated reads do not pay the I/O cost.
- *
- * Returns null when no `knowledge.json` is found anywhere — callers should
- * treat that as "project not initialized in any reachable location".
- *
- * @param projectId Project hash identifier.
- * @param cwd       Optional working directory override (defaults to
- *                  `process.cwd()`). Exposed for tests, where Vitest workers
- *                  cannot mutate the real process cwd.
- */
-export declare function resolveProjectDataDir(projectId: string, cwd?: string): Promise<string | null>;
-/**
- * Discover an existing data file for `projectId`. Returns the absolute path
- * when the resolved data dir contains `<relative>`, or null otherwise.
- *
- * Anchored on `knowledge.json` — if no project owns the dir, no file is
- * returned even if a same-named file happens to live in another repo's
- * `data/projects/<id>/` tree.
- *
- * @param projectId Project hash identifier.
- * @param relative  Path under `data/projects/<id>/`, e.g. "specs.json".
- */
-export declare function discoverProjectDataFile(projectId: string, relative: string, cwd?: string): Promise<string | null>;
-//# sourceMappingURL=data-dir-discovery.d.ts.map

package/dist/storage/data-dir-discovery.js

@@ -1,140 +0,0 @@
-// data-dir-discovery.ts — Cwd-tolerant data dir discovery for project stores.
-//
-// Background: projectDataDir() returns a relative path "data/projects/<id>".
-// All store reads thus depend on process.cwd(). When the MCP server is launched
-// from a directory other than the one used at init_project time, stores cannot
-// see existing data on disk and report the project as missing.
-//
-// This module resolves the data dir for a projectId once per session by
-// walking up from cwd and from the registered projectPath, anchoring the
-// search on `knowledge.json` (the canonical signal that a directory truly
-// belongs to the given project — not just a co-located hash collision in an
-// unrelated repo). Once resolved, the same base dir is used for every store
-// (specs.json, knowledge.json, etc.) so they stay coherent.
-//
-// Reads are read-only and best-effort: writes still go through projectDataDir().
-import { stat } from 'node:fs/promises';
-import { join, dirname, isAbsolute } from 'node:path';
-import { getProjects } from './global-projects-store.js';
-const MAX_WALK_DEPTH = 8;
-/** The file used to anchor discovery: presence == this dir owns the project. */
-const ANCHOR_FILE = 'knowledge.json';
-const dataDirCache = new Map();
-/** Clear the resolution cache — TEST USE ONLY. */
-export function clearDataDirCache() {
-    dataDirCache.clear();
-}
-async function fileExists(filePath) {
-    try {
-        const s = await stat(filePath);
-        return s.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Walk upward from `startDir` looking for the first directory under which
- * `<dir>/<subPath>/<ANCHOR_FILE>` exists. Returns the matched data dir
- * (`<dir>/<subPath>`), or null when no anchor is found.
- */
-async function walkUpForAnchor(startDir, subPath) {
-    if (!isAbsolute(startDir)) {
-        return null;
-    }
-    let current = startDir;
-    for (let i = 0; i < MAX_WALK_DEPTH; i++) {
-        const dataDir = join(current, subPath);
-        if (await fileExists(join(dataDir, ANCHOR_FILE))) {
-            return dataDir;
-        }
-        const parent = dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-    return null;
-}
-/**
- * Resolve the data dir for `projectId`, walking ancestors of cwd and of the
- * registered projectPath when the cwd-relative dir lacks the anchor file.
- *
- * Result is cached per session: the first successful (or unsuccessful)
- * resolution sticks, so repeated reads do not pay the I/O cost.
- *
- * Returns null when no `knowledge.json` is found anywhere — callers should
- * treat that as "project not initialized in any reachable location".
- *
- * @param projectId Project hash identifier.
- * @param cwd       Optional working directory override (defaults to
- *                  `process.cwd()`). Exposed for tests, where Vitest workers
- *                  cannot mutate the real process cwd.
- */
-export async function resolveProjectDataDir(projectId, cwd = process.cwd()) {
-    if (dataDirCache.has(projectId)) {
-        return dataDirCache.get(projectId) ?? null;
-    }
-    const subPath = join('data', 'projects', projectId);
-    // 1. cwd-relative direct hit (current behavior, fast path)
-    const direct = join(cwd, subPath);
-    if (await fileExists(join(direct, ANCHOR_FILE))) {
-        dataDirCache.set(projectId, direct);
-        return direct;
-    }
-    // 2. Walk up from cwd
-    const fromCwd = await walkUpForAnchor(cwd, subPath);
-    if (fromCwd !== null) {
-        dataDirCache.set(projectId, fromCwd);
-        return fromCwd;
-    }
-    // 3. Use the registered projectPath, if any
-    let registeredPath = null;
-    try {
-        const projects = await getProjects();
-        const match = projects.find((p) => p.hash === projectId);
-        if (match) {
-            registeredPath = match.path;
-        }
-    }
-    catch {
-        /* registry unreadable — skip */
-    }
-    if (registeredPath !== null) {
-        const directFromRegistered = join(registeredPath, subPath);
-        if (await fileExists(join(directFromRegistered, ANCHOR_FILE))) {
-            dataDirCache.set(projectId, directFromRegistered);
-            return directFromRegistered;
-        }
-        const fromRegistered = await walkUpForAnchor(registeredPath, subPath);
-        if (fromRegistered !== null) {
-            dataDirCache.set(projectId, fromRegistered);
-            return fromRegistered;
-        }
-    }
-    dataDirCache.set(projectId, null);
-    return null;
-}
-/**
- * Discover an existing data file for `projectId`. Returns the absolute path
- * when the resolved data dir contains `<relative>`, or null otherwise.
- *
- * Anchored on `knowledge.json` — if no project owns the dir, no file is
- * returned even if a same-named file happens to live in another repo's
- * `data/projects/<id>/` tree.
- *
- * @param projectId Project hash identifier.
- * @param relative  Path under `data/projects/<id>/`, e.g. "specs.json".
- */
-export async function discoverProjectDataFile(projectId, relative, cwd) {
-    const dir = await resolveProjectDataDir(projectId, cwd ?? process.cwd());
-    if (dir === null) {
-        return null;
-    }
-    const candidate = join(dir, relative);
-    if (await fileExists(candidate)) {
-        return candidate;
-    }
-    return null;
-}
-//# sourceMappingURL=data-dir-discovery.js.map

package/dist/storage/migrations/cwd-to-absolute.d.ts

@@ -1,25 +0,0 @@
-import type { CwdMigrationResult as MigrationResult } from '../../types/migration/cwd-to-absolute.js';
-export type { MigrationResult };
-/** Test-only: reset the in-memory short-circuit set. */
-export declare function clearMigratedThisSession(): void;
-declare function pathExists(p: string): Promise<boolean>;
-/**
- * Move a legacy `<cwd>/data/projects/<id>/` tree into the absolute home for
- * `projectId`. Idempotent across calls and processes.
- *
- * Test isolation: when PLANU_PROJECT_DATA_DIR is assigned to a fresh tmp dir
- * (as in `tests/setup.ts`), this migration walks `cwd` from the test's
- * directory and finds nothing — returns `noop` immediately.
- */
-export declare function migrateLegacyDataDir(projectId: string, cwd?: string): Promise<MigrationResult>;
-export declare const MIGRATION_INTERNALS: Readonly<{
-    SENTINEL_FILE: ".migrated-from-cwd";
-    LOCK_FILE: ".migration.lock";
-    MAX_WALK_DEPTH: 8;
-    ANCHOR_FILE: "knowledge.json";
-    LEGACY_SUBPATH: "data/projects";
-}>;
-export declare const __test: {
-    pathExists: typeof pathExists;
-};
-//# sourceMappingURL=cwd-to-absolute.d.ts.map