cclaw-cli 0.51.30 → 1.0.0

package/dist/content/ideate-command.js

@@ -1,315 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-import { resolveIdeateFrames } from "./ideate-frames.js";
-import { ideateStructuredAskToolsWithFallback } from "./decision-protocol.js";
-import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
-const IDEATE_SKILL_FOLDER = "flow-ideate";
-const IDEATE_SKILL_NAME = "flow-ideate";
-/**
- * Directory + filename convention for ideate artifacts. These are separate
- * from stage artifacts (00-..08-*.md) because `/cc-ideate` runs outside the
- * critical-path flow state machine and must not collide with stage numbering.
- */
-const IDEATE_ARTIFACT_GLOB = ".cclaw/artifacts/ideate-*.md";
-const IDEATE_ARTIFACT_PATTERN = ".cclaw/artifacts/ideate-<YYYY-MM-DD-slug>.md";
-const IDEATE_RESUME_WINDOW_DAYS = 30;
-const STRUCTURED_ASK_TOOLS = ideateStructuredAskToolsWithFallback();
-export function minimumDistinctIdeateFrames(frameCount, mode = "repo-grounded") {
-    if (frameCount <= 0)
-        return 0;
-    const cap = mode === "repo-grounded" ? 4 : 2;
-    return Math.min(cap, frameCount);
-}
-function renderFrameBullets(frameIds) {
-    return resolveIdeateFrames(frameIds)
-        .map((frame) => `   - ${frame.label} (\`${frame.id}\`)`)
-        .join("\n");
-}
-function renderFrameNames(frameIds) {
-    return resolveIdeateFrames(frameIds)
-        .map((frame) => frame.label)
-        .join(", ");
-}
-export function ideateCommandContract(options = {}) {
-    const frames = resolveIdeateFrames(options.frameIds);
-    const frameBullets = renderFrameBullets(options.frameIds);
-    const minimumDistinctFrames = minimumDistinctIdeateFrames(frames.length, options.mode);
-    return `# /cc-ideate
-
-## Purpose
-
-Repository-improvement ideate mode. Generate a ranked backlog of
-high-value improvements, persist it as an artifact on disk, and end with
-an explicit handoff — either launch \`/cc\` on a chosen candidate in the
-same session, or save/discard the backlog.
-
-## HARD-GATE
-
-${conversationLanguagePolicyMarkdown()}
-- Ideate mode only. Never mutate \`.cclaw/state/flow-state.json\`.
-- Every recommendation cites evidence from the current repository
-  (file path, command output, or knowledge-store entry id).
-- Always write a persisted artifact to
-  \`${IDEATE_ARTIFACT_PATTERN}\`. Chat-only output is not acceptable —
-  the next session must be able to resume.
-- Always end with a structured handoff prompt, not an open question.
-
-## Algorithm
-
-1. **Resume check.** Glob \`${IDEATE_ARTIFACT_GLOB}\`. If any artifact
-   has been modified within the last ${IDEATE_RESUME_WINDOW_DAYS} days,
-   offer the user: continue that backlog, start fresh, or cancel.
-2. **Mode classification.** Explicitly classify subject:
-   \`repo-grounded\` / \`elsewhere-software\` / \`elsewhere-non-software\` / \`narrow\`.
-   Do not assume repo-grounded by default. Repo-grounded scans keep the
-   broadest frame minimum; narrow and non-repo modes use the smaller minimum
-   shown below.
-3. **Mode-aware grounding (parallel).**
-   - Repo-grounded: repo signal scan + \`${RUNTIME_ROOT}/knowledge.jsonl\`
-     repetition scan.
-   - Elsewhere-software: docs-first grounding (Context7 and official docs).
-   - Elsewhere-non-software: constraints and objective grounding.
-4. **Divergent ideation frames (parallel).** Generate candidates with
-   configured frames (${frames.length} total):
-${frameBullets}
-   Keep at least ${minimumDistinctFrames} distinct frame outputs in this rendered mode.
-   Deterministic minimum: repo-grounded = 4, narrow/non-repo = 2, always capped
-   by configured frame count.
-5. **Adversarial critique pass.** For each candidate, write the strongest
-   counter-argument, kill weak ideas, and keep survivors only.
-6. **Produce 5-10 survivors** with impact (High/Medium/Low),
-   effort (S/M/L), confidence (High/Medium/Low), **why now**, expected user impact, risk, and one evidence path per
-   survivor.
-7. **Rank by impact/effort/confidence** using
-   \`(impact points / effort cost) * confidence multiplier\` and recommend
-   the top survivor.
-8. **Write the artifact** at
-   \`${IDEATE_ARTIFACT_PATTERN}\` using the schema in the skill.
-8.5 **Seed shelf (optional).** For critiqued-out or deferred ideas that still
-   show upside, write seed notes to
-   \`${RUNTIME_ROOT}/seeds/SEED-<YYYY-MM-DD>-<slug>.md\` with
-   \`trigger_when\`, hypothesis, and suggested action.
-9. **Present the handoff prompt** with four concrete options — not A/B/C
-   letters. Default = "Start /cc on the top recommendation".
-
-## Headless mode
-
-For skill-to-skill invocation, emit exactly one JSON envelope:
-
-\`\`\`json
-{"version":"1","kind":"stage-output","stage":"non-flow","payload":{"command":"/cc-ideate","artifact":".cclaw/artifacts/ideate-<date>-<slug>.md","recommendation":"I-1"},"emittedAt":"<ISO-8601>"}
-\`\`\`
-
-Validate envelopes with:
-\`cclaw internal envelope-validate --stdin\`
-
-## Primary skill
-
-   **${RUNTIME_ROOT}/skills/${IDEATE_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function ideateCommandSkillMarkdown(options = {}) {
-    const frames = resolveIdeateFrames(options.frameIds);
-    const frameBullets = renderFrameBullets(options.frameIds);
-    const minimumDistinctFrames = minimumDistinctIdeateFrames(frames.length, options.mode);
-    const frameNames = renderFrameNames(options.frameIds);
-    return `---
-name: ${IDEATE_SKILL_NAME}
-description: "Repository ideate mode: detect and rank high-leverage improvements, persist a backlog artifact, and hand off to /cc or save/discard."
----
-
-# /cc-ideate
-
-## Announce at start
-
-"Using flow-ideate to identify highest-leverage improvements in this
-repository. Will persist a ranked backlog to
-\`${IDEATE_ARTIFACT_PATTERN}\` and end with an explicit handoff."
-
-## HARD-GATE
-
-${conversationLanguagePolicyMarkdown()}
-- Do not start coding in ideate mode.
-- Do not mutate \`.cclaw/state/flow-state.json\` — ideate mode sits outside
-  the critical-path flow.
-- Always produce the artifact file on disk before presenting the handoff.
-- Always end with a structured handoff that names the concrete follow-up
-  command for each option. No A/B/C letters without command context.
-
-## Protocol
-
-### Phase 0 — Resume and classify
-
-1. Use the harness's file-glob tool (\`Glob\` pattern
-   \`${IDEATE_ARTIFACT_GLOB}\` or equivalent \`ls\`/\`find\`).
-2. Filter to files modified within the last ${IDEATE_RESUME_WINDOW_DAYS} days.
-3. If one or more match, present **one** structured ask using the
-   harness's native tool (${STRUCTURED_ASK_TOOLS}) with options:
-   - **Continue the existing backlog** — read the most-recent
-     ideate-*.md and work from its candidate list; skip re-scanning.
-   - **Start a fresh scan** — proceed to Phase 1; the old artifact stays
-     on disk for history.
-   - **Cancel** — stop; do not scan or write anything.
-4. If no recent artifact exists, proceed to Phase 1 silently.
-5. Classify the ideation mode before grounding:
-   - \`repo-grounded\` — explicitly tied to this repository.
-   - \`elsewhere-software\` — software problem not tied to this repository.
-   - \`elsewhere-non-software\` — process/business/non-software problem.
-   - \`narrow\` — a focused prompt where broad frame coverage would be performative.
-6. Record the chosen mode in the artifact.
-
-### Phase 1 — Mode-aware grounding
-
-Run grounding in parallel where available:
-
-- For \`repo-grounded\`:
-  - \`rg -n 'TODO|FIXME|XXX|HACK|TBD'\` grouped by file.
-  - Test-runner output (\`npm test\`, \`pytest\`, \`go test ./...\`) — note
-    failures, timeouts, deprecation warnings.
-  - Module size outliers (\`wc -l\` or \`du\`) with weak direct test coverage.
-  - Docs drift: check that \`README.md\` / \`docs/\` reference files that still
-    exist and flags/APIs that still match \`src/\`.
-  - \`${RUNTIME_ROOT}/knowledge.jsonl\` entries with recurring \`type\` in \`rule | pattern | lesson | compound\` and repeated \`trigger/action\` pairs; prefer clusters that already show stable \`origin_run\` history.
-- For \`elsewhere-software\`:
-  - Gather current framework/library docs first.
-  - Add one comparison scan for established solutions.
-- For \`elsewhere-non-software\`:
-  - Capture objective, constraints, and measured friction before proposing fixes.
-
-Record each finding with exact evidence (path, command, or doc source).
-
-### Phase 2 — Divergent ideation
-
-Generate candidate ideas by frame, in parallel when possible:
-
-${frameBullets}
-
-Require at least ${minimumDistinctFrames} distinct frames in this rendered mode. The
-runtime rule is deterministic: repo-grounded scans require 4 distinct frames;
-narrow, elsewhere-software, and elsewhere-non-software runs require 2; all modes
-are capped by the configured frame count. Avoid frame-collapse (same idea
-rewritten many times). Keep raw outputs for auditability.
-
-### Phase 3 — Critique all, keep survivors
-
-For each raw candidate:
-
-- Write strongest argument **against** this idea.
-- Identify disqualifiers (duplicate, weak evidence, poor ROI, wrong timing).
-- Mark as \`survivor\` or \`critiqued-out\`.
-
-Only survivors advance to ranking.
-
-### Phase 4 — Rank and write the artifact
-
-1. Keep 5–10 survivors.
-2. For each survivor, include:
-   - **ID** — \`I-1\`, \`I-2\`, …
-   - **Title** — one short imperative phrase
-   - **Impact** — High / Medium / Low
-   - **Effort** — S / M / L
-   - **Confidence** — High / Medium / Low
-   - **Evidence** — path(s) or command output, inline if short
-   - **Why now** — timing signal from repo evidence, user friction, repeated knowledge, or blocked flow
-   - **Expected impact** — concrete user-facing benefit if this lands
-   - **Risk** — main implementation/product risk to manage
-   - **Counter-argument** — strongest concern that survived
-   - **Next /cc prompt** — exact \`/cc <phrase>\` that starts the work
-3. Sort by score \`(impact points / effort cost) * confidence multiplier\`
-   and break ties with rationale strength.
-4. Compute the artifact filename:
-   - \`slug\` = first 3–5 words of the top recommendation, lowercase,
-     non-alphanumeric collapsed to \`-\`, trimmed. When ideate mode is
-     focus-hinted (user passed an argument), use the focus hint instead.
-   - \`date\` = today in \`YYYY-MM-DD\` (local time).
-   - Path = \`.cclaw/artifacts/ideate-<date>-<slug>.md\`.
-5. Use the harness's write-file tool (\`Write\`, \`apply_patch\`, or shell
-   \`cat <<EOF > path\`) to create the artifact with this schema:
-
-   \`\`\`markdown
-   # Ideation — <date>
-
-   **Focus:** <user-supplied focus or "open-ended scan">
-   **Mode:** <repo-grounded | elsewhere-software | elsewhere-non-software | narrow>
-   **Generated:** <ISO-8601 timestamp>
-   **Frames used:** <comma-separated list>
-   **Raw candidates:** <N>
-   **Critiqued out:** <M>
-   **Recommendation:** I-1
-
-   ## Grounding evidence
-
-   - <signal and evidence>
-   - ...
-
-   ## Critiqued out
-
-   | Idea | Why it was rejected |
-   |---|---|
-   | ... | ... |
-
-   ## Ranked survivors
-
-   | ID | Improvement | Why now | Expected impact | Risk | Impact | Effort | Confidence | Evidence | Next /cc prompt |
-   |---|---|---|---|---|---|---|---|---|---|
-| I-1 | Simplify a confusing generated prompt surface | Repeated blocker in generated UX | Faster operator recovery | Might over-trim context | High | S | High | <path-to-generated-surface> | \`/cc Simplify the confusing generated prompt surface while preserving behavior\` |
-   | …   | …                                  | …    | … | …    | …                                     |
-
-   ## Candidate detail
-
-### I-1 — Simplify a confusing generated prompt surface
-- **Evidence:** \`<path>\` contains repeated or stale guidance that a user would see.
-- **Why now:** The prompt is on the daily /cc path, so confusion compounds quickly.
-- **Expected impact:** Operators get a clearer next action without changing gates.
-- **Risk:** Trimming too hard can remove useful orientation for new users.
-- **Next /cc prompt:** \`/cc Simplify the confusing generated prompt surface while preserving behavior\`
-
-   ### I-2 — …
-   \`\`\`
-
-6. Optional: for promising non-selected ideas, write
-   \`${RUNTIME_ROOT}/seeds/SEED-<YYYY-MM-DD>-<slug>.md\` entries with:
-   \`title\`, \`trigger_when\`, \`hypothesis\`, \`action\`, and
-   \`source_artifact\` = ideate artifact path.
-7. Confirm in chat: "Wrote <path>."
-
-### Phase 5 — Handoff prompt
-
-Present **one** structured ask using the harness's native tool
-(${STRUCTURED_ASK_TOOLS}). Each option must name the concrete follow-up —
-no bare A/B/C.
-
-Required options, in this order:
-
-1. **Start /cc on the top recommendation** — the agent immediately loads
-   \`${RUNTIME_ROOT}/skills/using-cclaw/SKILL.md\` and invokes
-   \`/cc <I-1 handoff phrase>\` in the same turn. Default choice.
-2. **Pick a different candidate** — the agent asks which ID (I-2, I-3, …)
-   and then invokes \`/cc <that candidate's handoff phrase>\`.
-3. **Save and close** — leave the artifact on disk, do nothing else.
-   Next session: \`/cc-ideate\` will offer to resume it.
-4. **Discard** — delete the just-written artifact. Use only when the
-   scan produced nothing actionable.
-
-When the structured-ask tool is unavailable, fall back to a plain-text
-lettered list with the same four labels. Do not invent extra options.
-
-### Phase 6 — Execute the choice
-
-- **Start /cc on I-1** or **different candidate:** announce
-  "Handing off to /cc <phrase>" and load the \`using-cclaw\` router
-  skill. From there, the normal \`/cc\` classification and stage flow
-  takes over. Do not produce a second artifact; the ideate file is
-  preserved as the origin document for this run.
-- **Save and close:** reply with the artifact path and stop.
-- **Discard:** delete the artifact file, confirm deletion, stop.
-
-## Do not
-
-- Do not write into \`.cclaw/artifacts/0X-*.md\` (stage artifacts).
-- Do not mutate \`.cclaw/state/flow-state.json\` at any phase.
-- Do not end the turn with an ungrounded "pick one" question — every
-  option in the handoff prompt must reference a concrete command.
-- Do not collapse all ideas into one frame; distribute across:
-  ${frameNames}.
-`;
-}

