open-multi-agent-kit 0.99.0 → 1.2.0

package/docs/runtime-algorithms.md

@@ -1,5 +1,81 @@
 # Runtime Algorithms and Direction
 
+## Current feature status (audit §19.3)
+
+"Implemented", "wired", "enabled", "verified in CI", "released", and
+"measured benefit" are different gates. A pure function passing unit tests is
+not a live product path, and a live path is not a measured improvement. This
+table records each mechanism's actual gate at the pinned commit; the dated
+baseline below is history, not current truth.
+
+| Mechanism | Implemented | Wired into live path | Enabled by default | Verified in CI | Released | Measured benefit |
+| --- | --- | --- | --- | --- | --- | --- |
+| DAG claim scheduler (`tool-dag-scheduler`) | yes | `agent-loop` frontier executor | `toolScheduler: "dag-v2"` | unit + integration tests | v0.99.x line | not measured |
+| Ready-frontier admission (`runDagFrontier`) | yes | `agent-loop` | same | `tool-dag-ready-frontier`, `tool-dag-hook-replan` tests | working tree | not measured |
+| Dynamic-claim conflict check (`conflictsWithUnsettledClaim`) | yes | `agent-loop` | same | `tool-dag-dependencies` + hook tests | working tree | not measured |
+| ECRAF admission planner (`tool-dag-ecraf`) | yes | **no** — no call path wires it | n/a | unit tests only | unreleased | not measured |
+| Context Budget V2 | yes | system-prompt assembly | opt-in policy | planner/selection/cache tests | working tree | not measured |
+| Tier floor reservation | yes | context-budget-v2 planner | when V2 enabled | `context-budget-v2-tier-floor` tests | working tree | not measured |
+| Reasoning router v4 | yes | `/think auto` lane | opt-in | router tests | released | classification only, not success-probability calibration |
+| Workload permit pool | yes | resource admission | default | pool tests | released | not measured |
+| Provider retry/failover classification | yes | `provider-retry`, `session-failure-cause` | default | resilience/classification tests | released | not measured |
+| MCP descriptor injection screen | yes | `mcp/manager` import path | default | quarantine tests | released | pattern rule score, not calibrated risk |
+| verified-run coordinator + evidence | yes | verified-run paths | opt-in command | coordinator/evidence tests | working tree | scope-limited binding, not general correctness |
+
+Gates are reported per row so a green "implemented" never upgrades itself to
+"released" or "measured".
+
+## ECRAF arithmetic boundary (2026-09-17)
+
+The internal `planEcrafAdmissions()` planner rejects non-finite derived density
+denominators, scores, and reserved usage with `RangeError`, even when each input
+number is finite. Scores are computed once per candidate before sorting or
+calling the conflict predicate; singleton and zero-slot batches receive the same
+validation. A bounded resource overflow still defers the candidate and allows
+later feasible candidates. An unbounded resource has no capacity limit, but its
+usage must remain representable as a finite number. Failed passes return no
+partial admission plan and do not mutate caller input.
+
+Regression coverage is in
+`packages/agent/test/tool-dag-ecraf-arithmetic.test.ts`; existing numeric and
+property tests remain in `packages/agent/test/tool-dag-ecraf.test.ts`.
+This is local pure-planner validation, not live frontier wiring, CI confirmation,
+a release, or evidence of latency/quality improvement. Resource normalization,
+slot-aware ranking, fairness, and equal-budget runtime comparisons remain separate
+work.
+
+## Final claim resolution is abort-bound (2026-09-19 audit F02)
+
+The dag-v2 frontier re-resolves each prepared call's resource claims from its
+exact post-hook arguments before admission. That wait was a bare `await`; the
+initial scheduling pass in `tool-dag-memo` was already raced against the run's
+abort signal, so an extension `resourceClaims()` that never settled on the
+second call pinned a cancelled run until the callback returned on its own.
+`resolveFinalResolution` now uses the same `awaitWithAbort` boundary. The
+callback itself is not killed — a plain Promise cannot be — but the aborted
+outcome settles the call, the frontier loop exits on the same signal, and a late
+fulfilment or rejection lands in a finished batch and admits nothing. In-flight
+peers keep the existing abort contract (`aborted`, `executionStarted: true`),
+and the authorization hook still runs once. Coverage:
+`packages/agent/test/tool-dag-final-claims-abort.test.ts`. This is the wait
+boundary only; isolating a non-cooperative extension needs a killable execution
+boundary, which this change does not add.
+
+## Reasoning router resolver contract (2026-09-19 audit F05/F06)
+
+The low-confidence escalation in `resolveThinkingLevelV4WithUncertainty` is
+monotone at a fixed bias and hint only; it is not a floor at the class base
+level, because a negative learning bias is applied before the +1 step (`debug`
+with `bias=-2` still resolves to `medium`). The docstring previously claimed the
+stronger floor. A policy that must never drop below the base level needs an
+explicit safety floor, which is a cost decision not taken here. The shared
+resolver also normalizes `bias` and `escalationSteps` to finite integers
+(non-finite → 0, fractions truncated toward zero) so a corrupted value keeps the
+class's own level instead of walking the ladder lookup off its rungs to the
+lowest available level; the session's bias-snapshot validator already rejects
+such values before they reach the resolver. Coverage:
+`packages/coding-agent/test/reasoning-router-resolver-contract.test.ts`.
+
 ## Working-tree shared run budgets
 
 The SDK `prompt(..., { runBudget })` path now shares a monotonic deadline and
