cclaw-cli 0.48.30 → 0.48.32

package/dist/config.d.ts

@@ -42,7 +42,7 @@ export declare function readConfig(projectRoot: string): Promise<CclawConfig>;
  * the user set them explicitly. Keeps the default template small and honest:
  * only knobs a new user would meaningfully flip show up.
  */
-type AdvancedConfigKey = "tddTestGlobs" | "tdd" | "compound" | "defaultTrack" | "languageRulePacks" | "trackHeuristics" | "sliceReview" | "ironLaws";
+type AdvancedConfigKey = "tddTestGlobs" | "tdd" | "compound" | "defaultTrack" | "languageRulePacks" | "trackHeuristics" | "sliceReview" | "ironLaws" | "optInAudits" | "reviewLoop";
 /**
  * Options controlling the serialisation shape of `config.yaml`.
  *

package/dist/config.js

@@ -25,7 +25,9 @@ const ALLOWED_CONFIG_KEYS = new Set([
     "languageRulePacks",
     "trackHeuristics",
     "sliceReview",
-    "ironLaws"
+    "ironLaws",
+    "optInAudits",
+    "reviewLoop"
 ]);
 /**
  * Config keys removed in the advisory-by-default consolidation. Kept here so
@@ -429,6 +431,76 @@ export async function readConfig(projectRoot) {
     else {
         ironLaws = { strictLaws: [] };
     }
+    const optInAuditsRaw = parsed.optInAudits;
+    let optInAudits = undefined;
+    if (Object.prototype.hasOwnProperty.call(parsed, "optInAudits")) {
+        if (!isRecord(optInAuditsRaw)) {
+            throw configValidationError(fullPath, `"optInAudits" must be an object`);
+        }
+        const unknownOptInAuditKeys = Object.keys(optInAuditsRaw).filter((key) => key !== "scopePreAudit" && key !== "staleDiagramAudit");
+        if (unknownOptInAuditKeys.length > 0) {
+            throw configValidationError(fullPath, `"optInAudits" has unknown key(s): ${unknownOptInAuditKeys.join(", ")}`);
+        }
+        if (optInAuditsRaw.scopePreAudit !== undefined &&
+            typeof optInAuditsRaw.scopePreAudit !== "boolean") {
+            throw configValidationError(fullPath, `"optInAudits.scopePreAudit" must be a boolean`);
+        }
+        if (optInAuditsRaw.staleDiagramAudit !== undefined &&
+            typeof optInAuditsRaw.staleDiagramAudit !== "boolean") {
+            throw configValidationError(fullPath, `"optInAudits.staleDiagramAudit" must be a boolean`);
+        }
+        optInAudits = {
+            scopePreAudit: typeof optInAuditsRaw.scopePreAudit === "boolean"
+                ? optInAuditsRaw.scopePreAudit
+                : false,
+            staleDiagramAudit: typeof optInAuditsRaw.staleDiagramAudit === "boolean"
+                ? optInAuditsRaw.staleDiagramAudit
+                : false
+        };
+    }
+    const reviewLoopRaw = parsed.reviewLoop;
+    let reviewLoop = undefined;
+    if (Object.prototype.hasOwnProperty.call(parsed, "reviewLoop")) {
+        if (!isRecord(reviewLoopRaw)) {
+            throw configValidationError(fullPath, `"reviewLoop" must be an object`);
+        }
+        const unknownReviewLoopKeys = Object.keys(reviewLoopRaw).filter((key) => key !== "externalSecondOpinion");
+        if (unknownReviewLoopKeys.length > 0) {
+            throw configValidationError(fullPath, `"reviewLoop" has unknown key(s): ${unknownReviewLoopKeys.join(", ")}`);
+        }
+        const externalRaw = reviewLoopRaw.externalSecondOpinion;
+        let externalSecondOpinion = undefined;
+        if (externalRaw !== undefined) {
+            if (!isRecord(externalRaw)) {
+                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion" must be an object`);
+            }
+            const unknownExternalKeys = Object.keys(externalRaw).filter((key) => key !== "enabled" && key !== "model" && key !== "scoreDeltaThreshold");
+            if (unknownExternalKeys.length > 0) {
+                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion" has unknown key(s): ${unknownExternalKeys.join(", ")}`);
+            }
+            if (externalRaw.enabled !== undefined && typeof externalRaw.enabled !== "boolean") {
+                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.enabled" must be a boolean`);
+            }
+            if (externalRaw.model !== undefined && typeof externalRaw.model !== "string") {
+                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.model" must be a string`);
+            }
+            if (externalRaw.scoreDeltaThreshold !== undefined &&
+                (typeof externalRaw.scoreDeltaThreshold !== "number" ||
+                    Number.isNaN(externalRaw.scoreDeltaThreshold) ||
+                    externalRaw.scoreDeltaThreshold < 0 ||
+                    externalRaw.scoreDeltaThreshold > 1)) {
+                throw configValidationError(fullPath, `"reviewLoop.externalSecondOpinion.scoreDeltaThreshold" must be a number between 0 and 1`);
+            }
+            externalSecondOpinion = {
+                enabled: externalRaw.enabled === true,
+                model: typeof externalRaw.model === "string" ? externalRaw.model : undefined,
+                scoreDeltaThreshold: typeof externalRaw.scoreDeltaThreshold === "number"
+                    ? externalRaw.scoreDeltaThreshold
+                    : 0.2
+            };
+        }
+        reviewLoop = { externalSecondOpinion };
+    }
     return {
         version: parsed.version ?? CCLAW_VERSION,
         flowVersion: parsed.flowVersion ?? FLOW_VERSION,
@@ -447,7 +519,9 @@ export async function readConfig(projectRoot) {
         languageRulePacks,
         trackHeuristics,
         sliceReview,
-        ironLaws
+        ironLaws,
+        optInAudits,
+        reviewLoop
     };
 }
 function isMinimalKey(key) {
@@ -470,7 +544,9 @@ function buildSerializableConfig(config, options = {}) {
         "languageRulePacks",
         "trackHeuristics",
         "sliceReview",
-        "ironLaws"
+        "ironLaws",
+        "optInAudits",
+        "reviewLoop"
     ];
     for (const key of ordered) {
         const value = config[key];
@@ -523,7 +599,9 @@ export async function detectAdvancedKeys(projectRoot) {
             "languageRulePacks",
             "trackHeuristics",
             "sliceReview",
-            "ironLaws"
+            "ironLaws",
+            "optInAudits",
+            "reviewLoop"
         ];
         const present = new Set();
         for (const key of advancedCandidates) {

package/dist/content/examples.js

@@ -18,18 +18,35 @@ const STAGE_EXAMPLES = {
 | 2 | Should the validation logic live in a reusable module or stay as shell scripts? | Reusable module. | Architecture: shared TypeScript module imported by CI and local tooling, not duplicated shell scripts. |
 | 3 | For v1, prioritize rapid delivery or maximum configurability? | Rapid delivery. | Minimal deterministic validation surface; defer plugin/config system to v2. |
 
+## Approach Tier
+
+- **Tier:** Standard
+- **Why this tier:** Change spans CI + local release workflow and shared module boundaries, but remains bounded to one subsystem.
+
+## Short-Circuit Decision
+
+- **Status:** bypassed
+- **Why:** Core requirements were not concrete enough initially; we still needed options + trade-off conversation.
+- **Scope handoff:** Continue full brainstorm flow before scope.
+
 ## Approaches
 
-| Approach | Architecture | Trade-offs | Recommendation |
-| --- | --- | --- | --- |
-| A: Reusable validation module | Shared TS module with typed validators, imported by CI scripts and local CLI. Existing \`pre-publish.sh\` calls the module. | Medium upfront effort, high reuse. Requires test coverage for the module. | **Recommended** — best balance of reuse and delivery speed. |
-| B: Hardened shell scripts | Keep existing script approach, add stricter checks and error messages. | Lowest effort. Weak reuse, CI/local divergence risk grows over time. | Viable fallback if TS module is blocked. |
-| C: Full release framework | New release orchestrator with plugin system, config files, rollback commands. | Maximum flexibility. High risk, delivery delay, over-engineered for current needs. | Not recommended for v1. |
+| Approach | Role | Architecture | Trade-offs | Recommendation |
+| --- | --- | --- | --- | --- |
+| A: Reusable validation module | baseline | Shared TS module with typed validators, imported by CI scripts and local CLI. Existing \`pre-publish.sh\` calls the module. | Medium upfront effort, high reuse. Requires test coverage for the module. | **Recommended** — best balance of reuse and delivery speed. |
+| B: Hardened shell scripts | fallback | Keep existing script approach, add stricter checks and error messages. | Lowest effort. Weak reuse, CI/local divergence risk grows over time. | Viable fallback if TS module is blocked. |
+| C: Full release framework | challenger: higher-upside | New release orchestrator with plugin system, config files, rollback commands. | Maximum flexibility. High risk, delivery delay, over-engineered for current needs. | Not recommended for v1. |
+
+## Approach Reaction
+
+- **Closest option:** A (reusable validation module).
+- **Concerns:** User wanted to avoid framework-level overbuild and keep v1 delivery speed high.
+- **What changed after reaction:** Recommendation stayed on A, but added explicit fallback path via existing shell entrypoint to reduce migration risk.
 
 ## Selected Direction
 
 - **Approach:** A — Reusable validation module
-- **Rationale:** shared TS module gives consistent behavior in CI and local, avoids script duplication, and stays within the no-new-dependency constraint.
+- **Rationale:** based on user reaction favoring fast delivery and lower complexity, shared TS module gives consistent behavior in CI/local, avoids script duplication, and stays within the no-new-dependency constraint.
 - **Approval:** approved
 
 ## Design

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

@@ -1,2 +1,6 @@
-export declare function ideateCommandContract(): string;
-export declare function ideateCommandSkillMarkdown(): string;
+import { type IdeateFrameId } from "./ideate-frames.js";
+export interface IdeateCommandOptions {
+    frameIds?: readonly IdeateFrameId[];
+}
+export declare function ideateCommandContract(options?: IdeateCommandOptions): string;
+export declare function ideateCommandSkillMarkdown(options?: IdeateCommandOptions): string;

package/dist/content/ideate-command.js

@@ -1,4 +1,5 @@
 import { RUNTIME_ROOT } from "../constants.js";
+import { resolveIdeateFrames } from "./ideate-frames.js";
 const IDEATE_SKILL_FOLDER = "flow-ideate";
 const IDEATE_SKILL_NAME = "flow-ideate";
 /**
@@ -18,7 +19,20 @@ const STRUCTURED_ASK_TOOLS = "`AskUserQuestion` on Claude, `AskQuestion` on Curs
     "`question` on OpenCode when `permission.question: \"allow\"` is set, " +
     "`request_user_input` on Codex in Plan / Collaboration mode; " +
     "fall back to a plain-text lettered list when the tool is hidden or errors";
-export function ideateCommandContract() {
+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 = Math.min(4, frames.length);
     return `# /cc-ideate
 
 ## Purpose
@@ -51,17 +65,24 @@ same session, or save/discard the backlog.
      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 at least
-   4 distinct frames: pain/friction, inversion, assumption-break, leverage,
-   cross-domain analogy, constraint-flip.
+4. **Divergent ideation frames (parallel).** Generate candidates with
+   configured frames (${frames.length} total):
+${frameBullets}
+   Keep at least ${minimumDistinctFrames} distinct frame outputs in every run.
 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), and one evidence path per
    survivor.
-7. **Rank by impact/effort**, recommend the top 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".
 
@@ -78,10 +99,14 @@ Validate envelopes with:
 
 ## Primary skill
 
-**${RUNTIME_ROOT}/skills/${IDEATE_SKILL_FOLDER}/SKILL.md**
+   **${RUNTIME_ROOT}/skills/${IDEATE_SKILL_FOLDER}/SKILL.md**
 `;
 }
-export function ideateCommandSkillMarkdown() {
+export function ideateCommandSkillMarkdown(options = {}) {
+    const frames = resolveIdeateFrames(options.frameIds);
+    const frameBullets = renderFrameBullets(options.frameIds);
+    const minimumDistinctFrames = Math.min(4, frames.length);
+    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."
@@ -150,14 +175,9 @@ Record each finding with exact evidence (path, command, or doc source).
 
 Generate candidate ideas by frame, in parallel when possible:
 
-- pain/friction
-- inversion
-- assumption-break
-- leverage
-- cross-domain analogy
-- constraint-flip
+${frameBullets}
 
-Require at least 4 distinct frames in every run. Avoid frame-collapse
+Require at least ${minimumDistinctFrames} distinct frames in every run. Avoid frame-collapse
 (same idea rewritten 6 times). Keep raw outputs for auditability.
 
 ### Phase 3 — Critique all, keep survivors
@@ -182,7 +202,8 @@ Only survivors advance to ranking.
    - **Evidence** — path(s) or command output, inline if short
    - **Counter-argument** — strongest concern that survived
    - **Proposed handoff** — exact \`/cc <phrase>\`
-3. Sort by impact/effort ratio; break ties with confidence.
+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
@@ -231,7 +252,11 @@ Only survivors advance to ranking.
    ### I-2 — …
    \`\`\`
 
-6. Confirm in chat: "Wrote <path>."
+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
 
@@ -270,5 +295,7 @@ lettered list with the same four labels. Do not invent extra options.
 - 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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,65 @@
+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
+    };
+}