open-multi-agent-kit 0.99.0 → 1.2.0

package/dist/metacognition/route-economics.js

@@ -0,0 +1,110 @@
+/**
+ * Cost- and latency-aware route selection (Jev audit algorithm A5).
+ *
+ * Adding a selector call only pays if it *replaces* work. Inserting one in
+ * front of an existing free-text step adds a semantic inference instead of
+ * removing one, so routes are compared on a single utility:
+ *
+ *   U_r = q_r − λ_C·(C_r/C_0) − λ_L·(L_r/L_0)
+ *
+ * Safety and permission are deliberately not terms in that utility. They are a
+ * hard filter, because a cheap unsafe route must never win on weights.
+ *
+ * Latency is measured over the whole step, not the model call: when operator
+ * approval dominates, a faster decision step barely moves the total. Amdahl's
+ * bound is included so that limit is explicit rather than assumed away.
+ */
+import { ensure } from "./validation.js";
+function assertUnits(units) {
+    ensure(Number.isFinite(units.costUnit) && units.costUnit > 0, "costUnit must be positive");
+    ensure(Number.isFinite(units.latencyUnit) && units.latencyUnit > 0, "latencyUnit must be positive");
+    ensure(Number.isFinite(units.costWeight) && units.costWeight >= 0, "costWeight must be nonnegative");
+    ensure(Number.isFinite(units.latencyWeight) && units.latencyWeight >= 0, "latencyWeight must be nonnegative");
+}
+/** Dimensionless utility; cost and latency are normalized before weighting. */
+export function routeUtility(route, units) {
+    ensure(Number.isFinite(route.completionProbability) &&
+        route.completionProbability >= 0 &&
+        route.completionProbability <= 1, "completionProbability must be in [0,1]");
+    ensure(Number.isFinite(route.costUsd) && route.costUsd >= 0, "costUsd must be nonnegative");
+    ensure(Number.isFinite(route.latencyMs) && route.latencyMs >= 0, "latencyMs must be nonnegative");
+    assertUnits(units);
+    return (route.completionProbability -
+        units.costWeight * (route.costUsd / units.costUnit) -
+        units.latencyWeight * (route.latencyMs / units.latencyUnit));
+}
+/**
+ * Highest-utility approved route, or null when nothing is approved.
+ *
+ * Returning null rather than the best unapproved route keeps "we may not do
+ * this" distinct from "this is expensive".
+ */
+export function selectRoute(routes, units) {
+    ensure(Array.isArray(routes) && routes.length > 0, "routes must be a non-empty array");
+    let best;
+    let bestUtility = Number.NEGATIVE_INFINITY;
+    for (const route of routes) {
+        if (!route.approved)
+            continue;
+        const utility = routeUtility(route, units);
+        const better = utility > bestUtility || (utility === bestUtility && best !== undefined && route.id < best.id);
+        if (best === undefined || better) {
+            best = route;
+            bestUtility = utility;
+        }
+    }
+    return best ?? null;
+}
+/** Whole-step duration. Model response time is one term among eight. */
+export function stepDuration(phases) {
+    let total = 0;
+    for (const [label, value] of Object.entries(phases)) {
+        ensure(Number.isFinite(value) && value >= 0, `${label} must be a nonnegative finite number`);
+        total += value;
+    }
+    return total;
+}
+/**
+ * Amdahl bound: S = 1 / ((1−f) + f/s).
+ *
+ * `speedup` may be Infinity to ask what an instantaneous step would buy — the
+ * answer is still capped by the fraction it occupies, which is the point.
+ */
+export function overallSpeedup(improvableFraction, speedup) {
+    ensure(Number.isFinite(improvableFraction) && improvableFraction >= 0 && improvableFraction <= 1, "improvableFraction must be in [0,1]");
+    ensure(typeof speedup === "number" && !Number.isNaN(speedup) && speedup >= 1, "speedup must be at least 1");
+    const remaining = 1 - improvableFraction;
+    const improved = speedup === Number.POSITIVE_INFINITY ? 0 : improvableFraction / speedup;
+    return 1 / (remaining + improved);
+}
+/**
+ * E[C] = c_J + c_V + p_F·c_L.
+ *
+ * A cost decomposition, not an independence claim. Compare it against the
+ * incumbent path's cost under the same success and safety conditions; if it is
+ * larger, the cheap path is not cheap.
+ */
+export function fallbackExpectedCost(costs) {
+    ensure(Number.isFinite(costs.selectorCost) && costs.selectorCost >= 0, "selectorCost must be nonnegative");
+    ensure(Number.isFinite(costs.verificationCost) && costs.verificationCost >= 0, "verificationCost must be nonnegative");
+    ensure(Number.isFinite(costs.fallbackCost) && costs.fallbackCost >= 0, "fallbackCost must be nonnegative");
+    ensure(Number.isFinite(costs.fallbackProbability) && costs.fallbackProbability >= 0 && costs.fallbackProbability <= 1, "fallbackProbability must be in [0,1]");
+    return costs.selectorCost + costs.verificationCost + costs.fallbackProbability * costs.fallbackCost;
+}
+/**
+ * Damp selector/model ping-pong on one observation generation.
+ *
+ * Re-asking the same question about the same state only adds calls. A further
+ * attempt is admitted when the budget remains, or when recovery genuinely
+ * changed the cause. The budget is a configured value, not a claimed optimum.
+ */
+export function reselectionAllowed(input) {
+    ensure(Number.isSafeInteger(input.attemptsForFingerprint) && input.attemptsForFingerprint >= 0, "attemptsForFingerprint must be a nonnegative integer");
+    ensure(Number.isSafeInteger(input.maxAttempts) && input.maxAttempts > 0, "maxAttempts must be a positive integer");
+    if (input.causeChanged)
+        return { allowed: true };
+    if (input.attemptsForFingerprint < input.maxAttempts)
+        return { allowed: true };
+    return { allowed: false, reason: "attempt-budget-exhausted" };
+}
+//# sourceMappingURL=route-economics.js.map

