instar 1.3.452 → 1.3.454

package/.claude/skills/autonomous/SKILL.md

@@ -16,8 +16,15 @@ Before activating the stop hook, you MUST:
 
 1. **Analyze the goal** and break it into specific, verifiable tasks
 2. **Present the task list** to the user with clear completion criteria
-3. **Wait for user confirmation** before activating the hook
-4. **Define the completion promise** — a phrase that is only TRUE when ALL tasks are done
+3. **Propose a measurable `completion_condition`** synthesized from those tasks — an
+   artifact-grounded end-state an INDEPENDENT judge can verify from what you SURFACE
+   (a commit SHA, a file's content, a CI run id, a test-count delta). This is the
+   PRIMARY completion mechanism. Only fall back to a self-declared promise when no
+   verifiable condition can be expressed — and then record `completion_mode:
+   promise-fallback` + a one-line `promise_fallback_reason:`.
+4. **Wait for user confirmation** before activating the hook
+5. **Define the completion promise** — retained as the fallback token (only TRUE when
+   ALL tasks are done)
 
 **Example interaction:**
 
@@ -90,6 +97,10 @@ collide on). If you somehow have no `report_topic`, fall back to `.instar/autono
 
 Write this content:
 
+<!-- COMPLETION_CONDITION_DEFAULT — the Write-tool template defaults to a verifiable
+     completion_condition (judged by an INDEPENDENT model), NOT the self-declared
+     promise. The promise is the recorded fallback. Spec: AUTONOMOUS-COMPLETION-DISCIPLINE.md -->
+
 ```markdown
 ---
 active: true
@@ -104,7 +115,11 @@ report_topic: "TOPIC_ID"
 report_interval: "30m"
 last_report_at: ""
 level_up: true
-completion_promise: "ALL_TASKS_COMPLETE"
+completion_condition: "<measurable, artifact-grounded end-state synthesized from the task list>"
+completion_mode: condition         # "condition" (default) | "promise-fallback"
+promise_fallback_reason: ""         # one line, REQUIRED iff completion_mode == promise-fallback
+completion_promise: "ALL_TASKS_COMPLETE"   # retained as the fallback token
+hard_blocker_nonce: "{a random per-run token — get via: openssl rand -hex 8}"
 ---
 
 # Autonomous Session
@@ -119,6 +134,27 @@ completion_promise: "ALL_TASKS_COMPLETE"
 {autonomous instructions}
 ```
 
+**`completion_condition` is the PRIMARY field — the default path.** It is judged each
+turn by an INDEPENDENT model against what you SURFACE in your output (it cannot grade
+its own homework, and it is fail-safe — evaluator-unreachable ⇒ keep working, never a
+false "done"). Synthesize it from the task list, and prefer an **artifact-grounded**
+end-state the judge can verify from the surfaced transcript — a commit SHA you show, a
+file whose content you show, a CI run id, a concrete test-count delta — over an
+unverifiable prose claim like "tests pass". `duration_seconds` is REQUIRED (a bounded
+run; the duration is the hard backstop) — never set a truly-unbounded run.
+
+**The self-declared promise is the RECORDED fallback, not the default.** Only fall back
+to it when a verifiable condition genuinely cannot be expressed (rare — a purely
+exploratory run with no testable end-state). When you do, set
+`completion_mode: promise-fallback` and a one-line `promise_fallback_reason:` — so
+"I chose the rationalizable path" is a logged, operator-visible fact, not an invisible
+default.
+
+**`hard_blocker_nonce` authenticates an honest `(a)` exit.** Write a fresh random token
+(`openssl rand -hex 8`). The stop hook accepts a `<hard-blocker nonce="...">` terminal
+marker ONLY when its nonce matches this — so incidental `<hard-blocker>` prose (e.g.
+quoting this skill) can never trip an exit. See "Legitimate Stop Conditions" below.
+
 **CRITICAL**: To capture the session ID correctly, run this FIRST:
 ```bash
 echo $CLAUDE_CODE_SESSION_ID
@@ -213,6 +249,18 @@ These are the rationalizations that end a pre-approved session early. Every one
 
 **If you genuinely hit (a):** report the hard blocker clearly (what you tried, why you are stuck, what you'd need), then continue with any *other* in-scope work that the blocker does not gate — a blocker on one task is not a stop for the whole session.
 
+**`(a)` reporting prose is DISTINCT from the terminal `<hard-blocker>` marker.** Routine "I'm blocked on this one task but continuing elsewhere" reporting is plain prose — do NOT use the marker tag for it. The nonce'd `<hard-blocker>` marker is emitted ONLY when you actually intend to TERMINATE the WHOLE run because a genuine, agent-unresolvable external blocker gates everything left. To terminate on `(a)`, emit — in your FINAL turn — exactly:
+
+```
+<hard-blocker nonce="THE_VALUE_OF_hard_blocker_nonce">
+  what I tried: <concrete steps>
+  why I am stuck: <the real, external reason>
+  what I would need to proceed: <a genuinely external, agent-unresolvable residual>
+</hard-blocker>
+```
+
+The hook then asks the independent P13 judge to classify the blocker **external vs buildable**: if "what I would need" is something you could build, derive, or fetch yourself (a derivable standard, a buildable artifact, a credential in your own vault), the judge classifies it **buildable** and you are re-fed to keep working — the honest exit is for a genuinely external residual ONLY (a credential that does not exist, a down service, missing data, a prohibited action). A clean `(a)` exit writes a durable record, raises an /ack-able Attention item, and sends one Telegram so the blocker re-surfaces until you acknowledge it. A malformed/partial/nonce-mismatched marker is ignored (you keep working) — the safe direction.
+
 ---
 
 ## Step 4: Completion