peaks-cli 1.0.14 → 1.0.15

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

@@ -1,280 +1,11 @@
-import { closeSync, constants, existsSync, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, resolve } from 'node:path';
 import { DEFAULT_CONFIG } from './config-types.js';
 import { stablePath } from '../../shared/path-utils.js';
-function getUserConfigPath() {
-    return resolve(homedir(), '.peaks', 'config.json');
-}
-function isInsidePath(childPath, parentPath) {
-    const relativePath = relative(parentPath, childPath);
-    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
-}
-function isSafeProjectConfigMarker(projectRoot) {
-    const peaksPath = resolve(projectRoot, '.peaks');
-    const markerPath = resolve(peaksPath, 'config.json');
-    try {
-        const projectRootReal = realpathSync(projectRoot);
-        const peaksStats = lstatSync(peaksPath);
-        const peaksReal = realpathSync(peaksPath);
-        const markerStats = lstatSync(markerPath);
-        if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink())
-            return false;
-        if (!markerStats.isFile() || markerStats.isSymbolicLink() || markerStats.nlink !== 1)
-            return false;
-        const markerReal = realpathSync(markerPath);
-        if (!isInsidePath(peaksReal, projectRootReal))
-            return false;
-        if (!isInsidePath(markerReal, projectRootReal))
-            return false;
-        return isInsidePath(markerReal, peaksReal);
-    }
-    catch {
-        return false;
-    }
-}
-function normalizeBoundaryPath(path) {
-    const resolved = resolve(path);
-    let realPath = resolved;
-    try {
-        realPath = existsSync(resolved) ? realpathSync.native(resolved) : resolved;
-    }
-    catch {
-        realPath = resolved;
-    }
-    return process.platform === 'win32' || process.platform === 'darwin' ? realPath.toLowerCase() : realPath;
-}
-function getHomeBoundaryPaths() {
-    return new Set([homedir(), process.env.HOME, process.env.USERPROFILE].filter((path) => typeof path === 'string' && path.length > 0).map(normalizeBoundaryPath));
-}
-function findProjectRoot(startPath) {
-    const homeBoundaryPaths = getHomeBoundaryPaths();
-    let current = resolve(startPath);
-    let parent = dirname(current);
-    while (current !== parent && !homeBoundaryPaths.has(normalizeBoundaryPath(current))) {
-        if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
-            return current;
-        }
-        parent = current;
-        current = dirname(parent);
-    }
-    return null;
-}
-export function resolveProjectRootForConfig(startPath) {
-    const start = resolve(startPath);
-    const homeBoundaryPaths = getHomeBoundaryPaths();
-    let current = start;
-    let parent = dirname(current);
-    while (current !== parent && !homeBoundaryPaths.has(normalizeBoundaryPath(current))) {
-        if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
-            return current;
-        }
-        if (existsSync(resolve(current, 'package.json')) || existsSync(resolve(current, '.git'))) {
-            return current;
-        }
-        parent = current;
-        current = dirname(parent);
-    }
-    return start;
-}
-function getProjectConfigPath(projectRoot) {
-    if (!projectRoot)
-        return null;
-    if (!isSafeProjectConfigMarker(projectRoot))
-        return null;
-    return resolve(projectRoot, '.peaks', 'config.json');
-}
-function getProjectBootstrapConfigPath(projectRoot) {
-    const projectRootPath = resolve(projectRoot);
-    const peaksPath = resolve(projectRootPath, '.peaks');
-    const configPath = resolve(peaksPath, 'config.json');
-    if (!isInsidePath(configPath, projectRootPath)) {
-        throw new Error('Project config path must stay inside the project root');
-    }
-    if (!existsSync(peaksPath)) {
-        mkdirSync(peaksPath, { recursive: true });
-    }
-    validateProjectBootstrapConfigPath(projectRootPath, peaksPath, configPath);
-    return configPath;
-}
-function validateProjectBootstrapConfigPath(projectRootPath, peaksPath, configPath) {
-    const projectRootReal = realpathSync(projectRootPath);
-    const peaksStats = lstatSync(peaksPath);
-    const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(projectRootReal, '.peaks')) {
-        throw new Error('Project config path must stay inside the project root');
-    }
-    try {
-        const markerStats = lstatSync(configPath);
-        if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
-            throw new Error('Project config path must stay inside the project root');
-        }
-        if (markerStats.nlink !== 1) {
-            throw new Error('Config path must not be hardlinked');
-        }
-        const markerReal = realpathSync(configPath);
-        if (!isInsidePath(markerReal, projectRootReal) || !isInsidePath(markerReal, peaksReal)) {
-            throw new Error('Project config path must stay inside the project root');
-        }
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
-    }
-}
-function validateProjectBootstrapConfigPathForWrite(projectRoot, configPath) {
-    const projectRootPath = resolve(projectRoot);
-    validateProjectBootstrapConfigPath(projectRootPath, resolve(projectRootPath, '.peaks'), configPath);
-}
-function validateUserConfigPathForWrite(configPath) {
-    const userRoot = resolve(homedir());
-    const peaksPath = resolve(userRoot, '.peaks');
-    const userRootReal = realpathSync(userRoot);
-    const peaksStats = lstatSync(peaksPath);
-    const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(userRootReal, '.peaks')) {
-        throw new Error('User config path must stay inside the user root');
-    }
-    try {
-        const markerStats = lstatSync(configPath);
-        if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
-            throw new Error('User config path must stay inside the user root');
-        }
-        if (markerStats.nlink !== 1) {
-            throw new Error('Config path must not be hardlinked');
-        }
-        const markerReal = realpathSync(configPath);
-        if (!isInsidePath(markerReal, userRootReal) || !isInsidePath(markerReal, peaksReal)) {
-            throw new Error('User config path must stay inside the user root');
-        }
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
-    }
-}
-function validateArtifactWorkspaceRoot(artifactRoot, workspaceRoot) {
-    const artifactStats = lstatSync(artifactRoot);
-    if (!artifactStats.isDirectory() || artifactStats.isSymbolicLink()) {
-        throw new Error('Artifact workspace marker must stay inside the artifact workspace');
-    }
-    const artifactRootReal = realpathSync(artifactRoot);
-    const workspaceRootReal = realpathSync(workspaceRoot);
-    if (isInsidePath(artifactRootReal, workspaceRootReal)) {
-        throw new Error('Artifact workspace must stay outside the project root');
-    }
-}
-function validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath) {
-    const artifactStats = lstatSync(artifactRoot);
-    if (!artifactStats.isDirectory() || artifactStats.isSymbolicLink()) {
-        throw new Error('Artifact workspace marker must stay inside the artifact workspace');
-    }
-    const artifactRootReal = realpathSync(artifactRoot);
-    const peaksStats = lstatSync(peaksPath);
-    const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(artifactRootReal, '.peaks')) {
-        throw new Error('Artifact workspace marker must stay inside the artifact workspace');
-    }
-    try {
-        const markerStats = lstatSync(markerPath);
-        if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
-            throw new Error('Artifact workspace marker must stay inside the artifact workspace');
-        }
-        if (markerStats.nlink !== 1) {
-            throw new Error('Config path must not be hardlinked');
-        }
-        const markerReal = realpathSync(markerPath);
-        if (!isInsidePath(markerReal, artifactRootReal) || !isInsidePath(markerReal, peaksReal)) {
-            throw new Error('Artifact workspace marker must stay inside the artifact workspace');
-        }
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
-    }
-}
-function validateOpenConfigFile(fd, tempPath, errorMessage) {
-    const fdStats = fstatSync(fd);
-    const pathStats = lstatSync(tempPath);
-    if (!fdStats.isFile() || !pathStats.isFile() || fdStats.dev !== pathStats.dev || fdStats.ino !== pathStats.ino) {
-        throw new Error(errorMessage);
-    }
-    if (fdStats.nlink !== 1 || pathStats.nlink !== 1) {
-        throw new Error('Config path must not be hardlinked');
-    }
-}
-function getSafeTempOpenFlags() {
-    const baseFlags = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL;
-    return typeof constants.O_NOFOLLOW === 'number' ? baseFlags | constants.O_NOFOLLOW : baseFlags;
-}
-function getSafeReadOpenFlags() {
-    return typeof constants.O_NOFOLLOW === 'number' ? constants.O_RDONLY | constants.O_NOFOLLOW : constants.O_RDONLY;
-}
-function readConfigFileSafely(configPath, errorMessage) {
-    const fd = openSync(configPath, getSafeReadOpenFlags());
-    try {
-        validateOpenConfigFile(fd, configPath, errorMessage);
-        return readFileSync(fd, 'utf-8');
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function writeConfigFileSafely(configPath, content, validateBeforeWrite, errorMessage) {
-    validateBeforeWrite();
-    const tempPath = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
-    let fd = openSync(tempPath, getSafeTempOpenFlags(), 0o600);
-    let renamed = false;
-    let closeError;
-    try {
-        validateOpenConfigFile(fd, tempPath, errorMessage);
-        fchmodSync(fd, 0o600);
-        writeFileSync(fd, content, 'utf-8');
-        const writeFd = fd;
-        fd = null;
-        closeSync(writeFd);
-        validateBeforeWrite();
-        const readFd = openSync(tempPath, getSafeReadOpenFlags());
-        try {
-            validateOpenConfigFile(readFd, tempPath, errorMessage);
-        }
-        finally {
-            closeSync(readFd);
-        }
-        renameSync(tempPath, configPath);
-        renamed = true;
-    }
-    finally {
-        if (fd !== null) {
-            try {
-                closeSync(fd);
-            }
-            catch (error) {
-                closeError = error;
-            }
-        }
-        try {
-            if (!renamed && existsSync(tempPath)) {
-                unlinkSync(tempPath);
-            }
-        }
-        finally {
-            if (closeError) {
-                throw closeError;
-            }
-        }
-    }
-}
-function writeProjectConfigFile(projectRoot, configPath, content) {
-    writeConfigFileSafely(configPath, content, () => validateProjectBootstrapConfigPathForWrite(projectRoot, configPath), 'Project config path must stay inside the project root');
-}
-function writeUserConfigFile(configPath, content) {
-    writeConfigFileSafely(configPath, content, () => validateUserConfigPathForWrite(configPath), 'User config path must stay inside the user root');
-}
+import { findProjectRoot, getProjectBootstrapConfigPath, getProjectConfigPath, getUserConfigPath, isInsidePath, readConfigFileSafely, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
+// Re-export resolveProjectRootForConfig for external consumers
+export { resolveProjectRootForConfig } from './config-safety.js';
 function readJsonFile(path, validateBeforeRead, errorMessage = 'Config path must stay inside the config root') {
     if (!path || !existsSync(path))
         return null;

package/dist/src/services/dashboard/project-dashboard-service.d.ts

@@ -2,6 +2,7 @@ import { type RequestArtifactRole, type RequestArtifactSummary } from '../artifa
 import type { OpenSpecChangeSummary } from '../openspec/openspec-types.js';
 import type { McpScanReport } from '../mcp/mcp-types.js';
 import type { CapabilityItem } from '../recommendations/recommendation-types.js';
+import { type SkillPresence } from '../skills/skill-presence-service.js';
 export type ProjectDashboardRequests = {
     count: number;
     byRole: Record<RequestArtifactRole, RequestArtifactSummary[]>;
@@ -39,6 +40,14 @@ export type ProjectDashboardCapabilities = {
     mcpCount: number;
     sample: Array<Pick<CapabilityItem, 'capabilityId' | 'name' | 'itemType' | 'category'>>;
 };
+export type ProjectDashboardSkillPresence = {
+    active: boolean;
+    fresh: boolean;
+    skill?: string;
+    mode?: string;
+    gate?: string;
+    setAt?: string;
+};
 export type ProjectDashboard = {
     generatedAt: string;
     projectRoot: string;
@@ -49,6 +58,7 @@ export type ProjectDashboard = {
     doctor: ProjectDashboardDoctor;
     runbookHealth: ProjectDashboardRunbookHealth;
     capabilities: ProjectDashboardCapabilities;
+    skillPresence: ProjectDashboardSkillPresence;
 };
 export type LoadProjectDashboardOptions = {
     projectRoot: string;
@@ -60,5 +70,6 @@ export type LoadProjectDashboardOptions = {
         failed: number;
     };
     runbookHealth?: ProjectDashboardRunbookHealth;
+    skillPresence?: SkillPresence | null;
 };
 export declare function loadProjectDashboard(options: LoadProjectDashboardOptions): Promise<ProjectDashboard>;

package/dist/src/services/dashboard/project-dashboard-service.js

@@ -4,11 +4,13 @@ import { scanMcpServers } from '../mcp/mcp-scan-service.js';
 import { scanUnderstandAnything } from '../understand/understand-scan-service.js';
 import { seedCapabilityItems } from '../recommendations/capability-seed-items.js';
 import { requiredSkillNames } from '../../shared/paths.js';
+import { getSkillPresence } from '../skills/skill-presence-service.js';
+const SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 function defaultClock() {
     return new Date().toISOString();
 }
 function groupRequestsByRole(items) {
-    const byRole = { prd: [], ui: [], rd: [], qa: [] };
+    const byRole = { prd: [], ui: [], rd: [], qa: [], sc: [] };
     for (const item of items) {
         byRole[item.role].push(item);
     }
@@ -72,6 +74,22 @@ function buildCapabilitiesSummary(sampleSize) {
         }))
     };
 }
+function buildSkillPresenceSummary(presence) {
+    const resolved = presence === undefined ? getSkillPresence() : presence;
+    if (resolved === null) {
+        return { active: false, fresh: true };
+    }
+    const setAtMs = Date.parse(resolved.setAt);
+    const fresh = !Number.isNaN(setAtMs) && Date.now() - setAtMs <= SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS;
+    return {
+        active: true,
+        fresh,
+        skill: resolved.skill,
+        ...(resolved.mode !== undefined ? { mode: resolved.mode } : {}),
+        ...(resolved.gate !== undefined ? { gate: resolved.gate } : {}),
+        setAt: resolved.setAt
+    };
+}
 export async function loadProjectDashboard(options) {
     const clock = options.clock ?? defaultClock;
     const sampleSize = options.sampleCapabilities ?? 8;
@@ -107,6 +125,7 @@ export async function loadProjectDashboard(options) {
         },
         doctor: doctorAndRunbook.doctor,
         runbookHealth: doctorAndRunbook.runbookHealth,
-        capabilities: buildCapabilitiesSummary(sampleSize)
+        capabilities: buildCapabilitiesSummary(sampleSize),
+        skillPresence: buildSkillPresenceSummary(options.skillPresence)
     };
 }

package/dist/src/services/doctor/doctor-service.d.ts

@@ -1,3 +1,4 @@
+import { type SkillPresence } from '../skills/skill-presence-service.js';
 export type DoctorCheck = {
     id: string;
     ok: boolean;
@@ -21,5 +22,7 @@ export type DoctorOptions = {
     schemasBaseDir?: string;
     skillsBaseDir?: string;
     codegraphProbe?: () => CodegraphCapabilityProbe;
+    skillPresenceProbe?: () => SkillPresence | null;
+    skillPresenceFreshnessThresholdMs?: number;
 };
 export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

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

@@ -7,7 +7,9 @@ import { readText } from '../../shared/fs.js';
 import { requiredSchemaFiles, requiredSkillNames, schemasDir } from '../../shared/paths.js';
 import { getErrorMessage } from '../../shared/result.js';
 import { loadSkillRegistry } from '../skills/skill-registry.js';
+import { getSkillPresence } from '../skills/skill-presence-service.js';
 const CODEGRAPH_EXPECTED_VERSION = '0.7.10';
+const SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 function defaultCodegraphProbe() {
     const require = createRequire(import.meta.url);
     const packagePath = require.resolve('@colbymchenry/codegraph/package.json');
@@ -132,6 +134,62 @@ export async function runDoctor(options = {}) {
         ok: true,
         message: hasUserConfig ? 'User config exists at ~/.peaks/config.json' : 'Optional user config not found at ~/.peaks/config.json'
     });
+    const presenceProbe = options.skillPresenceProbe ?? getSkillPresence;
+    const freshnessThresholdMs = options.skillPresenceFreshnessThresholdMs ?? SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS;
+    let presence = null;
+    try {
+        presence = presenceProbe();
+    }
+    catch {
+        presence = null;
+    }
+    if (presence === null) {
+        checks.push({
+            id: 'skill-presence:current',
+            ok: true,
+            message: 'No active Peaks skill presence (.peaks/.active-skill.json absent or invalid)'
+        });
+        checks.push({
+            id: 'skill-presence:freshness',
+            ok: true,
+            message: 'No active Peaks skill presence to age-check'
+        });
+    }
+    else {
+        const modePart = presence.mode !== undefined ? `, mode ${presence.mode}` : '';
+        const gatePart = presence.gate !== undefined ? `, gate ${presence.gate}` : '';
+        checks.push({
+            id: 'skill-presence:current',
+            ok: true,
+            message: `Active Peaks skill presence: ${presence.skill}${modePart}${gatePart} (set ${presence.setAt})`
+        });
+        const setAtMs = Date.parse(presence.setAt);
+        if (Number.isNaN(setAtMs)) {
+            checks.push({
+                id: 'skill-presence:freshness',
+                ok: false,
+                message: `Skill presence ${presence.skill} has invalid setAt: ${presence.setAt}`
+            });
+        }
+        else {
+            const ageMs = Date.now() - setAtMs;
+            if (ageMs > freshnessThresholdMs) {
+                const ageHours = Math.round(ageMs / (60 * 60 * 1000));
+                checks.push({
+                    id: 'skill-presence:freshness',
+                    ok: false,
+                    message: `Skill presence ${presence.skill} is stale (set ${presence.setAt}, ~${ageHours}h ago); run peaks skill presence:clear if the role has ended`
+                });
+            }
+            else {
+                checks.push({
+                    id: 'skill-presence:freshness',
+                    ok: true,
+                    message: `Skill presence ${presence.skill} is fresh (set ${presence.setAt})`
+                });
+            }
+        }
+    }
     const probe = options.codegraphProbe ?? defaultCodegraphProbe;
     try {
         const result = probe();

package/dist/src/services/workflow/autonomous-resume-writer.d.ts

@@ -0,0 +1,16 @@
+export type AutonomousResumeWriteRequest = {
+    readonly changeId: string;
+    readonly goal: string;
+    readonly artifactWorkspacePath: string;
+    readonly apply?: boolean;
+    readonly clock?: () => string;
+};
+export type AutonomousResumeArtifactFile = {
+    readonly path: string;
+    readonly content: string;
+};
+export type AutonomousResumeWriteResult = {
+    readonly applied: boolean;
+    readonly files: readonly AutonomousResumeArtifactFile[];
+};
+export declare function writeAutonomousResumeArtifacts(request: AutonomousResumeWriteRequest): Promise<AutonomousResumeWriteResult>;

package/dist/src/services/workflow/autonomous-resume-writer.js

@@ -0,0 +1,156 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { buildArtifactRelativePath, validateChangeIdOrThrow } from '../../shared/change-id.js';
+import { pathExists } from '../../shared/fs.js';
+function defaultClock() {
+    return new Date().toISOString();
+}
+function normalizeGoal(goal) {
+    const trimmed = goal.trim();
+    if (!trimmed) {
+        throw new Error('Goal must be non-empty');
+    }
+    return trimmed;
+}
+function renderGoalPackage(changeId, goal) {
+    return `${JSON.stringify({
+        changeId,
+        artifactType: 'goal-package',
+        status: 'ready',
+        goal,
+        doneCondition: `Autonomous plan for ${changeId} is complete when all acceptance criteria pass, the worker queue is empty or blocked with next actions, and validation evidence is recorded.`,
+        resumeCondition: `Resume ${changeId} only after checkpoint artifacts, worker queue state, and validation evidence requirements have been verified.`,
+        acceptanceCriteria: [
+            'A resumable autonomous RD plan exists with checkpoints, worker queue, and validation evidence requirements.',
+            'Curated capabilities from docs/accessRepo.md and docs/mcpServer.md are considered before custom implementation.',
+            'Resume after compact verifies checkpoints and evidence before continuing.',
+            'All execution remains dry-run until explicitly approved.'
+        ]
+    }, null, 2)}\n`;
+}
+function renderRdPlan(changeId) {
+    return `${JSON.stringify({
+        changeId,
+        artifactType: 'rd-plan',
+        status: 'ready',
+        workerQueueStatus: 'ready',
+        taskCount: 1,
+        reducerRequired: true
+    }, null, 2)}\n`;
+}
+function renderCheckpoint(changeId, createdAt) {
+    return `${JSON.stringify({
+        changeId,
+        artifactType: 'checkpoint',
+        status: 'ready',
+        checkpointId: 'checkpoint-1',
+        createdAt,
+        workerQueueState: {},
+        validationRefs: ['unit-tests.md']
+    }, null, 2)}\n`;
+}
+function renderValidationReport(changeId) {
+    return `---
+changeId: ${changeId}
+artifactType: validation-report
+status: passed
+---
+
+Validation summary:
+
+- Resume artifact scaffold generated for ${changeId}.
+
+Checks:
+
+- unit-tests
+
+Result: passed
+
+Evidence refs:
+
+- unit-tests.md
+`;
+}
+function renderUnitTestsEvidence(changeId) {
+    return `# unit-tests evidence for ${changeId}
+
+Replace this stub with the real test command, output, and coverage delta. The autonomous resume validator only requires this file to exist and be a safe markdown name listed in checkpoint-1.json validationRefs.
+`;
+}
+function renderResumeInstructions(changeId) {
+    return `---
+changeId: ${changeId}
+artifactType: resume-instructions
+status: passed
+---
+
+Resume steps:
+
+- Read autonomous-goal-package.json and confirm acceptance criteria.
+- Read autonomous-rd-plan.json and reconcile worker queue with current diff.
+- Read checkpoint-1.json and verify worker queue state matches what is on disk.
+- Read evidence/*.md referenced by checkpoint validationRefs and confirm Result: passed.
+
+Preconditions:
+
+- Artifact workspace is local and matches changeId ${changeId}.
+- No destructive --apply has run without explicit authorization.
+
+Blocked actions:
+
+- Resume cannot proceed if checkpoint validationRefs or evidence files are missing or invalid.
+
+Next actions:
+
+- Run peaks workflow autonomous --change-id ${changeId} --goal "<goal>" --json to recompute the plan.
+- Compare blockedReasons; resolve before reattempting resume.
+`;
+}
+function buildFiles(changeId, goal, createdAt, artifactWorkspacePath) {
+    return [
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'prd', 'autonomous-goal-package.json')),
+            content: renderGoalPackage(changeId, goal)
+        },
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'rd', 'swarm', 'autonomous-rd-plan.json')),
+            content: renderRdPlan(changeId)
+        },
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'rd', 'swarm', 'checkpoints', 'checkpoint-1.json')),
+            content: renderCheckpoint(changeId, createdAt)
+        },
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'rd', 'swarm', 'evidence', 'unit-tests.md')),
+            content: renderUnitTestsEvidence(changeId)
+        },
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'rd', 'swarm', 'evidence', 'validation-report.md')),
+            content: renderValidationReport(changeId)
+        },
+        {
+            path: join(artifactWorkspacePath, buildArtifactRelativePath(changeId, 'rd', 'swarm', 'resume-instructions.md')),
+            content: renderResumeInstructions(changeId)
+        }
+    ];
+}
+export async function writeAutonomousResumeArtifacts(request) {
+    validateChangeIdOrThrow(request.changeId);
+    const goal = normalizeGoal(request.goal);
+    const clock = request.clock ?? defaultClock;
+    const createdAt = clock();
+    const files = buildFiles(request.changeId, goal, createdAt, request.artifactWorkspacePath);
+    if (request.apply !== true) {
+        return { applied: false, files };
+    }
+    for (const file of files) {
+        if (await pathExists(file.path)) {
+            throw new Error(`Refusing to write: ${file.path} already exists. Remove it before re-running peaks autonomous resume init --apply.`);
+        }
+    }
+    for (const file of files) {
+        await mkdir(dirname(file.path), { recursive: true });
+        await writeFile(file.path, file.content, 'utf8');
+    }
+    return { applied: true, files };
+}

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.0.14";
+export declare const CLI_VERSION = "1.0.15";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.0.14";
+export const CLI_VERSION = "1.0.15";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "Peaks CLI and short skill family for Claude Code automation.",
   "author": "SquabbyZ",
   "license": "MIT",

