peaks-loop 4.1.1 → 4.1.2

package/dist/services/comments/comment-spans.js

@@ -0,0 +1,266 @@
+// src/services/comments/comment-spans.ts
+//
+// WHERE THE COMMENTS ACTUALLY ARE, read from the text the way a lexer reads it.
+//
+// version of this reader was line-local: a line was a comment if it began with `//`, a
+// block opener, or `*`, and a code line's trailing comment was `raw.indexOf('//')`
+// guarded by a quote-count parity check. Applying the pruner to the real tree then wrote
+// a corrupted file. `feedback-promotion-service.ts` holds a one-line template literal
+// whose CONTENT starts with a double slash — it is a snippet the CLI prints for users:
+//
+//     snippet: `// src/services/code/mode-gate.ts\n// 1. Add to HardFloorCategory union…`,
+//
+// The reader saw code + trailing comment, the pruner cut at the first double slash, and
+// the result was an unterminated template literal committed into `src/`. The quote parity
+// guard could not have caught it: the text before the cut contains NO quotes at all, so
+// its count is even, and "even" looked safe. Parity of a count is not the same as knowing
+// what character you are inside of.
+//
+// So this walks the file as ONE stream with an explicit notion of where it is: code, a
+// single- or double-quoted string, a template literal (whose `${ … }` re-enters code, so
+// a nested template, or a real comment, inside an interpolation follows the same rules),
+// a regex literal, a line comment, or a block comment.
+//
+// REGEX IS NOT OPTIONAL DETAIL, and finding that out is why this file is bigger than the
+// bug it fixes. `/https?:\/\//g` — a shape this repository has a hundred files of —
+// carries a real adjacent pair of slashes, made of an escaped one next to the closing
+// delimiter. A stream that does not know it is inside a regex reads that pair as a
+// comment and would cut code through it: the same accident as the template literal above,
+// reached from a different direction. Whether a `/` opens a regex or divides is decided by
+// what could end a value before it, which is the standard test; a word is only a value if
+// it is not `return`/`typeof`/`case`/…, because `return /x/` is the one place the naive
+// version of that test is wrong.
+//
+// ONE MACHINE, TWO QUESTIONS. `commentSpans` asks "where are the comments";
+// `endsInsideLiteral` asks "does this text stop inside something open". Both run the same
+// walk below, because two copies of a state machine is the defect class this repository
+// files most often — and the second question is the one the prune proof had to learn to
+// ask: `startsWith` is true of every truncation, so it cannot tell a revealed comment
+// from a string cut in half.
+//
+// A HANDLER PER REGION, not one function of nested ifs: the first working version was a
+// 126-line loop that both `max-lines-per-function` and `complexity` refused, and they were
+// right — `HANDLERS` below is the state diagram, where a single else-chain was not.
+//
+// NOT A PARSER, AND DELIBERATELY SO: `typescript` is a devDependency, so product code
+// cannot import it without handing the shipped CLI a runtime dependency. The parity
+// between this walk and the real TypeScript lexer is asserted in
+// `tests/unit/comments/comment-scan-parity.test.ts`, which MAY use `ts` — the check lives
+// where the dependency already is, instead of the dependency following the check into
+// every user's `node_modules`.
+/**
+ * Words after which a `/` is a regex, not division. `return /x/` is the case that makes
+ * "an identifier ends a value" wrong often enough to matter.
+ */
+const VALUE_ENDING_BEFORE_REGEX = /^(?:return|typeof|instanceof|in|of|new|delete|void|throw|case|do|else|yield|await)$/;
+const char = (w, offset = 0) => w.source.charAt(w.at + offset);
+/** Report the comment that opened at `spanStart`. */
+function emitSpan(w, end, endLine) {
+    w.emit({
+        start: w.spanStart,
+        end,
+        line: w.spanLine,
+        endLine,
+        text: w.source.slice(w.spanStart, end)
+    });
+}
+/** A finished word: only a non-keyword one can end a value. */
+function endWord(w) {
+    if (w.word === '')
+        return;
+    w.afterValue = !VALUE_ENDING_BEFORE_REGEX.test(w.word);
+    w.word = '';
+}
+function inLineComment(w) {
+    if (char(w) !== '\n')
+        return;
+    emitSpan(w, w.at, w.line - 1);
+    w.region = 'code';
+    w.afterValue = false;
+}
+function inBlockComment(w) {
+    if (char(w) !== '*' || char(w, 1) !== '/')
+        return;
+    emitSpan(w, w.at + 2, w.line);
+    w.at += 1;
+    w.region = 'code';
+    w.afterValue = false;
+}
+function inString(w) {
+    const c = char(w);
+    if (c === '\\')
+        w.at += 1;
+    else if (c === (w.region === 'single' ? "'" : '"')) {
+        w.region = 'code';
+        w.afterValue = true;
+    }
+    else if (c === '\n') {
+        // An unterminated string cannot survive to a newline in valid source. Resuming as
+        // code keeps one stray quote from deciding that the rest of the FILE is a string,
+        // which is the failure mode that turns every later comment invisible.
+        w.region = 'code';
+        w.afterValue = false;
+    }
+}
+function inTemplate(w) {
+    const c = char(w);
+    if (c === '\\')
+        w.at += 1;
+    else if (c === '`') {
+        w.region = 'code';
+        w.afterValue = true;
+    }
+    else if (c === '$' && char(w, 1) === '{') {
+        w.interpolations.push(w.at);
+        w.at += 1;
+        w.region = 'code';
+        w.afterValue = false;
+    }
+}
+/** A regex, or the inside of its `[…]` class where `/` is an ordinary character. */
+function inRegex(w) {
+    const c = char(w);
+    if (c === '\\')
+        w.at += 1;
+    else if (c === '[')
+        w.region = 'class';
+    else if (c === ']' && w.region === 'class')
+        w.region = 'regex';
+    else if (c === '/' && w.region === 'regex') {
+        w.region = 'code';
+        w.afterValue = true;
+    }
+    else if (c === '\n') {
+        // No regex crosses a line, so a newline means the `/` was division after all.
+        w.region = 'code';
+        w.afterValue = false;
+    }
+}
+/** A `}` in code: it closes the innermost open `${`, and only that one. */
+function closeInterpolation(w) {
+    w.afterValue = true;
+    if (w.interpolations.length === 0)
+        return;
+    w.interpolations.pop();
+    w.region = 'template';
+}
+/** Enter a string or template region, or report that this character starts none. */
+function enterLiteral(w, c) {
+    if (c !== "'" && c !== '"' && c !== '`')
+        return false;
+    w.region = c === "'" ? 'single' : c === '"' ? 'double' : 'template';
+    w.afterValue = false;
+    return true;
+}
+/**
+ * A slash in code. A comment opens on `//` or a block opener; a lone slash is a regex
+ * exactly where a value cannot have just ended, and division everywhere else.
+ */
+function readSlash(w, next) {
+    if (next === '/' || next === '*') {
+        w.region = next === '/' ? 'line' : 'block';
+        w.spanStart = w.at;
+        w.spanLine = w.line;
+        w.afterValue = false;
+        return;
+    }
+    w.region = w.afterValue ? 'code' : 'regex';
+    w.afterValue = false;
+}
+/**
+ * What each bracket says about "has a value just ended": an opener means the next slash
+ * cannot be division, a closer means it can. A table so `inCode` stays a reader's size.
+ */
+const BRACKET_ENDS_VALUE = {
+    '(': false,
+    '[': false,
+    ')': true,
+    ']': true
+};
+function inCode(w) {
+    const c = char(w);
+    if (/[A-Za-z0-9_$]/.test(c)) {
+        w.word += c;
+        return;
+    }
+    endWord(w);
+    if (enterLiteral(w, c))
+        return;
+    if (c === '{')
+        w.afterValue = false;
+    else if (c === '}')
+        closeInterpolation(w);
+    else if (c in BRACKET_ENDS_VALUE)
+        w.afterValue = BRACKET_ENDS_VALUE[c] ?? false;
+    else if (c === '/')
+        readSlash(w, char(w, 1));
+    else if (!/\s/.test(c))
+        w.afterValue = false;
+}
+/** One handler per state. THIS TABLE IS THE STATE DIAGRAM — read the regions off it. */
+const HANDLERS = {
+    code: inCode,
+    single: inString,
+    double: inString,
+    template: inTemplate,
+    regex: inRegex,
+    class: inRegex,
+    line: inLineComment,
+    block: inBlockComment
+};
+/**
+ * Walk `source`, report every comment, and return the region the text ENDED in.
+ *
+ * The return value is what makes `endsInsideLiteral` possible without a second machine: a
+ * caller that truncated some text wants to know whether the survivor is complete.
+ */
+function walkCode(source, onComment) {
+    const w = {
+        source,
+        at: 0,
+        line: 1,
+        region: 'code',
+        afterValue: false,
+        word: '',
+        interpolations: [],
+        spanStart: 0,
+        spanLine: 1,
+        emit: onComment
+    };
+    while (w.at < source.length) {
+        // Counted BEFORE dispatch, so a line comment closing on a newline reports the line
+        // it was written on, not the one after it. A handler that consumes a second character
+        // (an escape, a `*/`) advances `at` itself and the driver's step lands past it.
+        if (source.charAt(w.at) === '\n')
+            w.line += 1;
+        HANDLERS[w.region](w);
+        w.at += 1;
+    }
+    endWord(w);
+    if (w.region === 'block' || w.region === 'line')
+        emitSpan(w, source.length, w.line);
+    return w.region;
+}
+/**
+ * Every comment in `source`, in order.
+ *
+ * `text` is sliced from the original so a caller can cut at `start` and keep the code
+ * that was already there — which is the operation the pruner must get exactly right.
+ */
+export function commentSpans(source) {
+    const spans = [];
+    walkCode(source, (span) => spans.push(span));
+    return spans;
+}
+/**
+ * Does this code stop INSIDE something open?
+ *
+ * The question the comment-only proof had to learn to ask. `original.startsWith(kept)` is
+ * true of EVERY truncation, so it cannot tell a revealed comment from a string cut in
+ * half; a prefix that ends inside a quote, a template or a regex is a different program,
+ * whatever it starts with. This is what would have refused the write that left
+ * `snippet: \`` in `src/`.
+ */
+export function endsInsideLiteral(code) {
+    return walkCode(code, () => { }) !== 'code';
+}

package/dist/services/comments/prune-apply.d.ts

@@ -49,6 +49,28 @@ export declare function actionsByFile(actions: readonly PruneAction[]): Map<stri
  * so a dry run reports the refusals a real run would hit.
  */
 export declare function proofViolations(before: readonly string[], after: readonly string[], actions: readonly PruneAction[]): string[];
+/**
+ * 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 declare function orphanedBlanks(before: readonly string[], dropped: ReadonlySet<number>): Set<number>;
 /** Apply one file's actions to its lines, in the plan's own terms. */
 export declare function pruneFileLines(lines: readonly string[], actions: readonly PruneAction[]): string[];
 /**

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

@@ -9,6 +9,7 @@
  */
 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.
  *
@@ -62,12 +63,17 @@ export function actionsByFile(actions) {
  */
 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 (dropped.has(line))
+        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
@@ -77,6 +83,13 @@ export function proofViolations(before, after, actions) {
             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)
@@ -87,14 +100,68 @@ export function proofViolations(before, after, actions) {
         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 (drop.has(line))
+        if (gone.has(line))
             return;
         if (strip.has(line)) {
             // Cut where the scan's comment text starts, not at the first `//` in the line:

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