peaks-loop 4.1.2 → 4.1.4

package/dist/services/config/config-coercion.js

@@ -0,0 +1,156 @@
+/**
+ * Coercion of untrusted JSON into the typed config shapes.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { isRecord, isSafeConfigSegment } from './config-primitives.js';
+import { isValidProxyUrl } from './config-validation.js';
+function toArtifactRemoteRepoConfig(value) {
+    if (!isRecord(value) ||
+        (value.provider !== 'github' && value.provider !== 'gitlab') ||
+        typeof value.owner !== 'string' ||
+        typeof value.name !== 'string') {
+        return null;
+    }
+    if (!isSafeConfigSegment(value.owner) || !isSafeConfigSegment(value.name)) {
+        return null;
+    }
+    return { provider: value.provider, owner: value.owner, name: value.name };
+}
+function toArtifactStorageConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const localPath = typeof value.localPath === 'string' ? { localPath: value.localPath } : {};
+    if (value.mode === 'local') {
+        return { mode: 'local', ...localPath };
+    }
+    const remote = toArtifactRemoteRepoConfig(value.remote);
+    if (value.mode === 'local-with-remote-sync' && remote) {
+        return { mode: 'local-with-remote-sync', ...localPath, remote };
+    }
+    return null;
+}
+function toWorkspaceConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const { workspaceId, name, rootPath, installedCapabilityIds } = value;
+    if (typeof workspaceId !== 'string' ||
+        !isSafeConfigSegment(workspaceId) ||
+        typeof name !== 'string' ||
+        typeof rootPath !== 'string' ||
+        !Array.isArray(installedCapabilityIds) ||
+        !installedCapabilityIds.every((id) => typeof id === 'string')) {
+        return null;
+    }
+    const artifactRepo = toArtifactRemoteRepoConfig(value.artifactRepo);
+    const artifactStorage = toArtifactStorageConfig(value.artifactStorage);
+    return {
+        workspaceId,
+        name,
+        rootPath,
+        installedCapabilityIds,
+        ...(artifactRepo ? { artifactRepo } : {}),
+        ...(artifactStorage ? { artifactStorage } : {})
+    };
+}
+export function toWorkspaceConfigs(value) {
+    return Array.isArray(value)
+        ? value
+            .map(toWorkspaceConfig)
+            .filter((workspace) => workspace !== null)
+        : [];
+}
+export function toProviderModelConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return {
+        ...(typeof value.model === 'string' && value.model.trim().length > 0
+            ? { model: value.model.trim() }
+            : {}),
+        ...(typeof value.baseUrl === 'string' ? { baseUrl: value.baseUrl } : {}),
+        ...(typeof value.apiKey === 'string' ? { apiKey: value.apiKey } : {})
+    };
+}
+const TOKEN_CONFIG_KEYS = new Set([
+    'AnthropicApiKey',
+    'OpenAiApiKey',
+    'GitHubToken',
+    'GitLabToken'
+]);
+function toTokenRef(value) {
+    if (!isRecord(value))
+        return null;
+    const env = typeof value.env === 'string' ? value.env.trim() : '';
+    const keychain = typeof value.keychain === 'string' ? value.keychain.trim() : '';
+    if (env.length > 0) {
+        return { env };
+    }
+    if (keychain.length > 0) {
+        return { keychain };
+    }
+    if (value.ghCli === true) {
+        return { ghCli: true };
+    }
+    return null;
+}
+export function toTokenConfig(value) {
+    if (!isRecord(value))
+        return {};
+    const tokens = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!TOKEN_CONFIG_KEYS.has(key))
+            continue;
+        const tokenRef = toTokenRef(entry);
+        if (tokenRef) {
+            tokens[key] = tokenRef;
+        }
+    }
+    return tokens;
+}
+export function toModelProviderConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([providerId, providerConfig]) => [
+        providerId,
+        toProviderModelConfig(providerConfig)
+    ]));
+}
+function toProxyConfig(value) {
+    if (!isRecord(value))
+        return null;
+    return typeof value.httpProxy === 'string' && isValidProxyUrl(value.httpProxy)
+        ? { httpProxy: value.httpProxy }
+        : null;
+}
+export function inferHumanLanguage(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error('Language must be non-empty');
+    }
+    if (/^zh(?:-|$)/i.test(normalized) || /[㐀-鿿]/u.test(normalized)) {
+        return 'zh-CN';
+    }
+    if (/^en(?:-|$)/i.test(normalized)) {
+        return 'en';
+    }
+    return 'en';
+}
+export function toPeaksConfig(value) {
+    if (!isRecord(value))
+        return {};
+    const proxy = toProxyConfig(value.proxy);
+    return {
+        ...(typeof value.version === 'string' ? { version: value.version } : {}),
+        ...(typeof value.language === 'string' ? { language: value.language } : {}),
+        ...(typeof value.model === 'string' && ['haiku', 'sonnet', 'opus'].includes(value.model)
+            ? { model: value.model }
+            : {}),
+        ...(typeof value.economyMode === 'boolean' ? { economyMode: value.economyMode } : {}),
+        ...(typeof value.swarmMode === 'boolean' ? { swarmMode: value.swarmMode } : {}),
+        ...(isRecord(value.tokens) ? { tokens: toTokenConfig(value.tokens) } : {}),
+        ...(isRecord(value.providers) ? { providers: toModelProviderConfig(value.providers) } : {}),
+        ...(proxy ? { proxy } : {})
+    };
+}

package/dist/services/config/config-file-io.d.ts

@@ -0,0 +1,11 @@
+import type { PeaksConfig } from './config-types.js';
+export declare function readJsonFile(path: string | null, validateBeforeRead?: () => void, errorMessage?: string): Partial<PeaksConfig> | null;
+export declare function readExistingJsonFile(path: string, errorMessage: string, validateBeforeRead?: () => void): Partial<PeaksConfig> | null;
+export declare function readUserJsonFile(): Partial<PeaksConfig> | null;
+export declare function readProjectJsonFile(projectRoot: string | null): Partial<PeaksConfig> | null;
+export declare function ensureDir(dirPath: string): void;
+export declare function getProjectWriteTarget(): {
+    projectRoot: string;
+    configPath: string;
+};
+export declare function removeProjectSensitiveConfig(config: Partial<PeaksConfig>): Partial<PeaksConfig>;

package/dist/services/config/config-file-io.js

@@ -0,0 +1,61 @@
+/**
+ * Safe config-file reads/writes and the project-layer write target.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { existsSync, mkdirSync } from 'node:fs';
+import { findProjectRoot, getProjectConfigPath, getUserConfigPath, readConfigFileSafely, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite } from './config-safety.js';
+import { containsSensitiveConfigValue, isSecretKey } from './config-validation.js';
+export function readJsonFile(path, validateBeforeRead, errorMessage = 'Config path must stay inside the config root') {
+    if (!path || !existsSync(path))
+        return null;
+    validateBeforeRead?.();
+    const content = readConfigFileSafely(path, errorMessage);
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        return null;
+    }
+}
+export function readExistingJsonFile(path, errorMessage, validateBeforeRead) {
+    if (!existsSync(path))
+        return null;
+    validateBeforeRead?.();
+    try {
+        return JSON.parse(readConfigFileSafely(path, errorMessage));
+    }
+    catch {
+        throw new Error(errorMessage);
+    }
+}
+export function readUserJsonFile() {
+    const userPath = getUserConfigPath();
+    return readJsonFile(userPath, () => validateUserConfigPathForWrite(userPath), 'User config path must stay inside the user root');
+}
+export function readProjectJsonFile(projectRoot) {
+    const projectPath = getProjectConfigPath(projectRoot);
+    return readJsonFile(projectPath, projectRoot && projectPath
+        ? () => validateProjectBootstrapConfigPathForWrite(projectRoot, projectPath)
+        : undefined, 'Project config path must stay inside the project root');
+}
+export function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+export function getProjectWriteTarget() {
+    const projectRoot = findProjectRoot(process.cwd());
+    const configPath = getProjectConfigPath(projectRoot);
+    if (!projectRoot || !configPath) {
+        throw new Error('Project config not found');
+    }
+    return { projectRoot, configPath };
+}
+export function removeProjectSensitiveConfig(config) {
+    const OMITTED_KEYS = new Set(['providers', 'proxy', 'tokens']);
+    return Object.fromEntries(Object.entries(config).filter(([key, value]) => !OMITTED_KEYS.has(key) && !isSecretKey(key) && !containsSensitiveConfigValue(value)));
+}

package/dist/services/config/config-get.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigGetOptions } from './config-types.js';
+export declare function getConfig(options?: ConfigGetOptions): unknown;

package/dist/services/config/config-get.js

@@ -0,0 +1,36 @@
+/**
+ * The layered `peaks config get` reader.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { findProjectRoot } from './config-safety.js';
+import { getNestedValue } from './config-nested-path.js';
+import { isRecord, omitProxy } from './config-primitives.js';
+import { toTokenConfig } from './config-coercion.js';
+import { readProjectJsonFile, readUserJsonFile, removeProjectSensitiveConfig } from './config-file-io.js';
+export function getConfig(options = {}) {
+    const projectRoot = findProjectRoot(process.cwd());
+    const userConfig = readUserJsonFile() ?? {};
+    const projectConfig = removeProjectSensitiveConfig(readProjectJsonFile(projectRoot) ?? {});
+    const projectConfigWithoutProxy = omitProxy(projectConfig);
+    const source = options.layer === 'user'
+        ? userConfig
+        : options.layer === 'project'
+            ? projectConfig
+            : {
+                ...userConfig,
+                ...projectConfigWithoutProxy
+            };
+    const config = isRecord(source)
+        ? {
+            ...source,
+            ...(source.tokens !== undefined ? { tokens: toTokenConfig(source.tokens) } : {})
+        }
+        : source;
+    if (options.key !== undefined) {
+        return getNestedValue(config, options.key);
+    }
+    return config;
+}

package/dist/services/config/config-global-loader.d.ts

@@ -0,0 +1,15 @@
+import { type ConfigV2 } from './config-types.js';
+/**
+ * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed
+ * object when the file is at schema 2.0.0; returns null when the
+ * file is absent (fresh install, no global config yet).
+ *
+ * Throws `CONFIG_LEGACY_VERSION` when the file exists at a 1.x
+ * schema version — the caller is expected to run
+ * `peaks config migrate --apply` to bring it forward before
+ * continuing. This gate is intentional: a slim 2.0 reader must
+ * not silently pass through a 1.x shape, because every field it
+ * ignores is a field the caller is going to look for elsewhere
+ * (preferences.json, .bak, _state/).
+ */
+export declare function loadGlobalConfig(): ConfigV2 | null;

