peaks-loop 4.0.33 → 4.0.35

package/dist/services/doctor/doctor-service/checks/l3-memory-health.js

@@ -1,6 +1,5 @@
 /**
- * Check: `.peaks/memory/index.json` is well-formed JSON
- * (`L3:l3-memory-health`).
+ * Checks for `.peaks/memory/` health (`L3:l3-memory-health` and siblings).
  *
  * Slice 2026-06-13-repair-pre-existing-test-failures: the
  * production MemoryIndex schema (see
@@ -11,12 +10,122 @@
  *
  * When no `.peaks/memory/index.json` exists yet, the check passes
  * (fresh project — no memories have been extracted).
+ *
+ * Slice 2026-09-09-memory-system-overhaul (D) extends the check with the
+ * drift findings the original version could not see. It used to report
+ * `ok: true` for "index.json is well-formed JSON; 100 hot + 131 warm" and
+ * never looked at coverage, orphans, or unclassified files. It now emits,
+ * in addition to the unchanged well-formed-JSON assertion:
+ *
+ *   - `L3:l3-memory-coverage`      — disk files vs indexed entries (warning
+ *                                    when the gap exceeds a small threshold)
+ *   - `L3:l3-memory-orphans`       — index entries whose `sourcePath` is gone
+ *                                    (error) + disk files absent from the
+ *                                    index (warning)
+ *   - `L3:l3-memory-unclassified`  — files with no resolvable kind (warning,
+ *                                    count + first N names)
+ *
+ * All three are read-only and fail-soft: an inspection error degrades to a
+ * single warning instead of throwing, and none of them change the id or the
+ * `ok` semantics of the original `L3:l3-memory-health` assertion.
  */
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import { getErrorMessage } from 'peaks-loop-shared/result';
+import { listMarkdownFiles, MEMORY_MD_FILENAME, parseMemoryFrontmatter } from '../../../memory/project-memory-service/index.js';
+/** Warn when |disk - indexed| exceeds this. Small enough to catch real drift. */
+const COVERAGE_GAP_WARN_THRESHOLD = 2;
+/** How many offending names to inline before truncating the message. */
+const MAX_NAMES_IN_MESSAGE = 5;
+function countEntries(bucket) {
+    return Object.values(bucket ?? {}).reduce((sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0), 0);
+}
+function previewNames(names) {
+    const shown = names.slice(0, MAX_NAMES_IN_MESSAGE);
+    const suffix = names.length > shown.length ? ` (+${names.length - shown.length} more)` : '';
+    return shown.join(', ') + suffix;
+}
+function readIndexSourcePaths(indexPath) {
+    const parsed = JSON.parse(readFileSync(indexPath, 'utf8'));
+    const fromBucket = (bucket) => Object.values(bucket ?? {}).flatMap((arr) => (Array.isArray(arr) ? arr : []));
+    return [...fromBucket(parsed.hot), ...fromBucket(parsed.warm), ...(parsed.cold ?? [])];
+}
+function inspectDrift(memoryDir, memoryIndexPath, indexedCount) {
+    const checks = [];
+    const diskFiles = listMarkdownFiles(memoryDir).filter((filePath) => basename(filePath) !== MEMORY_MD_FILENAME);
+    // --- coverage ---------------------------------------------------------
+    const gap = diskFiles.length - indexedCount;
+    if (Math.abs(gap) > COVERAGE_GAP_WARN_THRESHOLD) {
+        const direction = gap > 0
+            ? `${gap} file(s) on disk are not in the index`
+            : `${-gap} index entr(ies) have no matching file`;
+        checks.push({
+            id: 'L3:l3-memory-coverage',
+            ok: false,
+            severity: 'warning',
+            message: `Memory index coverage gap: ${diskFiles.length} file(s) on disk vs ${indexedCount} indexed — ${direction}. Run \`peaks memory reindex\` for the full drift report.`
+        });
+    }
+    else {
+        checks.push({
+            id: 'L3:l3-memory-coverage',
+            ok: true,
+            message: `Memory index coverage: ${diskFiles.length} file(s) on disk, ${indexedCount} indexed (within threshold ${COVERAGE_GAP_WARN_THRESHOLD})`
+        });
+    }
+    // --- orphans (both directions) ---------------------------------------
+    const missingSources = readIndexSourcePaths(memoryIndexPath)
+        .filter((entry) => typeof entry.sourcePath !== 'string' || entry.sourcePath.length === 0 || !existsSync(entry.sourcePath))
+        .map((entry) => entry.name ?? entry.sourcePath ?? '<unnamed>')
+        .sort((left, right) => left.localeCompare(right));
+    if (missingSources.length > 0) {
+        checks.push({
+            id: 'L3:l3-memory-orphans',
+            ok: false,
+            severity: 'error',
+            message: `${missingSources.length} index entr(ies) point at a missing sourcePath: ${previewNames(missingSources)}. Run \`peaks memory reindex\` to rebuild the index.`
+        });
+    }
+    else {
+        checks.push({
+            id: 'L3:l3-memory-orphans',
+            ok: true,
+            message: 'No memory index entries point at missing files'
+        });
+    }
+    // --- unclassified -----------------------------------------------------
+    const unclassified = [];
+    for (const filePath of diskFiles) {
+        try {
+            if (parseMemoryFrontmatter(readFileSync(filePath, 'utf8')).kind.kind === null) {
+                unclassified.push(basename(filePath, '.md'));
+            }
+        }
+        catch {
+            unclassified.push(`${basename(filePath, '.md')} (unreadable)`);
+        }
+    }
+    unclassified.sort((left, right) => left.localeCompare(right));
+    if (unclassified.length > 0) {
+        checks.push({
+            id: 'L3:l3-memory-unclassified',
+            ok: false,
+            severity: 'warning',
+            message: `${unclassified.length} memory file(s) have no resolvable kind (no metadata.type / kind / type): ${previewNames(unclassified)}. Add \`metadata.type\` then run \`peaks memory reindex\`.`
+        });
+    }
+    else {
+        checks.push({
+            id: 'L3:l3-memory-unclassified',
+            ok: true,
+            message: 'Every memory file on disk has a resolvable kind'
+        });
+    }
+    return checks;
+}
 function run({ resolvedL3Root }) {
-    const memoryIndexPath = join(resolvedL3Root, '.peaks/memory/index.json');
+    const memoryDir = join(resolvedL3Root, '.peaks/memory');
+    const memoryIndexPath = join(memoryDir, 'index.json');
     if (!existsSync(memoryIndexPath)) {
         return [{
                 id: 'L3:l3-memory-health',
@@ -24,32 +133,47 @@ function run({ resolvedL3Root }) {
                 message: 'No .peaks/memory/index.json yet (no memories extracted)'
             }];
     }
+    let parsed;
     try {
         const raw = readFileSync(memoryIndexPath, 'utf8');
-        const parsed = JSON.parse(raw);
-        const schemaMarker = parsed.schema_version ?? parsed.version;
-        if (schemaMarker === undefined) {
-            return [{
-                    id: 'L3:l3-memory-health',
-                    ok: false,
-                    message: '.peaks/memory/index.json missing schema_version / version field'
-                }];
-        }
-        const hotCount = Object.values(parsed.hot ?? {}).reduce((sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0), 0);
-        const warmCount = Object.values(parsed.warm ?? {}).reduce((sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0), 0);
+        parsed = JSON.parse(raw);
+    }
+    catch (parseError) {
         return [{
                 id: 'L3:l3-memory-health',
-                ok: true,
-                message: `.peaks/memory/index.json is well-formed JSON; version=${schemaMarker}; ${hotCount} hot + ${warmCount} warm memory entries`
+                ok: false,
+                message: `.peaks/memory/index.json is not valid JSON: ${getErrorMessage(parseError)}`
             }];
     }
-    catch (parseError) {
+    const schemaMarker = parsed.schema_version ?? parsed.version;
+    if (schemaMarker === undefined) {
         return [{
                 id: 'L3:l3-memory-health',
                 ok: false,
-                message: `.peaks/memory/index.json is not valid JSON: ${getErrorMessage(parseError)}`
+                message: '.peaks/memory/index.json missing schema_version / version field'
             }];
     }
+    const hotCount = countEntries(parsed.hot);
+    const warmCount = countEntries(parsed.warm);
+    const checks = [{
+            id: 'L3:l3-memory-health',
+            ok: true,
+            message: `.peaks/memory/index.json is well-formed JSON; version=${schemaMarker}; ${hotCount} hot + ${warmCount} warm memory entries`
+        }];
+    // Drift inspection is best-effort: a scan failure must not turn a
+    // well-formed index into a hard failure.
+    try {
+        checks.push(...inspectDrift(memoryDir, memoryIndexPath, hotCount + warmCount));
+    }
+    catch (error) {
+        checks.push({
+            id: 'L3:l3-memory-coverage',
+            ok: true,
+            severity: 'warning',
+            message: `Memory drift inspection skipped: ${getErrorMessage(error)}`
+        });
+    }
+    return checks;
 }
 export const check = {
     name: 'l3-memory-health',

package/dist/services/hooks/auto-compact-hook-install.d.ts

@@ -37,7 +37,7 @@
  */
 export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -46,7 +46,7 @@ export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks compact auto";
+export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks code auto-compact";
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/hooks/auto-compact-hook-install.js

@@ -39,7 +39,7 @@ import { dirname, join } from 'node:path';
  */
 export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -48,7 +48,7 @@ export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export const AUTO_COMPACT_HOOK_COMMAND = 'peaks compact auto';
+export const AUTO_COMPACT_HOOK_COMMAND = 'peaks code auto-compact';
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/ide/adapters/claude-code-adapter.d.ts

@@ -20,6 +20,57 @@ export declare function resolveClaudeModelFromEnv(env: NodeJS.ProcessEnv | undef
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export declare function modelContextWindowTokens(model: string): number;
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export declare const CONTEXT_WINDOW_TOKENS_ENV_VAR = "PEAKS_CONTEXT_WINDOW_TOKENS";
+/**
+ * Which layer produced a resolved context window:
+ *   - `env-override`     — `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   - `config`           — `context.windowTokens` (`peaks config set`)
+ *   - `model-heuristic`  — `[1M]` suffix / `ONE_MILLION_CONTEXT_MODELS`
+ *   - `default`          — 200K safe default
+ */
+export type ContextWindowSource = 'env-override' | 'config' | 'model-heuristic' | 'default';
+export interface ContextWindowResolution {
+    readonly tokens: number;
+    readonly source: ContextWindowSource;
+}
+/** Explicit override inputs (both optional; env wins over config). */
+export interface ContextWindowOverrides {
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Raw `context.windowTokens` value (unvalidated — validated here). */
+    readonly configWindowTokens?: unknown;
+    /** Warning sink for an invalid override (defaults to `console.warn`). */
+    readonly onInvalidOverride?: ((message: string) => void) | undefined;
+}
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export declare function parseContextWindowOverride(raw: unknown): number | null;
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export declare function resolveContextWindow(model: string, overrides?: ContextWindowOverrides): ContextWindowResolution;
 export declare const CLAUDE_CODE_ADAPTER: IdeAdapter;

package/dist/services/ide/adapters/claude-code-adapter.js

@@ -161,6 +161,9 @@ export function resolveClaudeModelFromEnv(env) {
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export function modelContextWindowTokens(model) {
     const m = model.trim().toLowerCase();
@@ -174,6 +177,60 @@ export function modelContextWindowTokens(model) {
     }
     return DEFAULT_CONTEXT_WINDOW_TOKENS;
 }
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export const CONTEXT_WINDOW_TOKENS_ENV_VAR = 'PEAKS_CONTEXT_WINDOW_TOKENS';
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export function parseContextWindowOverride(raw) {
+    if (typeof raw !== 'number' && typeof raw !== 'string')
+        return null;
+    if (typeof raw === 'string' && raw.trim().length === 0)
+        return null;
+    const parsed = typeof raw === 'number' ? raw : Number(raw.trim());
+    return Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export function resolveContextWindow(model, overrides = {}) {
+    const warn = overrides.onInvalidOverride ?? ((message) => console.warn(message));
+    const envRaw = overrides.env?.[CONTEXT_WINDOW_TOKENS_ENV_VAR];
+    if (envRaw !== undefined) {
+        const parsed = parseContextWindowOverride(envRaw);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'env-override' };
+        warn(`[peaks] ${CONTEXT_WINDOW_TOKENS_ENV_VAR}="${String(envRaw)}" is not a positive integer — ignoring the override`);
+    }
+    if (overrides.configWindowTokens !== undefined) {
+        const parsed = parseContextWindowOverride(overrides.configWindowTokens);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'config' };
+        warn(`[peaks] config context.windowTokens=${JSON.stringify(overrides.configWindowTokens)} is not a positive integer — ignoring the override`);
+    }
+    const heuristic = modelContextWindowTokens(model);
+    return heuristic === DEFAULT_CONTEXT_WINDOW_TOKENS
+        ? { tokens: heuristic, source: 'default' }
+        : { tokens: heuristic, source: 'model-heuristic' };
+}
 /** A non-negative finite number, or null when the value is not numeric. */
 function numericTokenCount(value) {
     if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
@@ -277,14 +334,20 @@ function findLatestTranscriptUsage(filePath) {
     }
 }
 /**
- * Resolve the context window for a transcript usage entry. Prefers the
- * explicit `modelContextWindowTokens(model)` mapping; when the observed token
- * count contradicts it (tokens exceed the mapped window), the model must be
- * ≥1M, so bump to the 1M window.
+ * Resolve the context window for a transcript usage entry. Explicit user
+ * overrides (`resolveContextWindow`) win outright — the user pinned the
+ * number, so nothing else may contradict it. Without an explicit override,
+ * when the observed token count contradicts the heuristic window (tokens
+ * exceed it), the model must be ≥1M, so bump to the 1M window (the late
+ * rescue; it keeps the heuristic source tag, only the tokens change).
  */
-function resolveContextWindowTokens(model, contextTokens) {
-    const window = modelContextWindowTokens(model);
-    return contextTokens > window ? ONE_MILLION_CONTEXT_TOKENS : window;
+function resolveContextWindowTokens(model, contextTokens, overrides = {}) {
+    const resolved = resolveContextWindow(model, overrides);
+    if (resolved.source === 'env-override' || resolved.source === 'config')
+        return resolved;
+    return contextTokens > resolved.tokens
+        ? { tokens: ONE_MILLION_CONTEXT_TOKENS, source: resolved.source }
+        : resolved;
 }
 /**
  * Conservative transcript-estimate fallback. Recursively searches
@@ -298,9 +361,11 @@ function resolveContextWindowTokens(model, contextTokens) {
  *
  * Window model resolution is env-first: when `envModel` is present, its id
  * (which Claude Code stamps with the `[1M]` / `[200K]` suffix) drives the
- * window; otherwise the transcript `message.model` is used.
+ * window; otherwise the transcript `message.model` is used. Explicit
+ * overrides (env `PEAKS_CONTEXT_WINDOW_TOKENS` / config `context.windowTokens`)
+ * sit above both and are reported via `capacitySource`.
  */
-function readClaudeTranscriptEstimate(outerSessionId, envModel) {
+function readClaudeTranscriptEstimate(outerSessionId, envModel, overrides = {}) {
     const projectsDir = join(homedir(), '.claude', 'projects');
     const path = findTranscriptJsonl(projectsDir, outerSessionId);
     if (path === null)
@@ -309,9 +374,10 @@ function readClaudeTranscriptEstimate(outerSessionId, envModel) {
     if (latest === null)
         return null;
     const model = envModel !== undefined && envModel.trim().length > 0 ? envModel : latest.model;
-    const contextWindowTokens = resolveContextWindowTokens(model, latest.contextTokens);
+    const resolved = resolveContextWindowTokens(model, latest.contextTokens, overrides);
+    const contextWindowTokens = resolved.tokens;
     const ratio = Math.min(1, latest.contextTokens / contextWindowTokens);
-    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens };
+    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens, capacitySource: resolved.source };
 }
 /**
  * Claude Code's vendor-specific context-percent fallback, exposed as
@@ -344,13 +410,17 @@ function readContextPercentFallback(input) {
     }
     if (typeof input.outerSessionId === 'string' && input.outerSessionId.length > 0) {
         const envModel = resolveClaudeModelFromEnv(input.env);
-        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel);
+        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel, {
+            env: input.env,
+            configWindowTokens: input.configWindowTokens
+        });
         if (estimate !== null) {
             return {
                 ratio: estimate.ratio,
                 source: 'transcript-estimate',
                 rawTokens: estimate.contextTokens,
                 capacityTokens: estimate.contextWindowTokens,
+                capacitySource: estimate.capacitySource,
                 ide,
                 capturedAt
             };
@@ -401,7 +471,7 @@ export const CLAUDE_CODE_ADAPTER = {
     // Pathway = 'ide-native' (not 'shell-exec') so the dispatcher
     // routes main-session compacts through the PreToolUse hook in
     // `.claude/settings.local.json`. The hook fires
-    // `peaks compact auto` on the NEXT Bash/Task tool
+    // `peaks code auto-compact` on the NEXT Bash/Task tool
     // call from the runner, which in-band spawns `claude --compact`
     // against the CURRENT runner — not a child process (the
     // shell-exec spawn-new-claude bug documented in
@@ -412,7 +482,7 @@ export const CLAUDE_CODE_ADAPTER = {
         envVarForContextPercent: 'CLAUDE_CONTEXT_USAGE_PERCENT',
         compactCommand: 'claude --compact',
         compactPathway: 'ide-native',
-        postCompactDetectCommand: 'peaks compact auto --json',
+        postCompactDetectCommand: 'peaks code auto-compact --json',
         readContextPercentFallback
     },
     // Slice #011: standards profile. Claude Code reads its constitution at

package/dist/services/ide/ide-types.d.ts

@@ -197,7 +197,7 @@ export interface IdeCompactProfile {
     readonly compactPathway: 'shell-exec' | 'ide-native' | 'llm-self-compress' | 'noop';
     /**
      * Optional command the runner invokes post-compact to confirm
-     * ratio dropped (e.g. `peaks compact auto --json`). When omitted,
+     * ratio dropped (e.g. `peaks code auto-compact --json`). When omitted,
      * the orchestrator polls `envVarForContextPercent` directly.
      */
     readonly postCompactDetectCommand?: string;
@@ -239,6 +239,15 @@ export interface ContextPercentFallbackInput {
     readonly outerSessionId?: string | undefined;
     /** Injectable env (defaults to process.env in the reader). */
     readonly env?: NodeJS.ProcessEnv | undefined;
+    /**
+     * Raw `context.windowTokens` value from the merged config (project layer
+     * over user layer), read by the generic reader so the adapter stays free
+     * of config-path knowledge. UNVALIDATED — the adapter validates it via
+     * `parseContextWindowOverride` and warns on a bad value.
+     *
+     * Slice 2026-09-09-context-window-override.
+     */
+    readonly configWindowTokens?: unknown;
 }
 /**
  * Per-IDE standards-file location + format profile. Used by the

package/dist/services/job/job-types.d.ts

@@ -6,8 +6,8 @@ export declare const SliceStateSchema: z.ZodObject<{
         pending: "pending";
         blocked: "blocked";
         failed: "failed";
-        skipped: "skipped";
         done: "done";
+        skipped: "skipped";
         "in-progress": "in-progress";
     }>;
     commitSha: z.ZodOptional<z.ZodString>;
@@ -48,8 +48,8 @@ export declare const JobStateSchema: z.ZodObject<{
             pending: "pending";
             blocked: "blocked";
             failed: "failed";
-            skipped: "skipped";
             done: "done";
+            skipped: "skipped";
             "in-progress": "in-progress";
         }>;
         commitSha: z.ZodOptional<z.ZodString>;
@@ -118,8 +118,8 @@ export declare const JobCheckpointInputSchema: z.ZodObject<{
     sliceId: z.ZodString;
     state: z.ZodEnum<{
         failed: "failed";
-        skipped: "skipped";
         done: "done";
+        skipped: "skipped";
     }>;
     commitSha: z.ZodOptional<z.ZodString>;
     reason: z.ZodOptional<z.ZodString>;

package/dist/services/memory/memory-ingest-service.d.ts

@@ -0,0 +1,79 @@
+import type { ProjectMemoryKind } from './project-memory-service/types.js';
+export interface MemoryIngestOptions {
+    projectRoot: string;
+    /** Override the IDE-side source dir (defaults to `~/.claude/projects/<encoded>/memory`). */
+    sourceDir?: string;
+    /** Injectable home dir (tests); defaults to `os.homedir()`. */
+    homeDir?: string;
+    apply?: boolean;
+}
+export interface MemoryIngestImported {
+    name: string;
+    kind: ProjectMemoryKind;
+    sourcePath: string;
+    targetPath: string;
+}
+export interface MemoryIngestSkipped {
+    name: string;
+    sourcePath: string;
+    targetPath: string;
+}
+export interface MemoryIngestConflict {
+    name: string;
+    sourcePath: string;
+    targetPath: string;
+    reason: string;
+}
+export interface MemoryIngestNeedsClassification {
+    name: string;
+    sourcePath: string;
+    rawKind: string | null;
+    reason: string;
+}
+export interface MemoryIngestRefused {
+    name: string;
+    sourcePath: string;
+    reason: string;
+}
+export interface MemoryIngestReport {
+    apply: boolean;
+    projectRoot: string;
+    sourceDir: string;
+    sourceExists: boolean;
+    memoryDir: string;
+    scannedFiles: number;
+    imported: MemoryIngestImported[];
+    skippedIdentical: MemoryIngestSkipped[];
+    conflicts: MemoryIngestConflict[];
+    needsClassification: MemoryIngestNeedsClassification[];
+    refused: MemoryIngestRefused[];
+    writtenFiles: string[];
+    warnings: string[];
+}
+/**
+ * Claude Code encodes a project cwd into its `~/.claude/projects/<name>/`
+ * directory by replacing every non-alphanumeric character with `-`
+ * (`D:\peaks-loop` → `D--peaks-loop`). Separator-agnostic, so the same
+ * encoding holds for POSIX paths.
+ */
+export declare function encodeIdeProjectDir(projectRoot: string): string;
+/** Default IDE-side memory dir for a project: `~/.claude/projects/<encoded>/memory`. */
+export declare function defaultIdeMemoryDir(projectRoot: string, homeDir?: string): string;
+/**
+ * Rewrite a source file's frontmatter to the peaks contract: `name` pinned to
+ * the destination filename stem, and `metadata.type` set to the resolved
+ * kind. Non-contract keys (e.g. `originSessionId`, `modified`, `node_type`)
+ * are preserved verbatim so provenance survives the import; `type` / `kind`
+ * are consumed by the normalization and not duplicated.
+ */
+export declare function renderNormalizedMemory(input: {
+    stem: string;
+    kind: ProjectMemoryKind;
+    frontmatter: string;
+    body: string;
+}): string;
+/**
+ * Import IDE-side memories into `.peaks/memory/`. Always returns the full
+ * envelope; `apply` only controls whether files are actually written.
+ */
+export declare function executeMemoryIngest(options: MemoryIngestOptions): MemoryIngestReport;