mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-10-23 17:33:51 +02:00
DottaandPaperclip
505e1a5582
## Thinking Path > - Paperclip manages AI agents and their work. > - An agent workflow needs persistent facts and a safe way to transfer work. > - Creating a task for each phase splits the objective, discussion, workspace, and review policy. > - A case can retain the facts while one primary task moves between agents. > - Transfers must survive process failure and preserve private access, budgets, and completion gates. > - This pull request adds durable case handoffs, native case tools, and read-only case pages. > - Prompts describe the workflow. Existing task controls decide when work can run and finish. ## Linked Issues or Issue Description **Problem or motivation** Prompt-driven agent teams need a persistent record that can move through triage, implementation, verification, and correction. Ordinary reassignment does not provide a durable instruction, safe release barrier, or recoverable delivery receipt for an agent handing off its own running task. **Proposed solution** Extend standalone cases with one primary task, a descriptive phase, retained access sources, and a handoff ledger. Apply assignments after source execution and workspace settlement. Deliver each transfer through the existing durable wake queue. Provide `create_case`, `read_case`, `update_case`, and `handoff_case` in the native runner. Creation requires kickoff and explicit workflow text. An explicit handoff to `done` closes the case when normal task completion is accepted. **Alternatives considered** Do not add a workflow engine, filesystem queue, configured state graph, or one task per phase. The workflow document combines transition prose with an optional Mermaid `stateDiagram-v2` map. The server does not execute the diagram. The Pipelines experiment removed on master stays removed. **Roadmap alignment** This extends Agent Reviews and Approvals, Enforced Outcomes, Bounded Run Recovery, and Activity Log attribution. Existing approval, review, budget, privacy, workspace, and responsible-user rules remain authoritative. Related work: [ordinary handoff wake recovery](https://github.com/paperclipai/paperclip/pull/15019). This feature adds a separate persisted case-handoff receipt and release barrier. ## What Changed - Add case routing fields, retained access sources, durable handoff history, delivery leases, and replay-safe migrations. - Keep the same primary task across agent phases. Preserve each returning agent's own session and the task's workspace. - Fence outgoing mutations, wait for provider and workspace release, and recover delivery without duplicate task comments or runs. Recheck current assignment permissions as the original caller before applying a delayed transfer. Scope a run Stop to that run’s own handoff intents, so repeated old Stop requests preserve newer work. Cancelling terminal intent without a source run also requires fenced current task ownership, including native retries and preparation with an old checkout. For Cloud callers, revalidate current stack membership with an uncached Cloud RPC and derive owner elevation from the current managed setting. - Keep case reads, documents, assets, Audit, and live events inside retained task/project permissions. - Add native case creation/read/update/handoff tools. Store required workflow text and initial documents on the first task. Page oversized case facts and referenced document bodies through the dedicated tool with bounded UTF-8 JSON, current routing versions, snapshot conflicts, and current source authorization on every page. - Add read-only case lists and detail pages, task-style list controls, compact dotted field tables, linked handoff tasks, and case filters in Audit. - Add native/legacy integration tests, migration/restart tests, browser coverage, and bounded live receipt fixtures. Extend the trusted sandbox condition to cover the new subscription fixture profile. - Hide obsolete paused-agent warnings on completed or cancelled task threads. - Synchronize the company-switch settings test with React effects after a CI failure. Preserve its security assertions and production remount behavior. ## Verification The branch directly includes master `9ef434fe79`. The required `ci / verify` and `ci / e2e` gates pass on head `765fccd67c`. [Current-head CI](https://github.com/paperclipai/paperclip/actions/runs/39464348614) passes typecheck, build, tests, and all eight browser shards. Security checks pass. [Greptile gives this exact head 5/5](https://github.com/paperclipai/paperclip/pull/16959#issuecomment-6291156549), with no unresolved review threads. The optional Paperclip Review check remains queued because its assigned agent is paused. It is not a required branch check. No check result was overridden. Local workspace typecheck and build pass after the master merge, along with database migration checks, token gates, map checks, Storybook catalog checks, and the Copilot profile identity check. Standard builds refresh Runner vendor output. Focused checks pass 2,008 API/paging/context tests and 7 strict case protocol tests. The final commit changes one test fixture only; its ten tests, UI typecheck, and token gates pass. No production source changed in that commit. On current head `765fccd67c`, all **194 critical workflow tests** executed and passed with no skipped tests in those files: - 38 Stop/ownership tests, including board completion intent, native retries, stale Stop, and preparation with an old checkout. - 2 actual legacy process/HTTP handoff tests, including scratch failure, a closed-stdio child that continues writing, and recovery through a fresh worker after the process group stops. - 5 migration tests, including SQL column metadata, preserved null authority context, and all six prior-numbering receipts. - 3 process-settlement and 5 scratch tests. - 88 handoff-service, 18 heartbeat handoff, and 21 native case-tool integration tests. - 7 bounded case/document-read projection tests and 7 strict protocol-contract tests. The current CI checkout was `fed65d49`, merging `765fccd67c` into master `9ef434fe79`. Its new document regressions reconstruct exact Unicode/escaped bodies and revisions through real native authority and authenticated HTTP with generic API tools disabled. They cover case-owned, primary-task, and linked-task documents; routing on every page; stale document snapshots; access loss and unlinking; unrelated/foreign/private sources; system documents; and quarantined content. Active-task document tools retain their existing behavior. These are current-head test results from the first CI attempt; the browser-only retry did not rerun these suites. The full `64fdd3403f` CI failed one separate settings test: after a company switch, it observed an unsettled API-key draft. The production component and test were unchanged from prior green source. Production switches remount both keyed settings layers; the test directly reused an unkeyed view and used a timer tick instead of waiting for React effects. The final commit replaces that fixture synchronization with React `act`. The exact secret-clearing assertions and all timeouts remain unchanged. The original assertion failure remains recorded; no unchanged retry was used. The narrow unchanged baseline and fixed fixture each pass 10 tests. The upstream result-paging merge preserves case capture namespaces and current asset privacy. Its API integration suite executed 39 of 41 tests successfully, with two skipped; the optional assigned-result PRP integration test was skipped. Neither skipped suite is counted in the 194 critical tests or as live provider proof. All 361 upstream migration entries and SQL bodies remain unchanged. Six case migrations follow master as 0363–0368 with identical SQL hashes. Official Drizzle generators produced the combined metadata and five retained snapshots. Generation reports no schema changes, and the snapshot drift test passes. The earlier `ce361ae5d0` CI passed on attempt 1, including its then-current 179 critical tests. Fresh review later identified unusable document references with generic API tools disabled; the bounded document reads and ten additional authenticated HTTP tests address that finding. The full local `pnpm test:run` attempt was cancelled after this Mac exhausted PostgreSQL semaphore capacity; it is **not** counted as a pass. Later database attempts also stopped before assertions or skipped, including one sandbox socket denial. Two original stale-Stop regressions did reproduce the bug against the old source. A REST serialization assertion passed after two preserved database-startup failures. No test timeout was increased. All 194 assertions listed above executed and passed in current-head CI. The complete 385-file, 3,963-test UI shard also passed after the fixture repair. A configured-provider receipt workflow passed 13 backend checks across triage → implementation → verification → correction → done, using one task and four work runs. The saved receipt is revision 2 with total 6 USD; case and task both closed. The original canonical attempt remains failed because its browser assertion confused the terminal destination with completed-task tooltips. The corrected full browser verifier passed on the same retained database and original runs, with no additional provider calls. The last clean-build browser readback is on `6a86c54a53`; later changes affect recovery, authorization, bounded reads, and settlement. Accounted work cost is a $1.010574 rate-card estimate; provider billing and setup-probe usage are unavailable. Copilot profile 49 passed the unchanged seven-fixture private protocol pack (46/46 checks, no retries) and the product file-edit canary after master's completion-replay change. All 60 bound implementation hashes remain unchanged on the current source. Historical profile-47/48 identities and results remain intact. See the [profile-49 compatibility record](https://github.com/paperclipai/paperclip/blob/codex/persistent-case-handoffs/doc/plans/2026-10-20-copilot-completion-recovery-compatibility-v49.json). This is bounded compatibility evidence, not a fresh full matrix, installed-package product test, or Daytona rollout. Preserved CI failures and retries: - On `20662930ac`, Slack managed setup failed a five-second success assertion after reload. Its test/application path was unchanged from a prior green head. One unchanged-source retry passed all 25 tests in that shard; no source or timeout changed. - On `9402b4f17a`, two CI workers received shutdown signals at 15:24:19 UTC. Neither log had an assertion failure before interruption. One unchanged-source retry of each passed all Runner static checks and all 32 tests in browser shard 6; both aggregates passed. The next head, `7b4374edaf`, passed all CI without retries. - On `295f289b5a`, serialized shard 9 timed out during its first device-login test, then the next test found an active login lease. Direct login/test paths were unchanged from a prior green head. Cold import plus a timed-out async body using the next test's mutable actor/store is the supported fixture-race explanation; no request trace proves that sequence. The original failure remains recorded. One unchanged-source retry passed all 294 tests in 19 files, including all 41 device-login tests. No login source or timeout changed. The subsequent `ce361ae5d0` CI passed without retries. - On `64fdd3403f`, one company-switch settings assertion observed an unsettled draft. The final test-only commit uses React `act` without changing assertions, timeouts, or production code. On `765fccd67c`, all ten settings tests and the complete 385-file, 3,963-test UI shard passed. - On `765fccd67c`, browser shard 3 completed the split-handoff assertions, then cleanup received HTTP 500 from run cancellation after a one-second PostgreSQL row-lock timeout. The extra chat run was reporting completed work while teardown began. Cleanup stopped before restoring a global experiment flag, causing a later assertion to fail. Relevant production and test paths are unchanged from an earlier green commit. Stop's lock order is consistent, and no nested self-lock was found; the exact PostgreSQL blocker was not recorded. One unchanged-shard retry passed. The original failure, trace, and downstream flag failure remain recorded. No Stop implementation, cleanup assertion, or timeout changed. The retry supports intermittent cleanup contention; it does not identify the original blocking transaction. ## Risks - Local process transfers require host-owned PID/group absence. Missing or uncertain termination evidence keeps delivery pending, independently of scratch setup. - Handoff admission and task cancellation share execution ownership. New regression tests cover temporary holds, late source writes, and uncertain provider termination. - Retained private sources use an intersection of existing permissions. This intentionally fails closed when a source is missing or an existing task cannot preserve that boundary. - Migrations add tables and indexes. They preserve master history and can replay over prior feature installs. Migration 0368 adds nullable internal authorization provenance with no default or authority backfill. Historical transfers still awaiting release without this context fail closed; an operator must cancel them and request a new handoff. - Delayed Cloud handoffs depend on the current Cloud membership RPC. An unavailable, ambiguous, expired, or mismatched response holds the handoff for retry; it does not reuse cached authority or grant access. - Bounded reads reload and reauthorize the selected projection per page. Underlying work grows with the data size and number of pages. Changed data or routing requires restarting from offset zero without the old snapshot. - Phase names and workflow diagrams remain advisory. They do not satisfy review or approval gates. - This is a large, cross-cutting PR. The maintainer requested one PR for the whole feature; the commits separate data, runtime, UI, and qualification work. ## Model Used OpenAI Codex, GPT-6 family, with tool use, code execution, and delegated code review. The exact deployment model ID and context-window size were not exposed in the session. Live fixture agents used the explicitly configured provider model recorded in their test evidence. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip <noreply@paperclip.ing>
219 lines
13 KiB
Markdown
219 lines
13 KiB
Markdown
# Cases and structured work records — agent access
|
|
|
|
Product map: [Cases and structured work records](../feature-map/cases.md).
|
|
|
|
Feature ID: `cases`.
|
|
|
|
Review date: 2026-10-12. Source commit: `f981fa3cc10cb8663a87dec60345fbff46d54d0a`.
|
|
|
|
This is a source-reviewed baseline of representative operations and known gaps.
|
|
Each capability needs operation-level review before its entire scope can be
|
|
qualified. Scoped working-tree and live evidence is recorded below; it does not
|
|
qualify every operation in the baseline tables. Follow the [map contract](../README.md)
|
|
for format, permission checks, evidence and maintenance.
|
|
|
|
## `browse`
|
|
|
|
Capability ID: `cases/browse`.
|
|
|
|
Review: `baseline`.
|
|
|
|
API: `present` — representative operation IDs:
|
|
|
|
- `GET /api/companies/{companyId}/cases` (search/status/type/project filters,
|
|
`sortField=updated|created|title|status|type`, `sortDir=asc|desc`,
|
|
`groupBy=none|status|type|project`, and offset after authorization). Sorting and
|
|
group ordering apply to the full authorized result before pagination. Defaults
|
|
retain newest-updated ordering; status uses lifecycle order and project groups
|
|
use stable project IDs with unassigned cases last.
|
|
- `GET /api/companies/{companyId}/cases/types` (distinct types from accessible standalone cases).
|
|
|
|
Agent access: `available` — REST / native call_api; dedicated native `read_case`
|
|
for an authorized standalone case or the task's primary case; agent cases reference.
|
|
|
|
Native `read_case` has bounded UTF-8 JSON paging through the same authorized
|
|
case GET (`agentRead=true`). Small cases remain structured; large cases and
|
|
`section: "fields"` expose exact `readPage.text` chunks. Continuations require
|
|
`offsetBytes` and the returned `snapshot`; a changed case/task version or selected
|
|
projection returns 409. Every successful page retains handoff/task versions.
|
|
Generic `call_api` remains optional and is not needed to recover large fields.
|
|
`section: "document"` with `documentKey` reads a historical case-owned document;
|
|
adding `documentIssueId` selects a current primary or linked task document.
|
|
Bodies use the same bounded JSON pages without generic API tools. Each page
|
|
rechecks source-task access and linkage, excludes system/quarantined documents,
|
|
and binds the snapshot to the selected document identity, revision and body.
|
|
|
|
|
|
Policy: enableCases gate; company/case/task boundaries, active run where required,
|
|
source trust, and checked-out mutation ownership.
|
|
|
|
Evidence: `source-only` — [implementation](../../server/src/routes/cases.ts#L592) at the
|
|
reviewed commit above.
|
|
|
|
Verification: `not-run` — exercise a listed permitted operation with actual agent
|
|
credentials/run context; inspect its result and applicable persistence/attribution.
|
|
Assert the relevant denied actor, owner, company or mode from Policy. Review the
|
|
remaining operations before qualifying the whole capability.
|
|
|
|
Gaps: No dedicated production list_cases binding is required because the REST fallback
|
|
exists. Case pages are read-only; this does not remove agent mutation APIs.
|
|
|
|
## `structure`
|
|
|
|
Capability ID: `cases/structure`.
|
|
|
|
Review: `baseline`.
|
|
|
|
API: `present` — representative operation IDs:
|
|
|
|
- `POST /api/companies/{companyId}/cases`.
|
|
- `PATCH /api/cases/{id}`.
|
|
|
|
Agent access: `available` — REST / native call_api; native `create_case` creates a
|
|
fresh case and its first task through required `kickoff` and
|
|
`workflow_document_text`; new-case handoff API calls require the same text.
|
|
It is saved verbatim as ordinary task document `workflow` before delivery,
|
|
with create-only revision semantics and task mutation authority when binding.
|
|
Tool prompts, API schema descriptions and the case guide recommend both a Mermaid
|
|
`stateDiagram-v2` map and prose defining transition triggers, evidence, next
|
|
agents, human waits and correction/escalation rules. Diagram labels are advisory.
|
|
`initialDocuments` writes ordinary task documents before dispatch.
|
|
`update_case` changes title, summary and whole-object fields. Reads/updates
|
|
default to the primary workflow case and retain REST authorization. Standard
|
|
`read_document` / `write_document` operate on the active task; rollup references
|
|
identify other accessible tasks and their authenticated REST read paths. Native
|
|
`read_case` document selection can open those references without `call_api`.
|
|
|
|
Policy: enableCases gate; company/case/task boundaries, active run where required,
|
|
source trust, and checked-out mutation ownership.
|
|
|
|
Evidence: `source-only` — [implementation](../../server/src/routes/cases.ts#L592) at the
|
|
reviewed commit above.
|
|
|
|
Verification: `not-run` — exercise a listed permitted operation with actual agent
|
|
credentials/run context; inspect its result and applicable persistence/attribution.
|
|
Assert the relevant denied actor, owner, company or mode from Policy. Review the
|
|
remaining operations before qualifying the whole capability.
|
|
|
|
Gaps: Structured case data is supported; grouping/rendering is presentation, not a new
|
|
endpoint requirement.
|
|
|
|
Dedicated native CRUD is standard-mode/enableCases gated and has strict schemas;
|
|
fact updates cannot change status, routing or permissions. Update receipts are
|
|
run-scoped; creation always delegates to the principal-scoped
|
|
handoff receipt. Missing kickoff or workflow text is rejected before any writes.
|
|
Workflow text and other seeds share a bounded budget; extra seeds cannot replace
|
|
the workflow key. Later transfers use ordinary revision tools for edits. Documents use ordinary task revision checks. Historical
|
|
case-document REST/storage remains compatible, but separate native case-document
|
|
tools are retired. Deterministic production-boundary tests are in
|
|
[native case tools](../../server/src/services/native-runtime/native-case-tools.integration.test.ts)
|
|
and the [assembled native journey](../../server/src/__tests__/case-handoff-native.integration.test.ts);
|
|
the real-provider campaign `local-2026-10-19T19-57-00-135Z` also passed all 12
|
|
receipt workflow checks using the dedicated tools. This scoped evidence does not
|
|
qualify every generic case REST operation or subsequent tool replacements.
|
|
The newer create_case/initialDocuments/task-rollup implementation has its own
|
|
scoped deterministic verification in that record, including native creation and
|
|
authenticated HTTP replay/denial tests. The later campaign
|
|
`local-2026-10-19T21-39-45-440Z` passed all 13 live workflow checks using seeded
|
|
ordinary task documents and task-document reads/writes. Its returning builder
|
|
reused its own persisted session. Kickoff was initiated through the harness API;
|
|
provider-generated native `create_case` kickoff remains deterministically
|
|
verified rather than live-provider qualified. See the
|
|
[verification record](../../doc/plans/2026-10-19-persistent-case-handoffs.md).
|
|
|
|
The subsequent required workflow-document contract has authenticated HTTP,
|
|
real-database/API schema and assembled native-runner coverage. Receiving context
|
|
prioritizes its authorized reference, and fresh-session recovery keeps workflow
|
|
text reference-only as well. These controlled-provider tests verify required
|
|
creation, atomic task document persistence, replay and no automatic body injection;
|
|
the earlier live campaign predates this requirement and is not requalified.
|
|
|
|
## `history`
|
|
|
|
Capability ID: `cases/history`.
|
|
|
|
Review: `baseline`.
|
|
|
|
API: `present` — representative operation IDs:
|
|
|
|
- `GET /api/cases/{id}/events`.
|
|
- `GET /api/cases/{id}/documents/{key}/revisions`.
|
|
- `GET /api/issues/{id}/documents/{key}/revisions` for task-owned rollup documents.
|
|
|
|
Agent access: `available` — REST / native call_api.
|
|
|
|
Policy: enableCases gate; company/case/task boundaries, active run where required,
|
|
source trust, and checked-out mutation ownership.
|
|
|
|
Evidence: `source-only` — [implementation](../../server/src/routes/cases.ts#L592) at the
|
|
reviewed commit above.
|
|
|
|
Verification: `not-run` — exercise a listed permitted operation with actual agent
|
|
credentials/run context; inspect its result and applicable persistence/attribution.
|
|
Assert the relevant denied actor, owner, company or mode from Policy. Review the
|
|
remaining operations before qualifying the whole capability.
|
|
|
|
Gaps: Source-backed access only; case visibility and document locks still apply.
|
|
|
|
## `task-links`
|
|
|
|
Capability ID: `cases/task-links`.
|
|
|
|
Review: `baseline`.
|
|
|
|
API: `present` — representative operation IDs:
|
|
|
|
- `POST /api/cases/{id}/links`.
|
|
- `GET /api/issues/{issueId}/cases`.
|
|
|
|
Agent access: `available` — REST / native call_api.
|
|
|
|
Policy: enableCases gate; company/case/task boundaries, active run where required,
|
|
source trust, and checked-out mutation ownership.
|
|
|
|
Evidence: `source-only` — [implementation](../../server/src/routes/cases.ts#L592) at the
|
|
reviewed commit above.
|
|
|
|
Verification: `not-run` — exercise a listed permitted operation with actual agent
|
|
credentials/run context; inspect its result and applicable persistence/attribution.
|
|
Assert the relevant denied actor, owner, company or mode from Policy. Review the
|
|
remaining operations before qualifying the whole capability.
|
|
|
|
Gaps: Case/task association exists; source trust and issue visibility must be tested
|
|
with agent credentials.
|
|
|
|
## `handoffs`
|
|
|
|
Capability ID: `cases/handoffs`.
|
|
|
|
Review: `baseline`.
|
|
|
|
API: `present` — POST /api/companies/{companyId}/case-handoffs; GET /api/cases/{id}/handoffs; POST /api/cases/{id}/handoffs/{handoffId}/retry and /cancel.
|
|
|
|
Agent access: `available` — live native `handoff_case`, native API discovery/call_api, and authenticated agent REST. Initial kickoff creates or explicitly binds an ordinary task; subsequent calls reuse it.
|
|
|
|
Terminal destination: `to: "done"` records closure intent for an existing primary task, using case read/mutation and normal task mutation authority. It does not assign, wake, yield, or satisfy completion evidence. Normal accepted task completion atomically closes the case; a current execution's Stop, task cancellation, or reassignment invalidates the intent. Run-scoped Stop preserves newer work; cancelling terminal intent without a source run requires fenced current task ownership. Waiting on review or user input preserves it. Ordinary completion without a terminal intent leaves case status unchanged.
|
|
|
|
Retention: whole-company deletion removes case history before dependent tasks/agents. Individual agent purge returns `409 agent_case_history_retained` when handoffs reference the agent; termination preserves its attribution.
|
|
|
|
Policy: enableCases; standard mode; ordinary task creation/assignment authority; agents transfer only their own work; current case/task versions; company and retained task/project access intersection; existing review, Stop, budget, and workspace gates. Idempotency belongs to the authenticated principal, not a provider run. Cancellation remains available while the feature is disabled.
|
|
|
|
Delayed assignment rechecks the original caller's current assignment authority
|
|
using internal, server-derived provenance. The context is not returned by
|
|
history or recovery APIs. Missing historical provenance fails closed. After an
|
|
assignment is applied, delivery checks recipient admission rather than requiring
|
|
the former assignee to retain task access.
|
|
|
|
Cloud-user transfers confirm current stack membership through the uncached
|
|
tenant portfolio API before taking task locks. The short-lived proof is bound
|
|
to the original user and configured stack identity. Owner elevation also
|
|
requires the current managed feature setting. Missing membership, a viewer
|
|
role, an unavailable lookup, or a changed configuration holds the transfer.
|
|
No Cloud role or administrator grant is stored in the handoff context.
|
|
|
|
Evidence: `verified` — 2026-10-19 working-tree implementation. The [assembled native integration](../../server/src/__tests__/case-handoff-native.integration.test.ts) passed with actual runnerd and a controlled provider; [legacy HTTP integration](../../server/src/__tests__/case-handoff-legacy.integration.test.ts) and real-database authority/recovery tests passed. The later API-key campaign `local-2026-10-19T19-14-18-642Z` completed four real native runs and terminal case closure. The earlier subscription HTTP 429 remains recorded as a failed attempt; it was not regraded. See the [verification record](../../doc/plans/2026-10-19-persistent-case-handoffs.md).
|
|
|
|
Verification: `passed` — deterministic boundaries include native tool acceptance/yield, process settlement, same-task successor context, authenticated HTTP replay, denied private sources, version conflicts, review gates and restart/acknowledgment recovery. The configured-provider correction round trip passed using API credentials. The latest `local-2026-10-19T21-39-45-440Z` campaign passed 13 checks with task-owned documents, four nonoverlapping runs, same-task transfers, returning-builder session reuse and terminal case closure. The earlier `local-2026-10-19T21-32-43-612Z` campaign remains failed because the task revision API omitted stored writer-run attribution; the subsequent authorized projection fix was qualified by the new campaign. Compact context content/omission assertions retain separate deterministic evidence.
|
|
|
|
Gaps: Full provider qualification is recorded separately from source presence and deterministic service tests.
|