bug(sdd): tasks executor returns empty result on v2.2.4

[vitaminservice]

Pre-flight Checklist

• I have searched existing issues and this is not a duplicate
• I understand that PRs will be rejected if the linked issue does not have status:approved

📝 Bug Description

On the current native SDD workflow, the tasks executor can complete with an empty task result: no result contract, error detail, or task artifact is returned.

🔄 Steps to Reproduce

1. Prepare an SDD change with proposal, specification, and design artifacts.
2. Invoke the native SDD tasks executor through OpenCode.
3. Observe the completed task wrapper.

✅ Expected Behavior

The executor returns a non-empty result contract and persists/reports the task artifact, or returns a typed failure explaining why it could not do so.

❌ Actual Behavior

With Gentle AI 2.2.4, two bounded tasks-phase attempts completed with an empty task result. Neither attempt supplied a result contract or verifiable task artifact. The consumer workflow remained preserved at proposal/spec/design and did not advance to implementation.

Gentle AI Version

2.2.4

Operating System

Linux (Other)

AI Agent / Client

OpenCode

📋 Affected Area

Other

💡 Logs / Error Output

Additional Context

This is observed behavior, not a confirmed root cause. It reproduces after an upgrade and is narrower than the obsolete external-plugin report in #193. No secrets, source contents, private project identifiers, absolute paths, or environment values are included.

[rortizs]

Same empty-result symptom on v2.2.4, different phase and OS — adding this occurrence as evidence that the defect is neither phase-specific nor OS-specific.

My occurrence (OpenCode 1.18.10 on Darwin arm64, gentle-ai 2.2.4):

• Phase agent: sdd-init (profile-scoped subagent sdd-init-opencodego; the profile assigns this phase the model opencode-go/deepseek-v4-flash).
• Operation shape: orchestrator launched the init phase sub-agent via the task tool with a well-formed prompt (session context, artifact-store mode both, strict-TDD cache requirement, full result contract requested).
• Attempt 1 (task id ses_0467dd840ffeMJ84S0iPL78gDq): completed with an empty task-result envelope. Post-run verification: no openspec/ directory on disk (git status clean), no Engram records persisted (init report, skill-registry pointer, and testing-capabilities cache all absent).
• Attempt 2 (task id ses_0467cbd89ffeDSDuPCx27YM3bm): re-run with explicit corrective feedback naming the three exact failures (empty envelope, missing openspec/, missing persistence) — identical outcome: empty envelope, zero side effects.
• Expected: the phase writes the OpenSpec structure, persists three Engram records, and returns the full result contract. Actual: empty envelope plus no filesystem or memory mutations, twice.
• Consumer workflow preserved: the orchestrator gatekeeper stopped the automatic chain before any downstream phase; the failed runs mutated no repo state.
• Control: a general sub-agent completed successfully in the same session minutes earlier, so the task tool itself works — the empty completion appears scoped to this profile's SDD phase-agent binding.

Observed evidence only, root cause unknown. No secrets, absolute paths, private project identifiers, or environment values included.

[roxy-perez]

Adding one privacy-scrubbed occurrence.

• Environment: gentle-ai 2.2.4, macOS on Apple Silicon, OpenCode client.
• Operation shape: after completing SDD preflight, the orchestrator launched the sdd-init phase with hybrid artifacts, interactive execution, and a full result contract.
• Attempt: one bounded launch completed with an empty task-result envelope.
• Expected: init persistence plus the declared result contract.
• Actual: no result fields or artifacts were returned; openspec/ was absent and no persistent init record was found.
• Mutation outcome: no repository artifact or persistent init state was observed after the run.
• Minimal reproduction: complete SDD preflight, launch sdd-init, then inspect its result and expected init artifacts.
• Preserved state: no downstream planning or implementation phase ran.

This is observed behavior only; root cause is unknown.

[dnlrsls]

I reviewed the repository-owned path for this failure. OpenCode owns task execution and result serialization, so Gentle AI cannot guarantee that the provider never returns an empty <task_result>. It can, however, fail closed when one is received.

Recommended scope:

• classify empty and malformed task results for unsuffixed and profile-scoped sdd-* agents;
• return a typed phase failure and prevent downstream advancement;
• do not retry automatically, because hidden side effects cannot be ruled out safely;
• share the strict classifier with the existing review defense where practical, while preserving review behavior;
• add behavior-first regression coverage and a benchmark SDD friction journey proving typed failure, no artifact mutation, and no downstream launch.

This keeps the fix bounded to defensive handling rather than claiming to repair the upstream transport. If that scope is acceptable, please apply status:approved; I can take the implementation once the approval gate is open.

[zetser]

New occurrence of the same empty-result symptom, this time in the SDD design phase rather than the tasks phase.

Sanitized environment

• Gentle AI: 2.2.4
• OpenCode: 1.18.8
• OS/architecture: Linux x86_64
• Client: OpenCode

Operation shape
The orchestrator launched the native SDD design phase through the OpenCode task delegation path with a complete structured return contract, Engram persistence requirements, and pre-resolved skill paths. No source bytes, credentials, or private project identifiers were transported.

Bounded attempts and outcome