package/dist/services/config/config-global-loader.js

@@ -0,0 +1,111 @@
+/**
+ * The slim 2.0 `~/.peaks/config.json` loader and its legacy promotion.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { existsSync } from 'node:fs';
+import { CONFIG_SCHEMA_VERSION_V2, globalConfigPath } from './config-migration.js';
+import { readConfigFileSafely, writeUserConfigFile } from './config-safety.js';
+import { isRecord } from './config-primitives.js';
+import { SIDECAR_SCHEMA_VERSION, providersConfigPath, proxyConfigPath, readSidecarJson, sidecarExists, workspacesConfigPath, writeSidecarJson } from './sidecar-store.js';
+import { isConfigV2 } from './config-types.js';
+/**
+ * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed
+ * object when the file is at schema 2.0.0; returns null when the
+ * file is absent (fresh install, no global config yet).
+ *
+ * Throws `CONFIG_LEGACY_VERSION` when the file exists at a 1.x
+ * schema version — the caller is expected to run
+ * `peaks config migrate --apply` to bring it forward before
+ * continuing. This gate is intentional: a slim 2.0 reader must
+ * not silently pass through a 1.x shape, because every field it
+ * ignores is a field the caller is going to look for elsewhere
+ * (preferences.json, .bak, _state/).
+ */
+export function loadGlobalConfig() {
+    const path = globalConfigPath();
+    if (!existsSync(path))
+        return null;
+    const content = readConfigFileSafely(path, 'Global config path must stay inside the user root');
+    const raw = JSON.parse(content);
+    if (isConfigV2(raw)) {
+        if (hasLegacyGlobalFields(raw)) {
+            promoteLegacyGlobalFieldsToSidecars(raw);
+            rewriteSlimGlobalConfig();
+        }
+        return readSlimGlobalConfig();
+    }
+    const detected = typeof raw.version === 'string' ? raw.version : 'unknown';
+    throw new Error(`CONFIG_LEGACY_VERSION: ~/.peaks/config.json is at version "${detected}", expected ${CONFIG_SCHEMA_VERSION_V2}. Run \`peaks config migrate --apply\`.`);
+}
+/**
+ * Slim 2.0 schema allows `version` + `ocr`. Any other top-level
+ * field is a legacy artifact that needs to be promoted to a
+ * sidecar file.
+ */
+function hasLegacyGlobalFields(raw) {
+    const allowed = new Set(['version', 'ocr']);
+    return Object.keys(raw).some((k) => !allowed.has(k));
+}
+/**
+ * One-shot promotion of legacy fields into their dedicated sidecar
+ * files. Idempotent: if the sidecar already has the field, the
+ * legacy value is dropped (sidecar is the new source of truth).
+ */
+function promoteLegacyGlobalFieldsToSidecars(raw) {
+    if (isRecord(raw.providers)) {
+        const existing = readSidecarJson(providersConfigPath(), {
+            version: SIDECAR_SCHEMA_VERSION,
+            providers: {}
+        });
+        const mergedProviders = {
+            ...(existing.providers ?? {}),
+            ...raw.providers
+        };
+        writeSidecarJson(providersConfigPath(), {
+            version: SIDECAR_SCHEMA_VERSION,
+            providers: mergedProviders
+        });
+    }
+    if (isRecord(raw.proxy) && typeof raw.proxy.httpProxy === 'string') {
+        const httpProxy = raw.proxy.httpProxy;
+        if (!sidecarExists(proxyConfigPath())) {
+            writeSidecarJson(proxyConfigPath(), { version: SIDECAR_SCHEMA_VERSION, httpProxy });
+        }
+    }
+    if (Array.isArray(raw.workspaces) || typeof raw.currentWorkspace === 'string') {
+        if (!sidecarExists(workspacesConfigPath())) {
+            writeSidecarJson(workspacesConfigPath(), {
+                version: SIDECAR_SCHEMA_VERSION,
+                workspaces: Array.isArray(raw.workspaces) ? raw.workspaces : [],
+                currentWorkspace: typeof raw.currentWorkspace === 'string' ? raw.currentWorkspace : null
+            });
+        }
+    }
+}
+function readSlimGlobalConfig() {
+    const path = globalConfigPath();
+    if (!existsSync(path)) {
+        return { version: CONFIG_SCHEMA_VERSION_V2 };
+    }
+    const content = readConfigFileSafely(path, 'Global config path must stay inside the user root');
+    return JSON.parse(content);
+}
+function rewriteSlimGlobalConfig() {
+    const path = globalConfigPath();
+    const ocr = readOcrFromRawConfigFile();
+    const slim = { version: CONFIG_SCHEMA_VERSION_V2 };
+    if (ocr !== null)
+        slim['ocr'] = ocr;
+    writeUserConfigFile(path, JSON.stringify(slim, null, 2) + '\n');
+}
+function readOcrFromRawConfigFile() {
+    const path = globalConfigPath();
+    if (!existsSync(path))
+        return null;
+    const content = readConfigFileSafely(path, 'Global config path must stay inside the user root');
+    const raw = JSON.parse(content);
+    return isRecord(raw.ocr) ? raw.ocr : null;
+}

