peaks-loop 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/src/services/share/run-state-contract.js

@@ -1,138 +0,0 @@
-/**
- * run-state-contract.ts — locked read-only shape for the desktop
- * client (spec §7A.3 / §10 RL-9).
- *
- * The desktop client observes an in-flight bee through a single
- * JSON file. This module locks the shape so the desktop can render
- * progress without holding a lock on the asset:
- *
- *   {
- *     bee_id:                    string,
- *     status:                    "running" | "paused" | "done" | "failed" | "blocked",
- *     current_step:              string,
- *     started_at:                ISO8601 string,
- *     updated_at:                ISO8601 string,
- *     last_evaluator_verdict:    string | null,
- *     last_user_choice:          string | null
- *   }
- *
- * Hard rules (spec §7A.3):
- *   - The contract is read-only for the desktop client. Only the
- *     running bee (and peaks CLI) may write it.
- *   - The shape is locked — adding a field is a schema-version
- *     bump; removing or renaming a field is a breaking change.
- *
- * This module exposes:
- *   - A Zod schema (`RunStateContractSchema`) that validates the
- *     shape with strict rules (no extra keys, exact enum for
- *     status).
- *   - A type alias (`RunStateContract`).
- *   - A constructor-like factory (for testing / fixtures).
- *
- * It does NOT expose any mutation helpers — there are no setters,
- * because the contract is read-only at the desktop. The running
- * bee writes the file via the existing dispatch flow; the desktop
- * client reads via a separate channel.
- */
-import { z } from "zod";
-/* ---------------------------------------------------------------------- */
-/* Shape contract                                                            */
-/* ---------------------------------------------------------------------- */
-/**
- * The five status values an in-flight bee may report. The
- * desktop-client UI renders the status badge; only the running bee
- * transitions between them.
- */
-export const RUN_STATE_STATUSES = [
-    "running",
-    "paused",
-    "done",
-    "failed",
-    "blocked",
-];
-/**
- * RunStateContract — the locked read-only shape (spec §7A.3).
- *
- * Notes:
- *   - `bee_id`, `current_step`: non-empty NL strings.
- *   - `started_at`, `updated_at`: ISO8601; updated_at >= started_at
- *     is the caller's job (the schema does not check ordering
- *     because a clock skew between the dispatcher and the receiver
- *     is a transient runtime issue, not a shape invariant).
- *   - `last_evaluator_verdict`: optional NL string; null when no
- *     evaluator has fired yet.
- *   - `last_user_choice`: optional NL choice summary; null when
- *     the user has not made a pick yet.
- *
- * `.strict()` rejects unknown keys — adding a field is a
- * schema-version bump, not a quiet extension.
- */
-export const RunStateContractSchema = z
-    .object({
-    /** Stable bee id (kebab-case). */
-    bee_id: z.string().min(1).max(64),
-    /** Current run status (running / paused / done / failed / blocked). */
-    status: z.enum(RUN_STATE_STATUSES),
-    /** Current step name; NL short label. */
-    current_step: z.string().min(1).max(256),
-    /** ISO8601 timestamp the run started. */
-    started_at: z.string().datetime(),
-    /** ISO8601 timestamp of the latest update. */
-    updated_at: z.string().datetime(),
-    /** NL summary of the latest evaluator verdict (or null when none). */
-    last_evaluator_verdict: z.string().max(4000).nullable(),
-    /** NL summary of the latest user choice (or null when none). */
-    last_user_choice: z.string().max(4000).nullable(),
-})
-    .strict();
-/* ---------------------------------------------------------------------- */
-/* Validation helpers (read-only at the surface)                              */
-/* ---------------------------------------------------------------------- */
-/**
- * Strict-parse an unknown value as a RunStateContract. Throws
- * `ZodError` on failure. The desktop client uses this at the read
- * boundary; the running bee writes the file via the existing
- * dispatch flow (separate write path).
- */
-export function parseRunStateContract(input) {
-    return RunStateContractSchema.parse(input);
-}
-/**
- * Safe-parse twin — same Result-like envelope shape used elsewhere.
- */
-export function safeParseRunStateContract(input) {
-    const r = RunStateContractSchema.safeParse(input);
-    if (r.success)
-        return { ok: true, contract: r.data };
-    return {
-        ok: false,
-        findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
-    };
-}
-/* ---------------------------------------------------------------------- */
-/* Server-side writer (used by the dispatch flow)                            */
-/* ---------------------------------------------------------------------- */
-/**
- * Server-side factory used by the dispatch flow to write the file.
- * This helper is exported for testing purposes; the desktop client
- * is read-only and SHOULD NOT call this.
- *
- * The function returns a brand-new `RunStateContract` value; it
- * does NOT mutate any external state. Persistence is the caller's
- * responsibility (the dispatch flow writes a JSON file at a
- * well-known path under `.peaks/_runtime/<sid>/<role>/`).
- */
-export function buildRunState(args) {
-    return RunStateContractSchema.parse({
-        bee_id: args.bee_id,
-        status: args.status,
-        current_step: args.current_step,
-        started_at: args.started_at,
-        updated_at: args.updated_at,
-        last_evaluator_verdict: args.last_evaluator_verdict ?? null,
-        last_user_choice: args.last_user_choice ?? null,
-    });
-}

