peaks-loop 4.0.0-beta.9 → 4.0.1

package/dist/services/autonomous-swarm/autonomous-swarm-service.js

@@ -0,0 +1,446 @@
+/**
+ * autonomous-swarm-service — slice rid-014.
+ *
+ * Purpose:
+ *   Build a dry-run-only autonomous RD swarm planner that turns a
+ *   user-supplied goal + change-id + mode into a *resumable* plan:
+ *   goal package (done / resume conditions), capability reuse list,
+ *   checkpoint queue, worker-queue placeholders (no spawn), evidence
+ *   requirements, and resume instructions.
+ *
+ * Reuse (per rid-014 plan §1):
+ *   - `validateChangeId` + `planArtifactPath` + `buildWorkspaceUnavailable`
+ *     from `src/services/openspec/artifact-boundary.ts` (rid-009).
+ *   - `getTechStatus` from `src/services/tech/tech-service.ts` (rid-012).
+ *   - `planRdSwarmGraph` shape from `src/services/rd-swarm/rd-swarm-service.ts`
+ *     (rid-013) — composed as the workerQueue feed.
+ *
+ * Style:
+ *   - Named function exports — matches `rd-swarm-service.ts` + `artifact-boundary.ts`.
+ *   - Hand-rolled `Result<T, E>` unions — no `neverthrow` dep.
+ *   - Pure path math + intentional capability fs reads (no side effects).
+ *   - No real workers, no MCP install, no settings mutation, no target-repo edit.
+ *
+ * Hard ban:
+ *   - MUST NOT install / invoke / import any external skill or MCP server.
+ *   - MUST NOT launch workers or mutate the target repo.
+ *   - MUST NOT touch `src/services/openspec/artifact-boundary.ts`,
+ *     `src/services/tech/`, or `src/services/rd-swarm/`.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateChangeId, planArtifactPath, buildWorkspaceUnavailable, } from '../openspec/artifact-boundary.js';
+import { planRdSwarmGraph } from '../rd-swarm/rd-swarm-service.js';
+const MAX_CAPABILITY_ENTRIES = 50;
+const MIN_WORKERS = 25;
+const MAX_WORKERS = 40;
+export function buildAutonomousGoalPackage(input) {
+    const trimmedGoal = input.goal.trim();
+    if (!trimmedGoal) {
+        throw new Error('Goal must be non-empty');
+    }
+    const id = validateChangeId(input.changeId);
+    if (!id.ok) {
+        throw new Error(id.error.message);
+    }
+    const trimmedChangeId = id.value.changeId;
+    const doneCondition = input.mode === 'code'
+        ? 'All checkpoints verified; reducer-report.md committed; validation-report.md and coverage-report.md pass.'
+        : 'All team-mode checkpoints verified; team review artifacts persisted; reducer summary committed.';
+    const resumeCondition = 'Re-read the persisted Peaks artifacts (NOT session state); verify the latest checkpoint; re-verify evidence before continuing.';
+    const nonGoals = [
+        'Real worker spawning (dry-run only — autonomyMode is hard-coded to dry-run).',
+        'No external skill / MCP installation — capability entries are metadata-only.',
+        'No target-repo source edits — artifacts land under .peaks/changes/<id>/.',
+    ];
+    const riskNotes = [
+        'Treating /goal as durable would leak session state across runs; goalCommand is non-durable.',
+        'Worker queue is capped at 40; coordinate via checkpoints, not raw fan-out.',
+    ];
+    const goalCommand = {
+        marker: '/goal',
+        nonDurable: true,
+        notes: 'Read-only marker; never persisted as run state. Re-derive from the goal-package on every resume.',
+    };
+    return {
+        changeId: trimmedChangeId,
+        goal: trimmedGoal,
+        mode: input.mode,
+        autonomyMode: 'dry-run',
+        nonGoals,
+        doneCondition,
+        resumeCondition,
+        riskNotes,
+        goalCommand,
+    };
+}
+function readWorkspaceConfigArtifacts(workspaceRoot) {
+    // Read the project's workspace config file if present; the rd-swarm
+    // service expects a `workspace` field carrying the resolved config so
+    // its `getTechStatus` fallback can query the canonical path.
+    const configPath = join(workspaceRoot, '.peaks', 'workspace.json');
+    if (!existsSync(configPath))
+        return {};
+    try {
+        const raw = readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.workspace ? { workspace: parsed.workspace } : {};
+    }
+    catch {
+        return {};
+    }
+}
+function planSwarmArtifactPath(input) {
+    const result = planArtifactPath({
+        changeId: input.changeId,
+        workspaceRoot: input.workspaceRoot,
+        role: 'swarm',
+        requestId: input.requestId,
+        template: input.template,
+    });
+    if (!result.ok) {
+        return `${input.changeId}/swarm/${input.template.replace('<changeId>/swarm/', '')}`;
+    }
+    return result.value.jsonSafeRelativePath;
+}
+function deriveCheckpoints(goal, changeId, workspaceRoot) {
+    const requestId = 'autonomous';
+    return [
+        {
+            id: 'checkpoint-1-goal-package',
+            name: 'Goal package verified',
+            evidencePath: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/goal-package.md`,
+            }),
+            status: 'pending',
+        },
+        {
+            id: 'checkpoint-2-capability-reuse',
+            name: 'Capability reuse parsed',
+            evidencePath: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/capability-reuse.md`,
+            }),
+            status: 'pending',
+        },
+        {
+            id: 'checkpoint-3-worker-queue',
+            name: 'Worker queue composed',
+            evidencePath: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/worker-queue.md`,
+            }),
+            status: 'pending',
+        },
+        {
+            id: 'checkpoint-4-evidence-reports',
+            name: 'Validation + coverage + reducer reports generated',
+            evidencePath: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/evidence-summary.md`,
+            }),
+            status: 'pending',
+        },
+    ];
+}
+function deriveEvidenceRequirements(changeId, workspaceRoot) {
+    const requestId = 'autonomous';
+    return [
+        {
+            id: 'evidence-validation-report',
+            kind: 'validation-report',
+            path: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/validation-report.md`,
+            }),
+            required: true,
+        },
+        {
+            id: 'evidence-coverage-report',
+            kind: 'coverage-report',
+            path: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/evidence/coverage-report.md`,
+            }),
+            required: true,
+        },
+        {
+            id: 'evidence-reducer-report',
+            kind: 'reducer-report',
+            path: planSwarmArtifactPath({
+                changeId,
+                workspaceRoot,
+                requestId,
+                template: `<changeId>/swarm/reducer-report.md`,
+            }),
+            required: true,
+        },
+    ];
+}
+function workerQueueFromGraph(graph) {
+    return graph.tasks.map((task) => ({
+        taskId: task.taskId,
+        wave: task.wave,
+        status: 'planned',
+        briefPath: `${graph.artifactRoot}/${task.outputs[0]}`,
+        dependsOn: [...task.dependsOn],
+    }));
+}
+function localTechStatus(workspaceRoot, changeId, workspace) {
+    // Direct fs probe matching `rd-swarm-service.ts#localTechStatus` so the
+    // autonomous-swarm composer sees the same per-file presence check that
+    // the rd-swarm planner uses. The `getTechStatus` service wrapper requires
+    // a fully-configured `workspace` (the workspace-only contract); the
+    // rd-swarm planner's fs probe is the cross-mode fallback.
+    const root = join(workspaceRoot, changeId, 'rd', 'architecture');
+    const required = ['frontend-tech-doc.md', 'backend-tech-doc.md', 'tech-approval-record.md'];
+    const missing = required.filter((name) => !existsSync(join(root, name)));
+    if (missing.length > 0) {
+        return missing.includes('tech-approval-record.md') && missing.length === 1 ? 'missing-approval' : 'missing';
+    }
+    try {
+        return readFileSync(join(root, 'tech-approval-record.md'), 'utf8').split(/\r?\n/).some((line) => line.trim() === 'status: approved') ? 'approved' : 'not-approved';
+    }
+    catch {
+        return 'not-approved';
+    }
+}
+export function planCapabilityReuse(input) {
+    const docsDir = join(input.workspaceRoot, 'docs');
+    const warnings = [];
+    const entries = [];
+    if (!existsSync(docsDir)) {
+        return { entries, truncated: false, warnings };
+    }
+    const files = [
+        { source: 'accessRepo.md', trustLevel: 'internal' },
+        { source: 'mcpServer.md', trustLevel: 'external' },
+    ];
+    for (const file of files) {
+        const fullPath = join(docsDir, file.source);
+        if (!existsSync(fullPath))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(fullPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        // Match markdown bullets of the form `- name: purpose` or `* name: purpose`.
+        const lines = raw.split(/\r?\n/);
+        for (const line of lines) {
+            if (entries.length >= MAX_CAPABILITY_ENTRIES)
+                break;
+            const match = line.match(/^\s*[-*]\s+([A-Za-z0-9._-]+)\s*:\s*(.+?)\s*$/);
+            if (!match)
+                continue;
+            const name = match[1];
+            const purpose = match[2];
+            if (!name || !purpose)
+                continue;
+            entries.push({
+                source: file.source,
+                purpose,
+                trustLevel: file.trustLevel,
+                activation: `metadata-only — read from ${file.source}, never invoked`,
+                risk: file.source === 'mcpServer.md' ? 'external' : 'internal',
+            });
+        }
+    }
+    const truncated = entries.length >= MAX_CAPABILITY_ENTRIES;
+    if (truncated) {
+        warnings.push('TRUNCATED');
+    }
+    return { entries, truncated, warnings };
+}
+export function buildResumeInstructions(plan) {
+    const steps = [
+        'Re-read artifact paths under .peaks/changes/<changeId>/swarm/ — do not trust session state.',
+        'Verify the latest checkpoint (status: verified | pending | failed) before continuing.',
+        'Re-verify evidence: validation-report.md, coverage-report.md, reducer-report.md.',
+        'Re-derive the goal package from the persisted request; the /goal marker is non-durable.',
+    ];
+    const checkpointStates = plan.checkpoints.map((checkpoint) => ({
+        id: checkpoint.id,
+        status: checkpoint.status,
+    }));
+    return {
+        summary: plan.available
+            ? 'Plan is available; resume by re-deriving the goal package and verifying the next pending checkpoint.'
+            : 'Plan is blocked; resume by re-running planAutonomousRdSwarm and addressing the gateStatus / blockedReasons.',
+        steps,
+        checkpointStates,
+    };
+}
+export function planAutonomousRdSwarm(input) {
+    const id = validateChangeId(input.changeId);
+    if (!id.ok) {
+        const blocked = {
+            changeId: input.changeId,
+            goal: input.goal.trim(),
+            mode: input.mode,
+            autonomyMode: 'dry-run',
+            available: false,
+            goalPackage: buildAutonomousGoalPackage(input),
+            capabilityReuse: planCapabilityReuse({ workspaceRoot: input.workspaceRoot }),
+            checkpoints: deriveCheckpoints(input.goal, input.changeId, input.workspaceRoot),
+            workerQueue: [],
+            evidence: deriveEvidenceRequirements(input.changeId, input.workspaceRoot),
+            artifactRoot: `${input.changeId}/swarm`,
+            gateStatus: { techApprovalRequired: input.requiresTechApproval === true, techStatus: 'unavailable', ...(input.requiresTechApproval === true ? {} : { skipReason: 'tech-gate-not-required' }) },
+            blockedReasons: [id.error.code],
+            nextActions: [id.error.message],
+            resumeInstructions: {
+                summary: 'Plan is blocked; resume after fixing the change-id format.',
+                steps: [],
+                checkpointStates: [],
+            },
+        };
+        return blocked;
+    }
+    const trimmedGoal = input.goal.trim();
+    if (!trimmedGoal) {
+        const blocked = {
+            changeId: id.value.changeId,
+            goal: trimmedGoal,
+            mode: input.mode,
+            autonomyMode: 'dry-run',
+            available: false,
+            goalPackage: buildAutonomousGoalPackage(input),
+            capabilityReuse: planCapabilityReuse({ workspaceRoot: input.workspaceRoot }),
+            checkpoints: deriveCheckpoints(input.goal, id.value.changeId, input.workspaceRoot),
+            workerQueue: [],
+            evidence: deriveEvidenceRequirements(id.value.changeId, input.workspaceRoot),
+            artifactRoot: `${id.value.changeId}/swarm`,
+            gateStatus: { techApprovalRequired: input.requiresTechApproval === true, techStatus: 'unavailable', ...(input.requiresTechApproval === true ? {} : { skipReason: 'tech-gate-not-required' }) },
+            blockedReasons: ['INVALID_GOAL'],
+            nextActions: ['Use a non-empty goal'],
+            resumeInstructions: {
+                summary: 'Plan is blocked; resume by providing a non-empty goal.',
+                steps: [],
+                checkpointStates: [],
+            },
+        };
+        return blocked;
+    }
+    const changeId = id.value.changeId;
+    const workspaceArtifacts = readWorkspaceConfigArtifacts(input.workspaceRoot);
+    const requested = input.maxWorkers;
+    if (!Number.isInteger(requested) || requested < 1) {
+        const blocked = {
+            changeId,
+            goal: trimmedGoal,
+            mode: input.mode,
+            autonomyMode: 'dry-run',
+            available: false,
+            goalPackage: buildAutonomousGoalPackage(input),
+            capabilityReuse: planCapabilityReuse({ workspaceRoot: input.workspaceRoot }),
+            checkpoints: deriveCheckpoints(trimmedGoal, changeId, input.workspaceRoot),
+            workerQueue: [],
+            evidence: deriveEvidenceRequirements(changeId, input.workspaceRoot),
+            artifactRoot: `${changeId}/swarm`,
+            gateStatus: { techApprovalRequired: input.requiresTechApproval === true, techStatus: 'unavailable', ...(input.requiresTechApproval === true ? {} : { skipReason: 'tech-gate-not-required' }) },
+            blockedReasons: ['INVALID_MAX_WORKERS'],
+            nextActions: ['Use a positive integer for max-workers.'],
+            resumeInstructions: {
+                summary: 'Plan is blocked; resume by setting a positive max-workers value.',
+                steps: [],
+                checkpointStates: [],
+            },
+        };
+        return blocked;
+    }
+    const target = Math.min(requested, MAX_WORKERS);
+    const requiresTechApproval = input.requiresTechApproval === true;
+    let graph;
+    try {
+        graph = planRdSwarmGraph({
+            skill: 'rd',
+            changeId,
+            goal: trimmedGoal,
+            maxWorkers: target,
+            dryRun: true,
+            workspaceRoot: input.workspaceRoot,
+            requiresTechApproval,
+            ...(workspaceArtifacts.workspace ? { workspace: workspaceArtifacts.workspace } : {}),
+        });
+    }
+    catch {
+        graph = {
+            changeId,
+            goal: trimmedGoal,
+            available: false,
+            workerTarget: target,
+            waves: [],
+            tasks: [],
+            conflictGroups: [],
+            artifactRoot: `${changeId}/swarm`,
+            outputs: { taskGraph: `${changeId}/swarm/task-graph.json`, waveManifests: [], workerBriefs: [], reducerReport: `${changeId}/swarm/reducer-report.md` },
+            gateStatus: { techApprovalRequired: requiresTechApproval, techStatus: 'unavailable', ...(requiresTechApproval ? {} : { skipReason: 'tech-gate-not-required' }) },
+            blockedReasons: [],
+            nextActions: [],
+        };
+    }
+    const blockedReasons = [...graph.blockedReasons];
+    if (requested < MIN_WORKERS && !blockedReasons.includes('SMALL_SCOPE')) {
+        blockedReasons.push('SMALL_SCOPE');
+    }
+    if (requested > MAX_WORKERS && !blockedReasons.includes('WORKER_CAP_EXCEEDED')) {
+        blockedReasons.push('WORKER_CAP_EXCEEDED');
+    }
+    const techStatus = localTechStatus(input.workspaceRoot, changeId, workspaceArtifacts.workspace);
+    const gateStatus = {
+        techApprovalRequired: requiresTechApproval,
+        techStatus,
+        ...(requiresTechApproval ? {} : { skipReason: 'tech-gate-not-required' }),
+    };
+    const available = graph.available && !blockedReasons.includes('SMALL_SCOPE') && !blockedReasons.includes('INVALID_MAX_WORKERS');
+    const nextActions = [];
+    if (blockedReasons.includes('WORKER_CAP_EXCEEDED')) {
+        nextActions.push('Worker target was capped at 40.');
+    }
+    if (requiresTechApproval && techStatus !== 'approved') {
+        nextActions.push('Review and approve the technical plan before running the autonomous swarm.');
+    }
+    const goalPackage = buildAutonomousGoalPackage(input);
+    const capabilityReuse = planCapabilityReuse({ workspaceRoot: input.workspaceRoot });
+    const checkpoints = deriveCheckpoints(trimmedGoal, changeId, input.workspaceRoot);
+    const evidence = deriveEvidenceRequirements(changeId, input.workspaceRoot);
+    const workerQueue = workerQueueFromGraph(graph);
+    const draft = {
+        changeId,
+        goal: trimmedGoal,
+        mode: input.mode,
+        autonomyMode: 'dry-run',
+        available,
+        goalPackage,
+        capabilityReuse,
+        checkpoints,
+        workerQueue,
+        evidence,
+        artifactRoot: `${changeId}/swarm`,
+        gateStatus,
+        blockedReasons,
+        nextActions,
+        resumeInstructions: { summary: '', steps: [], checkpointStates: [] },
+    };
+    draft.resumeInstructions = buildResumeInstructions(draft);
+    return draft;
+}
+// Re-export the workspace-unavailable response so the CLI can map an
+// unconfigured artifact workspace to the standard envelope.
+export { buildWorkspaceUnavailable };

package/dist/services/changeset/changeset-check-service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * rid-011 — peaks changeset check hard gate (Phase 4 slice 2).
+ *
+ * Module path: src/services/changeset/changeset-check-service.ts
+ * Mirror of publish.yml gate-changeset step (lines 220-243). Hard-gate,
+ * no warning mode, no opt-out. Auto-wired as step 0 of `peaks release
+ * canary` and `peaks release hotfix` BEFORE the rid-010 precheck guard.
+ *
+ * Decoupling note: rid-010 Layer C (`runChangesetStaged`) is ad-hoc
+ * precheck (warning by default, --strict upgrade); rid-011 hard gate is
+ * unconditional. Both filters inspect `.changeset/*.md` (excluding
+ * README.md) but with different policy semantics.
+ */
+export type ChangesetGateState = 'staged-empty' | 'staged-present' | 'dir-missing';
+export interface ChangesetHardGateEnvelope {
+    readonly ok: boolean;
+    readonly state: ChangesetGateState;
+    readonly stagedFiles: readonly string[];
+    readonly root: string;
+    readonly snapshotAt: string;
+}
+export declare function runChangesetHardGate(projectRoot: string): ChangesetHardGateEnvelope;

