feat(tasks): the hand-off — SessionEnd releases a session's claims; the practice is written down (milestone 381 step 4)

Release is the mechanical half: scribe_session_end.sh sends the ending
session's id to /api/plugin/release-session, which releases the claims it
held. A tidy-up, not the guarantee (no SessionEnd on a crash; the lease
covers that), and skipped on /clear so SessionStart(clear) can still
hand the claimed work back.

Saying what happened is the half only the model can do. It is stated as a
practice where it is read: the using-scribe skill owns it ("Hand off before
this session's context stops existing", pinned in test_guidance_ownership),
the static context points at it for the wrap-up moment, and add_task_log's
docstring says a log claims the task. _INSTRUCTIONS is untouched.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

plugin/hooks/hooks.json

@@ -101,6 +101,16 @@
           }
         ]
       }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/scribe_session_end.sh\""
+          }
+        ]
+      }
     ]
   }
 }

plugin/hooks/scribe_session_end.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Scribe — release this session's task claims as it ends (milestone 381 step 4).
+#
+# A claim records a session's attention, and a session that ends has none left
+# to give. This is the mechanical half of the hand-off: it needs nothing from
+# the model, only the session id the harness reports. The other half — writing
+# down where the work stands — only the model can do, and it is stated as a
+# practice in the skill and the static context, not here.
+#
+# A TIDY-UP, NOT THE GUARANTEE. SessionEnd does not fire on a crash, a killed
+# terminal or a dropped connection, and those are exactly the cases the claim
+# was designed around. The lease is what makes a dead session's claim read as
+# dead; this only keeps the ordinary exit from leaving a claim to run out.
+#
+# NOT ON /clear. A clear ends one conversation and starts the next in the same
+# terminal, and SessionStart(source=clear) pushes back the work this session
+# had claimed. Releasing here would leave that push with nothing to say. The
+# next write moves the claim wherever the work actually continues.
+#
+# EXIT 0 AND SILENT, ALWAYS. Nobody reads a SessionEnd hook's output, and the
+# session is ending whether this succeeds or not.
+set -uo pipefail
+
+# shellcheck source=plugin/hooks/scribe_defs.sh
+. "$(dirname "${BASH_SOURCE[0]}")/scribe_defs.sh"
+
+command -v curl >/dev/null 2>&1 || exit 0
+scribe_config || exit 0
+
+event=$(cat 2>/dev/null || true)
+[ -n "$event" ] || exit 0
+
+event_flat=$(printf '%s' "$event" | scribe_json_flat)
+reason=$(scribe_json_pick "$event_flat" '.reason')
+[ "$reason" = "clear" ] && exit 0
+
+session_id=$(scribe_json_pick "$event_flat" '.session_id')
+[ -n "$session_id" ] || exit 0
+
+sid_enc=$(printf '%s' "$session_id" | scribe_urlenc) || exit 0
+curl -fsS --max-time 4 \
+  -H "Authorization: Bearer ${token}" \
+  "${url%/}/api/plugin/release-session?session_id=${sid_enc}" \
+  >/dev/null 2>&1 || true
+exit 0

plugin/hooks/scribe_static_context.md

@@ -23,6 +23,9 @@ What only Claude Code needs said:
   long session, log it to Scribe, then tell the operator it's a good moment to
   `/compact` and name what you logged. You can't run it yourself; suggest it at
   seams, not every turn.
+- **When the operator wraps up, hand off first.** Log where each task you
+  worked stands before the session ends; the plugin releases your claims at
+  session end, but only you can say what happened (using-scribe, "Hand off").
 - **Stored Processes arrive as skills** (`scribe-proc-*`), refreshed at session
   start. After a Process is added or edited, `/scribe:sync` makes it available
   straight away.