package/dist/content/ideate-frames.d.ts

@@ -1,31 +0,0 @@
-export type IdeateFrameId = "pain-friction" | "inversion" | "assumption-break" | "leverage" | "cross-domain-analogy" | "constraint-flip";
-export interface IdeateFrame {
-    id: IdeateFrameId;
-    label: string;
-    prompt: string;
-    examplePatterns: string[];
-}
-export interface IdeateFrameDispatchInput {
-    focus: string;
-    mode: "repo-grounded" | "elsewhere-software" | "elsewhere-non-software";
-    signalSummary: string[];
-}
-export interface IdeateFrameDispatchPlanEntry {
-    frameId: IdeateFrameId;
-    label: string;
-    prompt: string;
-}
-export interface IdeateCandidateDraft {
-    title: string;
-    evidencePath: string;
-    summary: string;
-    frameId: IdeateFrameId;
-}
-export interface IdeateCandidateMerged extends Omit<IdeateCandidateDraft, "frameId"> {
-    frameIds: IdeateFrameId[];
-}
-export declare const DEFAULT_IDEATE_FRAME_IDS: readonly IdeateFrameId[];
-export declare const IDEATE_FRAMES: readonly IdeateFrame[];
-export declare function resolveIdeateFrames(frameIds?: readonly IdeateFrameId[]): IdeateFrame[];
-export declare function buildIdeateFrameDispatchPlan(input: IdeateFrameDispatchInput, frameIds?: readonly IdeateFrameId[]): IdeateFrameDispatchPlanEntry[];
-export declare function dedupeIdeateCandidates(drafts: readonly IdeateCandidateDraft[]): IdeateCandidateMerged[];

