ms-tau-sdk 1.2.9.dev15__tar.gz → 1.2.9.dev17__tar.gz

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/CHANGELOG.md

@@ -1,7 +1,20 @@
 # Changelog
 
-## 1.2.9 — 2026-09-25
-
+## 1.2.9 — 2026-09-26
+
+- Added bounded A2A Task Message history with hard-cut A2A v1 role projection, canonical durable
+  status Messages, exact idempotent settlement replay, and reference-only status events.
+- Correlated every Task attempt with one immutable Tau turn and exact entry boundaries, including
+  local Task-owned lease fencing, committed/abandoned resolution, and late-write rejection.
+- Rebuilt Tau Board Task detail around Overview, Conversation, Result, Execution, and Technical
+  evidence, with byte-exact streamed Artifact reconstruction and bounded secret-redacted execution
+  entries.
+- Guaranteed A2A failure observability: standard terminal failed status events, conformant safe
+  status Messages, explicit terminalization-unknown transport errors, and bounded request waiting.
+- Added SDK-owned local Task reconciliation. Unclaimed submitted Tasks resume after restart;
+  exhausted starts fail terminally, while stale working attempts with uncertain side effects fail
+  as ambiguous instead of being blindly executed twice. Health, structured logs, and Tau Board now
+  expose recovery and failure evidence.
 - Added Tau Board's Agent view for readable effective Agent Card inspection, source-grouped tool
   catalog inspection, project extension diagnostics, and bounded registered-entry source viewing.
 - Added an explicit local project-tool workbench with schema-generated inputs, authoritative

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 1.2.9.dev15
+Version: 1.2.9.dev17
 Summary: Workspace-bound Tau application primitives for Main Sequence projects
 Project-URL: Changelog, https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md
 Project-URL: Documentation, https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs
@@ -116,6 +116,12 @@ from ms_tau_sdk import create_app
 app = create_app()
 ```
 
+Job-hosted batch execution is an [accepted design](docs/adrs/0015-job-hosted-batch-execution.md)
+with implementation pending. It will run this SDK's configured Tau composition for one assignment
+inside a project Job, close it, and exit without starting Uvicorn. The Job continues to own its
+status and logs. See the [batch guide](docs/guides/job-hosted-batch-execution.md) for the target
+Python integration; the current release does not expose that batch API.
+
 ## Local development without platform sessions
 
 Local mode runs the same workspace Tau runtime without registering an Agent or AgentSession. The
@@ -144,7 +150,25 @@ workspace default. Public A2A Message, Task, streaming, continuation, list/get/c
 subscription flows run without creating a platform AgentSession. Incoming local A2A calls do not
 need managed-gateway caller headers: supplied context IDs are mapped into the workspace-local
 session namespace and local provenance is recorded. Task records and event streams survive process
-restart.
+restart. On startup TAU reschedules unclaimed `submitted` Tasks. A stale `working` Task is not
+blindly executed again: if the previous process may have produced an external side effect, TAU
+settles it as `failed` with `ambiguous_execution_outcome`.
+
+Task terminality comes only from the standard A2A state. `completed`, `failed`, `canceled`, and
+`rejected` are terminal; `input_required` and `auth_required` are resumable interruptions. A normal
+provider, tool, validation, or execution failure is durably settled as `failed` with a safe A2A
+status Message. If TAU cannot persist that transition, a live stream reports
+`task_terminalization_unknown`; poll or subscribe to the Task while its recovery owner resolves the
+durable state. `returnImmediately=false` waits for at most the configured Task wait period and does
+not cancel a still-running Task when that transport wait expires.
+
+Task responses expose bounded A2A Message history separately from Artifacts and execution data.
+Use `configuration.historyLength` on Message send/stream and `historyLength` on Task get/list;
+omission selects the SDK's bounded 100-Message tail, zero omits history without reading it, and a
+positive value returns that latest tail oldest-to-newest. Public A2A roles are `ROLE_USER` and
+`ROLE_AGENT`; Main Sequence requester/responder direction values remain internal to persistence.
+Tau Board renders the conversation, final Artifacts, exact attempt/turn execution, and raw technical
+events as distinct sections.
 
 Local mode also appends privacy-filtered, structured JSON Lines to
 `~/.tau/mainsequence/<workspace-hash>/logs/tau.jsonl`, with bounded rotation. Both the database

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/README.md

@@ -85,6 +85,12 @@ from ms_tau_sdk import create_app
 app = create_app()
 ```
 