• Attempts: 2
• Provider task handle: ses_0406c447fffe2mZiQpGINGyvRy
• Attempt 1 completed with an empty <task_result> and no result contract.
• Attempt 2 resumed the same task with corrective feedback explicitly naming the empty response and missing artifact. It completed with the same empty <task_result>.
• No typed failure envelope, reason identifier, or revision identifier was returned.

Expected behavior
The phase should return the required structured result (status, executive_summary, artifacts, next_recommended, risks, and skill_resolution) and persist its design artifact, or return a typed failure explaining why it could not do so.

Actual behavior
The task wrapper reported completion, but its result was empty on both bounded attempts. No design artifact was persisted.

Mutation and preserved-state outcome
No application files, repository state, or downstream SDD phase were changed. The consumer workflow remained preserved at its proposal and specification artifacts and stopped before tasks or implementation.

Minimal reproduction

1. Prepare an SDD change with proposal and specification artifacts.
2. Launch the design phase through OpenCode with the full phase prompt and required structured return contract.
3. Observe a completed task wrapper with an empty <task_result>.
4. Resume the same task handle with corrective feedback.
5. Observe the same empty result and no design artifact.

This reports observed evidence only; the root cause is unknown. The occurrence differs from the existing tasks-phase report by phase, while reproducing the same completed-with-empty-result behavior.

[MarcosArispe]

I hit another occurrence of this issue.

What happened

1. A background general actor completed with an empty task_result.
2. I resumed the same task once with a read-only recovery prompt requesting its existing state.
3. The resumed task again completed with an empty task_result.

Expected

A completed actor should return a non-empty result, or a typed failure/incomplete envelope.

Actual

Both bounded attempts returned completed with an empty result, leaving the consumer unable to establish implementation or verification status safely.

State preservation

I stopped fail-closed after the second attempt. No downstream commit, push, PR, merge, or review occurred. The isolated consumer state remains preserved.

Minimal reproduction

1. Launch a background general actor that should return structured text.
2. Wait for completion.
3. If it returns an empty result, resume the same opaque task with a read-only status request.
4. Observe another completed state with an empty result.

[teba-isea]

New occurrence after the provider was already current and a managed OpenCode plugin update was applied.

• Sanitized environment: gentle-ai 2.2.4; macOS on Apple Silicon; OpenCode client.
• Operation shape: an interactive hybrid SDD change reached a native-ready apply state. The orchestrator acquired one bounded attempt for the first stacked work unit, then launched the sdd-apply agent with a structured-result contract and strict-TDD instructions.
• Attempt and outcome: the agent wrapper reported completed with an empty task result. No status, artifact list, test evidence, or apply-progress was returned. The native attempt was settled as failed; its safe opaque evidence revision was sha256:d11614974ea743311ddf47b109ff892710c957302eeb8ec975afe9f68310958b and it returned reason maintainer_decision.
• Expected: the agent returns the required structured result and persisted progress, or a typed failure.
• Actual: completed-with-empty-result prevented verification of implementation, test execution, cleanup, or mutations.
• Minimal reproduction: prepare a ready SDD change, acquire one apply attempt, launch sdd-apply through OpenCode, and observe its completed task result.
• Preserved state: no commit, push, PR, review, or verified implementation was produced. The consumer workflow stopped fail-closed.

Observed evidence only; root cause remains unconfirmed.

[CarlosSalega]

New privacy-scrubbed occurrence in the SDD tasks phase.

Sanitized environment

• Gentle AI: 2.2.4
• OpenCode: 1.18.5
• OS/architecture: Linux x86_64
• Client: OpenCode
• Receipt-driven development: disabled globally by explicit user choice

Operation shape
After completing the SDD preflight with interactive execution, OpenSpec artifacts, ask-before-splitting delivery, and a 400-line review budget, the orchestrator launched the sdd-tasks phase for a change that already had proposal, specification, and design artifacts. The prompt requested the complete phase result contract and a persisted tasks.md artifact. No secrets, source contents, absolute paths, private project names, usernames, hostnames, credentials, or environment values were transported.

Bounded attempts and outcomes

• Attempts: 2
• Attempt 1: task wrapper reported completed, but the task result was empty.
• Attempt 2: rerun with corrective feedback explicitly naming the empty result and missing artifact; task wrapper again reported completed with an empty result.
• No status, executive_summary, artifacts, next_recommended, risks, or skill_resolution fields were returned.
• No typed failure envelope, safe reason identifier, or revision identifier was returned.

Expected behavior
The phase returns the required non-empty result contract and persists the task artifact, or returns a typed failure explaining why it could not do so.

Actual behavior
Both bounded launches completed with an empty result. The expected tasks.md artifact was not created or readable.

Mutation and preserved-state outcome
No application files, commits, pushes, reviews, or downstream implementation phases were produced. The consumer workflow remains preserved at proposal/specification/design and stopped fail-closed.

Minimal reproduction

1. Prepare an SDD change with proposal, specification, and design artifacts.
2. Complete SDD preflight.
3. Launch the native sdd-tasks phase through OpenCode with a full structured-result contract.
4. Observe a completed wrapper with an empty task result and no task artifact.
5. Retry once with corrective feedback and observe the same outcome.

This is observed behavior only; the root cause is unknown. It reproduces the existing empty-result symptom in the same phase after the provider version is current.