agent-default

The scheduled autopilot agent named default (config in state/agents/default.json) writes its per-tick eval rows under this skill name. The cron entry */10 * * * * state/bin/agents/tick.sh fires this agent every 10 minutes until max_ticks is reached, then auto-marks it done.

This is not a "dormant ghost." It is the catch-all lane for the autopilot loop. Pod K's audit (2026-04-18) flagged the prior gate as a cheater because it scored every tick 1.0 based on the claude-p subprocess exit code, which ignored whether the agent actually shipped any work. Pods X + Z replaced it with a real outcome gate.

Contract

Per-tick eval row written by state/bin/agents/tick.sh:

{"ts":"...","skill":"agent-default","verb":"tick","score":<0|1>,
 "tick":N,"max_ticks":M,"dur_secs":N,"exit":N,
 "commits":N,"open_before":N,"open_after":N,"open_delta":N,
 "head_before":"sha","head_after":"sha","note":"progress|tick-no-op|tick-failed"}

Eval

Outcome gate (actor: claude -p subprocess; auditor: git rev-list HEAD-delta + state/log/breakage-report.ndjson open-friction-delta, both computed deterministically by tick.sh):

No 0.5 lane. A tick either shipped work or it didn't. The tick-no-op note is the load-bearing signal for the PID loop: a string of tick-no-op rows means the agent has nothing to do - retire it instead of re-firing every 10 minutes. Trend monitor: state/lint/pid-trends.ts.

Pass criteria (unambiguous): score=1 requires the git rev-list --count HEAD delta > 0 OR the breakage-report.ndjson open p0/p1 count dropped between tick start and end. Both are measured by tick.sh using deterministic shell arithmetic - not by LLM self-report.

Fail criteria (unambiguous): score=0 when (a) exit != 0 → note=tick-failed, or (b) exit == 0 but no HEAD advance and no friction drop → note=tick-no-op. Exit 255 always maps to tick-failed.

Shape gate (auditor: this skill page + state/lib/agents.ts):

• Every row MUST have skill="agent-<id>" where <id> matches a file in

state/agents/<id>.json - orphan IDs (no config file) are lint errors.

• The commits, open_delta, and note fields are required. Rows missing

them are pre-Pod-K legacy rows; lint warns on any new row without them.

Failure modes and diagnostics

exit=255 (dispatch timeout / rate-limit / API error). This is the dominant failure pattern (ticks 25-40 of the 2026-04-18 run all hit exit=255). dispatch-tick.ts exits 255 when the underlying dispatch() call fails at the API layer - not a Claude coding error. Diagnose via:

# Most recent per-agent run log:
ls -t ~/robot-rob/logs/claude-cron-agent-default.*.log | head -1 | xargs tail -40

Usual causes: Claude API rate-limit, network drop, or SNAPPY_AGENT_MODEL set to an unrecognized model name. Fix: wait for rate-limit window, check ~/.claude/.env.cache credentials, or clear SNAPPY_AGENT_MODEL.

Directive-complete drift (tick-no-op string after success). When the agent's directive is fully shipped (e.g., at tick 14), subsequent ticks re-verify the same completed work and score tick-no-op. This is expected and correct - the PID loop uses the tick-no-op string to auto-retire the agent. Do NOT re-score these 1; that would mask the retirement signal. The open friction (2026-04-25) about detecting completed work is a prompt-level optimization, not a scoring change.

Self-reported ok:true rows are NOT the score. An agent that writes {"ok":true} to evals.ndjson from within its own context is an actor scoring its own work - the cheater pattern. The score for agent-default ticks comes exclusively from tick.sh (HEAD-delta + open-friction-delta). Any ok:true rows written by the agent's subshell are logged under a different verb (e.g., verb:"regen-brief") and do not override the tick score.

Why "agent-default" specifically

The default agent is the standing autopilot lane that picks up work nobody else claimed: regen-briefs, graduations, tick-tock cleanup. Other named agents (agent-content, agent-sync, etc.) get spawned for specific directives. default is the always-running residual.

If the default agent has been running >5 ticks scoring tick-no-op, kill it with:

python3 -c "
import json
p = 'state/agents/default.json'
d = json.load(open(p))
d['status'] = 'done'
json.dump(d, open(p, 'w'), indent=2)
"

Rubric

