peaks-loop 4.0.8 → 4.0.10

package/dist/services/session/session-manager.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkS
 import { mkdir as mkdirAsync } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { projectRootsMatch, stableRealPath } from '../../shared/path-utils.js';
 import { ensureSession } from './session-binding-bridge.js';
 // As of slice 2026-06-05-peaks-runtime-layer the project-level session
 // binding lives under `.peaks/_runtime/session.json`. The legacy
@@ -89,17 +90,22 @@ function getSessionFilePath(projectRoot) {
  * Read existing session info from disk.
  * Returns null if no session file exists or if it's invalid.
  *
- * Strict equality on `data.projectRoot === projectRoot` is
- * preserved here on purpose: many other modules depend on
- * the strict-equality semantics to test the "no session bound"
- * code path. Changing the read semantics here would cascade
- * into many test failures — out of scope for the progress
- * rebind fix.
+ * The `projectRoot` comparison is canonicalized (separator, symlink,
+ * and — on Windows only — case) via `projectRootsMatch`. Before
+ * slice `2026-08-04-rid-001-path-canonicalize` this was a strict
+ * `===`, which returned null whenever the stored form differed
+ * cosmetically from the caller-passed form. On Windows Git Bash that
+ * is the common case: `peaks workspace init` stores
+ * `C:\Users\...\peaks-loop` while the caller passes
+ * `C:/Users/.../peaks-loop`, so every `getSessionId` returned null and
+ * `presence:set` failed closed with `PEAKS_SESSION_NOT_BOUND` —
+ * surfacing to the user as a permanent `peaks empty` statusline.
  *
- * The progress subcommands (which are the surface that
- * actually breaks on the rebind bug) use
- * `getSessionIdCanonical` instead, which does the
- * canonicalize-on-read resolution the bug fix needs.
+ * Canonicalization is a strict widening: paths that denote the same
+ * physical directory now match, and paths that denote different
+ * directories still do not (pinned by the Case 4 regression test in
+ * `tests/unit/session/session-manager-path-canonicalize.test.ts`), so
+ * the "no session bound" code path other modules depend on is intact.
  */
 function readSessionFile(projectRoot) {
     const sessionFile = getSessionFilePath(projectRoot);
@@ -112,7 +118,7 @@ function readSessionFile(projectRoot) {
         return null;
     try {
         const data = JSON.parse(readFileSync(pathToRead, 'utf8'));
-        if (data.sessionId && data.projectRoot === projectRoot) {
+        if (data.sessionId && typeof data.projectRoot === 'string' && projectRootsMatch(data.projectRoot, projectRoot)) {
             return data;
         }
         return null;
@@ -157,6 +163,13 @@ function readSessionFileCanonical(projectRoot) {
  * `.peaks/_runtime/session.json`. The `.peaks/_runtime/` directory is
  * created on demand. The legacy `.peaks/.session.json` is NOT written by
  * this slice; it is only read for back-compat.
+ *
+ * The persisted `projectRoot` is passed through `stableRealPath` so the
+ * stored form is symlink-resolved and stable across callers. We store
+ * the REAL path, not the `projectRootCompareKey` — the key is
+ * lossy (lower-cased on Windows) and is only ever a comparison
+ * artifact. Reads tolerate either form via `projectRootsMatch`, so
+ * bindings written by older versions keep resolving.
  */
 function writeSessionFile(projectRoot, info) {
     const sessionFile = getSessionFilePath(projectRoot);
@@ -164,7 +177,18 @@ function writeSessionFile(projectRoot, info) {
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(sessionFile, JSON.stringify(info, null, 2), 'utf8');
+    let canonicalProjectRoot;
+    try {
+        canonicalProjectRoot = stableRealPath(info.projectRoot);
+    }
+    catch {
+        // Never block a write on canonicalization: if the path cannot be
+        // realpath'd, persist the caller's form unchanged. Reads canonicalize
+        // both sides anyway, so a non-canonical stored value still matches.
+        canonicalProjectRoot = info.projectRoot;
+    }
+    const canonicalInfo = { ...info, projectRoot: canonicalProjectRoot };
+    writeFileSync(sessionFile, JSON.stringify(canonicalInfo, null, 2), 'utf8');
 }
 /**
  * Drop the project-level session binding at the canonical

package/dist/services/session/session-resume-service.d.ts

@@ -6,6 +6,10 @@
  * prepend to its own prompt. The output is LLM-friendly: stable
  * headings, monospace paths, and bullet lists — easy for the model to
  * scan and reason about.
+ *
+ * Resume locates the deepestGate (the latest completed gate in the
+ * workflow) so the skill can pick up the next step without re-asking
+ * the user for state already captured at that gate.
  */
 import { type CheckpointSnapshot } from './session-checkpoint-service.js';
 export interface ResumeOptions {

package/dist/services/session/session-resume-service.js

@@ -6,6 +6,10 @@
  * prepend to its own prompt. The output is LLM-friendly: stable
  * headings, monospace paths, and bullet lists — easy for the model to
  * scan and reason about.
+ *
+ * Resume locates the deepestGate (the latest completed gate in the
+ * workflow) so the skill can pick up the next step without re-asking
+ * the user for state already captured at that gate.
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, sep } from 'node:path';

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

@@ -14,66 +14,44 @@ export type StatusLineCapability = 'ansi-unicode' | 'unicode' | 'ascii';
 export interface StatusLineRenderOptions {
     readonly capability: StatusLineCapability;
 }
-/**
- * Resolve the capability tier from environment and TTY state. Pure and
- * deterministic — no I/O beyond reading the caller-supplied `env` and
- * `isTTY` flag. The CLI delegates to this so the read-only status line
- * does not need to know about ANSI/NO_COLOR semantics.
- *
- * The optional `forced` argument is a TEST SEAM (consumed by direct unit
- * tests, not by the CLI). It lets tests pin a tier without constructing a
- * TTY/NO_COLOR fixture. The CLI does NOT expose any flag that maps to
- * `forced` — the env-driven path is the single first-version runtime
- * source of truth.
- *
- * Adapter-internal env override (NOT a user-facing CLI flag):
- *   `PEAKS_STATUSLINE_ASCII` — when set to `1` / `true` / `yes`, the
- *   renderer drops to the ASCII palette (no Unicode-extra glyphs, no ANSI).
- *   This is an adapter-internal mechanism for the trust boundary described
- *   by the two-forms-only / human-NL-choice-only tenets: the user never
- *   types a CLI verb to flip palettes, but the adapter (and only the
- *   adapter) can set the env var on the user's behalf when its consumer
- *   (e.g. a tiny terminal without UTF-8) needs ASCII. We do NOT expose
- *   this via a CLI flag.
- *
- * Order of resolution (highest priority first):
- *
- *   1. `forced` argument (test seam only)
- *   2. `PEAKS_STATUSLINE_ASCII` set → `ascii` (adapter-internal override)
- *   3. `isTTY === true` → `ansi-unicode`
- *   4. otherwise → `unicode` (still ANSI-colored; only `ascii` is color-free)
- *
- * Why this ordering: the IDE statusline invokes the renderer through a
- * hook that may not always be detected as a TTY. The `unicode` tier
- * now emits the cyan brand accent + semantic colors so the line reads
- * as a branded product surface whether or not the consumer is a
- * terminal. `NO_COLOR` is honored as an ambient convention by the
- * IDE adapter (which can set `PEAKS_STATUSLINE_ASCII=1` to opt out
- * fully), so a separate tier for NO_COLOR is no longer needed.
- *
- * `ascii` is the strict no-color, no-Unicode-extra tier; it is the
- * single safe option for plain log / file consumers.
- *
- * Why `PEAKS_STATUSLINE_ASCII` outranks `NO_COLOR`:
- *   The two env vars are NOT redundant. `NO_COLOR` (https://no-color.org)
- *   is the cross-industry signal that NO escape sequences should be emitted
- *   — its only effect is "ANSI off". The Unicode-extra glyphs (●, █, ░, etc.)
- *   are NOT ANSI escape sequences; they are UTF-8 characters and `NO_COLOR`
- *   does not address them. `PEAKS_STATUSLINE_ASCII` is the adapter-internal
- *   "signal source is a tiny terminal without UTF-8" override and drops the
- *   glyphs to ASCII shape as well. Both are correct signals about
- *   different concerns; the ASCII override wins because it is strictly
- *   narrower (a tiny terminal needs both no-ANSI AND no-Unicode-extra).
- *
- * The deliberate ordering keeps the rendered text ANSI-free when the consumer
- * is a logger, a file, or any non-interactive sink, and only enables ANSI
- * under an explicit supported condition (TTY + no env veto).
- */
 export declare function resolveStatusLineCapability(input: {
     readonly env: NodeJS.ProcessEnv;
     readonly isTTY: boolean;
     readonly forced?: StatusLineCapability;
 }): StatusLineCapability;
+export declare function isNoColorEnv(env: NodeJS.ProcessEnv): boolean;
+/**
+ * Visible-character width of an ANSI-bearing string. Skips every
+ * `\x1b[...m` escape so the count reflects what the terminal paints,
+ * not the byte length on the wire.
+ */
+export declare function visibleCharWidth(s: string): number;
+interface AnsiToken {
+    readonly kind: 'text' | 'esc';
+    readonly value: string;
+}
+/**
+ * Split an ANSI string into a flat token stream. Escape sequences are
+ * grouped as `\x1b[...m` (single token, kind='esc'); everything else
+ * is grouped as a single 'text' run. Used by {@link applyMarquee} to
+ * locate visible-cell ranges inside an SGR-bearing string.
+ */
+export declare function tokenizeAnsi(s: string): readonly AnsiToken[];
+/**
+ * Apply the marquee highlight band to an ANSI-bearing string. Pure.
+ * - `bandStart` / `bandEnd` are visible-cell indices (0-based).
+ * - Cells in [bandStart, bandEnd] receive a `\x1b[1;38;2;224;224;224m`
+ *   prefix; cells after the band receive the closing `\x1b[0m` reset
+ *   so the rest of the line keeps its original SGR.
+ * - Empty strings and zero-width bands return the input unchanged.
+ */
+export declare function applyMarqueeHighlight(s: string, bandStart: number, bandEnd: number): string;
+/**
+ * Compute the marquee band for a string at time `nowMs` and re-emit
+ * the string with the band applied. ASCII tier is a pass-through (no
+ * SGR to inject) — the scanner has no visible effect on plain text.
+ */
+export declare function applyMarquee(s: string, nowMs: number, capability: StatusLineCapability): string;
 /**
  * Render the status line. Pure — no I/O, no side effects. The output is
  * a single short line suitable for the bottom-of-terminal status bar.
@@ -85,5 +63,17 @@ export declare function resolveStatusLineCapability(input: {
  * Compact-state precedence: when `model.compact.kind !== 'none'` the
  * compact bar replaces the active/idle/stale content. The C1 baseline
  * line is preserved when the compact state is `none`.
+ *
+ * The full line is wrapped by {@link applyMarquee} so the brand-purple
+ * text + non-focal bar cells share a single colour surface while the
+ * scanner band paints its `#E0E0E0` highlight over a moving slice.
+ *
+ * Idle suppression: the marquee is OFF when `model.state === 'idle'`
+ * (and no compact state is active). Idle keeps the slow-blink `○`
+ * as the only motion — the user is asking whether the harness is
+ * running a skill; the scan band would compete for attention and
+ * obscure that question. Active / stale / invalid-presence / compact
+ * states all keep the marquee.
  */
-export declare function renderStatusLine(model: StatusLineModel, options?: StatusLineRenderOptions): string;
+export declare function renderStatusLine(model: StatusLineModel, options?: StatusLineRenderOptions, env?: NodeJS.ProcessEnv): string;
+export {};