package/dist/services/changeset/changeset-check-service.js

@@ -0,0 +1,47 @@
+/**
+ * rid-011 — peaks changeset check hard gate (Phase 4 slice 2).
+ *
+ * Module path: src/services/changeset/changeset-check-service.ts
+ * Mirror of publish.yml gate-changeset step (lines 220-243). Hard-gate,
+ * no warning mode, no opt-out. Auto-wired as step 0 of `peaks release
+ * canary` and `peaks release hotfix` BEFORE the rid-010 precheck guard.
+ *
+ * Decoupling note: rid-010 Layer C (`runChangesetStaged`) is ad-hoc
+ * precheck (warning by default, --strict upgrade); rid-011 hard gate is
+ * unconditional. Both filters inspect `.changeset/*.md` (excluding
+ * README.md) but with different policy semantics.
+ */
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+export function runChangesetHardGate(projectRoot) {
+    const dir = join(projectRoot, '.changeset');
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {
+                ok: true,
+                state: 'dir-missing',
+                stagedFiles: [],
+                root: projectRoot,
+                snapshotAt: new Date().toISOString()
+            };
+        }
+        // Unexpected I/O — fail closed (do NOT silently report clean).
+        throw err;
+    }
+    const staged = files
+        .filter((f) => f.endsWith('.md') && f !== 'README.md')
+        .sort();
+    const ok = staged.length === 0;
+    const state = ok ? 'staged-empty' : 'staged-present';
+    return {
+        ok,
+        state,
+        stagedFiles: staged,
+        root: projectRoot,
+        snapshotAt: new Date().toISOString()
+    };
+}

