peaks-loop 4.0.0-beta → 4.0.0-beta.10

package/dist/services/code/step-08-gate.d.ts

@@ -0,0 +1,90 @@
+/**
+ * v3.1.2 Step 0.8 — Mechanical PreToolUse gate.
+ *
+ * Wire-installed by `peaks workspace init` (extends the existing hook
+ * installer; does NOT replace the Write|Edit|MultiEdit fact-forcing
+ * bypass). The hook runs `peaks code gate-step-08 --project .` before
+ * every Bash tool call. Exit code is the load-bearing contract:
+ *
+ *   exit 0 → allow (with structured stdout describing the decision)
+ *   exit 2 → block (stderr contains the BLOCKED: ... reason)
+ *
+ * Three decision paths:
+ *
+ *   1. `job-shape.json` exists with `decision.isJob === true`.
+ *      → allow, print `{ ok, allow, mode: 'job', decision }`. When a
+ *        matching `job/<jid>/progress.json` exists, also print
+ *        `Next: slice #<N+1> of <M> (<currentSlice>)` so the LLM sees
+ *        its resume context BEFORE any Bash call lands.
+ *   2. `job-shape.json` exists with `decision.isJob === false`.
+ *      → allow, print `{ ok, allow, mode: 'single' }`.
+ *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the
+ *      source of truth, but if it never recorded a decision we run a
+ *      lightweight backup regex against the user's prompt:
+ *        /until|全部|until all done|disavow cost|不用考虑费用|all of them/i
+ *      match → block (exit 2) with the BLOCKED: stderr message.
+ *      no match → allow (exit 0) — most prompts are not Job-shaped.
+ *
+ * Karpathy §2 (Simplicity First): ~120 lines, no LLM call inside. The
+ * regex is the FIRST time peaks-loop accepts hardcoded keywords —
+ * explicitly scoped as a *fail-closed backup* (case 3), NOT a primary
+ * judgement. The LLM still owns the semantic call via
+ * `peaks code detect-job`. The regex is a safety net for the v3.1.1
+ * incident class (LLM under load never records the decision at all).
+ */
+export declare const STEP_08_GATE_FILE_NAME: "job-shape.json";
+export declare const STEP_08_PROGRESS_FILE_NAME: "progress.json";
+/**
+ * Fail-closed backup regex — see module docstring case 3 for why this
+ * exists. Kept short and explicit; if the prompt mentions any of these
+ * triggers and `job-shape.json` is missing, the LLM is treated as
+ * having skipped `peaks code detect-job` and the gate blocks.
+ *
+ * The list mirrors the v3.1.0 / v3.1.1 incident triggers verbatim:
+ *   继续执行下个 slice (until next slice) → until / 直到
+ *   全部添加完 / all of them            → 全部 / all of them
+ *   不用考虑费用                        → 不用考虑费用 / disavow cost
+ *   until all done                      → until all done
+ */
+export declare const STEP_08_BACKUP_REGEX: RegExp;
+export interface Step08Progress {
+    readonly jobId: string;
+    readonly done: number;
+    readonly total: number;
+    readonly currentSlice: string;
+    readonly lastCommitSha: string | null;
+    readonly updatedAt: string;
+}
+export type Step08Verdict = {
+    readonly kind: 'allow-job';
+    readonly decision: import('./job-shape-decision.js').JobShapeDecision;
+    readonly progress: Step08Progress | null;
+} | {
+    readonly kind: 'allow-single';
+} | {
+    readonly kind: 'block-missing-decision';
+    readonly promptHit: boolean;
+    readonly promptSource: 'flag' | 'last-prompt-file' | 'stdin-empty';
+};
+export declare function runtimeSessionDir(projectRoot: string, sessionId: string): string;
+export interface EvaluateStep08Input {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    /**
+     * Explicit prompt text. When omitted, falls back to
+     * `.peaks/_runtime/<sid>/txt/last-prompt.txt`, then to stdin (the
+     * caller passes stdin verbatim — usually empty in tests).
+     */
+    readonly prompt?: string;
+}
+export interface EvaluateStep08Result {
+    readonly allow: boolean;
+    readonly verdict: Step08Verdict;
+    readonly nextSliceLine: string | null;
+}
+/**
+ * Pure evaluator — does NOT write, does NOT exit. CLI wrapper in
+ * `src/cli/commands/code-commands.ts` reads `allow` to set the process
+ * exit code (0 allow / 2 block) and prints the structured envelope.
+ */
+export declare function evaluateStep08(input: EvaluateStep08Input): EvaluateStep08Result;

