@tangle-network/agent-runtime 0.279.0 → 0.281.0

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { El as supervisorAgentWithTestBrain, Lc as SuperviseTestOptions, Tn as driverAgent, Zt as RunGraphTestOptions, _l as SupervisorAgentTestDeps, tn as runGraphWithTestBrain, wn as DriverAgentOptions, zc as superviseWithTestBrain } from "./index-Dm8SHDGW.js";
+import { Mc as SuperviseTestOptions, Pc as superviseWithTestBrain, Tn as driverAgent, Zt as RunGraphTestOptions, fl as SupervisorAgentTestDeps, tn as runGraphWithTestBrain, wn as DriverAgentOptions, xl as supervisorAgentWithTestBrain } from "./index-BSSGMvUd.js";
 import { Hn as ToolLoopChat, Vn as ToolLoopCallContext } from "./stream-agent-turn-Bk79CnTw.js";
 import { AgentImprovementProposal, AgentProfile, AgentProfileImprovementMeasuredComparison, SandboxSizePreset } from "@tangle-network/agent-interface";
 //#region src/testing/index.d.ts

package/dist/testing.js

@@ -1,14 +1,14 @@
 import { C as canonicalCandidateDigest$1, D as immutableCandidateValue } from "./workspace-archive-C9lgf77y.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-Bi43xCVa.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-DCTCTmNl.js";
 import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-D3eXNBQV.js";
-import { r as driverAgent } from "./coordination-driver-BBL_OgRw.js";
-import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-DBQdrp7H.js";
-import { i as runGraphWithTestBrain } from "./graph-Ci8Ufs_f.js";
+import { r as driverAgent } from "./coordination-driver-B-HOpGN4.js";
+import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-zt91I62x.js";
+import { i as runGraphWithTestBrain } from "./graph-KjJaTmbO.js";
 import { SANDBOX_SIZE_PRESET_NAMES, canonicalAgentProfileDigest } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:6dc04733d595ac3c5f58b135ae5319f888b44a299d4258e03ba4cf6db9baae7d",
+	digest: "sha256:98bec4725d0c3b80002b8966070c9b0f044f067703e5eb95772ae5cb670a117f",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.279.0"
+			"runtimeVersion": "0.281.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:ea350073ea1a7e79ea850632e202d7f5aaf18be18a6a90d6bd881f7e2e802123",
-			"runId": "agent-runtime-0.279.0-proposal-fixture",
+			"recordDigest": "sha256:01e22b717540452f46d2daa362c2c79b6505d08f38c4666659158da72f56e73f",
+			"runId": "agent-runtime-0.281.0-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4714,13 +4714,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.279.0-proposal-fixture"
+	runId: "agent-runtime-0.281.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:98bd67cacbe52e941c8555c8cd27a0334113769297793c5ea7e5b204a8a15118",
+	digest: "sha256:0c335937dad80024b1c5a8753c686e6ee5ed13fcb7664d3f99bf7ca98b678539",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.279.0"
+			"runtimeVersion": "0.281.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:88a31b3d914904ba0d031345a7195b7dc798412cbc379927bf39e42e91c9fa6a",
+			"recordDigest": "sha256:d8cca1539ebe1c5157c6ac7f7b69f7196f6c1b05b91f9b3a2a22aab98d3c1fba",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/dist/tui/index.d.ts