package/dist/src/services/signal/cancel-handler.d.ts

@@ -1,14 +0,0 @@
-export interface CancelResult {
-    readonly cancelled: number;
-    readonly scanned: number;
-    readonly paths: readonly string[];
-}
-/**
- * Walk `.peaks/_sub_agents/<sid>/`, mark every in-flight record as
- * `cancelled + disposed`, write back atomically (tmp + rename), and
- * return the count. Records that already have `completedAt` set are
- * skipped (they were already finished by the time cancel fired).
- */
-export declare function cancelInFlightDispatches(projectRoot: string, sessionId: string, options?: {
-    now?: () => Date;
-}): CancelResult;

package/dist/src/services/signal/cancel-handler.js

@@ -1,76 +0,0 @@
-/**
- * Slice #009 / G5 RL-9 — user cancel must dispose in-flight dispatch records.
- *
- * When Code's main loop receives SIGINT (Ctrl-C) or the user runs
- * `peaks workflow cancel --rid <rid>`, the loop MUST mark in-flight
- * dispatch records as `outcome: "cancelled"` + `disposed: true` +
- * `disposedAt: now()` BEFORE exiting.
- *
- * "In-flight" = a record with `createdAt` populated AND
- * `completedAt: null`. Those are the ones that the LLM got a toolCall
- * for but did not (yet) confirm completion.
- *
- * This module is the helper Code calls. The wiring (signal listener,
- * cancel command side-effect) is the Code main loop's responsibility;
- * this module is the pure data operation.
- */
-import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-const CANCELLED_OUTCOME = 'cancelled';
-const CANCELLED_STATUS = 'cancelled';
-/**
- * Walk `.peaks/_sub_agents/<sid>/`, mark every in-flight record as
- * `cancelled + disposed`, write back atomically (tmp + rename), and
- * return the count. Records that already have `completedAt` set are
- * skipped (they were already finished by the time cancel fired).
- */
-export function cancelInFlightDispatches(projectRoot, sessionId, options = {}) {
-    const now = options.now ?? (() => new Date());
-    const dir = join(projectRoot, '.peaks', '_sub_agents', sessionId);
-    if (!existsSync(dir)) {
-        return { cancelled: 0, scanned: 0, paths: [] };
-    }
-    let scanned = 0;
-    const cancelledPaths = [];
-    for (const entry of readdirSync(dir)) {
-        if (!entry.startsWith('dispatch-') || !entry.endsWith('.json'))
-            continue;
-        const fullPath = join(dir, entry);
-        scanned += 1;
-        const record = readRecordOrNull(fullPath);
-        if (record === null)
-            continue;
-        if (record.completedAt !== null)
-            continue; // already finished
-        const cancelled = {
-            ...record,
-            completedAt: now().toISOString(),
-            outcome: CANCELLED_OUTCOME,
-            status: CANCELLED_STATUS,
-            disposed: true,
-            disposedAt: now().toISOString()
-        };
-        writeFileSync(fullPath, JSON.stringify(cancelled, null, 2) + '\n', 'utf8');
-        cancelledPaths.push(fullPath);
-    }
-    return { cancelled: cancelledPaths.length, scanned, paths: cancelledPaths };
-}
-function readRecordOrNull(path) {
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null)
-            return null;
-        const obj = parsed;
-        if (typeof obj.createdAt !== 'string')
-            return null;
-        if (typeof obj.completedAt !== 'string' && obj.completedAt !== null)
-            return null;
-        if (typeof obj.role !== 'string')
-            return null;
-        return obj;
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}