package/dist/services/code/step-08-gate.js

@@ -0,0 +1,136 @@
+/**
+ * v3.1.2 Step 0.8 — Mechanical PreToolUse gate.
+ *
+ * Wire-installed by `peaks workspace init` (extends the existing hook
+ * installer; does NOT replace the Write|Edit|MultiEdit fact-forcing
+ * bypass). The hook runs `peaks code gate-step-08 --project .` before
+ * every Bash tool call. Exit code is the load-bearing contract:
+ *
+ *   exit 0 → allow (with structured stdout describing the decision)
+ *   exit 2 → block (stderr contains the BLOCKED: ... reason)
+ *
+ * Three decision paths:
+ *
+ *   1. `job-shape.json` exists with `decision.isJob === true`.
+ *      → allow, print `{ ok, allow, mode: 'job', decision }`. When a
+ *        matching `job/<jid>/progress.json` exists, also print
+ *        `Next: slice #<N+1> of <M> (<currentSlice>)` so the LLM sees
+ *        its resume context BEFORE any Bash call lands.
+ *   2. `job-shape.json` exists with `decision.isJob === false`.
+ *      → allow, print `{ ok, allow, mode: 'single' }`.
+ *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the
+ *      source of truth, but if it never recorded a decision we run a
+ *      lightweight backup regex against the user's prompt:
+ *        /until|全部|until all done|disavow cost|不用考虑费用|all of them/i
+ *      match → block (exit 2) with the BLOCKED: stderr message.
+ *      no match → allow (exit 0) — most prompts are not Job-shaped.
+ *
+ * Karpathy §2 (Simplicity First): ~120 lines, no LLM call inside. The
+ * regex is the FIRST time peaks-loop accepts hardcoded keywords —
+ * explicitly scoped as a *fail-closed backup* (case 3), NOT a primary
+ * judgement. The LLM still owns the semantic call via
+ * `peaks code detect-job`. The regex is a safety net for the v3.1.1
+ * incident class (LLM under load never records the decision at all).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED } from './job-shape-decision.js';
+export const STEP_08_GATE_FILE_NAME = 'job-shape.json';
+export const STEP_08_PROGRESS_FILE_NAME = 'progress.json';
+/**
+ * Fail-closed backup regex — see module docstring case 3 for why this
+ * exists. Kept short and explicit; if the prompt mentions any of these
+ * triggers and `job-shape.json` is missing, the LLM is treated as
+ * having skipped `peaks code detect-job` and the gate blocks.
+ *
+ * The list mirrors the v3.1.0 / v3.1.1 incident triggers verbatim:
+ *   继续执行下个 slice (until next slice) → until / 直到
+ *   全部添加完 / all of them            → 全部 / all of them
+ *   不用考虑费用                        → 不用考虑费用 / disavow cost
+ *   until all done                      → until all done
+ */
+export const STEP_08_BACKUP_REGEX = /直到|全部|until all done|disavow cost|不用考虑费用|all of them/i;
+export function runtimeSessionDir(projectRoot, sessionId) {
+    return join(projectRoot, '.peaks', '_runtime', sessionId);
+}
+function progressPath(projectRoot, sessionId, jid) {
+    // The progress file lives under job/<jid>/progress.json. The jid
+    // comes from job-shape.json (decision.suggestedJobId) — there is
+    // exactly one canonical jid per session under Job mode, so we read
+    // the matching path directly rather than enumerating the job/ dir.
+    // (Rotating mode spawns new jids but only one is "active" at a time;
+    // the active jid is the latest write to job-shape.json.)
+    return join(runtimeSessionDir(projectRoot, sessionId), 'job', jid, STEP_08_PROGRESS_FILE_NAME);
+}
+function readProgressIfAny(projectRoot, sessionId, jid) {
+    const path = progressPath(projectRoot, sessionId, jid);
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.jobId === 'string' &&
+            typeof parsed.done === 'number' &&
+            typeof parsed.total === 'number' &&
+            typeof parsed.currentSlice === 'string' &&
+            typeof parsed.updatedAt === 'string') {
+            return {
+                jobId: parsed.jobId,
+                done: parsed.done,
+                total: parsed.total,
+                currentSlice: parsed.currentSlice,
+                lastCommitSha: typeof parsed.lastCommitSha === 'string' ? parsed.lastCommitSha : null,
+                updatedAt: parsed.updatedAt
+            };
+        }
+        return null;
+    }
+    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        return null;
+    }
+}
+function readPromptFromLastPromptFile(projectRoot, sessionId) {
+    const path = join(runtimeSessionDir(projectRoot, sessionId), 'txt', 'last-prompt.txt');
+    if (!existsSync(path))
+        return '';
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Pure evaluator — does NOT write, does NOT exit. CLI wrapper in
+ * `src/cli/commands/code-commands.ts` reads `allow` to set the process
+ * exit code (0 allow / 2 block) and prints the structured envelope.
+ */
+export function evaluateStep08(input) {
+    try {
+        const record = readJobShapeDecision(input.projectRoot, input.sessionId);
+        if (record.decision.isJob) {
+            const progress = readProgressIfAny(input.projectRoot, input.sessionId, record.decision.suggestedJobId);
+            const nextSliceLine = progress !== null
+                ? `Next: slice #${progress.done + 1} of ${progress.total} (${progress.currentSlice})`
+                : null;
+            return {
+                allow: true,
+                verdict: { kind: 'allow-job', decision: record.decision, progress },
+                nextSliceLine
+            };
+        }
+        return { allow: true, verdict: { kind: 'allow-single' }, nextSliceLine: null };
+    }
+    catch (err) {
+        if (err instanceof JobShapeDecisionError && err.code === JOB_SHAPE_NOT_DECIDED) {
+            const promptText = input.prompt ?? readPromptFromLastPromptFile(input.projectRoot, input.sessionId);
+            const hit = promptText.length > 0 && STEP_08_BACKUP_REGEX.test(promptText);
+            const source = input.prompt !== undefined ? 'flag' : promptText.length > 0 ? 'last-prompt-file' : 'stdin-empty';
+            if (hit) {
+                return { allow: false, verdict: { kind: 'block-missing-decision', promptHit: true, promptSource: source }, nextSliceLine: null };
+            }
+            return { allow: true, verdict: { kind: 'block-missing-decision', promptHit: false, promptSource: source }, nextSliceLine: null };
+        }
+        throw err;
+    }
+}

package/dist/services/code/user-touchpoint-classifier.d.ts

@@ -0,0 +1,44 @@
+/**
+ * v2.15.0 follow-up — G4: user touchpoint classifier.
+ *
+ * 12 Gaps positioning memory: "user 介入 = 业务/产品审阅,不是技术决策".
+ * This service classifies every Code gate by the kind of decision it
+ * represents, so the CLI / status line can show user which gates
+ * actually need their attention vs which are technical defaults
+ * (AI auto-decides in full-auto).
+ *
+ *   - `business`         — user MUST be present (business / product decisions)
+ *   - `tech`             — AI auto-decides in full-auto (tech choices)
+ *   - `mode-selection`   — the gate IS the mode / context selection
+ *                          itself (always prompts the user, even in
+ *                          full-auto)
+ *   - `commit-boundary`  — hard-floor: push / tag / publish / global
+ *                          install (always prompts, even in full-auto)
+ *   - `commit-floor`     — other hard-floor categories
+ *                          (irreversible-external / auth / multi-day
+ *                          investment)
+ *
+ * Pure functions. No I/O.
+ */
+export type GateKind = 'business' | 'tech' | 'mode-selection' | 'commit-boundary' | 'commit-floor';
+export interface GateClassification {
+    readonly step: string;
+    readonly kind: GateKind;
+    /** Short description of what the user / AI is deciding. */
+    readonly description: string;
+    /** Whether full-auto can auto-proceed this gate. */
+    readonly fullAutoCanProceed: boolean;
+    /** When user should pay attention (always / business-only / never). */
+    readonly userShouldReview: 'always' | 'business-only' | 'never';
+}
+export declare function classifyAllGates(): readonly GateClassification[];
+/** Look up a single gate's classification. Returns null when the step is not in the table. */
+export declare function classifyGate(step: string): GateClassification | null;
+/** List all gates the user must review (per the 12 Gaps positioning). */
+export declare function userMustReviewGates(): readonly GateClassification[];
+/** List all gates AI auto-decides in full-auto. */
+export declare function aiAutoDecidesGates(): readonly GateClassification[];
+export declare const COMMIT_BOUNDARY_ACTIONS_LIST: readonly {
+    id: string;
+    description: string;
+}[];

package/dist/services/code/user-touchpoint-classifier.js

@@ -0,0 +1,145 @@
+/**
+ * v2.15.0 follow-up — G4: user touchpoint classifier.
+ *
+ * 12 Gaps positioning memory: "user 介入 = 业务/产品审阅,不是技术决策".
+ * This service classifies every Code gate by the kind of decision it
+ * represents, so the CLI / status line can show user which gates
+ * actually need their attention vs which are technical defaults
+ * (AI auto-decides in full-auto).
+ *
+ *   - `business`         — user MUST be present (business / product decisions)
+ *   - `tech`             — AI auto-decides in full-auto (tech choices)
+ *   - `mode-selection`   — the gate IS the mode / context selection
+ *                          itself (always prompts the user, even in
+ *                          full-auto)
+ *   - `commit-boundary`  — hard-floor: push / tag / publish / global
+ *                          install (always prompts, even in full-auto)
+ *   - `commit-floor`     — other hard-floor categories
+ *                          (irreversible-external / auth / multi-day
+ *                          investment)
+ *
+ * Pure functions. No I/O.
+ */
+const RAW_CLASSIFICATION = [
+    {
+        step: 'step-0.5-openspec-opt-in',
+        kind: 'mode-selection',
+        description: 'OpenSpec 一次性 opt-in(使用 OpenSpec spec-first 流程)。这是 context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.6-audit-goal',
+        kind: 'business',
+        description: 'Audit + Goal 确认。goal 必须明确区分业务/产品(user 写)与技术(AI 拍板)。user 必审。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.7-resume-detection',
+        kind: 'mode-selection',
+        description: '未完工作续做 vs 重开。context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.55-1x-upgrade',
+        kind: 'commit-floor',
+        description: '1.x → 2.0 升级检测。不可逆外部副作用(改写 config + cache schema),所有 mode 都必须 AskUserQuestion。full-auto 也暂停。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-0.75-checkpoint-resume',
+        kind: 'tech',
+        description: '同 session 当日重入 + checkpoint 续做。技术恢复逻辑,user 不参与。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'step-1-mode-select',
+        kind: 'mode-selection',
+        description: 'Mode 选择(全自动化 / 半自动 / 蜂群 / 严格)。context 选择门,user 必答。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-2.5-session-title',
+        kind: 'tech',
+        description: 'Session 标题生成(从用户首次请求抽取)。技术性 metadata,AI 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'phase-2-prd-confirm',
+        kind: 'business',
+        description: 'PRD 确认。user 必审业务/产品意图(4 必填块见 prd check-blocks)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'phase-3-swarm-gate-b',
+        kind: 'tech',
+        description: '蜂群 gate B(并行 fan-out 决策)。技术调度,AI 在 full-auto 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'phase-6-qa-gate-d',
+        kind: 'business',
+        description: 'QA gate D(业务验收)。user 必审业务/产品视角 6 项清单(不是技术指标)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'phase-10-txt-memory-extract',
+        kind: 'business',
+        description: 'TXT handoff + memory 提取。user 必审(决定哪些 peaks-memory 块落 .peaks/memory/)。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'step-n+1-final-review',
+        kind: 'business',
+        description: '4 维终审。user 必审业务交付完整性。',
+        fullAutoCanProceed: false,
+        userShouldReview: 'always'
+    },
+    {
+        step: 'frontend-only-mismatch',
+        kind: 'tech',
+        description: '前端-only 模式不匹配检测。技术模式判断,AI 在 full-auto 自决。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    },
+    {
+        step: 'standards-preflight',
+        kind: 'tech',
+        description: '项目标准预检(standards init/update dry-run)。技术 preflight,AI 自决 apply。',
+        fullAutoCanProceed: true,
+        userShouldReview: 'never'
+    }
+];
+export function classifyAllGates() {
+    return RAW_CLASSIFICATION.slice();
+}
+/** Look up a single gate's classification. Returns null when the step is not in the table. */
+export function classifyGate(step) {
+    const raw = RAW_CLASSIFICATION.find((g) => g.step === step);
+    return raw === undefined ? null : raw;
+}
+/** List all gates the user must review (per the 12 Gaps positioning). */
+export function userMustReviewGates() {
+    return RAW_CLASSIFICATION.filter((g) => g.userShouldReview !== 'never');
+}
+/** List all gates AI auto-decides in full-auto. */
+export function aiAutoDecidesGates() {
+    return RAW_CLASSIFICATION.filter((g) => g.fullAutoCanProceed);
+}
+export const COMMIT_BOUNDARY_ACTIONS_LIST = [
+    { id: 'git-push', description: 'git push / git push origin / git push --tags' },
+    { id: 'git-tag', description: 'git tag v2.15.0 / git tag -a ...' },
+    { id: 'npm-publish', description: 'npm publish / npm pub' },
+    { id: 'npm-install-global', description: 'npm install -g / npm i -g / npm add -g' },
+    { id: 'peaks-global-install', description: 'peaks-loop 全局安装 / npm install -g peaks-loop' }
+];

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

@@ -0,0 +1,66 @@
+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
+ * vendor. This unlocks running peaks-loop under non-Claude IDEs
+ * (z-code, Cursor, Trae, ...).
+ *
+ * Resolution order:
+ *   1. Explicit `config.model` (user override via `peaks config set model ...`)
+ *   2. Stable fallback for back-compat (env-var override; defaults to
+ *      `claude-opus-4-7` so legacy fixtures keep compiling per
+ *      SC §3.4 strategy A)
+ *
+ * Vendor-neutrality note: the default `'claude-opus-4-7'` is a
+ * *back-compat fallback*, NOT a hardcoded "the strongest model is
+ * always Claude" assumption. Production callers should set
+ * `config.model` (or override the env var) to declare their strongest
+ * model. Adapter-level runtime probing is wired in Slice C
+ * (`getStrongestModelIdAsync` below).
+ */
+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.
+ *
+ * Why this exists:
+ *   - `rd-service.buildPlan` (and other sync callers) still call the
+ *     sync `getStrongestModelId` — we do NOT change those signatures.
+ *   - New async callers (the future Slice C-extension of
+ *     `workflow-router-service`, plus any LLM-inside-z-code path)
+ *     resolve the strongest model from the IDE's actual state,
+ *     without forcing the user to set `config.model`.
+ *
+ * Resolution order:
+ *   1. Explicit `config.model`.
+ *   2. `PEAKS_STRONGEST_MODEL_DEFAULT` env var override.
+ *   3. Runtime probe via `detectCurrentIdeModel()` (only when the
+ *      registered IDE adapter opts in via `detectCurrentModel?` —
+ *      only `zcode` does in Slice C; other IDEs skip this layer).
+ *   4. Hardcoded back-compat default `'claude-opus-4-7'`.
+ *
+ * Each layer is isolated so a failure in the probe does not break
+ * the resolver.
+ */
+export declare function getStrongestModelIdAsync(config?: {
+    model?: unknown;
+}, 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`.
+ */
+export declare class ProviderNotConfiguredError extends Error {
+    constructor(message?: string);
+}
+export declare function getEconomyAwareExecutionModelId(config: Pick<PeaksConfig, 'economyMode' | 'providers'> & {
+    model?: string;
+}): string;

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

@@ -0,0 +1,105 @@
+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
+ * vendor. This unlocks running peaks-loop under non-Claude IDEs
+ * (z-code, Cursor, Trae, ...).
+ *
+ * Resolution order:
+ *   1. Explicit `config.model` (user override via `peaks config set model ...`)
+ *   2. Stable fallback for back-compat (env-var override; defaults to
+ *      `claude-opus-4-7` so legacy fixtures keep compiling per
+ *      SC §3.4 strategy A)
+ *
+ * Vendor-neutrality note: the default `'claude-opus-4-7'` is a
+ * *back-compat fallback*, NOT a hardcoded "the strongest model is
+ * always Claude" assumption. Production callers should set
+ * `config.model` (or override the env var) to declare their strongest
+ * model. Adapter-level runtime probing is wired in Slice C
+ * (`getStrongestModelIdAsync` below).
+ */
+export function getStrongestModelId(config) {
+    const raw = config?.model;
+    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.
+ *
+ * Why this exists:
+ *   - `rd-service.buildPlan` (and other sync callers) still call the
+ *     sync `getStrongestModelId` — we do NOT change those signatures.
+ *   - New async callers (the future Slice C-extension of
+ *     `workflow-router-service`, plus any LLM-inside-z-code path)
+ *     resolve the strongest model from the IDE's actual state,
+ *     without forcing the user to set `config.model`.
+ *
+ * Resolution order:
+ *   1. Explicit `config.model`.
+ *   2. `PEAKS_STRONGEST_MODEL_DEFAULT` env var override.
+ *   3. Runtime probe via `detectCurrentIdeModel()` (only when the
+ *      registered IDE adapter opts in via `detectCurrentModel?` —
+ *      only `zcode` does in Slice C; other IDEs skip this layer).
+ *   4. Hardcoded back-compat default `'claude-opus-4-7'`.
+ *
+ * Each layer is isolated so a failure in the probe does not break
+ * the resolver.
+ */
+export async function getStrongestModelIdAsync(config, runtimeProbeDisabled = false) {
+    const raw = config?.model;
+    const fromConfig = typeof raw === 'string' ? raw.trim() : undefined;
+    if (fromConfig)
+        return fromConfig;
+    const envDefault = process.env.PEAKS_STRONGEST_MODEL_DEFAULT;
+    if (envDefault && envDefault.length > 0)
+        return envDefault;
+    if (!runtimeProbeDisabled) {
+        try {
+            const probed = await detectCurrentIdeModel();
+            if (probed && probed.length > 0)
+                return probed;
+        }
+        catch { // TODO(g2): best-effort runtime probe — fall through to back-compat default is intentional
+            // best-effort — fall through to back-compat default
+        }
+    }
+    return 'claude-opus-4-7';
+}
+export function getConfiguredExecutionModelId(providers) {
+    const providerConfigs = Object.values(providers ?? {});
+    const configuredModel = providerConfigs
+        .map((provider) => provider?.model?.trim())
+        .find((model) => typeof model === 'string' && model.length > 0);
+    if (!configuredModel) {
+        throw new ProviderNotConfiguredError();
+    }
+    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`.
+ */
+export class ProviderNotConfiguredError extends Error {
+    constructor(message = 'Execution model must be configured in providers') {
+        super(message);
+        this.name = 'ProviderNotConfiguredError';
+    }
+}
+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/context/auto-compact-dispatcher.d.ts

@@ -0,0 +1,37 @@
+import type { CompactDispatchResult } from './auto-compact-types.js';
+export type CompactTarget = 'main' | 'sub-agent';
+export interface DispatchIdeCompactInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** 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
+     * shells that spawn their own `peaks code auto-compact` flow pass
+     * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
+     *
+     * Behaviour matrix (claude-code MVP):
+     *   - target='main'     → llm-self-compress (write intent; main LLM
+     *                          fires `/compact` on its next turn).
+     *   - target='sub-agent'→ shell-exec (spawn `sh -c /compact` in the
+     *                          sub-agent's own shell, preserving the
+     *                          pre-slice behaviour).
+     * Non-claude-code IDEs + target='main' return noop + warning.
+     */
+    readonly target?: CompactTarget | undefined;
+}
+/**
+ * Dispatch compact via the active IDE's registered pathway.
+ *
+ * Returns a `CompactDispatchResult` envelope. The result is `ok`
+ * when the dispatch path completed without error — for
+ * `llm-self-compress` the LLM still has to do the actual summary,
+ * so the orchestrator MUST NOT treat `ok: true` as proof that the
+ * context actually shrunk; the next `peaks context now` probe
+ * confirms.
+ */
+export declare function dispatchIdeCompact(input: DispatchIdeCompactInput): Promise<CompactDispatchResult>;