peaks-loop 4.1.0 → 4.1.2

package/dist/services/comments/prune-apply.js

@@ -0,0 +1,217 @@
+/**
+ * The line mechanics of a comment prune, and the proof that gates every write.
+ *
+ * Split from `comment-prune.ts` because the two change for different reasons: that
+ * module decides WHAT is debt (and follows the classifier), this one decides how a
+ * line is removed from a file without damaging the file (and follows the language).
+ * Keeping them apart is also what lets the proof be tested on a text array, with no
+ * filesystem and no scan in the room.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { endsInsideLiteral } from './comment-spans.js';
+/**
+ * Read a file, or report that it is not there — a prune never creates one.
+ *
+ * `existsSync` first, and NO catch: a `catch { return null }` answers "present but
+ * unreadable" (permissions, a locked handle, a directory named as a file) with the same
+ * `null` as "absent", and that conflation is the defect this repository already
+ * ratchets under `silentWarningCatchReturnNull` — this very helper was counted by it.
+ * An absent path is a state the caller handles; an unreadable one should be a crash an
+ * operator sees.
+ */
+export function readFileSafe(root, rel) {
+    const abs = join(root, rel);
+    return existsSync(abs) ? readFileSync(abs, 'utf8') : null;
+}
+/**
+ * Split a source into lines, remembering what separated them.
+ *
+ * `mixed` is the signal to leave a file alone rather than a detail to paper over: a
+ * file with both CRLF and LF endings cannot be re-joined from one delimiter without
+ * rewriting every line, and a rewrite of every line is not a comment edit — it would
+ * also make the proof below vacuous, because all the lines would differ.
+ */
+export function splitLines(source) {
+    const crlf = source.includes('\r\n');
+    const lfOnly = /\n(?!\r)/.test(source.replace(/\r\n/g, '\n')) || /\n[^\r]/.test(source);
+    return {
+        lines: source.split(/\r?\n/),
+        eol: crlf ? '\r\n' : '\n',
+        mixed: crlf && lfOnly
+    };
+}
+/** Group a plan by file, in first-seen order. */
+export function actionsByFile(actions) {
+    const byFile = new Map();
+    for (const action of actions) {
+        const list = byFile.get(action.file);
+        if (list === undefined)
+            byFile.set(action.file, [action]);
+        else
+            list.push(action);
+    }
+    return byFile;
+}
+/**
+ * The proof, as data: compare kept lines against the original.
+ *
+ * One string per violation; empty means every difference between the two texts is a
+ * line this plan named, and every line it named that was kept is byte-identical to
+ * what was there before. This is computed whether or not the caller intends to write,
+ * so a dry run reports the refusals a real run would hit.
+ */
+export function proofViolations(before, after, actions) {
+    const dropped = new Set(actions.filter((a) => a.mode === 'drop-line').map((a) => a.line));
+    // The blanks the drops orphan are removed on purpose too — the SAME function the writer
+    // uses decides, so the proof can never be persuaded to allow more than the writer does.
+    const removed = new Set(dropped);
+    for (const blank of orphanedBlanks(before, dropped))
+        removed.add(blank);
+    const stripped = new Set(actions.filter((a) => a.mode === 'strip-trailing').map((a) => a.line));
+    const violations = [];
+    let afterAt = 0;
+    before.forEach((original, index) => {
+        const line = index + 1;
+        if (removed.has(line))
+            return; // deleted on purpose
+        if (stripped.has(line)) {
+            // The only thing a strip may do is reveal the code that was already there, so
+            // what survives must be a PREFIX of the original line — that is what makes it a
+            // comment edit, and anything else is a code edit wearing its clothes.
+            const kept = after[afterAt] ?? '';
+            afterAt += 1;
+            if (!original.startsWith(kept))
+                violations.push(`line ${line}: code text changed`);
+            // The prefix test above is true of EVERY truncation, which is how a strip that
+            // cut a template literal in half passed it. `startsWith` says nothing about
+            // whether what survives is still complete code, so that is asked separately.
+            // refused the write that left `snippet: \`` in `src/`.)
+            else if (endsInsideLiteral(kept)) {
+                violations.push(`line ${line}: strip left an unterminated literal — the code changed`);
+            }
+            return;
+        }
+        if (after[afterAt] !== original)
+            violations.push(`line ${line}: untouched line differs`);
+        afterAt += 1;
+    });
+    if (afterAt !== after.length)
+        violations.push(`produced ${after.length - afterAt} extra line(s)`);
+    return violations;
+}
+/**
+ * The blank lines a set of drops ORPHANS.
+ *
+ * A comment standing alone between two blanks is the only thing separating two blocks:
+ *
+ *     }
+ *                    ← blank
+ *                    ← blank
+ *     type AuditEnvelopeGuard<T> = …
+ *
+ * Deleting the comment joins the two blanks into a double blank, which is not what the
+ * file said before and not what any formatter will keep. So the drop owns that blank line
+ * — it is the residue of a comment removal, not an edit of someone's whitespace. Only a
+ * blank that becomes adjacent to another blank THROUGH a drop is claimed here: a double
+ * blank the repository already carries is left exactly where it is, because the pruner did
+ * not make it and has no business "fixing" it.
+ *
+ * ONE HELPER, BOTH CALLERS: `pruneFileLines` removes these and `proofViolations` allows
+ * them. A second copy of this rule is the defect class this whole feature answers, so the
+ * writer and the checker ask the same function the same question.
+ */
+export function orphanedBlanks(before, dropped) {
+    const orphaned = new Set();
+    let lastKept = 0; // 1-based line number of the last line that survived
+    for (let index = 0; index < before.length; index += 1) {
+        const line = index + 1;
+        if (dropped.has(line))
+            continue;
+        const isBlank = (before[index] ?? '').trim() === '';
+        if (isBlank && lastKept > 0 && (before[lastKept - 1] ?? '').trim() === '') {
+            // Every original line between the two blanks was dropped, or this blank is the
+            // join the drop created. Anything else was a double blank before this run began.
+            // A blank is claimed ONLY when a drop actually sits between it and the previous
+            // surviving blank: `between` must be non-empty, because `[].every(…)` is true and
+            // an empty gap is a double blank the repository already had — which this run did
+            // not make and has no business touching.
+            const between = range(lastKept + 1, line - 1);
+            if (between.length > 0 && between.every((n) => dropped.has(n)))
+                orphaned.add(line);
+        }
+        lastKept = line;
+    }
+    return orphaned;
+}
+/** Inclusive integer range, empty when `from > to`. */
+function range(from, to) {
+    const out = [];
+    for (let n = from; n <= to; n += 1)
+        out.push(n);
+    return out;
+}
+/** Apply one file's actions to its lines, in the plan's own terms. */
+export function pruneFileLines(lines, actions) {
+    const drop = new Set(actions.filter((a) => a.mode === 'drop-line').map((a) => a.line));
+    const gone = new Set(drop);
+    for (const blank of orphanedBlanks(lines, drop))
+        gone.add(blank);
+    const strip = new Map(actions.filter((a) => a.mode === 'strip-trailing').map((a) => [a.line, a.comment]));
+    const out = [];
+    lines.forEach((original, index) => {
+        const line = index + 1;
+        if (gone.has(line))
+            return;
+        if (strip.has(line)) {
+            // Cut where the scan's comment text starts, not at the first `//` in the line:
+            // `const url = "https://example.com"; // Slice 1 kept it` has its `//` inside a
+            // string literal, and slicing there would delete code.
+            const comment = strip.get(line) ?? '';
+            const at = original.indexOf(comment);
+            out.push(at > 0 ? original.slice(0, at).trimEnd() : comment.trimEnd());
+            return;
+        }
+        out.push(original);
+    });
+    return out;
+}
+/**
+ * Run the proof on every planned file, and write only the files that passed it.
+ *
+ * A file that fails is reported and left alone — never written "mostly", because a
+ * partially-pruned file is exactly the state the proof exists to make unreachable.
+ */
+export function executePlan(projectRoot, byFile, apply) {
+    const touched = [];
+    const notWritten = [];
+    const fileSkips = [];
+    for (const [file, fileActions] of byFile) {
+        const source = readFileSafe(projectRoot, file);
+        if (source === null) {
+            notWritten.push(file);
+            continue;
+        }
+        const parts = splitLines(source);
+        if (parts.mixed) {
+            fileSkips.push({
+                file,
+                line: 0,
+                reason: 'mixed-line-endings',
+                text: `${parts.lines.length} line(s) left untouched`
+            });
+            notWritten.push(file);
+            continue;
+        }
+        const after = pruneFileLines(parts.lines, fileActions);
+        const violations = proofViolations(parts.lines, after, fileActions);
+        if (violations.length > 0) {
+            notWritten.push(`${file} (${violations[0]})`);
+            continue;
+        }
+        touched.push(file);
+        if (apply)
+            writeFileSync(join(projectRoot, file), after.join(parts.eol));
+    }
+    return { touched, notWritten, fileSkips };
+}