package/dist/services/code/auto-compact-modes.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
+ *
+ * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
+ * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
+ * earlier for 24h long-run scenarios where the user has explicitly
+ * opted into higher compaction cadence via `peaks session 24h-mode`.
+ *
+ * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
+ * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
+ * preempts and runs `peaks compact auto --execute` itself when
+ * context crosses `autoFire`; the LLM is NOT asked to "decide"
+ * (the LLM-judged 0.85–0.95 zone was the source of false-positive
+ * "context too low" reports at 60%+ free — the LLM was guessing).
+ *
+ * The mode only changes the THRESHOLDS at which the orchestrator fires.
+ * The actual partial-compaction behaviour (dropping low-priority context
+ * layers) is a follow-up slice; for now `partial` mode is logged +
+ * decision-emitted, no separate compaction pathway.
+ */
+export type AutoCompactMode = 'standard' | 'partial';
+export declare const AUTO_COMPACT_THRESHOLDS: Readonly<Record<AutoCompactMode, {
+    readonly autoFire: number;
+    readonly preCompact: number;
+    readonly redLine: number;
+}>>;
+export declare function thresholdFor(mode: AutoCompactMode, kind: 'autoFire' | 'preCompact' | 'redLine'): number;
+export declare function isValidMode(value: string): value is AutoCompactMode;
+export declare function describeMode(mode: AutoCompactMode): string;
+export declare function isPartialModeEligible(contextPercent: number): boolean;

