Omar SobhandClaude Opus 5
769e002bb3
Three phases of the approved plan, plus a correction to what the last one
claimed.
CORRECTION: skills reached ONE tier, not all of them
The previous commit said "skills can now reach a mission agent". That was
true only for the container/ZeroClaw tier — the fall-through that queues a
topology_runs row for topology_worker, which drives the executor that was
patched. compose_turn_prompt/pinned_skills_text had exactly one production
caller, and phase_runner's three other paths (composed microVM, solo
microVM, direct session) never called it. CAPABILITY-REVIEW.md said the
broad thing too; both are corrected.
Those three tiers share one task string and have no per-turn alias, so
their skills resolve per PHASE from the mission's crew and are appended
there. The container tier deliberately still injects per turn, with the
running node's own role — appending in both places would put every crew
member's skills in every turn twice.
The behavioural tests prove phase_skills_text and compose_turn_prompt work.
They cannot prove the three launch_* calls pass the composed string, and
that substitution is a one-word edit that would silently return all three
tiers to delivering nothing with every test still green. So there is also a
source-level assertion on the call sites, following the precedent in
mission_events::the_cap_is_enforced_in_one_statement. Its negative control
names the exact tier.
PROVENANCE: what an agent received, and what it said it did
Both were unanswerable. The prompt was never stored anywhere on any tier —
re-deriving it later re-runs the skill lookup against a catalogue that has
since changed, and once agents author their own skills it certainly will
have. The reasoning rows were durably write-only: pushed live once, then
never read from the database again by anything except the GC that deletes
them.
- prompt.composed records the exact bytes, on all four tiers
- the session tier writes its checkpoint record and a reasoning row,
instead of eprintln! and nothing — the same defect the solo microVM
path was fixed for, in the last tier that still had it
- narrative_for_mission reads both back
Found while doing it: the 400-event per-phase cap counted EVERY kind, so a
busy phase could push out its own phase.completed and its own provenance.
The cap now counts only the two unbounded kinds it was written for.
Negative control confirms the old behaviour dropped the prompt.
Retention is now a per-mission hold (0080) rather than a raised global —
with a test asserting unheld missions are still reaped, because an
exemption that applies to everything is not an exemption.
SELF-AUTHORING: agents apply their own skill drafts, no human click
By operator decision. level_up has generated complete drafts from a model
since it shipped; only a checkbox stood between propose and apply.
What replaces the gate is not another gate but four properties, each held
by a test:
- workspace-scoped, so a hand-authored skill can never be modified
- a draft cannot take a hand-authored skill's name. Ids are scoped and
bindings resolve by skill_id, so it could not overwrite or shadow one
anyway — but two procedures under one name means nobody reading a
transcript can tell which the agent followed, and that ambiguity is
fatal in a system where the skill is the standard being graded against
- every revision appends a skill_versions row, so it can be reverted and
a past run can be read against the text it was actually judged under
- approved_by = NULL. An agent's decision is never attributed to a person
who did not make it
Only skill_candidate applies autonomously. identity_refinement and
brain_consolidation still wait for a human: they change what an agent IS
rather than adding a procedure it can consult. State is announced at boot,
because a safety gate that changes silently is one nobody notices changed.
CLAWMATES_SKILL_SELF_AUTHORING=0 restores it.
Also: the test Postgres ran out of /dev/shm mid-suite (Docker's 64MB
default) and surfaced it during MIGRATIONS, which reads like a schema fault
and is not one. --shm-size=1g, and a pointer to the `clean` subcommand that
already existed for the 779 leaked test databases.
Full workspace suite green: 106 binaries, no failures.
Co-Authored-By: Claude Opus 5 <[email protected]>
94 lines
3.6 KiB
Rust
94 lines
3.6 KiB
Rust
//! Applies agents' own skill drafts, with no human decision.
|
|
//!
|
|
//! `level_up` has generated complete skill drafts from a model since it
|
|
//! shipped; the only thing between a draft and the catalogue was an operator
|
|
//! ticking a checkbox in `LevelUpDrawer`. This worker removes the checkbox, by
|
|
//! operator decision.
|
|
//!
|
|
//! What is deliberately NOT removed is the record. Every write stays
|
|
//! workspace-scoped and versioned, cannot take the name of a hand-authored
|
|
//! skill, and lands with `approved_by = NULL` — so "an agent decided this" is
|
|
//! distinguishable from "a person decided this" forever after, which is the
|
|
//! property that makes the change reversible instead of merely fast.
|
|
//!
|
|
//! Only `skill_candidate` items apply here. `identity_refinement` and
|
|
//! `brain_consolidation` still wait for a human: they change what an agent IS
|
|
//! rather than adding a procedure it can consult.
|
|
|
|
use sqlx::{PgPool, Row};
|
|
use std::time::Duration;
|
|
|
|
/// How often to sweep for pending drafts.
|
|
///
|
|
/// Proposals arrive when someone runs a level-up, not continuously, so this is
|
|
/// slow on purpose — the work is bounded by how often an agent reflects, and
|
|
/// polling faster would only add load.
|
|
const SWEEP_INTERVAL: Duration = Duration::from_secs(120);
|
|
|
|
/// Start the sweep, unless self-authoring is switched off.
|
|
pub fn spawn(pool: PgPool) {
|
|
if !crate::level_up::self_authoring_enabled() {
|
|
eprintln!(
|
|
"skill_self_authoring: DISABLED (CLAWMATES_SKILL_SELF_AUTHORING) — \
|
|
agent skill drafts wait for a human in the level-up drawer"
|
|
);
|
|
return;
|
|
}
|
|
eprintln!(
|
|
"skill_self_authoring: ENABLED — agents apply their own skill drafts \
|
|
without human approval. Writes are workspace-scoped, versioned, and \
|
|
cannot take a hand-authored skill's name; each lands with no approver \
|
|
recorded. Set CLAWMATES_SKILL_SELF_AUTHORING=0 to restore the gate."
|
|
);
|
|
tokio::spawn(async move {
|
|
loop {
|
|
if let Err(e) = sweep(&pool).await {
|
|
eprintln!("skill_self_authoring: sweep failed: {e}");
|
|
}
|
|
tokio::time::sleep(SWEEP_INTERVAL).await;
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Apply every pending proposal's skill candidates. Returns how many skills landed.
|
|
pub async fn sweep(pool: &PgPool) -> Result<usize, String> {
|
|
// Bounded per pass: a backlog drains over several sweeps rather than
|
|
// holding the pool for as long as it takes to apply all of it.
|
|
let rows = sqlx::query(
|
|
"SELECT id, workspace_id FROM level_up_proposals
|
|
WHERE status = 'pending'
|
|
ORDER BY created_at
|
|
LIMIT 20",
|
|
)
|
|
.fetch_all(pool)
|
|
.await
|
|
.map_err(|e| format!("select pending proposals: {e}"))?;
|
|
|
|
let mut applied = 0usize;
|
|
for row in &rows {
|
|
let id: uuid::Uuid = row.get("id");
|
|
let workspace_id: uuid::Uuid = row.get("workspace_id");
|
|
match crate::level_up::apply_autonomous(
|
|
pool,
|
|
cm_domain::WorkspaceId::from(workspace_id),
|
|
id,
|
|
)
|
|
.await
|
|
{
|
|
Ok(items) if !items.is_empty() => {
|
|
applied += items.len();
|
|
eprintln!(
|
|
"skill_self_authoring: applied {} skill draft(s) from proposal {id} \
|
|
with no human approval",
|
|
items.len()
|
|
);
|
|
}
|
|
// A proposal with no skill candidates is left pending on purpose —
|
|
// its identity/memory items still belong to the human gate.
|
|
Ok(_) => {}
|
|
Err(e) => eprintln!("skill_self_authoring: proposal {id}: {e}"),
|
|
}
|
|
}
|
|
Ok(applied)
|
|
}
|