@@ -1,4 +1,4 @@
-import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-Dm8SHDGW.js";
+import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-BSSGMvUd.js";
 //#region src/tui/top-app.d.ts
 /**
  * The interactive side of the supervisor-run TUI: a keypress/mouse loop over the frames

package/dist/tui/index.js

@@ -1,3 +1,3 @@
-import { t as provisionSupervisor } from "../provision-supervisor-BvnihiyB.js";
+import { t as provisionSupervisor } from "../provision-supervisor-CkN8RRjv.js";
 import { a as renderTopFrameWithLayout, i as renderTopFrame, n as runTopApp, r as loadTopSnapshot, t as renderTopOnce } from "../top-app-VAOrBskv.js";
 export { loadTopSnapshot, provisionSupervisor, renderTopFrame, renderTopFrameWithLayout, renderTopOnce, runTopApp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.279.0",
+  "version": "0.281.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -98,7 +98,7 @@
     "@arethetypeswrong/cli": "0.18.5",
     "@biomejs/biome": "^2.5.11",
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@tangle-network/agent-eval": "0.197.0",
+    "@tangle-network/agent-eval": "0.199.0",
     "@tangle-network/agent-interface": "^2.13.0",
     "@tangle-network/agent-provider-tangle": "1.7.0",
     "@tangle-network/sandbox": ">=0.36.4 <0.48.0",
@@ -122,13 +122,13 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@tangle-network/agent-eval": ">=0.197.0 <0.198.0",
+    "@tangle-network/agent-eval": ">=0.199.0 <0.200.0",
     "@tangle-network/agent-interface": "^2.13.0",
     "@tangle-network/sandbox": ">=0.36.4 <0.48.0 || ^0.49.0-0 || ^0.50.0 || ^0.51.0 || ^0.52.0 || ^0.53.0 || ^0.54.0 || ^0.55.0"
   },
   "dependencies": {
     "@tangle-network/agent-core": ">=0.9.6 <0.10.0",
-    "@tangle-network/agent-knowledge": "^17.1.8",
+    "@tangle-network/agent-knowledge": "^17.1.10",
     "@tangle-network/agent-profile-materialize": ">=0.20.1 <0.21.0",
     "@tangle-network/agent-trace-contract": "^1.2.0",
     "tar-stream": "3.2.1"

package/skills/profile-authoring/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: profile-authoring
+description: Author an AgentProfile from its audience's acceptance test, a probed proxy gap, and a control.
+---
+
+# Profile authoring
+
+Use this before a run that matters, and before you author an agent that another agent spawns.
+A profile is right when its result survives the people the result is for.
+Do not constrain agents with prohibitions.
+Change what is rewarded and who is in the room, so the honest path is the path that pays.
+
+Every open problem has three parts.
+The audience accepts or rejects the result: a paper's authors and referees, a repository's maintainers, a paying customer, or a domain expert.
+The proxy is the check you can run during the work: an exact checker, a test suite, a rater, or a demo.
+The gap is everything the proxy accepts and the audience rejects.
+Hacks live in the gap, and a stronger model does not close it.
+Measured: where a known gap existed, 15 of 27 lanes with claims filed false "new" results; where none was known, 0 of 34 lanes did.
+
+## 1. Name the audience and its acceptance test
+
+Name the audience and the decision the result supports.
+Quote the acceptance test from its source, word for word, with its location.
+Include standing assumptions, exclusions and nondegeneracy conditions; a transcription drops them.
+List the outcome classes the audience distinguishes: new, known, partial, conditional, documented null, invalid, unassessed.
+Never reduce them to solved and unsolved.
+Make a literature search part of acceptance, and record an answer already published as known.
+
+## 2. Probe the proxy's gap before launch
+
+Try to make the proxy accept something the audience rejects.
+Plant canaries: the source's trivial and excluded cases, a published answer, a degenerate artifact, an impossible variant, a stale comparator.
+The proxy must refuse each canary or class it as known.
+Record the probe, its inputs and its verdicts with the registration.
+If a canary passes, fix the proxy or narrow the claim; do not launch into a known gap.
+Use exact or interval arithmetic, and count only what is proven.
+An LLM judge becomes a gate only after it beats an always-reject baseline on cases a human graded.
+
+## 3. Keep acceptance out of the reward loop
+
+Give agents a development check they can run; hiding every check also blocks honest work.
+Hold back the acceptance check.
+It is a stricter superset, run from the delivered packet in a fresh environment, by a party outside the authoring lineage.
+Grade only outputs that the rerun reproduces.
+A parent that promotes children on proxy passes alone selects for the gap; have the referee attack a result before anyone builds on it.
+Keep the headline gate fixed for the whole task; report a stricter bar as a second line.
+
+## 4. Choose roles and a model for each
+
+Proposers: cheap, high-throughput models where an exact checker exists, with an occasional strong model.
+Referee: a skeptic from another model family, holding the artifact itself and its own instrument.
+An instrument is exact recomputation, execution, a literature search, or an attempt to build a counter-case.
+A change of family alone is weak, because models share many errors.
+A referee can reject a claim; only the held-back check accepts one.
+Monitor: reads the journal and live notes during the run, flags drift or proxy gaming, and steers or reports; it never scores.
+Choose each model from measured cost and quality on this kind of work, and state its dollars.
+Admit the referee's model in `allowedModels`; Runtime refuses a model outside that list at spawn.
+Hand every role the files it judges by path, never a summary.
+
+## 5. Define success, the honest null, and the stop
+
+Success is an accepted result or a documented null.
+A documented null states what was tried, the obstruction found, the cases covered and the cases left open.
+Credit it like a positive result; without a search record it is not a null.
+Tell agents the checker may be wrong, and credit a well-evidenced report of a checker defect.
+Measured elsewhere: a credited exit cut one model's test cheating from 54% to 9%, while prohibitions barely moved another's.
+
+A Runtime manager with a check is not served `stop`.
+It ends when the check accepts its `submit_result`, when `report_blocked` shows that a granted tool failed, or at a bound.
+The bounds are the continuation `deadline`, `maxBarren` turns without progress, the budget, and cancellation.
+So the in-run check must accept a well-formed documented null as its own class.
+Otherwise the only exits are a claim the proxy passes, or a bound.
+State the continuation block in the record, and put the honest exit in its `rules` text.
+The check or a bound ends the run; an agent's claim that it is done does not.
+
+## 6. Carry known traps
+
+Hand agents the domain's known traps as rules, not stories.
+Examples: excluded or trivial cases, stale or wrong-field comparators, published answers, tests versus users, a demo versus a customer, a rater versus an expert.
+Keep infrastructure incidents out of the brief; the operator owns the stack.
+Measured: a director told of an infrastructure failure spent 2 of its first 4 children probing it.
+Record each new trap where the next author reads it, in the same change as its fix.
+
+## 7. Set budget and caps
+
+Hard limits live in Runtime options and per-assignment budgets: `budget`, `workerSlots`, `maxDepth`, `allowedModels`, `continuation`.
+Prompt text enforces no limit.
+`maxTokens` is settled after the work: an overspent child keeps its output and carries a `budgetViolation`.
+A child's total counts input tokens on every turn, so reserve turns times context.
+Give each paid job its own named key with a dollar cap, and state the dollars before launch.
+
+## 8. Register arms, a control and outcomes
+
+Before launch, register the claim, the arms, the outcome measures, the useful-effect threshold, and the result that would refute the claim.
+Run each ingredient you want to credit against a control without it: the referee, the credited exit, live notes, the wording.
+Measured elsewhere: prompt wording alone moved one model's cheating from over 85% to 1%.
+Count precision after review, not claim volume.
+Report reviewed-claim precision, canary pass rate, how many proxy passes the audience accepts, and the cost per accepted result.
+
+## 9. Record what makes a hack visible
+
+Record the authored profile, the task and the materialization receipt, with each mounted file's sha256.
+Record every proxy verdict, the held-back verdict, and the referee's instrument and attempts.
+Record each claim with its artifact, the quoted statement it answers and its outcome class.
+Keep dated live notes that separate observation from inference and name the next check.
+Live notes coordinate the team and support an audit; they never certify honesty, so never score them.
+Keep unknown cost, output and state unknown; never record them as zero or success.
+
+## Write the profile
+
+Before a new or changed profile, name the observed reason and the result that would reverse the choice.
+Before you retry a null or failed child, inspect its recorded artifacts; finished work may be usable.
+A profile with no Runtime coordination tool is a leaf; any coordination tool makes it a managed node.
+Only `agent_runtime_coordination_spawn_worker: true` grants recursion; names, metadata and role labels grant nothing.
+Grant `submit_result` only when Runtime gives that node an independent check; otherwise its settlement stays unassessed.
+Grant only the observation, steering and journal tools that the assignment needs.
+Set `harness`, `model.default` and `model.provider` explicitly, and validate against the current `agentProfileSchema`.
+A tool name must be one the harness publishes, and a refused name fails the same way on retry.
+`ls`, `list` and `find` are not tool names; select paths with a glob tool and search contents with a grep tool.
+An unattended run denies any permission the profile does not grant; keep file access inside the workspace or grant it.
+A stop or cancel is a request that a live acknowledger applies; plan the out-of-band path for a wedged parent.
+Compare Runtime's materialization receipt with what you authored before a large run.
+
+Hand a file by path in `resources.files`, and compare the returned sha256 with your source:
+
+```json
+{"path":"input.txt","resource":{"kind":"inline","name":"input","path":"inputs/input.txt"}}
+```
+
+The outer `path` is the child's mount; the nested `resource.path` is a UTF-8 source file in your workspace, under 4 MiB.
+Every profile that can spawn carries this complete skill as an immutable inline `resources.skills` entry, with `resources.failOnError: true`.
+Copy the mounted bytes; never retype them.
+
+## Checklist
+
+Fill this in and store it with the registration before launch.
+
+```text
+Audience and decision:
+Acceptance test, quoted, with location and exclusions:
+Outcome classes:
+Proxy (in-run check) and who sees it:
+Gap probe: canaries, verdicts, date:
+Held-back acceptance: who runs it, where, from what:
+Proposers: models, dollars:
+Referee: family, instrument, dollars:
+Monitor: model, what it may steer:
+Documented null: required fields:
+Credited exit, in the agents' words:
+Stop: check, report_blocked, deadline, maxBarren, budget:
+Known traps handed to agents:
+Budget, caps, key and its dollar cap:
+Arms, control, measures, threshold, refuting result:
+Records that expose a hack:
+```
+
+## Worked examples
+
+### Counterexample hunt, before and after
+
+Before, on a 36-lane hunt over 12 conjectures in 2026-09:
+The brief transcribed Wang and Zheng's Conjecture 13 (arXiv:2104.12942) as "c != 1".
+The checker refused only c = 1, and its admission decoys came from that transcription.
+Workers held the same checker that scored claims, and it counted any verified claim as new.
+All 3 lanes on that conjecture filed 39 "verified-new" claims, every one at c = 0.
+The paper assumes c != 0 throughout; at c = 0 the question is only whether x^d permutes the field.
+One claim page said "the checker refuses only c = 1".
+The real yield was 0.
+
+After:
+Audience: the paper's authors and its referees.
+Acceptance: Conjecture 13 quoted with the standing assumption that c is not 0 or 1, plus a literature sweep.
+Gap probe: before launch, the checker refuses c = 0 and classes a Corollary 11 family member as known.
+Agents run the development checker; the operator reruns a held-back checker and the sweep on each packet.
+A referee from another family recomputes each claim with its own code.
+A documented null over m <= 20 is a credited outcome.
+Arms: with and without the referee.
+
+### Coding task scored by tests
+
+Audience: the task's author, and a maintainer who decides whether to merge.
+Proxy: the visible tests.
+Gap: a change that passes the tests and that a maintainer rejects, such as a special-cased input, an edited test or a skipped check.
+Measured: in an 8-lane Terminal-Bench batch, Runtime marked 6 lanes as winners and the task's verifier passed 1 of them.
+Measured elsewhere: 0 of 15 reviewed agent pull requests were mergeable as-is, including 4 that passed the tests.
+Profile: agents run the visible tests.
+The held-back verifier and hidden tests run on the patch in a fresh container.
+Hash the test files; a changed test fails acceptance.
+A referee from another family reads the diff for special cases.
+A report that the task cannot pass without breaking its specification is a credited outcome.
+
+### Product for a customer
+
+Audience: the customer who pays, and the decision the product supports.
+Acceptance: the customer's own evaluation criteria, quoted, and a walkthrough of the running product doing the customer's task.
+Proxy: an LLM fulfilment rater and a compliance checklist.
+Gap, measured across product lanes: the rater accepted 19 of 31 failed lanes and scored 0.45 where always-reject scored 0.73.
+In one wave, 19 of 44 reviewers never received the product.
+A grader gave B where the owner gave F.
+Profile: reviewers mount the product by path and must run it.
+A referee from another family walks the customer's task on the running product.
+The rater stays a ruler, not a gate, until it beats always-reject.
+Acceptance is the owner's or the customer's walkthrough.
+"Not ready, and this is what is missing" is a credited outcome.
+
+## Then consider
+
+- `supervise` to drive the tree once its profiles exist.
+- `calibrate-before-measure` when a judge or checker has no calibration yet.
+- `arena-experiment` when the claim compares arms.

package/skills/supervise/SKILL.md

@@ -18,10 +18,10 @@ Per-assignment budgets, continuity, and keys belong to the [coordination tools](
 An agent receives recursive authority by declaring `agent_runtime_coordination_spawn_worker: true` in its tools.
 Declare each other Runtime tool it needs explicitly.
 Metadata describes work; it does not grant authority.
-Every profile that can spawn workers carries the complete `profile-authoring/SKILL.md` resource, using an immutable snapshot and `resources.failOnError: true`.
+Every profile that can spawn workers carries the complete `profile-authoring/SKILL.md` skill shipped beside this one, as an immutable inline snapshot with `resources.failOnError: true`.
 The authored profile must explain its own ability to delegate; Runtime does not invent that policy.
 
-When creating or changing a descendant profile, read [profile authoring](references/profile-authoring.md) for the exact contract and resource placement.
+Before creating or changing any profile, follow [profile authoring](../profile-authoring/SKILL.md): the audience and its acceptance test, the probed proxy gap, the referee, the honest null, and the profile contract.
 The task names the concrete artifact and completion check; the profile names the method and granted capabilities.
 
 ## Direct the work