peaks-loop 4.0.53 → 4.1.0

package/dist/services/artifacts/artifact-templates.js

@@ -1,3 +1,4 @@
+import { PRD_TEMPLATE_BODY, UI_TEMPLATE_BODY, RD_TEMPLATE_BODY, QA_TEMPLATE_BODY, SC_TEMPLATE_BODY } from './artifact-template-bodies.js';
 /**
  * Handoff path helpers.
  *
@@ -26,40 +27,16 @@ export function formatSkillUsageLessonsPath(sessionId) {
     return `.peaks/_runtime/${sessionId}/txt/skill-usage-lessons.md`;
 }
 function renderPrdTemplate(requestId, _sessionId, sessionId, timestamp, requestType) {
-    return `# PRD Request ${requestId}
+    return (`# PRD Request ${requestId}
 
 - session: ${sessionId}
 - type: ${requestType}
 - 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
+` +
+        PRD_TEMPLATE_BODY +
+        `## Handoff
 
 - to peaks-rd: ${formatHandoffPath(sessionId, 'rd', requestId)}
 - to peaks-qa: ${formatHandoffPath(sessionId, 'qa', requestId)}
@@ -70,10 +47,10 @@ function renderPrdTemplate(requestId, _sessionId, sessionId, timestamp, requestT
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
-`;
+`);
 }
 function renderUiTemplate(requestId, _sessionId, sessionId, timestamp, requestType) {
-    return `# UI Request ${requestId}
+    return (`# UI Request ${requestId}
 
 - session: ${sessionId}
 - linked-prd: ${formatHandoffPath(sessionId, 'prd', requestId)}
@@ -81,36 +58,9 @@ function renderUiTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - 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
+` +
+        UI_TEMPLATE_BODY +
+        `## Handoff
 
 - to peaks-rd: ${formatHandoffPath(sessionId, 'rd', requestId)}
 - to peaks-qa: ${formatHandoffPath(sessionId, 'qa', requestId)}
@@ -120,54 +70,19 @@ function renderUiTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
-`;
+`);
 }
 function renderRdTemplate(requestId, _sessionId, sessionId, timestamp, requestType) {
-    return `# RD Request ${requestId}
+    return (`# RD Request ${requestId}
 
 - session: ${sessionId}
 - linked-prd: ${formatHandoffPath(sessionId, 'prd', requestId)}
 - linked-ui:  ${formatHandoffPath(sessionId, 'ui', requestId)}  (when UI involved)
 - type: ${requestType}
 
-## 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
+` +
+        RD_TEMPLATE_BODY +
+        `## Handoff
 
 - to peaks-qa: ${formatHandoffPath(sessionId, 'qa', requestId)}
 - to peaks-sc: ${formatCommitBoundaryPath(sessionId, requestId)}
@@ -177,10 +92,10 @@ function renderRdTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
-`;
+`);
 }
 function renderQaTemplate(requestId, _sessionId, sessionId, timestamp, requestType) {
-    return `# QA Request ${requestId}
+    return (`# QA Request ${requestId}
 
 - session: ${sessionId}
 - linked-prd: ${formatHandoffPath(sessionId, 'prd', requestId)}
@@ -188,54 +103,17 @@ function renderQaTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - linked-ui:  ${formatHandoffPath(sessionId, 'ui', requestId)}  (when UI involved)
 - type: ${requestType}
 
-## 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
+` +
+        QA_TEMPLATE_BODY +
+        `## Status
 
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
-`;
+`);
 }
 function renderScTemplate(requestId, _sessionId, sessionId, timestamp, requestType) {
-    return `# SC Request ${requestId}
+    return (`# SC Request ${requestId}
 
 - session: ${sessionId}
 - linked-prd: ${formatHandoffPath(sessionId, 'prd', requestId)}
@@ -244,29 +122,9 @@ function renderScTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - linked-ui:  ${formatHandoffPath(sessionId, 'ui', requestId)}  (when UI involved)
 - type: ${requestType}
 
-## 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/_runtime/${sessionId}/
+` +
+        SC_TEMPLATE_BODY +
+        `- artifact workspace path: .peaks/_runtime/${sessionId}/
 - memory sync authorized: yes | no
 - artifact sync authorized: yes | no
 - rationale if not authorized: keep local
@@ -284,7 +142,7 @@ function renderScTemplate(requestId, _sessionId, sessionId, timestamp, requestTy
 - created: ${timestamp}
 - last update: ${timestamp}
 - state: draft
-`;
+`);
 }
 export function renderTemplate(role, requestId, sessionId, changeSlug, timestamp, requestType) {
     switch (role) {

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

@@ -92,7 +92,7 @@ export async function createRequestArtifact(options) {
     // canonical session → legacy session). The change-id is preserved
     // in the artifact body's frontmatter (under `- change-id:`) for
     // human navigation; it is no longer a filesystem path key.
-    const sessionId = options.sessionId ?? await ensureSession(options.projectRoot);
+    const sessionId = options.sessionId ?? (await ensureSession(options.projectRoot));
     // Sid axis. The rid axis is guarded three times above (`REQUEST_ID_PATTERN`
     // at :110, and again in the numbered-filename path); the session id was
     // never checked, so `--session-id ../../x` wrote the artifact outside the
@@ -363,7 +363,8 @@ async function readRequestArtifact(dir, role, found, sessionId) {
         const content = await readFile(found.path, 'utf8');
         return { ...summary, content };
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -374,7 +375,7 @@ async function readRequestArtifact(dir, role, found, sessionId) {
 // the sibling `request-artifact-state-helpers.ts` module — see
 // v2.18.3 file-split for the rationale. Function signatures and
 // behaviour are unchanged (verbatim move).
-import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, readArtifactState, TypeSanityViolationError, updateStatusBlock, } from './request-artifact-state-helpers.js';
+import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, readArtifactState, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export async function transitionRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {
@@ -423,7 +424,9 @@ export async function transitionRequestArtifact(options) {
     // immutable peaks-prd handoff (sha256-frontmatter) for the same intent;
     // see PRD for `v2-11-rd-techdoc-removal-and-runtime-friction` AC-3/AC-4.)
     // Type sanity check for PRD handoff
-    if (options.typeSanityCheck !== undefined && options.role === 'prd' && options.newState === 'handed-off') {
+    if (options.typeSanityCheck !== undefined &&
+        options.role === 'prd' &&
+        options.newState === 'handed-off') {
         const sanityReport = checkTypeSanity({
             projectRoot: options.typeSanityCheck.projectRoot,
             declaredType: options.typeSanityCheck.declaredType
@@ -448,10 +451,12 @@ export async function transitionRequestArtifact(options) {
         }
     }
     // File size gate: when RD declares implemented, scan for oversized files (karpathy-skills "Simplicity First")
-    if (options.role === 'rd' && options.newState === 'implemented' && options.allowIncomplete !== true) {
+    if (options.role === 'rd' &&
+        options.newState === 'implemented' &&
+        options.allowIncomplete !== true) {
         const sizeResult = scanFileSize({ projectRoot: options.projectRoot });
         if (!sizeResult.ok) {
-            throw new FileSizeViolationError(sizeResult.violations, sizeResult.threshold);
+            throw new FileSizeViolationError(sizeResult.violations);
         }
     }
     const clock = options.clock ?? defaultClock;
@@ -459,7 +464,9 @@ export async function transitionRequestArtifact(options) {
     const bypassNote = !prerequisiteResult.ok && options.allowIncomplete === true
         ? `bypassed prerequisites (${prerequisiteResult.missing.map((entry) => entry.path).join(', ')})`
         : undefined;
-    const combinedReason = [options.reason, bypassNote].filter((part) => part !== undefined && part.length > 0).join(' | ');
+    const combinedReason = [options.reason, bypassNote]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join(' | ');
     const reasonForNote = combinedReason.length > 0 ? combinedReason : undefined;
     const { updated, previousState } = updateStatusBlock(existing.content, options.newState, timestamp, reasonForNote);
     await writeFile(existing.path, updated, 'utf8');

package/dist/services/artifacts/request-artifact-state-helpers.d.ts

@@ -38,12 +38,13 @@ export declare class FileSizeViolationError extends Error {
     readonly violations: Array<{
         file: string;
         lines: number;
+        cap: number;
     }>;
-    readonly threshold: number;
     constructor(violations: Array<{
         file: string;
         lines: number;
-    }>, threshold: number);
+        cap: number;
+    }>);
 }
 export interface ArtifactStateLocation {
     /** Index of the authoritative `- state:` line, or -1 when the document has none. */

