SDD sdd-explore returns empty task result via OpenCode task delegation (sdd_task_result_empty) #3318

Activity

1. Nesbant commented on Aug 17, 2026

   

   Nesbant

   on Aug 17, 2026

   More actions

   New occurrence, same symptom, observed 2026-08-17.

   Observed evidence

   • gentle-ai: 2.2.4
   • OS/architecture: Linux, x86_64
   • Client/runtime: OpenCode task delegation with subagent_type: sdd-init
   • Artifact store: hybrid (OpenSpec + Engram)
   • Operation shape: three bounded sdd-init delegation attempts with the required Result Contract prompt
   • Outcomes: all three returned an empty task result; no status, phase result, or diagnostic envelope was delivered
   • Mutation outcome: no application source changes and no SDD init artifacts were created by those attempts
   • Preserved state: repository remained clean; the consumer workflow stopped before any dependent SDD phase

   Expected vs actual

   • Expected: sdd-init detects the stack, initializes hybrid persistence/testing capabilities/registry, and returns the structured init result.
   • Actual: the delegated actor completed without a user-visible result, so the orchestrator could not verify artifacts or advance safely.

   Minimal reproduction

   1. Start an SDD session with interactive mode, hybrid artifact store, automatic PR chaining, and an 800-line review budget.
   2. Delegate sdd-init through the OpenCode task mechanism with the project path and the standard SDD-init executor prompt.
   3. Observe an empty task result.
   4. Repeat with a changed corrective prompt and a third explicit bootstrap prompt; the result remains empty.

   This is observed evidence only; root cause is unconfirmed. The consumer was stopped fail-closed and no dependent phase was launched. Please associate this occurrence with the existing sdd_task_result_empty investigation.
2. gabuvi7 commented on Aug 17, 2026

   

   gabuvi7

   on Aug 17, 2026

   More actions

   New occurrence: sdd-design phase via OpenCode

   Observed evidence only; no root cause is asserted.

   Environment

   • Gentle AI: 2.3.0
   • OpenCode: 1.18.18
   • OS/architecture: Darwin arm64
   • Artifact store: OpenSpec

   Operation shape

   A dedicated sdd-design planning actor was asked to amend an existing design artifact and return the standard SDD Result Contract. The correction was bounded to one architecture decision and did not include implementation, provider, database, or delivery actions.

   Attempts and outcomes

   1. Initial launch returned gentle-ai.sdd-task-result-failure/v1 with code: sdd_task_result_empty and no valid task result.
   2. After the required status continuation and explicit user-authorized retry, the same phase returned the same typed empty-result failure again.

   The continuation omitted the launched change selector. Because multiple OpenSpec changes were active, native status returned nextRecommended: select-change with ambiguous change selection rather than the state of the launched change. That continuation behavior is separately tracked by #2790.

   Expected behavior

   The dedicated design actor should return a valid Result Contract and persist the requested design amendment, or return an actionable provider failure with a recovery path bound to the launched change.

   Actual behavior

   No valid result was delivered in either attempt. The requested design correction was not persisted. The typed contract prohibited further retry or phase advancement.

   Mutation and preserved-state evidence

   • No source, test, database, provider, staging, commit, push, PR, branch, or worktree mutation occurred.
   • The pre-existing design amendment remained preserved as the only uncommitted artifact.
   • Tasks and implementation state were not advanced.

   Minimal reproduction shape

   1. Use an OpenSpec repository with multiple active changes.
   2. Launch a dedicated sdd-design actor through OpenCode for an existing change.
   3. Observe sdd_task_result_empty.
   4. Execute the supplied continuation once and observe ambiguous change selection.
   5. With explicit authorization, retry the same bounded phase once.
   6. Observe the same typed empty-result failure and no requested artifact mutation.