package/dist/services/comments/repo-path-probe.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Is a path required to exist in a checkout at all?
+ *
+ * The dominant false positive on `dead-reference` was never a stale comment: it
+ * was a correct reference to a file git is told not to track. Ranked over this
+ * repository, the top twelve "dead" citations were `.claude/settings.local.json`,
+ * `.peaks/_runtime/session.json`, `.peaks/.session.json`,
+ * `.peaks/_runtime/active-skill.json`, `.codegraph/config.json`,
+ * `.peaks/preferences.json` and friends — all generated state, all named
+ * correctly by the code that writes them.
+ *
+ * So the probe answers "exists OR ignored", and the ignore reading is deliberately
+ * bounded: trailing-slash prefixes, whole-path entries, and bare-basename entries.
+ * That limit has a direction, and the direction is the safe one — a rule
+ * `.gitignore` expresses fancily (negation, `**`, character classes) is NOT read
+ * here, so such a path stays reported. A missed exemption is a finding a human
+ * reads and dismisses; a phantom exemption is a silent false green in a gate that
+ * exists to catch claims that outlived their referent.
+ */
+type IgnoreRules = {
+    /** Directory rules: match the path and everything below it. */
+    readonly prefixes: readonly string[];
+    /** File rules written with a slash: match that exact repo-relative path. */
+    readonly exact: ReadonlySet<string>;
+    /** Basename rules: match that name in any directory. */
+    readonly basenames: ReadonlySet<string>;
+};
+/** True when `.gitignore` says this repo-relative path need not be on disk. */
+export declare function isIgnoredPath(relPath: string, rules: IgnoreRules): boolean;
+/**
+ * Build the existence probe a scan should use: a real filesystem lookup, widened
+ * by the repository's own ignore list read from its root.
+ *
+ * The second export below is the deliberate exception. "Is this an installed
+ * package name?" must NOT be widened by the ignore list, because `node_modules` is
+ * itself ignored — an ignore-aware probe answers yes for every first segment, and
+ * the whole `dead-reference` count collapses to zero while looking perfectly
+ * healthy.
+ */
+export declare function createRepoProbe(repoRoot: string): (relPath: string) => boolean;
+/** Filesystem-only existence, for questions where "git ignores it" is no answer. */
+export declare function createFsProbe(repoRoot: string): (relPath: string) => boolean;
+export {};