package/dist/metacognition/route-economics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-economics.js","sourceRoot":"","sources":["../../src/metacognition/route-economics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cost- and latency-aware route selection (Jev audit algorithm A5).\n *\n * Adding a selector call only pays if it *replaces* work. Inserting one in\n * front of an existing free-text step adds a semantic inference instead of\n * removing one, so routes are compared on a single utility:\n *\n *   U_r = q_r − λ_C·(C_r/C_0) − λ_L·(L_r/L_0)\n *\n * Safety and permission are deliberately not terms in that utility. They are a\n * hard filter, because a cheap unsafe route must never win on weights.\n *\n * Latency is measured over the whole step, not the model call: when operator\n * approval dominates, a faster decision step barely moves the total. Amdahl's\n * bound is included so that limit is explicit rather than assumed away.\n */\n\nimport { ensure } from \"./validation.ts\";\n\nexport interface RouteCandidate {\n\treadonly id: string;\n\t/** Probability this route completes the step correctly. */\n\treadonly completionProbability: number;\n\treadonly costUsd: number;\n\treadonly latencyMs: number;\n\t/** Policy and permission verdict. A false value is a veto, not a penalty. */\n\treadonly approved: boolean;\n}\n\nexport interface RouteUnits {\n\treadonly costUnit: number;\n\treadonly latencyUnit: number;\n\treadonly costWeight: number;\n\treadonly latencyWeight: number;\n}\n\nfunction assertUnits(units: RouteUnits): void {\n\tensure(Number.isFinite(units.costUnit) && units.costUnit > 0, \"costUnit must be positive\");\n\tensure(Number.isFinite(units.latencyUnit) && units.latencyUnit > 0, \"latencyUnit must be positive\");\n\tensure(Number.isFinite(units.costWeight) && units.costWeight >= 0, \"costWeight must be nonnegative\");\n\tensure(Number.isFinite(units.latencyWeight) && units.latencyWeight >= 0, \"latencyWeight must be nonnegative\");\n}\n\n/** Dimensionless utility; cost and latency are normalized before weighting. */\nexport function routeUtility(route: RouteCandidate, units: RouteUnits): number {\n\tensure(\n\t\tNumber.isFinite(route.completionProbability) &&\n\t\t\troute.completionProbability >= 0 &&\n\t\t\troute.completionProbability <= 1,\n\t\t\"completionProbability must be in [0,1]\",\n\t);\n\tensure(Number.isFinite(route.costUsd) && route.costUsd >= 0, \"costUsd must be nonnegative\");\n\tensure(Number.isFinite(route.latencyMs) && route.latencyMs >= 0, \"latencyMs must be nonnegative\");\n\tassertUnits(units);\n\treturn (\n\t\troute.completionProbability -\n\t\tunits.costWeight * (route.costUsd / units.costUnit) -\n\t\tunits.latencyWeight * (route.latencyMs / units.latencyUnit)\n\t);\n}\n\n/**\n * Highest-utility approved route, or null when nothing is approved.\n *\n * Returning null rather than the best unapproved route keeps \"we may not do\n * this\" distinct from \"this is expensive\".\n */\nexport function selectRoute(routes: readonly RouteCandidate[], units: RouteUnits): RouteCandidate | null {\n\tensure(Array.isArray(routes) && routes.length > 0, \"routes must be a non-empty array\");\n\tlet best: RouteCandidate | undefined;\n\tlet bestUtility = Number.NEGATIVE_INFINITY;\n\tfor (const route of routes) {\n\t\tif (!route.approved) continue;\n\t\tconst utility = routeUtility(route, units);\n\t\tconst better = utility > bestUtility || (utility === bestUtility && best !== undefined && route.id < best.id);\n\t\tif (best === undefined || better) {\n\t\t\tbest = route;\n\t\t\tbestUtility = utility;\n\t\t}\n\t}\n\treturn best ?? null;\n}\n\nexport interface StepPhases {\n\treadonly queueMs: number;\n\treadonly observeMs: number;\n\treadonly packMs: number;\n\treadonly decideMs: number;\n\treadonly approvalMs: number;\n\treadonly executeMs: number;\n\treadonly verifyMs: number;\n\treadonly recoveryMs: number;\n}\n\n/** Whole-step duration. Model response time is one term among eight. */\nexport function stepDuration(phases: StepPhases): number {\n\tlet total = 0;\n\tfor (const [label, value] of Object.entries(phases)) {\n\t\tensure(Number.isFinite(value) && value >= 0, `${label} must be a nonnegative finite number`);\n\t\ttotal += value;\n\t}\n\treturn total;\n}\n\n/**\n * Amdahl bound: S = 1 / ((1−f) + f/s).\n *\n * `speedup` may be Infinity to ask what an instantaneous step would buy — the\n * answer is still capped by the fraction it occupies, which is the point.\n */\nexport function overallSpeedup(improvableFraction: number, speedup: number): number {\n\tensure(\n\t\tNumber.isFinite(improvableFraction) && improvableFraction >= 0 && improvableFraction <= 1,\n\t\t\"improvableFraction must be in [0,1]\",\n\t);\n\tensure(typeof speedup === \"number\" && !Number.isNaN(speedup) && speedup >= 1, \"speedup must be at least 1\");\n\tconst remaining = 1 - improvableFraction;\n\tconst improved = speedup === Number.POSITIVE_INFINITY ? 0 : improvableFraction / speedup;\n\treturn 1 / (remaining + improved);\n}\n\nexport interface FallbackCosts {\n\treadonly selectorCost: number;\n\treadonly verificationCost: number;\n\treadonly fallbackProbability: number;\n\treadonly fallbackCost: number;\n}\n\n/**\n * E[C] = c_J + c_V + p_F·c_L.\n *\n * A cost decomposition, not an independence claim. Compare it against the\n * incumbent path's cost under the same success and safety conditions; if it is\n * larger, the cheap path is not cheap.\n */\nexport function fallbackExpectedCost(costs: FallbackCosts): number {\n\tensure(Number.isFinite(costs.selectorCost) && costs.selectorCost >= 0, \"selectorCost must be nonnegative\");\n\tensure(\n\t\tNumber.isFinite(costs.verificationCost) && costs.verificationCost >= 0,\n\t\t\"verificationCost must be nonnegative\",\n\t);\n\tensure(Number.isFinite(costs.fallbackCost) && costs.fallbackCost >= 0, \"fallbackCost must be nonnegative\");\n\tensure(\n\t\tNumber.isFinite(costs.fallbackProbability) && costs.fallbackProbability >= 0 && costs.fallbackProbability <= 1,\n\t\t\"fallbackProbability must be in [0,1]\",\n\t);\n\treturn costs.selectorCost + costs.verificationCost + costs.fallbackProbability * costs.fallbackCost;\n}\n\nexport interface ReselectionInput {\n\t/** Attempts already spent on this observation fingerprint. */\n\treadonly attemptsForFingerprint: number;\n\treadonly maxAttempts: number;\n\t/** True when recovery changed the cause, not merely retried the same question. */\n\treadonly causeChanged: boolean;\n}\n\nexport type ReselectionDecision =\n\t| { readonly allowed: true }\n\t| { readonly allowed: false; readonly reason: \"attempt-budget-exhausted\" };\n\n/**\n * Damp selector/model ping-pong on one observation generation.\n *\n * Re-asking the same question about the same state only adds calls. A further\n * attempt is admitted when the budget remains, or when recovery genuinely\n * changed the cause. The budget is a configured value, not a claimed optimum.\n */\nexport function reselectionAllowed(input: ReselectionInput): ReselectionDecision {\n\tensure(\n\t\tNumber.isSafeInteger(input.attemptsForFingerprint) && input.attemptsForFingerprint >= 0,\n\t\t\"attemptsForFingerprint must be a nonnegative integer\",\n\t);\n\tensure(Number.isSafeInteger(input.maxAttempts) && input.maxAttempts > 0, \"maxAttempts must be a positive integer\");\n\tif (input.causeChanged) return { allowed: true };\n\tif (input.attemptsForFingerprint < input.maxAttempts) return { allowed: true };\n\treturn { allowed: false, reason: \"attempt-budget-exhausted\" };\n}\n"]}

