peaks-loop 4.0.54 → 4.1.0

package/dist/services/memory/project-memory-service/parsers/frontmatter.d.ts

@@ -1,27 +1,5 @@
-import type { ExtractedProjectMemory, MemoryBlockParse, ProjectMemoryKind, StoredProjectMemory } from '../types.js';
-/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
- *  tuple so the parser cannot drift from the union type / tier map. */
-export declare const VALID_MEMORY_KINDS: ReadonlySet<ProjectMemoryKind>;
-/** Exported for guard tests + tooling that needs to enumerate the accepted
- *  set (CLI help text, `--kind` validation) without duplicating the literal. */
-export declare const VALID_PROJECT_MEMORY_KINDS: readonly ProjectMemoryKind[];
-export declare function slugify(title: string): string;
-/**
- * Single implementation of the extract-path block parse. Returns a
- * discriminated result so the caller can say WHY a found block was rejected.
- *
- * The precondition order mirrors the original combined `if` exactly
- * (separator → title → kind present → kind valid → body non-empty), so the
- * accepted set is bit-for-bit what it always was; only the explanation is new.
- */
-export declare function parseBlockResult(block: string, sourceArtifact: string): MemoryBlockParse;
-/**
- * `null`-on-failure projection of `parseBlockResult`. Kept because callers
- * (and the parser's own contract) consume a plain nullable value; both views
- * come from the one implementation above, so they cannot diverge.
- */
-export declare function parseBlock(block: string, sourceArtifact: string): ExtractedProjectMemory | null;
-export declare function renderMemoryFile(memory: ExtractedProjectMemory): string;
+import type { ProjectMemoryKind, StoredProjectMemory } from '../types.js';
+export { parseBlock, parseBlockResult, renderMemoryFile, slugify, VALID_MEMORY_KINDS, VALID_PROJECT_MEMORY_KINDS } from './frontmatter-parse.js';
 /**
  * Where a stored memory file's `kind` came from. `'none'` means the file
  * has no resolvable kind (no `metadata.type`, no `kind:`, no `type:`, or

package/dist/services/memory/project-memory-service/parsers/frontmatter.js

@@ -20,82 +20,12 @@
 // `slugify` helper used to derive filenames from titles.
 // ---------------------------------------------------------------------------
 import { basename } from 'node:path';
-import { PROJECT_MEMORY_KINDS } from '../types.js';
-/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
- *  tuple so the parser cannot drift from the union type / tier map. */
-export const VALID_MEMORY_KINDS = new Set(PROJECT_MEMORY_KINDS);
-/** Exported for guard tests + tooling that needs to enumerate the accepted
- *  set (CLI help text, `--kind` validation) without duplicating the literal. */
-export const VALID_PROJECT_MEMORY_KINDS = PROJECT_MEMORY_KINDS;
-export function slugify(title) {
-    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-    return slug.length > 0 ? slug : 'project-memory';
-}
-/**
- * Single implementation of the extract-path block parse. Returns a
- * discriminated result so the caller can say WHY a found block was rejected.
- *
- * The precondition order mirrors the original combined `if` exactly
- * (separator → title → kind present → kind valid → body non-empty), so the
- * accepted set is bit-for-bit what it always was; only the explanation is new.
- */
-export function parseBlockResult(block, sourceArtifact) {
-    const normalizedBlock = block.replace(/\r\n/g, '\n');
-    const separatorIndex = normalizedBlock.indexOf('\n---\n');
-    if (separatorIndex < 0) {
-        return { ok: false, reason: 'missing-separator', detail: "block header is not followed by a '---' separator line" };
-    }
-    const header = normalizedBlock.slice(0, separatorIndex).trim();
-    const body = normalizedBlock.slice(separatorIndex + '\n---\n'.length).trim();
-    const fields = new Map();
-    for (const line of header.split('\n')) {
-        const [key, ...valueParts] = line.split(':');
-        const normalizedKey = key?.trim();
-        const value = valueParts.join(':').trim();
-        if (normalizedKey && value) {
-            fields.set(normalizedKey, value);
-        }
-    }
-    const title = fields.get('title')?.trim();
-    const kind = fields.get('kind')?.trim();
-    if (!title) {
-        return { ok: false, reason: 'missing-title', detail: "block header has no non-empty 'title:' field" };
-    }
-    if (!kind) {
-        return { ok: false, reason: 'missing-kind', detail: "block header has no non-empty 'kind:' field" };
-    }
-    if (!VALID_MEMORY_KINDS.has(kind)) {
-        return { ok: false, reason: 'unknown-kind', detail: `block declares kind '${kind}', which is not an accepted memory kind` };
-    }
-    if (body.length === 0) {
-        return { ok: false, reason: 'empty-body', detail: 'block body is empty' };
-    }
-    return { ok: true, memory: { title, kind, body, sourceArtifact } };
-}
-/**
- * `null`-on-failure projection of `parseBlockResult`. Kept because callers
- * (and the parser's own contract) consume a plain nullable value; both views
- * come from the one implementation above, so they cannot diverge.
- */
-export function parseBlock(block, sourceArtifact) {
-    const parsed = parseBlockResult(block, sourceArtifact);
-    return parsed.ok ? parsed.memory : null;
-}
-export function renderMemoryFile(memory) {
-    const name = slugify(memory.title);
-    return [
-        '---',
-        `name: ${name}`,
-        `description: ${memory.title}`,
-        'metadata:',
-        `  type: ${memory.kind}`,
-        `  sourceArtifact: ${memory.sourceArtifact}`,
-        '---',
-        '',
-        memory.body,
-        ''
-    ].join('\n');
-}
+import { VALID_MEMORY_KINDS } from './frontmatter-parse.js';
+// The kind allow-list, the `slugify` helper, and the extract-path block
+// parser / renderer now live in `./frontmatter-parse.ts`. Re-exported here so
+// the `index.ts` barrel and `markdown-pure.ts` keep resolving them from
+// `./parsers/frontmatter.js` unchanged.
+export { parseBlock, parseBlockResult, renderMemoryFile, slugify, VALID_MEMORY_KINDS, VALID_PROJECT_MEMORY_KINDS } from './frontmatter-parse.js';
 /**
  * Resolve the peaks memory kind from a stored memory file's frontmatter.
  *
@@ -170,11 +100,21 @@ export function parseMemoryFrontmatter(content) {
     const normalized = content.replace(/\r\n/g, '\n');
     const head = normalized.slice(leadingCommentPrefixLength(normalized));
     if (!head.startsWith('---\n')) {
-        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+        return {
+            hasFrontmatter: false,
+            kind: { kind: null, source: 'none', rawKind: null },
+            frontmatter: '',
+            body: normalized.trim()
+        };
     }
     const endIndex = head.indexOf('\n---\n', 4);
     if (endIndex < 0) {
-        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+        return {
+            hasFrontmatter: false,
+            kind: { kind: null, source: 'none', rawKind: null },
+            frontmatter: '',
+            body: normalized.trim()
+        };
     }
     const frontmatter = head.slice(4, endIndex);
     const body = head.slice(endIndex + '\n---\n'.length).trim();
@@ -228,7 +168,16 @@ export function parseMemoryFrontmatter(content) {
             break;
         }
     }
-    return { hasFrontmatter: true, frontmatter, ...(name !== undefined ? { name } : {}), ...(titleField !== undefined ? { title: titleField } : {}), ...(description !== undefined ? { description } : {}), ...(sourceArtifact !== undefined ? { sourceArtifact } : {}), kind, body };
+    return {
+        hasFrontmatter: true,
+        frontmatter,
+        ...(name !== undefined ? { name } : {}),
+        ...(titleField !== undefined ? { title: titleField } : {}),
+        ...(description !== undefined ? { description } : {}),
+        ...(sourceArtifact !== undefined ? { sourceArtifact } : {}),
+        kind,
+        body
+    };
 }
 /**
  * Deterministic name fallback chain for the read path:

package/dist/services/memory/project-memory-service/parsers/markdown-pure.js

@@ -60,7 +60,9 @@ export function summarizeMemoryBody(body) {
         .replace(/^\s*[-*+]\s+/gm, '')
         .replace(/\n+/g, ' ')
         .trim();
-    const sentences = cleaned.split(/(?<=[.!?])\s+/).filter((s) => s.length > MIN_BODY_SENTENCE_LENGTH && !/^\[.+\]$/.test(s));
+    const sentences = cleaned
+        .split(/(?<=[.!?])\s+/)
+        .filter((s) => s.length > MIN_BODY_SENTENCE_LENGTH && !/^\[.+\]$/.test(s));
     if (sentences.length === 0) {
         return cleaned.slice(0, MAX_DESCRIPTION_LENGTH) || 'Project memory';
     }
@@ -101,7 +103,10 @@ export function extractStableProjectMemoriesWithDiagnostics(content, sourceArtif
             memories.push(parsed.memory);
         }
         else {
-            drops.push({ index: start, drop: { sourceArtifact, reason: parsed.reason, detail: parsed.detail } });
+            drops.push({
+                index: start,
+                drop: { sourceArtifact, reason: parsed.reason, detail: parsed.detail }
+            });
         }
         searchStart = end + END_MARKER.length;
     }
@@ -120,7 +125,14 @@ export function extractStableProjectMemoriesWithDiagnostics(content, sourceArtif
         const index = match.index ?? 0;
         if (locatedRanges.some(([from, to]) => index >= from && index < to))
             continue;
-        drops.push({ index, drop: { sourceArtifact, reason: 'unrecognized-marker', detail: describeUnrecognizedMarker(found) } });
+        drops.push({
+            index,
+            drop: {
+                sourceArtifact,
+                reason: 'unrecognized-marker',
+                detail: describeUnrecognizedMarker(found)
+            }
+        });
     }
     drops.sort((left, right) => left.index - right.index);
     return {

package/dist/services/memory/project-memory-service/store/atomic-write.js

@@ -77,20 +77,32 @@ const SENSITIVE_MEMORY_REFUSAL = 'Refusing to store sensitive memory content';
  * predicate exists to end.
  */
 const SENSITIVE_PROSE_TERMS = new Set([
-    'apikey', 'apikeys',
-    'accesskey', 'accesskeys',
-    'privatekey', 'privatekeys',
-    'secretkey', 'secretkeys',
-    'accesstoken', 'accesstokens',
-    'authtoken', 'authtokens',
-    'authkey', 'authkeys',
-    'refreshtoken', 'refreshtokens',
-    'token', 'tokens',
-    'secret', 'secrets',
-    'password', 'passwords',
+    'apikey',
+    'apikeys',
+    'accesskey',
+    'accesskeys',
+    'privatekey',
+    'privatekeys',
+    'secretkey',
+    'secretkeys',
+    'accesstoken',
+    'accesstokens',
+    'authtoken',
+    'authtokens',
+    'authkey',
+    'authkeys',
+    'refreshtoken',
+    'refreshtokens',
+    'token',
+    'tokens',
+    'secret',
+    'secrets',
+    'password',
+    'passwords',
     'passwd',
     'bearer',
-    'credential', 'credentials'
+    'credential',
+    'credentials'
 ]);
 /** A lower→upper transition: the boundary between the words of `apiKey`. */
 const CAMEL_CASE_BOUNDARY = /([a-z0-9])([A-Z])/g;