package/dist/content/ideate-frames.js

@@ -1,140 +0,0 @@
-const FRAME_REGISTRY = {
-    "pain-friction": {
-        id: "pain-friction",
-        label: "pain/friction",
-        prompt: "Find repeated friction in the repo workflow. Prioritize changes that eliminate recurring toil, fragile handoffs, or repeated manual recovery.",
-        examplePatterns: [
-            "Repeated TODO/FIXME hotspots in one subsystem",
-            "Flows that require manual retries or ad-hoc scripts",
-            "Developer loops slowed by avoidable boilerplate"
-        ]
-    },
-    inversion: {
-        id: "inversion",
-        label: "inversion",
-        prompt: "Invert a dominant assumption in the current implementation (e.g., push vs pull, synchronous vs queued, implicit vs explicit) and evaluate upside.",
-        examplePatterns: [
-            "Replace optimistic assumptions with fail-closed defaults",
-            "Switch from post-facto checks to pre-flight validation",
-            "Move from global policy to module-local contracts"
-        ]
-    },
-    "assumption-break": {
-        id: "assumption-break",
-        label: "assumption-break",
-        prompt: "List assumptions that might be false in production. Generate ideas that remain correct even when those assumptions fail.",
-        examplePatterns: [
-            "Edge paths currently treated as impossible",
-            "Implicit coupling between modules with no explicit contract",
-            "Latency, scale, or environment assumptions baked into logic"
-        ]
-    },
-    leverage: {
-        id: "leverage",
-        label: "leverage",
-        prompt: "Target interventions with asymmetric payoff: one change that improves multiple stages, teams, or failure classes at once.",
-        examplePatterns: [
-            "A shared helper replacing duplicated logic in many files",
-            "One lint/gate that blocks an entire class of regressions",
-            "A protocol update that improves multiple stage outputs"
-        ]
-    },
-    "cross-domain-analogy": {
-        id: "cross-domain-analogy",
-        label: "cross-domain analogy",
-        prompt: "Borrow a proven pattern from another domain and adapt it to this repo. Keep it concrete and grounded in local constraints.",
-        examplePatterns: [
-            "Apply SRE-style error budgets to planning artifacts",
-            "Use security threat-model thinking for reliability design",
-            "Import CI release-train discipline into stage completion gates"
-        ]
-    },
-    "constraint-flip": {
-        id: "constraint-flip",
-        label: "constraint-flip",
-        prompt: "Flip one assumed constraint (time, team size, risk tolerance, compatibility) and derive better options under the new boundary.",
-        examplePatterns: [
-            "Assume near-zero migration window and redesign rollout",
-            "Assume one maintainer and optimize for low operational burden",
-            "Assume strict auditability and remove ambiguous behaviors"
-        ]
-    }
-};
-export const DEFAULT_IDEATE_FRAME_IDS = Object.freeze([
-    "pain-friction",
-    "inversion",
-    "assumption-break",
-    "leverage",
-    "cross-domain-analogy",
-    "constraint-flip"
-]);
-export const IDEATE_FRAMES = Object.freeze(DEFAULT_IDEATE_FRAME_IDS.map((id) => FRAME_REGISTRY[id]));
-export function resolveIdeateFrames(frameIds) {
-    if (!frameIds || frameIds.length === 0) {
-        return [...IDEATE_FRAMES];
-    }
-    const seen = new Set();
-    const resolved = [];
-    for (const rawId of frameIds) {
-        if (!DEFAULT_IDEATE_FRAME_IDS.includes(rawId)) {
-            throw new Error(`Unknown ideate frame id: ${rawId}`);
-        }
-        if (seen.has(rawId))
-            continue;
-        seen.add(rawId);
-        resolved.push(FRAME_REGISTRY[rawId]);
-    }
-    return resolved;
-}
-export function buildIdeateFrameDispatchPlan(input, frameIds) {
-    const signalBlock = input.signalSummary.length > 0
-        ? input.signalSummary.map((line) => `- ${line}`).join("\n")
-        : "- no pre-scan signals captured yet";
-    return resolveIdeateFrames(frameIds).map((frame) => ({
-        frameId: frame.id,
-        label: frame.label,
-        prompt: [
-            `Frame: ${frame.label} (${frame.id})`,
-            `Mode: ${input.mode}`,
-            `Focus: ${input.focus || "open-ended scan"}`,
-            "",
-            "Signal summary:",
-            signalBlock,
-            "",
-            `Frame prompt: ${frame.prompt}`,
-            "",
-            "Generate 3-5 concrete candidates with repo-grounded evidence."
-        ].join("\n")
-    }));
-}
-function normalizeCandidateKey(title, evidencePath) {
-    const normalizedTitle = title.trim().toLowerCase().replace(/[^a-z0-9]+/gu, " ").trim();
-    const normalizedEvidence = evidencePath
-        .trim()
-        .toLowerCase()
-        .replace(/\\/gu, "/");
-    return `${normalizedTitle}::${normalizedEvidence}`;
-}
-export function dedupeIdeateCandidates(drafts) {
-    const merged = new Map();
-    for (const draft of drafts) {
-        const key = normalizeCandidateKey(draft.title, draft.evidencePath);
-        const existing = merged.get(key);
-        if (!existing) {
-            merged.set(key, {
-                title: draft.title,
-                evidencePath: draft.evidencePath,
-                summary: draft.summary,
-                frameIds: [draft.frameId]
-            });
-            continue;
-        }
-        if (!existing.frameIds.includes(draft.frameId)) {
-            existing.frameIds.push(draft.frameId);
-        }
-        if (draft.summary.length > existing.summary.length) {
-            existing.summary = draft.summary;
-        }
-    }
-    return [...merged.values()];
-}

