open-multi-agent-kit 0.79.1 → 0.79.3

package/dist/goal/interview-assimilation.js

@@ -0,0 +1,383 @@
+// Module: src/goal/interview-assimilation.ts
+// Owner: Deep Interview phase 2 (answer assimilation + conflict resolution + spec-delta apply)
+//
+// Deterministic, offline, NO LLM, NO network. Pure logic over the interview /
+// goal contracts. The only side-effecting call is `new Date().toISOString()`
+// inside `applyInterviewDelta` (the contract's single allowed timestamp site).
+//
+// Conflict resolver priority (highest wins):
+//   1. explicit answer            (a non-skipped, non-empty interview answer)
+//   2. existing explicit value    (e.g. SuccessCriterion.inferred === false,
+//                                   or a non-empty objective NOT derived from
+//                                   the inferred IntentFrame)
+//   3. inferred field             (values produced by intent inference)
+//   4. heuristic default          (scaffolding defaults)
+//
+// `add` ops always append and therefore never contradict. `replace` ops on
+// `objective` / `riskLevel` are the only ones that can collide: when the goal
+// already holds an explicit value and the new answer differs materially, we
+// record a human-readable contradiction (and lower confidence to 0.5) instead
+// of silently overwriting. The downstream `applyInterviewDelta` re-checks the
+// goal state so it stays self-consistent even with externally-built deltas.
+import { INTERVIEW_DELTA_SCHEMA_VERSION } from "../contracts/interview.js";
+const EXPLICIT_CONFIDENCE = 0.9;
+const CONFLICTED_CONFIDENCE = 0.5;
+const HIGH_RISK_RE = /production|prod\b|migrat|database|deploy|보안|배포|권한|마이그/i;
+const LOW_RISK_RE = /docs only|문서만|read[- ]?only|읽기 전용/i;
+const COMMAND_RE = /\b(test|tests|spec|specs|command|cmd|run|build|lint|typecheck|pytest|jest|vitest|npm|yarn|pnpm|make|check|ci)\b/i;
+const PATH_RE = /[\w./-]+\.[a-zA-Z0-9]+/;
+// ---------------------------------------------------------------------------
+// assimilateAnswers
+// ---------------------------------------------------------------------------
+export function assimilateAnswers(input) {
+    const { questions, answers, goal } = input;
+    const questionById = new Map(questions.map((q) => [q.id, q]));
+    const findings = [];
+    const changes = [];
+    const contradictions = [];
+    const record = (question, field, op, value, confidence, conflict) => {
+        changes.push({ field, op, value, sourceQuestionId: question.id, confidence });
+        findings.push({ field: question.targetField, value, sourceQuestionId: question.id, confidence, conflict });
+    };
+    for (const answer of answers) {
+        if (answer.skipped)
+            continue;
+        const text = answer.answer.trim();
+        if (text.length === 0)
+            continue;
+        const question = questionById.get(answer.questionId);
+        if (!question)
+            continue;
+        switch (question.targetField) {
+            case "objective": {
+                let confidence = EXPLICIT_CONFIDENCE;
+                let conflict = false;
+                if (isObjectiveExplicit(goal) && differsMaterially(goal?.objective ?? "", text)) {
+                    conflict = true;
+                    confidence = CONFLICTED_CONFIDENCE;
+                    contradictions.push(`objective: answer ${question.id} conflicts with existing explicit objective ` +
+                        `("${truncate(goal?.objective ?? "")}" vs "${truncate(text)}")`);
+                }
+                record(question, "objective", "replace", text, confidence, conflict);
+                break;
+            }
+            case "successCriteria": {
+                for (const item of splitIntoItems(text, 3)) {
+                    record(question, "successCriteria", "add", item, EXPLICIT_CONFIDENCE, false);
+                }
+                break;
+            }
+            case "expectedArtifacts": {
+                const path = extractPath(text);
+                const gate = COMMAND_RE.test(text) ? "command-pass" : "file-exists";
+                const name = path ? basename(path) : truncate(firstNonEmptyLine(text), 80);
+                const value = path !== undefined ? { name, path, gate } : { name, gate };
+                record(question, "expectedArtifacts", "add", value, EXPLICIT_CONFIDENCE, false);
+                break;
+            }
+            case "constraints": {
+                record(question, "constraints", "add", text, EXPLICIT_CONFIDENCE, false);
+                break;
+            }
+            case "nonGoals": {
+                record(question, "nonGoals", "add", text, EXPLICIT_CONFIDENCE, false);
+                break;
+            }
+            case "risks": {
+                const level = computeRiskLevel(text);
+                record(question, "risks", "add", { description: text, level }, EXPLICIT_CONFIDENCE, false);
+                // Escalate the goal-level riskLevel when a risk answer is high.
+                // Never downgrade here (applyInterviewDelta enforces escalate-only).
+                if (level === "high") {
+                    record(question, "riskLevel", "replace", "high", EXPLICIT_CONFIDENCE, false);
+                }
+                break;
+            }
+            case "riskLevel": {
+                const newLevel = computeRiskLevel(text);
+                let confidence = EXPLICIT_CONFIDENCE;
+                let conflict = false;
+                if (goal && goal.riskLevel === "high" && riskRank(newLevel) < riskRank("high")) {
+                    conflict = true;
+                    confidence = CONFLICTED_CONFIDENCE;
+                    contradictions.push(`riskLevel: answer ${question.id} would downgrade explicit "high" risk to "${newLevel}"`);
+                }
+                record(question, "riskLevel", "replace", newLevel, confidence, conflict);
+                break;
+            }
+            // intentFrame / actionAtoms are not assimilated by this module.
+            default:
+                break;
+        }
+    }
+    const specDelta = {
+        schemaVersion: INTERVIEW_DELTA_SCHEMA_VERSION,
+        goalId: goal?.goalId,
+        changes,
+    };
+    return { findings, specDelta, contradictions };
+}
+// ---------------------------------------------------------------------------
+// applyInterviewDelta
+// ---------------------------------------------------------------------------
+export function applyInterviewDelta(goal, delta) {
+    // Clone: new top-level object + fresh copies of every collection we mutate so
+    // the caller's GoalSpec is never touched. Existing nested entries are reused
+    // by reference but never mutated (we only push new entries / reassign scalars).
+    const next = {
+        ...goal,
+        successCriteria: [...goal.successCriteria],
+        constraints: [...goal.constraints],
+        nonGoals: [...goal.nonGoals],
+        risks: [...goal.risks],
+        expectedArtifacts: [...goal.expectedArtifacts],
+        runIds: [...goal.runIds],
+    };
+    const appliedChanges = [];
+    const skippedChanges = [];
+    const contradictions = [];
+    for (const change of delta.changes) {
+        if (change.op === "add") {
+            switch (change.field) {
+                case "successCriteria": {
+                    const description = asString(change.value);
+                    if (!description) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    const requirement = next.successCriteria.length === 0 ? "required" : "optional";
+                    const criterion = {
+                        id: `criterion-${next.successCriteria.length + 1}`,
+                        description,
+                        requirement,
+                        weight: requirement === "required" ? 1.0 : 0.5,
+                        inferred: false,
+                    };
+                    next.successCriteria.push(criterion);
+                    appliedChanges.push(change);
+                    break;
+                }
+                case "expectedArtifacts": {
+                    const artifact = asArtifactValue(change.value);
+                    if (!artifact) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    const entry = { name: artifact.name };
+                    if (artifact.path !== undefined)
+                        entry.path = artifact.path;
+                    if (artifact.gate !== undefined)
+                        entry.gate = artifact.gate;
+                    next.expectedArtifacts.push(entry);
+                    appliedChanges.push(change);
+                    break;
+                }
+                case "constraints": {
+                    const description = asString(change.value);
+                    if (!description) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    const constraint = { id: `constraint-${next.constraints.length + 1}`, description };
+                    next.constraints.push(constraint);
+                    appliedChanges.push(change);
+                    break;
+                }
+                case "nonGoals": {
+                    const value = asString(change.value);
+                    if (!value) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    next.nonGoals.push(value);
+                    appliedChanges.push(change);
+                    break;
+                }
+                case "risks": {
+                    const risk = asRiskValue(change.value);
+                    if (!risk) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    const entry = { id: `risk-${next.risks.length + 1}`, description: risk.description, level: risk.level };
+                    next.risks.push(entry);
+                    appliedChanges.push(change);
+                    break;
+                }
+                default:
+                    skippedChanges.push(change);
+                    break;
+            }
+            continue;
+        }
+        if (change.op === "replace") {
+            switch (change.field) {
+                case "riskLevel": {
+                    const newLevel = asRiskLevel(change.value);
+                    if (newLevel === null || change.confidence < CONFLICTED_CONFIDENCE) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    const current = next.riskLevel;
+                    const downgradeFromHigh = current === "high" && riskRank(newLevel) < riskRank(current);
+                    if (downgradeFromHigh) {
+                        contradictions.push(`riskLevel: skipped downgrade of explicit "high" risk to "${newLevel}" (from ${change.sourceQuestionId})`);
+                        skippedChanges.push(change);
+                    }
+                    else if (newLevel !== current) {
+                        // higher-or-different
+                        next.riskLevel = newLevel;
+                        appliedChanges.push(change);
+                    }
+                    else {
+                        skippedChanges.push(change);
+                    }
+                    break;
+                }
+                case "objective": {
+                    const newObjective = asString(change.value);
+                    if (!newObjective) {
+                        skippedChanges.push(change);
+                        break;
+                    }
+                    if (isObjectiveExplicit(next) &&
+                        change.confidence < EXPLICIT_CONFIDENCE &&
+                        differsMaterially(next.objective, newObjective)) {
+                        contradictions.push(`objective: skipped overwrite of explicit objective with low-confidence answer (from ${change.sourceQuestionId})`);
+                        skippedChanges.push(change);
+                    }
+                    else {
+                        next.objective = newObjective;
+                        appliedChanges.push(change);
+                    }
+                    break;
+                }
+                default:
+                    skippedChanges.push(change);
+                    break;
+            }
+            continue;
+        }
+        // "remove" and any unknown op are not supported by this module.
+        skippedChanges.push(change);
+    }
+    // The single allowed timestamp site for this module.
+    next.updatedAt = new Date().toISOString();
+    return { goal: next, appliedChanges, skippedChanges, contradictions };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers (pure)
+// ---------------------------------------------------------------------------
+/**
+ * A goal's objective is "explicit" when it is non-empty and was not merely
+ * lifted from the inferred IntentFrame (problem / desiredOutcome). Without a
+ * dedicated flag on GoalSpec.objective this is the most reliable deterministic
+ * signal that the value came from a user/prompt source rather than inference.
+ */
+function isObjectiveExplicit(goal) {
+    if (!goal)
+        return false;
+    const objective = goal.objective?.trim() ?? "";
+    if (objective.length === 0)
+        return false;
+    const frame = goal.intentFrame;
+    if (frame) {
+        const desired = frame.desiredOutcome?.trim() ?? "";
+        const problem = frame.problem?.trim() ?? "";
+        if (objective === desired || objective === problem)
+            return false;
+    }
+    return true;
+}
+function computeRiskLevel(text) {
+    if (HIGH_RISK_RE.test(text))
+        return "high";
+    if (LOW_RISK_RE.test(text))
+        return "low";
+    return "medium";
+}
+function riskRank(level) {
+    return level === "high" ? 2 : level === "medium" ? 1 : 0;
+}
+function differsMaterially(a, b) {
+    return normalize(a) !== normalize(b);
+}
+function normalize(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+/** Split answer text into list items on newlines or inline numbered markers. */
+function splitIntoItems(text, max) {
+    const byLine = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    let parts;
+    if (byLine.length > 1) {
+        parts = byLine;
+    }
+    else {
+        const single = byLine[0] ?? text.trim();
+        const inline = single
+            .split(/(?=\b\d+[.)]\s)/)
+            .map((segment) => segment.trim())
+            .filter((segment) => segment.length > 0);
+        parts = inline.length > 1 ? inline : [single];
+    }
+    return parts
+        .map(stripListMarker)
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .slice(0, max);
+}
+function stripListMarker(value) {
+    return value.replace(/^\s*(?:\d+[.)]|[-*•])\s+/, "").trim();
+}
+function extractPath(text) {
+    const match = text.match(PATH_RE);
+    return match ? match[0] : undefined;
+}
+function basename(path) {
+    const segments = path.split("/");
+    return segments[segments.length - 1] || path;
+}
+function firstNonEmptyLine(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return text.trim();
+}
+function truncate(value, max = 60) {
+    const trimmed = value.trim();
+    return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}…`;
+}
+function asString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function asRiskLevel(value) {
+    return value === "low" || value === "medium" || value === "high" ? value : null;
+}
+function asArtifactValue(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    const name = typeof record.name === "string" ? record.name.trim() : "";
+    if (name.length === 0)
+        return null;
+    const path = typeof record.path === "string" && record.path.length > 0 ? record.path : undefined;
+    const gate = record.gate === "file-exists" || record.gate === "command-pass" || record.gate === "summary"
+        ? record.gate
+        : undefined;
+    return { name, path, gate };
+}
+function asRiskValue(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    const description = typeof record.description === "string" ? record.description.trim() : "";
+    const level = asRiskLevel(record.level);
+    if (description.length === 0 || level === null)
+        return null;
+    return { description, level };
+}

package/dist/goal/interview-question-bank.d.ts

@@ -0,0 +1,11 @@
+import type { InterviewQuestion, InterviewSeed } from "../contracts/interview.js";
+/**
+ * Build the deterministic candidate-question bank for a seed.
+ *
+ * The result always contains the 10 axes in a stable order. Signals are
+ * adjusted deterministically: risk/authority/rollback axes are boosted on
+ * high-risk seeds, and any axis already satisfied by `seed.goal` has its
+ * informationGain reduced so the caller's ranker downranks it. `score` is
+ * intentionally omitted — the caller assigns it.
+ */
+export declare function buildInterviewQuestionBank(seed: InterviewSeed): Array<Omit<InterviewQuestion, "score">>;

package/dist/goal/interview-question-bank.js

@@ -0,0 +1,225 @@
+// Module: src/goal/interview-question-bank.ts
+// Owner: Interview Question Bank Worker (Deep Interview phase)
+//
+// Deterministic, offline candidate-question bank for the OMK Deep Interview.
+// NO LLM calls, NO network, NO Date, NO randomness: the same `InterviewSeed`
+// always yields the same candidate set. The caller is responsible for scoring
+// (the returned candidates intentionally omit `score`).
+/**
+ * Seeds matching this pattern (or a `high` riskLevel) boost the risk/authority/
+ * rollback axes so the ranker surfaces safety questions earlier.
+ */
+const HIGH_RISK_PATTERN = /production|deploy|migrat|database|보안|배포|마이그/i;
+/** Axes that defend against execution risk and benefit from high-risk boosts. */
+const RISK_AXIS_IDS = new Set(["q-risk", "q-authority", "q-rollback"]);
+/** Multiplier applied to informationGain when the goal already fills the axis. */
+const POPULATED_DOWNRANK = 0.4;
+/**
+ * The 10 deep-interview axes. Base signals follow the deterministic guidance:
+ *  - required-true axes start with informationGain >= 0.8;
+ *  - artifact/verification/success-criteria carry evidenceImpact >= 0.7 and
+ *    dagImpact >= 0.6;
+ *  - scope/non-goal carry moderate dagImpact (~0.5);
+ *  - risk/authority/rollback carry riskReduction >= 0.7;
+ *  - userCost stays in the ~0.2-0.4 band.
+ */
+const QUESTION_SPECS = [
+    {
+        id: "q-objective",
+        kind: "objective",
+        targetField: "objective",
+        required: true,
+        prompt: "이 작업이 최종적으로 무엇이 되면 성공인지 한 문장으로 정의해줘.",
+        informationGain: 0.9,
+        riskReduction: 0.3,
+        dagImpact: 0.7,
+        evidenceImpact: 0.5,
+        userCost: 0.2,
+    },
+    {
+        id: "q-success-criteria",
+        kind: "success-criteria",
+        targetField: "successCriteria",
+        required: true,
+        prompt: "완료를 판단할 필수 성공 기준을 1-3개로 써줘.",
+        informationGain: 0.86,
+        riskReduction: 0.4,
+        dagImpact: 0.65,
+        evidenceImpact: 0.8,
+        userCost: 0.3,
+    },
+    {
+        id: "q-artifact",
+        kind: "artifact",
+        targetField: "expectedArtifacts",
+        required: true,
+        prompt: "반드시 생성/수정되어야 하는 산출물을 경로까지 적어줘. 예: src/commands/goal-interview.ts",
+        informationGain: 0.83,
+        riskReduction: 0.35,
+        dagImpact: 0.7,
+        evidenceImpact: 0.85,
+        userCost: 0.3,
+    },
+    {
+        id: "q-scope",
+        kind: "constraint",
+        targetField: "constraints",
+        required: false,
+        prompt: "수정 가능한 범위를 구체적으로 지정해줘. 예: src/ 만, docs 만, 전체 repo.",
+        informationGain: 0.6,
+        riskReduction: 0.5,
+        dagImpact: 0.5,
+        evidenceImpact: 0.4,
+        userCost: 0.3,
+    },
+    {
+        id: "q-non-goal",
+        kind: "non-goal",
+        targetField: "nonGoals",
+        required: false,
+        prompt: "절대 하지 말아야 할 행동이 있어? 예: npm publish 금지, git push 금지, production config 수정 금지.",
+        informationGain: 0.55,
+        riskReduction: 0.5,
+        dagImpact: 0.5,
+        evidenceImpact: 0.35,
+        userCost: 0.3,
+    },
+    {
+        id: "q-verification",
+        kind: "evidence",
+        targetField: "successCriteria",
+        required: true,
+        prompt: "검증 명령/테스트가 있으면 적어줘. 없으면 OMK가 추론해도 되는지 답해줘.",
+        informationGain: 0.8,
+        riskReduction: 0.5,
+        dagImpact: 0.6,
+        evidenceImpact: 0.85,
+        userCost: 0.35,
+    },
+    {
+        id: "q-risk",
+        kind: "risk",
+        targetField: "risks",
+        required: false,
+        prompt: "데이터/보안/배포/권한 측면의 위험이 있어?",
+        informationGain: 0.6,
+        riskReduction: 0.75,
+        dagImpact: 0.55,
+        evidenceImpact: 0.5,
+        userCost: 0.35,
+    },
+    {
+        id: "q-authority",
+        kind: "authority",
+        targetField: "riskLevel",
+        required: false,
+        prompt: "허용 권한 수준을 알려줘. write/shell/merge 중 어디까지 허용해?",
+        informationGain: 0.55,
+        riskReduction: 0.7,
+        dagImpact: 0.55,
+        evidenceImpact: 0.45,
+        userCost: 0.25,
+    },
+    {
+        id: "q-dependency",
+        kind: "dependency",
+        targetField: "intentFrame",
+        required: false,
+        prompt: "참고해야 할 파일/문서/외부 시스템이 있어?",
+        informationGain: 0.55,
+        riskReduction: 0.4,
+        dagImpact: 0.5,
+        evidenceImpact: 0.45,
+        userCost: 0.35,
+    },
+    {
+        id: "q-rollback",
+        kind: "rollback",
+        targetField: "riskLevel",
+        required: false,
+        prompt: "실패 시 rollback 또는 중단 조건이 있어?",
+        informationGain: 0.5,
+        riskReduction: 0.7,
+        dagImpact: 0.55,
+        evidenceImpact: 0.5,
+        userCost: 0.3,
+    },
+];
+/** Clamp a signal into [0,1] and round to 2 decimals for stable output. */
+function clamp01(value) {
+    const bounded = value < 0 ? 0 : value > 1 ? 1 : value;
+    return Math.round(bounded * 100) / 100;
+}
+/** True when the seed describes risk-sensitive work (prompt match or high risk). */
+function isHighRiskSeed(seed) {
+    if (seed.riskLevel === "high") {
+        return true;
+    }
+    return HIGH_RISK_PATTERN.test(seed.rawPrompt);
+}
+/**
+ * True when the goal already carries a usable value for the axis, so the axis
+ * question can be downranked. `riskLevel` always has a default and does not
+ * capture authority/rollback intent, so those axes are never auto-populated.
+ */
+function isAxisPopulated(goal, id) {
+    if (!goal) {
+        return false;
+    }
+    switch (id) {
+        case "q-objective":
+            return goal.objective.trim().length > 0;
+        case "q-success-criteria":
+        case "q-verification":
+            return goal.successCriteria.length > 0;
+        case "q-artifact":
+            return goal.expectedArtifacts.length > 0;
+        case "q-scope":
+            return goal.constraints.length > 0;
+        case "q-non-goal":
+            return goal.nonGoals.length > 0;
+        case "q-risk":
+            return goal.risks.length > 0;
+        case "q-dependency":
+            return (goal.intentFrame?.entities.length ?? 0) > 0;
+        default:
+            return false;
+    }
+}
+/**
+ * Build the deterministic candidate-question bank for a seed.
+ *
+ * The result always contains the 10 axes in a stable order. Signals are
+ * adjusted deterministically: risk/authority/rollback axes are boosted on
+ * high-risk seeds, and any axis already satisfied by `seed.goal` has its
+ * informationGain reduced so the caller's ranker downranks it. `score` is
+ * intentionally omitted — the caller assigns it.
+ */
+export function buildInterviewQuestionBank(seed) {
+    const highRisk = isHighRiskSeed(seed);
+    return QUESTION_SPECS.map((spec) => {
+        let informationGain = spec.informationGain;
+        let riskReduction = spec.riskReduction;
+        let dagImpact = spec.dagImpact;
+        if (highRisk && RISK_AXIS_IDS.has(spec.id)) {
+            informationGain += 0.1;
+            riskReduction = Math.max(riskReduction + 0.15, 0.85);
+            dagImpact = Math.max(dagImpact + 0.2, 0.7);
+        }
+        if (isAxisPopulated(seed.goal, spec.id)) {
+            informationGain *= POPULATED_DOWNRANK;
+        }
+        return {
+            id: spec.id,
+            kind: spec.kind,
+            prompt: spec.prompt,
+            required: spec.required,
+            targetField: spec.targetField,
+            informationGain: clamp01(informationGain),
+            riskReduction: clamp01(riskReduction),
+            dagImpact: clamp01(dagImpact),
+            evidenceImpact: clamp01(spec.evidenceImpact),
+            userCost: clamp01(spec.userCost),
+        };
+    });
+}

package/dist/goal/interview-scoring.d.ts

@@ -0,0 +1,31 @@
+import type { GoalSpec } from "../contracts/goal.js";
+import type { InterviewCompleteness, InterviewDepth, InterviewFinding, InterviewQuestion, InterviewSeed } from "../contracts/interview.js";
+/** Max questions surfaced per interview depth. */
+export declare const DEPTH_LIMITS: Record<InterviewDepth, number>;
+/**
+ * Derive the ranking score for a candidate question.
+ * score = informationGain*0.35 + riskReduction*0.25 + dagImpact*0.20
+ *       + evidenceImpact*0.15 - userCost*0.05, clamped to [0,1].
+ */
+export declare function scoreInterviewQuestion(input: Omit<InterviewQuestion, "score">): InterviewQuestion;
+/**
+ * Select the highest-value questions for a depth, dropping questions whose
+ * target field is already answered by the goal (unless marked required).
+ */
+export declare function selectInterviewQuestions(goal: GoalSpec | undefined, candidates: InterviewQuestion[], depth: InterviewDepth, maxQuestions?: number): InterviewQuestion[];
+/**
+ * Ambiguity 0..1 — higher means more interview is needed. Computed as the
+ * weighted sum of axes that are neither described in the prompt nor present on
+ * the goal. Axis weights sum to 1.
+ */
+export declare function computeAmbiguity(seed: InterviewSeed): number;
+/**
+ * Map an ambiguity score to a recommended depth.
+ * <0.25 light (caller may skip) · <0.50 light · <0.75 standard · else deep.
+ */
+export declare function recommendDepth(ambiguity: number): InterviewDepth;
+/**
+ * Completeness across required and supporting axes, blending populated goal
+ * fields with assimilated interview findings.
+ */
+export declare function computeCompleteness(goal: GoalSpec | undefined, findings: InterviewFinding[]): InterviewCompleteness;