@@ -125,16 +137,16 @@ export function findSensitiveMemoryTitleTerm(title) {
     return null;
 }
 export function hasSensitiveMemoryContent(content) {
-    return /(?:api[_-]?key|token|secret|password|credential|bearer)\s*[:=]/i.test(content)
-        || /\bauthorization\s*:\s*bearer\s+\S+/i.test(content)
-        || /\bbearer\s+[A-Za-z0-9._~+/=-]{12,}\b/i.test(content)
-        || /\bsk-[A-Za-z0-9_-]{6,}\b/.test(content)
-        || /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/.test(content)
-        || /\bgithub_pat_[A-Za-z0-9_]{20,}\b/.test(content)
-        || /\bglpat-[A-Za-z0-9_-]{20,}\b/.test(content)
-        || /\bAKIA[0-9A-Z]{16}\b/.test(content)
-        || /-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(content)
-        || /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(content);
+    return (/(?:api[_-]?key|token|secret|password|credential|bearer)\s*[:=]/i.test(content) ||
+        /\bauthorization\s*:\s*bearer\s+\S+/i.test(content) ||
+        /\bbearer\s+[A-Za-z0-9._~+/=-]{12,}\b/i.test(content) ||
+        /\bsk-[A-Za-z0-9_-]{6,}\b/.test(content) ||
+        /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/.test(content) ||
+        /\bgithub_pat_[A-Za-z0-9_]{20,}\b/.test(content) ||
+        /\bglpat-[A-Za-z0-9_-]{20,}\b/.test(content) ||
+        /\bAKIA[0-9A-Z]{16}\b/.test(content) ||
+        /-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(content) ||
+        /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(content));
 }
 /**
  * The refusal `assertSafeMemory` raises: the check that fired and the term it

package/dist/services/memory/project-memory-service/store/paths.js

@@ -93,7 +93,8 @@ export function safeRealpath(path) {
     try {
         return realpathSync(path);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }

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

@@ -1,34 +1,6 @@
-/**
- * Canonical memory-kind vocabulary — the single source of truth.
- *
- * The union type, the accepted-kind set in the frontmatter parser, the
- * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
- * `--kind` help text all derive from this tuple. Adding a kind here is the
- * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
- *
- * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
- * unchanged. The 13 appended kinds were observed on disk with real values
- * that the index schema rejected (`peaks memory reindex` reported them as
- * `unrecognized kind value`). Accepting them moves those files into the
- * index; files with no kind field at all stay reported as unclassified.
- */
-export declare const PROJECT_MEMORY_KINDS: readonly ["project", "rule", "decision", "reference", "feedback", "convention", "module", "lesson", "bug", "investigation", "technical-pattern", "project-rule", "design", "handoff", "session-handoff", "project-todo", "publish-closure", "project-closure", "slice-closure", "slice-pilot-findings", "sediment"];
-export type ProjectMemoryKind = (typeof PROJECT_MEMORY_KINDS)[number];
-/** Hot kinds keep their body in the always-available index; warm kinds are
- *  indexed with the same entry shape but read on demand. */
-export type MemoryKindTier = 'hot' | 'warm';
-/**
- * Hot/warm tier per kind. Insertion order IS the deterministic section order
- * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
- * so this object's key order is load-bearing — append new kinds at the end
- * of their tier block rather than reshuffling existing entries.
- *
- * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
- * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
- */
-export declare const MEMORY_KIND_TIER: Record<ProjectMemoryKind, MemoryKindTier>;
-export declare const HOT_MEMORY_KINDS: readonly ProjectMemoryKind[];
-export declare const WARM_MEMORY_KINDS: readonly ProjectMemoryKind[];
+import type { ProjectMemoryKind } from './memory-kinds.js';
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './memory-kinds.js';
+export type { MemoryKindTier, ProjectMemoryKind } from './memory-kinds.js';
 export type ExtractedProjectMemory = {
     title: string;
     kind: ProjectMemoryKind;

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

@@ -6,79 +6,4 @@
 // from here, and the top-level `index.ts` re-exports them for back-compat
 // with downstream callers (CLI commands, audit writers, presence service).
 // ---------------------------------------------------------------------------
-/**
- * Canonical memory-kind vocabulary — the single source of truth.
- *
- * The union type, the accepted-kind set in the frontmatter parser, the
- * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
- * `--kind` help text all derive from this tuple. Adding a kind here is the
- * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
- *
- * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
- * unchanged. The 13 appended kinds were observed on disk with real values
- * that the index schema rejected (`peaks memory reindex` reported them as
- * `unrecognized kind value`). Accepting them moves those files into the
- * index; files with no kind field at all stay reported as unclassified.
- */
-export const PROJECT_MEMORY_KINDS = [
-    // Original 8 (pre-2026-09-10).
-    'project',
-    'rule',
-    'decision',
-    'reference',
-    'feedback',
-    'convention',
-    'module',
-    'lesson',
-    // Slice E expansion — observed on-disk values, hot tier.
-    'bug',
-    'investigation',
-    'technical-pattern',
-    'project-rule',
-    // Slice E expansion — observed on-disk values, warm tier.
-    'design',
-    'handoff',
-    'session-handoff',
-    'project-todo',
-    'publish-closure',
-    'project-closure',
-    'slice-closure',
-    'slice-pilot-findings',
-    'sediment'
-];
-/**
- * Hot/warm tier per kind. Insertion order IS the deterministic section order
- * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
- * so this object's key order is load-bearing — append new kinds at the end
- * of their tier block rather than reshuffling existing entries.
- *
- * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
- * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
- */
-export const MEMORY_KIND_TIER = {
-    // hot — full body kept in the index
-    feedback: 'hot',
-    decision: 'hot',
-    rule: 'hot',
-    convention: 'hot',
-    module: 'hot',
-    lesson: 'hot',
-    bug: 'hot',
-    investigation: 'hot',
-    'technical-pattern': 'hot',
-    'project-rule': 'hot',
-    // warm — same entry shape, read on demand
-    project: 'warm',
-    reference: 'warm',
-    design: 'warm',
-    handoff: 'warm',
-    'session-handoff': 'warm',
-    'project-todo': 'warm',
-    'publish-closure': 'warm',
-    'project-closure': 'warm',
-    'slice-closure': 'warm',
-    'slice-pilot-findings': 'warm',
-    sediment: 'warm'
-};
-export const HOT_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'hot');
-export const WARM_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'warm');
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './memory-kinds.js';