package/dist/content/ideate-ranking.d.ts

@@ -1,25 +0,0 @@
-export type IdeateImpact = "high" | "medium" | "low";
-export type IdeateEffort = "s" | "m" | "l";
-export type IdeateConfidence = "high" | "medium" | "low";
-export interface IdeateCandidateEvaluationInput {
-    id: string;
-    title: string;
-    impact: IdeateImpact;
-    effort: IdeateEffort;
-    confidence: IdeateConfidence;
-    rationaleStrength: number;
-    counterArgumentStrength: number;
-}
-export interface IdeateCandidateEvaluation extends IdeateCandidateEvaluationInput {
-    disposition: "survivor" | "critiqued-out";
-    rankingScore: number;
-}
-export interface IdeateRankingResult {
-    survivors: IdeateCandidateEvaluation[];
-    critiquedOut: IdeateCandidateEvaluation[];
-    recommendationId: string | null;
-}
-export declare function isCritiquedOut(rationaleStrength: number, counterArgumentStrength: number): boolean;
-export declare function scoreIdeateCandidate(impact: IdeateImpact, effort: IdeateEffort, confidence: IdeateConfidence): number;
-export declare function evaluateIdeateCandidate(input: IdeateCandidateEvaluationInput): IdeateCandidateEvaluation;
-export declare function rankIdeateCandidates(inputs: readonly IdeateCandidateEvaluationInput[], maxSurvivors?: number): IdeateRankingResult;

