peaks-cli 1.0.28 → 1.1.1

package/dist/src/services/memory/project-context-service.js

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { join } from 'node:path';
 import { listSessionMetas } from '../session/session-manager.js';
 const PROJECT_CONTEXT_FILE = '.peaks/PROJECT.md';
-const ONTOLOGY_FILE = '.peaks/ontology.json';
 const CONTEXT_HEADER = `# Peaks Project Context
 
 > Auto-generated project memory. Peaks reads this at the start of each session to understand
@@ -46,26 +45,6 @@ function listMdFiles(dir, maxDepth = 3) {
     }
     return results;
 }
-function extractArtifactSummary(filePath, sessionRoot) {
-    try {
-        const content = readFileSync(filePath, 'utf8');
-        const lines = content.split(/\r?\n/);
-        const firstHeading = lines.find((l) => /^#\s/.test(l))?.replace(/^#\s+/, '').trim();
-        const stateLine = lines.find((l) => /^\-\s*state:\s*/.test(l))?.trim();
-        const relPath = relative(sessionRoot, filePath).split(/[\\/]/).join('/');
-        const parts = [];
-        if (firstHeading)
-            parts.push(firstHeading);
-        if (stateLine)
-            parts.push(stateLine.replace(/^-\s*state:\s*/, ''));
-        if (parts.length === 0)
-            return `- \`${relPath}\``;
-        return `- \`${relPath}\` — ${parts.join(' | ')}`;
-    }
-    catch {
-        return null;
-    }
-}
 function extractOneLineSummary(sessionRoot) {
     const artifacts = listMdFiles(sessionRoot, 4);
     for (const artifact of artifacts.slice(0, 5)) {
@@ -88,27 +67,6 @@ function extractOneLineSummary(sessionRoot) {
     }
     return null;
 }
-function renderSessionBlock(meta, projectRoot) {
-    const title = meta.title ?? 'Untitled';
-    const date = meta.createdAt ? meta.createdAt.slice(0, 10) : '?';
-    const skill = meta.skill ?? '-';
-    const mode = meta.mode ?? '-';
-    let block = `### ${date} — ${title}\n`;
-    block += `- ${skill} (${mode})`;
-    const sessionRoot = join(projectRoot, '.peaks', meta.sessionId);
-    const summary = extractOneLineSummary(sessionRoot);
-    if (summary) {
-        block += ` — ${summary.slice(0, 120)}`;
-    }
-    block += '\n';
-    // Key artifact paths only
-    const artifacts = listMdFiles(sessionRoot, 3);
-    if (artifacts.length > 0) {
-        const paths = artifacts.slice(0, 8).map((f) => relative(sessionRoot, f).split(/[\\/]/).join('/'));
-        block += `  ${paths.join('  ')}\n`;
-    }
-    return block;
-}
 function buildSessionHistory(projectRoot) {
     const metas = listSessionMetas(projectRoot);
     if (metas.length === 0) {
@@ -139,263 +97,6 @@ function buildSessionHistory(projectRoot) {
     body += `\n${MANAGED_BLOCK_END}`;
     return body;
 }
-// --- Ontology engine ---
-function emptyOntology(projectName) {
-    return {
-        version: 1,
-        updated: new Date().toISOString(),
-        project: projectName,
-        modules: [],
-        decisions: [],
-        conventions: []
-    };
-}
-function ontoPath(projectRoot) {
-    return join(projectRoot, ONTOLOGY_FILE);
-}
-export function loadOntology(projectRoot) {
-    const path = ontoPath(projectRoot);
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf8'));
-        if (raw?.version === 1 && Array.isArray(raw.modules)) {
-            return raw;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function slugify(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
-}
-function scanModulesFromArtifacts(sessionRoot, sessionId) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const modules = [];
-    const seen = new Set();
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            // Extract file paths — non-capturing groups for extensions
-            const patterns = [
-                /\b(src\/[^\s)`\]}"]+\.(?:tsx?|jsx?|css|less|scss|vue|svelte))\b/g,
-                /\b(packages\/[^\s)`\]}"]+\.(?:tsx?|jsx?))\b/g
-            ];
-            for (const pattern of patterns) {
-                let m;
-                while ((m = pattern.exec(content)) !== null) {
-                    const filePath = m[1] ?? '';
-                    if (!filePath || filePath.length > 120 || filePath.length < 5)
-                        continue;
-                    const id = slugify(filePath.replace(/\.[^.]+$/, '').replace(/[\/\\]/g, '-'));
-                    if (seen.has(id))
-                        continue;
-                    seen.add(id);
-                    modules.push({ id, path: filePath });
-                    if (modules.length >= 30)
-                        break;
-                }
-                if (modules.length >= 30)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return modules;
-}
-function scanDecisionsFromArtifacts(sessionRoot, session) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const decisions = [];
-    const date = session.createdAt ? session.createdAt.slice(0, 10) : new Date().toISOString().slice(0, 10);
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            // Look for decision markers: "- Decision: ..." or "Decision: ..." or "ADR: ..."
-            const decRegex = /^[\s-]*(?:decision|adr|决定|决策)\s*:\s*(.+?)$/gim;
-            let m;
-            while ((m = decRegex.exec(content)) !== null) {
-                const what = (m[1] ?? '').trim().slice(0, 200);
-                if (what.length < 5)
-                    continue;
-                const id = slugify(what.slice(0, 40));
-                // Collect scope from surrounding context (modules mentioned within 3 lines before/after)
-                const scope = [];
-                const lineIdx = content.slice(0, m.index).split('\n').length;
-                const lines = content.split('\n');
-                for (let i = Math.max(0, lineIdx - 3); i < Math.min(lines.length, lineIdx + 3); i++) {
-                    const line = lines[i] ?? '';
-                    const pathMatch = /src\/[^\s)`\]}"]+\.(tsx?|jsx?)/.exec(line);
-                    if (pathMatch?.[0])
-                        scope.push(pathMatch[0]);
-                }
-                decisions.push({ id, what, scope: [...new Set(scope)].slice(0, 5), session: session.sessionId, date });
-                if (decisions.length >= 10)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return decisions;
-}
-function scanConventionsFromArtifacts(sessionRoot, session) {
-    const artifacts = listMdFiles(sessionRoot, 4);
-    const conventions = [];
-    const date = session.createdAt ? session.createdAt.slice(0, 10) : new Date().toISOString().slice(0, 10);
-    for (const artifact of artifacts.slice(0, 10)) {
-        try {
-            const content = readFileSync(artifact, 'utf8');
-            const convRegex = /^[\s-]*(?:convention|约定|规范)\s*:\s*(.+?)$/gim;
-            let m;
-            while ((m = convRegex.exec(content)) !== null) {
-                const rule = (m[1] ?? '').trim().slice(0, 200);
-                if (rule.length < 5)
-                    continue;
-                const id = slugify(rule.slice(0, 40));
-                // Infer category from keywords
-                let category = 'other';
-                if (/class|function|interface|type|hook|component/i.test(rule))
-                    category = 'code-style';
-                else if (/service|layer|package|module|shared|extract/i.test(rule))
-                    category = 'architecture';
-                else if (/naming|命名|文件名|prefix|suffix/i.test(rule))
-                    category = 'naming';
-                else if (/tooling|lint|format|build|test/i.test(rule))
-                    category = 'tooling';
-                conventions.push({ id, rule, category, source: session.sessionId, date });
-                if (conventions.length >= 10)
-                    break;
-            }
-        }
-        catch {
-            // skip unreadable
-        }
-    }
-    return conventions;
-}
-function buildOntology(projectRoot) {
-    const name = projectName(projectRoot);
-    const existing = loadOntology(projectRoot);
-    const onto = existing ?? emptyOntology(name);
-    onto.updated = new Date().toISOString();
-    onto.project = name;
-    const metas = listSessionMetas(projectRoot);
-    const knownSessions = new Set(metas.map((m) => m.sessionId));
-    // Prune: remove modules/decisions/conventions from sessions that no longer exist
-    onto.modules = onto.modules.filter((m) => m.sessions.some((s) => knownSessions.has(s)));
-    onto.decisions = onto.decisions.filter((d) => knownSessions.has(d.session));
-    onto.conventions = onto.conventions.filter((c) => knownSessions.has(c.source));
-    // Merge: scan each session for new modules and decisions
-    const moduleMap = new Map();
-    for (const m of onto.modules)
-        moduleMap.set(m.id, m);
-    const decisionMap = new Map();
-    for (const d of onto.decisions)
-        decisionMap.set(d.id, d);
-    for (const meta of metas) {
-        const sessionRoot = join(projectRoot, '.peaks', meta.sessionId);
-        // Modules
-        const foundModules = scanModulesFromArtifacts(sessionRoot, meta.sessionId);
-        for (const fm of foundModules) {
-            if (moduleMap.has(fm.id)) {
-                const existing = moduleMap.get(fm.id);
-                if (!existing.sessions.includes(meta.sessionId)) {
-                    existing.sessions.push(meta.sessionId);
-                }
-            }
-            else {
-                moduleMap.set(fm.id, {
-                    id: fm.id,
-                    path: fm.path,
-                    sessions: [meta.sessionId]
-                });
-            }
-        }
-        // Decisions
-        const foundDecisions = scanDecisionsFromArtifacts(sessionRoot, meta);
-        for (const fd of foundDecisions) {
-            if (!decisionMap.has(fd.id)) {
-                decisionMap.set(fd.id, fd);
-            }
-        }
-        // Conventions
-        const foundConventions = scanConventionsFromArtifacts(sessionRoot, meta);
-        const convMap = new Map();
-        for (const c of onto.conventions)
-            convMap.set(c.id, c);
-        for (const fc of foundConventions) {
-            if (!convMap.has(fc.id)) {
-                convMap.set(fc.id, fc);
-            }
-        }
-        onto.conventions = [...convMap.values()].sort((a, b) => a.date.localeCompare(b.date));
-    }
-    // Dedup: remove shorter paths that are substring-matches of longer paths
-    const modules = [...moduleMap.values()];
-    const deduped = modules.filter((m) => {
-        return !modules.some((other) => other !== m && other.path.length > m.path.length && other.path.endsWith(m.path));
-    });
-    onto.modules = deduped.sort((a, b) => b.sessions.length - a.sessions.length);
-    onto.decisions = [...decisionMap.values()].sort((a, b) => b.date.localeCompare(a.date));
-    return onto;
-}
-export function saveOntology(projectRoot, onto) {
-    const peaksDir = join(projectRoot, '.peaks');
-    if (!existsSync(peaksDir))
-        mkdirSync(peaksDir, { recursive: true });
-    writeFileSync(ontoPath(projectRoot), JSON.stringify(onto, null, 2), 'utf8');
-}
-// Mutations for skills to call when they discover new facts
-export function upsertModule(projectRoot, mod) {
-    const onto = buildOntology(projectRoot);
-    const existing = onto.modules.find((m) => m.id === mod.id);
-    if (existing) {
-        if (!existing.sessions.includes(mod.session))
-            existing.sessions.push(mod.session);
-        if (mod.risk)
-            existing.risk = mod.risk;
-        if (mod.summary)
-            existing.summary = mod.summary;
-    }
-    else {
-        onto.modules.push({ ...mod, sessions: [mod.session] });
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-export function upsertDecision(projectRoot, dec) {
-    const onto = buildOntology(projectRoot);
-    const idx = onto.decisions.findIndex((d) => d.id === dec.id);
-    if (idx >= 0) {
-        onto.decisions[idx] = dec;
-    }
-    else {
-        onto.decisions.push(dec);
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-export function upsertConvention(projectRoot, conv) {
-    const onto = buildOntology(projectRoot);
-    const idx = onto.conventions.findIndex((c) => c.id === conv.id);
-    if (idx >= 0) {
-        onto.conventions[idx] = conv;
-    }
-    else {
-        onto.conventions.push(conv);
-    }
-    onto.updated = new Date().toISOString();
-    saveOntology(projectRoot, onto);
-    return onto;
-}
-// --- Context generator (unified: PROJECT.md + ontology.json) ---
 export function generateProjectContext(projectRoot) {
     const peaksDir = join(projectRoot, '.peaks');
     if (!existsSync(peaksDir)) {
@@ -428,10 +129,7 @@ export function generateProjectContext(projectRoot) {
         content = header + '\n' + sessionHistory + '\n';
     }
     writeFileSync(contextPath, content, 'utf8');
-    // Build and save ontology alongside PROJECT.md
-    const ontology = buildOntology(projectRoot);
-    saveOntology(projectRoot, ontology);
-    return { path: contextPath, content, sessionCount: listSessionMetas(projectRoot).length, ontology };
+    return { path: contextPath, content, sessionCount: listSessionMetas(projectRoot).length };
 }
 export function readProjectContext(projectRoot) {
     const contextPath = join(projectRoot, PROJECT_CONTEXT_FILE);

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

@@ -1,4 +1,4 @@
-export type ProjectMemoryKind = 'project' | 'rule' | 'decision' | 'reference' | 'feedback';
+export type ProjectMemoryKind = 'project' | 'rule' | 'decision' | 'reference' | 'feedback' | 'convention' | 'module';
 export type ExtractedProjectMemory = {
     title: string;
     kind: ProjectMemoryKind;
@@ -59,6 +59,21 @@ export type ProjectMemoryBackupPlan = {
 export type ProjectMemoryBackupResult = ProjectMemoryBackupPlan & {
     copiedFiles: string[];
 };
+export type StoredProjectMemory = {
+    name: string;
+    title: string;
+    kind: ProjectMemoryKind;
+    sourceArtifact: string | null;
+    body: string;
+    filePath: string;
+};
+export type ProjectMemoryReadResult = {
+    projectRoot: string;
+    memoryDir: string;
+    total: number;
+    byKind: Record<ProjectMemoryKind, StoredProjectMemory[]>;
+    memories: StoredProjectMemory[];
+};
 type ExtractPlanOptions = {
     projectRoot: string;
     artifactPaths: string[];
@@ -76,4 +91,5 @@ export declare function createProjectMemoryBackupPlan(options: BackupPlanOptions
 export declare function executeProjectMemoryBackup(options: BackupPlanOptions): ProjectMemoryBackupResult;
 export declare function summarizeProjectMemoryExtractResult(result: ProjectMemoryExtractResult): ProjectMemoryExtractSummary;
 export declare function summarizeProjectMemoryBackupResult(result: ProjectMemoryBackupResult): ProjectMemoryBackupSummary;
+export declare function readProjectMemories(projectRoot: string): ProjectMemoryReadResult;
 export {};

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

@@ -4,7 +4,7 @@ import { isInsidePath, isWindowsAbsolutePath, normalizePath, resolveInputPath, s
 import { containsSensitiveConfigValue, isSensitiveConfigPath } from '../config/config-service.js';
 const START_MARKER = '<!-- peaks-memory:start -->';
 const END_MARKER = '<!-- peaks-memory:end -->';
-const VALID_MEMORY_KINDS = new Set(['project', 'rule', 'decision', 'reference', 'feedback']);
+const VALID_MEMORY_KINDS = new Set(['project', 'rule', 'decision', 'reference', 'feedback', 'convention', 'module']);
 function normalizeRoot(path) {
     return resolveInputPath(path);
 }
@@ -42,11 +42,11 @@ function assertInsideProject(path, projectRoot) {
 function assertSafeProjectMemoryDir(projectRoot) {
     const resolvedRoot = normalizeRoot(projectRoot);
     const realRoot = normalizeRealRoot(projectRoot);
-    const claudeDir = join(resolvedRoot, '.claude');
-    if (existsSync(claudeDir) && lstatSync(claudeDir).isSymbolicLink()) {
+    const peaksDir = join(resolvedRoot, '.peaks');
+    if (existsSync(peaksDir) && lstatSync(peaksDir).isSymbolicLink()) {
         throw new Error('Project memory directory must stay inside the project root');
     }
-    const memoryDir = join(claudeDir, 'memory');
+    const memoryDir = join(peaksDir, 'memory');
     if (existsSync(memoryDir)) {
         if (lstatSync(memoryDir).isSymbolicLink()) {
             throw new Error('Project memory directory must stay inside the project root');
@@ -136,6 +136,41 @@ function renderMemoryFile(memory) {
         ''
     ].join('\n');
 }
+function parseStoredMemoryFile(content, filePath) {
+    const normalized = content.replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---\n'))
+        return null;
+    const endIndex = normalized.indexOf('\n---\n', 4);
+    if (endIndex < 0)
+        return null;
+    const frontmatter = normalized.slice(4, endIndex);
+    const body = normalized.slice(endIndex + '\n---\n'.length).trim();
+    let name;
+    let description;
+    let kind;
+    let sourceArtifact;
+    for (const rawLine of frontmatter.split('\n')) {
+        const line = rawLine.trim();
+        if (line.startsWith('name:'))
+            name = line.slice('name:'.length).trim();
+        else if (line.startsWith('description:'))
+            description = line.slice('description:'.length).trim();
+        else if (line.startsWith('type:'))
+            kind = line.slice('type:'.length).trim();
+        else if (line.startsWith('sourceArtifact:'))
+            sourceArtifact = line.slice('sourceArtifact:'.length).trim();
+    }
+    if (!name || !kind || !VALID_MEMORY_KINDS.has(kind) || body.length === 0)
+        return null;
+    return {
+        name,
+        title: description ?? name,
+        kind: kind,
+        sourceArtifact: sourceArtifact && sourceArtifact !== 'undefined' ? sourceArtifact : null,
+        body,
+        filePath
+    };
+}
 function summarizeExtractResult(result) {
     return {
         apply: result.apply,
@@ -304,3 +339,36 @@ export function summarizeProjectMemoryExtractResult(result) {
 export function summarizeProjectMemoryBackupResult(result) {
     return summarizeBackupResult(result);
 }
+function emptyByKind() {
+    return {
+        project: [],
+        rule: [],
+        decision: [],
+        reference: [],
+        feedback: [],
+        convention: [],
+        module: []
+    };
+}
+export function readProjectMemories(projectRoot) {
+    const normalizedRoot = normalizeRoot(projectRoot);
+    const memoryDir = assertSafeProjectMemoryDir(normalizedRoot);
+    const memories = [];
+    for (const filePath of listMarkdownFiles(memoryDir)) {
+        const parsed = parseStoredMemoryFile(readFileSync(filePath, 'utf8'), filePath);
+        if (parsed)
+            memories.push(parsed);
+    }
+    memories.sort((left, right) => left.name.localeCompare(right.name));
+    const byKind = emptyByKind();
+    for (const memory of memories) {
+        byKind[memory.kind].push(memory);
+    }
+    return {
+        projectRoot: normalizedRoot,
+        memoryDir,
+        total: memories.length,
+        byKind,
+        memories
+    };
+}

package/dist/src/services/skills/skill-statusline-renderer.d.ts

@@ -0,0 +1,6 @@
+import type { StatusLineModel } from './skill-statusline-service.js';
+/**
+ * Render the status line. The output is plain text with simple status glyphs so
+ * it stays readable in any terminal; Claude Code applies its own styling.
+ */
+export declare function renderStatusLine(model: StatusLineModel): string;

package/dist/src/services/skills/skill-statusline-renderer.js

@@ -0,0 +1,55 @@
+import { basename } from 'node:path';
+/**
+ * Pure formatting layer for the Peaks statusLine. Takes the read-only status
+ * model and produces the single line Claude Code paints at the bottom of the
+ * terminal. Kept separate from the reader so formatting can be tested without
+ * touching the filesystem.
+ */
+const BRAND = '⛰ Peaks';
+function formatAge(ageMs) {
+    if (ageMs === null)
+        return '';
+    const hours = Math.round(ageMs / (60 * 60 * 1000));
+    if (hours >= 1)
+        return `stale ${hours}h`;
+    const minutes = Math.max(1, Math.round(ageMs / (60 * 1000)));
+    return `stale ${minutes}m`;
+}
+function rootLabel(projectRoot) {
+    if (!projectRoot)
+        return '';
+    return basename(projectRoot);
+}
+/**
+ * Render the status line. The output is plain text with simple status glyphs so
+ * it stays readable in any terminal; Claude Code applies its own styling.
+ */
+export function renderStatusLine(model) {
+    const root = rootLabel(model.projectRoot);
+    const rootSuffix = root ? ` · ${root}` : '';
+    switch (model.state) {
+        case 'active': {
+            const presence = model.presence;
+            if (!presence)
+                return `${BRAND} ○ idle${rootSuffix}`;
+            const parts = [presence.skill];
+            if (presence.mode)
+                parts.push(presence.mode);
+            if (presence.gate)
+                parts.push(`gate:${presence.gate}`);
+            return `${BRAND} ● ${parts.join(' · ')}${rootSuffix}`;
+        }
+        case 'stale': {
+            const presence = model.presence;
+            const skill = presence?.skill ?? 'unknown';
+            const age = formatAge(model.ageMs);
+            const ageSuffix = age ? ` · ${age}` : '';
+            return `${BRAND} ⚠ ${skill}${ageSuffix}${rootSuffix}`;
+        }
+        case 'invalid-presence':
+            return `${BRAND} ⚠ presence file unreadable${rootSuffix}`;
+        case 'idle':
+        default:
+            return `${BRAND} ○ idle${rootSuffix}`;
+    }
+}

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

@@ -0,0 +1,22 @@
+export type StatusLineStdin = {
+    workspace?: {
+        current_dir?: string;
+        project_dir?: string;
+    };
+    cwd?: string;
+};
+export type StatusLineState = 'active' | 'idle' | 'stale' | 'invalid-presence';
+export type StatusLinePresence = {
+    skill: string;
+    mode?: string;
+    gate?: string;
+    setAt?: string;
+};
+export type StatusLineModel = {
+    state: StatusLineState;
+    projectRoot: string | null;
+    presence: StatusLinePresence | null;
+    ageMs: number | null;
+};
+export declare function parseStatusLineStdin(raw: string): StatusLineStdin | null;
+export declare function buildStatusLineModel(stdin: StatusLineStdin | null, nowMs: number): StatusLineModel;

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

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { findProjectRoot } from '../config/config-safety.js';
+/**
+ * Out-of-band Peaks skill status renderer for the Claude Code statusLine.
+ *
+ * Claude Code invokes the configured statusLine command on every turn and pipes
+ * a JSON session payload on stdin. This renderer reads the durable presence file
+ * (.peaks/.active-skill.json) and prints a single line that Claude Code paints at
+ * the bottom of the terminal. Because it is rendered by the harness — not emitted
+ * as LLM tokens — the signal cannot be forgotten by the model, cannot be confused
+ * with normal output, and survives context compaction.
+ *
+ * This module is intentionally READ-ONLY. Unlike getSkillPresence in
+ * skill-presence-service.ts, it never deletes or rewrites the presence file:
+ * the statusLine runs on every turn and must have zero side effects.
+ */
+const PRESENCE_FILE = '.peaks/.active-skill.json';
+const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function resolveCwdFromStdin(stdin) {
+    const fromWorkspace = stdin?.workspace?.current_dir ?? stdin?.workspace?.project_dir;
+    if (typeof fromWorkspace === 'string' && fromWorkspace.length > 0) {
+        return resolve(fromWorkspace);
+    }
+    if (typeof stdin?.cwd === 'string' && stdin.cwd.length > 0) {
+        return resolve(stdin.cwd);
+    }
+    return process.cwd();
+}
+export function parseStatusLineStdin(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the presence file without any side effects. Returns null when the file is
+ * absent (idle) and a sentinel object for malformed content (invalid-presence).
+ */
+function readPresenceReadOnly(projectRoot) {
+    const presencePath = resolve(projectRoot, PRESENCE_FILE);
+    if (!existsSync(presencePath)) {
+        return { presence: null, invalid: false };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(presencePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object') {
+            return { presence: null, invalid: true };
+        }
+        const candidate = parsed;
+        if (typeof candidate.skill !== 'string' || candidate.skill.length === 0) {
+            return { presence: null, invalid: true };
+        }
+        return {
+            presence: {
+                skill: candidate.skill,
+                ...(typeof candidate.mode === 'string' ? { mode: candidate.mode } : {}),
+                ...(typeof candidate.gate === 'string' ? { gate: candidate.gate } : {}),
+                ...(typeof candidate.setAt === 'string' ? { setAt: candidate.setAt } : {})
+            },
+            invalid: false
+        };
+    }
+    catch {
+        return { presence: null, invalid: true };
+    }
+}
+export function buildStatusLineModel(stdin, nowMs) {
+    const cwd = resolveCwdFromStdin(stdin);
+    const projectRoot = findProjectRoot(cwd);
+    if (projectRoot === null) {
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null };
+    }
+    const { presence, invalid } = readPresenceReadOnly(projectRoot);
+    if (invalid) {
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null };
+    }
+    if (presence === null) {
+        return { state: 'idle', projectRoot, presence: null, ageMs: null };
+    }
+    const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
+    const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
+    const state = ageMs !== null && ageMs > STALE_THRESHOLD_MS ? 'stale' : 'active';
+    return { state, projectRoot, presence, ageMs };
+}

package/dist/src/services/skills/statusline-settings-service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Installs (and removes) the Peaks statusLine entry in a Claude Code
+ * settings.json. The statusLine renders `peaks statusline` on every turn, giving
+ * users an out-of-band, harness-painted signal of which Peaks skill is active —
+ * independent of LLM tokens and immune to context compaction.
+ *
+ * Writes preserve all other settings keys, reject symlinked targets, and use an
+ * atomic rename so a partial write can never corrupt an existing settings file.
+ */
+export type StatusLineScope = 'project' | 'global';
+export type StatusLineSettingsPlan = {
+    scope: StatusLineScope;
+    settingsPath: string;
+    exists: boolean;
+    alreadyInstalled: boolean;
+    conflict: boolean;
+    conflictCommand: string | null;
+    desiredCommand: string;
+};
+export type StatusLineSettingsResult = StatusLineSettingsPlan & {
+    applied: boolean;
+};
+export declare const STATUSLINE_COMMAND = "peaks statusline";
+export declare function planStatusLineInstall(scope: StatusLineScope, projectRoot?: string): StatusLineSettingsPlan;
+export declare function applyStatusLineInstall(scope: StatusLineScope, projectRoot?: string, options?: {
+    force?: boolean;
+}): StatusLineSettingsResult;
+export declare function removeStatusLineInstall(scope: StatusLineScope, projectRoot?: string): {
+    scope: StatusLineScope;
+    settingsPath: string;
+    removed: boolean;
+};