open-multi-agent-kit 0.78.1 → 0.78.2

package/dist/goal/interview-scoring.js

@@ -0,0 +1,187 @@
+// Module: src/goal/interview-scoring.ts
+// OMK Deep Interview — pure deterministic scoring/ranking.
+//
+// 100% deterministic: no I/O, no Date.now, no randomness, no network/LLM calls.
+// All 0..1 outputs are clamped to [0,1] and scores rounded to 2 decimals.
+const clamp01 = (x) => Math.min(1, Math.max(0, x));
+const round2 = (x) => Math.round(x * 100) / 100;
+/** Max questions surfaced per interview depth. */
+export const DEPTH_LIMITS = {
+    light: 5,
+    standard: 10,
+    deep: 18,
+};
+/**
+ * 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 function scoreInterviewQuestion(input) {
+    const raw = input.informationGain * 0.35 +
+        input.riskReduction * 0.25 +
+        input.dagImpact * 0.2 +
+        input.evidenceImpact * 0.15 -
+        input.userCost * 0.05;
+    const score = round2(clamp01(raw));
+    return { ...input, score };
+}
+/**
+ * Select the highest-value questions for a depth, dropping questions whose
+ * target field is already answered by the goal (unless marked required).
+ */
+export function selectInterviewQuestions(goal, candidates, depth, maxQuestions) {
+    const limit = maxQuestions != null ? Math.min(maxQuestions, DEPTH_LIMITS[depth]) : DEPTH_LIMITS[depth];
+    const answeredTargets = new Set();
+    if (goal) {
+        if (goal.objective?.trim())
+            answeredTargets.add("objective");
+        if (goal.successCriteria.length > 0)
+            answeredTargets.add("successCriteria");
+        if (goal.expectedArtifacts.length > 0)
+            answeredTargets.add("expectedArtifacts");
+        if (goal.constraints.length > 0)
+            answeredTargets.add("constraints");
+        if (goal.nonGoals.length > 0)
+            answeredTargets.add("nonGoals");
+        if (goal.risks.length > 0)
+            answeredTargets.add("risks");
+    }
+    const filtered = candidates.filter((q) => q.required || !answeredTargets.has(q.targetField));
+    const byScoreThenRequired = (a, b) => {
+        const byScore = b.score - a.score;
+        if (byScore !== 0)
+            return byScore;
+        return Number(b.required) - Number(a.required);
+    };
+    // Pin required questions so a small --max-questions/limit can never drop a
+    // required axis; optional questions fill the remaining slots by score.
+    const required = filtered.filter((q) => q.required).sort(byScoreThenRequired);
+    const optional = filtered.filter((q) => !q.required).sort(byScoreThenRequired);
+    const remaining = Math.max(0, limit - required.length);
+    return [...required, ...optional.slice(0, remaining)].sort(byScoreThenRequired);
+}
+/** Keyword/regex heuristics describing one ambiguity axis. */
+const AMBIGUITY_AXES = [
+    {
+        weight: 0.18,
+        pattern: /\b(objective|goal|implement|build|create|add|fix|refactor|design|develop|generate|support|enable)\b/,
+        goalPresent: (s) => !!s.goal?.objective?.trim(),
+    },
+    {
+        weight: 0.18,
+        pattern: /\b(acceptance|success criteria|criteria|criterion|definition of done|done when|must pass|requirement|expected result|should)\b/,
+        goalPresent: (s) => (s.goal?.successCriteria.length ?? 0) > 0,
+    },
+    {
+        weight: 0.13,
+        pattern: /\b(test|verify|verification|check|lint|typecheck|build|coverage|assert|validate)\b/,
+        goalPresent: (s) => (s.goal?.expectedArtifacts.some((a) => a.gate === "command-pass") ?? false),
+    },
+    {
+        weight: 0.12,
+        pattern: /(\.[a-z]{2,4}\b|\bfile\b|\bpath\b|\bmodule\b|\bcomponent\b|\bdirectory\b|\bartifact\b|\boutput\b)/,
+        goalPresent: (s) => (s.goal?.expectedArtifacts.length ?? 0) > 0,
+    },
+    {
+        weight: 0.1,
+        pattern: /\b(constraint|must not|only|do not|don't|limit|restrict|without|avoid|never|forbidden)\b/,
+        goalPresent: (s) => (s.goal?.constraints.length ?? 0) > 0,
+    },
+    {
+        weight: 0.08,
+        pattern: /\b(risk|danger|safe|safety|destructive|irreversible|production|rollback|backup|prod)\b/,
+        goalPresent: (s) => (s.goal?.risks.length ?? 0) > 0 || s.riskLevel != null,
+    },
+    {
+        weight: 0.08,
+        pattern: /\b(write|edit|modify|delete|shell|command|merge|commit|push|deploy|permission|read.only|authority|scope)\b/,
+        goalPresent: (s) => !!s.goal?.intentFrame?.directives?.some((d) => d.kind === "read-only" || d.kind === "no-edits" || d.kind === "scope"),
+    },
+    {
+        weight: 0.07,
+        pattern: /\b(non-goal|out of scope|exclude|except|not (include|touch|modify|change|do)|do not (edit|modify|change|touch))\b/,
+        goalPresent: (s) => (s.goal?.nonGoals.length ?? 0) > 0,
+    },
+    {
+        weight: 0.06,
+        pattern: /\b(depend|dependenc|requires|require|prerequisite|blocked by|relies on|integrat|import)\b/,
+        goalPresent: () => false,
+    },
+];
+/**
+ * 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 function computeAmbiguity(seed) {
+    const prompt = (seed.rawPrompt ?? "").toLowerCase();
+    let missing = 0;
+    for (const axis of AMBIGUITY_AXES) {
+        const present = axis.pattern.test(prompt) || axis.goalPresent(seed);
+        if (!present)
+            missing += axis.weight;
+    }
+    return round2(clamp01(missing));
+}
+/**
+ * Map an ambiguity score to a recommended depth.
+ * <0.25 light (caller may skip) · <0.50 light · <0.75 standard · else deep.
+ */
+export function recommendDepth(ambiguity) {
+    if (ambiguity < 0.5)
+        return "light";
+    if (ambiguity < 0.75)
+        return "standard";
+    return "deep";
+}
+/** Per-axis completeness: 0.6 if goal field populated, +0.4 if a finding matches. */
+function axisScore(goalPopulated, fields, findings) {
+    const hasFinding = findings.some((f) => fields.includes(String(f.field)));
+    let score = 0;
+    if (goalPopulated)
+        score += 0.6;
+    if (hasFinding)
+        score += 0.4;
+    return round2(clamp01(score));
+}
+/**
+ * Completeness across required and supporting axes, blending populated goal
+ * fields with assimilated interview findings.
+ */
+export function computeCompleteness(goal, findings) {
+    const objective = axisScore(!!goal?.objective?.trim(), ["objective"], findings);
+    const successCriteria = axisScore((goal?.successCriteria.length ?? 0) > 0, ["successCriteria"], findings);
+    const evidence = axisScore((goal?.expectedArtifacts.some((a) => !!a.gate) ?? false) ||
+        (goal?.successCriteria.some((c) => c.requirement === "required") ?? false), ["evidence"], findings);
+    const artifacts = axisScore((goal?.expectedArtifacts.length ?? 0) > 0, ["expectedArtifacts", "artifact", "artifacts"], findings);
+    const constraints = axisScore((goal?.constraints.length ?? 0) > 0, ["constraints"], findings);
+    const risks = axisScore((goal?.risks.length ?? 0) > 0, ["risks", "riskLevel"], findings);
+    const authority = axisScore(!!goal?.intentFrame?.directives?.some((d) => d.kind === "read-only" || d.kind === "no-edits" || d.kind === "scope"), ["authority", "intentFrame"], findings);
+    const overall = round2(clamp01(objective * 0.15 +
+        successCriteria * 0.25 +
+        evidence * 0.2 +
+        artifacts * 0.15 +
+        constraints * 0.1 +
+        risks * 0.1 +
+        authority * 0.05));
+    const criticalMissing = [];
+    if (objective < 0.5)
+        criticalMissing.push("objective");
+    if (successCriteria < 0.5)
+        criticalMissing.push("successCriteria");
+    if (evidence < 0.5)
+        criticalMissing.push("evidence");
+    const contradictions = findings.filter((f) => f.conflict).map((f) => String(f.field));
+    return {
+        overall,
+        objective,
+        successCriteria,
+        evidence,
+        artifacts,
+        constraints,
+        risks,
+        authority,
+        criticalMissing,
+        contradictions,
+    };
+}

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

@@ -0,0 +1,25 @@
+import type { InterviewAnswer, InterviewDepth, InterviewMode, InterviewSeed, InterviewSession } from "../contracts/interview.js";
+/** Completeness threshold above which the interview is considered done. */
+export declare const COMPLETENESS_THRESHOLD = 0.82;
+export interface BuildInterviewSessionInput {
+    seed: InterviewSeed;
+    mode: InterviewMode;
+    depth?: InterviewDepth;
+    maxQuestions?: number;
+    sessionId?: string;
+    goalId?: string;
+}
+/**
+ * Build a fresh interview session: score ambiguity, rank deterministic
+ * questions, and emit an empty spec delta. No answers are applied yet.
+ */
+export declare function buildInterviewSession(input: BuildInterviewSessionInput): InterviewSession;
+/**
+ * Apply a batch of answers to an open session: assimilate into findings and a
+ * spec delta, recompute completeness, and decide the terminal status.
+ *
+ * Termination (spec): complete when completeness >= 0.82 AND no critical
+ * missing field AND no unresolved contradiction. Contradictions => blocked.
+ */
+export declare function ingestAnswers(session: InterviewSession, seed: InterviewSeed, newAnswers: InterviewAnswer[]): InterviewSession;
+export declare function decideStatus(completeness: InterviewSession["completeness"]): InterviewSession["status"];

package/dist/goal/interview-session.js

@@ -0,0 +1,116 @@
+// src/goal/interview-session.ts
+// OMK Deep Interview — session orchestrator.
+//
+// Composes the three deterministic modules (question-bank, scoring,
+// assimilation) into an InterviewSession lifecycle:
+//   seed -> ambiguity -> question ranking -> answers -> findings
+//        -> spec delta -> completeness -> status
+//
+// This module owns the critical integration path and is intentionally
+// deterministic except for timestamps and the session id.
+import { INTERVIEW_SCHEMA_VERSION, INTERVIEW_DELTA_SCHEMA_VERSION } from "../contracts/interview.js";
+import { computeAmbiguity, computeCompleteness, recommendDepth, scoreInterviewQuestion, selectInterviewQuestions, } from "./interview-scoring.js";
+import { buildInterviewQuestionBank } from "./interview-question-bank.js";
+import { assimilateAnswers, applyInterviewDelta } from "./interview-assimilation.js";
+import { createGoalSpec } from "./intake.js";
+import { redactSecretText } from "./intent-frame.js";
+/** Completeness threshold above which the interview is considered done. */
+export const COMPLETENESS_THRESHOLD = 0.82;
+function generateSessionId() {
+    return `iv-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+}
+/**
+ * Build a fresh interview session: score ambiguity, rank deterministic
+ * questions, and emit an empty spec delta. No answers are applied yet.
+ */
+export function buildInterviewSession(input) {
+    const now = new Date().toISOString();
+    const ambiguity = computeAmbiguity(input.seed);
+    const depth = input.depth ?? recommendDepth(ambiguity);
+    const candidates = buildInterviewQuestionBank(input.seed);
+    const scored = candidates.map((candidate) => scoreInterviewQuestion(candidate));
+    const questions = selectInterviewQuestions(input.seed.goal, scored, depth, input.maxQuestions);
+    const completeness = computeCompleteness(input.seed.goal, []);
+    return {
+        schemaVersion: INTERVIEW_SCHEMA_VERSION,
+        sessionId: input.sessionId ?? generateSessionId(),
+        goalId: input.goalId ?? input.seed.goal?.goalId,
+        mode: input.mode,
+        depth,
+        createdAt: now,
+        updatedAt: now,
+        rawPrompt: redactSecretText(input.seed.rawPrompt),
+        ambiguity,
+        questions,
+        answers: [],
+        findings: [],
+        completeness,
+        specDelta: {
+            schemaVersion: INTERVIEW_DELTA_SCHEMA_VERSION,
+            goalId: input.goalId ?? input.seed.goal?.goalId,
+            changes: [],
+        },
+        status: "open",
+    };
+}
+/**
+ * Apply a batch of answers to an open session: assimilate into findings and a
+ * spec delta, recompute completeness, and decide the terminal status.
+ *
+ * Termination (spec): complete when completeness >= 0.82 AND no critical
+ * missing field AND no unresolved contradiction. Contradictions => blocked.
+ */
+export function ingestAnswers(session, seed, newAnswers) {
+    // Redact secrets from answers before they are assimilated, persisted, or
+    // echoed so tokens never reach interview artifacts or the GoalSpec.
+    const redactedAnswers = newAnswers.map((answer) => ({
+        ...answer,
+        answer: redactSecretText(answer.answer),
+    }));
+    const mergedAnswers = mergeAnswers(session.answers, redactedAnswers);
+    const { findings, specDelta, contradictions } = assimilateAnswers({
+        seed,
+        questions: session.questions,
+        answers: mergedAnswers,
+        goal: seed.goal,
+    });
+    // Completeness is measured against the PROJECTED goal (base + delta) so the
+    // score reflects what the answers actually contribute to the GoalSpec, not
+    // the empty seed goal. This makes the 0.82 termination threshold meaningful.
+    const baseGoal = seed.goal ?? createGoalSpec(seed.rawPrompt);
+    const projected = applyInterviewDelta(baseGoal, specDelta).goal;
+    const completeness = computeCompleteness(projected, findings);
+    completeness.contradictions = uniqueStrings([...completeness.contradictions, ...contradictions]);
+    const status = decideStatus(completeness);
+    return {
+        ...session,
+        updatedAt: new Date().toISOString(),
+        answers: mergedAnswers,
+        findings,
+        completeness,
+        specDelta: {
+            ...specDelta,
+            goalId: session.goalId ?? specDelta.goalId,
+        },
+        status,
+    };
+}
+export function decideStatus(completeness) {
+    if (completeness.contradictions.length > 0)
+        return "blocked";
+    if (completeness.overall >= COMPLETENESS_THRESHOLD && completeness.criticalMissing.length === 0) {
+        return "complete";
+    }
+    return "open";
+}
+function mergeAnswers(existing, incoming) {
+    const byId = new Map();
+    for (const answer of existing)
+        byId.set(answer.questionId, answer);
+    for (const answer of incoming)
+        byId.set(answer.questionId, answer);
+    return [...byId.values()];
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.length > 0))];
+}

package/dist/input/input-envelope.d.ts

@@ -1,4 +1,23 @@
 export type InputKind = "plain-prompt" | "slash-command" | "goal-form" | "resume" | "verify" | "replan";
+/**
+ * Image or file attached to a prompt (clipboard paste, --image flag, drag).
+ * Carries both the on-disk path and the base64 data URI for multimodal
+ * wire protocol use (image_url parts).
+ */
+export interface InputAttachment {
+    /** Original file name or "clipboard-image.png". */
+    name: string;
+    /** Absolute or project-relative path to the saved file. */
+    path: string;
+    /** MIME type: image/png, image/jpeg, image/webp, image/gif. */
+    mimeType: string;
+    /** Base64 data URI (data:image/png;base64,...) for wire protocol. */
+    dataUri: string;
+    /** Detected extension: png, jpg, webp, gif. */
+    ext: string;
+    /** Source of the attachment. */
+    source: "clipboard" | "file" | "drag";
+}
 export type InputSource = "chat" | "parallel" | "run" | "goal" | "api";
 export type InputMcpScope = "all" | "project" | "none";
 export interface InputRequestedArtifact {
@@ -32,6 +51,8 @@ export interface InputEnvelope {
     theme?: string;
     constraints: string[];
     requestedArtifacts: InputRequestedArtifact[];
+    /** Images/files attached to this input (clipboard paste, --image, drag). */
+    attachments: InputAttachment[];
     slashCommand?: InputSlashCommandEnvelope;
     createdAt: string;
 }
@@ -52,6 +73,7 @@ export interface BuildInputEnvelopeInput {
     theme?: string;
     constraints?: readonly string[];
     requestedArtifacts?: readonly InputRequestedArtifact[];
+    attachments?: readonly InputAttachment[];
     slashCommand?: InputSlashCommandEnvelope;
     now?: () => Date;
 }

package/dist/input/input-envelope.js

@@ -60,6 +60,7 @@ export function buildInputEnvelope(input) {
         theme: input.theme,
         constraints: [...(input.constraints ?? [])],
         requestedArtifacts: input.requestedArtifacts?.map((artifact) => ({ ...artifact })) ?? [],
+        attachments: input.attachments?.map((a) => ({ ...a })) ?? [],
         slashCommand: input.slashCommand
             ? cloneSlashCommand(input.slashCommand)
             : undefined,

package/dist/runtime/advanced-control-loop.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Advanced Control Loop — Phase 6 of OMK Weakness Remediation (Algorithm 12).
+ *
+ * Orchestrates Phases 1–5 into a single turn-gating engine:
+ * 1. Public surface compression
+ * 2. Proof bundle trust evaluation
+ * 3. Provider maturity gating
+ * 4. Evidence-calibrated router v2
+ * 5. Release gate advisory
+ */
+import type { CompressionResult, SurfaceItem } from "./public-surface.js";
+import type { ProofBundleScores, TrustScoreResult } from "./proof-bundle-trust.js";
+import type { MaturityResult } from "./provider-maturity-gate.js";
+import type { RuntimeRouterDecisionV2, EvidenceHistoryEntry, NodeIntent } from "./contracts/router-v2.js";
+import type { ReleasePromotionInputs, ReleasePromotionResult } from "./contracts/weakness-remediation.js";
+import type { ReleasePromotionGate } from "../cli/release-promotion-gate.js";
+import type { AdapterTestResult } from "./contracts/evidence.js";
+import type { AgentRuntime } from "./agent-runtime.js";
+export type IntegrationResultKind = "verified" | "blocked" | "handoff";
+export interface WeaknessRemediationState {
+    readonly publicSurface: CompressionResult;
+    readonly proofTrust: TrustScoreResult;
+    readonly providerMaturity: MaturityResult;
+    readonly routerV2Decision: RuntimeRouterDecisionV2 | null;
+    readonly releaseGate: ReleasePromotionResult | null;
+}
+export interface AdvancedControlLoopInput {
+    readonly turnId: string;
+    readonly intent: NodeIntent;
+    readonly surfaceItems: readonly SurfaceItem[];
+    readonly proofScores: ProofBundleScores;
+    readonly providerTests: readonly AdapterTestResult[];
+    readonly candidates: readonly AgentRuntime[];
+    readonly evidenceHistory: readonly EvidenceHistoryEntry[];
+    readonly releaseInputs?: ReleasePromotionInputs;
+    readonly retryBudget?: number;
+}
+export interface AdvancedControlLoopResult {
+    readonly kind: IntegrationResultKind;
+    readonly turnId: string;
+    readonly state: WeaknessRemediationState;
+    readonly replan?: {
+        readonly triggered: boolean;
+        readonly reason: string;
+        readonly retryBudgetRemaining: number;
+    };
+    readonly evidenceContractPath: string;
+}
+export interface AdvancedControlLoop {
+    readonly run: (input: AdvancedControlLoopInput) => Promise<AdvancedControlLoopResult>;
+}
+export interface AdvancedControlLoopOptions {
+    readonly publicSurfaceBudget?: number;
+    readonly tauProof?: number;
+    readonly tauEvidence?: number;
+    readonly releaseGate?: ReleasePromotionGate;
+    readonly releaseGateEnabled?: boolean;
+    readonly evidenceContractDir?: string;
+}
+export declare function createAdvancedControlLoop(options?: AdvancedControlLoopOptions): AdvancedControlLoop;

package/dist/runtime/advanced-control-loop.js

@@ -0,0 +1,136 @@
+/**
+ * Advanced Control Loop — Phase 6 of OMK Weakness Remediation (Algorithm 12).
+ *
+ * Orchestrates Phases 1–5 into a single turn-gating engine:
+ * 1. Public surface compression
+ * 2. Proof bundle trust evaluation
+ * 3. Provider maturity gating
+ * 4. Evidence-calibrated router v2
+ * 5. Release gate advisory
+ */
+import { PublicSurfaceCompressor } from "./public-surface.js";
+import { createProofBundleTrustEngine } from "./proof-bundle-trust.js";
+import { TAU_PROOF } from "./contracts/weakness-remediation.js";
+import { createProviderMaturityGate } from "./provider-maturity-gate.js";
+import { createRouterV2ScoringEngine } from "./router-v2-scoring.js";
+import { TAU_EVIDENCE } from "./contracts/weakness-remediation.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function clamp01(n) {
+    return Math.max(0, Math.min(1, n));
+}
+function buildState(publicSurface, proofTrust, providerMaturity, routerV2Decision, releaseGate) {
+    return Object.freeze({
+        publicSurface,
+        proofTrust: proofTrust ??
+            Object.freeze({
+                score: 0,
+                permissionLevel: "no-claim",
+                passed: false,
+                breakdown: Object.freeze({
+                    schema: 0,
+                    hashes: 0,
+                    commands: 0,
+                    stdout: 0,
+                    decisions: 0,
+                    evidence: 0,
+                    limitations: 0,
+                    replay: 0,
+                }),
+            }),
+        providerMaturity: providerMaturity ??
+            Object.freeze({
+                score: 0,
+                authorityClass: "disabled",
+                passed: false,
+                subScores: Object.freeze({
+                    auth: 0,
+                    read: 0,
+                    write: 0,
+                    shell: 0,
+                    mcp: 0,
+                    merge: 0,
+                    evidence: 0,
+                    fallback: 0,
+                }),
+            }),
+        routerV2Decision,
+        releaseGate,
+    });
+}
+// ─── Factory ─────────────────────────────────────────────────────────────────
+export function createAdvancedControlLoop(options = {}) {
+    const { publicSurfaceBudget, tauProof = TAU_PROOF, tauEvidence = TAU_EVIDENCE, releaseGate, releaseGateEnabled = true, evidenceContractDir = ".omk/evidence", } = options;
+    const compressorOptions = publicSurfaceBudget
+        ? { budget: publicSurfaceBudget }
+        : {};
+    const compressor = new PublicSurfaceCompressor(compressorOptions);
+    const proofEngine = createProofBundleTrustEngine();
+    const maturityGate = createProviderMaturityGate();
+    const routerV2Engine = createRouterV2ScoringEngine();
+    return {
+        async run(input) {
+            // Phase 1 — Public surface compression
+            const publicSurface = compressor.compress(input.surfaceItems);
+            if (!publicSurface.invariantPassed) {
+                return Object.freeze({
+                    kind: "blocked",
+                    turnId: input.turnId,
+                    state: buildState(publicSurface, null, null, null, null),
+                    evidenceContractPath: `${evidenceContractDir}/${input.turnId}-blocked.json`,
+                });
+            }
+            // Phase 2 — Proof bundle trust evaluation
+            const proofTrust = proofEngine.evaluate(input.proofScores);
+            if (proofTrust.score < tauProof) {
+                return Object.freeze({
+                    kind: "handoff",
+                    turnId: input.turnId,
+                    state: buildState(publicSurface, proofTrust, null, null, null),
+                    replan: {
+                        triggered: false,
+                        reason: `Proof trust ${clamp01(proofTrust.score).toFixed(3)} < τ_proof ${tauProof}`,
+                        retryBudgetRemaining: input.retryBudget ?? 0,
+                    },
+                    evidenceContractPath: `${evidenceContractDir}/${input.turnId}-handoff.json`,
+                });
+            }
+            // Phase 3 — Provider maturity gating
+            const providerMaturity = maturityGate.evaluate(input.providerTests);
+            if (!providerMaturity.passed || providerMaturity.authorityClass === "disabled") {
+                return Object.freeze({
+                    kind: "blocked",
+                    turnId: input.turnId,
+                    state: buildState(publicSurface, proofTrust, providerMaturity, null, null),
+                    evidenceContractPath: `${evidenceContractDir}/${input.turnId}-blocked.json`,
+                });
+            }
+            // Phase 4 — Evidence-calibrated router v2
+            const routerV2Decision = routerV2Engine.select([...input.candidates], input.intent, [...input.evidenceHistory]);
+            const bestScore = routerV2Decision.scores[0];
+            if (!bestScore || bestScore.bayesianEvidenceScore < tauEvidence) {
+                return Object.freeze({
+                    kind: "handoff",
+                    turnId: input.turnId,
+                    state: buildState(publicSurface, proofTrust, providerMaturity, routerV2Decision, null),
+                    replan: {
+                        triggered: true,
+                        reason: `Router v2 bayesian evidence ${bestScore ? clamp01(bestScore.bayesianEvidenceScore).toFixed(3) : "n/a"} < τ_evidence ${tauEvidence}`,
+                        retryBudgetRemaining: Math.max(0, (input.retryBudget ?? 1) - 1),
+                    },
+                    evidenceContractPath: `${evidenceContractDir}/${input.turnId}-handoff.json`,
+                });
+            }
+            // Phase 5 — Release gate advisory (optional)
+            let releaseGateResult = null;
+            if (releaseGateEnabled && releaseGate && input.releaseInputs) {
+                releaseGateResult = releaseGate.evaluate(input.releaseInputs);
+            }
+            return Object.freeze({
+                kind: "verified",
+                turnId: input.turnId,
+                state: buildState(publicSurface, proofTrust, providerMaturity, routerV2Decision, releaseGateResult),
+                evidenceContractPath: `${evidenceContractDir}/${input.turnId}-verified.json`,
+            });
+        },
+    };
+}

package/dist/runtime/agent-runtime.d.ts

@@ -91,12 +91,22 @@ export interface ProviderPolicy {
 export interface CapabilityManifest extends RuntimeCapabilities {
     readonly structuredOutput?: boolean;
 }
+export interface AgentTaskAttachment {
+    readonly name: string;
+    readonly path?: string;
+    readonly mimeType: string;
+    readonly dataUri: string;
+    readonly ext: string;
+    readonly source: "clipboard" | "file" | "drag";
+}
 export interface AgentTask {
     readonly prompt: string;
     readonly context: AgentContext;
     readonly tools: ToolManifest;
     readonly providerPolicy: ProviderPolicy;
     readonly capabilities: CapabilityManifest;
+    /** Images/files attached to this task (clipboard paste, --image, drag). */
+    readonly attachments?: readonly AgentTaskAttachment[];
 }
 export interface AgentResult {
     readonly output: string;

package/dist/runtime/blast-radius.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Blast radius penalty — penalizes runtimes for high-risk, wide-impact tasks.
+ *
+ * Higher downstream dependency counts, larger affected file surfaces, and
+ * global side-effects increase the penalty, nudging the router toward
+ * more mature or lower-blast-radius runtimes.
+ */
+import type { BlastRadiusParams } from "./contracts/router-v2.js";
+export type { BlastRadiusParams } from "./contracts/router-v2.js";
+export declare function computeBlastRadiusPenalty(params: BlastRadiusParams): number;

package/dist/runtime/blast-radius.js

@@ -0,0 +1,14 @@
+/**
+ * Blast radius penalty — penalizes runtimes for high-risk, wide-impact tasks.
+ *
+ * Higher downstream dependency counts, larger affected file surfaces, and
+ * global side-effects increase the penalty, nudging the router toward
+ * more mature or lower-blast-radius runtimes.
+ */
+export function computeBlastRadiusPenalty(params) {
+    const { downstreamNodeCount, affectedFileCount, hasGlobalSideEffects } = params;
+    const downstreamPenalty = Math.min(0.15, downstreamNodeCount * 0.03);
+    const filePenalty = Math.min(0.10, affectedFileCount * 0.01);
+    const sideEffectPenalty = hasGlobalSideEffects ? 0.10 : 0.0;
+    return Math.min(0.30, downstreamPenalty + filePenalty + sideEffectPenalty);
+}