# Premature completion and stale activity in `test_three`

The inspected session had stopped making requests because it had committed a
successful terminal result. It was not waiting for a model at collection time.
That result did not establish that the original request was fulfilled.

## Evidence and scope

Collection was read-only. No input was injected, no project source was changed,
and no inference, model load, service restart, or GPU deployment was performed.
The private evidence case is
`test-three-premature-completion-20261022T013213Z`: 78 initial files, 2,093,283
bytes, with source stability checks and SHA-256 hashes. Three supplemental
files preserve font bindings and the persisted agent view. Raw conversations,
tool outputs, and local runtime records are deliberately excluded from Git.

Initial manifest SHA-256:
`d7d851dbcfc3e24a923d7bd9815c16e8231a518956adf1559225edb6c6b0adcf`.
Supplemental manifest SHA-256:
`7e0a9cf823ee7cf384c80916fedf945f6b0b983e74c0394639153b9e5eb596a5`.

The terminal receipt identifies the loaded package as `omnius@1.0.893`, with
module SHA-256
`7a890817c1b4386b83e8f9ff2b59a387ffc8b1e1e45d77993734b24da8236105`.
The source baseline inspected for this repair is commit `196cecff`.

## Timeline

Times below are UTC on October 21–22, 2026; subtract seven hours for local PDT.

| Time | Observed event | Implication |
| --- | --- | --- |
| Oct 21 22:01:54 | Original detailed task committed an incomplete result. Its objective had generic effect criteria but no native semantic requirements. | The original request remained unfinished; generic observation, mutation, and verification are insufficient to establish reference parity. |
| Oct 21 23:16:34 | Last observed application source edit. | Later completion cannot be explained by newly implementing the missing features. |
| Oct 22 00:52:02 | A new run started with goal `continue until completion` and no objective contract. | The follow-up displaced the original objective instead of continuing it. |
| 00:55:20 | Parent delegated a read-only discovery brief with that narrowed goal. | The child was not evaluating the complete original acceptance requirements. |
| 00:56:17 | Child described the existing page as complete and reported default framework fonts. | A child verdict was mistaken for evidence of original requirement coverage. |
| 00:56:24 | Parent ran a successful production build. | Compilation was demonstrated; visual and reference requirements were not. The build receipt itself is genuine. |
| 00:57:55 | Parent committed a completed terminal receipt with no unresolved completion obligations. | A real terminal commit recorded an insufficiently grounded success. |
| 00:59:40 | Optional memory evaluators wrote a failed lifecycle state under the main session identity. | Background bookkeeping obscured the main lifecycle after its terminal result. |
| 01:28–01:33 | No active or queued inference was observed for this session. Persisted child view had `stage: completed`, `status: running`, and no completion timestamp. | The lingering activity row was stale; it did not establish live progress. |

## Causal defects

### Incomplete results disappeared from frontend outcome handling

`startTask` invoked its result callback only inside `if (result.completed)`.
Normal task admission cleared `lastTaskMeta`. After an ordinary incomplete
result, the frontend therefore retained null metadata. Its finalizer tested
`lastTaskMeta?.verified === false`; null did not satisfy that test, and the
work queue recorded completion. The same missing callback omitted the original
request and incomplete response from the in-memory conversation used for the
next admission review.

This is a confirmed production path, not an assumption that every normal
promise resolution means success. Both the callback placement and the null
comparison are needed to explain the failure.

### Idle continuation had no retained objective authority

The interaction router supports an active scope and a reviewed continuity
decision. Ordinary idle TUI admission did not supply that scope or carry its
continuity decision into an objective continuation. It passed the latest input
as `actualUserGoal` and created a fresh runner without an objective contract.
Only an explicit pending interruption had an identity-preserving path.

Consequently, conversational history and handoff prose could suggest earlier
work, but the runner lacked the original request, accepted steering, and
requirement identity as completion authority. Matching the word `continue`
would not repair this: the host must decide whether a message continues,
replaces, queries, or starts work against the real conversation scope.

### Completion accepted an empty requirement set

The original contract already expressed only broad effect categories. The
latest run had no contract at all. Canonical requirement coverage review was
conditional on native requirements being present, and generic ledger claims
were advisory. Completion readiness consequently received no semantic
obligations and reported ready.

An offline reproduction using the retained ledger and the production readiness
and terminal-record modules reproduced this result: zero obligations, zero
canonical claims, `intrinsicReady: true`, and a completed terminal record.
This does not make all heuristic summary claims authoritative, nor does an
audit ledger remaining `open` by itself prove an invalid terminal. The defect
is the missing human-origin requirement authority at admission and closeout.