criteria:
  - name: eval_row_schema_adherence
    kind: deterministic
    check: "The eval row in state/log/evals.ndjson for 'agent-default' MUST strictly conform to the specified JSON schema for fields: ts, skill, verb, score, tick, max_ticks, dur_secs, exit, commits, open_before, open_after, open_delta, head_before, head_after, and note."
  - name: score_matches_exit_status
    kind: deterministic
    check: "If the 'exit' field in the eval row is not 0, the 'score' field MUST be 0 and the 'note' field MUST be 'tick-failed'."
  - name: score_matches_progress
    kind: deterministic
    check: "If the 'exit' field is 0, the 'score' field MUST be 1 IF 'commits' > 0 OR 'open_delta' > 0, and the 'note' field MUST be 'progress'."
  - name: score_matches_no_op
    kind: deterministic
    check: "If the 'exit' field is 0, the 'score' field MUST be 0 IF 'commits' == 0 AND 'open_delta' <= 0, and the 'note' field MUST be 'tick-no-op'."

agent-default - loader

Per-turn rules. Full reference: state/skills/agent-default/SKILL.md. Do not skip these.

Critical Rules

• NEVER score a tick 1 based solely on claude -p exit code - that was the Pod K cheater pattern. Score is 1 only if commits > 0 OR open_delta > 0.
• ALWAYS include the commits, open_delta, and note fields in any new tick row written under skill="agent-default" - state/bin/agents/tick.sh is the canonical writer; do not bypass it.
• ALWAYS use note tick-no-op (with score=0) for ticks that ran cleanly but shipped nothing - this is the load-bearing signal that the agent should be retired.

Commands

| ui dashboard | state/skills/agent-default/resources/ui.openui | |writer: state/bin/agents/tick.sh (cron: */10 * * * *) |config: state/agents/default.json |eval log: state/log/evals.ndjson (skill: "agent-default") |kill agent: edit state/agents/default.json set status: "done"

OpenUI Resource

• Skill-owned OpenUI Lang resource: state/skills/agent-default/resources/ui.openui. Read it before rendering or editing this skill's generated component surface.
• Treat this resource as a first-class artifact of the skill, not a generic chat response. Improve it when the skill's user-facing output needs to become richer.
• System resources compose OpenUI primitives and inherit SnappyChat tokens. Use ui_contract: branded in SKILL.md only for deliberate platform or client visuals.

Known Pitfalls

• Bare exit-code scoring is a cheater gate (Pod K audit, 2026-04-18). Outcome = commits delta OR open p0/p1 friction delta, not subprocess success.
• The default agent has no special status - it is the standing autopilot lane. Other agents (content, sync, etc.) follow the same gate.
• Don't write rows under skill="agent-default" from anywhere except tick.sh - orphan writers will trip the shape gate.
• No 0.5 lane in the current gate (Pod X version superseded an earlier 0.5 design). A tick either shipped work or it didn't.

Self-Test

1. [ ] Does the new tick row include commits, open_delta, and note fields?
2. [ ] Is the score 0 (with note tick-no-op) when the agent shipped no commits AND closed no frictions?
3. [ ] Is the score 0 (with note tick-failed) when exit code is non-zero?
4. [ ] Is the score 1 (with note progress) when commits > 0 OR open_delta > 0?

Self-report

If this loader fell short, append a line:

echo "[$(date -u +%FT%TZ)] agent-default: <what was missing>" >> state/log/loader-feedback.log

<!-- kernel-ok: historical attribution for the PID-loader pattern. -->

Self-correcting loader (PID feedback)

This is the rule that makes loaders learn. Ported from snappy-kernel, where it demonstrably worked: the snappy-dom-cartographer skill mapped Skool admin UI once, every later ship-agent inherited the full map for free.

Before you finish, do two things:

1. Fix gaps (P - proportional). MANDATORY. If this loader didn't cover your case - if you had to read another file, run an undocumented command, work around a wrong selector, or discover a quirk - you MUST attempt an Edit to this AGENTS.md before you log.

• Default action: edit this file. Surgical. Add the missing line, table

row, or code example where it belongs. No restructuring.

• Only LOGGED is allowed when: the fix needs >10 lines, spans multiple

files, or requires a structural rewrite. In that case the state/regen/drain.sh queue picks it up asynchronously.

• "I didn't have time" / "it's minor" / "the next agent will figure it out"

are NOT valid reasons. Minor gaps compound - that's the whole point of this loop.

• Concrete example of a valid P-fix: discover agent-browser screenshot

takes path positionally not as --output <path>. One line in a table. Edit it in. Do not just log it.

• The goal: the next agent never has to leave the loader.

2. Log the result.

echo "[$(date -u +%FT%TZ)] agent-default: <what was missing or fixed> [FIXED|LOGGED]" >> state/log/loader-feedback.log

• FIXED = you patched this loader inline (P-fix).
• LOGGED = too large for inline; the PostToolUse enqueue + Stop-hook drain

will rewrite the loader from scratch on next session-end.

Do not skip this. Every agent run must leave the system better than it found it. The loader is the setpoint; you are the sensor; the gap is the error signal; closing the gap is the correction.