package/dist/services/config/config-nested-path.d.ts

@@ -0,0 +1,3 @@
+export declare function getNestedPathParts(path: string): string[];
+export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+export declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void;

package/dist/services/config/config-nested-path.js

@@ -0,0 +1,53 @@
+/**
+ * Dotted-path access into a raw config object, with prototype-pollution guards.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+const UNSAFE_NESTED_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+export function getNestedPathParts(path) {
+    return path
+        .replace(/\[(\d+)\]/g, '.$1')
+        .split('.')
+        .filter(Boolean);
+}
+function hasUnsafeNestedPathSegment(parts) {
+    return parts.some((part) => UNSAFE_NESTED_PATH_SEGMENTS.has(part));
+}
+export function getNestedValue(obj, path) {
+    const parts = getNestedPathParts(path);
+    if (parts.length === 0 || hasUnsafeNestedPathSegment(parts)) {
+        return undefined;
+    }
+    let current = obj;
+    for (const part of parts) {
+        if (current === null ||
+            current === undefined ||
+            typeof current !== 'object' ||
+            !Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function setNestedValue(obj, path, value) {
+    const parts = getNestedPathParts(path);
+    if (parts.length === 0 || hasUnsafeNestedPathSegment(parts)) {
+        throw new Error('Unsafe config path');
+    }
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!Object.prototype.hasOwnProperty.call(current, part) ||
+            typeof current[part] !== 'object' ||
+            current[part] === null ||
+            Array.isArray(current[part])) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    const last = parts[parts.length - 1];
+    current[last] = value;
+}

package/dist/services/config/config-primitives.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shape predicates shared by the config reader/writer family.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isSafeConfigSegment(value: string): boolean;
+/**
+ * A shallow copy of `value` with the `proxy` key removed. The project layer's
+ * config is always consumed without its `proxy` (the proxy belongs to the user
+ * layer), and spreading around a named rest sibling left a binding no reader
+ * needs.
+ */
+export declare function omitProxy<T extends object>(value: T): Omit<T, 'proxy'>;

