peaks-cli 1.0.13 → 1.0.14

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

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

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

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

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

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

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

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

package/dist/src/services/mcp/mcp-scan-service.js

@@ -74,7 +74,7 @@ function buildServerConfig(name, raw, scope, source, pluginName) {
         scope,
         source
     };
-    if (pluginName !== undefined) {
+    if (pluginName !== undefined && pluginName.length > 0) {
         config.pluginName = pluginName;
     }
     return config;

package/dist/src/services/skills/skill-presence-service.d.ts

@@ -0,0 +1,10 @@
+export type SkillPresence = {
+    skill: string;
+    mode?: string;
+    gate?: string;
+    setAt: string;
+};
+export declare function exportSkillPresence(): string;
+export declare function setSkillPresence(skill: string, mode?: string, gate?: string): SkillPresence;
+export declare function getSkillPresence(): SkillPresence | null;
+export declare function clearSkillPresence(): boolean;

package/dist/src/services/skills/skill-presence-service.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+const PRESENCE_FILE = '.peaks/.active-skill.json';
+function resolvePresencePath() {
+    return resolve(process.cwd(), PRESENCE_FILE);
+}
+export function exportSkillPresence() {
+    return resolvePresencePath();
+}
+export function setSkillPresence(skill, mode, gate) {
+    const presence = {
+        skill,
+        ...(mode ? { mode } : {}),
+        ...(gate ? { gate } : {}),
+        setAt: new Date().toISOString()
+    };
+    const presencePath = resolvePresencePath();
+    const presenceDir = dirname(presencePath);
+    if (!existsSync(presenceDir)) {
+        mkdirSync(presenceDir, { recursive: true });
+    }
+    writeFileSync(presencePath, JSON.stringify(presence, null, 2), 'utf8');
+    return presence;
+}
+export function getSkillPresence() {
+    const presencePath = resolvePresencePath();
+    if (!existsSync(presencePath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(presencePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.skill !== 'string' || parsed.skill.length === 0) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function clearSkillPresence() {
+    const presencePath = resolvePresencePath();
+    if (!existsSync(presencePath)) {
+        return false;
+    }
+    try {
+        unlinkSync(presencePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/services/skills/skill-runbook-service.js

@@ -11,7 +11,7 @@ const AUTHORIZATION_KEYWORDS_PATTERN = /authoriz|explicit|--dry-run|approv|only
 const PEAKS_COMMAND_LINE_PATTERN = /^\s*peaks\s+\w/;
 function extractRunbookSection(body) {
     const match = /## Default runbook\n+([\s\S]*?)(?=\n## |$)/.exec(body);
-    return match === null ? null : (match[1] ?? null);
+    return match === null ? null : match[1];
 }
 function findDestructiveApplyLines(section) {
     const lines = section.split(/\r?\n/);

package/dist/src/services/workflow/workflow-autonomous-service.js

@@ -250,9 +250,6 @@ function readResumeArtifact(artifactWorkspacePath, artifact) {
             return null;
         }
         const pathSegments = artifact.replace(/\\/g, '/').split('/');
-        if (pathSegments.length < 4 || pathSegments[0] !== '.peaks') {
-            return null;
-        }
         const sessionRootPath = resolve(artifactWorkspacePath, '.peaks', pathSegments[1]);
         const roleRootPath = resolve(sessionRootPath, pathSegments[2]);
         if (lstatSync(sessionRootPath).isSymbolicLink() || lstatSync(roleRootPath).isSymbolicLink()) {
@@ -261,16 +258,13 @@ function readResumeArtifact(artifactWorkspacePath, artifact) {
         let allowedRootRealPath;
         if (pathSegments[2] === 'rd') {
             const swarmRootPath = resolve(roleRootPath, 'swarm');
-            if (pathSegments[3] !== 'swarm' || lstatSync(swarmRootPath).isSymbolicLink()) {
+            if (lstatSync(swarmRootPath).isSymbolicLink()) {
                 return null;
             }
             allowedRootRealPath = realpathSync(swarmRootPath);
         }
-        else if (pathSegments[2] === 'prd') {
-            allowedRootRealPath = realpathSync(roleRootPath);
-        }
         else {
-            return null;
+            allowedRootRealPath = realpathSync(roleRootPath);
         }
         const artifactRealPath = realpathSync(artifactPath);
         if (!isInsidePath(allowedRootRealPath, artifactWorkspaceRealPath) || !isInsidePath(artifactRealPath, allowedRootRealPath)) {
@@ -354,12 +348,12 @@ function parseFrontMatter(content) {
     if (lines[0] !== '---') {
         return null;
     }
-    const endIndex = lines.slice(1).findIndex((line) => line === '---');
-    if (endIndex === -1) {
+    const closingDelimiterIndex = lines.slice(1).findIndex((line) => line === '---');
+    if (closingDelimiterIndex === -1) {
         return null;
     }
     const metadata = new Map();
-    for (const line of lines.slice(1, endIndex + 1)) {
+    for (const line of lines.slice(1, closingDelimiterIndex + 1)) {
         const separatorIndex = line.indexOf(':');
         if (separatorIndex === -1) {
             return null;
@@ -370,8 +364,8 @@ function parseFrontMatter(content) {
 }
 function getMarkdownBody(content) {
     const lines = content.split(/\r?\n/);
-    const endIndex = lines.slice(1).findIndex((line) => line === '---');
-    return endIndex === -1 ? '' : lines.slice(endIndex + 2).join('\n');
+    const closingDelimiterIndex = lines.slice(1).findIndex((line) => line === '---');
+    return closingDelimiterIndex === -1 ? '' : lines.slice(closingDelimiterIndex + 2).join('\n');
 }
 function hasValidationReportBody(body) {
     return body.includes('Validation summary:')

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

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

package/dist/src/shared/version.js

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

package/package.json

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

package/skills/peaks-prd/SKILL.md

@@ -34,6 +34,7 @@ For a feature / bug / clarification request with no authenticated source documen
 ```bash
 # 0. confirm PRD's own runbook integrity before driving any phase
 peaks skill runbook peaks-prd --json
+peaks skill presence:set peaks-prd               # show persistent skill presence every turn
 
 # 1. capture the request as the canonical PRD artifact (preview, then apply)
 peaks request init --role prd --id <request-id> --project <repo> --json
@@ -53,6 +54,7 @@ peaks codegraph status  --project <repo>                   # local index status
 
 # 5. write goals / non-goals / acceptance into the artifact body, then hand off
 peaks request show <request-id> --role prd --project <repo> --json
+peaks skill presence:clear                      # handoff complete, remove presence indicator
 ```
 
 For an authenticated product document request (Feishu/Lark/wiki), add before step 5:

package/skills/peaks-qa/SKILL.md

@@ -33,6 +33,7 @@ The default sequence the QA skill should execute. Do not skip the boundary check
 ```bash
 # 0. confirm QA's own runbook integrity before validating anything
 peaks skill runbook peaks-qa --json
+peaks skill presence:set peaks-qa               # show persistent skill presence every turn
 
 # 1. capture the QA request artifact and read upstream scope
 peaks request init --role qa --id <request-id> --project <repo> --apply --json
@@ -69,6 +70,7 @@ peaks mcp apply --capability playwright-mcp.browser-validation --yes --json
 # 7. on verdict=return-to-rd, route findings back through the request id; otherwise close.
 peaks request show <request-id> --role qa --project <repo> --json
 peaks openspec archive <change-id> --project <repo> --json   # preview, then --apply on full pass
+peaks skill presence:clear                      # QA complete, remove presence indicator
 ```
 
 Verdict `pass` is blocked until every applicable validation gate has evidence in the artifact.

package/skills/peaks-rd/SKILL.md

@@ -31,6 +31,7 @@ The default sequence the RD skill should execute for a code-touching request. Sk
 ```bash
 # 0. confirm RD's own runbook integrity before any code edit
 peaks skill runbook peaks-rd --json
+peaks skill presence:set peaks-rd               # show persistent skill presence every turn
 
 # 1. capture the RD request artifact and read upstream PRD / UI scope
 peaks request init --role rd --id <request-id> --project <repo> --apply --json
@@ -65,6 +66,7 @@ peaks openspec validate <change-id> --project <repo> --json    # exit gate (re-r
 # 8. hand off to QA via the cross-linked request id
 peaks request init --role qa --id <request-id> --project <repo> --apply --json
 peaks request show <request-id> --role rd --project <repo> --json
+peaks skill presence:clear                      # handoff complete, remove presence indicator
 ```
 
 For refactor work, the coverage ≥ 95% gate in `Refactor hard gates` still applies and must be recorded in the artifact before slicing begins.

package/skills/peaks-sc/SKILL.md

@@ -48,6 +48,7 @@ Use this sequence when SC owns the change-control pass for a refactor or release
 ```bash
 # 0. Confirm SC's own runbook integrity before recording boundary evidence
 peaks skill runbook peaks-sc --json
+peaks skill presence:set peaks-sc               # show persistent skill presence every turn
 
 # 1. Derive commit boundaries from OpenSpec when openspec/ exists
 peaks openspec to-rd <change-id> --project <repo> --json
@@ -71,6 +72,7 @@ peaks sc boundary --slice-id <slice-id> --artifact <artifact-path> --code <code-
 # 7. Sync memory and artifacts only when the user or active profile authorizes durable writes
 peaks memory sync --project <repo> --workspace <workspace> --apply --json
 peaks artifacts sync --workspace <workspace> --apply --json
+peaks skill presence:clear                      # SC complete, remove presence indicator
 ```
 
 The final two `--apply` calls require explicit authorization. Without it, default to `--dry-run` or omit the sync calls entirely and keep the boundary evidence local under `.peaks/<session-id>/`.

package/skills/peaks-solo/SKILL.md

@@ -92,6 +92,7 @@ The default end-to-end sequence Peaks Solo orchestrates when a user supplies a r
 peaks doctor --json
 peaks project dashboard --project <repo> --json     # one-call cross-role status
 peaks skill runbook peaks-solo --json               # confirm Solo's own runbook is intact + apply-gated
+peaks skill presence:set peaks-solo --mode solo     # show persistent skill presence every turn
 
 # 1. PRD phase — capture the request as the canonical artifact
 peaks request init --role prd --id <request-id> --project <repo> --apply --json
@@ -141,6 +142,7 @@ peaks memory extract --project <repo> --artifact <qa-artifact> --dry-run --json
 # 8. final snapshot to confirm the workflow really closed
 peaks project dashboard --project <repo> --json
 peaks skill doctor --json                            # all 7 required skills still healthy?
+peaks skill presence:clear                          # workflow complete, remove presence indicator
 ```
 
 Solo's RD↔QA repair loop (`## Mandatory RD QA repair loop` above) applies if QA's verdict is `return-to-rd`. In that case, Solo re-runs phase 3 + phase 4 against the same `<request-id>` instead of starting a new one; the previous artifacts get appended with new transition notes via `--reason` rather than rewritten.

package/skills/peaks-txt/SKILL.md

@@ -105,6 +105,7 @@ Use this sequence when TXT compresses an in-flight workflow into a portable, com
 ```bash
 # 0. Confirm TXT's own runbook integrity before compressing a handoff
 peaks skill runbook peaks-txt --json
+peaks skill presence:set peaks-txt               # show persistent skill presence every turn
 
 # 1. Inventory per-role artifacts already produced for the request
 peaks request list --project <repo> --json
@@ -123,6 +124,7 @@ peaks capabilities --json
 # 5. Memory extraction — dry-run by default, apply only when authorized
 peaks memory extract --project <repo> --artifact <artifact-path> --dry-run --json
 peaks memory extract --project <repo> --artifact <artifact-path> --apply --json
+peaks skill presence:clear                      # handoff capsule complete, remove presence indicator
 ```
 
 The final `--apply` call requires explicit user or profile authorization. Without it, keep the capsule under `.peaks/<session-id>/txt/` and reference artifact paths from other roles instead of duplicating their content.

package/skills/peaks-ui/SKILL.md

@@ -30,6 +30,7 @@ The default sequence the UI skill should execute. Skip steps that do not apply;
 ```bash
 # 0. confirm UI's own runbook integrity before driving any phase
 peaks skill runbook peaks-ui --json
+peaks skill presence:set peaks-ui               # show persistent skill presence every turn
 
 # 1. capture the UI request as a durable artifact tied to the same PRD request id
 peaks request init --role ui --id <request-id> --project <repo> --json
@@ -55,6 +56,7 @@ peaks mcp apply --capability playwright-mcp.browser-validation --yes --json   #
 # 5. hand off to RD / QA via the cross-linked request id
 peaks request list --project <repo> --json
 peaks request show <request-id> --role ui --project <repo> --json
+peaks skill presence:clear                      # handoff complete, remove presence indicator
 ```
 
 Handoff is blocked until the UI artifact's `state` reaches `direction-locked` or `handed-off`.