package/dist/services/artifacts/request-artifact-state-helpers.js

@@ -64,15 +64,13 @@ export class TypeSanityViolationError extends Error {
 export class FileSizeViolationError extends Error {
     code = 'FILE_SIZE_VIOLATION';
     violations;
-    threshold;
-    constructor(violations, threshold) {
-        const summary = violations.map((v) => `${v.file} (${v.lines} lines)`).join(', ');
-        super(`File size violation: ${violations.length} file(s) exceed ${threshold} lines: ${summary}. ` +
+    constructor(violations) {
+        const summary = violations.map((v) => `${v.file} (${v.lines} lines, cap ${v.cap})`).join(', ');
+        super(`File size violation: ${violations.length} file(s) exceed their file-size cap: ${summary}. ` +
             'Split into smaller modules, or consider reusing existing components / existing API data ' +
             '(karpathy-guidelines §2 Simplicity First), or use --allow-incomplete to bypass.');
         this.name = 'FileSizeViolationError';
         this.violations = violations;
-        this.threshold = threshold;
     }
 }
 /**

package/dist/services/artifacts/workspace-artifact-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { WorkspaceConfig } from '../config/config-types.js';
+export type SyncStatus = 'synced' | 'pending' | 'out-of-sync' | 'unknown';
+export type ArtifactWorkspaceStatus = {
+    workspaceId: string;
+    localPath: string;
+    configured: boolean;
+    syncStatus: SyncStatus;
+    lastSync: string | null;
+    hasLocalChanges: boolean;
+    artifactRepo: WorkspaceConfig['artifactRepo'] | null;
+    nextActions: string[];
+};
+export type SyncResult = {
+    workspaceId: string;
+    success: boolean;
+    localPath: string;
+    remoteUrl: string | null;
+    commands: string[];
+    output: string[];
+    error?: string;
+};
+export declare function canonicalPath(path: string): string;
+export declare function canonicalChildPath(parentPath: string, ...segments: string[]): string;
+export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
+export declare function getArtifactRemoteRepo(workspace: WorkspaceConfig): WorkspaceConfig['artifactRepo'] | null;
+export declare function getPublicRemoteUrl(artifactRepo: WorkspaceConfig['artifactRepo'] | null): string | null;
+export declare function getGitAuthEnv(artifactRepo: WorkspaceConfig['artifactRepo'] | null): NodeJS.ProcessEnv | undefined;
+export declare function redactSecrets(message: string): string;

package/dist/services/artifacts/workspace-artifact-helpers.js

@@ -0,0 +1,54 @@
+import { Buffer } from 'node:buffer';
+import { resolve } from 'node:path';
+import { stablePath } from '../../shared/path-utils.js';
+export function canonicalPath(path) {
+    return stablePath(path);
+}
+export function canonicalChildPath(parentPath, ...segments) {
+    return stablePath(resolve(parentPath, ...segments));
+}
+export function getLocalArtifactPath(workspace) {
+    if (workspace.artifactStorage?.localPath) {
+        return resolve(workspace.artifactStorage.localPath);
+    }
+    return resolve(workspace.rootPath, '.peaks', 'artifacts');
+}
+export function getArtifactRemoteRepo(workspace) {
+    if (workspace.artifactStorage?.mode === 'local-with-remote-sync') {
+        return workspace.artifactStorage.remote;
+    }
+    if (workspace.artifactStorage?.mode === 'local') {
+        return null;
+    }
+    return workspace.artifactRepo ?? null;
+}
+export function getPublicRemoteUrl(artifactRepo) {
+    if (!artifactRepo)
+        return null;
+    return artifactRepo.provider === 'github'
+        ? `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`
+        : `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
+}
+export function getGitAuthEnv(artifactRepo) {
+    if (!artifactRepo || artifactRepo.provider !== 'github')
+        return undefined;
+    const token = process.env.GH_TOKEN;
+    if (!token)
+        return undefined;
+    const authValue = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
+    return {
+        ...process.env,
+        GIT_CONFIG_COUNT: '1',
+        GIT_CONFIG_KEY_0: 'http.https://github.com/.extraheader',
+        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${authValue}`
+    };
+}
+export function redactSecrets(message) {
+    const token = process.env.GH_TOKEN;
+    const urlRedacted = message.replace(/https:\/\/x-access-token:[^@]+@/g, 'https://x-access-token:***@');
+    const headerRedacted = urlRedacted.replace(/AUTHORIZATION:\s*basic\s+[A-Za-z0-9+/=]+/gi, 'AUTHORIZATION: basic ***');
+    if (!token)
+        return headerRedacted;
+    const encoded = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
+    return headerRedacted.replaceAll(token, '***').replaceAll(encoded, '***');
+}

package/dist/services/artifacts/workspace-service.d.ts

@@ -1,28 +1,9 @@
 import type { WorkspaceConfig } from '../config/config-types.js';
-export type SyncStatus = 'synced' | 'pending' | 'out-of-sync' | 'unknown';
-export type ArtifactWorkspaceStatus = {
-    workspaceId: string;
-    localPath: string;
-    configured: boolean;
-    syncStatus: SyncStatus;
-    lastSync: string | null;
-    hasLocalChanges: boolean;
-    artifactRepo: WorkspaceConfig['artifactRepo'] | null;
-    nextActions: string[];
-};
-export type SyncResult = {
-    workspaceId: string;
-    success: boolean;
-    localPath: string;
-    remoteUrl: string | null;
-    commands: string[];
-    output: string[];
-    error?: string;
-};
-export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
+import { getArtifactRemoteRepo, getLocalArtifactPath, type ArtifactWorkspaceStatus, type SyncResult, type SyncStatus } from './workspace-artifact-helpers.js';
+export { getArtifactRemoteRepo, getLocalArtifactPath };
+export type { ArtifactWorkspaceStatus, SyncResult, SyncStatus };
 export declare function isArtifactWorkspaceOutsideTarget(_workspace: WorkspaceConfig, _artifactWorkspacePath?: string): boolean;
 export declare function hasValidArtifactWorkspace(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
-export declare function getArtifactRemoteRepo(workspace: WorkspaceConfig): WorkspaceConfig['artifactRepo'] | null;
 export declare function executeArtifactSync(workspaceId?: string): Promise<SyncResult>;
 export declare function getArtifactWorkspaceStatus(workspaceId?: string): ArtifactWorkspaceStatus;
 export declare function planArtifactSync(workspaceId?: string, dryRun?: boolean): {

package/dist/services/artifacts/workspace-service.js

@@ -1,22 +1,11 @@
 import { existsSync } from 'node:fs';
-import { Buffer } from 'node:buffer';
 import { resolve } from 'node:path';
-import { isInsidePath, stablePath } from '../../shared/path-utils.js';
+import { isInsidePath } from '../../shared/path-utils.js';
 import { getWorkspaceConfig, getWorkspaceConfigForCurrentPath } from '../config/config-service.js';
 import { pathExists } from 'peaks-loop-shared/fs';
 import { execCommand } from '../../shared/process.js';
-function canonicalPath(path) {
-    return stablePath(path);
-}
-function canonicalChildPath(parentPath, ...segments) {
-    return stablePath(resolve(parentPath, ...segments));
-}
-export function getLocalArtifactPath(workspace) {
-    if (workspace.artifactStorage?.localPath) {
-        return resolve(workspace.artifactStorage.localPath);
-    }
-    return resolve(workspace.rootPath, '.peaks', 'artifacts');
-}
+import { canonicalChildPath, canonicalPath, getArtifactRemoteRepo, getGitAuthEnv, getLocalArtifactPath, getPublicRemoteUrl, redactSecrets } from './workspace-artifact-helpers.js';
+export { getArtifactRemoteRepo, getLocalArtifactPath };
 export function isArtifactWorkspaceOutsideTarget(_workspace, _artifactWorkspacePath) {
     return true;
 }
@@ -37,45 +26,6 @@ export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = get
         return false;
     return true;
 }
-export function getArtifactRemoteRepo(workspace) {
-    if (workspace.artifactStorage?.mode === 'local-with-remote-sync') {
-        return workspace.artifactStorage.remote;
-    }
-    if (workspace.artifactStorage?.mode === 'local') {
-        return null;
-    }
-    return workspace.artifactRepo ?? null;
-}
-function getPublicRemoteUrl(artifactRepo) {
-    if (!artifactRepo)
-        return null;
-    return artifactRepo.provider === 'github'
-        ? `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`
-        : `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
-}
-function getGitAuthEnv(artifactRepo) {
-    if (!artifactRepo || artifactRepo.provider !== 'github')
-        return undefined;
-    const token = process.env.GH_TOKEN;
-    if (!token)
-        return undefined;
-    const authValue = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return {
-        ...process.env,
-        GIT_CONFIG_COUNT: '1',
-        GIT_CONFIG_KEY_0: 'http.https://github.com/.extraheader',
-        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${authValue}`
-    };
-}
-function redactSecrets(message) {
-    const token = process.env.GH_TOKEN;
-    const urlRedacted = message.replace(/https:\/\/x-access-token:[^@]+@/g, 'https://x-access-token:***@');
-    const headerRedacted = urlRedacted.replace(/AUTHORIZATION:\s*basic\s+[A-Za-z0-9+/=]+/gi, 'AUTHORIZATION: basic ***');
-    if (!token)
-        return headerRedacted;
-    const encoded = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return headerRedacted.replaceAll(token, '***').replaceAll(encoded, '***');
-}
 export async function executeArtifactSync(workspaceId) {
     const workspace = workspaceId
         ? getWorkspaceConfig(workspaceId)
@@ -191,18 +141,16 @@ export function getArtifactWorkspaceStatus(workspaceId) {
             lastSync: null,
             hasLocalChanges: false,
             artifactRepo: null,
-            nextActions: ['Add a workspace with: peaks config workspace add --id <id> --name <name> --path <path>']
+            nextActions: [
+                'Add a workspace with: peaks config workspace add --id <id> --name <name> --path <path>'
+            ]
         };
     }
     const localPath = getLocalArtifactPath(workspace);
     const hasLocalDir = existsSync(localPath);
     const artifactRepo = getArtifactRemoteRepo(workspace);
     const hasSafeBoundary = isArtifactWorkspaceOutsideTarget(workspace, localPath);
-    const syncStatus = !hasSafeBoundary
-        ? 'unknown'
-        : !hasLocalDir
-            ? 'pending'
-            : 'synced';
+    const syncStatus = !hasSafeBoundary ? 'unknown' : !hasLocalDir ? 'pending' : 'synced';
     return {
         workspaceId: workspace.workspaceId,
         localPath,
@@ -228,7 +176,9 @@ export function planArtifactSync(workspaceId, dryRun = true) {
             dryRun,
             localPath: '.peaks-artifacts',
             remoteUrl: null,
-            plannedCommands: ['No artifact repo configured — add one with peaks config workspace add --provider github --repo-owner <owner> --repo-name <name>']
+            plannedCommands: [
+                'No artifact repo configured — add one with peaks config workspace add --provider github --repo-owner <owner> --repo-name <name>'
+            ]
         };
     }
     const localPath = getLocalArtifactPath(workspace);