package/dist/services/comments/repo-path-probe.js

@@ -0,0 +1,78 @@
+/**
+ * Is a path required to exist in a checkout at all?
+ *
+ * The dominant false positive on `dead-reference` was never a stale comment: it
+ * was a correct reference to a file git is told not to track. Ranked over this
+ * repository, the top twelve "dead" citations were `.claude/settings.local.json`,
+ * `.peaks/_runtime/session.json`, `.peaks/.session.json`,
+ * `.peaks/_runtime/active-skill.json`, `.codegraph/config.json`,
+ * `.peaks/preferences.json` and friends — all generated state, all named
+ * correctly by the code that writes them.
+ *
+ * So the probe answers "exists OR ignored", and the ignore reading is deliberately
+ * bounded: trailing-slash prefixes, whole-path entries, and bare-basename entries.
+ * That limit has a direction, and the direction is the safe one — a rule
+ * `.gitignore` expresses fancily (negation, `**`, character classes) is NOT read
+ * here, so such a path stays reported. A missed exemption is a finding a human
+ * reads and dismisses; a phantom exemption is a silent false green in a gate that
+ * exists to catch claims that outlived their referent.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+function parseGitignore(source) {
+    const prefixes = [];
+    const exact = new Set();
+    const basenames = new Set();
+    for (const raw of source.split(/\r?\n/)) {
+        const rule = raw.trim();
+        if (rule.length === 0 || rule.startsWith('#') || rule.startsWith('!'))
+            continue;
+        const cleaned = rule.replace(/^\//, '').replace(/\/$/, '');
+        if (cleaned.length === 0)
+            continue;
+        if (!cleaned.includes('/')) {
+            basenames.add(cleaned);
+            continue;
+        }
+        // A rule with a slash is registered both ways rather than guessed: `.peaks/_runtime/`
+        // is a directory, `.claude/settings.local.json` is one file, and a rule that
+        // matched only `path/` silently failed every single-file ignore in the
+        // repository. Registering both costs nothing — an over-broad directory prefix
+        // here can only ever name the path it was written for and things under it.
+        prefixes.push(`${cleaned}/`);
+        exact.add(cleaned);
+    }
+    return { prefixes, exact, basenames };
+}
+/** True when `.gitignore` says this repo-relative path need not be on disk. */
+export function isIgnoredPath(relPath, rules) {
+    const posix = relPath.replace(/\\/g, '/');
+    if (rules.exact.has(posix))
+        return true;
+    if (rules.prefixes.some((prefix) => posix.startsWith(prefix)))
+        return true;
+    const segments = posix.split('/');
+    return segments.some((segment) => rules.basenames.has(segment));
+}
+/**
+ * Build the existence probe a scan should use: a real filesystem lookup, widened
+ * by the repository's own ignore list read from its root.
+ *
+ * The second export below is the deliberate exception. "Is this an installed
+ * package name?" must NOT be widened by the ignore list, because `node_modules` is
+ * itself ignored — an ignore-aware probe answers yes for every first segment, and
+ * the whole `dead-reference` count collapses to zero while looking perfectly
+ * healthy.
+ */
+export function createRepoProbe(repoRoot) {
+    let rules = { prefixes: [], exact: new Set(), basenames: new Set() };
+    const ignorePath = join(repoRoot, '.gitignore');
+    if (existsSync(ignorePath)) {
+        rules = parseGitignore(readFileSync(ignorePath, 'utf8'));
+    }
+    return (relPath) => existsSync(join(repoRoot, relPath)) || isIgnoredPath(relPath, rules);
+}
+/** Filesystem-only existence, for questions where "git ignores it" is no answer. */
+export function createFsProbe(repoRoot) {
+    return (relPath) => existsSync(join(repoRoot, relPath));
+}

