Merge current TinyAgents owner changes

AGENTS.md

@@ -12,6 +12,9 @@ capability catalog), `crates/tinyagents-session/` (durable session data),
 task stores and orchestration controls), and
 `crates/tinyagents-orchestration/` (direct and durable subagent invocation,
 tools, sessions, lifecycle logic, and focused tests).
+`crates/tinyagents-harness-tools/` owns reusable harness tool implementations
+and their stateful support: goals, todos, skills, time, clarification, plan
+exit, per-call binding, thread locks, and feature-gated subagent tool shells.
 `crates/tinyagents-integration-tests/` owns cross-crate tests and examples.
 The workspace also has `crates/tinyagents-runtime/`, `crates/tinyagents-definition/`
 and `crates/tinyagents-live/`.
@@ -24,8 +27,9 @@ dedicated `types.rs` file and keep module-local unit tests in a sibling
 smallest useful API.
 
 Cargo features are package-local. `tinyagents-harness` exposes `sqlite`,
-`builtin-tools` (`tools` is a deprecated alias), `multimodal`, `png-optimize`,
-`media`, `claude-code`, `langfuse`, `storage-drivers`, and `tracing`; `tinyagents-graph`
+`multimodal`, `png-optimize`, `media`, `claude-code`, `langfuse`,
+`storage-drivers`, and `tracing`; `tinyagents-harness-tools` exposes default
+`todos`, `goals`, and `skills`, plus opt-in `subagents`; `tinyagents-graph`
 exposes `sqlite`, `storage-drivers`, and `tracing`; session exposes
 `storage-drivers` and `tracing`; registry exposes `tracing`. The
 `storage-drivers` features put each store on `tinystoragedrivers` ports. The harness's own

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## Unreleased: settled completions drop their result (tinyagents#354)
+
+`CompletionRouter` now empties a record's `result` when the record settles:
+`mark_delivered`, `tombstone` and `cancel_parent` store the record with its
+id, parent key, status, state, attempts and timestamps but no text, artifact
+reference or omitted-character count, so a delivered child's output or a
+deleted parent's withdrawn completions do not sit in the store until
+`compact(retain)`. `mark_failed` still returns the full record to the host's
+give-up writer and stores the emptied one. Dedupe, tombstones and reopen
+behaviour are unchanged.
+
 ## Unreleased: dedicated hooks crate (tinyagents#470)
 
 **Breaking.** Stop-hook and lifecycle-hook APIs now live in