package/dist/src/services/skill/resume-detector.d.ts

@@ -1,54 +0,0 @@
-export type ResumeKind = 'fresh' | 'complete' | 'resume' | 'in-flight';
-/**
- * Step at which the slice should resume. The values are stable strings
- * (not raw step numbers) so log output is greppable and a future
- * workflow reshuffle can keep the names but remap the steps.
- */
-export type ResumePoint = 'rd-planning' | 'rd-review-fanout' | 'rd-perf-baseline' | 'qa-test-cases' | 'qa-execution' | 'qa-validation' | 'txt-handoff';
-/**
- * Mid-implementation RD/QA states. The skill body treats these as
- * "ask the user to confirm the in-flight gate" — there is no safe
- * auto-resume for a slice the LLM is currently driving.
- */
-export type InFlightState = 'spec-locked' | 'implemented' | 'running' | 'blocked';
-export type ResumeClassification = {
-    kind: ResumeKind;
-    /** Set when `kind === 'resume'`; the step that should be re-entered. */
-    point: ResumePoint | null;
-    /** Set when `kind === 'in-flight'`; the current non-terminal state. */
-    state: InFlightState | null;
-    /**
-     * Files that the SKILL.md spec says should already exist for the
-     * current gate but were not found. Informational — the LLM uses this
-     * to decide what to produce next. Includes legacy-missing files when
-     * the legacy path was read.
-     */
-    missingArtifacts: string[];
-    /**
-     * Inconsistencies between state and file presence (e.g. RD is
-     * `state: qa-handoff` but `rd/code-review.md` is absent). The
-     * classifier still emits a `resume:` verdict, but the warning is the
-     * audit trail.
-     */
-    warnings: string[];
-    /** Number of RD/QA requests filtered as `user-requested-abandon`. */
-    abandonedRequestCount: number;
-    /**
-     * True when the canonical `.peaks/_runtime/<sid>/` path was absent
-     * and the classifier fell back to `.peaks/_runtime/<sid>/`. Lets the SKILL.md
-     * surface a one-time migration reminder to the user.
-     */
-    usedLegacyPath: boolean;
-};
-/**
- * Classify a session's resume state. Pure function — does not write
- * files, does not call any peaks CLI.
- *
- * @param sid        The session id (e.g. `2026-06-06-session-22f08c`).
- * @param peaksRoot  The canonical peaks runtime root, i.e. the
- *                   directory containing `<sid>/` subdirs. For the
- *                   v1.3.2 layout this is `<repo>/.peaks/_runtime`.
- *                   The legacy `<repo>/.peaks` layout is also accepted
- *                   for one minor release (see `usedLegacyPath`).
- */
-export declare function classifyResume(sid: string, peaksRoot: string): ResumeClassification;

package/dist/src/services/skill/resume-detector.js