package/dist/services/config/config-primitives.js

@@ -0,0 +1,24 @@
+/**
+ * Shape predicates shared by the config reader/writer family.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function isSafeConfigSegment(value) {
+    return (/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value) && !value.includes('..') && !value.endsWith('.'));
+}
+/**
+ * A shallow copy of `value` with the `proxy` key removed. The project layer's
+ * config is always consumed without its `proxy` (the proxy belongs to the user
+ * layer), and spreading around a named rest sibling left a binding no reader
+ * needs.
+ */
+export function omitProxy(value) {
+    const copy = { ...value };
+    delete copy['proxy'];
+    return copy;
+}

package/dist/services/config/config-service.d.ts

@@ -1,19 +1,12 @@
-import { type ConfigGetOptions, type ConfigLayer, type ConfigSetOptions, type ConfigV2, type PeaksConfig, type TokenRef, type WorkspaceConfig } from './config-types.js';
+import { type ConfigLayer, type ConfigSetOptions, type PeaksConfig, type TokenRef, type WorkspaceConfig } from './config-types.js';
+import { getUserConfigPath } from './config-safety.js';
+import { containsSensitiveConfigValue, isLegacyConfigKey, isSensitiveConfigPath, redactConfigSecrets, type RedactedConfigValue } from './config-validation.js';
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
-/**
- * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed
- * object when the file is at schema 2.0.0; returns null when the
- * file is absent (fresh install, no global config yet).
- *
- * Throws `CONFIG_LEGACY_VERSION` when the file exists at a 1.x
- * schema version — the caller is expected to run
- * `peaks config migrate --apply` to bring it forward before
- * continuing. This gate is intentional: a slim 2.0 reader must
- * not silently pass through a 1.x shape, because every field it
- * ignores is a field the caller is going to look for elsewhere
- * (preferences.json, .bak, _state/).
- */
-export declare function loadGlobalConfig(): ConfigV2 | null;
+export { getConfig } from './config-get.js';
+export { loadGlobalConfig } from './config-global-loader.js';
+export { addWorkspace, ensureWorkspaceConfigForCurrentPath, ensureWorkspaceConfigForPath, getCurrentWorkspaceConfig, getWorkspaceConfig, getWorkspaceConfigForCurrentPath, getWorkspaceConfigForPath, removeWorkspace, setCurrentWorkspace } from './config-workspace.js';
+export { containsSensitiveConfigValue, isLegacyConfigKey, isSensitiveConfigPath, redactConfigSecrets };
+export type { RedactedConfigValue };
 export declare function isConfigLayer(value: string): value is ConfigLayer;
 /**
  * Machine-scoped context-window override key, the config twin of the
@@ -31,27 +24,10 @@ export declare const CONTEXT_WINDOW_TOKENS_CONFIG_KEY = "context.windowTokens";
  * never throws (a corrupt config must not crash a context probe).
  */
 export declare function readContextWindowTokensOverride(projectRoot?: string | null): unknown;