package/dist/metacognition/runtime-bridge.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Runtime bridge — §13 "기존 완료 판정 호출부": projects host-owned OMK
+ * runtime artifacts (protocol ClaimGraph claims, ObservationNodes, waiver
+ * records, workspace/session facts) onto the metacognition kernel's input
+ * types. It only translates; it never relaxes trust floors, never admits a
+ * model's JSON as runner truth, and never fabricates completion.
+ */
+import type { ClaimNode, ObservationNode } from "omk-protocol";
+import type { CheckObservation, Claim, DecisionObservation, ReferenceObservation, SourceIdentity, Stage } from "./knowledge.ts";
+import type { MetaState } from "./state.ts";
+/** ClaimNode → kernel Claim. Severity maps to impact; leaves keep their check demands. */
+export declare function toKernelClaim(node: ClaimNode, stage: Stage, binding: string): Claim;
+/** ObservationNode → kernel observation. Trust floor rank maps to source admissibility. */
+export declare function toKernelObservation(node: ObservationNode, binding: string, nowMs: number, claimById?: ReadonlyMap<string, Claim>): CheckObservation | ReferenceObservation | DecisionObservation;
+export interface RuntimeBridgeOutput {
+    readonly state: MetaState;
+    readonly claims: readonly Claim[];
+    readonly observations: readonly (CheckObservation | ReferenceObservation | DecisionObservation)[];
+}
+export interface RuntimeBridgeInput {
+    readonly taskId: string;
+    readonly stageId: string;
+    readonly goalScope: string;
+    readonly targetArtifact: string;
+    readonly candidateHash: string;
+    readonly environmentHash: string;
+    readonly claims: readonly ClaimNode[];
+    readonly observations: readonly ObservationNode[];
+    readonly trustedRunnerIds: readonly string[];
+    readonly decisionActorIds: readonly string[];
+    readonly authorizedActions: readonly string[];
+    readonly budget: {
+        remainingMs: number;
+        remainingRequests: number;
+        remainingTokens: number;
+        remainingConcurrent: number;
+    };
+    readonly policyVersion: string;
+    readonly modelRevision: string;
+    readonly interruptionReason?: string | null;
+    readonly stage: Stage;
+    readonly nowMs: number;
+    readonly progressHistory?: readonly {
+        key: string;
+        newEvidence: boolean;
+        resolvedObligations: number;
+        newValidChecks: number;
+    }[];
+}
+/** Build kernel inputs plus a MetaState for one safe checkpoint. Host-owned inputs only. */
+export declare function toMetaState(input: RuntimeBridgeInput): RuntimeBridgeOutput;
+/** Sources admitted for reference evidence: only repository/official qualify. */
+export declare function sourceIdentities(overrides?: readonly SourceIdentity[]): readonly SourceIdentity[];
+//# sourceMappingURL=runtime-bridge.d.ts.map

