@planu/cli 5.1.1 → 5.3.0

package/CHANGELOG.md

@@ -1,3 +1,57 @@
+## [5.3.0] - 2026-08-05
+
+### Features
+- feat(watchers): ignore non-actionable root events in validation freshness watchers (SPEC-1340)
+- feat(release): harden local release pipeline — auth preflight, receipt env isolation, publish retry, visibility wait (SPEC-1369)
+
+### Bug Fixes
+- fix(release): accept npm 12 keyed pack JSON across release gates (SPEC-1339)
+- fix(validator): stop marking provably implemented test-only criteria as indeterminate (SPEC-1367)
+- fix(deps): raise brace-expansion and postcss transitive floors past advisories (SPEC-1338)
+- fix(readiness): fail strict readiness when canonical BDD extraction returns zero criteria (SPEC-1321)
+- fix(lifecycle): route implementation review digests to done gates without entering reconciliation (SPEC-1328)
+- fix(privacy): redact minimality policy locators from persisted artifacts (SPEC-1334)
+- fix(create-spec): remove hardcoded test-framework commands from generated specs (SPEC-1234)
+- fix(challenge): preserve title evidence in event capability detection (SPEC-1235)
+- fix(release): enforce proprietary license and canonical plugin tool parity (SPEC-1236)
+
+### Tests
+- test(release): make release preflight/receipt regressions deterministic under full-suite load (SPEC-1207)
+- test(release): reconcile full test suite with local-only release policy and rollback semantics (SPEC-1373)
+
+### Chores
+- chore(deps): update 11 patch/minor dependencies
+- chore(planu): close stale lifecycle for SPEC-1010/1011 tool-reliability specs and record SPEC-1010 tech debt
+- chore(planu): file SPEC-1374/1375/1376 dogfood bug specs
+
+
+## [5.2.0] - 2026-08-04
+
+### Features
+- feat(autopilot): refresh semantic index fire-and-forget on spec:created (SPEC-1345)
+- feat(i18n): auto-detect and persist user locale (SPEC-1347)
+- feat(spec-language): offer translation instead of rejecting non-English specs (SPEC-1342)
+- feat(semantic-search): persist index with incremental updates (SPEC-1345)
+
+### Bug Fixes
+- fix(storage): classify non-ENOENT failures in sync global-config read
+- fix(status): prefer implementing work over review work in compact status (SPEC-1228)
+- fix(challenge): stop handler names activating event scenarios across clauses (SPEC-1262)
+
+### Performance
+- perf(core-bridge): route main-thread hot paths through native dispatch (SPEC-1344)
+- perf(init-project): parallelize independent pipeline stages (SPEC-1343)
+
+### Chores
+- chore(website): regenerate deterministic product proof
+- chore(planu): close lifecycle for 8 specs done + SPEC-1368 bug spec + session checkpoint
+- chore(planu): file SPEC-1367 dogfood bug spec (validate false-negative on test-only criteria)
+- chore(planu): file SPEC-1366 dogfood bug spec and refresh session context
+- chore(doctor): remove commercial remnants and deepen diagnostics (SPEC-1346)
+- chore(planu): file SPEC-1365 dogfood bug spec (teamSuggestion recommends unregistered tools)
+- chore(planu): session checkpoint after v5.1.1 release
+
+
 ## [5.1.1] - 2026-08-04
 
 ### Bug Fixes

package/dist/cli/commands/doctor.d.ts

@@ -10,7 +10,29 @@ interface ToolCheck {
     paths: string[];
     format: 'standard' | 'zed';
 }
+interface DeepCheckResult {
+    name: string;
+    /** 'warn' is a degraded-but-working state (e.g. TS fallback active); 'fail' blocks usage. */
+    status: 'ok' | 'warn' | 'fail';
+    detail: string;
+}
 declare function checkTool(check: ToolCheck): ToolReport[];
