[release] v0.115.2

STATUS-round7.md

@@ -0,0 +1,48 @@
+# Round 7 status
+
+Branch: `feat/session-durable-approvals`
+
+Implemented as seven buildable commits after `5700408966`:
+
+1. Cross-reader interaction events bypass the general refetch throttle, then refetch and reconcile
+   settled rows into mounted transcripts.
+2. Held messages remain visible during gates; recoverable Sends retry the durable continuation.
+3. A terminal server transcript clears the desktop approval dock even if the row cache is stale.
+4. Approval response and recovery state is scoped to the interaction that produced it.
+5. Initial and background transcript hydration replay against fresh interaction rows.
+6. Dispatcher and inline router fallback share bounded reference resolution (latest turn, then stream).
+7. Replayed terminal records release the held queue after a completed continuation.
+
+## Browser re-check
+
+- Open one pending approval in two desktop tabs. Answer in tab B. Tab A must leave the actionable
+  "Needs your approval" state within one second without a second click, then clear after the
+  continuation's terminal record.
+- Repeat with mobile answering and desktop observing. The desktop result must match the two-desktop
+  case.
+- While a gate is open, send a message. A visible `1 queued message · waits for your answer` card
+  must appear immediately on desktop and mobile.
+- Force a recoverable approval response, then Send. The Send must redeliver the saved continuation,
+  keep the typed message visible in the held queue, and must not start a competing fresh turn or
+  create a `continuation_resumed` failure bubble.
+- After that continuation writes its terminal record, the approval dock must close and the held
+  message must leave the queue and run exactly once as the next turn.
+- After any recoverable interaction, start a new approval whose continuation succeeds. The new card
+  must show ordinary pending/answered copy, never inherited "retry needed" copy.
+- Reload a session whose interaction row is `responded` or `resolved`. No actionable approval card
+  may reappear.
+- Exercise a legacy/reference-less gate through the inline fallback composition. The continuation
+  must resolve the newest turn's workflow reference (or the stream fallback) and invoke normally.
+
+## Automated verification
+
+- `@agenta/chat`: 648 passed.
+- `@agenta/oss`: 429 passed, 1 skipped.
+- `@agenta/entities`: 1,480 unit tests passed; 31 integration tests skipped because the required
+  API/auth environment was not configured.
+- `@agenta/mobile`: 147 passed.
+- `@agenta/sessions`: 71 passed.
+- Chat, OSS, entities, and mobile typechecks passed.
+- Monorepo frontend lint passed (four pre-existing mobile hook warnings remain).
+- API sessions: 706 passed.
+- Ruff 0.15.12 format check: 1,491 files formatted; Ruff check passed.

api/entrypoints/routers.py

@@ -1,6 +1,7 @@
 from contextlib import asynccontextmanager
 import asyncio
 import time
+from uuid import UUID
 
 import agenta as ag
 from fastapi import FastAPI
@@ -95,6 +96,7 @@
 from oss.src.core.folders.service import FoldersService
 from oss.src.core.workflows.service import WorkflowsService
 from oss.src.core.workflows.service import SimpleWorkflowsService
+from oss.src.core.workflows.dtos import WorkflowServiceRequest
 from oss.src.core.workflows.static_catalog import StaticWorkflowCatalog
 from oss.src.core.evaluators.service import EvaluatorsService
 from oss.src.core.evaluators.service import SimpleEvaluatorsService
@@ -185,6 +187,9 @@
 from oss.src.dbs.postgres.sessions.commands.dbes import SessionCommandDBE  # noqa: F401
 from oss.src.dbs.postgres.sessions.commands.dao import SessionCommandsDAO
 from oss.src.dbs.postgres.sessions.executions.dao import SessionExecutionsDAO
+from oss.src.dbs.postgres.sessions.inputs.dbes import SessionInputDBE  # noqa: F401
+from oss.src.dbs.postgres.sessions.inputs.dao import SessionInputsDAO
+from oss.src.core.sessions.inputs.service import SessionInputsService
 from oss.src.core.sessions.commands.service import SessionCommandsService
 from oss.src.dbs.http.sessions.control_delivery_direct import DirectControlDelivery
 from oss.src.tasks.asyncio.sessions.orphan_sweep import orphan_sweep_loop
@@ -602,6 +607,7 @@ async def lifespan(*args, **kwargs):
 session_turns_dao = SessionTurnsDAO(engine=_transactions_engine)
 session_commands_dao = SessionCommandsDAO(engine=_transactions_engine)
 session_executions_dao = SessionExecutionsDAO(engine=_transactions_engine)
+session_inputs_dao = SessionInputsDAO(engine=_transactions_engine)
 
 connections_dao = ConnectionsDAO(engine=_transactions_engine)
 mounts_dao = MountsDAO(engine=_transactions_engine)
@@ -868,11 +874,12 @@ async def lifespan(*args, **kwargs):
 
 # Detached workflow start: hand the run to the runner and return on the started handshake
 # (no awaiting the run). Shared by both detached consumers (triggers + interactions respond).
