Put work items in the state store, and bind the log to them (M1.1)

Development Plan M1.1, as discussed.

- Schema v4: a work_items table (id, scope, title, status, outcome,
  position, data) and an agent row whose active_item points at one
  (NULL: idle). Canonical events and intents carry their work item, and
  events their actor. Older stores are refused with a clear message:
  there was no production data, so no migration (the mechanism stays).
- The log is reached through a Transcript bound to one work item and
  one actor: store.transcript(item, actor) reads only that item and
  writes with both. The planner, executor, delegation and expert desk
  get one per call from the orchestrator instead of holding the store,
  so a component can neither read another task's events (the planner
  read every earlier task's, #78) nor write without attribution.
  store.all_events() is kept for readers that span items (evaluation
  capture, dumps). Intents are begun through the transcript or with
  work_item=, so each belongs to its item.
- The orchestrator opens a work item on 'use', closes it with its
  outcome (completed or abandoned), and carries what the operator said
  while idle into the new item as copies with their origin, so a task
  sent before 'use' is still planned from (D1). control.py keeps its
  state machine through get_state()/transition(), now over the active
  work item, until M2.6 retires it.
- nisse_dev.dump shows work items and each event's item and actor.

Tests: test_work_items.py (scoping, attribution, intent ownership,
restart, outcomes, carried messages, a second task never seeing the
first); the suites updated for the per-call transcript.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PPQ14L3LikyefCMFBqEbKE

nisse-dev/src/nisse_dev/planner.py

@@ -15,7 +15,7 @@ from nisse_dev.cancel import Cancel
 from nisse_dev.canonical import AssistantText, ToolCall, ToolResult
 from nisse_dev.control import AskHuman, PlanningError, PlanningStopped, SubmitPlan
 from nisse_dev.llm import BudgetExhausted, LLMClient, LLMError, RoleMap
-from nisse_dev.state import StateStore
+from nisse_dev.state import Transcript
 
 # Plans may be executed by a materially weaker model, which cannot
 # reconstruct intent. This predates the architecture's capability profiles
@@ -83,14 +83,12 @@ class LLMPlanningAgent:
     def __init__(
         self,
         client: LLMClient,
-        store: StateStore,
         roles: RoleMap,
         *,
         system_prompt: str = SYSTEM_PROMPT,
         cancel: Cancel | None = None,
     ) -> None:
         self._client = client
-        self._store = store
         self._roles = roles
         self._system_prompt = system_prompt
         # Checked before each turn only. A turn is one model call, and a turn
@@ -99,6 +97,7 @@ class LLMPlanningAgent:
 
     def plan(
         self,
+        transcript: Transcript,
         gate: str,
         project: str,
         feedback: str | None = None,
@@ -106,18 +105,21 @@ class LLMPlanningAgent:
     ) -> SubmitPlan | AskHuman:
         """Operator feedback and answers are already durable in the canonical
         log (the orchestrator appends every inbound message), so they are not
-        re-injected here; the log is the single source of context."""
+        re-injected here; the log is the single source of context. The
+        transcript is the work item's, written as the planner (L6, L7)."""
         model = self._roles.resolve("planner")
         instruction = (
             f"{self._system_prompt}\n\n"
             f"Current task: draft the {gate} plan for project {project!r}."
         )
         self._check_stop()
-        action, first_error = self._try_turn(model, instruction)
+        action, first_error = self._try_turn(transcript, model, instruction)
         if action is not None:
             return action
         self._check_stop()
-        action, second_error = self._try_turn(model, f"{instruction}\n\n{_NUDGE}")
+        action, second_error = self._try_turn(
+            transcript, model, f"{instruction}\n\n{_NUDGE}"
+        )
         if action is None:
             detail = second_error or first_error
             raise PlanningError(
@@ -131,13 +133,13 @@ class LLMPlanningAgent:
             raise PlanningStopped("stopped by the operator")
 
     def _try_turn(
-        self, model: str, system: str
+        self, transcript: Transcript, model: str, system: str
     ) -> tuple[SubmitPlan | AskHuman | None, str | None]:
         """A malformed or failed call is a bad turn, not a crash: the caller
         retries once and then gates to the human (L9 — judgment about model
         output is observable, never the model's own claim)."""
         try:
-            return self._turn(model, system), None
+            return self._turn(transcript, model, system), None
         except BudgetExhausted:
             # Retrying cannot help: the budget will not reappear within a
             # turn. Surface it now so the operator is told rather than the
@@ -146,8 +148,10 @@ class LLMPlanningAgent:
         except LLMError as exc:
             return None, str(exc)
 
-    def _turn(self, model: str, system: str) -> SubmitPlan | AskHuman | None:
-        events = self._store.read_events()
+    def _turn(
+        self, transcript: Transcript, model: str, system: str
+    ) -> SubmitPlan | AskHuman | None:
+        events = transcript.read()
         produced = self._client.complete(
             events, tools=PLANNER_TOOLS, model=model, system=system
         )
@@ -155,7 +159,7 @@ class LLMPlanningAgent:
         for event in produced:
             # Append before interpreting: the transcript must be truthful even
             # if the call below rejects the arguments.
-            self._store.append_event(event)
+            transcript.append(event)
             if isinstance(event, AssistantText) or action is not None:
                 continue
             if isinstance(event, ToolCall):
@@ -164,7 +168,7 @@ class LLMPlanningAgent:
                     # The gate is this call's outcome. Recording it keeps the
                     # transcript renderable: providers reject a tool call with
                     # no result, and the next planning turn replays this log.
-                    self._store.append_event(
+                    transcript.append(
                         ToolResult(
                             call_id=event.call_id,
                             result=(