peaks-cli 1.0.12 → 1.0.13

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

@@ -0,0 +1,432 @@
+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']);
+function defaultClock() {
+    return new Date().toISOString();
+}
+function dateSlugFromIso(iso) {
+    return iso.slice(0, 10);
+}
+function defaultSessionId(iso) {
+    return `${dateSlugFromIso(iso)}-session`;
+}
+function renderPrdTemplate(requestId, sessionId, timestamp) {
+    return `# PRD Request ${requestId}
+
+- session: ${sessionId}
+- type: feature | bug | refactor | clarification
+- source: <ticket, message URL, or "verbal" with a short sanitized quote>
+- raw input (sanitized): <one-paragraph restatement of what the user actually asked for>
+
+## Goals
+
+- ...
+
+## Non-goals
+
+- ...
+
+## Preserved behavior
+
+- ...
+
+## Acceptance criteria
+
+- ... (browser-verifiable when frontend is in scope)
+
+## Frontend delta (only when target is frontend)
+
+- pages / routes / components / states / permissions / data deps / edge cases
+- 待联调态: ...
+- API contracts pending: ...
+
+## Risks and open questions
+
+- ...
+
+## Handoff
+
+- to peaks-rd: .peaks/${sessionId}/rd/requests/${requestId}.md
+- to peaks-qa: .peaks/${sessionId}/qa/requests/${requestId}.md
+- to peaks-ui: .peaks/${sessionId}/ui/requests/${requestId}.md  (when UI involved)
+
+## Status
+
+- created: ${timestamp}
+- last update: ${timestamp}
+- state: draft
+`;
+}
+function renderUiTemplate(requestId, sessionId, timestamp) {
+    return `# UI Request ${requestId}
+
+- session: ${sessionId}
+- linked-prd: .peaks/${sessionId}/prd/requests/${requestId}.md
+- scope: full new surface | iteration on existing surface | regression fix | visual refresh
+- design direction: editorial | bento | Swiss | luxury | retro-futurist | glass | product-system | other-explicit-name
+
+## Affected surfaces
+
+- pages / routes / components / modals / states (loading, empty, error, hover, focus, active, responsive)
+- explicit out-of-scope surfaces (do not modify)
+
+## UX flow and page states
+
+- entry points, primary flow, secondary flows, exit points
+- state machine per surface when state transitions matter
+
+## Visual constraints
+
+- typography pair: ...
+- palette: ...
+- density and motion intensity dials: ...
+- rejected generic patterns
+
+## Interaction constraints
+
+- keyboard, focus order, ARIA roles, gesture support, accessibility minima
+
+## UI regression seeds
+
+- list of visible regressions QA must check against the prior state
+
+## Browser evidence
+
+- sanitized observations only — no login URLs, cookies, headers, tokens, storage state, browser traces, or screenshots/logs with PII / SSO / MFA material
+
+## Handoff
+
+- to peaks-rd: .peaks/${sessionId}/rd/requests/${requestId}.md
+- to peaks-qa: .peaks/${sessionId}/qa/requests/${requestId}.md
+
+## Status
+
+- created: ${timestamp}
+- last update: ${timestamp}
+- state: draft
+`;
+}
+function renderRdTemplate(requestId, sessionId, timestamp) {
+    return `# RD Request ${requestId}
+
+- session: ${sessionId}
+- linked-prd: .peaks/${sessionId}/prd/requests/${requestId}.md
+- linked-ui:  .peaks/${sessionId}/ui/requests/${requestId}.md  (when UI involved)
+- type: feature | bug | refactor | clarification
+
+## Red-line scope
+
+- in-scope files / routes / API paths / data models
+- explicit out-of-scope surfaces (do not modify, mock, delete, or replace)
+
+## Standards preflight
+
+- peaks standards init/update --project <path> --dry-run output paths and status
+- planned application: apply | review-only | blocked
+
+## OpenSpec linkage (when openspec/ exists)
+
+- change-id: <openspec change id>
+- entry validate: peaks openspec validate <change-id> data.valid status
+- to-rd projection: peaks openspec to-rd <change-id> artifact path
+- exit validate (after implementation): status
+
+## Coverage status
+
+- current total UT coverage: <percent>
+- new/changed code coverage: <percent>
+- gate verdict: pass | legacy-accepted | blocked
+
+## Slice contract
+
+- slice id, functional boundary, pre-refactor behavior, target structure, unit-test requirements, acceptance checks, rollback plan, commit boundary
+
+## Implementation evidence
+
+- diff paths, test commands + outputs, code review findings + fixes, security review findings + fixes, dry-run output
+
+## MCP usage (when external docs lookup was used)
+
+- capabilityId / tool / sanitized args
+- artifact path of stored result
+- no secrets, no full network bodies
+
+## Handoff
+
+- to peaks-qa: .peaks/${sessionId}/qa/requests/${requestId}.md
+- to peaks-sc: .peaks/${sessionId}/sc/commit-boundaries/${requestId}.md
+
+## Status
+
+- created: ${timestamp}
+- last update: ${timestamp}
+- state: draft
+`;
+}
+function renderQaTemplate(requestId, sessionId, timestamp) {
+    return `# QA Request ${requestId}
+
+- session: ${sessionId}
+- linked-prd: .peaks/${sessionId}/prd/requests/${requestId}.md
+- linked-rd:  .peaks/${sessionId}/rd/requests/${requestId}.md
+- linked-ui:  .peaks/${sessionId}/ui/requests/${requestId}.md  (when UI involved)
+- type: feature | bug | refactor | clarification
+
+## Red-line boundary check
+
+- in-scope changes seen in the diff (match PRD + RD scope)
+- out-of-scope changes flagged (any extra file, route, mock, fixture, behavior)
+- verdict: clean | boundary-violation
+
+## OpenSpec exit gate (when openspec/ exists)
+
+- change-id: <id>
+- peaks openspec validate <id> data.valid: true | false
+- issues: ...
+
+## Acceptance checks
+
+- per-criterion: check method, result (pass | fail | blocked), evidence path
+
+## Mandatory validation gates
+
+- unit tests: command + pass/fail + coverage delta
+- API validation (when applicable): request paths exercised, evidence
+- browser E2E (when frontend): headed gstack/browse/dist/browse visible-browser confirmation, sanitized route/actions, console/network observations
+- browser-error feedback loop: page errors, console exceptions, broken network, hydration failures → return-to-RD evidence
+- security check: tool used, findings, fixes, unresolved risks
+- performance check: tool used, baseline vs after numbers when available
+- validation report path
+
+## Regression matrix
+
+- list of surfaces / API paths / browser flows checked
+- pass/fail per row
+
+## Browser evidence
+
+- sanitized observations only — no login URLs, cookies, headers, tokens, storage state, browser traces, or screenshots/logs with PII / SSO / MFA material
+
+## Verdict
+
+- overall: pass | return-to-rd | blocked
+
+## Status
+
+- created: ${timestamp}
+- last update: ${timestamp}
+- state: draft
+`;
+}
+function renderTemplate(role, requestId, sessionId, timestamp) {
+    switch (role) {
+        case 'prd':
+            return renderPrdTemplate(requestId, sessionId, timestamp);
+        case 'ui':
+            return renderUiTemplate(requestId, sessionId, timestamp);
+        case 'rd':
+            return renderRdTemplate(requestId, sessionId, timestamp);
+        case 'qa':
+            return renderQaTemplate(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)`);
+    }
+    if (!REQUEST_ID_PATTERN.test(options.requestId)) {
+        throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);
+    }
+    const clock = options.clock ?? defaultClock;
+    const timestamp = clock();
+    const sessionId = options.sessionId ?? defaultSessionId(timestamp);
+    const path = join(options.projectRoot, '.peaks', sessionId, options.role, 'requests', `${options.requestId}.md`);
+    const content = renderTemplate(options.role, options.requestId, sessionId, timestamp);
+    if (options.apply !== true) {
+        return { role: options.role, requestId: options.requestId, sessionId, path, content, applied: false };
+    }
+    if (await pathExists(path)) {
+        throw new Error(`Refusing to write: ${path} already exists. Update it in place or remove it before re-running peaks request init.`);
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, 'utf8');
+    return { role: options.role, requestId: options.requestId, sessionId, path, content, applied: true };
+}
+function extractStateAndCreated(markdown) {
+    let state = 'unknown';
+    let createdAt;
+    for (const rawLine of markdown.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        const stateMatch = /^-\s*state:\s*(.+?)\s*$/.exec(line);
+        if (stateMatch !== null && stateMatch[1] !== undefined) {
+            state = stateMatch[1];
+            continue;
+        }
+        const createdMatch = /^-\s*created:\s*(.+?)\s*$/.exec(line);
+        if (createdMatch !== null && createdMatch[1] !== undefined) {
+            createdAt = createdMatch[1];
+        }
+    }
+    return createdAt === undefined ? { state } : { state, createdAt };
+}
+async function readSummary(projectRoot, sessionId, role, fileName) {
+    const path = join(projectRoot, '.peaks', sessionId, role, 'requests', fileName);
+    const body = await readFile(path, 'utf8');
+    const { state, createdAt } = extractStateAndCreated(body);
+    const requestId = fileName.replace(/\.md$/, '');
+    const summary = { role, sessionId, requestId, path, state };
+    if (createdAt !== undefined) {
+        summary.createdAt = createdAt;
+    }
+    return summary;
+}
+async function listMarkdownFiles(dir) {
+    if (!(await isDirectory(dir))) {
+        return [];
+    }
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+        .map((entry) => entry.name)
+        .sort();
+}
+export async function listRequestArtifacts(options) {
+    const peaksRoot = join(options.projectRoot, '.peaks');
+    if (!(await isDirectory(peaksRoot))) {
+        return [];
+    }
+    const sessions = options.sessionId !== undefined ? [options.sessionId] : await listDirectories(peaksRoot);
+    const roles = options.role !== undefined ? [options.role] : Array.from(VALID_ROLES);
+    const summaries = [];
+    for (const sessionId of sessions) {
+        for (const role of roles) {
+            const dir = join(peaksRoot, sessionId, role, 'requests');
+            const fileNames = await listMarkdownFiles(dir);
+            for (const fileName of fileNames) {
+                summaries.push(await readSummary(options.projectRoot, sessionId, role, fileName));
+            }
+        }
+    }
+    return summaries;
+}
+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)`);
+    }
+    if (!REQUEST_ID_PATTERN.test(options.requestId)) {
+        throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);
+    }
+    const fileName = `${options.requestId}.md`;
+    if (options.sessionId !== undefined) {
+        const path = join(options.projectRoot, '.peaks', options.sessionId, options.role, 'requests', fileName);
+        if (!(await pathExists(path))) {
+            return null;
+        }
+        const summary = await readSummary(options.projectRoot, options.sessionId, options.role, fileName);
+        const content = await readFile(path, 'utf8');
+        return { ...summary, content };
+    }
+    const peaksRoot = join(options.projectRoot, '.peaks');
+    if (!(await isDirectory(peaksRoot))) {
+        return null;
+    }
+    const sessions = await listDirectories(peaksRoot);
+    for (const sessionId of sessions) {
+        const path = join(peaksRoot, sessionId, options.role, 'requests', fileName);
+        if (await pathExists(path)) {
+            const summary = await readSummary(options.projectRoot, sessionId, options.role, fileName);
+            const content = await readFile(path, 'utf8');
+            return { ...summary, content };
+        }
+    }
+    return null;
+}
+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']
+};
+export function allowedStatesForRole(role) {
+    return ALLOWED_STATES_PER_ROLE[role];
+}
+function updateStatusBlock(markdown, newState, timestamp, reason) {
+    const lines = markdown.split(/\r?\n/);
+    let previousState = 'unknown';
+    let stateLineIndex = -1;
+    let lastUpdateLineIndex = -1;
+    for (const [index, raw] of lines.entries()) {
+        const trimmed = raw.trim();
+        const stateMatch = /^-\s*state:\s*(.+?)\s*$/.exec(trimmed);
+        if (stateMatch !== null && stateMatch[1] !== undefined) {
+            previousState = stateMatch[1];
+            stateLineIndex = index;
+            continue;
+        }
+        if (/^-\s*last update:\s*/.test(trimmed)) {
+            lastUpdateLineIndex = index;
+        }
+    }
+    if (stateLineIndex >= 0) {
+        lines[stateLineIndex] = `- state: ${newState}`;
+    }
+    else {
+        lines.push('', '## Status', '', `- state: ${newState}`);
+    }
+    if (lastUpdateLineIndex >= 0) {
+        lines[lastUpdateLineIndex] = `- last update: ${timestamp}`;
+    }
+    else if (stateLineIndex >= 0) {
+        lines.splice(stateLineIndex, 0, `- last update: ${timestamp}`);
+    }
+    else {
+        lines.push(`- last update: ${timestamp}`);
+    }
+    if (reason !== undefined && reason.length > 0) {
+        lines.push(`- transition note (${timestamp}): ${reason}`);
+    }
+    return { updated: lines.join('\n'), previousState };
+}
+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)`);
+    }
+    if (!REQUEST_ID_PATTERN.test(options.requestId)) {
+        throw new Error(`Invalid request id: ${options.requestId} (expected letters, digits, dots, underscores, or dashes)`);
+    }
+    const allowed = ALLOWED_STATES_PER_ROLE[options.role];
+    if (!allowed.includes(options.newState)) {
+        throw new Error(`Invalid state for role ${options.role}: ${options.newState} (expected one of ${allowed.join(', ')})`);
+    }
+    const showOptions = {
+        projectRoot: options.projectRoot,
+        role: options.role,
+        requestId: options.requestId
+    };
+    if (options.sessionId !== undefined) {
+        showOptions.sessionId = options.sessionId;
+    }
+    const existing = await showRequestArtifact(showOptions);
+    if (existing === null) {
+        return null;
+    }
+    const clock = options.clock ?? defaultClock;
+    const timestamp = clock();
+    const { updated, previousState } = updateStatusBlock(existing.content, options.newState, timestamp, options.reason);
+    await writeFile(existing.path, updated, 'utf8');
+    const result = {
+        role: options.role,
+        sessionId: existing.sessionId,
+        requestId: options.requestId,
+        path: existing.path,
+        state: options.newState,
+        previousState,
+        content: updated
+    };
+    if (existing.createdAt !== undefined) {
+        result.createdAt = existing.createdAt;
+    }
+    return result;
+}

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

@@ -1,15 +1,19 @@
 import { existsSync, realpathSync, statSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { dirname, isAbsolute, relative, resolve, sep, win32 } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 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'];
 const COMMON_OPTION_KEYS = ['subcommand', 'project'];
 const ALLOWED_OPTIONS_BY_SUBCOMMAND = {
     status: [],
@@ -20,16 +24,13 @@ const ALLOWED_OPTIONS_BY_SUBCOMMAND = {
     context: ['task'],
     affected: ['files', 'json']
 };
-function assertCodegraphBinaryExists(binaryPath) {
-    if (!existsSync(binaryPath)) {
-        throw new Error('Unable to resolve local codegraph binary from @colbymchenry/codegraph');
-    }
-}
 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');
-    assertCodegraphBinaryExists(binaryPath);
+    if (!existsSync(binaryPath)) {
+        throw new Error('Unable to resolve local codegraph binary from @colbymchenry/codegraph');
+    }
     return binaryPath;
 }
 function assertSupportedSubcommand(subcommand) {
@@ -37,15 +38,12 @@ function assertSupportedSubcommand(subcommand) {
         throw new Error(`Unsupported codegraph subcommand: ${subcommand}`);
     }
 }
-function assertProjectRootDirectory(projectRoot) {
-    if (!statSync(projectRoot).isDirectory()) {
-        throw new Error('Project path must exist and be a directory');
-    }
-}
 function resolveProjectRoot(project) {
     const projectRoot = resolve(project);
     try {
-        assertProjectRootDirectory(projectRoot);
+        if (!statSync(projectRoot).isDirectory()) {
+            throw new Error('Project path must exist and be a directory');
+        }
         return realpathSync.native(projectRoot);
     }
     catch {
@@ -90,8 +88,12 @@ function assertInsideProject(projectRoot, absolutePath) {
         throw new Error('Affected files must stay inside the project');
     }
 }
-function climbToExistingBoundary(currentPath, pathExists = existsSync) {
-    while (!pathExists(currentPath)) {
+function resolveExistingBoundary(absoluteFilePath) {
+    if (existsSync(absoluteFilePath)) {
+        return absoluteFilePath;
+    }
+    let currentPath = dirname(absoluteFilePath);
+    while (!existsSync(currentPath)) {
         const parentPath = dirname(currentPath);
         if (parentPath === currentPath) {
             return currentPath;
@@ -100,9 +102,6 @@ function climbToExistingBoundary(currentPath, pathExists = existsSync) {
     }
     return currentPath;
 }
-function resolveExistingBoundary(absoluteFilePath) {
-    return existsSync(absoluteFilePath) ? absoluteFilePath : climbToExistingBoundary(dirname(absoluteFilePath));
-}
 function normalizeProjectRelativeFile(projectRoot, file) {
     assertPositionalArgument(file, 'Affected files');
     const absoluteFilePath = resolve(projectRoot, file);
@@ -111,13 +110,10 @@ function normalizeProjectRelativeFile(projectRoot, file) {
     assertInsideProject(projectRoot, realBoundary);
     return relative(projectRoot, absoluteFilePath).split(sep).join('/');
 }
-function assertAffectedFiles(files) {
+function buildAffectedFileArgs(projectRoot, files) {
     if (!files || files.length < 1) {
         throw new Error('affected requires at least one file');
     }
-}
-function buildAffectedFileArgs(projectRoot, files) {
-    assertAffectedFiles(files);
     return files.map((file) => normalizeProjectRelativeFile(projectRoot, file));
 }
 function buildCommandArgs(options, projectRoot) {
@@ -172,36 +168,24 @@ function assertOutputLimit(currentSize, chunkSize) {
     }
     return nextSize;
 }
-function getWindowsTaskkillPath(fileExists = existsSync) {
-    const candidates = [
-        win32.join('C:\\Windows', 'System32', 'taskkill.exe'),
-        win32.join('C:\\WINNT', 'System32', 'taskkill.exe')
-    ];
-    return candidates.find((candidate) => fileExists(candidate)) ?? null;
-}
-function terminateCodegraphProcess(childProcess, platform = process.platform, killProcess = process.kill, spawnProcess = spawn, taskkillPath = getWindowsTaskkillPath()) {
+function terminateCodegraphProcess(childProcess) {
     if (childProcess.pid === undefined) {
         childProcess.kill();
         return;
     }
-    if (platform === 'win32') {
-        if (!taskkillPath) {
-            childProcess.kill();
-            return;
-        }
-        const killerProcess = spawnProcess(taskkillPath, ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
-        killerProcess.on('error', () => childProcess.kill());
-        killerProcess.unref();
+    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 {
-        killProcess(-childProcess.pid, 'SIGTERM');
+        process.kill(-childProcess.pid, 'SIGTERM');
     }
     catch {
         childProcess.kill('SIGTERM');
     }
 }
-function runCodegraphProcess(invocation, timeoutMs = CODEGRAPH_PROCESS_TIMEOUT_MS) {
+function defaultCodegraphProcessRunner(invocation) {
     return new Promise((resolveResult, reject) => {
         const childProcess = spawn(invocation.executable, invocation.args, {
             cwd: invocation.cwd,
@@ -211,8 +195,8 @@ function runCodegraphProcess(invocation, timeoutMs = CODEGRAPH_PROCESS_TIMEOUT_M
         });
         const timeout = setTimeout(() => {
             terminateCodegraphProcess(childProcess);
-            reject(new Error(`codegraph process timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+            reject(new Error(`codegraph process timed out after ${CODEGRAPH_PROCESS_TIMEOUT_MS}ms`));
+        }, CODEGRAPH_PROCESS_TIMEOUT_MS);
         const stdoutChunks = [];
         const stderrChunks = [];
         let stdoutSize = 0;