-async def _dispatch_detached_run(*, project_id, user_id, request) -> str:
+async def _dispatch_detached_run(*, project_id, user_id, request, run_id=None) -> str:
     result = await workflows_service.invoke_workflow_detached(
         project_id=project_id,
         user_id=user_id,
         request=request,
+        run_id=run_id,
     )
     return result.run_id
 
@@ -891,6 +898,10 @@ async def _dispatch_detached_run(*, project_id, user_id, request) -> str:
     workflows_service=workflows_service,
     interactions_service=interactions_service,
     records_service=records_service,
+    # Read-only: the resume's reference fallback, for a gate row whose own `data.references` is
+    # empty. Without it the invoke has nothing to resolve a service URL from.
+    turns_service=session_turns_service,
+    streams_service=session_streams_service,
     dispatch_fn=_dispatch_detached_run,
 )
 
@@ -1148,8 +1159,37 @@ async def _dispatch_detached_run(*, project_id, user_id, request) -> str:
     streams_service=session_streams_service,
     interactions_service=interactions_service,
     lock_engine=_lock_engine,
-    delivery=DirectControlDelivery(),
+    delivery=DirectControlDelivery(
+        continue_interaction=lambda command: _interactions_dispatcher.respond_many(
+            project_id=command.project_id,
+            user_id=command.created_by_id,
+            interaction_answers=[
+                (UUID(item["interaction_id"]), item["answer"])
+                for item in command.data["answers"]
+            ],
+            control_command_id=command.id,
+            continuation_execution_id=command.target_turn_id,
+        ),
+        continue_input=lambda command: workflows_service.invoke_workflow_detached(
+            project_id=command.project_id,
+            user_id=command.created_by_id,
+            request=WorkflowServiceRequest.model_validate(command.data["request"]),
+            run_id=command.target_turn_id,
+            control_command_id=command.id,
+        ),
+    ),
+    executions_dao=session_executions_dao,
+    inputs_dao=session_inputs_dao,
+)
+session_inputs_service = SessionInputsService(
+    inputs_dao=session_inputs_dao,
+    interactions_dao=interactions_dao,
+    streams_service=session_streams_service,
     executions_dao=session_executions_dao,
+    continuation_resumer=session_commands_service.resume_recoverable_continuation,
+)
+workflows_service.set_session_continuation_resumer(
+    session_commands_service.resume_recoverable_continuation
 )
 
 sessions = SessionsRouter(
@@ -1163,6 +1203,7 @@ async def _dispatch_detached_run(*, project_id, user_id, request) -> str:
     turns_service=session_turns_service,
     sessions_service=sessions_service,
     commands_service=session_commands_service,
+    inputs_service=session_inputs_service,
     respond_task=_interactions_worker.respond_interaction,
     interactions_dispatcher=_interactions_dispatcher,
 )

api/entrypoints/worker_streams.py

@@ -35,6 +35,7 @@
 from oss.src.dbs.postgres.events.dao import EventsDAO
 from oss.src.dbs.postgres.secrets.dao import SecretsDAO
 from oss.src.dbs.postgres.sessions.interactions.dao import SessionInteractionsDAO
+from oss.src.dbs.postgres.sessions.executions.dao import SessionExecutionsDAO
 from oss.src.dbs.postgres.sessions.records.dao import RecordsDAO
 from oss.src.dbs.postgres.tracing.dao import TracingDAO
 from oss.src.dbs.postgres.webhooks.dao import WebhooksDAO