@@ -82,7 +93,6 @@ Fixes (the two deferred tinyagents#463 findings):
 The Release workflow derives the next version from the highest of the
 workspace version and the latest `v*` tag instead of the (stale) workspace
 version alone, so it no longer proposes a tag that already exists.
-
 ## Unreleased: locator-based transcript reads and writes (tinyagents#453)
 
 Hosts can now do through a `TranscriptLocator` everything they used the

Cargo.toml

@@ -2,6 +2,7 @@
 members = ["crates/*"]
 default-members = [
     "crates/tinyagents-harness",
+    "crates/tinyagents-harness-tools",
     "crates/tinyagents-graph",
     "crates/tinyagents-tasks",
     "crates/tinyagents-registry",

README.md

@@ -29,9 +29,13 @@ TinyAgents is a Cargo workspace, not one crate. Depend on the pieces you need:
   middleware, structured output, streaming, usage/cost accounting, retries,
   caching, and a Claude Code CLI model adapter with stream-json,
   session, authentication, and MCP endpoint support. Features: `sqlite`,
-  `storage-drivers`, `builtin-tools` (`tools` is a deprecated alias),
-  `multimodal`, `png-optimize` (opt-in PNG re-compression), `media`,
+  `storage-drivers`, `multimodal`, `png-optimize` (opt-in PNG re-compression), `media`,
   `claude-code` and `langfuse` (both default), `tracing` (forwards to `tinytools-agent/tracing` for its parsing diagnostics; the harness's own instrumentation is always compiled in).
+- **`tinyagents-harness-tools`** — reusable implementations for the harness:
+  goals and budgets, per-thread todos, skill tool packs, subagent control
+  tools, time and clarification tools, plan exit, per-call binding, and
+  per-thread locks. Features: `todos`, `goals`, `skills` (all default), and
+  `subagents` (opt-in). See the [crate guide](crates/tinyagents-harness-tools/README.md).
 - **`tinyagents-graph`** — a LangGraph-style durable, typed state graph:
   `START`/`END`, nodes, conditional edges, `Send` fanout, reducers/channels,
   checkpoints, interrupts, subgraphs, and time travel. Features: `sqlite`,
@@ -164,15 +168,22 @@ for exercising the loop without a live provider. Memory, workspace lifecycle,
 authorization, and persistence policy stay in the host and can wrap a complete
 run with `AgentMiddleware`.
 
+Tool packs keep read-only disclosure available in mixed-permission sessions
+while gating each bound invocation on its actual arguments. The harness also
+exposes [executor-entry observation](docs/modules/harness/middleware-tool-wrap.md#actual-execution-observation)
+for finish checks and host bookkeeping: it reports the bound target without
+changing the outer transcript or treating a preview as a write.
+
 ## Subagent orchestration
 
-`tinyagents-orchestration` owns child-agent composition. `SubAgentTool` is a
-typed parent-context dispatcher: its default `background` mode starts a child
-in the background and returns a stable job id immediately, while `inline` mode
-waits for and returns the child's final result in the same call. `SubAgentJobsTool` queries job
-status/results and `SubAgentMessageTool` sends messages to a live job;
-hosts register these control tools over the same explicitly shared
-`SubAgentJobRegistry`. `SubAgentSession` covers retained post-completion
+`tinyagents-orchestration` owns child-agent composition and the shared
+`SubAgentJobRegistry`. The `subagents` feature in `tinyagents-harness-tools`
+exposes `tinyagents_harness_tools::subagents`, which provides
+`DriverSubAgentTool`, the host-planned typed dispatcher: its `background` mode
+starts a child and returns a stable job id, while `inline` mode waits for the
+final result. That module also provides the `SubAgentJobsTool` and
+`SubAgentMessageTool` declarations over the shared registry. `SubAgentSession`
+covers retained post-completion
 conversations, while `SubagentDriver` coordinates durable lifecycle
 preparation, execution, pause, resume, and persistence. Teams and workflow DAGs
 are intentionally outside this focused crate.

crates/tinyagents-definition/Cargo.toml

@@ -16,7 +16,7 @@ toml = "0.8"
 anyhow.workspace = true
 tracing.workspace = true
 # `AgentDefinition::tool_rules` carries the shared tool-rule vocabulary.
-tinytools = { path = "../../vendor/tinytools/crates/tinytools", version = "0.5.0" }
+tinytools = { path = "../../vendor/tinytools/crates/tinytools", version = "0.6.0" }
 
 [dev-dependencies]
 tempfile = "3"

crates/tinyagents-graph/Cargo.toml

@@ -9,7 +9,6 @@ rust-version.workspace = true
 description = "Durable typed state graphs for TinyAgents."
 
 [dependencies]
-anyhow = { workspace = true }
 async-trait = { workspace = true }
 futures = { workspace = true }
 serde = { workspace = true }
@@ -18,8 +17,8 @@ tinyagents-tasks = { path = "../tinyagents-tasks", version = "2.2.0", default-fe
 tinyagents-harness = { path = "../tinyagents-harness", version = "2.2.0", default-features = false, features = [
     "langfuse",
 ] }
-tinyinference-llm = { path = "../../vendor/tinyinference/crates/tinyinference-llm", version = "0.4.1" }
-tinytools = { path = "../../vendor/tinytools/crates/tinytools", version = "0.5.0" }
+tinyinference-llm = { path = "../../vendor/tinyinference/crates/tinyinference-llm", version = "0.5.0" }
+tinytools = { path = "../../vendor/tinytools/crates/tinytools", version = "0.6.0" }
 tokio = { workspace = true, features = ["sync", "time", "macros", "rt", "rt-multi-thread", "fs"] }
 tracing = { workspace = true }
 # Storage ports (no database client) for `DriverCheckpointer`.

crates/tinyagents-graph/src/README.md

@@ -25,7 +25,7 @@ carry their own `README.md` — see the module map below.
 | `export` | Graph introspection/visualization: topology extraction, Mermaid/JSON export, validation reports. |
 | `goals` | A durable per-thread goal (single "completion contract"), continuation loop, and harness tools. See [`goals/README.md`](goals/README.md). |
 | `observability` | Durable graph observability: journals, status stores, the journaling sink, latency/health rollups, Langfuse export. See [`observability/README.md`](observability/README.md). |
-| `orchestration` | Managed child-work controls (`spawn`/`await`/`cancel`/... ) exposed as harness tools, backed by a `TaskStore`. Now lives in `tinyagents-tasks` ([README](../../tinyagents-tasks/src/README.md)); this module only re-exports it for compatibility. |
+| `orchestration` | Detached-task runtime types backed by a `TaskStore`. The runtime lives in `tinyagents-tasks` ([README](../../tinyagents-tasks/src/README.md)); this module re-exports its current public surface for compatibility. Model-facing orchestration tool adapters were removed. |
 | `parallel` | `map_reduce` — ordered, bounded-concurrency parallel map/reduce with a configurable failure policy, independent of the graph executor. |
 | `recursion` | Recursion policy and depth tracking: `RecursionFrame`/`RecursionPolicy`/`RecursionStack`/`RunTree` bound and observe nested graph/subgraph/sub-agent recursion. See [`recursion/README.md`](recursion/README.md). |
 | `reducer` | `StateReducer`/`Reducer` implementations (overwrite, append, min/max, set-union, closures) that fold branch updates into committed state at a superstep boundary. See [`reducer/README.md`](reducer/README.md). |

crates/tinyagents-graph/src/compiled/executor.rs

@@ -15,7 +15,7 @@ use super::*;
 use crate::compiled::boundary::StepBoundary;
 use crate::compiled::run_ctx::{ResumeSeed, RunCtx};
 use crate::compiled::step::StepRunner;
-use crate::thread_locks::ThreadLockMap;
+use crate::execution_locks::RunLockMap;
 use std::sync::OnceLock;
 
 /// Default TTL for the durable execution lease claimed in [`CompiledGraph::execute`]
@@ -32,9 +32,9 @@ const THREAD_LEASE_TTL: Duration = Duration::from_secs(300);
 /// the gap the review's C3 finding describes (`executor.rs` took no lock of
 /// its own). Keyed on `thread_id` *and* namespace so a parent run and a
 /// subgraph run sharing a thread id never contend on each other's lock.
-fn execution_lock_map() -> &'static ThreadLockMap {
-    static LOCKS: OnceLock<ThreadLockMap> = OnceLock::new();
-    LOCKS.get_or_init(|| ThreadLockMap::new("graph executor per-thread run lock"))
+fn execution_lock_map() -> &'static RunLockMap {
+    static LOCKS: OnceLock<RunLockMap> = OnceLock::new();
+    LOCKS.get_or_init(RunLockMap::default)
 }
 
 /// Builds the in-process lock map key for `thread_id` scoped to `namespace`.

crates/tinyagents-graph/src/delegation/run.rs

@@ -13,7 +13,7 @@ use super::types::{
     DelegationStageOutput, DelegationState, DelegationUpdate, PendingApproval,
 };
 use crate::checkpoint::{Checkpoint, Checkpointer};
-use crate::thread_locks::ThreadLockMap;
+use crate::execution_locks::RunLockMap;
 use crate::{Command, END};
 
 /// Serializes [`run_or_resume_delegation`]'s classify-then-dispatch critical
@@ -22,10 +22,8 @@ use crate::{Command, END};
 /// — a weak-value map so an idle thread's mutex is reclaimed instead of
 /// leaking for the life of the process.
 fn thread_lock(thread_id: &str) -> Arc<Mutex<()>> {
-    static LOCKS: OnceLock<ThreadLockMap> = OnceLock::new();
-    LOCKS
-        .get_or_init(|| ThreadLockMap::new("delegation run/resume lock map"))
-        .lock_for(thread_id)
+    static LOCKS: OnceLock<RunLockMap> = OnceLock::new();
+    LOCKS.get_or_init(RunLockMap::default).lock_for(thread_id)
 }
 
 /// Run the plan→execute⇄review→finalize delegation graph, invoking `run_stage`

crates/tinyagents-graph/src/execution_locks.rs

@@ -0,0 +1,33 @@
+//! Private per-thread lock state for the graph's executor and delegation runner.
+//!
+//! Reusable lock maps live in `tinyagents-harness-tools`; these two graph
+//! entry points retain only the private serialization state they need until
+//! the graph runtime is retired.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex as StdMutex, Weak};
+
+use tokio::sync::Mutex;
+
+#[derive(Default)]
+pub(super) struct RunLockMap {
+    locks: StdMutex<HashMap<String, Weak<Mutex<()>>>>,
+}
+
+impl RunLockMap {
+    pub(super) fn lock_for(&self, key: &str) -> Arc<Mutex<()>> {
+        let mut locks = self
+            .locks
+            .lock()
+            .unwrap_or_else(|_| panic!("graph run lock map poisoned"));
+        if let Some(lock) = locks.get(key).and_then(Weak::upgrade) {
+            return lock;
+        }
+        let lock = Arc::new(Mutex::new(()));
+        locks.insert(key.to_owned(), Arc::downgrade(&lock));
+        if locks.len() >= 16 {
+            locks.retain(|_, weak| weak.strong_count() > 0);
+        }
+        lock
+    }
+}