package/dist/services/compact/decision-tables.d.ts

@@ -1,5 +1,4 @@
 /**
- * Strategic-compact decision tables (slice 2026-07-01-strategic-compact-cli).
  *
  * Pure data + lookup helpers. No I/O. The byte-for-byte text mirrors the
  * "Compaction Decision Guide" + "What Survives Compaction" tables in
@@ -9,7 +8,6 @@
  * The `peaks compact recommend` + `peaks compact survival` + `peaks
  * compact dry-run` primitives read from these tables; any change to the
  * upstream skill table must be mirrored here and re-asserted by the
- * `tests/unit/cli/compact-command.test.ts` regression suite.
  */
 export type Phase = 'research' | 'planning' | 'implementation' | 'testing' | 'debugging';
 export declare const PHASES: readonly Phase[];

package/dist/services/compact/decision-tables.js

@@ -1,5 +1,4 @@
 /**
- * Strategic-compact decision tables (slice 2026-07-01-strategic-compact-cli).
  *
  * Pure data + lookup helpers. No I/O. The byte-for-byte text mirrors the
  * "Compaction Decision Guide" + "What Survives Compaction" tables in
@@ -9,7 +8,6 @@
  * The `peaks compact recommend` + `peaks compact survival` + `peaks
  * compact dry-run` primitives read from these tables; any change to the
  * upstream skill table must be mirrored here and re-asserted by the
- * `tests/unit/cli/compact-command.test.ts` regression suite.
  */
 export const PHASES = [
     'research',

package/dist/services/compact/request-transition-hook.js

@@ -1,5 +1,4 @@
 /**
- * Slice-boundary pre-compact hook (slice 2026-07-01-strategic-compact-cli).
  *
  * The RD → QA and QA → final-review slice-boundary transitions go
  * through `peaks request transition`. When the active session is in
@@ -19,7 +18,6 @@
  * auto-compact orchestrator asks the harness to compact and reports that
  * it is waiting. It does not refuse sub-agent dispatch — peaks-loop has no
  * executor for a running session, so a refusal gated nothing and deadlocked
- * the runner (slice 2026-09-13-auto-compact-trigger-ownership).
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';

package/dist/services/compact-history/compact-history-service.d.ts

@@ -11,7 +11,6 @@ export interface CompactHistoryEvent {
     readonly checkpointPath: string;
     readonly dispatchMessage: string;
     /**
-     * Slice 2026-09-13-auto-compact-trigger-ownership (T4): the window this
      * dispatch divided by. `beforeRatio * windowTokens` is the token point
      * peaks-loop asked the harness to compact at.
      */
@@ -27,7 +26,6 @@ export interface CompactHistoryEvent {
     /** `observed` rows only: the measured post-compact ratio. */
     readonly afterRatio?: number;
     /**
-     * rid `2026-09-13-compact-event-settle`: what the HARNESS said caused the
      * compaction — `manual` (a user ran `/compact`) or `auto` (the harness's own
      * window fired). Written only by the `PostCompact` hook path, which is the
      * only path a harness reports it on.

package/dist/services/compact-history/compact-history-service.js

@@ -1,6 +1,5 @@
 // src/services/compact-history/compact-history-service.ts
 //
-// Slice 2026-07-30-compact-visibility (slice 1/4). Pure-function
 // reader for the .peaks/_runtime/<sessionId>/compact-history.jsonl
 // file that auto-compact-orchestrator now appends to on every
 // dispatch. The CLI surface `peaks compact history` and the

package/dist/services/compact-statusline/compact-lifecycle-store.js

@@ -1,6 +1,5 @@
 // src/services/compact-statusline/compact-lifecycle-store.ts
 //
-// Slice 2026-08-01-compact-lifecycle (Task 1/5). Pure persistence
 // for the runtime *compact lifecycle* record that the auto-compact
 // orchestrator writes on every state transition. The record is the
 // single source of truth that downstream statusline / dashboard
@@ -20,7 +19,6 @@
 // staleAfterMs. Terminal stages (`completed`, `failed`) NEVER go
 // stalled — the record is the historical answer, not a heartbeat.
 //
-// Slice 2026-09-12-compact-band-policy (defect B): `armed` is a third
 // category — a RESTING stage. It records a fact ("we registered a
 // compact trigger") that stays true until a measurement supersedes it;
 // no heartbeat was ever promised, so waiting in it is NORMAL and it

package/dist/services/compact-statusline/compact-lifecycle-types.d.ts

@@ -1,6 +1,5 @@
 export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting'
 /**
- * Slice 2026-09-12-compact-band-policy: a compact trigger was
  * REGISTERED but no compaction has started — e.g. claude-code's
  * `ide-native` pathway only installs the PreToolUse hook, which
  * compacts in-band at ratio ≥ 0.95. In the 0.80–0.95 band nothing

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -1,6 +1,5 @@
 // src/services/compact-statusline/compact-statusline-service.ts
 //
-// Slice 2026-08-01-compact-lifecycle (Task 3/5). Pure semantic
 // decision + render helper for the 'peaks statusline compact'
 // indicator. Reads .peaks/_runtime/<sessionId>/compact-lifecycle.json
 // first (the canonical source of truth) and falls back to the legacy
@@ -28,7 +27,6 @@
 //   none       → 0 cells
 //   invalid    → 0 cells (no false reassurance)
 //   stalled    → keep the active stage's cell
-//   armed      → NO bar at all (slice 2026-09-12-compact-band-policy):
 //                a registered-but-idle trigger has no progress to
 //                report, and a bar would imply one.
 //
@@ -130,7 +128,6 @@ function decideLegacyFallback(input) {
     // Priority 2 within legacy: a history row TESTIFIES that a compaction was
     // witnessed, recently enough to still be the one being reported.
     //
-    // Repair R9 (AC4). This used to read the file's mtime — freshness taken as
     // evidence that "a compact just landed". Freshness is evidence of neither:
     // the same file takes a `dispatch` row every time peaks-loop ASKS for a
     // compact, and an ask is an intent, not an outcome. One real session
@@ -193,7 +190,6 @@ export function renderCompactStatusline(state) {
             return `compact ${renderBar(2)}`;
         case 'compacting':
             return `compact ${renderBar(STAGE_CELL_COMPACTING)}`;
-        // Slice 2026-09-12-compact-band-policy: a registered trigger that has
         // not fired is NOT progress. Rendering a bar would imply movement
         // that is not happening, so `armed` deliberately renders no bar at
         // all — the label states what is true and what would change it.

package/dist/services/config/config-rollback.js

@@ -15,7 +15,6 @@ export function planRollback() {
 export function executeRollback(opts) {
     const plan = planRollback();
     if (!plan.available) {
-        // rid 2026-09-13-two-decisions ①: a machine that never migrated has no
         // `.bak`, and that is its normal state — `--apply` on such a machine is
         // "nothing to roll back", not a failure. Returned instead of thrown so the
         // exit status and the `available` key agree on every path; see

package/dist/services/config/config-safety.d.ts

@@ -29,7 +29,6 @@ export declare function resolveProjectRootForConfig(startPath: string): string;
  */
 export declare function resolveCanonicalProjectRoot(startPath: string): string;
 /**
- * Slice rid-statusline-stale-ux AC-2 + P1 H1 option A: strict
  * canonicalization for use in trust-boundary paths (e.g.
  * `peaks session primer`).
  *

package/dist/services/config/config-safety.js

@@ -139,7 +139,6 @@ export function resolveCanonicalProjectRoot(startPath) {
     return start;
 }
 /**
- * Slice rid-statusline-stale-ux AC-2 + P1 H1 option A: strict
  * canonicalization for use in trust-boundary paths (e.g.
  * `peaks session primer`).
  *

package/dist/services/config/config-service.d.ts

@@ -18,7 +18,6 @@ export declare function isConfigLayer(value: string): value is ConfigLayer;
 /**
  * Machine-scoped context-window override key, the config twin of the
  * `PEAKS_CONTEXT_WINDOW_TOKENS` env var (slice
- * 2026-09-09-context-window-override). Written with
  * `peaks config set --key context.windowTokens --value <positive-int>`
  * (user layer) so the user pins it once instead of exporting an env var
  * in every shell.

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

@@ -200,7 +200,6 @@ export function isConfigLayer(value) {
 /**
  * Machine-scoped context-window override key, the config twin of the
  * `PEAKS_CONTEXT_WINDOW_TOKENS` env var (slice
- * 2026-09-09-context-window-override). Written with
  * `peaks config set --key context.windowTokens --value <positive-int>`
  * (user layer) so the user pins it once instead of exporting an env var
  * in every shell.

package/dist/services/config/model-routing.d.ts

@@ -1,6 +1,5 @@
 import { type ModelProviderConfig, type PeaksConfig } from './config-types.js';
 /**
- * Slice 2026-07-09 add-zcode-adapter (A.3): replaces the legacy
  * `STRONGEST_MODEL_ID = 'claude-opus-4-7'` constant (removed) with a dynamic
  * resolver. The strongest planner/reviewer model is now derived
  * from the active config instead of being hardcoded to a specific
@@ -24,7 +23,6 @@ export declare function getStrongestModelId(config?: {
     model?: unknown;
 }): string;
 /**
- * Slice 2026-07-09 add-zcode-adapter (Slice C, C.4): async variant
  * of `getStrongestModelId`. Same precedence for layers 1 + 2, but
  * layer 2.5 is the IDE's runtime probe (`detectCurrentIdeModel`)
  * which is consulted BEFORE the env-var back-compat fallback.
@@ -53,7 +51,6 @@ export declare function getStrongestModelIdAsync(config?: {
 }, runtimeProbeDisabled?: boolean): Promise<string>;
 export declare function getConfiguredExecutionModelId(providers: ModelProviderConfig | undefined): string;
 /**
- * Slice 015 — typed exception for "no provider has a configured model".
  * Lives next to its throw site so a downstream `instanceof` check survives
  * any tree-shaking. CLI catch sites map this to the `INVALID_PROVIDERS`
  * envelope code via `_cli-error-envelope.mapServiceError`.

package/dist/services/config/model-routing.js

@@ -1,6 +1,5 @@
 import { detectCurrentIdeModel } from '../ide/current-model-detector.js';
 /**
- * Slice 2026-07-09 add-zcode-adapter (A.3): replaces the legacy
  * `STRONGEST_MODEL_ID = 'claude-opus-4-7'` constant (removed) with a dynamic
  * resolver. The strongest planner/reviewer model is now derived
  * from the active config instead of being hardcoded to a specific
@@ -25,12 +24,10 @@ export function getStrongestModelId(config) {
     const fromConfig = typeof raw === 'string' ? raw.trim() : undefined;
     if (fromConfig)
         return fromConfig;
-    // Slice 2026-07-09: back-compat fallback for test fixtures that
     // pre-date this slice (SC §3.4 strategy A env-var override).
     return process.env.PEAKS_STRONGEST_MODEL_DEFAULT ?? 'claude-opus-4-7';
 }
 /**
- * Slice 2026-07-09 add-zcode-adapter (Slice C, C.4): async variant
  * of `getStrongestModelId`. Same precedence for layers 1 + 2, but
  * layer 2.5 is the IDE's runtime probe (`detectCurrentIdeModel`)
  * which is consulted BEFORE the env-var back-compat fallback.
@@ -86,7 +83,6 @@ export function getConfiguredExecutionModelId(providers) {
     return configuredModel;
 }
 /**
- * Slice 015 — typed exception for "no provider has a configured model".
  * Lives next to its throw site so a downstream `instanceof` check survives
  * any tree-shaking. CLI catch sites map this to the `INVALID_PROVIDERS`
  * envelope code via `_cli-error-envelope.mapServiceError`.
@@ -101,7 +97,6 @@ export function getEconomyAwareExecutionModelId(config) {
     // Slice 2.0.1-bug1 round 3: economy is the project default. Treat undefined as enabled
     // (matches the pre-slice implicit default from DEFAULT_CONFIG.economyMode = true). Only an
     // explicit `economyMode === false` switches execution to the strongest planner/reviewer
-    // model (resolved dynamically per Slice 2026-07-09 add-zcode-adapter A.3).
     return config.economyMode !== false
         ? getConfiguredExecutionModelId(config.providers)
         : getStrongestModelId(config);

package/dist/services/container/container-lease.d.ts

@@ -1,7 +1,6 @@
 /**
  * container-lease — pure-function lease store for `peaks container spawn`.
  *
- * Slice 2026-07-29-worktree-l2-extended Part 12 (L4 container
  * runtime). Mirrors the design of `worktree-lease.ts` (Part 1):
  * - Pure function module: every helper takes the lease
  *   directory path as an argument and returns structured data.

package/dist/services/container/container-lease.js

@@ -1,7 +1,6 @@
 /**
  * container-lease — pure-function lease store for `peaks container spawn`.
  *
- * Slice 2026-07-29-worktree-l2-extended Part 12 (L4 container
  * runtime). Mirrors the design of `worktree-lease.ts` (Part 1):
  * - Pure function module: every helper takes the lease
  *   directory path as an argument and returns structured data.

package/dist/services/context/artifact-meta.js

@@ -1,5 +1,4 @@
 /**
- * G7 — sub-agent context minimal-occupation (RL-17..RL-22, AC-38..AC-43).
  *
  * `ArtifactMeta` is what the dispatch record stores per sub-agent artifact
  * instead of the full content. The `contentInlined: false` literal is the

package/dist/services/context/auto-compact-dispatcher-input.d.ts

@@ -14,7 +14,6 @@ export interface DispatchIdeCompactInput {
     /** Spawn timeout (ms). Default 30s — Claude Code `/compact` is sync. */
     readonly timeoutMs?: number | undefined;
     /**
-     * Slice 2026-06-28-code-mode-bypass-fix (defect #4): which session
      * the compact should target. Default `'main'` — the orchestrator
      * (peaks-code body) runs in the main-session Claude Code window and
      * wants to compress *its* context, not a sub-agent's. Sub-agent
@@ -23,13 +22,11 @@ export interface DispatchIdeCompactInput {
      *
      * Behaviour matrix, keyed on the ADAPTER'S DECLARED pathway only
      * — never on the adapter's name (slice
-     * 2026-09-12-auto-compact-vendor-neutrality):
      *   - target='main'     → llm-self-compress (write intent; main LLM
      *                          fires its compact command on its next turn).
      *   - target='sub-agent'→ shell-exec stub (DEPRECATED — no host
      *                          CLI spawn; returns envelope with
      *                          `pathway: 'shell-exec'` for legacy
-     *                          contract only — see rid-031).
      * An adapter with no registered `compact` profile returns noop for
      * BOTH targets; an adapter whose profile serves the main session is
      * dispatched regardless of which IDE it is.