package/dist/metacognition/runtime-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bridge.d.ts","sourceRoot":"","sources":["../../src/metacognition/runtime-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,KAAK,EACX,gBAAgB,EAChB,KAAK,EACL,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,KAAK,EACL,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAS5C,4FAA0F;AAC1F,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAsBnF;AAED,6FAA2F;AAC3F,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GACpC,gBAAgB,GAAG,oBAAoB,GAAG,mBAAmB,CAiC/D;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,gBAAgB,GAAG,oBAAoB,GAAG,mBAAmB,CAAC,EAAE,CAAC;CAClG;AACD,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,SAAS,eAAe,EAAE,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,mBAAmB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS;QACnC,GAAG,EAAE,MAAM,CAAC;QACZ,WAAW,EAAE,OAAO,CAAC;QACrB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,cAAc,EAAE,MAAM,CAAC;KACvB,EAAE,CAAC;CACJ;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CAwD1E;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,SAAS,GAAE,SAAS,cAAc,EAAO,GAAG,SAAS,cAAc,EAAE,CAWrG","sourcesContent":["/**\n * Runtime bridge — §13 \"기존 완료 판정 호출부\": projects host-owned OMK\n * runtime artifacts (protocol ClaimGraph claims, ObservationNodes, waiver\n * records, workspace/session facts) onto the metacognition kernel's input\n * types. It only translates; it never relaxes trust floors, never admits a\n * model's JSON as runner truth, and never fabricates completion.\n */\nimport type { ClaimNode, ObservationNode } from \"omk-protocol\";\nimport { createCalibrationStore } from \"./calibration.ts\";\nimport type {\n\tCheckObservation,\n\tClaim,\n\tDecisionObservation,\n\tReferenceObservation,\n\tSourceIdentity,\n\tStage,\n} from \"./knowledge.ts\";\nimport type { MetaState } from \"./state.ts\";\nimport { ensure, integer, lexical, member, text } from \"./validation.ts\";\n\nconst ISO_MS = (iso: string): number => {\n\tconst ms = Date.parse(iso);\n\tensure(Number.isFinite(ms), `invalid ISO timestamp: ${iso}`);\n\treturn ms;\n};\n\n/** ClaimNode → kernel Claim. Severity maps to impact; leaves keep their check demands. */\nexport function toKernelClaim(node: ClaimNode, stage: Stage, binding: string): Claim {\n\ttext(node.claimId, \"claimId\", 256);\n\ttext(node.statement, \"statement\", 2048);\n\tmember(stage, [\"before-change\", \"after-change\"], \"stage\");\n\tlet impact = 100;\n\tif (node.kind === \"safety\") impact = 1_000;\n\telse if (node.severity === \"required\") impact = 500;\n\treturn {\n\t\tid: node.claimId,\n\t\tbinding,\n\t\tphase: node.kind === \"requirement\" || node.kind === \"safety\" ? \"precondition\" : \"postcondition\",\n\t\tstatement: node.statement,\n\t\trequired: node.severity === \"required\",\n\t\timpact,\n\t\tneedsReference: false,\n\t\trequiresVersion: false,\n\t\tversion: null,\n\t\tminSourceFamilies: node.requiredWitnesses ?? 1,\n\t\trequiredCheckIds: node.invalidationKeys,\n\t\tneedsUserDecision: node.trustFloor === \"model_narrative\",\n\t\tpublicQuery: null,\n\t};\n}\n\n/** ObservationNode → kernel observation. Trust floor rank maps to source admissibility. */\nexport function toKernelObservation(\n\tnode: ObservationNode,\n\tbinding: string,\n\tnowMs: number,\n\tclaimById?: ReadonlyMap<string, Claim>,\n): CheckObservation | ReferenceObservation | DecisionObservation {\n\ttext(node.observationId, \"observationId\", 256);\n\ttext(binding, \"binding\", 512);\n\tinteger(nowMs, \"nowMs\");\n\tconst observedAtMs = nowMs;\n\tconst expiresAtMs = node.validUntil !== undefined ? ISO_MS(node.validUntil) : nowMs + 1;\n\tconst claimId = node.claimIds[0] ?? \"\";\n\tconst base = { id: node.observationId, claimId, binding, observedAtMs, expiresAtMs };\n\tif (node.receiptId !== undefined) {\n\t\t// checkId is the claim's required check predicate (its invalidation key),\n\t\t// not the receipt id — receipts are evidence artifacts, checkIds are obligations.\n\t\tconst checkId = claimById?.get(claimId)?.requiredCheckIds[0] ?? node.receiptId;\n\t\treturn {\n\t\t\t...base,\n\t\t\tkind: \"check\",\n\t\t\trunnerId: node.source,\n\t\t\tcheckId,\n\t\t\tsequence: 0,\n\t\t\tverdict: node.polarity === \"supports\" ? \"pass\" : \"fail\",\n\t\t};\n\t}\n\tif (node.source === \"model_narrative\") {\n\t\treturn { ...base, kind: \"decision\", actorId: \"model\", accepted: node.polarity === \"supports\" };\n\t}\n\treturn {\n\t\t...base,\n\t\tkind: \"reference\",\n\t\tsourceId: node.source,\n\t\tversion: null,\n\t\tstance: node.polarity === \"supports\" ? \"support\" : \"refute\",\n\t\tdocumentDigest: node.environmentDigest,\n\t\tlocator: node.sourceRoot,\n\t};\n}\n\nexport interface RuntimeBridgeOutput {\n\treadonly state: MetaState;\n\treadonly claims: readonly Claim[];\n\treadonly observations: readonly (CheckObservation | ReferenceObservation | DecisionObservation)[];\n}\nexport interface RuntimeBridgeInput {\n\treadonly taskId: string;\n\treadonly stageId: string;\n\treadonly goalScope: string;\n\treadonly targetArtifact: string;\n\treadonly candidateHash: string;\n\treadonly environmentHash: string;\n\treadonly claims: readonly ClaimNode[];\n\treadonly observations: readonly ObservationNode[];\n\treadonly trustedRunnerIds: readonly string[];\n\treadonly decisionActorIds: readonly string[];\n\treadonly authorizedActions: readonly string[];\n\treadonly budget: {\n\t\tremainingMs: number;\n\t\tremainingRequests: number;\n\t\tremainingTokens: number;\n\t\tremainingConcurrent: number;\n\t};\n\treadonly policyVersion: string;\n\treadonly modelRevision: string;\n\treadonly interruptionReason?: string | null;\n\treadonly stage: Stage;\n\treadonly nowMs: number;\n\treadonly progressHistory?: readonly {\n\t\tkey: string;\n\t\tnewEvidence: boolean;\n\t\tresolvedObligations: number;\n\t\tnewValidChecks: number;\n\t}[];\n}\n\n/** Build kernel inputs plus a MetaState for one safe checkpoint. Host-owned inputs only. */\nexport function toMetaState(input: RuntimeBridgeInput): RuntimeBridgeOutput {\n\ttext(input.taskId, \"taskId\", 128);\n\ttext(input.stageId, \"stageId\", 128);\n\ttext(input.goalScope, \"goalScope\", 256);\n\ttext(input.targetArtifact, \"targetArtifact\", 512);\n\ttext(input.candidateHash, \"candidateHash\", 128);\n\ttext(input.environmentHash, \"environmentHash\", 128);\n\ttext(input.policyVersion, \"policyVersion\", 64);\n\ttext(input.modelRevision, \"modelRevision\", 128);\n\tinteger(input.nowMs, \"nowMs\");\n\tensure(input.claims.length <= 128 && input.observations.length <= 4096, \"runtime bridge input too large\");\n\t// Only leaf claims map to kernel claims — compound satisfaction is the\n\t// protocol layer's job, not a kernel evidence predicate.\n\tconst binding = `${input.candidateHash}@${input.environmentHash}`;\n\tconst leafClaims = input.claims.filter((c) => c.satisfaction.inputs.length === 0);\n\tconst claimById = new Map(leafClaims.map((c) => [c.claimId, toKernelClaim(c, input.stage, binding)]));\n\tconst kernelClaims = [...claimById.values()].sort((a, b) => lexical(a.id, b.id));\n\tconst kernelObservations = input.observations.map((o) => toKernelObservation(o, binding, input.nowMs, claimById));\n\tconst state: MetaState = {\n\t\tgoal: {\n\t\t\ttaskId: input.taskId,\n\t\t\tstageId: input.stageId,\n\t\t\ttargetArtifact: input.targetArtifact,\n\t\t\tgoalScope: input.goalScope,\n\t\t},\n\t\tfacts: {\n\t\t\tcandidateHash: input.candidateHash,\n\t\t\tenvironmentHash: input.environmentHash,\n\t\t\tchangeScope: [input.targetArtifact],\n\t\t\tanalyzerCoverage: \"unknown\",\n\t\t},\n\t\tobligations: [],\n\t\tevidence: { report: null, adoptedSourceIds: [] },\n\t\tpredictions: [],\n\t\thypotheses: { open: [], discriminatorCandidates: [], modelMismatch: false },\n\t\tcalibration: createCalibrationStore({\n\t\t\tminSamples: 5,\n\t\t\tpriorAlpha: 1,\n\t\t\tpriorBeta: 1,\n\t\t\treferenceMean: 0.3,\n\t\t\tslack: 0.15,\n\t\t\tthreshold: 3,\n\t\t}),\n\t\tverifier: { evaluations: [], runnerHealth: \"unverified\" },\n\t\tbudget: input.budget,\n\t\tpolicy: {\n\t\t\tpolicyVersion: input.policyVersion,\n\t\t\tauthorizedActions: input.authorizedActions,\n\t\t\trequiredApprovals: [],\n\t\t\tinterruptionReason: input.interruptionReason ?? null,\n\t\t},\n\t\thostSequence: 0,\n\t\tprogressHistory: input.progressHistory ?? [],\n\t\tcheckpointCount: 0,\n\t};\n\treturn { state, claims: kernelClaims, observations: kernelObservations };\n}\n\n/** Sources admitted for reference evidence: only repository/official qualify. */\nexport function sourceIdentities(overrides: readonly SourceIdentity[] = []): readonly SourceIdentity[] {\n\treturn [\n\t\t{ id: \"deterministic_validator\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"workspace_witness\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"trusted_attestation\", family: \"attestation\", kind: \"official\" },\n\t\t{ id: \"effect_reconciliation\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"independent_review\", family: \"review\", kind: \"official\" },\n\t\t{ id: \"self_review\", family: \"model\", kind: \"model\" },\n\t\t{ id: \"model_narrative\", family: \"model\", kind: \"model\" },\n\t\t...overrides,\n\t];\n}\n"]}

package/dist/metacognition/runtime-bridge.js