@@ -130,21 +206,93 @@ The planner:
 4. scores optional items for relevance, recency, evidence, redundancy,
    priority, and full-text token cost;
 5. sorts optional items by
-   `density -> effectiveScore -> priorityRank -> fullTokens -> id`; and
+   `density -> effectiveScore -> priorityRank -> fullTokens -> id`;
 6. selects a full, summary, headroom-compressed, pointer, or omitted
-   representation that fits.
+   representation that fits (floor pass per tier, then the global pass);
+7. lets each still-omitted item buy its cheapest admissible form by stepping
+   selected items down to theirs, applied all-or-nothing; and
+8. re-offers each remaining item its costlier representations against the
+   leftover budget and promotes only when the selection policy prefers the
+   costlier form and it fits both the tier ceiling and the global remainder
+   (`context-budget-v2-global-pass.ts`; never touches hard items).
+
+Breadth is settled before quality: step 7 runs before step 8, so an exchange
+that admits another item cannot be undone by a promotion.
 
 Density divides effective score by the cheapest non-omit representation
 (`admissibleTokens`), not by full-text size. This avoids penalizing an item that
 can be represented by a small evidence pointer. Stable item IDs and explicit
-selection policy `sel-2` make tie-breaking and plan-cache invalidation
+selection policy `sel-3` make tie-breaking and plan-cache invalidation
 deterministic.
 
+### Representation cost accounting (2026-09-19 audit F01/F03)
+
+Every derived representation is priced by counting the string it materializes
+with the planner's own token counter, the same counter that priced the full
+text. The former `ceil(0.15 * full) + 8` summary price was a compression target,
+not a cost: a 100-character "summary" identical to its source was recorded at
+12 tokens against the source's 25 and admitted into a 12-token budget. A
+representation whose text equals the source, or whose counted cost is not below
+the full text, is no longer offered. `createPlannedItems` stores the priced
+candidates on each planned item so ranking and selection read one cost; the
+selection policy token moved from `sel-2` to `sel-3` so plans and
+representation entries cached under the old prices are not served.
+
+### Representation exchange (2026-09-19 audit F04)
+
+Items are ranked by their cheapest admissible representation but admitted at
+whatever the selector prefers, so a high-priority item priced at 10 for ordering
+could consume 100 and displace two 45-token items. On the audit's counterexample
+that scored 121 against 169.5 for `A-pointer + B-full + C-full` at the same 100
+tokens, measured with the selector's own preference score.
+
+The repair is bounded. After the global pass, each still-omitted item in rank
+order may pay for its admission by stepping already-selected items down to their
+cheapest admissible representation. Donors yield in order of the preference the
+policy loses per token freed, the whole exchange is applied or none of it is,
+and a donor is skipped when stepping it down would drop its tier below the floor
+it is currently honouring. An item admitted this way leaves the omitted list, so
+it is never reported as both included and omitted.
+
+This is not joint `(item, representation)` optimization: donor choice is greedy
+and admission order is unchanged, so the planner can still trail a brute-force
+oracle on instances the bounded repair cannot reach. It does reach the oracle on
+the audit counterexample, and a 200-instance randomized property check holds
+feasibility (global and tier caps), disjoint included/omitted sets, and
+maximality: no omitted item still fits at its cheapest admissible form.
+
+The quality-policy field `preferFullForHighPriority` is deprecated: nothing
+reads it, and flipping it changes no candidate or choice
+(`context-budget-quality-policy-semantics.test.ts`). The priority weight already
+prefers full text for high-priority items.
+
+Evidence:
+
+- `packages/coding-agent/test/context-budget-representation-accounting.test.ts`
+- `packages/coding-agent/test/context-budget-representation-exchange.test.ts`
+- `packages/coding-agent/test/context-budget-representation-promotion.test.ts`
+- `packages/coding-agent/test/context-budget-quality-policy-semantics.test.ts`
+
 When enabled, representation and negative-result entries persist under
 `.omk/cache/context-budget-v2`; plan entries remain session-memory-only.
 `OMK_CONTEXT_GOVERNOR_CACHE=memory` keeps every cache entry in session memory,
 and `OMK_CONTEXT_GOVERNOR_CACHE_DIR` relocates the representation snapshot.
 