@@ -88,7 +89,10 @@ async def _build_spans_worker(redis_client: Redis) -> StreamConsumer:
 async def _build_records_worker(redis_client: Redis) -> StreamConsumer:
     watch_publisher = SessionsWatchPublisher(redis_client=redis_client)
     return RecordsWorker(
-        service=RecordsService(records_dao=RecordsDAO()),
+        service=RecordsService(
+            records_dao=RecordsDAO(),
+            executions_dao=SessionExecutionsDAO(),
+        ),
         redis_client=redis_client,
         stream_name=RECORD_STREAM_NAME,
         consumer_group="worker-records",

api/oss/databases/postgres/migrations/core_oss/versions/oss000000027_add_durable_interaction_continuations.py

@@ -0,0 +1,76 @@
+"""add durable interaction continuation executions
+
+Revision ID: oss000000027
+Revises: oss000000026
+Create Date: 2026-09-04 12:00:00.000000
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+revision: str = "oss000000027"
+down_revision: Union[str, None] = "oss000000026"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.drop_constraint("ck_session_commands_kind", "session_commands", type_="check")
+    op.create_check_constraint(
+        "ck_session_commands_kind",
+        "session_commands",
+        "kind IN ('cancel', 'continue_interaction')",
+    )
+
+    op.alter_column("session_executions", "terminal_outcome", nullable=True)
+    op.alter_column("session_executions", "settled_by", nullable=True)
+    op.alter_column("session_executions", "settled_at", nullable=True)
+    op.add_column(
+        "session_executions",
+        sa.Column("state", sa.String(), server_default="terminal", nullable=False),
+    )
+    op.add_column(
+        "session_executions",
+        sa.Column("parent_execution_id", sa.String(), nullable=True),
+    )
+    op.add_column(
+        "session_executions",
+        sa.Column("source_interaction_id", sa.UUID(as_uuid=True), nullable=True),
+    )
+    op.add_column(
+        "session_executions",
+        sa.Column("error", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+    )
+    op.alter_column(
+        "session_executions", "state", server_default="active", nullable=False
+    )
+    op.create_index(
+        "uq_session_executions_source_interaction",
+        "session_executions",
+        ["project_id", "source_interaction_id"],
+        unique=True,
+        postgresql_where=sa.text("source_interaction_id IS NOT NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(
+        "uq_session_executions_source_interaction", table_name="session_executions"
+    )
+    op.drop_column("session_executions", "error")
+    op.drop_column("session_executions", "source_interaction_id")
+    op.drop_column("session_executions", "parent_execution_id")
+    op.drop_column("session_executions", "state")
+    op.execute("DELETE FROM session_executions WHERE terminal_outcome IS NULL")
+    op.alter_column("session_executions", "settled_at", nullable=False)
+    op.alter_column("session_executions", "settled_by", nullable=False)
+    op.alter_column("session_executions", "terminal_outcome", nullable=False)
+
+    op.drop_constraint("ck_session_commands_kind", "session_commands", type_="check")
+    op.create_check_constraint(
+        "ck_session_commands_kind", "session_commands", "kind IN ('cancel')"
+    )

api/oss/databases/postgres/migrations/core_oss/versions/oss000000028_add_session_pending_inputs.py

@@ -0,0 +1,93 @@
+"""add durable session pending inputs
+
+Revision ID: oss000000028
+Revises: oss000000027
+Create Date: 2026-09-04 15:00:00.000000
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+revision: str = "oss000000028"
+down_revision: Union[str, None] = "oss000000027"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.drop_constraint("ck_session_commands_kind", "session_commands", type_="check")
+    op.create_check_constraint(
+        "ck_session_commands_kind",
+        "session_commands",
+        "kind IN ('cancel', 'continue_interaction', 'continue_input')",
+    )
+    op.create_table(
+        "session_inputs",
+        sa.Column("project_id", sa.UUID(as_uuid=True), nullable=False),
+        sa.Column("id", sa.UUID(as_uuid=True), nullable=False),
+        sa.Column("session_id", sa.String(), nullable=False),
+        sa.Column("content", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("position", sa.BigInteger(), nullable=False),
+        sa.Column("state", sa.String(), server_default="pending", nullable=False),
+        sa.Column("policy", sa.String(), nullable=False),
+        sa.Column("idempotency_key", sa.String(), nullable=False),
+        sa.Column("request_fingerprint", sa.String(length=64), nullable=False),
+        sa.Column("promoted_execution_id", sa.String(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            server_default=sa.func.current_timestamp(),
+            nullable=True,
+        ),
+        sa.Column("updated_at", sa.TIMESTAMP(timezone=True), nullable=True),
+        sa.Column("deleted_at", sa.TIMESTAMP(timezone=True), nullable=True),
+        sa.Column("created_by_id", sa.UUID(as_uuid=True), nullable=True),
+        sa.Column("updated_by_id", sa.UUID(as_uuid=True), nullable=True),
+        sa.Column("deleted_by_id", sa.UUID(as_uuid=True), nullable=True),
+        sa.CheckConstraint(
+            "state IN ('pending', 'promoted', 'removed')",
+            name="ck_session_inputs_state",
+        ),
+        sa.CheckConstraint(
+            "policy IN ('queue', 'steer')", name="ck_session_inputs_policy"
+        ),
+        sa.ForeignKeyConstraint(["project_id"], ["projects.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("project_id", "id"),
+    )
+    op.create_index("uq_session_inputs_id", "session_inputs", ["id"], unique=True)
+    op.create_index(
+        "uq_session_inputs_idempotency",
+        "session_inputs",
+        ["project_id", "session_id", "idempotency_key"],
+        unique=True,
+    )
+    op.create_index(
+        "uq_session_inputs_position",
+        "session_inputs",
+        ["project_id", "session_id", "position"],
+        unique=True,
+    )
+    op.create_index(
+        "ix_session_inputs_pending",
+        "session_inputs",
+        ["project_id", "session_id", "position"],
+        postgresql_where=sa.text("state = 'pending'"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_session_inputs_pending", table_name="session_inputs")
+    op.drop_index("uq_session_inputs_position", table_name="session_inputs")
+    op.drop_index("uq_session_inputs_idempotency", table_name="session_inputs")
+    op.drop_index("uq_session_inputs_id", table_name="session_inputs")
+    op.drop_table("session_inputs")
+    op.drop_constraint("ck_session_commands_kind", "session_commands", type_="check")
+    op.create_check_constraint(
+        "ck_session_commands_kind",
+        "session_commands",
+        "kind IN ('cancel', 'continue_interaction')",
+    )