+/** Check (1): the running Node version satisfies the `engines.node` field in package.json. */
+declare function checkNodeVersion(): DeepCheckResult;
+/**
+ * Check (2): the native Rust module loads, with a remediation hint when it doesn't.
+ * Missing native is a supported degraded mode (TypeScript fallback stays correct), so
+ * this reports 'warn' rather than 'fail' — it never blocks `planu doctor`'s exit code.
+ */
+declare function checkNativeModule(): DeepCheckResult;
+/** Check (3): PLANU_HOME / the resolved data directory is writable. */
+declare function checkDataDirWritable(): DeepCheckResult;
+/** Check (4): the runtime SQLite database opens without corruption. */
+declare function checkRuntimeDatabase(): DeepCheckResult;
+/** Check (5): the active locale resolves to a real translated message. */
+declare function checkLocaleResolution(): DeepCheckResult;
+declare function runDeepChecks(): DeepCheckResult[];
+export { checkNodeVersion, checkNativeModule, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 export { checkTool };
 export declare const doctorCommand: CliCommand;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/cli/commands/doctor.js

@@ -1,9 +1,16 @@
 // cli/commands/doctor.ts — planu doctor: verify MCP installations health (SPEC-236)
-import { existsSync } from 'node:fs';
+// Deep diagnostics (Node version, native engine, storage writability, runtime DB,
+// locale resolution) added by SPEC-1346 / SPEC-1344.
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { bold, cyan, green, yellow, red, dim } from '../colors.js';
 import { readJsonFile, hasPlanuEntry } from './install.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { RuntimeDatabase } from '../../storage/runtime-db.js';
+import { probeNativeLoad } from '../../engine/core-bridge.js';
+import { getLocale, t } from '../../i18n/index.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -86,6 +93,166 @@ function checkTool(check) {
     }
     return reports;
 }