package/dist/services/code/auto-compact-modes.js

@@ -0,0 +1,38 @@
+/**
+ * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
+ *
+ * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
+ * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
+ * earlier for 24h long-run scenarios where the user has explicitly
+ * opted into higher compaction cadence via `peaks session 24h-mode`.
+ *
+ * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
+ * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
+ * preempts and runs `peaks compact auto --execute` itself when
+ * context crosses `autoFire`; the LLM is NOT asked to "decide"
+ * (the LLM-judged 0.85–0.95 zone was the source of false-positive
+ * "context too low" reports at 60%+ free — the LLM was guessing).
+ *
+ * The mode only changes the THRESHOLDS at which the orchestrator fires.
+ * The actual partial-compaction behaviour (dropping low-priority context
+ * layers) is a follow-up slice; for now `partial` mode is logged +
+ * decision-emitted, no separate compaction pathway.
+ */
+export const AUTO_COMPACT_THRESHOLDS = {
+    standard: { autoFire: 0.80, preCompact: 0.85, redLine: 0.95 },
+    partial: { autoFire: 0.65, preCompact: 0.70, redLine: 0.85 }
+};
+export function thresholdFor(mode, kind) {
+    return AUTO_COMPACT_THRESHOLDS[mode][kind];
+}
+export function isValidMode(value) {
+    return value === 'standard' || value === 'partial';
+}
+export function describeMode(mode) {
+    return mode === 'standard'
+        ? 'standard (0.85/0.95 — v2.13.0 zero-pause contract)'
+        : 'partial (0.70/0.85 — 24h long-run mode)';
+}
+export function isPartialModeEligible(contextPercent) {
+    return contextPercent >= AUTO_COMPACT_THRESHOLDS.partial.preCompact;
+}

