peaks-cli 1.0.28 → 1.1.1

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

@@ -0,0 +1,144 @@
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+export const STATUSLINE_COMMAND = 'peaks statusline';
+function isInsidePath(childPath, parentPath) {
+    const rel = relative(parentPath, childPath);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function resolveSettingsRoot(scope, projectRoot) {
+    if (scope === 'global')
+        return resolve(homedir());
+    if (!projectRoot) {
+        throw new Error('Project scope requires a project root');
+    }
+    return resolve(projectRoot);
+}
+function resolveSettingsPath(scope, projectRoot) {
+    const root = resolveSettingsRoot(scope, projectRoot);
+    return join(root, '.claude', 'settings.json');
+}
+/** Reject symlinked .claude dir or settings file to prevent escape. */
+function assertSafeSettingsPath(scope, root, settingsPath) {
+    const claudeDir = join(root, '.claude');
+    if (existsSync(claudeDir) && lstatSync(claudeDir).isSymbolicLink()) {
+        throw new Error('.claude directory must not be a symlink');
+    }
+    if (existsSync(settingsPath)) {
+        if (lstatSync(settingsPath).isSymbolicLink()) {
+            throw new Error('settings.json must not be a symlink');
+        }
+        const realRoot = realpathSync(root);
+        if (!isInsidePath(realpathSync(settingsPath), realRoot)) {
+            throw new Error(`settings.json must stay inside the ${scope} root`);
+        }
+    }
+}
+function readSettings(settingsPath) {
+    if (!existsSync(settingsPath))
+        return {};
+    const fd = openSync(settingsPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const raw = readFileSync(fd, 'utf8').trim();
+        if (raw.length === 0)
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('settings.json must contain a JSON object');
+        }
+        return parsed;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function extractExistingCommand(settings) {
+    const statusLine = settings.statusLine;
+    if (statusLine && typeof statusLine === 'object' && !Array.isArray(statusLine)) {
+        const command = statusLine.command;
+        if (typeof command === 'string')
+            return command;
+    }
+    return null;
+}
+function buildPlan(scope, settingsPath, settings, exists) {
+    const existingCommand = extractExistingCommand(settings);
+    const alreadyInstalled = existingCommand !== null && existingCommand.includes(STATUSLINE_COMMAND);
+    const conflict = existingCommand !== null && !alreadyInstalled;
+    return {
+        scope,
+        settingsPath,
+        exists,
+        alreadyInstalled,
+        conflict,
+        conflictCommand: conflict ? existingCommand : null,
+        desiredCommand: STATUSLINE_COMMAND
+    };
+}
+export function planStatusLineInstall(scope, projectRoot) {
+    const root = resolveSettingsRoot(scope, projectRoot);
+    const settingsPath = resolveSettingsPath(scope, projectRoot);
+    assertSafeSettingsPath(scope, root, settingsPath);
+    const exists = existsSync(settingsPath);
+    const settings = readSettings(settingsPath);
+    return buildPlan(scope, settingsPath, settings, exists);
+}
+function atomicWriteJson(settingsPath, settings) {
+    const dir = dirname(settingsPath);
+    mkdirSync(dir, { recursive: true });
+    const tempPath = join(dir, `.settings.${randomUUID()}.tmp`);
+    const fd = openSync(tempPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        writeFileSync(fd, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+    try {
+        renameSync(tempPath, settingsPath);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            // best effort cleanup
+        }
+        throw error;
+    }
+}
+export function applyStatusLineInstall(scope, projectRoot, options = {}) {
+    const root = resolveSettingsRoot(scope, projectRoot);
+    const settingsPath = resolveSettingsPath(scope, projectRoot);
+    assertSafeSettingsPath(scope, root, settingsPath);
+    const exists = existsSync(settingsPath);
+    const settings = readSettings(settingsPath);
+    const plan = buildPlan(scope, settingsPath, settings, exists);
+    if (plan.alreadyInstalled) {
+        return { ...plan, applied: false };
+    }
+    if (plan.conflict && !options.force) {
+        return { ...plan, applied: false };
+    }
+    const entry = { type: 'command', command: STATUSLINE_COMMAND, padding: 0 };
+    const nextSettings = { ...settings, statusLine: entry };
+    atomicWriteJson(settingsPath, nextSettings);
+    return { ...plan, applied: true };
+}
+export function removeStatusLineInstall(scope, projectRoot) {
+    const root = resolveSettingsRoot(scope, projectRoot);
+    const settingsPath = resolveSettingsPath(scope, projectRoot);
+    assertSafeSettingsPath(scope, root, settingsPath);
+    if (!existsSync(settingsPath)) {
+        return { scope, settingsPath, removed: false };
+    }
+    const settings = readSettings(settingsPath);
+    const existingCommand = extractExistingCommand(settings);
+    if (existingCommand === null || !existingCommand.includes(STATUSLINE_COMMAND)) {
+        return { scope, settingsPath, removed: false };
+    }
+    const { statusLine: _removed, ...rest } = settings;
+    atomicWriteJson(settingsPath, rest);
+    return { scope, settingsPath, removed: true };
+}

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

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.0.28";
+export declare const CLI_VERSION = "1.1.1";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.0.28";
+export const CLI_VERSION = "1.1.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.0.28",
+  "version": "1.1.1",
   "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|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)."
+            "pattern": "^(skill|skill-name|skill-parse|skill-runbook|skill-apply-note|skill-presence|statusline|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), statusline:<topic> (whether the out-of-band Claude Code statusLine is installed), 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

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-prd --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-prd | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-prd --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-qa/SKILL.md

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-qa --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-qa | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-qa --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-rd/SKILL.md

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-rd --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-rd | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-rd --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities

package/skills/peaks-sc/SKILL.md

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-sc --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-sc | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-sc --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities
@@ -56,7 +63,7 @@ Use gstack as a concrete source-control and release workflow reference for the `
 
 ## Project memory backup
 
-Project `.claude/memory` is the primary source for durable project memory. At approved checkpoints, use `peaks memory sync --project <path> --workspace <artifact-workspace> --apply` to back up the full project memory directory into the artifact repository workspace; do not treat the artifact backup as a second writable memory source.
+Project `.peaks/memory` is the primary source for durable project memory. At approved checkpoints, use `peaks memory sync --project <path> --workspace <artifact-workspace> --apply` to back up the full project memory directory into the artifact repository workspace; do not treat the artifact backup as a second writable memory source.
 
 ## Commit boundary derivation
 

package/skills/peaks-solo/SKILL.md

@@ -74,26 +74,33 @@ Only after the mode is known (user selected or explicitly named), run:
 peaks skill presence:set peaks-solo --project <repo> --mode <mode-value> --gate startup
 ```
 
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
 Then display the compact status header: `Peaks-Cli Skill: peaks-solo | Peaks-Cli Gate: startup | Next: <one short action>`. Display this header on EVERY turn while the skill is active.
 
 Update with `peaks skill presence:set peaks-solo --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — do NOT clear it at workflow end.
 
-### Peaks-Cli Step 2.3: Load project memory (structured ontology for LLM)
+### Peaks-Cli Step 2.3: Load project memory (durable, LLM-authored memories)
 
-Before planning any work, read the project's persistent memory — structured data that survives across sessions:
+Before planning any work, read the project's persistent memory — durable memories that survive across sessions:
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` containing:
-- **modules** — code areas touched, with risk levels and which sessions modified them
-- **decisions** — architectural choices, why they were made, what modules they affect
-- **conventions** — discovered project patterns (code style, naming, tooling)
+This returns durable memories from `.peaks/memory`, grouped by kind:
+- **module** — code areas touched, with risk and rationale captured by past sessions
+- **decision** — architectural choices, why they were made, what they affect
+- **convention** — discovered project patterns (code style, naming, tooling)
+- **rule** / **reference** / **project** — standing constraints, external pointers, and project context
 
-Use this to understand what exists, what was decided, and what to avoid re-litigating. The ontology is auto-updated on `peaks skill presence:clear`.
+Filter with `--kind <decision|convention|module|rule|reference|project>` when you only need one slice. Use this to understand what exists, what was decided, and what to avoid re-litigating. Memories are LLM-authored at approved checkpoints via `peaks memory extract`.
 
-`.peaks/PROJECT.md` is a human-readable timeline only — do NOT use it for LLM context.
+`.peaks/PROJECT.md` is a human-readable session timeline only — do NOT use it for LLM context.
 
 ### Peaks-Cli Step 2.5: Set session title
 

package/skills/peaks-txt/SKILL.md

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-txt --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-txt | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-txt --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities
@@ -96,7 +103,7 @@ Each entry should include:
 - why it exists;
 - affected skills;
 - how future PRD/RD/UI/QA/SC/Solo workflows should apply it;
-- whether it is stable enough for `.claude/memory` extraction.
+- whether it is stable enough for `.peaks/memory` extraction.
 
 ## Project memory guidance
 
@@ -111,7 +118,7 @@ Stable memory body.
 <!-- peaks-memory:end -->
 ```
 
-The primary write target is the target project's `.claude/memory`. Use `peaks memory extract --project <path> --artifact <artifact> --apply` only after the user or active profile allows durable project memory writes.
+The primary write target is the target project's `.peaks/memory`. Use `peaks memory extract --project <path> --artifact <artifact> --apply` only after the user or active profile allows durable project memory writes.
 
 ## Matt Pocock skills integration
 

package/skills/peaks-ui/SKILL.md

@@ -14,13 +14,20 @@ Before any analysis or tool call, immediately run:
 ```bash
 peaks skill presence:set peaks-ui --project <repo> --mode <mode> --gate startup
 ```
-Read persistent project memory via CLI (structured ontology for LLM):
+
+On the first presence:set in a project, ensure the out-of-band status bar is installed so the user can see at a glance that Peaks is orchestrating — it renders the active skill in Claude Code's terminal status line, independent of model output:
+
+```bash
+peaks statusline install --project <repo>   # idempotent; skips if already installed
+```
+
+Read persistent project memory via CLI (durable, LLM-authored memories):
 
 ```bash
-peaks project ontology show --project <repo> --json
+peaks project memories --project <repo> --json
 ```
 
-This returns `.peaks/ontology.json` — structured modules, decisions, and conventions from past sessions. (`.peaks/PROJECT.md` is a human-readable timeline only.)
+This returns durable memories from `.peaks/memory` — decisions, conventions, modules, and rules captured in past sessions. Filter with `--kind <decision|convention|module|rule|reference|project>`. (`.peaks/PROJECT.md` is a human-readable session timeline only.)
 Then display: `Peaks-Cli Skill: peaks-ui | Peaks-Cli Gate: startup | Next: <one short action>`. Update with `peaks skill presence:set peaks-ui --project <repo> --mode <mode> --gate <gate>` when gates change. When the role's work ends, run `peaks skill presence:clear --project <repo>`.
 
 ## Responsibilities