A passing build cannot establish that a requested font, layout, reference
structure, live preview, or other distinct requirement was implemented. In
this case, inspected source still imported default framework fonts while the
reference-font assets existed unused. That is concrete counterevidence to the
unqualified completion claim.

### Internal helpers inherited the main lifecycle identity

The two memory evaluators created internal runners without independent session
identities or a background workload class. Non-subagent runners inherited
`OMNIUS_SESSION_ID` even when their artifact mode was internal. Their lifecycle
constructors recovered and persisted the main session file. Subsequent owner
checks rejected their terminal commits, and their failure projections then
overwrote that same lifecycle file.

The main immutable completion receipt survived. There is no evidence that the
evaluators changed its run-specific objective ledger or fulfilled the original
task. Their separate faults were lifecycle contamination, incorrect workload
priority, and misleading later failure state.

### Child view retirement was not an outcome

The saved child row combined a completed stage with a running lifecycle status.
Conversely, removing a view could manufacture a successful status for a child
that had never reported an outcome. Presentation must follow an explicit
terminal result or classify an unresolved retired view as interrupted; a
stage label and a teardown callback cannot certify completion.

## Repair and validation

The repair separates authored task authority, actual tool evidence, independent
review, and frontend outcome projection:

- TUI action admission reviews the complete original request and accepted
  corrections. A separate critic checks that the interpretation preserves that
  scope. Continuation routing receives the retained objective; unrelated new
  work receives a new objective. Native source bytes, conversation ownership,
  and predecessor ledger hashes are checked before reuse.
- Every returned runtime outcome reaches frontend settlement. Missing results,
  incomplete results, stopped work, and rejected promises cannot become queue
  success or successful learning records merely by resolving a promise.
- Required human-requirement admission is enforced in tool execution,
  completion readiness, and terminal commit. Generic build success and child
  summaries cannot substitute for the requested semantic comparison.
- Completion claims receive an independent, evidence-bound challenge against
  the full request and accepted changes. The worker receives specific questions
  about existing artifacts and missing results, and can answer with authentic
  evidence or repair the artifact. The actual reviewer verdict and exchange are
  retained as audit records, not promoted into tool-effect evidence.
- Identical rejected claims reuse their real challenge rather than launching
  another reviewer. Rewording alone has a bounded review budget, and repeated
  unchanged claims have a bounded feedback budget. Actual new evidence permits
  a fresh review. A supported result can pass immediately; cancellation,
  superseding input, and update/resume release temporary review reservations.
- Internal memory evaluators have independent sessions, lifecycle storage,
  background admission, and owned cancellation. All-failed evaluations preserve
  the local fallback rather than publishing a fabricated score.
- Child views settle from actual child outcomes. Teardown without a result
  means stopped, and late progress cannot overwrite a settled stage.

Regression fixtures are neutral and use CPU-only mock transports. They do not
continue the inspected application task or send requests to local inference
services.

A read-only probe of the new recovery selector against the actual `test_three`
queue and ledgers selected the original detailed request, not the later
`continue` goals. It identified exactly the two previously applied human
corrections whose objective lineage was lost. Their relationship is reviewed
before adoption; sharing a conversation does not automatically authorize it.
No task was resumed or modified by this probe.

The archived-ledger reproduction also confirms the changed boundary: the old
unstructured call remains compatible for advisory/internal use, while the TUI's
explicit required-admission policy produces a non-overridable missing-human-
requirements obligation and refuses success for that same actual ledger.

Final verification covered 623 distinct regression cases:

| Scope | Result |
| --- | --- |
| Core admission, evidence, independent challenges, continuation, interruption and update compatibility | 336 passed across 22 files |
| TUI admission and settlement, child views, background helpers, daemon admission Stop, and required web transport lifecycle cases | 196 passed across 19 files |
| Child execution and actual outcome publication | 28 passed |
| Requirement review and exact citation parsing | 63 passed |

The core count combines the broad run with a focused rerun after correcting a
pre-existing test expectation. A clean baseline reproduced the stale assertion:
the third request offered a bounded repair for missing mutation evidence. The
updated test checks that exact feedback, the missing effect, no invented
mutation, and one incomplete terminal result. No failing case was excluded.

All 11 workspaces rebuilt from cleared TypeScript build caches. The complete
publish bundle and fresh dependency lock passed the artifact audit. The packed
881-file development tarball also passed the tarball audit with zero warnings.
After the final rebuild, nine actual adapter/runner and standalone control
cases passed again against the compiled outputs; these reruns are not added to
the distinct-case count above.

This verifies the host protocol and the reproduced failure paths. Backend
responses in the regression suites are controlled fixtures, so this is not a
benchmark of an actual model's judgment. The inspected live process and its
application were not restarted, resumed, or altered, and no npm release was
published as part of this RCA.