package/dist/services/code/auto-compact-orchestrator.d.ts

@@ -1,5 +1,6 @@
 import { type CompactTrigger, type ConvergencePlan, type InFlightBatchProbe, type AutoCompactResult } from '../context/auto-compact-types.js';
 import type { CompactTarget } from '../context/auto-compact-dispatcher.js';
+import { type AutoCompactMode } from './auto-compact-modes.js';
 export interface AutoCompactInput {
     /** Project root for context (default cwd). */
     readonly projectRoot: string;
@@ -27,17 +28,28 @@ export interface AutoCompactInput {
      * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
      */
     readonly target?: CompactTarget | undefined;
+    /**
+     * Slice 2026-07-28 (rid-027): auto-compact mode. Default
+     * `'standard'` (v2.13.0 zero-pause contract, 0.85/0.95). `'partial'`
+     * fires earlier (0.70/0.85) for 24h long-run scenarios. CLI flag
+     * `--mode <mode>` overrides the 24h-mode auto-detection.
+     */
+    readonly mode?: AutoCompactMode | undefined;
 }
 /**
  * Map a context ratio to a `CompactTrigger` action. Pure; the side
  * effects (checkpoint + IDE dispatch) live in `runAutoCompact`. Two
- * tiers:
+ * tiers (standard mode; partial mode shifts both thresholds):
+ *
+ *   - ratio < preCompact → 'none' or 'soft-warn'
+ *   - ratio ≥ preCompact → 'pre-compact' (async-friendly path)
+ *   - ratio ≥ redLine    → 'red-line' (synchronous gate)
  *
- *   - ratio < 0.85 → 'none' or 'soft-warn'
- *   - ratio ≥ 0.85 → 'pre-compact' (async-friendly path)
- *   - ratio ≥ 0.95 → 'red-line' (synchronous gate)
+ * Slice 2026-07-28 (rid-027): `mode` selects the threshold table.
+ * Default `'standard'` (0.85/0.95). `'partial'` (0.70/0.85) is used
+ * when 24h long-run mode is active or `--mode partial` is passed.
  */
-export declare function evaluateCompactTrigger(ratio: number): CompactTrigger;
+export declare function evaluateCompactTrigger(ratio: number, mode?: AutoCompactMode): CompactTrigger;
 /**
  * Decide whether to run the auto-compact flow. Pure function for the
  * decision; side effects (checkpoint + IDE dispatch) live in
@@ -55,6 +67,7 @@ export declare function evaluateAutoCompactDecision(input: {
     inFlightBatch?: InFlightBatchProbe | undefined;
     force?: boolean | undefined;
     bypassRedLine?: boolean | undefined;
+    mode?: AutoCompactMode | undefined;
 }): {
     shouldCompact: boolean;
     reason: 'below-threshold' | 'in-flight-batch' | 'pre-compact' | 'red-line';
@@ -96,3 +109,28 @@ export declare function buildConvergencePlan(input: {
 export declare function runAutoCompact(input: AutoCompactInput): Promise<AutoCompactResult>;
 /** Re-export for callers that need to surface the trigger shape. */
 export type { CompactTrigger, ConvergencePlan, InFlightBatchProbe, AutoCompactResult };
+/**
+ * Slice 2026-07-30-compact-visibility: JSONL history of every
+ * auto-compact dispatch. Appended at the end of `executeAutoCompact`
+ * so the new 'peaks compact history' CLI + the
+ * 'peaks statusline compact' indicator have a record. One file
+ * per session (gitignored under `.peaks/_runtime/<sessionId>/`).
+ */
+export interface CompactHistoryEvent {
+    readonly schemaVersion: 1;
+    readonly ts: string;
+    readonly target: 'main' | 'sub-agent' | 'worker';
+    readonly mode: 'standard' | 'partial' | 'aggressive';
+    readonly ide: string;
+    readonly pathway: string;
+    readonly beforeRatio: number;
+    readonly redLine: boolean;
+    readonly ok: boolean;
+    readonly checkpointPath: string;
+    readonly dispatchMessage: string;
+}
+export declare function appendCompactHistoryEvent(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly event: CompactHistoryEvent;
+}): void;