+Cache keys are bound to the counter that produced the prices. Two of the three
+layers bind it implicitly — a plan key hashes each planned item's token counts,
+and an exact representation key hashes a fingerprint containing
+`estimatedTokens` — but the materialized (semantic) key is bucketed at 100
+tokens and carries the tokenizer as a field, and no caller passed one, so every
+counter shared the static `heuristic-v1` key space and the entry's
+`tokenizer_mismatch` check compared that constant against itself. Since F01 made
+every representation price counter-dependent, that let one estimator's price be
+admitted in another estimator's run. The planner now resolves the key's
+tokenizer from the counter's own `adapterId`
+(`resolveEffectiveTokenizerIdV2`, probing a non-empty string because
+`countText("")` short-circuits to the fallback estimator); an explicit
+`tokenizerId` input still wins. Coverage:
+`packages/coding-agent/test/context-budget-cache-tokenizer-binding.test.ts`.
+
 Evidence:
 
 - `packages/coding-agent/src/core/context-budget-v2-planner.ts`

package/docs/skills.md

@@ -4,7 +4,7 @@
 
 Skills are self-contained capability packages that the agent loads on-demand. A skill provides specialized workflows, setup instructions, helper scripts, and reference documentation for specific tasks.
 
-OMK ships with **no built-in skills** — every skill is user-installed via the locations below, an OMK package, or `--skill`. The default session has zero skills and zero MCP servers configured.
+This source tree includes six public [Neo skills](neo.md) in `resources/neo/skills`. They fill names not supplied by user, project, or explicit skills. `--no-skills` disables automatic loading, while `OMK_BUNDLED_SKILLS=0` disables only the bundled set. Explicit `--skill` paths remain available. Bundled instructions do not install or connect MCP servers; MCP setup remains opt-in. This source integration does not imply that older published packages include Neo.
 
 OMK implements the [Agent Skills standard](https://agentskills.io/specification), warning about most violations but remaining lenient. OMK allows skill names to differ from their parent directory even though the standard disallows it; that rule is suboptimal for shared skill directories used across multiple agent harnesses.
 

package/docs/usage.md

@@ -146,7 +146,8 @@ When the resolved model ID is exactly `gpt-6-astra`, the built-in preset appends
 such as `openai/gpt-6-astra` and `openrouter/openai/gpt-6-astra` match the same
 model. Similar names, dated variants, and other GPT models do not select this
 preset. Select the configured model through `/model`; the preset does not add
-model availability to an account.
+model availability to an account. `--thinking ultra` is a selector alias for
+Astra's documented ceiling `max`; OMK does not send `reasoning.effort: "ultra"`.
 
 The Astra guidance encourages completing authorized work, asking only material
 clarifying questions, explaining any skill instruction that blocks progress,

package/examples/extensions/custom-provider-anthropic/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "omk-extension-custom-provider-anthropic",
-  "version": "0.99.0",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omk-extension-custom-provider-anthropic",
-      "version": "0.99.0",
+      "version": "1.2.0",
       "dependencies": {
         "@anthropic-ai/sdk": "0.52.0"
       }

package/examples/extensions/custom-provider-anthropic/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "omk-extension-custom-provider-anthropic",
 	"private": true,
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/custom-provider-gitlab-duo/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "omk-extension-custom-provider-gitlab-duo",
 	"private": true,
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/gondolin/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "omk-extension-gondolin",
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "omk-extension-gondolin",
-			"version": "0.99.0",
+			"version": "1.2.0",
 			"dependencies": {
 				"@earendil-works/gondolin": "0.12.0"
 			}

package/examples/extensions/gondolin/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "omk-extension-gondolin",
 	"private": true,
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/sandbox/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "omk-extension-sandbox",
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "omk-extension-sandbox",
-			"version": "0.99.0",
+			"version": "1.2.0",
 			"dependencies": {
 				"@anthropic-ai/sandbox-runtime": "0.0.26"
 			}

package/examples/extensions/sandbox/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "omk-extension-sandbox",
 	"private": true,
-	"version": "0.99.0",
+	"version": "1.2.0",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",

package/examples/extensions/subagent/adaptive-agent-runtime.ts

@@ -28,6 +28,7 @@ import {
 	remainingExecutionMs,
 } from "./deadline-budget.ts";
 import type { DeadlineProfileStore } from "./deadline-profile-store.ts";
+import type { ManagedProcessResult } from "./managed-process.ts";
 import type {
 	DeadlineAttemptMetadata,
 	DeadlineOutcome,
@@ -99,6 +100,7 @@ export async function runAdaptiveAgent(options: RunAdaptiveAgentOptions): Promis
 	let duplicateResumeBlocked = false;
 	let lastCheckpoint: Awaited<ReturnType<typeof readCheckpoint>> | undefined;
 	let terminalOutcome: DeadlineOutcome = "budget-exhausted";
+	let unsettledProcess: ManagedProcessResult | undefined;
 	const checkpointPrefix = options.checkpointPrefix ?? path.join(os.tmpdir(), "omk-subagent-checkpoint-");
 	const workspace = await createCheckpointWorkspace(checkpointPrefix);
 
@@ -183,7 +185,11 @@ export async function runAdaptiveAgent(options: RunAdaptiveAgentOptions): Promis
 					processReason: attempt.process.reason,
 					cleanup: attempt.process.cleanup,
 				});
