@planu/cli 4.14.1 → 5.1.1

package/dist/engine/migrations/remove-commercial-state.js

@@ -0,0 +1,343 @@
+import { lstat, readFile, readdir, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { withUpgradeLock } from '../auto-updater/upgrade-lock.js';
+import { deleteSecretField } from '../../security/secret-field.js';
+import { isSecretReference, parseSecretReference } from '../../security/secret-provider.js';
+import { globalDataDir } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const TOP_LEVEL_USAGE_KEYS = [
+    'trialState',
+    'firstRunAt',
+    'dailyLimit',
+    'dailyCalls',
+    'remainingDailyCalls',
+    'currentTier',
+    'callsByTier',
+    'daysSinceFirstRun',
+    'isTrialActive',
+    'trialDaysLeft',
+];
+const EVENT_USAGE_KEYS = ['tier', 'trial', 'quota', 'dailyLimit', 'remainingDailyCalls'];
+const COMMERCIAL_HOST_ENV_KEYS = [
+    'SDD_LICENSE_KEY',
+    'SDD_OWNER_TOKEN',
+    'PLANU_LICENSE_KEY',
+    'PLANU_SKIP_TRIAL',
+];
+const ARCHIVED_USAGE = /^usage-\d{4}-\d{2}-\d{2}\.json$/u;
+function nodeError(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}
+function cleanupCode(error) {
+    if (error instanceof Error && error.message.includes('symlink')) {
+        return 'SYMLINK_REJECTED';
+    }
+    if (error instanceof SyntaxError ||
+        (error instanceof Error && error.message.includes('malformed'))) {
+        return 'MALFORMED_JSON';
+    }
+    if (nodeError(error, 'EACCES') || nodeError(error, 'EPERM') || nodeError(error, 'EROFS')) {
+        return 'WRITE_DENIED';
+    }
+    if (error instanceof Error && error.message.includes('lock')) {
+        return 'LOCK_UNAVAILABLE';
+    }
+    return 'CLEANUP_FAILED';
+}
+async function regularFile(path) {
+    try {
+        const info = await lstat(path);
+        if (info.isSymbolicLink()) {
+            throw new Error('[Planu] cleanup symlink rejected');
+        }
+        if (!info.isFile()) {
+            throw new Error('[Planu] cleanup non-file rejected');
+        }
+        return true;
+    }
+    catch (error) {
+        if (nodeError(error, 'ENOENT')) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function parseJsonFile(path) {
+    if (!(await regularFile(path))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error('[Planu] cleanup malformed JSON', { cause: error });
+    }
+}
+function omitKnownKeys(record, keys) {
+    const forbidden = new Set(keys);
+    const entries = Object.entries(record).filter(([key]) => !forbidden.has(key));
+    return {
+        value: Object.fromEntries(entries),
+        changed: entries.length !== Object.keys(record).length,
+    };
+}
+function stripCommercialUsage(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return { value, changed: false };
+    }
+    const root = value;
+    const topLevel = omitKnownKeys(root, TOP_LEVEL_USAGE_KEYS);
+    let changed = topLevel.changed;
+    let events = topLevel.value.events;
+    if (Array.isArray(root.events)) {
+        const sourceEvents = root.events;
+        events = sourceEvents.map((event) => {
+            if (event === null || typeof event !== 'object' || Array.isArray(event)) {
+                return event;
+            }
+            const sanitized = omitKnownKeys(event, EVENT_USAGE_KEYS);
+            changed = sanitized.changed || changed;
+            return sanitized.value;
+        });
+    }
+    return {
+        value: Array.isArray(root.events) ? { ...topLevel.value, events } : topLevel.value,
+        changed,
+    };
+}
+async function rewriteJson(path, value, assertFence) {
+    await assertFence();
+    await atomicWriteFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+async function cleanUsage(path, assertFence) {
+    const document = await parseJsonFile(path);
+    const sanitized = stripCommercialUsage(document);
+    if (document === undefined || !sanitized.changed) {
+        return 0;
+    }
+    await rewriteJson(path, sanitized.value, assertFence);
+    return 1;
+}
+async function cleanHost(path, assertFence) {
+    const document = await parseJsonFile(path);
+    if (document === undefined || document === null || typeof document !== 'object') {
+        return 0;
+    }
+    const root = document;
+    const sanitizeContainer = (value) => {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            return { value, changed: false };
+        }
+        const container = value;
+        const planu = container.planu;
+        if (planu === null || typeof planu !== 'object' || Array.isArray(planu)) {
+            return { value, changed: false };
+        }
+        const entry = planu;
+        const env = entry.env;
+        if (env === null || typeof env !== 'object' || Array.isArray(env)) {
+            return { value, changed: false };
+        }
+        const sanitized = omitKnownKeys(env, COMMERCIAL_HOST_ENV_KEYS);
+        return {
+            value: sanitized.changed
+                ? { ...container, planu: { ...entry, env: sanitized.value } }
+                : value,
+            changed: sanitized.changed,
+        };
+    };
+    const mcpServers = sanitizeContainer(root.mcpServers);
+    const contextServers = sanitizeContainer(root.context_servers);
+    const changed = mcpServers.changed || contextServers.changed;
+    const sanitizedRoot = {
+        ...root,
+        ...(Object.hasOwn(root, 'mcpServers') ? { mcpServers: mcpServers.value } : {}),
+        ...(Object.hasOwn(root, 'context_servers') ? { context_servers: contextServers.value } : {}),
+    };
+    if (!changed) {
+        return 0;
+    }
+    await rewriteJson(path, sanitizedRoot, assertFence);
+    return 1;
+}
+async function removeFile(path, assertFence) {
+    if (!(await regularFile(path))) {
+        return 0;
+    }
+    await assertFence();
+    await unlink(path);
+    return 1;
+}
+async function matchingFiles(directory, predicate) {
+    try {
+        return (await readdir(directory)).filter(predicate).map((name) => join(directory, name));
+    }
+    catch (error) {
+        if (nodeError(error, 'ENOENT')) {
+            return [];
+        }
+        throw error;
+    }
+}
+async function licenseBackups(licensePath) {
+    const file = basename(licensePath);
+    const stem = file.endsWith('.json') ? file.slice(0, -5) : file;
+    return matchingFiles(dirname(licensePath), (entry) => entry === `${file}.bak` ||
+        (entry.startsWith(`${file}.bak.`) && /^\d+$/u.test(entry.slice(file.length + 5))) ||
+        (entry.startsWith(`${stem}.backup-`) && entry.endsWith('.json')));
+}
+async function hostPathsFromManifest(path) {
+    try {
+        const document = await parseJsonFile(path);
+        if (document === undefined || document === null || typeof document !== 'object') {
+            return [];
+        }
+        const records = document.installations;
+        if (!Array.isArray(records)) {
+            return [];
+        }
+        return records.flatMap((record) => {
+            if (record === null || typeof record !== 'object') {
+                return [];
+            }
+            const configPath = record.configPath;
+            return typeof configPath === 'string' && isAbsolute(configPath) ? [configPath] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function defaultLegacyDataPaths() {
+    const packageRoot = fileURLToPath(new URL('../../../', import.meta.url));
+    return [
+        join(packageRoot, 'data', 'global'),
+        join(homedir(), '.planu', 'data', 'global'),
+        join(homedir(), '.planu'),
+    ];
+}
+function defaultHostConfigPaths(home, project) {
+    return [
+        join(home, '.claude.json'),
+        join(home, '.cursor', 'mcp.json'),
+        join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+        join(home, '.config', 'zed', 'settings.json'),
+        join(home, '.vscode', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+        join(home, '.continue', 'config.json'),
+        join(project, '.claude.json'),
+        join(project, '.cursor', 'mcp.json'),
+        join(project, '.windsurf', 'mcp.json'),
+        join(project, '.zed', 'settings.json'),
+        join(project, '.continue', 'config.json'),
+    ];
+}
+async function cleanDataDirectory(dataPath, assertFence, strict) {
+    const errors = [];
+    const attempt = async (operation, kind) => {
+        try {
+            const count = await operation();
+            if (kind === 'remove') {
+                removedFiles += count;
+            }
+            else {
+                updatedFiles += count;
+            }
+        }
+        catch (error) {
+            const code = cleanupCode(error);
+            errors.push(code);
+            if (strict) {
+                throw new Error(`[Planu] commercial cleanup failed: ${code}`, { cause: error });
+            }
+        }
+    };
+    let removedFiles = 0;
+    let updatedFiles = 0;
+    const licensePath = join(dataPath, 'license.json');
+    await attempt(async () => {
+        const licenseDocument = await parseJsonFile(licensePath);
+        if (licenseDocument && typeof licenseDocument === 'object') {
+            const reference = licenseDocument.licenseKey;
+            if (isSecretReference(reference) && parseSecretReference(reference).purpose === 'license') {
+                await assertFence();
+                await deleteSecretField(reference);
+            }
+        }
+        return removeFile(licensePath, assertFence);
+    }, 'remove');
+    await attempt(async () => {
+        let count = 0;
+        for (const backup of await licenseBackups(licensePath)) {
+            count += await removeFile(backup, assertFence);
+        }
+        return count;
+    }, 'remove');
+    await attempt(() => removeFile(join(dataPath, 'first-run.json'), assertFence), 'remove');
+    await attempt(() => cleanUsage(join(dataPath, 'usage.json'), assertFence), 'update');
+    let archives = [];
+    try {
+        archives = await matchingFiles(dataPath, (name) => ARCHIVED_USAGE.test(name));
+    }
+    catch (error) {
+        errors.push(cleanupCode(error));
+    }
+    for (const archive of archives) {
+        await attempt(() => cleanUsage(archive, assertFence), 'update');
+    }
+    return { removedFiles, updatedFiles, errors };
+}
+export async function removeCommercialState(options = {}) {
+    const layout = resolveStorageLayout();
+    const lockPath = options.lockPath ?? layout.installationManifest;
+    const errors = [];
+    const run = options.lockRunner ?? withUpgradeLock;
+    try {
+        return await run(lockPath, async (assertFence) => {
+            let removedFiles = 0;
+            let updatedFiles = 0;
+            const dataPaths = new Set([
+                options.globalDataPath ?? globalDataDir(),
+                ...(options.legacyGlobalDataPaths ?? defaultLegacyDataPaths()),
+            ]);
+            const hostPaths = new Set([
+                ...(options.hostConfigPaths ?? []),
+                ...defaultHostConfigPaths(options.homeDirectory ?? homedir(), options.projectDirectory ?? process.cwd()),
+                ...(await hostPathsFromManifest(layout.installationManifest)),
+            ]);
+            const attempt = async (operation) => {
+                try {
+                    const result = await operation();
+                    removedFiles += result.removedFiles ?? 0;
+                    updatedFiles += result.updatedFiles ?? 0;
+                }
+                catch (error) {
+                    const code = cleanupCode(error);
+                    errors.push(code);
+                    if (options.strict) {
+                        throw new Error(`[Planu] commercial cleanup failed: ${code}`, { cause: error });
+                    }
+                }
+            };
+            for (const path of dataPaths) {
+                const result = await cleanDataDirectory(path, assertFence, options.strict === true);
+                removedFiles += result.removedFiles;
+                updatedFiles += result.updatedFiles;
+                errors.push(...result.errors);
+            }
+            for (const path of hostPaths) {
+                await attempt(async () => ({ updatedFiles: await cleanHost(path, assertFence) }));
+            }
+            return { removedFiles, updatedFiles, errors };
+        });
+    }
+    catch (error) {
+        if (options.strict) {
+            throw error;
+        }
+        return { removedFiles: 0, updatedFiles: 0, errors: [cleanupCode(error)] };
+    }
+}
+//# sourceMappingURL=remove-commercial-state.js.map

package/dist/engine/minimality/policy-loader.js

@@ -1,9 +1,239 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { constants } from 'node:fs';
+import { lstat, open, readFile, realpath } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
+const BUNDLED_POLICY_ID = 'bundled:minimal-implementation-gate';
+const PROJECT_CONFIG_ID = 'project:planu.json#minimalImplementationGate';
+const REDACTED_POLICY_MESSAGE = 'Minimality policy source is unavailable (external:redacted).';
+const REDACTED_BUNDLED_MESSAGE = 'Bundled minimality policy is unavailable (external:redacted).';
+const MAX_POLICY_BYTES = 1024 * 1024;
+const POLICY_READ_CHUNK_BYTES = 64 * 1024;
+class PolicySourceError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'MINIMALITY_BUNDLED_POLICY_UNAVAILABLE'
+            ? REDACTED_BUNDLED_MESSAGE
+            : REDACTED_POLICY_MESSAGE);
+        this.name = 'PolicySourceError';
+        this.code = code;
+    }
+}
 function configPath() {
     return join(dirname(fileURLToPath(import.meta.url)), '../../config/minimal-implementation-gate.json');
 }
+function isOutside(root, candidate) {
+    const pathFromRoot = relative(root, candidate);
+    return pathFromRoot === '..' || pathFromRoot.startsWith(`..${sep}`) || isAbsolute(pathFromRoot);
+}
+function nodeErrorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+function sourceErrorFor(error) {
+    if (error instanceof PolicySourceError) {
+        return error;
+    }
+    switch (nodeErrorCode(error)) {
+        case 'ENOENT':
+        case 'ENOTDIR':
+            return new PolicySourceError('MINIMALITY_POLICY_SOURCE_NOT_FOUND');
+        case 'ELOOP':
+            return new PolicySourceError('MINIMALITY_POLICY_SOURCE_SYMLINK_REJECTED');
+        case 'EISDIR':
+            return new PolicySourceError('MINIMALITY_POLICY_SOURCE_NOT_REGULAR');
+        case undefined:
+        default:
+            return new PolicySourceError('MINIMALITY_POLICY_SOURCE_UNREADABLE');
+    }
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function sameStableMetadata(left, right) {
+    return (sameIdentity(left, right) &&
+        left.size === right.size &&
+        left.mtimeNs === right.mtimeNs &&
+        left.ctimeNs === right.ctimeNs);
+}
+async function assertNoSymlinkComponents(projectRoot, candidate) {
+    const relativePath = relative(projectRoot, candidate);
+    let current = projectRoot;
+    for (const component of relativePath.split(sep).filter(Boolean)) {
+        current = join(current, component);
+        let status;
+        try {
+            status = await lstat(current);
+        }
+        catch (error) {
+            throw sourceErrorFor(error);
+        }
+        if (status.isSymbolicLink()) {
+            throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_SYMLINK_REJECTED');
+        }
+    }
+}
+function validateExplicitPath(path) {
+    if (path.length === 0 ||
+        path.length > 4096 ||
+        /^project:/iu.test(path) ||
+        path.includes('\0') ||
+        path.includes('?') ||
+        path.includes('#') ||
+        (sep === '/' && path.includes('\\'))) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_INVALID_PATH');
+    }
+}
+async function readBoundedPolicy(handle) {
+    const chunks = [];
+    let offset = 0;
+    while (offset <= MAX_POLICY_BYTES) {
+        const remaining = MAX_POLICY_BYTES + 1 - offset;
+        const chunk = Buffer.allocUnsafe(Math.min(POLICY_READ_CHUNK_BYTES, remaining));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, offset);
+        if (bytesRead === 0) {
+            break;
+        }
+        offset += bytesRead;
+        if (offset > MAX_POLICY_BYTES) {
+            throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_UNREADABLE');
+        }
+        chunks.push(chunk.subarray(0, bytesRead));
+    }
+    return Buffer.concat(chunks, offset).toString('utf8');
+}
+async function resolvePolicySource(projectPath, explicitPath) {
+    if (explicitPath === undefined) {
+        return { path: configPath(), identifier: BUNDLED_POLICY_ID, bundled: true };
+    }
+    validateExplicitPath(explicitPath);
+    if (projectPath === undefined) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_OUTSIDE_ALLOWED_ROOT');
+    }
+    const lexicalRoot = resolve(projectPath);
+    const candidate = isAbsolute(explicitPath)
+        ? resolve(explicitPath)
+        : resolve(lexicalRoot, explicitPath);
+    if (isOutside(lexicalRoot, candidate)) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_OUTSIDE_ALLOWED_ROOT');
+    }
+    let canonicalRoot;
+    try {
+        canonicalRoot = await realpath(lexicalRoot);
+    }
+    catch {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_OUTSIDE_ALLOWED_ROOT');
+    }
+    await assertNoSymlinkComponents(lexicalRoot, candidate);
+    let candidateStatus;
+    let canonicalCandidate;
+    try {
+        [candidateStatus, canonicalCandidate] = await Promise.all([
+            lstat(candidate),
+            realpath(candidate),
+        ]);
+    }
+    catch (error) {
+        throw sourceErrorFor(error);
+    }
+    if (candidateStatus.isSymbolicLink()) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_SYMLINK_REJECTED');
+    }
+    if (!candidateStatus.isFile()) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_NOT_REGULAR');
+    }
+    if (isOutside(canonicalRoot, canonicalCandidate)) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_OUTSIDE_ALLOWED_ROOT');
+    }
+    const portablePath = relative(canonicalRoot, canonicalCandidate)
+        .replaceAll('\\', '/')
+        .normalize('NFC');
+    if (portablePath.length === 0 ||
+        portablePath.startsWith('../') ||
+        portablePath.startsWith('project:') ||
+        /^[a-z]:/iu.test(portablePath) ||
+        isAbsolute(portablePath)) {
+        throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_INVALID_PATH');
+    }
+    return {
+        path: candidate,
+        identifier: `project:${portablePath}`,
+        bundled: false,
+        projectRoot: lexicalRoot,
+    };
+}
+async function readStableJson(source) {
+    try {
+        if (source.projectRoot !== undefined) {
+            await assertNoSymlinkComponents(source.projectRoot, source.path);
+        }
+        const canonicalBefore = await realpath(source.path);
+        const pathBefore = await lstat(source.path, { bigint: true });
+        if (pathBefore.isSymbolicLink()) {
+            throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_SYMLINK_REJECTED');
+        }
+        if (!pathBefore.isFile()) {
+            throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_NOT_REGULAR');
+        }
+        let handle;
+        try {
+            handle = await open(source.path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        }
+        catch (error) {
+            if (nodeErrorCode(error) === 'ELOOP') {
+                throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_CHANGED');
+            }
+            throw error;
+        }
+        try {
+            const handleBefore = await handle.stat({ bigint: true });
+            if (!handleBefore.isFile() || !sameIdentity(pathBefore, handleBefore)) {
+                throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_CHANGED');
+            }
+            if (handleBefore.size > BigInt(MAX_POLICY_BYTES)) {
+                throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_UNREADABLE');
+            }
+            const content = await readBoundedPolicy(handle);
+            let handleAfter;
+            let pathAfter;
+            let canonicalAfter;
+            try {
+                [handleAfter, pathAfter, canonicalAfter] = await Promise.all([
+                    handle.stat({ bigint: true }),
+                    lstat(source.path, { bigint: true }),
+                    realpath(source.path),
+                ]);
+            }
+            catch {
+                throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_CHANGED');
+            }
+            if (canonicalBefore !== canonicalAfter ||
+                !sameStableMetadata(pathBefore, pathAfter) ||
+                !sameStableMetadata(handleBefore, handleAfter) ||
+                !sameIdentity(pathAfter, handleAfter)) {
+                throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_CHANGED');
+            }
+            if (source.projectRoot !== undefined) {
+                try {
+                    await assertNoSymlinkComponents(source.projectRoot, source.path);
+                }
+                catch {
+                    throw new PolicySourceError('MINIMALITY_POLICY_SOURCE_CHANGED');
+                }
+            }
+            return JSON.parse(content);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (source.bundled) {
+            throw new PolicySourceError('MINIMALITY_BUNDLED_POLICY_UNAVAILABLE');
+        }
+        throw sourceErrorFor(error);
+    }
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -109,10 +339,21 @@ async function readJson(path) {
     return JSON.parse(await readFile(path, 'utf-8'));
 }
 export async function loadMinimalImplementationPolicy(projectPath, options = {}) {
-    const defaultPolicyPath = options.defaultPolicyPath ?? configPath();
-    const defaultPolicy = validatePolicy(await readJson(defaultPolicyPath));
+    const source = await resolvePolicySource(projectPath, options.defaultPolicyPath);
+    let defaultPolicy;
+    try {
+        defaultPolicy = validatePolicy(await readStableJson(source));
+    }
+    catch (error) {
+        if (error instanceof PolicySourceError) {
+            throw error;
+        }
+        throw source.bundled
+            ? new PolicySourceError('MINIMALITY_BUNDLED_POLICY_UNAVAILABLE')
+            : new PolicySourceError('MINIMALITY_POLICY_SOURCE_UNREADABLE');
+    }
     const evidence = [
-        { source: 'policy', key: defaultPolicyPath },
+        { source: 'policy', key: source.identifier },
     ];
     let merged = defaultPolicy;
     if (projectPath !== undefined) {
@@ -121,7 +362,7 @@ export async function loadMinimalImplementationPolicy(projectPath, options = {})
             const config = await readJson(planuConfigPath);
             if (isRecord(config) && isRecord(config.minimalImplementationGate)) {
                 merged = validatePolicy(mergeDeep(defaultPolicy, config.minimalImplementationGate));
-                evidence.push({ source: 'project-config', key: 'planu.json.minimalImplementationGate' });
+                evidence.push({ source: 'project-config', key: PROJECT_CONFIG_ID });
             }
         }
         catch {

package/dist/engine/network-policy.js

@@ -49,6 +49,7 @@ function environmentConsent() {
 }
 function isNetworkPurpose(value) {
     return (value === 'dependency-audit' ||
+        value === 'feedback' ||
         value === 'integration' ||
         value === 'oauth' ||
         value === 'registry' ||

package/dist/engine/planu-core.darwin-arm64.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "4.14.1",
-  "engineVersion": "4.14.1",
-  "buildId": "1-4.14.1-aarch64-apple-darwin",
+  "cliVersion": "5.1.1",
+  "engineVersion": "5.1.1",
+  "buildId": "1-5.1.1-aarch64-apple-darwin",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -17,15 +17,15 @@
   "platform": "darwin",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "5e2c55c2f381c543c0909efb8bc183ba9bbd44f8c4f5faacc61bb6d0a603e794",
+  "artifactSha256": "3791a7635fda74d3c0c5a226115ac4ab78c98afc366d0451a107ed1419139873",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.darwin-arm64.node.sbom.json",
-    "sha256": "04829beb5af09b1b805f3454bf58f9cbff09b6d6b08a18f9cf0591172d7cc413"
+    "sha256": "434d0491e2130ac49b7eb34989f5ae2135f3ad9f54f0042f5bb3ba660bd2c568"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "6f1f1f95b8f68ae5e9987ef924987e1e9112b27a",
+    "sourceCommit": "5046eff43d23641fe60bd1c01e8c34277172db16",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -34,6 +34,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "vi1PiQ/jDc4F21zckyqwUSUPqCDb1qsp/UY7HO+a2puJBml0yh8WJKhvcQZ6RRyDZDrApq078WcNsGhncR+EBg=="
+    "value": "7kFQj3Sq5rFuMciulVbszYysMir4sSVuTrgLv0exAYSmkfwj16xag4ldwYRCJky/EXeCn1ZYZYJvfuCNEqZ5DQ=="
   }
 }