+// ---------------------------------------------------------------------------
+// Deep diagnostics (SPEC-1346 / SPEC-1344)
+// ---------------------------------------------------------------------------
+/** Root of the package, resolved relative to this module so it works from src/ and dist/. */
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../package.json');
+function parseVersionTuple(version) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+    return [Number(match?.[1] ?? 0), Number(match?.[2] ?? 0), Number(match?.[3] ?? 0)];
+}
+function isVersionAtLeast(actual, required) {
+    for (let i = 0; i < 3; i++) {
+        const a = actual[i] ?? 0;
+        const r = required[i] ?? 0;
+        if (a !== r) {
+            return a > r;
+        }
+    }
+    return true;
+}
+/** Check (1): the running Node version satisfies the `engines.node` field in package.json. */
+function checkNodeVersion() {
+    let requiredRange;
+    try {
+        const pkg = JSON.parse(readFileSync(PACKAGE_ROOT, 'utf-8'));
+        requiredRange = pkg.engines?.node ?? '';
+    }
+    catch {
+        return {
+            name: 'Node version',
+            status: 'fail',
+            detail: 'Could not read package.json engines field',
+        };
+    }
+    if (!requiredRange) {
+        return { name: 'Node version', status: 'ok', detail: `Running Node ${process.version}` };
+    }
+    const required = parseVersionTuple(requiredRange);
+    const actual = parseVersionTuple(process.version);
+    if (isVersionAtLeast(actual, required)) {
+        return {
+            name: 'Node version',
+            status: 'ok',
+            detail: `${process.version} satisfies ${requiredRange}`,
+        };
+    }
+    return {
+        name: 'Node version',
+        status: 'fail',
+        detail: `${process.version} does not satisfy required range ${requiredRange}. Upgrade Node to continue.`,
+    };
+}
+/**
+ * Check (2): the native Rust module loads, with a remediation hint when it doesn't.
+ * Missing native is a supported degraded mode (TypeScript fallback stays correct), so
+ * this reports 'warn' rather than 'fail' — it never blocks `planu doctor`'s exit code.
+ */
+function checkNativeModule() {
+    if (process.env.DISABLE_NATIVE_CORE === '1') {
+        return {
+            name: 'Native engine',
+            status: 'ok',
+            detail: 'Disabled via DISABLE_NATIVE_CORE=1 (TypeScript fallback in use)',
+        };
+    }
+    const diagnostic = probeNativeLoad();
+    if (diagnostic.loaded) {
+        return { name: 'Native engine', status: 'ok', detail: `Loaded (${diagnostic.loaded})` };
+    }
+    const reason = diagnostic.errors[0] ?? 'unknown failure';
+    return {
+        name: 'Native engine',
+        status: 'warn',
+        detail: `Failed to load (${reason}). Running on the TypeScript fallback. Reinstall the platform package for your OS/arch to restore native acceleration.`,
+    };
+}
+/** Check (3): PLANU_HOME / the resolved data directory is writable. */
+function checkDataDirWritable() {
+    const layout = resolveStorageLayout();
+    const probePath = join(layout.data, `.doctor-write-probe-${String(process.pid)}`);
+    try {
+        mkdirSync(layout.data, { recursive: true, mode: 0o700 });
+        writeFileSync(probePath, 'ok', { mode: 0o600 });
+        unlinkSync(probePath);
+        return { name: 'Data directory', status: 'ok', detail: `Writable: ${layout.data}` };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: 'Data directory',
+            status: 'fail',
+            detail: `Cannot write to ${layout.data} (${message}). Check ownership/permissions on that path or set PLANU_HOME to a writable location.`,
+        };
+    }
+}
+/** Check (4): the runtime SQLite database opens without corruption. */
+function checkRuntimeDatabase() {
+    const layout = resolveStorageLayout();
+    try {
+        const db = new RuntimeDatabase({ path: layout.runtimeDatabase });
+        db.close();
+        return {
+            name: 'Runtime database',
+            status: 'ok',
+            detail: `Opens correctly: ${layout.runtimeDatabase}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: 'Runtime database',
+            status: 'fail',
+            detail: `Cannot open ${layout.runtimeDatabase} (${message}). Move or delete the corrupted file and retry — Planu recreates it on next use.`,
+        };
+    }
+}
+/** Check (5): the active locale resolves to a real translated message. */
+function checkLocaleResolution() {
+    const locale = getLocale();
+    const sample = t('locale.changed', locale);
+    if (sample === 'locale.changed') {
+        return {
+            name: 'Locale resolution',
+            status: 'fail',
+            detail: `Locale "${locale}" resolved but message bundle failed to load. Reinstall Planu to restore i18n/messages/.`,
+        };
+    }
+    return { name: 'Locale resolution', status: 'ok', detail: `Resolved locale: ${locale}` };
+}
+function runDeepChecks() {
+    return [
+        checkNodeVersion(),
+        checkNativeModule(),
+        checkDataDirWritable(),
+        checkRuntimeDatabase(),
+        checkLocaleResolution(),
+    ];
+}
+function deepCheckIcon(status) {
+    if (status === 'ok') {
+        return green('+');
+    }
+    return status === 'warn' ? yellow('!') : red('x');
+}
+function deepCheckLabel(status) {
+    if (status === 'ok') {
+        return green('OK');
+    }
+    return status === 'warn' ? yellow('DEGRADED') : red('FAIL');
+}
+function printDeepChecks(results) {
+    process.stdout.write(`\n${bold('Deep diagnostics')}\n\n`);
+    for (const result of results) {
+        const icon = deepCheckIcon(result.status);
+        const label = deepCheckLabel(result.status);
+        process.stdout.write(`  [${icon}] ${result.name.padEnd(18)} ${label}\n`);
+        process.stdout.write(`       ${dim(result.detail)}\n`);
+    }
+}
+// Exported for tests
+export { checkNodeVersion, checkNativeModule, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 function statusIcon(status) {
     switch (status) {
         case 'ok':
@@ -143,9 +310,16 @@ export const doctorCommand = {
             }
         }
         printReports(allReports);
+        const deepChecks = runDeepChecks();
+        printDeepChecks(deepChecks);
         const installed = allReports.filter((r) => r.status === 'ok').length;
         const invalid = allReports.filter((r) => r.status === 'invalid-config').length;
+        const failedDeepChecks = deepChecks.filter((c) => c.status === 'fail').length;
         process.stdout.write('\n');
+        if (failedDeepChecks > 0) {
+            process.stdout.write(`${red('Warning:')} ${String(failedDeepChecks)} deep diagnostic check(s) failed. See remediation steps above.\n`);
+            process.exitCode = 1;
+        }
         if (invalid > 0) {
             process.stdout.write(`${yellow('Warning:')} ${String(invalid)} config file(s) have invalid JSON. Run ${cyan('planu install')} to fix.\n`);
         }

package/dist/config/environment-schema.json

@@ -8,10 +8,34 @@
       "sensitivity": "secret",
       "default": null
     },
-    { "name": "PLANU_AUTO_DRIFT", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_COMMENT", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_DISABLE_HOOKS", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_DRIFT_THRESHOLD", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_AUTO_DRIFT",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_COMMENT",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_DISABLE_HOOKS",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_DRIFT_THRESHOLD",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_ENABLE_AUTOCOMMIT",
       "type": "boolean",
@@ -26,7 +50,13 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_FIGMA_CLIENT_ID", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_FIGMA_CLIENT_ID",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_FIGMA_CLIENT_SECRET",
       "type": "string",
@@ -55,7 +85,13 @@
       "sensitivity": "private",
       "default": null
     },
-    { "name": "PLANU_HOST", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_HOST",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_MAX_PARALLEL_AGENTS",
       "type": "number",
@@ -63,7 +99,13 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_MAX_TS_WATCHERS", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_MAX_TS_WATCHERS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_MONTHLY_BUDGET_USD",
       "type": "number",
@@ -71,7 +113,13 @@
       "sensitivity": "private",
       "default": null
     },
-    { "name": "PLANU_NATIVE_PATH", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_NATIVE_PATH",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
     {
       "name": "PLANU_NETWORK_CONSENT",
       "type": "string",
@@ -79,8 +127,20 @@
       "sensitivity": "private",
       "default": null
     },
-    { "name": "PLANU_OFFLINE", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_PLUGINS_DIR", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_OFFLINE",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_PLUGINS_DIR",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
     {
       "name": "PLANU_PROJECT_DATA_DIR",
       "type": "string",
@@ -88,7 +148,13 @@
       "sensitivity": "private",
       "default": null
     },
-    { "name": "PLANU_PROJECT_PATH", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_PROJECT_PATH",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
     {
       "name": "PLANU_QA_CHECK_TIMEOUT_MS",
       "type": "number",
@@ -96,11 +162,41 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_RECORD_CASSETTES", "type": "boolean", "scope": "test", "sensitivity": "public", "default": null },
-    { "name": "PLANU_REGISTRY_URL", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_SAGA_CHAOS", "type": "string", "scope": "test", "sensitivity": "public", "default": null },
-    { "name": "PLANU_SESSION_BUDGET", "type": "number", "scope": "runtime", "sensitivity": "private", "default": null },
-    { "name": "PLANU_SESSION_ID", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_RECORD_CASSETTES",
+      "type": "boolean",
+      "scope": "test",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_REGISTRY_URL",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_SAGA_CHAOS",
+      "type": "string",
+      "scope": "test",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_SESSION_BUDGET",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    {
+      "name": "PLANU_SESSION_ID",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
     {
       "name": "PLANU_SUPPRESS_AUTOCOMMIT",
       "type": "boolean",
@@ -108,7 +204,13 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_TELEMETRY", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_TELEMETRY",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_TELEMETRY_CONSENT_VERSION",
       "type": "string",
@@ -123,9 +225,27 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_TELEMETRY_TOKEN", "type": "string", "scope": "runtime", "sensitivity": "secret", "default": null },
-    { "name": "PLANU_TIMING", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_TOOL_TIMEOUT_MS", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_TELEMETRY_TOKEN",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "secret",
+      "default": null
+    },
+    {
+      "name": "PLANU_TIMING",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_TOOL_TIMEOUT_MS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_VALIDATE_LINT_TIMEOUT_MS",
       "type": "number",
@@ -133,7 +253,27 @@
       "sensitivity": "public",
       "default": null
     },
-    { "name": "PLANU_VERBOSE_OUTPUT", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null }
+    {
+      "name": "PLANU_VALIDATE_PROBE",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_VALIDATE_PROBE_TIMEOUT_MS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_VERBOSE_OUTPUT",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    }
   ],
   "dynamicPatterns": [
     {

package/dist/config/release-policy.json

@@ -96,13 +96,5 @@
       { "id": "CC", "command": "clang" },
       { "id": "CXX", "command": "clang++" }
     ]
-  },
-  "workflowActions": {
-    "actions/checkout": "d23441a48e516b6c34aea4fa41551a30e30af803",
-    "actions/setup-node": "249970729cb0ef3589644e2896645e5dc5ba9c38",
-    "actions/upload-artifact": "b7c566a772e6b6bfb58ed0dc250532a479d7789f",
-    "pnpm/action-setup": "fc06bc1257f339d1d5d8b3a19a8cae5388b55320",
-    "dtolnay/rust-toolchain": "2c7215f132e9ebf062739d9130488b56d53c060c",
-    "Swatinem/rust-cache": "e18b497796c12c097a38f9edb9d0641fb99eee32"
   }
 }

package/dist/engine/autopilot/bootstrap.js

@@ -99,6 +99,31 @@ function registerPluginInstalledListener() {
         })();
     });
 }
+/**
+ * SPEC-1345 AC4: Fire-and-forget semantic index refresh on spec:created.
+ * Reconciles the persisted TF-IDF index against the current corpus so the next
+ * semantic_search call hits a warm, up-to-date index.
+ */
+function registerSemanticIndexRefreshListener() {
+    onAutopilotEvent('spec:created', (event) => {
+        void (async () => {
+            try {
+                const { getOrCreateBackend } = await import('../../storage/vector-store/backend-factory.js');
+                const { SemanticIndexStore } = await import('../../storage/semantic-index-store.js');
+                const backend = await getOrCreateBackend(event.projectId);
+                const allDocs = await backend.getAll();
+                if (allDocs.length === 0) {
+                    return;
+                }
+                const indexStore = new SemanticIndexStore(event.projectId, 'all');
+                await indexStore.loadOrBuild(allDocs.map((doc) => ({ id: doc.id, content: doc.content })));
+            }
+            catch {
+                /* best-effort — never surface to user */
+            }
+        })();
+    });
+}
 const AUTOPILOT_EVENTS = [
     'spec:created',
     'spec:status:approved',
@@ -133,5 +158,7 @@ export function bootstrapAutopilotHandlers() {
     registerPluginInstalledListener();
     // SPEC-628: Register daily cron for auto_fix_health (moved from update_status cascade)
     registerDailyCronListener();
+    // SPEC-1345 AC4: Register semantic index refresh on spec:created
+    registerSemanticIndexRefreshListener();
 }
 //# sourceMappingURL=bootstrap.js.map

package/dist/engine/core-bridge.d.ts

@@ -31,6 +31,34 @@ export declare function fastExtractTsRelations(rootPath: string, paths: string[]
 export declare function fastQueryAffectedNodes(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): AffectedNodeRs[];
 export declare function fastQueryShortestPath(from: string, to: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): ShortestPathResultRs;
 export declare function fastSelectCompactGraphSlice(seeds: string[], nodes: GraphNodeInputRs[], edges: GraphEdgeInputRs[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): CompactGraphSliceRs;
+/** Worker-dispatched variant of {@link fastDetectDriftParallel} for main-thread callers. */
+export declare function fastDetectDriftParallelAsync(rootPath: string, keywords: string[]): Promise<{
+    value: DriftResult;
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanAndHashFiles} for main-thread callers. */
+export declare function fastScanAndHashFilesAsync(rootPath: string): Promise<{
+    value: FileHash[];
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanProjectMetadata} for main-thread callers. */
+export declare function fastScanProjectMetadataAsync(rootPath: string): Promise<{
+    value: FileMetadata[];
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanSpecs} for main-thread callers. */
+export declare function fastScanSpecsAsync(rootPath: string): Promise<{
+    value: SpecBriefRs[] | null;
+    degradationNotice?: string;
+}>;
 export declare const isNativeActive: () => boolean;
 export declare const nativeLoadDiagnostic: () => NativeLoadDiagnostic;
+/**
+ * Force a native load attempt regardless of the calling thread and return the
+ * resulting diagnostic. `nativeLoadDiagnostic()` alone only reports load state
+ * that some other main-thread-bypassing caller already triggered (e.g. the
+ * macOS Keychain port); this is the main-thread-safe way to actually probe
+ * native availability, used by `planu doctor`.
+ */
+export declare const probeNativeLoad: () => NativeLoadDiagnostic;
 //# sourceMappingURL=core-bridge.d.ts.map