+Job-hosted batch execution is an [accepted design](docs/adrs/0015-job-hosted-batch-execution.md)
+with implementation pending. It will run this SDK's configured Tau composition for one assignment
+inside a project Job, close it, and exit without starting Uvicorn. The Job continues to own its
+status and logs. See the [batch guide](docs/guides/job-hosted-batch-execution.md) for the target
+Python integration; the current release does not expose that batch API.
+
 ## Local development without platform sessions
 
 Local mode runs the same workspace Tau runtime without registering an Agent or AgentSession. The
@@ -113,7 +119,25 @@ workspace default. Public A2A Message, Task, streaming, continuation, list/get/c
 subscription flows run without creating a platform AgentSession. Incoming local A2A calls do not
 need managed-gateway caller headers: supplied context IDs are mapped into the workspace-local
 session namespace and local provenance is recorded. Task records and event streams survive process
-restart.
+restart. On startup TAU reschedules unclaimed `submitted` Tasks. A stale `working` Task is not
+blindly executed again: if the previous process may have produced an external side effect, TAU
+settles it as `failed` with `ambiguous_execution_outcome`.
+
+Task terminality comes only from the standard A2A state. `completed`, `failed`, `canceled`, and
+`rejected` are terminal; `input_required` and `auth_required` are resumable interruptions. A normal
+provider, tool, validation, or execution failure is durably settled as `failed` with a safe A2A
+status Message. If TAU cannot persist that transition, a live stream reports
+`task_terminalization_unknown`; poll or subscribe to the Task while its recovery owner resolves the
+durable state. `returnImmediately=false` waits for at most the configured Task wait period and does
+not cancel a still-running Task when that transport wait expires.
+
+Task responses expose bounded A2A Message history separately from Artifacts and execution data.
+Use `configuration.historyLength` on Message send/stream and `historyLength` on Task get/list;
+omission selects the SDK's bounded 100-Message tail, zero omits history without reading it, and a
+positive value returns that latest tail oldest-to-newest. Public A2A roles are `ROLE_USER` and
+`ROLE_AGENT`; Main Sequence requester/responder direction values remain internal to persistence.
+Tau Board renders the conversation, final Artifacts, exact attempt/turn execution, and raw technical
+events as distinct sections.
 
 Local mode also appends privacy-filtered, structured JSON Lines to
 `~/.tau/mainsequence/<workspace-hash>/logs/tau.jsonl`, with bounded rotation. Both the database

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/packages/tau-board/src/ms_tau_board/app.py

@@ -283,10 +283,14 @@ async def session_list(request: Request) -> Response:
 
 async def task_list(request: Request) -> Response:
     token, session, new = _session(request)
-    directory = _directory(request, session, _selected(request, session))
+    profile = _selected(request, session)
+    directory = _directory(request, session, profile)
     result = await asyncio.to_thread(
         state.tasks, directory, session_uid=request.query_params.get("sessionUid", "")
     )
+    health = session.health.get(profile.name, {})
+    policy = health.get("a2a_task_policy")
+    result["policy"] = policy if isinstance(policy, dict) else {}
     return _cookie(JSONResponse(result), token, new)
 
 

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/packages/tau-board/src/ms_tau_board/state.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+import json
+import re
 import sqlite3
 from contextlib import closing
 from pathlib import Path
 from typing import Any
 
-SCHEMA_VERSION = "2"
+SCHEMA_VERSION = "4"
 TABLES = (
     "sessions",
     "entries",
@@ -27,6 +29,20 @@ PRIVATE_FIELDS = {
     "status_message_json",
     "metadata_json",
 }
+EXECUTION_VALUE_MAX_BYTES = 64 * 1024
+_SENSITIVE_ENTRY_KEYS = {
+    "api_key",
+    "authorization",
+    "client_secret",
+    "credential",
+    "credentials",
+    "password",
+    "prompt",
+    "secret",
+    "system_prompt",
+    "token",
+}
+_BEARER_PATTERN = re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]+")
 
 
 class StateError(ValueError):