package/dist/services/migrate-skill-name/migrate.js

@@ -79,7 +79,7 @@ export function migrateSkillName(opts) {
         keyValueReplacements: 0,
         stringReplacements: 0,
         skipped: [...SKIP_DIRS],
-        errors: [],
+        errors: []
     };
     for (const file of files) {
         if (shouldSkip(opts.projectRoot, file))

package/dist/services/migrate-skill-name/schema.js

@@ -21,5 +21,5 @@ export const MigrateResultSchema = z.object({
     keyValueReplacements: z.number().int().gte(0),
     stringReplacements: z.number().int().gte(0),
     skipped: z.array(z.string()),
-    errors: z.array(z.string()),
+    errors: z.array(z.string())
 });

package/dist/services/mode/mode-enforcement.js

@@ -60,7 +60,8 @@ export async function requireUserConfirmation(options) {
     // For assisted/strict, env var is ignored unless --force-confirm is also set
     if (process.env.PEAKS_AUTO_CONFIRM === '1') {
         if (options.forceConfirm) {
-            console.error(// TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
+            console.error(
+            // TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
             `[WARNING] --force-confirm used in ${mode} mode. ` +
                 'This bypasses user confirmation. Use with caution.');
             return;
@@ -69,7 +70,8 @@ export async function requireUserConfirmation(options) {
     }
     // --force-confirm without env var
     if (options.forceConfirm) {
-        console.error(// TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
+        console.error(
+        // TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
         `[WARNING] --force-confirm used in ${mode} mode. ` +
             'This bypasses user confirmation. Use with caution.');
         return;

package/dist/services/mode/mode-status-service.d.ts

@@ -59,16 +59,34 @@ export interface ModeStatus {
  */
 export declare function resolvePresenceMode(projectRoot: string): ResolvedPresenceMode;
 /**
- * Resolve the auto-compact profile from the MODE, not from the 24h
- * state machine. `24h` mode → `partial` (earlier thresholds for
- * long-run sessions); every other mode → `standard`.
+ * Resolve the auto-compact profile: `partial` (earlier thresholds for
+ * long-run sessions) or `standard`.
  *
- * Slice 2026-09-09-mode-consolidation: this replaced the previous
- * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
- * long-run *phase*; the mode is the autonomy level the user (or the
- * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
- * session keeps the partial profile even while it is in
- * `WAITING_USER`, which is the correct long-run behaviour.
+ * Two sources answer "is this a 24h long run?", and EITHER is enough:
+ *
+ *   1. the PRESENCE MODE is `24h` — the autonomy level the user (or
+ *      the T3/T4 auto-engage) selected; or
+ *   2. the 24h STATE MACHINE is engaged (`24H_ACTIVE` /
+ *      `WAITING_USER`) — the durable, session-scoped record.
+ *
+ * Why both (slice H3, rid=h3-24h-threshold-not-wired): source 1 alone
+ * is not reliable. The mode lives on a per-caller, per-workflow
+ * presence lease, and `applyAutoEngagePresenceMode` can only stamp
+ * leases that are already in flight — entering `24H_ACTIVE` with no
+ * in-flight lease fails closed as `{ applied: false, reason:
+ * 'no-in-flight-lease' }`. A fresh lease is also written without a
+ * mode (`workflow-presence-lifecycle.initWorkflow`), so a successful
+ * stamp does not survive the next skill workflow either. The observed
+ * consequence was a `24H_ACTIVE` session resolving to `standard` and
+ * auto-compacting LATER than a plain session, the opposite of the
+ * documented contract.
+ *
+ * The union is a superset of both the pre-2026-09-09 mapping (state
+ * machine) and the 2026-09-09-mode-consolidation mapping (presence
+ * mode): keep partial while the mode says `24h` even in
+ * `WAITING_USER`, and keep it when only the state machine knows.
+ * Nothing that resolved to `partial` before resolves to `standard`
+ * now; a project with no 24h run is byte-identical to before.
  */
 export declare function resolveAutoCompactProfile(projectRoot: string): AutoCompactMode;
 /**

package/dist/services/mode/mode-status-service.js

@@ -46,19 +46,65 @@ export function resolvePresenceMode(projectRoot) {
     }
 }
 /**
- * Resolve the auto-compact profile from the MODE, not from the 24h
- * state machine. `24h` mode → `partial` (earlier thresholds for
- * long-run sessions); every other mode → `standard`.
+ * The 24h state-machine states in which the long run is ENGAGED.
  *
- * Slice 2026-09-09-mode-consolidation: this replaced the previous
- * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
- * long-run *phase*; the mode is the autonomy level the user (or the
- * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
- * session keeps the partial profile even while it is in
- * `WAITING_USER`, which is the correct long-run behaviour.
+ * `24H_ACTIVE` is the run itself; `WAITING_USER` is a pause *inside*
+ * it (the run is still on — the user just has to answer). `BRAINSTORM`
+ * / `USER_CONFIRM` precede the run, `HANDOFF` ends it, `IDLE` means it
+ * never started.
+ */
+const ENGAGED_24H_STATES = new Set(['24H_ACTIVE', 'WAITING_USER']);
+/**
+ * Fail-soft read of the bound session's 24h state machine: `true` when
+ * the long run is engaged. Every degradation (no session, missing or
+ * malformed snapshot) reads as `false` so a non-24h project is
+ * untouched by this signal.
+ */
+function is24hRunEngaged(projectRoot) {
+    try {
+        const sessionId = getCurrentSessionId(projectRoot);
+        if (sessionId === null)
+            return false;
+        return ENGAGED_24H_STATES.has(read24hState(projectRoot, sessionId).state);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the auto-compact profile: `partial` (earlier thresholds for
+ * long-run sessions) or `standard`.
+ *
+ * Two sources answer "is this a 24h long run?", and EITHER is enough:
+ *
+ *   1. the PRESENCE MODE is `24h` — the autonomy level the user (or
+ *      the T3/T4 auto-engage) selected; or
+ *   2. the 24h STATE MACHINE is engaged (`24H_ACTIVE` /
+ *      `WAITING_USER`) — the durable, session-scoped record.
+ *
+ * Why both (slice H3, rid=h3-24h-threshold-not-wired): source 1 alone
+ * is not reliable. The mode lives on a per-caller, per-workflow
+ * presence lease, and `applyAutoEngagePresenceMode` can only stamp
+ * leases that are already in flight — entering `24H_ACTIVE` with no
+ * in-flight lease fails closed as `{ applied: false, reason:
+ * 'no-in-flight-lease' }`. A fresh lease is also written without a
+ * mode (`workflow-presence-lifecycle.initWorkflow`), so a successful
+ * stamp does not survive the next skill workflow either. The observed
+ * consequence was a `24H_ACTIVE` session resolving to `standard` and
+ * auto-compacting LATER than a plain session, the opposite of the
+ * documented contract.
+ *
+ * The union is a superset of both the pre-2026-09-09 mapping (state
+ * machine) and the 2026-09-09-mode-consolidation mapping (presence
+ * mode): keep partial while the mode says `24h` even in
+ * `WAITING_USER`, and keep it when only the state machine knows.
+ * Nothing that resolved to `partial` before resolves to `standard`
+ * now; a project with no 24h run is byte-identical to before.
  */
 export function resolveAutoCompactProfile(projectRoot) {
-    return resolvePresenceMode(projectRoot).mode === '24h' ? 'partial' : 'standard';
+    if (resolvePresenceMode(projectRoot).mode === '24h')
+        return 'partial';
+    return is24hRunEngaged(projectRoot) ? 'partial' : 'standard';
 }
 /**
  * Assemble the full stacked status. `sessionId` defaults to the
@@ -95,6 +141,12 @@ export function resolveModeStatus(input) {
             jobMode = false;
         }
     }
+    // Delegate rather than re-derive `is24h ? 'partial' : 'standard'`: the
+    // profile has a second source (the 24h state machine), and a local
+    // copy of the old one-source rule would make `peaks code mode status`
+    // advertise a different profile than the one `peaks code
+    // auto-compact` actually applies.
+    const autoCompactProfile = resolveAutoCompactProfile(projectRoot);
     return {
         mode: presence.mode,
         skill: presence.skill,
@@ -102,7 +154,7 @@ export function resolveModeStatus(input) {
         is24h,
         h24State,
         jobMode,
-        autoCompactProfile: is24h ? 'partial' : 'standard',
-        autoCompactThresholds: AUTO_COMPACT_THRESHOLDS[is24h ? 'partial' : 'standard']
+        autoCompactProfile,
+        autoCompactThresholds: AUTO_COMPACT_THRESHOLDS[autoCompactProfile]
     };
 }

package/dist/services/observability/aggregation-helpers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `src/services/observability/aggregation-helpers.ts`
+ *
+ * The event-detail readers the aggregations in `aggregation.ts` are built on
+ * (category test, `detail` field extraction, timestamp difference), the
+ * per-slice repair-cycle count, and the two event-source helpers the CLI
+ * calls. Moved verbatim (wave 3, file-size cap campaign) so the aggregation
+ * module stays under the 300 raw-line cap. The first four were module-private
+ * before the move and are NOT re-exported from `aggregation.ts`; the two
+ * event-source helpers were public and are re-exported there, so that
+ * module's public surface is unchanged.
+ */
+import { type ObservabilityEvent } from './observability-service.js';
+export declare function isSliceTransition(event: ObservabilityEvent): event is ObservabilityEvent & {
+    sliceRid: string;
+};
+export declare function artifactRole(event: ObservabilityEvent): string;
+export declare function transitionTo(event: ObservabilityEvent): string | null;
+export declare function durationMsBetween(firstTs: string, lastTs: string): number;
+export declare function computeRepairCyclesBySlice(events: readonly ObservabilityEvent[]): Map<string, number>;
+export declare function readAllSessionEvents(projectRoot: string): ObservabilityEvent[];
+export declare function readSessionEvents(projectRoot: string, sessionId: string): ObservabilityEvent[];