3. Steven-Quihuire commented on Aug 17, 2026

   

   Steven-Quihuire

   on Aug 17, 2026

   More actions

   New occurrence: sdd-propose phase via OpenCode — observed 2026-08-17. Evidence only; no root cause asserted.

   Environment

   • Gentle AI: 2.3.0
   • OS/architecture: Linux x86_64
   • Client/runtime: OpenCode task delegation with an SDD propose phase agent
   • Artifact store: hybrid (OpenSpec + Engram)

   Operation shape

   Orchestrated SDD run (automatic mode) for a new change. The planning chain had already completed and persisted the exploration artifact in both stores (file + memory). The next phase (sdd-propose) was delegated with a full Result-Contract prompt: required input artifact references, scope boundaries, skills-to-load paths, Engram topic key, and the exact output-contract fields.

   Bounded attempts and outcomes

   • 1/1 attempt for sdd-propose: the phase agent ran, but the runtime received no valid task result; the harness returned the typed failure envelope instead of the SDD Result Contract.
   • Not retried: the envelope is explicitly terminal (Do not retry or advance SDD).

   Failure envelope (redacted)

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_result_empty","phase":"sdd-propose","summary":"sdd-propose returned no valid task result. Do not retry or advance SDD; inspect the existing artifact state and surface the terminal failure to the user."}

   Mutation outcome

   None. No proposal artifact was created on disk or in the memory store. The pre-existing exploration artifact remained intact and readable. The native status continuation command run afterwards reported all planning artifacts for the change as missing and downstream dependencies blocked — consistent with the phase having produced nothing.

   Expected vs actual

   • Expected: a Result Contract envelope (status, executive_summary, artifacts, next_recommended, risks, skill_resolution) and a persisted proposal artifact.
   • Actual: empty task result, terminal failure envelope, consumer SDD chain blocked at propose.

   Notable detail

   The immediately preceding sdd-explore delegation succeeded with identical topology (same client, same delegation mechanism, same prompt contract shape, same stores) minutes before, which suggests the failure is intermittent rather than prompt-shape-specific.

   Minimal reproduction

   1. Complete preflight and sdd-init for a repo (hybrid store).
   2. Complete any one SDD phase via OpenCode task delegation (it succeeds and persists artifacts).
   3. Delegate the next phase (sdd-propose) with the same Result-Contract prompt shape.
   4. Observe the typed sdd_task_result_empty envelope and no persisted artifacts for that phase.

   Preserved-state evidence

   Consumer state fully preserved: earlier-phase artifacts intact, no partial writes, no repository mutation by the failed phase. Reporting stop-point honored; no further SDD actions taken.