@@ -0,0 +1,140 @@
+import { createCalibrationStore } from "./calibration.js";
+import { ensure, integer, lexical, member, text } from "./validation.js";
+const ISO_MS = (iso) => {
+    const ms = Date.parse(iso);
+    ensure(Number.isFinite(ms), `invalid ISO timestamp: ${iso}`);
+    return ms;
+};
+/** ClaimNode → kernel Claim. Severity maps to impact; leaves keep their check demands. */
+export function toKernelClaim(node, stage, binding) {
+    text(node.claimId, "claimId", 256);
+    text(node.statement, "statement", 2048);
+    member(stage, ["before-change", "after-change"], "stage");
+    let impact = 100;
+    if (node.kind === "safety")
+        impact = 1_000;
+    else if (node.severity === "required")
+        impact = 500;
+    return {
+        id: node.claimId,
+        binding,
+        phase: node.kind === "requirement" || node.kind === "safety" ? "precondition" : "postcondition",
+        statement: node.statement,
+        required: node.severity === "required",
+        impact,
+        needsReference: false,
+        requiresVersion: false,
+        version: null,
+        minSourceFamilies: node.requiredWitnesses ?? 1,
+        requiredCheckIds: node.invalidationKeys,
+        needsUserDecision: node.trustFloor === "model_narrative",
+        publicQuery: null,
+    };
+}
+/** ObservationNode → kernel observation. Trust floor rank maps to source admissibility. */
+export function toKernelObservation(node, binding, nowMs, claimById) {
+    text(node.observationId, "observationId", 256);
+    text(binding, "binding", 512);
+    integer(nowMs, "nowMs");
+    const observedAtMs = nowMs;
+    const expiresAtMs = node.validUntil !== undefined ? ISO_MS(node.validUntil) : nowMs + 1;
+    const claimId = node.claimIds[0] ?? "";
+    const base = { id: node.observationId, claimId, binding, observedAtMs, expiresAtMs };
+    if (node.receiptId !== undefined) {
+        // checkId is the claim's required check predicate (its invalidation key),
+        // not the receipt id — receipts are evidence artifacts, checkIds are obligations.
+        const checkId = claimById?.get(claimId)?.requiredCheckIds[0] ?? node.receiptId;
+        return {
+            ...base,
+            kind: "check",
+            runnerId: node.source,
+            checkId,
+            sequence: 0,
+            verdict: node.polarity === "supports" ? "pass" : "fail",
+        };
+    }
+    if (node.source === "model_narrative") {
+        return { ...base, kind: "decision", actorId: "model", accepted: node.polarity === "supports" };
+    }
+    return {
+        ...base,
+        kind: "reference",
+        sourceId: node.source,
+        version: null,
+        stance: node.polarity === "supports" ? "support" : "refute",
+        documentDigest: node.environmentDigest,
+        locator: node.sourceRoot,
+    };
+}
+/** Build kernel inputs plus a MetaState for one safe checkpoint. Host-owned inputs only. */
+export function toMetaState(input) {
+    text(input.taskId, "taskId", 128);
+    text(input.stageId, "stageId", 128);
+    text(input.goalScope, "goalScope", 256);
+    text(input.targetArtifact, "targetArtifact", 512);
+    text(input.candidateHash, "candidateHash", 128);
+    text(input.environmentHash, "environmentHash", 128);
+    text(input.policyVersion, "policyVersion", 64);
+    text(input.modelRevision, "modelRevision", 128);
+    integer(input.nowMs, "nowMs");
+    ensure(input.claims.length <= 128 && input.observations.length <= 4096, "runtime bridge input too large");
+    // Only leaf claims map to kernel claims — compound satisfaction is the
+    // protocol layer's job, not a kernel evidence predicate.
+    const binding = `${input.candidateHash}@${input.environmentHash}`;
+    const leafClaims = input.claims.filter((c) => c.satisfaction.inputs.length === 0);
+    const claimById = new Map(leafClaims.map((c) => [c.claimId, toKernelClaim(c, input.stage, binding)]));
+    const kernelClaims = [...claimById.values()].sort((a, b) => lexical(a.id, b.id));
+    const kernelObservations = input.observations.map((o) => toKernelObservation(o, binding, input.nowMs, claimById));
+    const state = {
+        goal: {
+            taskId: input.taskId,
+            stageId: input.stageId,
+            targetArtifact: input.targetArtifact,
+            goalScope: input.goalScope,
+        },
+        facts: {
+            candidateHash: input.candidateHash,
+            environmentHash: input.environmentHash,
+            changeScope: [input.targetArtifact],
+            analyzerCoverage: "unknown",
+        },
+        obligations: [],
+        evidence: { report: null, adoptedSourceIds: [] },
+        predictions: [],
+        hypotheses: { open: [], discriminatorCandidates: [], modelMismatch: false },
+        calibration: createCalibrationStore({
+            minSamples: 5,
+            priorAlpha: 1,
+            priorBeta: 1,
+            referenceMean: 0.3,
+            slack: 0.15,
+            threshold: 3,
+        }),
+        verifier: { evaluations: [], runnerHealth: "unverified" },
+        budget: input.budget,
+        policy: {
+            policyVersion: input.policyVersion,
+            authorizedActions: input.authorizedActions,
+            requiredApprovals: [],
+            interruptionReason: input.interruptionReason ?? null,
+        },
+        hostSequence: 0,
+        progressHistory: input.progressHistory ?? [],
+        checkpointCount: 0,
+    };
+    return { state, claims: kernelClaims, observations: kernelObservations };
+}
+/** Sources admitted for reference evidence: only repository/official qualify. */
+export function sourceIdentities(overrides = []) {
+    return [
+        { id: "deterministic_validator", family: "host", kind: "repository" },
+        { id: "workspace_witness", family: "host", kind: "repository" },
+        { id: "trusted_attestation", family: "attestation", kind: "official" },
+        { id: "effect_reconciliation", family: "host", kind: "repository" },
+        { id: "independent_review", family: "review", kind: "official" },
+        { id: "self_review", family: "model", kind: "model" },
+        { id: "model_narrative", family: "model", kind: "model" },
+        ...overrides,
+    ];
+}
+//# sourceMappingURL=runtime-bridge.js.map