-
+				if (attempt.process.terminationObserved === false) {
+					unsettledProcess = attempt.result.process;
+					terminalOutcome = "failed";
+					break outer;
+				}
 				if (outcome === "completed") {
 					completedShardIds.push(shard.id);
 					terminalOutcome = "completed";
@@ -228,6 +234,13 @@ export async function runAdaptiveAgent(options: RunAdaptiveAgentOptions): Promis
 		attempts,
 		...(lastCheckpoint === undefined ? {} : { checkpoint: lastCheckpoint }),
 	};
+	if (unsettledProcess) {
+		aggregate.exitCode = 1;
+		aggregate.stopReason = "unsettled";
+		aggregate.errorMessage = "Subagent termination unconfirmed (unsettled)";
+		aggregate.process = unsettledProcess;
+		return aggregate;
+	}
 	return aggregate;
 }
 

package/examples/extensions/subagent/graph-result.ts

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+import { emptyUsage, type SingleResult } from "./subagent-runtime-types.ts";
+import type { GraphTask } from "./workflow-graph.ts";
+
+export function failedResult(result: SingleResult): boolean {
+	return (
+		result.process?.terminationObserved === false ||
+		result.exitCode !== 0 ||
+		result.stopReason === "error" ||
+		result.stopReason === "aborted"
+	);
+}
+
+export function laneResult(
+	result: SingleResult,
+): void | { status: "failed" } | { status: "unsettled"; settlement: Promise<void> } {
+	if (result.process?.terminationObserved === false)
+		return { status: "unsettled", settlement: result.process.settlement };
+	if (failedResult(result)) return { status: "failed" };
+}
+
+export function blockedResult(task: GraphTask, reason = "blocked-dependency"): SingleResult {
+	return {
+		nodeId: task.id,
+		agent: task.agent,
+		agentSource: "unknown",
+		task: task.task,
+		exitCode: 1,
+		messages: [],
+		stderr: reason,
+		stopReason: reason,
+		usage: emptyUsage(),
+	};
+}
+
+export function dependencyDigests(
+	task: GraphTask,
+	outputs: ReadonlyMap<string, string>,
+): Readonly<Record<string, string>> {
+	return Object.fromEntries(
+		(task.dependsOn ?? []).map((id) => [
+			id,
+			createHash("sha256")
+				.update(outputs.get(id) ?? "")
+				.digest("hex"),
+		]),
+	);
+}