4. fsagastapolar commented on Aug 18, 2026

   

   fsagastapolar

   on Aug 18, 2026

   More actions

   Occurrence comment (scrubbed).

   Environment

   • gentle-ai: 2.4.0
   • OS/arch: Linux x86_64
   • Runtime/client: OpenCode, task delegation with subagent_type: sdd-explore
   • Artifact store: Engram (not OpenSpec)
   • Repository: private monorepo (details omitted)

   Reproduction

   • Completed SDD session preflight (auto mode, engram store, single-pr, 800-line budget).
   • sdd-init previously completed (artifacts intact).
   • Delegated sdd-explore for a new change via the OpenCode task tool with a standard read-only investigation brief requesting a Result Contract.
   • Delegation returned the typed failure envelope instead of the SDD Result Contract.
   • Retried once with an explicit "Result Contract must be the last JSON in your response" instruction -> identical failure.
   • Reproduced 2/2 attempts.

   Failure envelope (redacted)

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_result_empty","phase":"sdd-explore","summary":"sdd-explore returned no valid task result. Do not retry or advance SDD; inspect the existing artifact state and surface the terminal failure to the user."}

   Note: the continuation field pointed to gentle-ai sdd-status --json, but the session artifact store is Engram. The native SDD dispatcher only reads OpenSpec files and reported artifactStore: openspec with no change root, so the continuation was a no-op for this Engram-backed change (consistent with the orchestrator contract's Engram-vs-OpenSpec scoping).

   Expected vs actual

   • Expected: sdd-explore returns the Result Contract and persists the exploration artifact to Engram.
   • Actual: no result delivered; no Engram explore artifact written; pipeline blocked at the explore phase.

   Mutation outcome

   None. No change artifacts created. Preflight observation and prior sdd-init artifacts remain intact.

   Notes

   • Observed evidence only; root cause not confirmed.
   • No further SDD phase was attempted after the failure (no automatic retry beyond the one explicit re-launch, no phase advancement).
5. marioSoftmedic commented on Aug 20, 2026

   

   marioSoftmedic

   on Aug 20, 2026

   More actions

   Additional user-consented occurrence — sdd-design correction on released 2.4.0

   Observed evidence only; no root cause is asserted. Final privacy scan completed before duplicate lookup and submission.

   Environment

   • Gentle AI: 2.4.0
   • OpenCode: 1.18.19
   • OS/architecture: Darwin 15.7.8, arm64
   • Artifact store: repository-local OpenSpec
   • Execution mode: automatic

   Operation shape and bounded outcome

   • Precondition: one selected SDD change had completed proposal and specification artifacts.
   • Operation: the dedicated sdd-design correction actor was expected to amend/persist the design and return the standard SDD Result Contract.
   • Attempts after the terminal envelope: 0; no caller retry was performed.
   • Provider outcome: no valid task result was returned.
   • Failure envelope: gentle-ai.sdd-task-result-failure/v1, code sdd_task_result_empty, phase sdd-design.
   • The supplied read-only continuation was executed exactly once.
   • Preserved artifact state after continuation: proposal, specification, and design were present; tasks were absent.
   • Native status reported design done, nextRecommended: tasks, and no dispatcher blockers, while the typed transport envelope prohibited retry or downstream advancement. The consumer therefore stopped and did not launch tasks.

   Sanitized failure envelope

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_result_empty","phase":"sdd-design","summary":"sdd-design returned no valid task result. Do not retry or advance SDD; inspect the existing artifact state and surface the terminal failure to the user.","continuation":"gentle-ai sdd-status --cwd '<repo>' --json"}

   Safe reason identifier: sdd_task_result_empty.

   Expected behavior

   The design correction should persist its intended artifact state and return the documented Result Contract, or return a non-empty actionable failure whose recovery contract agrees with native status.

   Actual behavior

   The correction returned no valid phase result. Existing planning artifacts remained readable and native status considered design complete, but the typed terminal failure required the consumer to stop before tasks. This left valid-looking persisted design state without an admissible transition to the next phase.

   Minimal reproduction shape

   1. Use an OpenSpec-backed SDD change with proposal and specifications complete.
   2. Launch a dedicated sdd-design correction through OpenCode in automatic mode.
   3. Observe sdd_task_result_empty.
   4. Execute the supplied status continuation exactly once.
   5. Observe proposal/specification/design present, tasks absent, and native status recommending tasks without blockers.
   6. Honor the typed failure and do not retry or advance.

   Mutation and preserved-state evidence

   • Planning artifacts before tasks remain available.
   • No tasks artifact was created.
   • No application implementation, provider call, database action, commit, push, pull request, deployment, reset, or downstream SDD phase occurred after the terminal envelope.
   • The consumer state remains preserved and blocked pending a supported recovery.

   This comment excludes raw arguments, absolute paths, private project/change names, usernames, hostnames, credentials, environment values, source contents, diffs, and provider payloads.
6. lealsergio23 commented on Aug 21, 2026

   

   lealsergio23

   on Aug 21, 2026

   More actions

   New occurrence — sdd-explore via OpenCode

   Observed evidence only; root cause is unconfirmed.

   Environment

   • gentle-ai: 2.4.0
   • OS/architecture: macOS, arm64
   • Runtime/client: OpenCode automatic mode, task delegation
   • Artifact store: hybrid (OpenSpec + Engram)

   Operation and bounded outcome

   • Operation: delegated sdd-explore for a new bounded Framework change with the standard SDD Result Contract requirement.
   • Attempt 1: returned gentle-ai.sdd-task-result-failure/v1 with code: sdd_task_result_empty; no valid phase result.
   • The supplied native status continuation was executed exactly once.
   • One retry was explicitly authorized.
   • Attempt 2: returned the same typed failure; no valid phase result.
   • The native status continuation was executed exactly once again.

   Expected vs actual

   • Expected: a valid Explore Result Contract and a persisted exploration artifact, or an actionable provider failure.
   • Actual: an empty task result and terminal blocked envelope; native status showed no selected change and no phase artifacts.

   Failure evidence

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_result_empty","phase":"sdd-explore-cost-optimized","summary":"sdd-explore-cost-optimized returned no valid task result. Do not retry or advance SDD; inspect the existing artifact state and surface the terminal failure to the user."}

   Mutation and preserved-state evidence

   • No change artifact, implementation, commit, push, or downstream SDD phase was created by either attempt.
   • Repository and OpenSpec state remained unchanged; the consumer stopped before advancement.

   Minimal reproduction shape

   1. Start an automatic hybrid SDD session.
   2. Delegate sdd-explore through OpenCode for a new bounded change.
   3. Observe sdd_task_result_empty.
   4. Execute the supplied status continuation once.
   5. Authorize one bounded retry.
   6. Observe the same failure and no phase artifact.

   Safe identifiers: reason=sdd_task_result_empty; phase=sdd-explore-cost-optimized; revision=unavailable.,workdir:/Users/leal.sergio/projects/sharksia-delivery-hub
7. eacunar commented on Aug 25, 2026

   

   eacunar

   on Aug 25, 2026

   More actions

   Occurrence report — same observable defect class on gentle-ai 2.4.0 (stable), phase sdd-design, plus session-wide dispatch latch

   Observed behavior

   • An SDD phase delegated through the OpenCode task mechanism returned the typed failure envelope gentle-ai.sdd-task-result-failure/v1 with code sdd_task_result_empty for phase sdd-design: the sub-agent ran, but the runtime received no valid task result. Same envelope shape reported here for sdd-explore on 2.3.0.
   • A later SDD launch in the SAME session was refused without dispatching, with code sdd_task_dispatch_latched (verbatim redacted envelope below): no provider call, no sub-agent launch, no artifact write. Recovery required starting a new session. This matches the stale-envelope-replayed-without-dispatch dimension previously tracked under bug(sdd): sdd-verify returns empty result twice (sdd_task_result_empty) with nothing persisted (v2.3.0) #2950 (closed completed).
   • Recurrence on this installation: 3 incidents across separate sessions on different days — phase sdd-explore, then sdd-design, then sdd-design again. Every incident was cleared only by a fresh session.

   Failure envelopes (redacted)

   Original phase failure (reconstructed from session record; exact bytes lost to client compaction):

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","code":"sdd_task_result_empty","phase":"sdd-design"}

   Subsequent latched launch (captured verbatim):

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_dispatch_latched","phase":"sdd-archive","latchedPhase":"sdd-design","latchedCode":"sdd_task_result_empty","summary":"<phase> was not dispatched. Earlier in this session <latchedPhase> returned sdd_task_result_empty, and SDD launches stay latched afterwards so a failed phase is never silently retried and no later phase advances on top of it.","continuation":"gentle-ai sdd-status --cwd '<repo>' --json"}

   Environment

   • gentle-ai: 2.4.0 (stable; build string carries no prerelease tag)
   • OS/arch: Windows x86_64, PowerShell 5.1 host shell
   • Runtime/client: OpenCode, task delegation with subagent_type sdd-design / sdd-archive
   • Artifact store: hybrid (Engram + OpenSpec files)

   Context of the occurrences

   • First two incidents occurred during normal proposal→design planning on a private Java/Maven repository (details omitted for privacy).
   • The third incident surfaced when archiving a fully verified change after client-side context compaction: every pre-archive gate was green (tasks complete, verification report re-validated pass, review authority not applicable), and the archive launch hit the latch left by the earlier sdd-design empty result.

   Mutation outcome

   • None from any failed launch: no change artifacts created, no partial writes, prior artifact state intact at every incident. Work was continued manually outside the SDD pipeline under explicit user authorization.

   Expected vs actual

   • Expected: sdd-design returns the SDD Result Contract (status, executive_summary, artifacts, next_recommended, risks, skill_resolution) and persists its artifact.
   • Actual: empty result → terminal typed failure → every subsequent SDD launch in that session refuses to dispatch until a new session starts.

   Notes

   • Observed evidence only; root cause not confirmed. No retry loops were attempted, per the orchestrator contract.
   • Same-class issues bug(sdd): sdd-verify returns empty result twice (sdd_task_result_empty) with nothing persisted (v2.3.0) #2950, sdd-apply and sdd-verify return sdd_task_result_empty; sdd-verify failure mislabeled as sdd-apply #3278 and bug(sdd): sdd-explore returns empty result twice and leaves new phase blocked #2853 were closed as completed before v2.4.0 (released Aug 17) shipped, yet this class still reproduced on 2.4.0 stable — posting here as the open canonical tracker for the OpenCode-delegation empty-result defect rather than opening a duplicate.
8. Alan-TheGentleman commented on Aug 28, 2026

   

   Alan-TheGentleman

   on Aug 28, 2026

   Contributor

   More actions

   Not fixed by #3839, and worth saying so explicitly because this issue was listed as a satellite of #3814 while that work was in flight. That classification was made from the title and was wrong.

   #3814 fixed a real cause of empty results: phase agents resolved their own inputs through Engram only, so in an OpenSpec workspace an agent had no instruction naming a path and no resolvable tools. That produces an empty result because the agent never obtains its inputs.

   Your evidence rules that out here. You report that "the subagent runs, but the runtime receives no valid task result", with an OpenSpec store and a validated openspec/config.yaml. The agent executing and its output not reaching the runtime is a transport failure, which is a different root cause and one this wave did not touch — no commit in it changed OpenCode delegation or the task-result transport.

   #3818 gave the result contract a Go owner and a gentle-ai sdd-task-result command so runtimes without their own validating host can enforce it, but that is the classification surface, not the delivery path your report exercises.

   Leaving this open against the transport.
9. AncientGear commented on Aug 29, 2026

   

   AncientGear

   on Aug 29, 2026

   More actions

   New occurrence — sdd-propose via OpenCode on 2.3.0

   Observed evidence only; root cause is unconfirmed. Final privacy scan completed before submission.

   Environment

   • Gentle AI: 2.3.0
   • OpenCode: 1.15.11
   • OS/architecture: Linux x86_64
   • Artifact store: Engram
   • Execution mode: automatic

   Operation and bounded outcome

   • A prior sdd-explore phase completed and its Engram artifact remained readable.
   • sdd-propose was delegated through the OpenCode task mechanism with the standard Result Contract requirement.
   • Attempt 1 returned gentle-ai.sdd-task-result-failure/v1 with code sdd_task_result_empty; no proposal artifact was persisted.
   • The supplied status continuation was executed exactly once; it projected OpenSpec state and could not observe the Engram-backed change.
   • One retry was explicitly authorized by the user.
   • Attempt 2 returned the same typed failure; the continuation was executed exactly once again.
   • No dependent SDD phase was launched.

   Sanitized failure envelope

   {"schemaName":"gentle-ai.sdd-task-result-failure/v1","status":"blocked","code":"sdd_task_result_empty","phase":"sdd-propose-derby","summary":"sdd-propose returned no valid task result. Do not retry or advance SDD; inspect the existing artifact state and surface the terminal failure to the user.","continuation":"gentle-ai sdd-status --cwd <repo> --json"}

   Expected vs actual

   • Expected: sdd-propose returns the documented Result Contract and persists the proposal to the selected Engram store.
   • Actual: both bounded attempts returned an empty-result terminal envelope and no proposal artifact.

   Mutation and preserved-state evidence

   • Existing initialization and exploration artifacts remained intact and readable.
   • No proposal, specification, design, tasks, application changes, deployment, commit, push, or pull request was created by the failed phase.
   • Consumer state remains preserved and blocked at proposal.

   Minimal reproduction shape

   1. Complete SDD preflight with Engram storage and automatic execution.
   2. Complete sdd-init and sdd-explore.
   3. Delegate sdd-propose through OpenCode with the standard Result Contract.
   4. Observe sdd_task_result_empty and no Engram proposal artifact.
   5. Execute the supplied continuation once.
   6. With explicit user authorization, retry once and observe the same outcome.

   Safe identifier: reason=sdd_task_result_empty; phase sdd-propose-derby; revision unavailable.
10. Alan-TheGentleman commented on Sep 12, 2026

    

    Alan-TheGentleman

    on Sep 12, 2026

    Contributor

    More actions

    Investigation checkpoint: separate output delivery from the SDD latch

    Please complete the required issue-form/pre-flight information in place while retaining the original reproduction and comments. The plan below records how to resume this report. It is an investigation design, not an implemented transport fix or approval to relax dispatch safeguards.

    Boundaries to preserve

    An empty or malformed task result cannot prove success, phase credit, or readiness. It also cannot prove that the child wrote nothing. Keep output delivery, result classification, native artifact/attempt state, and the adapter's subsequent session latch as separate questions.

    Static inspection at 01e6fac15df169e8993e02549b9edcbd01abc0ee locates SDD output validation/latching in internal/assets/opencode/plugins/sdd-task-result-artifacts.ts. gentle-ai sdd-task-result classifies/renders results; that command by itself is not proof of an all-phase dispatch-authority gate. General workers such as those in #2609 bypass this SDD-only hook. The review transport is another lifecycle and must not be conflated with this one.

    Bounded investigation

    1. Capture one current, named OpenCode/Gentle AI/provider tuple reproducing the original failure. Preserve the exact selected phase and sanitized launch/completion metadata, distinguishing foreground completion from a background launch acknowledgement.
    2. Locate where a genuine child response or error stops reaching the parent: before generation, during child execution, or during host completion/output delivery. Preserve zero-work and retained-work cases separately. File existence is not an admissible substitute for a result.
    3. Compare the host's completion record with the plugin's actual input. A completed-empty result, an explicit provider/transport failure, and a malformed envelope are distinct observations. Do not infer an authentication/model/region cause without the corresponding evidence.
    4. Fix delivery at its demonstrated owner. Do not add a Gentle AI proxy or intercept general workers merely because the visible symptom is similar. Keep this issue linked to the demonstrated upstream correction when one is available, rather than asserting an unverified root fix.
    5. Evaluate any latch change independently against real phase-dispatch authority and failure controls. No automatic retry/advance, inferred task credit, or artifact-based unlocking is proposed. The hasRealWork style of unlatching in the inspected PR fix(opencode): don't latch the session when a failed SDD phase left real work behind #3062 does not repair output delivery and should not be used as a shortcut.

    Acceptance evidence to add

    Exercise real host rejection before generation, response loss after work, valid non-empty SDD output, empty/malformed SDD output, and background acknowledgement. Require truthful completion/error delivery and no invented task/evidence credit. Verify that general-worker and review-transport behavior is not changed by an SDD-specific fix.

    If latch semantics are later changed through a separate reviewed decision, first inventory every affected phase and the existing old-behavior pins. Update the relevant corpus expectations and prove execution using CI's actual driven bench invocation; declaration tests alone are not execution evidence. No reproduction, host run, or bench run was performed for this design.

    Resume here

    Complete the missing form information and attach the first bounded host-to-plugin trace before selecting code changes. #2855 and #4032 are related reports, not automatically proven instances of the same current cause. This AI-assisted draft records static findings and an evidence plan; it does not claim these issues are fixed or authorize implementation.
11. Alan-TheGentleman commented on Sep 12, 2026

    

    Alan-TheGentleman

    on Sep 12, 2026

    Contributor

    More actions

    Host-to-plugin trace completed on OpenCode 1.18.18

    A bounded real-host reproduction now separates the OpenCode transport from Gentle AI's result classifier and session latch.

    Controlled setup

    • OpenCode: 1.18.18
    • OpenCode tag commit: 31406ccc51b4bd2a4e1e086b2bcaa5f7f804f26d
    • Gentle AI baseline: 01e6fac15df169e8993e02549b9edcbd01abc0ee
    • The installed sdd-task-result-artifacts.ts was byte-identical to the repository asset.
    • All provider traffic was restricted to a disposable localhost endpoint. No credentials, prompts, raw model output, or private repository data were captured.

    Results

    Child outcome	Parent/plugin observation
    Valid non-empty text	One foreground before/after pair; completed task result; accepted.
    Successful result with no text parts	Parent-facing result collapsed to empty; Gentle AI emitted sdd_task_result_empty.
    Malformed nested task result	Gentle AI emitted sdd_task_result_malformed.
    Child HTTP 400 provider error	OpenCode emitted session.error, but the parent/plugin boundary still received the empty-result shape and Gentle AI emitted sdd_task_result_empty.
    Background task	The running acknowledgement was correctly ignored as nonterminal; terminal completion arrived later through synthetic parent-message injection, not a second tool.execute.after.

    The relevant OpenCode 1.18.18 TaskTool path returns the child's last text part or "" before rendering the foreground completed task envelope. Once that collapse has happened, the Gentle AI plugin cannot truthfully distinguish a legitimate no-text completion from provider-error/output-delivery loss.

    Ownership conclusion

    This reproduces the original transport symptom at the OpenCode TaskTool boundary. Changing Gentle AI's fail-closed classifier or session latch would hide the ambiguity rather than restore the missing result. No Gentle AI source patch was selected for this issue.

    The existing conforming upstream tracker is anomalyco/opencode#38866. The same controlled evidence has been added there rather than opening a duplicate.
12. dnlrsls

    added

    type:bugBug fixBug fix

    status:needs-reviewAwaiting maintainer reviewAwaiting maintainer review

    priority:highHigh priorityHigh priority

    on Sep 12, 2026
13. egdev6 commented on Sep 25, 2026

    

    egdev6

    on Sep 25, 2026

    SponsorContributor

    More actions

    Closing this as not planned because SDD has been removed from Gentle AI. This issue was cataloged as SDD-primary in the BA-23 cleanup, so the requested behavior belongs to a retired workflow and is no longer tracked as active backlog.

    Please reopen only with fresh evidence from the latest versions used, including exact Gentle AI/Pi versions or commit SHAs and relevant provider or client versions, showing that the same problem affects ODD or another current, non-SDD flow. Without that current-flow impact, we should not carry this as open work.
14. egdev6

    closed this as not plannedon Sep 25, 2026