@@ -251,9 +235,6 @@ function runCodegraphProcess(invocation, timeoutMs = CODEGRAPH_PROCESS_TIMEOUT_M
         });
     });
 }
-function defaultCodegraphProcessRunner(invocation) {
-    return runCodegraphProcess(invocation);
-}
 export function createCodegraphInvocation(options) {
     assertSupportedSubcommand(options.subcommand);
     const projectRoot = resolveProjectRoot(options.project);

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

@@ -156,25 +156,6 @@ function validateUserConfigPathForWrite(configPath) {
         }
     }
 }
-function getExistingBoundary(path) {
-    let currentPath = resolve(path);
-    while (!existsSync(currentPath)) {
-        const parentPath = dirname(currentPath);
-        if (parentPath === currentPath) {
-            return currentPath;
-        }
-        currentPath = parentPath;
-    }
-    return currentPath;
-}
-function validateArtifactWorkspaceRootBeforeCreate(artifactRoot, workspaceRoot) {
-    const workspaceRootReal = realpathSync(workspaceRoot);
-    const existingBoundary = getExistingBoundary(artifactRoot);
-    const existingBoundaryReal = realpathSync(existingBoundary);
-    if (isInsidePath(resolve(artifactRoot), workspaceRoot) || isInsidePath(existingBoundaryReal, workspaceRootReal)) {
-        throw new Error('Artifact workspace must stay outside the project root');
-    }
-}
 function validateArtifactWorkspaceRoot(artifactRoot, workspaceRoot) {
     const artifactStats = lstatSync(artifactRoot);
     if (!artifactStats.isDirectory() || artifactStats.isSymbolicLink()) {
@@ -890,7 +871,6 @@ function ensureArtifactWorkspaceMarker(workspace) {
     const artifactRoot = getWorkspaceArtifactRoot(workspace);
     const peaksPath = resolve(artifactRoot, '.peaks');
     const markerPath = resolve(peaksPath, 'config.json');
-    validateArtifactWorkspaceRootBeforeCreate(artifactRoot, workspace.rootPath);
     ensureDir(artifactRoot);
     validateArtifactWorkspaceRoot(artifactRoot, workspace.rootPath);
     ensureDir(peaksPath);
@@ -907,7 +887,7 @@ export function ensureWorkspaceConfigForPath(path = process.cwd()) {
     const existingWorkspace = findWorkspaceForPath(config.workspaces, path);
     if (existingWorkspace) {
         ensureArtifactWorkspaceMarker(existingWorkspace);
-        if (config.currentWorkspace !== existingWorkspace.workspaceId) {
+        if (!config.currentWorkspace) {
             writeConfig({ currentWorkspace: existingWorkspace.workspaceId }, 'user');
         }
         return existingWorkspace;
@@ -923,7 +903,7 @@ export function ensureWorkspaceConfigForPath(path = process.cwd()) {
     };
     ensureArtifactWorkspaceMarker(workspace);
     const updatedWorkspaces = [...config.workspaces, workspace];
-    writeConfig({ workspaces: updatedWorkspaces, currentWorkspace: workspace.workspaceId }, 'user');
+    writeConfig({ workspaces: updatedWorkspaces, ...(!config.currentWorkspace ? { currentWorkspace: workspace.workspaceId } : {}) }, 'user');
     return workspace;
 }
 export function getWorkspaceConfigForCurrentPath() {