@@ -1,334 +0,0 @@
-/**
- * Peaks-Loop Code Step 0.7 — Resume-mode detector.
- *
- * Mirrors the classification table in
- * `skills/peaks-code/SKILL.md` "Peaks-Loop Step 0.7: Detect unfinished work
- * and offer resume". The function is a pure read of session artifacts;
- * it performs no side effects and is safe to call from hooks, scripts,
- * and skills.
- *
- * Two classification sources are merged:
- *   1. State-based (PRD / RD / QA request artifact `state:` field) →
- *      determines the *deepest completed gate*.
- *   2. File-presence ("Other resume triggers" table) → if a required
- *      artifact is missing for a gate that state says is complete, the
- *      classifier emits a `resume:<earlier-point>` verdict AND a
- *      `warnings[]` entry flagging the inconsistency.
- *
- * Primary vs. abandoned filter: when multiple RD/QA request artifacts
- * exist for the same session (the 8-slice governance pass leaves
- * `deferred`/`abandoned` artifacts alongside the active one), the
- * classifier filters out files whose `state: blocked` field is paired
- * with a `user-requested-abandon` transition note. The remaining
- * artifacts are sorted by filename (alphabetical) and the first is the
- * primary.
- *
- * Legacy path fallback: prefers the canonical
- * `.peaks/_runtime/<sid>/` layout introduced in slice
- * `2026-06-05-peaks-runtime-layer`; falls back to the pre-migration
- * `.peaks/_runtime/<sid>/` for one minor release so older trees do not show as
- * false "fresh". The `usedLegacyPath` field reports which path was
- * read.
- */
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-const MID_IMPL_RD_STATES = new Set([
-    'spec-locked',
-    'implemented',
-    'running',
-    'blocked'
-]);
-/**
- * Classify a session's resume state. Pure function — does not write
- * files, does not call any peaks CLI.
- *
- * @param sid        The session id (e.g. `2026-06-06-session-22f08c`).
- * @param peaksRoot  The canonical peaks runtime root, i.e. the
- *                   directory containing `<sid>/` subdirs. For the
- *                   v1.3.2 layout this is `<repo>/.peaks/_runtime`.
- *                   The legacy `<repo>/.peaks` layout is also accepted
- *                   for one minor release (see `usedLegacyPath`).
- */
-export function classifyResume(sid, peaksRoot) {
-    const resolved = resolveSessionDir(sid, peaksRoot);
-    if (resolved === null) {
-        return {
-            kind: 'fresh',
-            point: null,
-            state: null,
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: 0,
-            usedLegacyPath: false
-        };
-    }
-    const { sessionDir, usedLegacyPath } = resolved;
-    const prdStates = readRequestStates(sessionDir, 'prd');
-    const rdStatesRaw = readRequestStates(sessionDir, 'rd');
-    const qaStatesRaw = readRequestStates(sessionDir, 'qa');
-    // Filter abandoned (state=blocked + user-requested-abandon note).
-    const abandonedRd = rdStatesRaw.filter((s) => s.abandoned);
-    const abandonedQa = qaStatesRaw.filter((s) => s.abandoned);
-    const abandonedCount = abandonedRd.length + abandonedQa.length;
-    // Primary selection filter: when there are MULTIPLE RD/QA requests,
-    // the abandoned ones are excluded from the candidate set so the
-    // classifier surfaces the active slice, not the audit-only trail.
-    // When there is only ONE request, the abandoned flag is informational
-    // only — a single blocked RD with an abandoned note is still the
-    // primary, because the user might want to unblock and continue.
-    const rdStates = rdStatesRaw.length > 1 ? rdStatesRaw.filter((s) => !s.abandoned) : rdStatesRaw;
-    const qaStates = qaStatesRaw.length > 1 ? qaStatesRaw.filter((s) => !s.abandoned) : qaStatesRaw;
-    const primaryPrd = pickPrimary(prdStates);
-    const primaryRd = pickPrimary(rdStates);
-    const primaryQa = pickPrimary(qaStates);
-    // Phase 1: TXT handoff present → workflow complete. Always wins.
-    if (existsSync(join(sessionDir, 'txt', 'handoff.md'))) {
-        return {
-            kind: 'complete',
-            point: null,
-            state: null,
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: abandonedCount,
-            usedLegacyPath
-        };
-    }
-    // Phase 2: every RD/QA request is abandoned (filtered out) AND
-    // there were multiple to begin with. The slice is effectively
-    // dead — return fresh so the user can start over without
-    // re-attaching to the abandoned work.
-    if (primaryRd === null &&
-        primaryQa === null &&
-        abandonedCount > 0 &&
-        (rdStatesRaw.length > 1 || qaStatesRaw.length > 1)) {
-        return {
-            kind: 'fresh',
-            point: null,
-            state: null,
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: abandonedCount,
-            usedLegacyPath
-        };
-    }
-    // Phase 3: mid-implementation RD states (spec-locked / implemented /
-    // running / blocked). Wins over the PRD-handed-off branch because
-    // the slice IS in flight — the LLM should not be told to "re-run
-    // the swarm" when an RD artifact is already mid-edit.
-    if (primaryRd !== null && MID_IMPL_RD_STATES.has(primaryRd.state)) {
-        return {
-            kind: 'in-flight',
-            point: null,
-            state: primaryRd.state,
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: abandonedCount,
-            usedLegacyPath
-        };
-    }
-    // Phase 4: terminal gates (QA verdict-issued / RD qa-handoff / PRD
-    // handed-off, with file-presence overrides).
-    const terminal = classifyTerminalGates(sessionDir, {
-        primaryPrd,
-        primaryRd,
-        primaryQa,
-        usedLegacyPath,
-        abandonedCount
-    });
-    if (terminal !== null)
-        return terminal;
-    // Phase 5: PRD exists with a non-handed-off state — treat as
-    // in-flight:spec-locked placeholder. The user can confirm whether
-    // they want to advance the PRD or start fresh.
-    if (primaryPrd !== null && primaryPrd.state.length > 0) {
-        return {
-            kind: 'in-flight',
-            point: null,
-            state: 'spec-locked',
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: abandonedCount,
-            usedLegacyPath
-        };
-    }
-    return {
-        kind: 'fresh',
-        point: null,
-        state: null,
-        missingArtifacts: [],
-        warnings: [],
-        abandonedRequestCount: abandonedCount,
-        usedLegacyPath
-    };
-}
-function classifyTerminalGates(sessionDir, ctx) {
-    // QA verdict-issued → deepest gate is D. If the test-report is
-    // missing the state is inconsistent; fall back to qa-execution.
-    if (ctx.primaryQa !== null && ctx.primaryQa.state === 'verdict-issued') {
-        const reportPath = join(sessionDir, 'qa', 'test-reports', ctx.primaryQa.filename);
-        if (!existsSync(reportPath)) {
-            return {
-                kind: 'resume',
-                point: 'qa-execution',
-                state: null,
-                missingArtifacts: [`qa/test-reports/${ctx.primaryQa.filename}`],
-                warnings: [
-                    'inconsistent: qa verdict-issued but no qa/test-reports/<rid>.md; CLI gate should have blocked the transition'
-                ],
-                abandonedRequestCount: ctx.abandonedCount,
-                usedLegacyPath: ctx.usedLegacyPath
-            };
-        }
-        return {
-            kind: 'resume',
-            point: 'txt-handoff',
-            state: null,
-            missingArtifacts: ['txt/handoff.md'],
-            warnings: [],
-            abandonedRequestCount: ctx.abandonedCount,
-            usedLegacyPath: ctx.usedLegacyPath
-        };
-    }
-    // RD qa-handoff → deepest gate is C. If the review artifacts are
-    // missing the state is inconsistent; fall back to rd-review-fanout.
-    if (ctx.primaryRd !== null && ctx.primaryRd.state === 'qa-handoff') {
-        const codeReviewPath = join(sessionDir, 'rd', 'code-review.md');
-        const securityReviewPath = join(sessionDir, 'rd', 'security-review.md');
-        const missing = [];
-        if (!existsSync(codeReviewPath))
-            missing.push('rd/code-review.md');
-        if (!existsSync(securityReviewPath))
-            missing.push('rd/security-review.md');
-        if (missing.length > 0) {
-            return {
-                kind: 'resume',
-                point: 'rd-review-fanout',
-                state: null,
-                missingArtifacts: missing,
-                warnings: [
-                    'inconsistent: rd qa-handoff but review artifacts missing; CLI gate should have blocked the transition'
-                ],
-                abandonedRequestCount: ctx.abandonedCount,
-                usedLegacyPath: ctx.usedLegacyPath
-            };
-        }
-        return {
-            kind: 'resume',
-            point: 'qa-validation',
-            state: null,
-            missingArtifacts: ctx.primaryQa === null
-                ? [`qa/test-cases/${ctx.primaryRd.filename}`]
-                : [],
-            warnings: [],
-            abandonedRequestCount: ctx.abandonedCount,
-            usedLegacyPath: ctx.usedLegacyPath
-        };
-    }
-    // PRD handed-off → deepest gate is B. Walk "Other resume triggers"
-    // in priority order: tech-doc > qa/test-cases > in-flight (swarm
-    // converged, RD impl not yet started).
-    if (ctx.primaryPrd !== null && ctx.primaryPrd.state === 'handed-off') {
-        const missing = [];
-        if (!existsSync(join(sessionDir, 'rd', 'tech-doc.md'))) {
-            missing.push('rd/tech-doc.md');
-        }
-        // QA test-cases path: use the RD rid if present, else fall back
-        // to the PRD rid. The rid is shared across roles.
-        const qaCasesRid = ctx.primaryRd !== null
-            ? ctx.primaryRd.filename
-            : ctx.primaryPrd !== null
-                ? ctx.primaryPrd.filename
-                : null;
-        if (qaCasesRid !== null) {
-            const qaCasesPath = join(sessionDir, 'qa', 'test-cases', qaCasesRid);
-            if (!existsSync(qaCasesPath)) {
-                missing.push(`qa/test-cases/${qaCasesRid}`);
-            }
-        }
-        if (missing.includes('rd/tech-doc.md')) {
-            return {
-                kind: 'resume',
-                point: 'rd-planning',
-                state: null,
-                missingArtifacts: missing,
-                warnings: [],
-                abandonedRequestCount: ctx.abandonedCount,
-                usedLegacyPath: ctx.usedLegacyPath
-            };
-        }
-        if (missing.some((m) => m.startsWith('qa/test-cases/'))) {
-            return {
-                kind: 'resume',
-                point: 'qa-test-cases',
-                state: null,
-                missingArtifacts: missing,
-                warnings: [],
-                abandonedRequestCount: ctx.abandonedCount,
-                usedLegacyPath: ctx.usedLegacyPath
-            };
-        }
-        // All post-PRD artifacts present. Either the RD is mid-impl
-        // (handled upstream in Phase 3) or the swarm converged but the
-        // implementation has not yet started. Report the latter as
-        // in-flight:spec-locked so the user can confirm.
-        return {
-            kind: 'in-flight',
-            point: null,
-            state: 'spec-locked',
-            missingArtifacts: [],
-            warnings: [],
-            abandonedRequestCount: ctx.abandonedCount,
-            usedLegacyPath: ctx.usedLegacyPath
-        };
-    }
-    return null;
-}
-/**
- * Resolve the session directory. Prefers the canonical
- * `.peaks/_runtime/<sid>/`; falls back to the legacy
- * `.peaks/_runtime/<sid>/` (one level up from the runtime root) for one
- * minor release. Returns `null` when neither path exists.
- */
-function resolveSessionDir(sid, peaksRoot) {
-    const canonical = join(peaksRoot, sid);
-    if (existsSync(canonical)) {
-        return { sessionDir: canonical, usedLegacyPath: false };
-    }
-    const legacy = join(peaksRoot, '..', sid);
-    if (existsSync(legacy)) {
-        return { sessionDir: legacy, usedLegacyPath: true };
-    }
-    return null;
-}
-function readRequestStates(sessionDir, role) {
-    const dir = join(sessionDir, role, 'requests');
-    if (!existsSync(dir))
-        return [];
-    return readdirSync(dir)
-        .filter((f) => typeof f === 'string' && f.endsWith('.md'))
-        .sort()
-        .map((filename) => {
-        const full = join(dir, filename);
-        const content = readFileSync(full, 'utf8');
-        return {
-            filename,
-            state: extractState(content),
-            abandoned: hasAbandonedTransitionNote(content)
-        };
-    });
-}
-function extractState(content) {
-    const match = /^-\s*state:\s*(\S+)|^state:\s*(\S+)/m.exec(content);
-    if (match === null)
-        return '';
-    const captured = match[1] ?? match[2] ?? '';
-    return captured.trim();
-}
-function hasAbandonedTransitionNote(content) {
-    return /user-requested-abandon/.test(content);
-}
-function pickPrimary(states) {
-    if (states.length === 0)
-        return null;
-    return states[0] ?? null;
-}