package/dist/metacognition/runtime-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bridge.js","sourceRoot":"","sources":["../../src/metacognition/runtime-bridge.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Runtime bridge — §13 \"기존 완료 판정 호출부\": projects host-owned OMK\n * runtime artifacts (protocol ClaimGraph claims, ObservationNodes, waiver\n * records, workspace/session facts) onto the metacognition kernel's input\n * types. It only translates; it never relaxes trust floors, never admits a\n * model's JSON as runner truth, and never fabricates completion.\n */\nimport type { ClaimNode, ObservationNode } from \"omk-protocol\";\nimport { createCalibrationStore } from \"./calibration.ts\";\nimport type {\n\tCheckObservation,\n\tClaim,\n\tDecisionObservation,\n\tReferenceObservation,\n\tSourceIdentity,\n\tStage,\n} from \"./knowledge.ts\";\nimport type { MetaState } from \"./state.ts\";\nimport { ensure, integer, lexical, member, text } from \"./validation.ts\";\n\nconst ISO_MS = (iso: string): number => {\n\tconst ms = Date.parse(iso);\n\tensure(Number.isFinite(ms), `invalid ISO timestamp: ${iso}`);\n\treturn ms;\n};\n\n/** ClaimNode → kernel Claim. Severity maps to impact; leaves keep their check demands. */\nexport function toKernelClaim(node: ClaimNode, stage: Stage, binding: string): Claim {\n\ttext(node.claimId, \"claimId\", 256);\n\ttext(node.statement, \"statement\", 2048);\n\tmember(stage, [\"before-change\", \"after-change\"], \"stage\");\n\tlet impact = 100;\n\tif (node.kind === \"safety\") impact = 1_000;\n\telse if (node.severity === \"required\") impact = 500;\n\treturn {\n\t\tid: node.claimId,\n\t\tbinding,\n\t\tphase: node.kind === \"requirement\" || node.kind === \"safety\" ? \"precondition\" : \"postcondition\",\n\t\tstatement: node.statement,\n\t\trequired: node.severity === \"required\",\n\t\timpact,\n\t\tneedsReference: false,\n\t\trequiresVersion: false,\n\t\tversion: null,\n\t\tminSourceFamilies: node.requiredWitnesses ?? 1,\n\t\trequiredCheckIds: node.invalidationKeys,\n\t\tneedsUserDecision: node.trustFloor === \"model_narrative\",\n\t\tpublicQuery: null,\n\t};\n}\n\n/** ObservationNode → kernel observation. Trust floor rank maps to source admissibility. */\nexport function toKernelObservation(\n\tnode: ObservationNode,\n\tbinding: string,\n\tnowMs: number,\n\tclaimById?: ReadonlyMap<string, Claim>,\n): CheckObservation | ReferenceObservation | DecisionObservation {\n\ttext(node.observationId, \"observationId\", 256);\n\ttext(binding, \"binding\", 512);\n\tinteger(nowMs, \"nowMs\");\n\tconst observedAtMs = nowMs;\n\tconst expiresAtMs = node.validUntil !== undefined ? ISO_MS(node.validUntil) : nowMs + 1;\n\tconst claimId = node.claimIds[0] ?? \"\";\n\tconst base = { id: node.observationId, claimId, binding, observedAtMs, expiresAtMs };\n\tif (node.receiptId !== undefined) {\n\t\t// checkId is the claim's required check predicate (its invalidation key),\n\t\t// not the receipt id — receipts are evidence artifacts, checkIds are obligations.\n\t\tconst checkId = claimById?.get(claimId)?.requiredCheckIds[0] ?? node.receiptId;\n\t\treturn {\n\t\t\t...base,\n\t\t\tkind: \"check\",\n\t\t\trunnerId: node.source,\n\t\t\tcheckId,\n\t\t\tsequence: 0,\n\t\t\tverdict: node.polarity === \"supports\" ? \"pass\" : \"fail\",\n\t\t};\n\t}\n\tif (node.source === \"model_narrative\") {\n\t\treturn { ...base, kind: \"decision\", actorId: \"model\", accepted: node.polarity === \"supports\" };\n\t}\n\treturn {\n\t\t...base,\n\t\tkind: \"reference\",\n\t\tsourceId: node.source,\n\t\tversion: null,\n\t\tstance: node.polarity === \"supports\" ? \"support\" : \"refute\",\n\t\tdocumentDigest: node.environmentDigest,\n\t\tlocator: node.sourceRoot,\n\t};\n}\n\nexport interface RuntimeBridgeOutput {\n\treadonly state: MetaState;\n\treadonly claims: readonly Claim[];\n\treadonly observations: readonly (CheckObservation | ReferenceObservation | DecisionObservation)[];\n}\nexport interface RuntimeBridgeInput {\n\treadonly taskId: string;\n\treadonly stageId: string;\n\treadonly goalScope: string;\n\treadonly targetArtifact: string;\n\treadonly candidateHash: string;\n\treadonly environmentHash: string;\n\treadonly claims: readonly ClaimNode[];\n\treadonly observations: readonly ObservationNode[];\n\treadonly trustedRunnerIds: readonly string[];\n\treadonly decisionActorIds: readonly string[];\n\treadonly authorizedActions: readonly string[];\n\treadonly budget: {\n\t\tremainingMs: number;\n\t\tremainingRequests: number;\n\t\tremainingTokens: number;\n\t\tremainingConcurrent: number;\n\t};\n\treadonly policyVersion: string;\n\treadonly modelRevision: string;\n\treadonly interruptionReason?: string | null;\n\treadonly stage: Stage;\n\treadonly nowMs: number;\n\treadonly progressHistory?: readonly {\n\t\tkey: string;\n\t\tnewEvidence: boolean;\n\t\tresolvedObligations: number;\n\t\tnewValidChecks: number;\n\t}[];\n}\n\n/** Build kernel inputs plus a MetaState for one safe checkpoint. Host-owned inputs only. */\nexport function toMetaState(input: RuntimeBridgeInput): RuntimeBridgeOutput {\n\ttext(input.taskId, \"taskId\", 128);\n\ttext(input.stageId, \"stageId\", 128);\n\ttext(input.goalScope, \"goalScope\", 256);\n\ttext(input.targetArtifact, \"targetArtifact\", 512);\n\ttext(input.candidateHash, \"candidateHash\", 128);\n\ttext(input.environmentHash, \"environmentHash\", 128);\n\ttext(input.policyVersion, \"policyVersion\", 64);\n\ttext(input.modelRevision, \"modelRevision\", 128);\n\tinteger(input.nowMs, \"nowMs\");\n\tensure(input.claims.length <= 128 && input.observations.length <= 4096, \"runtime bridge input too large\");\n\t// Only leaf claims map to kernel claims — compound satisfaction is the\n\t// protocol layer's job, not a kernel evidence predicate.\n\tconst binding = `${input.candidateHash}@${input.environmentHash}`;\n\tconst leafClaims = input.claims.filter((c) => c.satisfaction.inputs.length === 0);\n\tconst claimById = new Map(leafClaims.map((c) => [c.claimId, toKernelClaim(c, input.stage, binding)]));\n\tconst kernelClaims = [...claimById.values()].sort((a, b) => lexical(a.id, b.id));\n\tconst kernelObservations = input.observations.map((o) => toKernelObservation(o, binding, input.nowMs, claimById));\n\tconst state: MetaState = {\n\t\tgoal: {\n\t\t\ttaskId: input.taskId,\n\t\t\tstageId: input.stageId,\n\t\t\ttargetArtifact: input.targetArtifact,\n\t\t\tgoalScope: input.goalScope,\n\t\t},\n\t\tfacts: {\n\t\t\tcandidateHash: input.candidateHash,\n\t\t\tenvironmentHash: input.environmentHash,\n\t\t\tchangeScope: [input.targetArtifact],\n\t\t\tanalyzerCoverage: \"unknown\",\n\t\t},\n\t\tobligations: [],\n\t\tevidence: { report: null, adoptedSourceIds: [] },\n\t\tpredictions: [],\n\t\thypotheses: { open: [], discriminatorCandidates: [], modelMismatch: false },\n\t\tcalibration: createCalibrationStore({\n\t\t\tminSamples: 5,\n\t\t\tpriorAlpha: 1,\n\t\t\tpriorBeta: 1,\n\t\t\treferenceMean: 0.3,\n\t\t\tslack: 0.15,\n\t\t\tthreshold: 3,\n\t\t}),\n\t\tverifier: { evaluations: [], runnerHealth: \"unverified\" },\n\t\tbudget: input.budget,\n\t\tpolicy: {\n\t\t\tpolicyVersion: input.policyVersion,\n\t\t\tauthorizedActions: input.authorizedActions,\n\t\t\trequiredApprovals: [],\n\t\t\tinterruptionReason: input.interruptionReason ?? null,\n\t\t},\n\t\thostSequence: 0,\n\t\tprogressHistory: input.progressHistory ?? [],\n\t\tcheckpointCount: 0,\n\t};\n\treturn { state, claims: kernelClaims, observations: kernelObservations };\n}\n\n/** Sources admitted for reference evidence: only repository/official qualify. */\nexport function sourceIdentities(overrides: readonly SourceIdentity[] = []): readonly SourceIdentity[] {\n\treturn [\n\t\t{ id: \"deterministic_validator\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"workspace_witness\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"trusted_attestation\", family: \"attestation\", kind: \"official\" },\n\t\t{ id: \"effect_reconciliation\", family: \"host\", kind: \"repository\" },\n\t\t{ id: \"independent_review\", family: \"review\", kind: \"official\" },\n\t\t{ id: \"self_review\", family: \"model\", kind: \"model\" },\n\t\t{ id: \"model_narrative\", family: \"model\", kind: \"model\" },\n\t\t...overrides,\n\t];\n}\n"]}

package/dist/metacognition/skills.d.ts