package/schemas/doctor-report.schema.json

@@ -13,8 +13,8 @@
         "properties": {
           "id": {
             "type": "string",
-            "pattern": "^(skill|skill-name|skill-parse|skill-runbook|skill-apply-note|schema|config|doctor-self|capability):[A-Za-z0-9][A-Za-z0-9._-]*$",
-            "description": "Stable check id. Known prefixes: skill:<name> (required skill present), skill-name:<dir> (directory matches declared name), skill-parse:<dir> (skill metadata parsed), skill-runbook:<name> (Default runbook section exists), skill-apply-note:<name> (destructive --apply lines carry an authorization/--dry-run note), schema:<file> (schema file exists and is valid JSON), config:<scope> (optional config locations), doctor-self:<topic> (doctor validates its own output against this schema), capability:<name> (third-party capability is resolvable at the pinned version)."
+            "pattern": "^(skill|skill-name|skill-parse|skill-runbook|skill-apply-note|skill-presence|schema|config|doctor-self|capability):[A-Za-z0-9][A-Za-z0-9._-]*$",
+            "description": "Stable check id. Known prefixes: skill:<name> (required skill present), skill-name:<dir> (directory matches declared name), skill-parse:<dir> (skill metadata parsed), skill-runbook:<name> (Default runbook section exists), skill-apply-note:<name> (destructive --apply lines carry an authorization/--dry-run note), skill-presence:<topic> (status of .peaks/.active-skill.json — current/freshness), schema:<file> (schema file exists and is valid JSON), config:<scope> (optional config locations), doctor-self:<topic> (doctor validates its own output against this schema), capability:<name> (third-party capability is resolvable at the pinned version)."
           },
           "ok": { "type": "boolean" },
           "message": { "type": "string", "minLength": 1 }

package/skills/peaks-prd/SKILL.md

@@ -7,6 +7,16 @@ description: Product and requirement skill for Peaks. Use when a workflow needs
 
 Peaks PRD turns user intent into verifiable product artifacts.
 
+## Skill presence (MANDATORY first action)
+
+Before any analysis or tool call, immediately run:
+
+```bash
+peaks skill presence:set peaks-prd --mode <mode> --gate startup
+```
+
+Then display: `Peaks Skill: peaks-prd | Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-prd --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear`.
+
 ## Responsibilities
 
 - clarify goals and non-goals;