peaks-cli 1.0.20 → 1.0.22

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

@@ -1,6 +1,5 @@
 import { existsSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, dirname, isAbsolute, resolve } from 'node:path';
+import { dirname, isAbsolute, resolve } from 'node:path';
 import { DEFAULT_CONFIG } from './config-types.js';
 import { stablePath } from '../../shared/path-utils.js';
 import { findProjectRoot, getProjectBootstrapConfigPath, getProjectConfigPath, getUserConfigPath, isInsidePath, readConfigFileSafely, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
@@ -199,10 +198,6 @@ function isRecord(value) {
 function isSafeConfigSegment(value) {
     return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value) && !value.includes('..') && !value.endsWith('.');
 }
-function toSafeConfigSegment(value) {
-    const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').replace(/\.+$/g, '');
-    return isSafeConfigSegment(normalized) ? normalized : 'workspace';
-}
 function toArtifactRemoteRepoConfig(value) {
     if (!isRecord(value) || (value.provider !== 'github' && value.provider !== 'gitlab') || typeof value.owner !== 'string' || typeof value.name !== 'string') {
         return null;
@@ -246,15 +241,6 @@ function toWorkspaceConfig(value) {
 function toWorkspaceConfigs(value) {
     return Array.isArray(value) ? value.map(toWorkspaceConfig).filter((workspace) => workspace !== null) : [];
 }
-function mergeWorkspaceConfigs(userWorkspaces, projectWorkspaces) {
-    const merged = new Map(userWorkspaces.map((workspace) => [workspace.workspaceId, workspace]));
-    for (const workspace of projectWorkspaces) {
-        if (!merged.has(workspace.workspaceId)) {
-            merged.set(workspace.workspaceId, workspace);
-        }
-    }
-    return [...merged.values()];
-}
 function toProviderModelConfig(value) {
     if (!isRecord(value))
         return {};
@@ -400,8 +386,6 @@ function toPeaksConfig(value) {
     const proxy = toProxyConfig(value.proxy);
     return {
         ...(typeof value.version === 'string' ? { version: value.version } : {}),
-        ...(typeof value.currentWorkspace === 'string' ? { currentWorkspace: value.currentWorkspace } : {}),
-        ...(Array.isArray(value.workspaces) ? { workspaces: toWorkspaceConfigs(value.workspaces) } : {}),
         ...(typeof value.language === 'string' ? { language: value.language } : {}),
         ...(typeof value.model === 'string' && ['haiku', 'sonnet', 'opus', 'minimax'].includes(value.model) ? { model: value.model } : {}),
         ...(typeof value.economyMode === 'boolean' ? { economyMode: value.economyMode } : {}),
@@ -424,15 +408,23 @@ export function readConfig(projectRoot) {
     const detectedRoot = projectRoot ?? findProjectRoot(process.cwd());
     const userConfig = toPeaksConfig(readUserJsonFile());
     const projectConfig = removeProjectSensitiveConfig(toPeaksConfig(readProjectJsonFile(detectedRoot)));
-    const { proxy: projectProxy, workspaces: projectWorkspaces, ...projectConfigWithoutProxy } = projectConfig;
-    const userWorkspaces = userConfig.workspaces ?? [];
+    const { proxy: projectProxy, ...projectConfigWithoutProxy } = projectConfig;
     return {
         ...DEFAULT_CONFIG,
         ...userConfig,
-        ...projectConfigWithoutProxy,
-        workspaces: mergeWorkspaceConfigs(userWorkspaces, projectWorkspaces ?? [])
+        ...projectConfigWithoutProxy
     };
 }
+function sanitizeWorkspacePartial(partial) {
+    const result = { ...partial };
+    if (Array.isArray(result.workspaces)) {
+        result.workspaces = toWorkspaceConfigs(result.workspaces);
+    }
+    if (typeof result.currentWorkspace !== 'string' && result.currentWorkspace !== null && result.currentWorkspace !== undefined) {
+        delete result.currentWorkspace;
+    }
+    return result;
+}
 export function writeConfig(partial, layer = 'user') {
     if (!isConfigLayer(layer)) {
         throw new Error('Invalid config layer');
@@ -446,29 +438,28 @@ export function writeConfig(partial, layer = 'user') {
         const { projectRoot, configPath } = getProjectWriteTarget();
         ensureDir(dirname(configPath));
         const existing = readJsonFile(configPath, () => validateProjectBootstrapConfigPathForWrite(projectRoot, configPath)) ?? {};
-        const merged = { ...existing, ...partial };
+        const merged = sanitizeWorkspacePartial({ ...existing, ...partial });
         writeProjectConfigFile(projectRoot, configPath, JSON.stringify(merged, null, 2));
         return;
     }
     const userPath = getUserConfigPath();
     ensureDir(dirname(userPath));
     const existing = readJsonFile(userPath, () => validateUserConfigPathForWrite(userPath)) ?? {};
-    const merged = { ...existing, ...partial };
+    const merged = sanitizeWorkspacePartial({ ...existing, ...partial });
     writeUserConfigFile(userPath, JSON.stringify(merged, null, 2));
 }
 export function getConfig(options = {}) {
     const projectRoot = findProjectRoot(process.cwd());
     const userConfig = readUserJsonFile() ?? {};
     const projectConfig = removeProjectSensitiveConfig(readProjectJsonFile(projectRoot) ?? {});
-    const { proxy: projectProxy, workspaces: projectWorkspaces, ...projectConfigWithoutProxy } = projectConfig;
+    const { proxy: projectProxy, ...projectConfigWithoutProxy } = projectConfig;
     const source = options.layer === 'user'
         ? userConfig
         : options.layer === 'project'
             ? projectConfig
             : {
                 ...userConfig,
-                ...projectConfigWithoutProxy,
-                workspaces: mergeWorkspaceConfigs(toWorkspaceConfigs(userConfig.workspaces), toWorkspaceConfigs(projectWorkspaces))
+                ...projectConfigWithoutProxy
             };
     const config = isRecord(source) ? { ...source, ...(source.tokens !== undefined ? { tokens: toTokenConfig(source.tokens) } : {}) } : source;
     if (options.key !== undefined) {
@@ -514,11 +505,7 @@ export function setConfig(options) {
         writeUserConfigFile(targetPath, content);
     }
 }
-export function getWorkspaceConfig(workspaceId, projectRoot) {
-    const config = readConfig(projectRoot ?? findProjectRoot(process.cwd()));
-    return config.workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
-}
-function readLayerConfig(layer) {
+function readRawWorkspaceData(layer) {
     const config = getConfig({ layer });
     return isRecord(config)
         ? {
@@ -527,61 +514,74 @@ function readLayerConfig(layer) {
         }
         : { currentWorkspace: null, workspaces: [] };
 }
+function writeRawWorkspaceData(data, layer) {
+    const projectTarget = layer === 'project' ? getProjectWriteTarget() : null;
+    const targetPath = projectTarget?.configPath ?? getUserConfigPath();
+    ensureDir(dirname(targetPath));
+    const existing = projectTarget
+        ? readJsonFile(targetPath, () => validateProjectBootstrapConfigPathForWrite(projectTarget.projectRoot, targetPath)) ?? {}
+        : readJsonFile(targetPath, () => validateUserConfigPathForWrite(targetPath)) ?? {};
+    const merged = { ...existing, ...data };
+    const content = JSON.stringify(merged, null, 2);
+    if (projectTarget) {
+        writeProjectConfigFile(projectTarget.projectRoot, targetPath, content);
+    }
+    else {
+        writeUserConfigFile(targetPath, content);
+    }
+}
+export function getWorkspaceConfig(workspaceId, projectRoot) {
+    const { workspaces } = readRawWorkspaceData('user');
+    return workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
+}
+function readLayerConfig(layer) {
+    return readRawWorkspaceData(layer);
+}
 export function addWorkspace(workspace, layer = 'user') {
     if (!isSafeConfigSegment(workspace.workspaceId)) {
         throw new Error('Workspace id must only contain letters, numbers, dots, underscores, or hyphens and must not contain path traversal');
     }
-    const config = readLayerConfig(layer);
+    const config = readRawWorkspaceData(layer);
     const workspaces = config.workspaces;
     const existing = workspaces.findIndex((w) => w.workspaceId === workspace.workspaceId);
     const updatedWorkspaces = existing >= 0
         ? workspaces.map((existingWorkspace) => existingWorkspace.workspaceId === workspace.workspaceId ? workspace : existingWorkspace)
         : [...workspaces, workspace];
-    writeConfig({ workspaces: updatedWorkspaces }, layer);
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces }, layer);
 }
 export function removeWorkspace(workspaceId, layer = 'user') {
     if (!isSafeConfigSegment(workspaceId))
         return false;
-    const config = readLayerConfig(layer);
+    const config = readRawWorkspaceData(layer);
     const workspaces = config.workspaces;
     const idx = workspaces.findIndex((w) => w.workspaceId === workspaceId);
     if (idx < 0)
         return false;
     const updatedWorkspaces = workspaces.filter((w) => w.workspaceId !== workspaceId);
     const currentWorkspace = config.currentWorkspace === workspaceId ? updatedWorkspaces[0]?.workspaceId ?? null : config.currentWorkspace ?? null;
-    writeConfig({ workspaces: updatedWorkspaces, currentWorkspace }, layer);
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces, currentWorkspace }, layer);
     return true;
 }
 export function setCurrentWorkspace(workspaceId, layer = 'user') {
     if (!isSafeConfigSegment(workspaceId))
         return false;
-    const config = readLayerConfig(layer);
+    const config = readRawWorkspaceData(layer);
     const workspaces = config.workspaces;
     const exists = workspaces.some((w) => w.workspaceId === workspaceId);
     if (!exists)
         return false;
-    writeConfig({ currentWorkspace: workspaceId }, layer);
+    writeRawWorkspaceData({ currentWorkspace: workspaceId }, layer);
     return true;
 }
 export function getCurrentWorkspaceConfig() {
-    const config = readConfig();
-    if (!config.currentWorkspace)
+    const { currentWorkspace, workspaces } = readRawWorkspaceData('user');
+    if (!currentWorkspace)
         return null;
-    return getWorkspaceConfig(config.currentWorkspace);
+    return workspaces.find((w) => w.workspaceId === currentWorkspace) ?? null;
 }
 export function getWorkspaceConfigForPath(path = process.cwd()) {
-    const config = readConfig(findProjectRoot(path));
-    return findWorkspaceForPath(config.workspaces, path);
-}
-function createWorkspaceId(projectRoot, existingIds) {
-    const base = toSafeConfigSegment(basename(projectRoot));
-    if (!existingIds.has(base))
-        return base;
-    let suffix = 2;
-    while (existingIds.has(`${base}-${suffix}`)) {
-        suffix += 1;
-    }
-    return `${base}-${suffix}`;
+    const { workspaces } = readRawWorkspaceData('user');
+    return findWorkspaceForPath(workspaces, path);
 }
 function findWorkspaceForPath(workspaces, path) {
     const targetPath = stablePath(path);
@@ -596,7 +596,7 @@ function findWorkspaceForPath(workspaces, path) {
     return matches.reduce((best, match) => match.rootPath.length > best.rootPath.length ? match : best).workspace;
 }
 function getWorkspaceArtifactRoot(workspace) {
-    return workspace.artifactStorage?.localPath ? resolve(workspace.artifactStorage.localPath) : resolve(homedir(), '.peaks', 'workspaces', workspace.workspaceId, 'artifacts');
+    return workspace.artifactStorage?.localPath ? resolve(workspace.artifactStorage.localPath) : resolve(workspace.rootPath, '.peaks', 'artifacts');
 }
 function ensureArtifactWorkspaceMarker(workspace) {
     const artifactRoot = getWorkspaceArtifactRoot(workspace);
@@ -618,24 +618,9 @@ export function ensureWorkspaceConfigForPath(path = process.cwd()) {
     const existingWorkspace = findWorkspaceForPath(config.workspaces, path);
     if (existingWorkspace) {
         ensureArtifactWorkspaceMarker(existingWorkspace);
-        if (!config.currentWorkspace) {
-            writeConfig({ currentWorkspace: existingWorkspace.workspaceId }, 'user');
-        }
         return existingWorkspace;
     }
-    const existingIds = new Set(config.workspaces.map((workspace) => workspace.workspaceId));
-    const workspaceId = createWorkspaceId(projectRoot, existingIds);
-    const workspace = {
-        workspaceId,
-        name: basename(projectRoot) || 'Workspace',
-        rootPath: stablePath(projectRoot),
-        artifactStorage: { mode: 'local', localPath: resolve(homedir(), '.peaks', 'workspaces', workspaceId, 'artifacts') },
-        installedCapabilityIds: []
-    };
-    ensureArtifactWorkspaceMarker(workspace);
-    const updatedWorkspaces = [...config.workspaces, workspace];
-    writeConfig({ workspaces: updatedWorkspaces, ...(!config.currentWorkspace ? { currentWorkspace: workspace.workspaceId } : {}) }, 'user');
-    return workspace;
+    return null;
 }
 export function getWorkspaceConfigForCurrentPath() {
     return getWorkspaceConfigForPath(process.cwd());

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

@@ -51,8 +51,6 @@ export type WorkspaceConfig = {
 };
 export type PeaksConfig = {
     version: string;
-    currentWorkspace: string | null;
-    workspaces: WorkspaceConfig[];
     language: string;
     model: ModelPreference;
     economyMode: boolean;

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

@@ -1,8 +1,6 @@
 import { CLI_VERSION } from '../../shared/version.js';
 export const DEFAULT_CONFIG = {
     version: CLI_VERSION,
-    currentWorkspace: null,
-    workspaces: [],
     language: 'en',
     model: 'sonnet',
     economyMode: true,

package/dist/src/services/mode/bypass-tracker.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_BYPASSES_PER_SESSION = 3;
+export declare function getBypassCount(sessionRoot: string): number;
+export declare function recordBypass(sessionRoot: string): number;
+export declare function isBypassLimitReached(sessionRoot: string): boolean;

package/dist/src/services/mode/bypass-tracker.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const MAX_BYPASSES_PER_SESSION = 3;
+const BYPASS_FILE = '.bypass-count.json';
+function bypassFilePath(sessionRoot) {
+    return join(sessionRoot, BYPASS_FILE);
+}
+export function getBypassCount(sessionRoot) {
+    const filePath = bypassFilePath(sessionRoot);
+    if (!existsSync(filePath)) {
+        return 0;
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.count === 'number' ? parsed.count : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function recordBypass(sessionRoot) {
+    const current = getBypassCount(sessionRoot);
+    const next = current + 1;
+    const filePath = bypassFilePath(sessionRoot);
+    writeFileSync(filePath, JSON.stringify({ count: next }, null, 2), 'utf8');
+    return next;
+}
+export function isBypassLimitReached(sessionRoot) {
+    return getBypassCount(sessionRoot) >= MAX_BYPASSES_PER_SESSION;
+}

package/dist/src/services/mode/mode-enforcement.d.ts

@@ -0,0 +1,14 @@
+import { type SkillPresenceMode } from '../skills/skill-presence-service.js';
+type TransitionKey = `${string}:${string}`;
+export declare function requiresConfirmation(mode: SkillPresenceMode, transitionKey: TransitionKey): boolean;
+export type ConfirmationOptions = {
+    projectRoot: string;
+    transitionKey: TransitionKey;
+    confirmed?: boolean | undefined;
+    forceConfirm?: boolean | undefined;
+};
+export declare class ConfirmationRequiredError extends Error {
+    constructor(transitionKey: TransitionKey);
+}
+export declare function requireUserConfirmation(options: ConfirmationOptions): Promise<void>;
+export {};

package/dist/src/services/mode/mode-enforcement.js

@@ -0,0 +1,81 @@
+import * as readline from 'node:readline';
+import { getSkillPresence } from '../skills/skill-presence-service.js';
+const ASSISTED_CONFIRM_TRANSITIONS = new Set([
+    'prd:confirmed-by-user',
+    'rd:qa-handoff',
+    'qa:verdict-issued'
+]);
+export function requiresConfirmation(mode, transitionKey) {
+    if (mode === 'full-auto' || mode === 'swarm') {
+        return false;
+    }
+    if (mode === 'strict') {
+        return true;
+    }
+    // assisted: only specific transitions
+    return ASSISTED_CONFIRM_TRANSITIONS.has(transitionKey);
+}
+function describeTransition(transitionKey) {
+    const parts = transitionKey.split(':');
+    const role = parts[0] ?? 'unknown';
+    const state = parts[1] ?? 'unknown';
+    return `Transition ${role.toUpperCase()} → ${state}`;
+}
+export class ConfirmationRequiredError extends Error {
+    constructor(transitionKey) {
+        const description = describeTransition(transitionKey);
+        super(`Confirmation required for: ${description}\n` +
+            'Add --confirm to proceed non-interactively, or run in an interactive terminal.\n' +
+            'In assisted/strict mode, major workflow boundaries require explicit user approval.');
+        this.name = 'ConfirmationRequiredError';
+    }
+}
+export async function requireUserConfirmation(options) {
+    const presence = getSkillPresence();
+    if (!presence?.mode) {
+        return;
+    }
+    const mode = presence.mode;
+    if (!requiresConfirmation(mode, options.transitionKey)) {
+        return;
+    }
+    // --confirm flag bypasses interactive prompt
+    if (options.confirmed) {
+        return;
+    }
+    // PEAKS_AUTO_CONFIRM=1 only works for full-auto/swarm (already returned above)
+    // For assisted/strict, env var is ignored unless --force-confirm is also set
+    if (process.env.PEAKS_AUTO_CONFIRM === '1') {
+        if (options.forceConfirm) {
+            console.error(`[WARNING] --force-confirm used in ${mode} mode. ` +
+                'This bypasses user confirmation. Use with caution.');
+            return;
+        }
+        throw new ConfirmationRequiredError(options.transitionKey);
+    }
+    // --force-confirm without env var
+    if (options.forceConfirm) {
+        console.error(`[WARNING] --force-confirm used in ${mode} mode. ` +
+            'This bypasses user confirmation. Use with caution.');
+        return;
+    }
+    // Interactive prompt
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr
+    });
+    return new Promise((resolve, reject) => {
+        const description = describeTransition(options.transitionKey);
+        const prompt = `\n[CONFIRM] ${description}\nProceed? (y/N) `;
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === 'y' || normalized === 'yes') {
+                resolve();
+            }
+            else {
+                reject(new ConfirmationRequiredError(options.transitionKey));
+            }
+        });
+    });
+}

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

@@ -2,7 +2,7 @@ import { existsSync, lstatSync, readFileSync, realpathSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { basename, relative, resolve } from 'node:path';
 import { isInsidePath } from '../../shared/path-utils.js';
-import { getCurrentWorkspaceConfig } from '../config/config-service.js';
+import { getWorkspaceConfigForPath } from '../config/config-service.js';
 import { getArtifactRemoteRepo, getArtifactWorkspaceStatus, getLocalArtifactPath } from '../artifacts/workspace-service.js';
 const REQUIRED_ARTIFACTS = [
     { name: 'retention-boundary.md', path: ['sc', 'retention-boundary.md'] },
@@ -109,7 +109,7 @@ function isRetainedArtifactFile(filePath, artifactWorkspacePath, changesRoot, ch
     }
 }
 export function getChangeTraceabilityStatus() {
-    const workspace = getCurrentWorkspaceConfig();
+    const workspace = getWorkspaceConfigForPath(process.cwd());
     const artifactStatus = getArtifactWorkspaceStatus(workspace?.workspaceId);
     if (!workspace) {
         return {
@@ -155,7 +155,7 @@ export function getChangeTraceabilityStatus() {
     };
 }
 export function createChangeImpact(options) {
-    const workspace = getCurrentWorkspaceConfig();
+    const workspace = getWorkspaceConfigForPath(process.cwd());
     const artifactRepo = workspace ? getArtifactRemoteRepo(workspace) : null;
     return {
         changeId: options.changeId,
@@ -193,7 +193,7 @@ export function createArtifactRetentionReport(options) {
     };
 }
 export function recordCommitBoundary(options) {
-    const workspace = getCurrentWorkspaceConfig();
+    const workspace = getWorkspaceConfigForPath(process.cwd());
     const artifactStatus = getArtifactWorkspaceStatus(workspace?.workspaceId);
     const commitHash = getCurrentCommitHash(workspace?.rootPath);
     return {
@@ -207,7 +207,7 @@ export function recordCommitBoundary(options) {
     };
 }
 export function validateArtifactRetention(sliceId) {
-    const workspace = getCurrentWorkspaceConfig();
+    const workspace = getWorkspaceConfigForPath(process.cwd());
     if (!workspace) {
         return {
             valid: false,

package/dist/src/services/scan/file-size-scan.d.ts

@@ -0,0 +1,19 @@
+export declare const DEFAULT_FILE_SIZE_THRESHOLD = 800;
+export type FileSizeViolation = {
+    file: string;
+    lines: number;
+};
+export type FileSizeScanResult = {
+    ok: boolean;
+    threshold: number;
+    checkedFiles: number;
+    violations: FileSizeViolation[];
+};
+export type FileSizeScanOptions = {
+    projectRoot: string;
+    /** Compare working tree against this ref. Default 'HEAD'. */
+    baseRef?: string;
+    /** Line count threshold. Default 800. */
+    threshold?: number;
+};
+export declare function scanFileSize(options: FileSizeScanOptions): FileSizeScanResult;

package/dist/src/services/scan/file-size-scan.js

@@ -0,0 +1,44 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const DEFAULT_FILE_SIZE_THRESHOLD = 800;
+function getChangedFiles(projectRoot, baseRef) {
+    try {
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8' });
+        const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return Array.from(new Set([...tracked, ...untracked]));
+    }
+    catch {
+        return [];
+    }
+}
+function countLines(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        return content.split(/\r?\n/).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function scanFileSize(options) {
+    const baseRef = options.baseRef ?? 'HEAD';
+    const threshold = options.threshold ?? DEFAULT_FILE_SIZE_THRESHOLD;
+    const files = getChangedFiles(options.projectRoot, baseRef);
+    const violations = [];
+    for (const file of files) {
+        const absolute = join(options.projectRoot, file);
+        const lines = countLines(absolute);
+        if (lines > threshold) {
+            violations.push({ file, lines });
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        threshold,
+        checkedFiles: files.length,
+        violations
+    };
+}

package/dist/src/services/session/index.d.ts

@@ -0,0 +1 @@
+export { ensureSession, getSessionId, getCurrentSessionDir, listSessions, getProjectScanPath, hasProjectScan, type SessionInfo } from './session-manager.js';

package/dist/src/services/session/index.js

@@ -0,0 +1 @@
+export { ensureSession, getSessionId, getCurrentSessionDir, listSessions, getProjectScanPath, hasProjectScan } from './session-manager.js';

package/dist/src/services/session/session-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Session management service for Peaks artifact storage.
+ * Manages session lifecycle: creation, retrieval, and directory initialization.
+ *
+ * Sessions are automatically created when any skill is invoked.
+ * Each session gets a unique directory under .peaks/ with incrementing numbered files.
+ */
+export type SessionInfo = {
+    sessionId: string;
+    createdAt: string;
+    projectRoot: string;
+};
+/**
+ * Get or create the current session for a project.
+ * If a valid session already exists, returns it.
+ * Otherwise, creates a new session with auto-generated ID.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns Session ID (e.g., "2026-05-26-session-a3f8b1")
+ */
+export declare function ensureSession(projectRoot: string): Promise<string>;
+/**
+ * Get the current session ID without creating a new one.
+ * Returns null if no session exists.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns Session ID or null
+ */
+export declare function getSessionId(projectRoot: string): string | null;
+/**
+ * Get the absolute path to the current session directory.
+ * Creates the session if it doesn't exist.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns Absolute path to session directory (e.g., "/path/to/project/.peaks/2026-05-26-session-a3f8b1")
+ */
+export declare function getCurrentSessionDir(projectRoot: string): Promise<string>;
+/**
+ * List all session directories in the .peaks folder.
+ * Returns session IDs (directory names) sorted by date.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns Array of session IDs
+ */
+export declare function listSessions(projectRoot: string): string[];
+/**
+ * Get the path to project-scan.md for the current session.
+ * Creates the session if it doesn't exist.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns Absolute path to project-scan.md
+ */
+export declare function getProjectScanPath(projectRoot: string): Promise<string>;
+/**
+ * Check if project-scan.md exists for the current session.
+ *
+ * @param projectRoot - Root directory of the project
+ * @returns true if project-scan.md exists
+ */
+export declare function hasProjectScan(projectRoot: string): boolean;