@@ -0,0 +1,42 @@
+export interface CapabilityNeed {
+    readonly capability: string;
+    readonly weight: number;
+    readonly required: boolean;
+}
+export interface SkillDescriptor {
+    readonly id: string;
+    readonly contentHash: string;
+    readonly capabilities: readonly string[];
+    readonly phases: readonly string[];
+    readonly tokenCost: number;
+    readonly dependencies: readonly string[];
+    readonly conflicts: readonly string[];
+    readonly permissions: readonly string[];
+    readonly explicitOnly: boolean;
+    /** Exact versions intentionally, never a hand-written semver implementation. */
+    readonly packages: Readonly<Record<string, readonly string[]>>;
+}
+export interface SkillPlanInput {
+    readonly phase: string;
+    readonly needs: readonly CapabilityNeed[];
+    readonly catalog: readonly SkillDescriptor[];
+    /** Host-owned content pins, not fields supplied by the skill being selected. */
+    readonly approvedHashes: Readonly<Record<string, string>>;
+    readonly installedVersions: Readonly<Record<string, string>>;
+    readonly allowedPermissions: readonly string[];
+    readonly explicitSkills: readonly string[];
+    readonly tokenBudget: number;
+    readonly maxSkills: number;
+}
+export interface SkillPlan {
+    readonly selected: readonly string[];
+    readonly tokenCost: number;
+    readonly covered: readonly string[];
+    readonly uncoveredRequired: readonly string[];
+    readonly blockedExplicit: readonly string[];
+    readonly rejected: Readonly<Record<string, string>>;
+    readonly algorithm: "exact-small" | "greedy-with-singleton";
+    readonly state: "covered" | "capability-gap" | "explicit-blocked";
+}
+export declare function planSkills(input: SkillPlanInput): SkillPlan;
+//# sourceMappingURL=skills.d.ts.map