@@ -167,7 +183,9 @@ def tasks(directory: Path, *, session_uid: str = "", limit: int = 100) -> dict[s
             params: tuple[object, ...] = (session_uid, limit) if session_uid else (limit,)
             rows = connection.execute(
                 "SELECT uid, task_id, context_id, agent_session_uid, status, "
-                "status_timestamp, cancellation_requested, created_at, updated_at "
+                "status_timestamp, cancellation_requested, failure_code, "
+                "failure_category, failure_retryable, correlation_id, recovery_owner, "
+                "recovery_count, terminal_at, created_at, updated_at "
                 f"FROM a2a_tasks {where} ORDER BY created_at DESC LIMIT ?",
                 params,
             ).fetchall()
@@ -190,6 +208,15 @@ def task_detail(directory: Path, task_id: str) -> dict[str, Any]:
             if task is None:
                 raise StateError("Task not found")
             uid = task["uid"]
+            runtime_selection = connection.execute(
+                "SELECT provider, model, thinking FROM sessions WHERE uid = ?",
+                (task["context_id"],),
+            ).fetchone()
+            messages = connection.execute(
+                "SELECT sequence, message_id, role, message_json, created_at "
+                "FROM a2a_task_messages WHERE task_uid = ? ORDER BY sequence",
+                (uid,),
+            ).fetchall()
             events = connection.execute(
                 "SELECT sequence, uid, event_type, status, message_uid, output_uid, "
                 "payload_json, created_at FROM a2a_task_events "
@@ -197,20 +224,160 @@ def task_detail(directory: Path, task_id: str) -> dict[str, Any]:
                 (uid,),
             ).fetchall()
             attempts = connection.execute(
-                "SELECT uid, attempt_number, state, created_at, updated_at "
+                "SELECT uid, attempt_number, state, outcome_category, failure_code, "
+                "failure_detail, retryable, correlation_id, turn_uid, "
+                "entry_start_sequence, entry_end_sequence, turn_resolution, "
+                "created_at, updated_at "
                 "FROM a2a_task_attempts WHERE task_uid = ? ORDER BY attempt_number",
                 (uid,),
             ).fetchall()
             outputs = connection.execute(
-                "SELECT artifact_id, revision, name, finalized, created_at, updated_at "
+                "SELECT artifact_id, revision, name, parts_json, metadata_json, "
+                "finalized, created_at, updated_at "
                 "FROM a2a_task_outputs WHERE task_uid = ? ORDER BY created_at",
                 (uid,),
             ).fetchall()
+            execution_entries = connection.execute(
+                """
+                SELECT DISTINCT entries.sequence, entries.entry_type,
+                    entries.entry_json, entries.idempotency_key, entries.turn_uid
+                FROM entries
+                JOIN a2a_task_attempts AS attempts
+                    ON attempts.turn_uid = entries.turn_uid
+                    AND attempts.task_uid = ?
+                WHERE entries.session_uid = ?
+                    AND attempts.turn_uid IS NOT NULL
+                    AND (
+                        attempts.entry_start_sequence IS NULL
+                        OR entries.sequence >= attempts.entry_start_sequence
+                    )
+                    AND (
+                        attempts.entry_end_sequence IS NULL
+                        OR entries.sequence < attempts.entry_end_sequence
+                    )
+                ORDER BY entries.sequence
+                """,
+                (uid, task["context_id"]),
+            ).fetchall()
     except sqlite3.Error as error:
         raise StateError(f"Cannot read local Task: {type(error).__name__}") from error
+    task_value = dict(task)
+    raw_status_message = task_value.pop("status_message_json", None)
+    try:
+        status_message = json.loads(raw_status_message) if raw_status_message else None
+    except (TypeError, json.JSONDecodeError):
+        status_message = None
+    task_value["status_message"] = status_message
+    task_value["runtime"] = dict(runtime_selection) if runtime_selection is not None else None
+    status_text = ""
+    if isinstance(status_message, dict):
+        parts = status_message.get("parts")
+        if isinstance(parts, list):
+            status_text = "\n".join(
+                str(part.get("text") or "")
+                for part in parts
+                if isinstance(part, dict) and part.get("text")
+            )
+    task_value["failure"] = {
+        "code": str(task_value.get("failure_code") or ""),
+        "category": str(task_value.get("failure_category") or ""),
+        "retryable": (
+            bool(task_value["failure_retryable"])
+            if task_value.get("failure_retryable") is not None
+            else None
+        ),
+        "message": status_text,
+        "correlationId": str(task_value.get("correlation_id") or ""),
+    }
+    message_values = []
+    for row in messages:
+        value = dict(row)
+        value["message"] = _decode_json(value.pop("message_json"), {})
+        message_values.append(value)
+    output_values = []
+    for row in outputs:
+        value = dict(row)
+        parts = _decode_json(value.pop("parts_json"), [])
+        metadata = _decode_json(value.pop("metadata_json"), {})
+        text = "".join(str(part.get("text") or "") for part in parts if isinstance(part, dict))
+        byte_size = 0
+        for part in parts:
+            if not isinstance(part, dict):
+                continue
+            if isinstance(part.get("text"), str):
+                byte_size += len(part["text"].encode("utf-8"))
+            elif "data" in part:
+                byte_size += len(
+                    json.dumps(
+                        part["data"],
+                        ensure_ascii=False,
+                        separators=(",", ":"),
+                        sort_keys=True,
+                    ).encode("utf-8")
+                )
+        value.update(
+            {
+                "parts": parts,
+                "metadata": metadata,
+                "text": text,
+                "byte_size": byte_size,
+            }
+        )
+        output_values.append(value)
+    event_values = []
+    for row in events:
+        value = dict(row)
+        value["payload"] = _decode_json(value.pop("payload_json"), {})
+        event_values.append(value)
+    entry_values = []
+    for row in execution_entries:
+        value = dict(row)
+        value["entry"] = _safe_execution_value(_decode_json(value.pop("entry_json"), {}))
+        entry_values.append(value)
     return {
-        "task": dict(task),
-        "events": [dict(row) for row in events],
+        "task": task_value,
+        "messages": message_values,
+        "events": event_values,
         "attempts": [dict(row) for row in attempts],
-        "outputs": [dict(row) for row in outputs],
+        "outputs": output_values,
+        "executionEntries": entry_values,
+    }
+
+
+def _decode_json(value: object, default: Any) -> Any:
+    if value is None or value == "":
+        return default
+    try:
+        return json.loads(str(value))
+    except (TypeError, json.JSONDecodeError):
+        return default
+
+
+def _safe_execution_value(value: Any, *, key: str = "") -> Any:
+    """Bound and redact operational entry data before it reaches the browser."""
+
+    normalized = key.lower().replace("-", "_")
+    if normalized in _SENSITIVE_ENTRY_KEYS or normalized.endswith(
+        ("_credential", "_password", "_secret", "_token")
+    ):
+        return "[REDACTED]"
+    safe: Any
+    if isinstance(value, dict):
+        safe = {
+            str(child_key): _safe_execution_value(child, key=str(child_key))
+            for child_key, child in value.items()
+        }
+    elif isinstance(value, list):
+        safe = [_safe_execution_value(child) for child in value]
+    elif isinstance(value, str):
+        safe = _BEARER_PATTERN.sub("Bearer [REDACTED]", value)
+    else:
+        safe = value
+    encoded = json.dumps(safe, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+    if len(encoded) <= EXECUTION_VALUE_MAX_BYTES:
+        return safe
+    return {
+        "truncated": True,
+        "originalBytes": len(encoded),
+        "message": "Execution entry exceeds the Tau Board inspection limit.",
     }

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/packages/tau-board/src/ms_tau_board/static/app.js

@@ -539,7 +539,8 @@ function displayTask(task) {
   $("a2a-context").value = task.contextId || "";
   const timing = taskTiming(task);
   const statusLabel = timing.completed ? "Completed" : (timing.terminal ? "Terminal status" : "Status recorded");
-  $("task-output").textContent = `${task.id} · ${task.status?.state || "unknown"}\nCreated: ${displayTime(timing.created)}\n${statusLabel}: ${displayTime(timing.statusTime)}\n\n${taskText(task)}`;
+  const statusText = (task.status?.message?.parts || []).map((part) => part.text || "").filter(Boolean).join("\n");
+  $("task-output").textContent = `${task.id} · ${task.status?.state || "unknown"}\nCreated: ${displayTime(timing.created)}\n${statusLabel}: ${displayTime(timing.statusTime)}${statusText ? `\nReason: ${statusText}` : ""}\n\n${taskText(task)}`;
 }
 function handleA2AFrame(frame) {
   const value = frame.result || frame;
@@ -713,7 +714,12 @@ async function refreshTaskExplorer() {
   const result = await json(`/api/board/tasks?${query}`, { headers });
   const list = $("tasks-list"); clear(list);
   for (const task of result.tasks || []) {
-    const button = node("button", `${task.task_id} · ${task.status}\n${task.context_id}`, "button is-light");
+    const threshold = task.status === "submitted" ? result.policy?.pending_timeout_seconds : result.policy?.stale_after_seconds;
+    const recorded = task.status === "submitted" ? task.created_at : task.status_timestamp;
+    const ageSeconds = recorded ? (Date.now() - new Date(recorded).valueOf()) / 1000 : 0;
+    const stale = ["submitted", "working"].includes(task.status) && threshold && ageSeconds > threshold;
+    const suffix = task.failure_code ? `\n${task.failure_code}` : (stale ? "\nRecovery overdue" : "");
+    const button = node("button", `${task.task_id} · ${task.status}\n${task.context_id}${suffix}`, stale ? "button is-warning" : "button is-light");
     button.type = "button";
     button.classList.toggle("is-selected", selectedTaskId === task.task_id);
     button.addEventListener("click", () => inspectTask(task.task_id).catch(report));
@@ -765,12 +771,89 @@ async function loadTaskLogs(reset = false) {
   renderTaskTimeline();
 }
 
+function renderTaskConversation() {
+  const list = $("tasks-conversation"); clear(list);
+  for (const record of selectedTaskData?.messages || []) {
+    const message = record.message || {};
+    const card = node("article", "", "task-card");
+    const head = node("div", "", "task-card-head");
+    const role = message.role === "ROLE_REQUESTER" ? "Requester" : (message.role === "ROLE_RESPONDER" ? "Responder" : (message.role || "Message"));
+    head.append(node("strong", role), node("span", `#${record.sequence}`, "tag is-light"), node("span", displayTime(record.created_at), "mono"));
+    card.append(head);
+    for (const part of message.parts || []) {
+      if (typeof part.text === "string") card.append(node("pre", part.text));
+      else if (Object.hasOwn(part, "data")) card.append(node("pre", JSON.stringify(part.data, null, 2)));
+      else card.append(node("pre", JSON.stringify(part, null, 2)));
+    }
+    list.append(card);
+  }
+  if (!(selectedTaskData?.messages || []).length) list.append(node("p", "No durable Task Messages.", "help"));
+}
+
+function renderTaskResults() {
+  const list = $("tasks-result"); clear(list);
+  for (const artifact of selectedTaskData?.outputs || []) {
+    const card = node("article", "", "task-card");
+    const head = node("div", "", "task-card-head");
+    head.append(node("strong", artifact.name || artifact.artifact_id), node("span", `revision ${artifact.revision}`, "tag is-light"), node("span", artifact.finalized ? "Final" : "Open", artifact.finalized ? "tag is-success is-light" : "tag is-warning is-light"), node("span", `${artifact.byte_size || 0} bytes`, "tag is-light"));
+    card.append(head);
+    if (artifact.text) card.append(node("pre", artifact.text));
+    for (const part of artifact.parts || []) {
+      if (!Object.hasOwn(part, "data")) continue;
+      card.append(node("pre", JSON.stringify(part.data, null, 2)));
+    }
+    list.append(card);
+  }
+  if (!(selectedTaskData?.outputs || []).length) list.append(node("p", "No Task Artifacts.", "help"));
+}
+
+function executionLabel(entry) {
+  const raw = JSON.stringify(entry.entry || {}).toLowerCase();
+  if (raw.includes("tool_result") || raw.includes("toolresult")) return "Tool result";
+  if (raw.includes("tool_call") || raw.includes("toolcall")) return "Tool call";
+  if (raw.includes("reasoning") || raw.includes("thinking")) return "Recorded reasoning";
+  if (entry.entry_type === "message") return "Model message";
+  return entry.entry_type || "Tau entry";
+}
+
+function executionOutcome(entry) {
+  const value = entry.entry || {};
+  const raw = JSON.stringify(value).toLowerCase();
+  if (raw.includes('"is_error":true') || raw.includes('"error":true') || raw.includes('"status":"failed"')) return "Failed";
+  if (raw.includes('"status":"completed"') || raw.includes('"status":"success"') || raw.includes('"success":true')) return "Succeeded";
+  return "";
+}
+
+function renderTaskExecution() {
+  const list = $("tasks-execution"); clear(list);
+  const entries = selectedTaskData?.executionEntries || [];
+  for (const attempt of selectedTaskData?.attempts || []) {
+    const card = node("article", "", "task-card");
+    const head = node("div", "", "task-card-head");
+    head.append(node("strong", `Attempt ${attempt.attempt_number}`), node("span", attempt.state, "tag is-info is-light"), node("span", attempt.turn_resolution || "unresolved", attempt.turn_resolution === "committed" ? "tag is-success is-light" : "tag is-warning is-light"));
+    card.append(head);
+    detailLine(card, "Turn", attempt.turn_uid || "—");
+    detailLine(card, "Entry interval", attempt.entry_start_sequence == null ? "—" : `[${attempt.entry_start_sequence}, ${attempt.entry_end_sequence ?? "?"})`);
+    const attemptEntries = entries.filter((entry) => entry.turn_uid && entry.turn_uid === attempt.turn_uid && (attempt.entry_start_sequence == null || entry.sequence >= attempt.entry_start_sequence) && (attempt.entry_end_sequence == null || entry.sequence < attempt.entry_end_sequence));
+    for (const entry of attemptEntries) card.append(taskEventItem("Tau", `#${entry.sequence}`, executionLabel(entry), entry, executionOutcome(entry)));
+    if (!attemptEntries.length) card.append(node("p", "No retained entries in this turn interval.", "help"));
+    list.append(card);
+  }
+  if (!(selectedTaskData?.attempts || []).length) list.append(node("p", "No execution attempts.", "help"));
+}
+
 async function inspectTask(taskId) {
   selectedTaskId = taskId;
   selectedTaskData = await json(`/api/board/tasks/${encodeURIComponent(taskId)}`, { headers: { "X-Tau-Board-Profile": $("tasks-profile").value } });
   const task = selectedTaskData.task;
   const detail = $("tasks-detail"); clear(detail);
-  for (const [label, value] of [["Task ID", task.task_id], ["Session", task.context_id], ["Status", task.status], ["Created", task.created_at], ["Updated", task.updated_at], ["Attempts", selectedTaskData.attempts.length], ["Artifacts", selectedTaskData.outputs.length]]) detailLine(detail, label, value);
+  const failure = task.failure || {};
+  const runtime = task.runtime || {};
+  const duration = task.created_at && (task.terminal_at || task.status_timestamp) ? Math.max(0, new Date(task.terminal_at || task.status_timestamp).valueOf() - new Date(task.created_at).valueOf()) : null;
+  for (const [label, value] of [["Task ID", task.task_id], ["Session", task.context_id], ["Status", task.status], ["Created", displayTime(task.created_at)], ["Status time", displayTime(task.status_timestamp)], ["Terminal time", displayTime(task.terminal_at)], ["Duration", duration == null || Number.isNaN(duration) ? "—" : `${duration} ms`], ["Provider", runtime.provider || "—"], ["Model", runtime.model || "—"], ["Thinking", runtime.thinking || "—"], ["Failure", failure.message || "—"], ["Failure code", failure.code || "—"], ["Failure category", failure.category || "—"], ["Retry safe", failure.retryable == null ? "—" : String(failure.retryable)], ["Recovery owner", task.recovery_owner || "—"], ["Recovery attempts", task.recovery_count || 0], ["Correlation ID", failure.correlationId || "—"], ["Attempts", selectedTaskData.attempts.length], ["Messages", selectedTaskData.messages.length], ["Artifacts", selectedTaskData.outputs.length]]) detailLine(detail, label, value);
+  renderTaskConversation();
+  renderTaskResults();
+  renderTaskExecution();
   $("tasks-open-a2a").disabled = false;
   $("tasks-open-session").disabled = false;
   for (const button of $("tasks-list").querySelectorAll("button")) button.classList.toggle("is-selected", button.textContent.startsWith(`${taskId} ·`));
@@ -928,7 +1011,7 @@ async function start() {
   bind("a2a-new-task", "click", () => { $("a2a-task-id").value = ""; $("a2a-kind").value = "task"; $("a2a-input").focus(); });
   bind("refresh-tasks", "click", refreshTasks);
   bind("tasks-refresh", "click", refreshTaskExplorer);
-  bind("tasks-profile", "change", () => { selectedTaskId = ""; selectedTaskData = null; clear($("tasks-detail")); clear($("tasks-timeline")); return refreshTaskExplorer(); });
+  bind("tasks-profile", "change", () => { selectedTaskId = ""; selectedTaskData = null; for (const id of ["tasks-detail", "tasks-conversation", "tasks-result", "tasks-execution", "tasks-timeline"]) clear($(id)); return refreshTaskExplorer(); });
   bind("tasks-session", "change", refreshTaskExplorer);
   bind("tasks-open-id", "click", () => inspectTask($("tasks-id").value.trim()));
   bind("tasks-older", "click", () => loadTaskLogs());

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/packages/tau-board/src/ms_tau_board/static/board.css

@@ -40,6 +40,10 @@ td { max-width: 24rem; overflow-wrap: anywhere; font-size: .82rem; }
 .tool-field { margin-bottom: .8rem; }
 .extension-card { border-bottom: 1px solid var(--bulma-border-weak); padding: .55rem 0; font-size: .82rem; overflow-wrap: anywhere; }
 #tasks-detail { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 1rem; }
+.task-section { display: grid; gap: .7rem; }
+.task-card { border: 1px solid var(--bulma-border-weak); border-radius: .45rem; padding: .8rem; background: var(--bulma-scheme-main-bis); }
+.task-card .task-card-head { display: flex; flex-wrap: wrap; gap: .45rem; align-items: center; margin-bottom: .55rem; }
+.task-card pre { margin-top: .5rem; white-space: pre-wrap; overflow-wrap: anywhere; max-height: 24rem; overflow: auto; }
 .settings-table td { vertical-align: middle; }
 .settings-table td:first-child { min-width: 15rem; }
 .settings-table td:last-child { min-width: 14rem; }

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/packages/tau-board/src/ms_tau_board/static/index.html

@@ -146,9 +146,18 @@
         <div class="column"><div class="box">
           <h2 class="title is-5">Task detail</h2>
           <div id="tasks-detail" class="detail-list">Select a Task to inspect its status and events.</div>
-          <div class="buttons mt-4"><button class="button is-small" id="tasks-open-a2a" disabled>Open in A2A</button><button class="button is-small" id="tasks-open-session" disabled>Open session logs</button></div>
-          <h3 class="title is-6 mt-5">Event timeline</h3>
-          <p class="help">Task state events and related session logs are labelled separately. Raw event fields are available by expanding a row.</p>
+          <div class="buttons mt-4"><button class="button is-small" id="tasks-open-a2a" disabled>Open in A2A Console</button><button class="button is-small" id="tasks-open-session" disabled>Open session logs</button></div>
+          <h3 class="title is-6 mt-5">Conversation</h3>
+          <p class="help">Durable requester and responder Messages associated with this Task.</p>
+          <div id="tasks-conversation" class="task-section"></div>
+          <h3 class="title is-6 mt-5">Result</h3>
+          <p class="help">Final Artifacts. Streamed text fragments are joined without added separators.</p>
+          <div id="tasks-result" class="task-section"></div>
+          <h3 class="title is-6 mt-5">Execution</h3>
+          <p class="help">Exact attempt and Tau turn correlation. Internal evidence is operational data, not public Task history.</p>
+          <div id="tasks-execution" class="task-section"></div>
+          <h3 class="title is-6 mt-5">Technical</h3>
+          <p class="help">Task events and related session logs are labelled separately. Expand a row for raw evidence.</p>
           <div id="tasks-timeline" class="log-list"></div>
           <button class="button is-small mt-3 is-hidden" id="tasks-older">Load older logs</button>
         </div></div>

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ms-tau-sdk"
-version = "1.2.9.dev15"
+version = "1.2.9.dev17"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/src/ms_tau_sdk/agent_skills/tau_a2a_runtime_adapter/SKILL.md

@@ -76,5 +76,25 @@ When an A2A operation fails, identify the boundary before changing code:
 5. Wire validation: request/response role, context, extension, or payload invalid.
 6. Task lifecycle: fence, lease, cancellation, event order, or retry semantics violated.
 
+For Task lifecycle diagnosis, derive terminality from the Task state; never introduce a second
+terminal flag. Normal execution errors must settle `failed` and streaming must emit that
+authoritative terminal status update. `task_terminalization_unknown` means settlement durability
+is unknown and belongs to the recovery owner. Local SQLite recovery is SDK-owned; managed dispatch
+recovery is backend-owned. Do not retry a stale working attempt when project or MCP side effects may
+have occurred unless a checkpoint or idempotency contract proves replay safe.
+
+Treat Task Messages, Artifacts, Tau entries, Task events, and logs as separate ontologies. Use
+`historyLength` only for the bounded durable Message tail. Omission means the SDK default of 100,
+zero omits history without a tail read, and positive values return the latest bounded tail in
+oldest-to-newest order. Public A2A v1 roles are `ROLE_USER` and `ROLE_AGENT`; persistence uses the
+Main Sequence requester/responder direction values. Never expose internal Tau entries, reasoning,
+tool traffic, prompts, or logs as public Task history.
+
+Allocate the Tau turn UID before attempt start and pass that exact UID to the runtime prompt. A
+Task attempt owns one turn and one half-open entry interval with a `committed` or `abandoned`
+resolution. Do not correlate by timestamps. A status settlement is absent or one complete durable
+responder Message; never send the removed ad hoc status-detail shape. Status events reference that
+Message and consumers reload the Task snapshot.
+
 Change this SDK only for catalog projection, proof attachment, runtime execution, or transport
 translation defects. Platform contract changes belong to Django.

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/src/ms_tau_sdk/agent_skills/tau_local_development/SKILL.md

@@ -77,7 +77,9 @@ a platform AgentSession. Local mode supports:
 - subscription resumption with `afterSequence`;
 - continuation of a Task in `input_required` or `auth_required` by sending a new Message carrying
   that `taskId`; and
-- Task status, messages, artifacts, attempts, and events surviving process restart.
+- Task status, messages, artifacts, attempts, and events surviving process restart, with the SDK
+  rescheduling safe unclaimed work and terminalizing stale uncertain work rather than replaying
+  possible side effects.
 
 To request a Task from `message:send`, send the response-kind extension header
 `A2A-Extensions: https://mainsequence.ai/a2a/extensions/response-kind/v1` together with
@@ -85,6 +87,33 @@ To request a Task from `message:send`, send the response-kind extension header
 response. `message:stream` is always Task-oriented and does not accept `responseKind` or
 `returnImmediately`.
 
+Task terminality is derived only from its A2A state. `completed`, `failed`, `canceled`, and
+`rejected` are terminal; `input_required` and `auth_required` are resumable. A normal execution
+failure produces a durable failed Task and a standard responder `status.message`. A
+`task_terminalization_unknown` stream error means the terminal write itself could not be proven;
+retrieve or subscribe to the Task while recovery resolves it. Never treat an HTTP disconnect or
+bounded wait expiry as Task cancellation.
+
+Task responses include a bounded Message tail by default. Set `configuration.historyLength` on
+Message send/stream or `historyLength` on Task get/list: zero omits history and performs no tail
+read, while a positive value returns the latest Messages oldest-to-newest, capped at 100. History
+contains requester and deliberately durable responder/status Messages only. Final output remains
+under `artifacts`; Tau entries, tool activity, events, and logs never become public history. Public
+roles are `ROLE_USER`/`ROLE_AGENT`; the local SQLite binding stores requester/responder directions.
+
+Each local Task attempt reserves one immutable Tau turn. Its entries share that turn UID and remain
+inside the recorded half-open sequence interval. Completed and interrupted settlement requires a
+committed turn; failed, rejected, or canceled settlement can abandon a pending turn, after which
+late append or commit is rejected. An unresolved Task-owned turn prevents lease replacement until
+the local Task reconciler records its recovery outcome. Ordinary chat/direct-Message turns have no
+Task owner and retain normal lease cleanup.
+
+After restart, the local reconciler schedules an unclaimed `submitted` Task from its persisted
+request. It does not blindly rerun a stale `working` Task: once the old lease and stale interval
+expire, an attempt without replay-safe checkpoint evidence becomes failed with
+`ambiguous_execution_outcome`. Inspect the failure code, attempt, recovery owner, and correlation ID
+in Tau Board and the structured log.
+
 Incoming local A2A requests do not need managed-gateway `X-Caller-*` headers. TAU assigns
 workspace-local provenance and maps each supplied `contextId` into the same workspace-scoped local
 session namespace used by chat. A supplied `taskId` remains the public Task identifier. The local
@@ -123,6 +152,12 @@ tool still has the Tau process's real filesystem, network, environment, and cred
 there is no automatic rollback. A busy session, stale catalog, expired confirmation, non-project
 tool, oversized output, timeout, or cancellation must fail explicitly.
 
+The Tasks tab is the primary inspection surface: Overview states the lifecycle, Conversation shows
+durable Messages, Result shows complete Artifacts, Execution uses exact attempt/turn correlation,
+and Technical retains mutation events and logs. **Open in A2A Console** is an action shortcut, not
+the Task explanation. Many `output_updated` records represent revisions of one Artifact and must
+not be interpreted as many agent responses.
+
 ## Outbound A2A through Main Sequence MCP
 
 Keep the projected `a2a.send_message` tool available. A local agent may send a Message or create a

{ms_tau_sdk-1.2.9.dev15 → ms_tau_sdk-1.2.9.dev17}/src/ms_tau_sdk/agent_skills/tau_project_customization/SKILL.md

@@ -59,6 +59,11 @@ Set them in `harness_agent.spec.env_vars` in a managed repository workflow, in t
 environment for local `ms-tau`, or through explicit `TauSDKSettings` fields in a Python host. They
 apply to all sessions in that process; neither Agent Card skills nor prompt text removes tools.
 
+The accepted, pending job-hosted batch entry point uses these same two settings. It must not
+start Main Sequence MCP or add coding tools when the corresponding source is excluded. The table
+below describes the currently implemented service and local modes; batch behavior for A2A-only
+Task controls requires an actual Task context and is specified by ADR 0015.
+
 | Exclude base tools | Exclude Main Sequence MCP | Model-facing sources |
 | --- | --- | --- |
 | `false` | `false` | Coding tools, Main Sequence MCP, project extension tools, A2A Task controls. |