package/dist/src/services/skill/skill-scheduler.d.ts

@@ -1,40 +0,0 @@
-/**
- * G6 — skill-level heartbeat scheduler config.
- *
- * Slice 2026-06-07-sub-agent-dispatch-decouple (G6): the SKILL.md front
- * matter for a Dispatcher (peaks-code / peaks-rd / peaks-qa) can opt
- * into a non-default heartbeat interval by including a line like:
- *
- *   heartbeatIntervalSec: 15
- *
- * The default is 30 s (RL-13 empirical sweet spot). The poller
- * cadence is fixed at 10 s (sub-agent 30 s / poller 10 s is the
- * jitter-resistant offset).
- *
- * This module is a pure-key parser — it takes a SKILL.md body and
- * returns the effective config. The Dispatcher's prompt template
- * for sub-agents is then responsible for inlining the chosen value
- * into the sub-agent prompt so that the LLM knows how often to
- * call `peaks sub-agent heartbeat`.
- *
- * Note: the heartbeat *cadence* the LLM uses is enforced socially
- * (via the prompt), not via any hook. R-1 / R-8 boundary — LLM
- * behaviour is not observable. The user has been explicit about
- * this: "心跳是 sub-agent 主动写, peaks CLI 不观测 LLM 行为".
- */
-export declare const DEFAULT_HEARTBEAT_INTERVAL_SEC = 30;
-export declare const MIN_HEARTBEAT_INTERVAL_SEC = 5;
-export declare const MAX_HEARTBEAT_INTERVAL_SEC = 600;
-export type SkillHeartbeatConfig = {
-    readonly intervalSec: number;
-    /** Source of the chosen value (useful for debugging). */
-    readonly source: 'default' | 'skill-frontmatter';
-};
-/** Parse a SKILL.md body for a `heartbeatIntervalSec: <N>` line. */
-export declare function parseHeartbeatConfig(skillBody: string): SkillHeartbeatConfig;
-/**
- * Build the heartbeat-instruction paragraph to inline in a sub-agent
- * prompt. The LLM reads this and adjusts its `peaks sub-agent
- * heartbeat` cadence accordingly.
- */
-export declare function heartbeatInstructionParagraph(config: SkillHeartbeatConfig): string;