package/dist/content/ideate-ranking.js

@@ -1,65 +0,0 @@
-const IMPACT_POINTS = {
-    high: 9,
-    medium: 6,
-    low: 3
-};
-const EFFORT_COST = {
-    s: 1,
-    m: 2,
-    l: 3
-};
-const CONFIDENCE_MULTIPLIER = {
-    high: 1,
-    medium: 0.75,
-    low: 0.5
-};
-function clampStrength(value) {
-    if (!Number.isFinite(value))
-        return 0;
-    if (value < 0)
-        return 0;
-    if (value > 1)
-        return 1;
-    return value;
-}
-export function isCritiquedOut(rationaleStrength, counterArgumentStrength) {
-    return clampStrength(counterArgumentStrength) > clampStrength(rationaleStrength);
-}
-export function scoreIdeateCandidate(impact, effort, confidence) {
-    const raw = (IMPACT_POINTS[impact] / EFFORT_COST[effort]) * CONFIDENCE_MULTIPLIER[confidence];
-    return Number(raw.toFixed(3));
-}
-export function evaluateIdeateCandidate(input) {
-    const disposition = isCritiquedOut(input.rationaleStrength, input.counterArgumentStrength)
-        ? "critiqued-out"
-        : "survivor";
-    return {
-        ...input,
-        disposition,
-        rankingScore: scoreIdeateCandidate(input.impact, input.effort, input.confidence)
-    };
-}
-export function rankIdeateCandidates(inputs, maxSurvivors = 10) {
-    const evaluated = inputs.map(evaluateIdeateCandidate);
-    const survivors = evaluated
-        .filter((candidate) => candidate.disposition === "survivor")
-        .sort((left, right) => {
-        if (right.rankingScore !== left.rankingScore) {
-            return right.rankingScore - left.rankingScore;
-        }
-        if (right.rationaleStrength !== left.rationaleStrength) {
-            return right.rationaleStrength - left.rationaleStrength;
-        }
-        return left.id.localeCompare(right.id);
-    })
-        .slice(0, Math.max(0, maxSurvivors));
-    const survivorIds = new Set(survivors.map((candidate) => candidate.id));
-    const critiquedOut = evaluated
-        .filter((candidate) => candidate.disposition === "critiqued-out" || !survivorIds.has(candidate.id))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    return {
-        survivors,
-        critiquedOut,
-        recommendationId: survivors[0]?.id ?? null
-    };
-}

package/dist/content/next-command.d.ts

@@ -1,20 +0,0 @@
-/**
- * Single source of truth for how /cc-next should treat Ralph Loop status.
- *
- * IMPORTANT: Ralph Loop is a **progress indicator + soft pre-advance nudge**,
- * not a hard gate. Hard enforcement always flows through flow-state.json
- * gates via `stage-complete.mjs`. Both the command contract and the skill
- * document render this same paragraph to prevent drift — see
- * `tests/e2e/next-command-ralph-loop-contract.test.ts`.
- */
-export declare const RALPH_LOOP_CONTRACT_MARKER = "ralph-loop-contract:v1";
-export declare function ralphLoopContractSnippet(): string;
-/**
- * Internal compatibility contract for /cc-next.
- * /cc is the promoted public progression command; this remains as an internal/legacy alias.
- */
-export declare function nextCommandContract(): string;
-/**
- * Skill body for /cc-next — the primary flow progression command.
- */
-export declare function nextCommandSkillMarkdown(): string;