package/dist/metacognition/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/metacognition/skills.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC3B;AACD,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CAC/D;AACD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AACD,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,uBAAuB,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;CAClE;AAQD,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAmM3D","sourcesContent":["/**\n * Capability-coverage skill planning under host-approved constraints.\n *\n * Ported from docs/OMK_skill_knowledge_control_2026-09-19.zip\n * (src/skills.ts). Exact search for small sets, bounded greedy for large sets.\n */\nimport { arrayBound, ensure, integer, lexical, text, unique } from \"./validation.ts\";\n\nexport interface CapabilityNeed {\n\treadonly capability: string;\n\treadonly weight: number;\n\treadonly required: boolean;\n}\nexport interface SkillDescriptor {\n\treadonly id: string;\n\treadonly contentHash: string;\n\treadonly capabilities: readonly string[];\n\treadonly phases: readonly string[];\n\treadonly tokenCost: number;\n\treadonly dependencies: readonly string[];\n\treadonly conflicts: readonly string[];\n\treadonly permissions: readonly string[];\n\treadonly explicitOnly: boolean;\n\t/** Exact versions intentionally, never a hand-written semver implementation. */\n\treadonly packages: Readonly<Record<string, readonly string[]>>;\n}\nexport interface SkillPlanInput {\n\treadonly phase: string;\n\treadonly needs: readonly CapabilityNeed[];\n\treadonly catalog: readonly SkillDescriptor[];\n\t/** Host-owned content pins, not fields supplied by the skill being selected. */\n\treadonly approvedHashes: Readonly<Record<string, string>>;\n\treadonly installedVersions: Readonly<Record<string, string>>;\n\treadonly allowedPermissions: readonly string[];\n\treadonly explicitSkills: readonly string[];\n\treadonly tokenBudget: number;\n\treadonly maxSkills: number;\n}\nexport interface SkillPlan {\n\treadonly selected: readonly string[];\n\treadonly tokenCost: number;\n\treadonly covered: readonly string[];\n\treadonly uncoveredRequired: readonly string[];\n\treadonly blockedExplicit: readonly string[];\n\treadonly rejected: Readonly<Record<string, string>>;\n\treadonly algorithm: \"exact-small\" | \"greedy-with-singleton\";\n\treadonly state: \"covered\" | \"capability-gap\" | \"explicit-blocked\";\n}\ninterface Value {\n\trequired: number;\n\toptional: number;\n\tcost: number;\n\tids: string[];\n}\n\nexport function planSkills(input: SkillPlanInput): SkillPlan {\n\ttext(input.phase, \"phase\", 128);\n\tinteger(input.tokenBudget, \"tokenBudget\", 10_000_000);\n\tinteger(input.maxSkills, \"maxSkills\", 64);\n\tarrayBound(input.catalog, \"catalog\", 500);\n\tarrayBound(input.needs, \"needs\", 128);\n\tunique(\n\t\tinput.catalog.map((s) => s.id),\n\t\t\"catalog ids\",\n\t);\n\tunique(\n\t\tinput.needs.map((n) => n.capability),\n\t\t\"need ids\",\n\t\t128,\n\t);\n\tunique(input.allowedPermissions, \"permissions\");\n\tunique(input.explicitSkills, \"explicitSkills\", 64);\n\tfor (const need of input.needs) {\n\t\tensure(Number.isFinite(need.weight) && need.weight > 0 && need.weight <= 1_000_000, \"invalid need weight\");\n\t\tensure(typeof need.required === \"boolean\", \"required must be boolean\");\n\t}\n\tconst byId = new Map(input.catalog.map((skill) => [skill.id, skill]));\n\tconst rejected = new Map<string, string>();\n\tfor (const skill of input.catalog) {\n\t\ttext(skill.contentHash, \"contentHash\");\n\t\tinteger(skill.tokenCost, \"tokenCost\", 1_000_000);\n\t\tunique(skill.capabilities, \"capabilities\", 128);\n\t\tunique(skill.phases, \"phases\", 32);\n\t\tunique(skill.dependencies, \"dependencies\", 64);\n\t\tunique(skill.conflicts, \"conflicts\", 64);\n\t\tunique(skill.permissions, \"skill permissions\", 64);\n\t\tensure(typeof skill.explicitOnly === \"boolean\", \"explicitOnly must be boolean\");\n\t\tensure(skill.packages !== null && typeof skill.packages === \"object\", \"packages must be a record\");\n\t\tfor (const [name, versions] of Object.entries(skill.packages)) {\n\t\t\ttext(name, \"package\");\n\t\t\tunique(versions, \"versions\", 128);\n\t\t\tensure(versions.length > 0, \"empty supported versions\");\n\t\t}\n\t\tif (input.approvedHashes[skill.id] !== skill.contentHash) rejected.set(skill.id, \"unapproved-or-changed-content\");\n\t\telse if (!skill.phases.includes(input.phase)) rejected.set(skill.id, \"phase-mismatch\");\n\t\telse if (skill.explicitOnly && !input.explicitSkills.includes(skill.id)) rejected.set(skill.id, \"explicit-only\");\n\t\telse if (skill.permissions.some((permission) => !input.allowedPermissions.includes(permission))) {\n\t\t\trejected.set(skill.id, \"permission-denied\");\n\t\t} else if (\n\t\t\tObject.entries(skill.packages).some(\n\t\t\t\t([name, versions]) => !versions.includes(input.installedVersions[name] ?? \"\"),\n\t\t\t)\n\t\t) {\n\t\t\trejected.set(skill.id, \"version-unknown-or-incompatible\");\n\t\t}\n\t}\n\t// A cycle or unavailable prerequisite invalidates the entire dependent closure.\n\tconst closureCache = new Map<string, Set<string> | undefined>();\n\tconst closure = (id: string, trail = new Set<string>()): Set<string> | undefined => {\n\t\tif (trail.has(id) || rejected.has(id)) return undefined;\n\t\tif (closureCache.has(id)) return closureCache.get(id);\n\t\tconst skill = byId.get(id);\n\t\tif (!skill) return undefined;\n\t\tconst result = new Set([id]);\n\t\tconst next = new Set([...trail, id]);\n\t\tfor (const dependency of skill.dependencies) {\n\t\t\tconst children = closure(dependency, next);\n\t\t\tif (!children) {\n\t\t\t\tclosureCache.set(id, undefined);\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tfor (const child of children) result.add(child);\n\t\t}\n\t\tclosureCache.set(id, result);\n\t\treturn result;\n\t};\n\tconst closures = new Map<string, Set<string>>();\n\tfor (const id of [...byId.keys()].sort(lexical)) {\n\t\tconst set = closure(id);\n\t\tif (set) closures.set(id, set);\n\t\telse if (!rejected.has(id)) rejected.set(id, \"invalid-dependency-closure\");\n\t}\n\tconst feasible = (ids: ReadonlySet<string>): boolean => {\n\t\tif (ids.size > input.maxSkills) return false;\n\t\tlet cost = 0;\n\t\tfor (const id of ids) {\n\t\t\tconst skill = byId.get(id);\n\t\t\tif (!skill || rejected.has(id)) return false;\n\t\t\tif (skill.dependencies.some((d) => !ids.has(d))) return false;\n\t\t\tif (skill.conflicts.some((c) => ids.has(c))) return false;\n\t\t\tcost += skill.tokenCost;\n\t\t}\n\t\treturn cost <= input.tokenBudget;\n\t};\n\tconst value = (ids: ReadonlySet<string>): Value => {\n\t\tconst coverage = new Set<string>();\n\t\tlet cost = 0;\n\t\tfor (const id of ids) {\n\t\t\tconst skill = byId.get(id)!;\n\t\t\tcost += skill.tokenCost;\n\t\t\tfor (const capability of skill.capabilities) coverage.add(capability);\n\t\t}\n\t\tlet required = 0,\n\t\t\toptional = 0;\n\t\tfor (const need of input.needs) {\n\t\t\tif (coverage.has(need.capability)) {\n\t\t\t\tif (need.required) required += need.weight;\n\t\t\t\telse optional += need.weight;\n\t\t\t}\n\t\t}\n\t\treturn { required, optional, cost, ids: [...ids].sort(lexical) };\n\t};\n\tconst better = (left: Value, right: Value): boolean =>\n\t\tleft.required !== right.required\n\t\t\t? left.required > right.required\n\t\t\t: left.optional !== right.optional\n\t\t\t\t? left.optional > right.optional\n\t\t\t\t: left.cost !== right.cost\n\t\t\t\t\t? left.cost < right.cost\n\t\t\t\t\t: left.ids.length !== right.ids.length\n\t\t\t\t\t\t? left.ids.length < right.ids.length\n\t\t\t\t\t\t: lexical(left.ids.join(\"\\0\"), right.ids.join(\"\\0\")) < 0;\n\tlet base = new Set<string>();\n\tconst blockedExplicit: string[] = [];\n\tfor (const id of [...input.explicitSkills].sort(lexical)) {\n\t\tconst set = closures.get(id);\n\t\tif (!set) blockedExplicit.push(id);\n\t\telse for (const item of set) base.add(item);\n\t}\n\tif (!feasible(base)) blockedExplicit.push(...input.explicitSkills.filter((id) => !blockedExplicit.includes(id)));\n\t// Conflicting explicit requests are never silently replaced by automatic picks.\n\tif (blockedExplicit.length > 0) base = new Set();\n\tlet best = base;\n\tconst candidates = [...closures.entries()].filter(([id]) => !base.has(id));\n\tconst algorithm = candidates.length <= 12 ? \"exact-small\" : \"greedy-with-singleton\";\n\tif (blockedExplicit.length === 0) {\n\t\tif (algorithm === \"exact-small\") {\n\t\t\tconst visit = (position: number, current: Set<string>): void => {\n\t\t\t\tif (!feasible(current)) return;\n\t\t\t\tif (better(value(current), value(best))) best = current;\n\t\t\t\tconst candidate = candidates[position];\n\t\t\t\tif (!candidate) return;\n\t\t\t\tvisit(position + 1, current);\n\t\t\t\tvisit(position + 1, new Set([...current, ...candidate[1]]));\n\t\t\t};\n\t\t\tvisit(0, base);\n\t\t} else {\n\t\t\tlet current = base;\n\t\t\twhile (true) {\n\t\t\t\tconst previous = value(current);\n\t\t\t\tlet winner: Set<string> | undefined;\n\t\t\t\tlet rank: readonly [number, number, string] = [-1, -1, \"\"];\n\t\t\t\tfor (const [id, set] of candidates) {\n\t\t\t\t\tif (current.has(id)) continue;\n\t\t\t\t\tconst joined = new Set([...current, ...set]);\n\t\t\t\t\tif (!feasible(joined)) continue;\n\t\t\t\t\tconst after = value(joined);\n\t\t\t\t\tconst requiredGain = after.required - previous.required;\n\t\t\t\t\tconst optionalGain = after.optional - previous.optional;\n\t\t\t\t\tif (requiredGain <= 0 && optionalGain <= 0) continue;\n\t\t\t\t\tconst cost = Math.max(1, after.cost - previous.cost);\n\t\t\t\t\tconst proposal = [requiredGain / cost, optionalGain / cost, id] as const;\n\t\t\t\t\tif (\n\t\t\t\t\t\t!winner ||\n\t\t\t\t\t\tproposal[0] > rank[0] ||\n\t\t\t\t\t\t(proposal[0] === rank[0] &&\n\t\t\t\t\t\t\t(proposal[1] > rank[1] || (proposal[1] === rank[1] && lexical(proposal[2], rank[2]) < 0)))\n\t\t\t\t\t) {\n\t\t\t\t\t\twinner = joined;\n\t\t\t\t\t\trank = proposal;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!winner) break;\n\t\t\t\tcurrent = winner;\n\t\t\t}\n\t\t\tbest = current;\n\t\t\tfor (const [, set] of candidates) {\n\t\t\t\tconst joined = new Set([...base, ...set]);\n\t\t\t\tif (feasible(joined) && better(value(joined), value(best))) best = joined;\n\t\t\t}\n\t\t}\n\t}\n\tconst allCovered = new Set([...best].flatMap((id) => byId.get(id)!.capabilities));\n\tconst uncoveredRequired = input.needs\n\t\t.filter((n) => n.required && !allCovered.has(n.capability))\n\t\t.map((n) => n.capability)\n\t\t.sort(lexical);\n\treturn {\n\t\tselected: [...best].sort(lexical),\n\t\ttokenCost: value(best).cost,\n\t\tcovered: input.needs\n\t\t\t.filter((n) => allCovered.has(n.capability))\n\t\t\t.map((n) => n.capability)\n\t\t\t.sort(lexical),\n\t\tuncoveredRequired,\n\t\tblockedExplicit: blockedExplicit.sort(lexical),\n\t\trejected: Object.fromEntries([...rejected].sort(([a], [b]) => lexical(a, b))),\n\t\talgorithm,\n\t\tstate: blockedExplicit.length ? \"explicit-blocked\" : uncoveredRequired.length ? \"capability-gap\" : \"covered\",\n\t};\n}\n"]}