peaks-cli 1.0.13 → 1.0.15

package/dist/src/cli/commands/core-artifact-commands.js

@@ -7,6 +7,7 @@ import { planProxyTest } from '../../services/proxy/proxy-service.js';
 import { runDoctor } from '../../services/doctor/doctor-service.js';
 import { listSkills } from '../../services/skills/skill-registry.js';
 import { inspectSkillRunbook } from '../../services/skills/skill-runbook-service.js';
+import { setSkillPresence, clearSkillPresence, getSkillPresence } from '../../services/skills/skill-presence-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, isArtifactProvider, isArtifactSetupStep, printResult } from '../cli-helpers.js';
 export function registerCoreAndArtifactCommands(program, io) {
@@ -56,6 +57,30 @@ export function registerCoreAndArtifactCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    addJsonOption(skill
+        .command('presence')
+        .description('Show the currently active Peaks skill')).action((options) => {
+        const presence = getSkillPresence();
+        if (presence === null) {
+            printResult(io, ok('skill.presence', { active: false }), options.json);
+            return;
+        }
+        printResult(io, ok('skill.presence', { active: true, ...presence }), options.json);
+    });
+    addJsonOption(skill
+        .command('presence:set <name>')
+        .description('Set the currently active Peaks skill for session-wide visibility')
+        .option('--mode <mode>', 'execution mode')
+        .option('--gate <gate>', 'current gate')).action((name, options) => {
+        const presence = setSkillPresence(name, options.mode, options.gate);
+        printResult(io, ok('skill.presence:set', { active: true, ...presence }), options.json);
+    });
+    addJsonOption(skill
+        .command('presence:clear')
+        .description('Clear the active Peaks skill presence indicator')).action((options) => {
+        const removed = clearSkillPresence();
+        printResult(io, ok('skill.presence:clear', { active: false, removed }), options.json);
+    });
     const profile = program.command('profile').description('Manage runtime profiles');
     addJsonOption(profile.command('list').description('List available profiles')).action((options) => {
         printResult(io, ok('profile.list', { profiles: listProfiles() }), options.json);

package/dist/src/cli/commands/project-commands.js

@@ -22,6 +22,11 @@ export function registerProjectCommands(program, io) {
                 process.exitCode = 1;
                 return;
             }
+            if (dashboard.skillPresence.active && !dashboard.skillPresence.fresh) {
+                printResult(io, fail('project.dashboard', 'PROJECT_DASHBOARD_STALE_SKILL_PRESENCE', `Active Peaks skill presence ${dashboard.skillPresence.skill ?? '<unknown>'} is stale (set ${dashboard.skillPresence.setAt ?? '<unknown>'})`, dashboard, ['Run `peaks skill presence:clear` if the role has ended, or `peaks skill presence:set <skill>` to refresh it']), options.json);
+                process.exitCode = 1;
+                return;
+            }
             if (!dashboard.doctor.ok) {
                 printResult(io, fail('project.dashboard', 'PROJECT_DASHBOARD_DOCTOR_FAILED', `Doctor reports ${dashboard.doctor.failed} failed check(s) (${dashboard.doctor.passed} passed)`, dashboard, ['Run `peaks doctor --json` and resolve the failing checks before re-running the dashboard']), options.json);
                 process.exitCode = 1;

package/dist/src/cli/commands/request-commands.js

@@ -2,7 +2,7 @@ import { InvalidArgumentError } from 'commander';
 import { allowedStatesForRole, createRequestArtifact, listRequestArtifacts, showRequestArtifact, transitionRequestArtifact } from '../../services/artifacts/request-artifact-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-const VALID_ROLES = ['prd', 'ui', 'rd', 'qa'];
+const VALID_ROLES = ['prd', 'ui', 'rd', 'qa', 'sc'];
 function parseRole(value) {
     if (!VALID_ROLES.includes(value)) {
         throw new InvalidArgumentError(`must be one of ${VALID_ROLES.join(', ')}`);

package/dist/src/cli/commands/workflow-commands.js

@@ -2,6 +2,7 @@ import { createRdSwarmPlan } from '../../services/rd/rd-service.js';
 import { createTechPlan, getTechStatus } from '../../services/tech/tech-service.js';
 import { createWorkflowRouterPlan, isSoloMode, isWorkflowMode } from '../../services/workflow/workflow-router-service.js';
 import { createAutonomousWorkflowPlan } from '../../services/workflow/workflow-autonomous-service.js';
+import { writeAutonomousResumeArtifacts } from '../../services/workflow/autonomous-resume-writer.js';
 import { createRecommendationPlan } from '../../services/recommendations/recommendation-service.js';
 import { createRefactorDryRun } from '../../services/refactor/refactor-service.js';
 import { ensureWorkspaceConfigForCurrentPath, getCurrentWorkspaceConfig, readConfig } from '../../services/config/config-service.js';
@@ -196,6 +197,31 @@ function runSwarmPlan(io, options) {
         process.exitCode = 1;
     }
 }
+async function runAutonomousResumeInit(io, options) {
+    try {
+        if (!options.project || !options.project.trim()) {
+            throw new Error('Project path must be non-empty');
+        }
+        const result = await writeAutonomousResumeArtifacts({
+            changeId: options.changeId,
+            goal: options.goal,
+            artifactWorkspacePath: options.project,
+            apply: options.apply === true
+        });
+        const data = {
+            applied: result.applied,
+            files: result.files.map((file) => file.path)
+        };
+        const nextActions = result.applied
+            ? ['Run peaks workflow autonomous --change-id ' + options.changeId + ' --goal "<goal>" --json to verify resumePlan.status']
+            : ['Re-run with --apply to write the resume scaffold to disk'];
+        printResult(io, ok('autonomous-resume.init', data, [], nextActions), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('autonomous-resume.init', 'AUTONOMOUS_RESUME_INIT_FAILED', getErrorMessage(error), {}, ['Use a safe change id, a non-empty goal, and a writable project path']), options.json);
+        process.exitCode = 1;
+    }
+}
 function addTechPlanOptions(command) {
     return addJsonOption(command
         .description('Generate a technical dry-run graph')
@@ -232,6 +258,14 @@ function addSwarmPlanOptions(command, includeSkill) {
     }
     return addJsonOption(configured);
 }
+function addAutonomousResumeInitOptions(command) {
+    return addJsonOption(command
+        .description('Write the autonomous resume artifact scaffold for a change-id')
+        .requiredOption('--change-id <id>', 'change identifier')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .requiredOption('--project <path>', 'artifact workspace path to write under')
+        .option('--apply', 'write the artifacts to disk (default is dry-run preview)'));
+}
 export function registerWorkflowCommands(program, io) {
     const refactor = program.command('refactor').description('Plan a Peaks refactor run without modifying code');
     addJsonOption(refactor
@@ -261,6 +295,10 @@ export function registerWorkflowCommands(program, io) {
     addWorkflowRouteOptions(program.command('route'), 'Plan a workflow routing dry-run summary').action((options) => runWorkflowRoute(io, options));
     addWorkflowRouteOptions(workflow.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
     addWorkflowRouteOptions(program.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
+    const autonomousResume = workflow.command('autonomous-resume').description('Manage autonomous workflow resume artifacts');
+    addAutonomousResumeInitOptions(autonomousResume.command('init')).action((options) => runAutonomousResumeInit(io, options));
+    const autonomousResumeAlias = program.command('autonomous-resume').description('Manage autonomous workflow resume artifacts');
+    addAutonomousResumeInitOptions(autonomousResumeAlias.command('init')).action((options) => runAutonomousResumeInit(io, options));
     const swarm = program.command('swarm').description('Plan RD swarm dry-run graphs');
     addSwarmPlanOptions(swarm.command('plan'), true).action((options) => runSwarmPlan(io, options));
     addSwarmPlanOptions(program.command('swarm-plan'), false).action((options) => runSwarmPlan(io, options));

package/dist/src/services/artifacts/request-artifact-service.d.ts

@@ -1,4 +1,4 @@
-export type RequestArtifactRole = 'prd' | 'ui' | 'rd' | 'qa';
+export type RequestArtifactRole = 'prd' | 'ui' | 'rd' | 'qa' | 'sc';
 export type CreateRequestArtifactOptions = {
     role: RequestArtifactRole;
     requestId: string;
@@ -40,7 +40,7 @@ export type ShowRequestArtifactResult = RequestArtifactSummary & {
 };
 export declare function listRequestArtifacts(options: ListRequestArtifactsOptions): Promise<RequestArtifactSummary[]>;
 export declare function showRequestArtifact(options: ShowRequestArtifactOptions): Promise<ShowRequestArtifactResult | null>;
-export type RequestArtifactState = 'draft' | 'confirmed-by-user' | 'direction-locked' | 'spec-locked' | 'implemented' | 'qa-handoff' | 'running' | 'verdict-issued' | 'handed-off' | 'blocked';
+export type RequestArtifactState = 'draft' | 'confirmed-by-user' | 'direction-locked' | 'spec-locked' | 'implemented' | 'qa-handoff' | 'running' | 'verdict-issued' | 'impact-recorded' | 'boundary-recorded' | 'handed-off' | 'blocked';
 export declare function allowedStatesForRole(role: RequestArtifactRole): ReadonlyArray<RequestArtifactState>;
 export type TransitionRequestArtifactOptions = {
     role: RequestArtifactRole;

package/dist/src/services/artifacts/request-artifact-service.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { isDirectory, listDirectories, pathExists } from '../../shared/fs.js';
 const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const VALID_ROLES = new Set(['prd', 'ui', 'rd', 'qa']);
+const VALID_ROLES = new Set(['prd', 'ui', 'rd', 'qa', 'sc']);
 function defaultClock() {
     return new Date().toISOString();
 }
@@ -215,6 +215,58 @@ function renderQaTemplate(requestId, sessionId, timestamp) {
 
 ## Status
 
+- created: ${timestamp}
+- last update: ${timestamp}
+- state: draft
+`;
+}
+function renderScTemplate(requestId, sessionId, timestamp) {
+    return `# SC Request ${requestId}
+
+- session: ${sessionId}
+- linked-prd: .peaks/${sessionId}/prd/requests/${requestId}.md
+- linked-rd:  .peaks/${sessionId}/rd/requests/${requestId}.md
+- linked-qa:  .peaks/${sessionId}/qa/requests/${requestId}.md
+- linked-ui:  .peaks/${sessionId}/ui/requests/${requestId}.md  (when UI involved)
+- type: feature | bug | refactor | clarification
+
+## Change impact
+
+- modules / files / routes / data models touched
+- blast radius: local | cross-cutting | release-critical
+- rollback strategy
+
+## Commit boundaries
+
+- one commit per OpenSpec heading (when openspec/ exists)
+- otherwise: list of slice ids → commit message + scope
+
+## Artifact retention
+
+- prd artifact: ...
+- rd artifact: ...
+- qa artifact: ...
+- ui artifact: ... (when UI involved)
+- coverage evidence: ...
+- code review evidence: ...
+
+## Sync / authorization
+
+- artifact workspace path: .peaks/${sessionId}/
+- memory sync authorized: yes | no
+- artifact sync authorized: yes | no
+- rationale if not authorized: keep local
+
+## Rollback points
+
+- commits / tags / branches that can revert each boundary
+
+## Handoff
+
+- to peaks-txt: .peaks/${sessionId}/txt/skill-usage-lessons.md (when reusable lesson exists)
+
+## Status
+
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
@@ -230,11 +282,13 @@ function renderTemplate(role, requestId, sessionId, timestamp) {
             return renderRdTemplate(requestId, sessionId, timestamp);
         case 'qa':
             return renderQaTemplate(requestId, sessionId, timestamp);
+        case 'sc':
+            return renderScTemplate(requestId, sessionId, timestamp);
     }
 }
 export async function createRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {
-        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, or qa)`);
+        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, qa, or sc)`);
     }
     if (!REQUEST_ID_PATTERN.test(options.requestId)) {
         throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);
@@ -313,7 +367,7 @@ export async function listRequestArtifacts(options) {
 }
 export async function showRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {
-        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, or qa)`);
+        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, qa, or sc)`);
     }
     if (!REQUEST_ID_PATTERN.test(options.requestId)) {
         throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);
@@ -347,7 +401,8 @@ const ALLOWED_STATES_PER_ROLE = {
     prd: ['draft', 'confirmed-by-user', 'handed-off', 'blocked'],
     ui: ['draft', 'direction-locked', 'handed-off', 'blocked'],
     rd: ['draft', 'spec-locked', 'implemented', 'qa-handoff', 'handed-off', 'blocked'],
-    qa: ['draft', 'running', 'verdict-issued', 'blocked']
+    qa: ['draft', 'running', 'verdict-issued', 'blocked'],
+    sc: ['draft', 'impact-recorded', 'boundary-recorded', 'handed-off', 'blocked']
 };
 export function allowedStatesForRole(role) {
     return ALLOWED_STATES_PER_ROLE[role];
@@ -391,7 +446,7 @@ function updateStatusBlock(markdown, newState, timestamp, reason) {
 }
 export async function transitionRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {
-        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, or qa)`);
+        throw new Error(`Invalid role: ${String(options.role)} (expected prd, ui, rd, qa, or sc)`);
     }
     if (!REQUEST_ID_PATTERN.test(options.requestId)) {
         throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);

package/dist/src/services/codegraph/codegraph-process-runner.d.ts

@@ -0,0 +1,2 @@
+import type { CodegraphExecutionResult, CodegraphInvocation } from './codegraph-service.js';
+export declare function defaultCodegraphProcessRunner(invocation: CodegraphInvocation): Promise<CodegraphExecutionResult>;

package/dist/src/services/codegraph/codegraph-process-runner.js

@@ -0,0 +1,93 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+const CODEGRAPH_PROCESS_TIMEOUT_MS = 600_000;
+const CODEGRAPH_OUTPUT_LIMIT_BYTES = 10 * 1024 * 1024;
+function createCodegraphEnvironment(sourceEnv = process.env) {
+    const preservedKeys = ['PATH', 'Path', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'WINDIR'];
+    const environment = {};
+    for (const key of preservedKeys) {
+        const value = sourceEnv[key];
+        if (value !== undefined) {
+            environment[key] = value;
+        }
+    }
+    return environment;
+}
+function assertOutputLimit(currentSize, chunkSize) {
+    const nextSize = currentSize + chunkSize;
+    if (nextSize > CODEGRAPH_OUTPUT_LIMIT_BYTES) {
+        throw new Error(`codegraph output exceeded ${CODEGRAPH_OUTPUT_LIMIT_BYTES} bytes`);
+    }
+    return nextSize;
+}
+function terminateCodegraphProcess(childProcess) {
+    if (childProcess.pid === undefined) {
+        childProcess.kill();
+        return;
+    }
+    if (process.platform === 'win32') {
+        if (process.env.SystemRoot) {
+            spawn(join(process.env.SystemRoot, 'System32', 'taskkill.exe'), ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
+        }
+        else {
+            childProcess.kill();
+        }
+        return;
+    }
+    try {
+        process.kill(-childProcess.pid, 'SIGTERM');
+    }
+    catch {
+        childProcess.kill('SIGTERM');
+    }
+}
+export function defaultCodegraphProcessRunner(invocation) {
+    return new Promise((resolveResult, reject) => {
+        const childProcess = spawn(invocation.executable, invocation.args, {
+            cwd: invocation.cwd,
+            detached: process.platform !== 'win32',
+            env: createCodegraphEnvironment(),
+            shell: false
+        });
+        const timeout = setTimeout(() => {
+            terminateCodegraphProcess(childProcess);
+            reject(new Error(`codegraph process timed out after ${CODEGRAPH_PROCESS_TIMEOUT_MS}ms`));
+        }, CODEGRAPH_PROCESS_TIMEOUT_MS);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutSize = 0;
+        let stderrSize = 0;
+        childProcess.stdout.on('data', (chunk) => {
+            try {
+                stdoutSize = assertOutputLimit(stdoutSize, chunk.length);
+                stdoutChunks.push(chunk);
+            }
+            catch (error) {
+                terminateCodegraphProcess(childProcess);
+                reject(error);
+            }
+        });
+        childProcess.stderr.on('data', (chunk) => {
+            try {
+                stderrSize = assertOutputLimit(stderrSize, chunk.length);
+                stderrChunks.push(chunk);
+            }
+            catch (error) {
+                terminateCodegraphProcess(childProcess);
+                reject(error);
+            }
+        });
+        childProcess.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        childProcess.on('close', (exitCode) => {
+            clearTimeout(timeout);
+            resolveResult({
+                exitCode,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8')
+            });
+        });
+    });
+}

package/dist/src/services/codegraph/codegraph-service.js

@@ -1,16 +1,11 @@
 import { existsSync, realpathSync, statSync } from 'node:fs';
-import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { defaultCodegraphProcessRunner } from './codegraph-process-runner.js';
 const CODEGRAPH_PACKAGE_NAME = '@colbymchenry/codegraph';
 const CODEGRAPH_PACKAGE_VERSION = '0.7.10';
 const CODEGRAPH_EXECUTABLE = process.execPath;
 const CODEGRAPH_BINARY_PATH = resolveCodegraphBinaryPath();
-const CODEGRAPH_PROCESS_TIMEOUT_MS = 600_000;
-const CODEGRAPH_OUTPUT_LIMIT_BYTES = 10 * 1024 * 1024;
-const NODE_OPTIONS_ENV_KEY = 'NODE_OPTIONS';
-const NPM_CONFIG_PREFIX = 'npm_config_';
-const NPM_CONFIG_UPPER_PREFIX = 'NPM_CONFIG_';
 const POSITIONAL_ARGUMENT_PREFIX = '-';
 const ALLOWED_SUBCOMMANDS = ['status', 'init', 'index', 'query', 'files', 'context', 'affected'];
 const NUMERIC_FLAG_NAMES = ['limit', 'maxDepth'];
@@ -28,9 +23,6 @@ function resolveCodegraphBinaryPath() {
     const require = createRequire(import.meta.url);
     const packageJsonPath = require.resolve('@colbymchenry/codegraph/package.json');
     const binaryPath = resolve(dirname(packageJsonPath), 'dist', 'bin', 'codegraph.js');
-    if (!existsSync(binaryPath)) {
-        throw new Error('Unable to resolve local codegraph binary from @colbymchenry/codegraph');
-    }
     return binaryPath;
 }
 function assertSupportedSubcommand(subcommand) {
@@ -95,9 +87,6 @@ function resolveExistingBoundary(absoluteFilePath) {
     let currentPath = dirname(absoluteFilePath);
     while (!existsSync(currentPath)) {
         const parentPath = dirname(currentPath);
-        if (parentPath === currentPath) {
-            return currentPath;
-        }
         currentPath = parentPath;
     }
     return currentPath;
@@ -150,91 +139,6 @@ function buildCommandArgs(options, projectRoot) {
     }
     return args;
 }
-function createCodegraphEnvironment(sourceEnv = process.env) {
-    const preservedKeys = ['PATH', 'Path', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'WINDIR'];
-    const environment = {};
-    for (const key of preservedKeys) {
-        const value = sourceEnv[key];
-        if (value !== undefined) {
-            environment[key] = value;
-        }
-    }
-    return environment;
-}
-function assertOutputLimit(currentSize, chunkSize) {
-    const nextSize = currentSize + chunkSize;
-    if (nextSize > CODEGRAPH_OUTPUT_LIMIT_BYTES) {
-        throw new Error(`codegraph output exceeded ${CODEGRAPH_OUTPUT_LIMIT_BYTES} bytes`);
-    }
-    return nextSize;
-}
-function terminateCodegraphProcess(childProcess) {
-    if (childProcess.pid === undefined) {
-        childProcess.kill();
-        return;
-    }
-    if (process.platform === 'win32') {
-        const taskkillPath = process.env.SystemRoot ? join(process.env.SystemRoot, 'System32', 'taskkill.exe') : 'taskkill.exe';
-        spawn(taskkillPath, ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
-        return;
-    }
-    try {
-        process.kill(-childProcess.pid, 'SIGTERM');
-    }
-    catch {
-        childProcess.kill('SIGTERM');
-    }
-}
-function defaultCodegraphProcessRunner(invocation) {
-    return new Promise((resolveResult, reject) => {
-        const childProcess = spawn(invocation.executable, invocation.args, {
-            cwd: invocation.cwd,
-            detached: process.platform !== 'win32',
-            env: createCodegraphEnvironment(),
-            shell: false
-        });
-        const timeout = setTimeout(() => {
-            terminateCodegraphProcess(childProcess);
-            reject(new Error(`codegraph process timed out after ${CODEGRAPH_PROCESS_TIMEOUT_MS}ms`));
-        }, CODEGRAPH_PROCESS_TIMEOUT_MS);
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let stdoutSize = 0;
-        let stderrSize = 0;
-        childProcess.stdout.on('data', (chunk) => {
-            try {
-                stdoutSize = assertOutputLimit(stdoutSize, chunk.length);
-                stdoutChunks.push(chunk);
-            }
-            catch (error) {
-                terminateCodegraphProcess(childProcess);
-                reject(error);
-            }
-        });
-        childProcess.stderr.on('data', (chunk) => {
-            try {
-                stderrSize = assertOutputLimit(stderrSize, chunk.length);
-                stderrChunks.push(chunk);
-            }
-            catch (error) {
-                terminateCodegraphProcess(childProcess);
-                reject(error);
-            }
-        });
-        childProcess.on('error', (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-        childProcess.on('close', (exitCode) => {
-            clearTimeout(timeout);
-            resolveResult({
-                exitCode,
-                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
-                stderr: Buffer.concat(stderrChunks).toString('utf8')
-            });
-        });
-    });
-}
 export function createCodegraphInvocation(options) {
     assertSupportedSubcommand(options.subcommand);
     const projectRoot = resolveProjectRoot(options.project);

package/dist/src/services/config/config-safety.d.ts

@@ -0,0 +1,14 @@
+export declare function getUserConfigPath(): string;
+export declare function isInsidePath(childPath: string, parentPath: string): boolean;
+export declare function findProjectRoot(startPath: string): string | null;
+export declare function resolveProjectRootForConfig(startPath: string): string;
+export declare function getProjectConfigPath(projectRoot: string | null): string | null;
+export declare function getProjectBootstrapConfigPath(projectRoot: string): string;
+export declare function validateProjectBootstrapConfigPathForWrite(projectRoot: string, configPath: string): void;
+export declare function validateUserConfigPathForWrite(configPath: string): void;
+export declare function validateArtifactWorkspaceRoot(artifactRoot: string, workspaceRoot: string): void;
+export declare function validateArtifactWorkspaceMarkerPath(artifactRoot: string, peaksPath: string, markerPath: string): void;
+export declare function readConfigFileSafely(configPath: string, errorMessage: string): string;
+export declare function writeConfigFileSafely(configPath: string, content: string, validateBeforeWrite: () => void, errorMessage: string): void;
+export declare function writeProjectConfigFile(projectRoot: string, configPath: string, content: string): void;
+export declare function writeUserConfigFile(configPath: string, content: string): void;