-export declare function isSensitiveConfigPath(path: string): boolean;
-export declare function isLegacyConfigKey(path: string): boolean;
-export declare function containsSensitiveConfigValue(value: unknown): boolean;
-export type RedactedConfigValue = string | number | boolean | null | RedactedConfigValue[] | {
-    [key: string]: RedactedConfigValue;
-};
-export declare function redactConfigSecrets(value: unknown, path?: string): RedactedConfigValue;
 export declare function bootstrapProjectLanguageConfig(projectRoot: string, language: string): void;
 export declare function readConfig(projectRoot?: string | null): PeaksConfig;
 export declare function writeConfig(partial: Partial<PeaksConfig>, layer?: ConfigLayer): void;
-export declare function getConfig(options?: ConfigGetOptions): unknown;
 export declare function setConfig(options: ConfigSetOptions): void;
-export declare function getWorkspaceConfig(workspaceId: string, _projectRoot?: string | null): WorkspaceConfig | null;
-export declare function addWorkspace(workspace: WorkspaceConfig, layer?: ConfigLayer): void;
-export declare function removeWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
-export declare function setCurrentWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
-export declare function getCurrentWorkspaceConfig(): WorkspaceConfig | null;
-export declare function getWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
-export declare function ensureWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
-export declare function getWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
-export declare function ensureWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
 export type { TokenRef, WorkspaceConfig, PeaksConfig, ConfigLayer };
-export { getUserConfigPath } from './config-safety.js';
+export { getUserConfigPath };
 export { globalConfigPath } from './config-migration.js';