Skip to content

Commit 83fb214

Browse files
diagnostic: native OpenCode CLI smoke — free-tier compatibility via read:ask (Draft) (#199)
## Objective Resolve the false-negative native CLI smoke caused by OpenCode 1.19.3's free-tier incompatibility with `read: deny`, without granting uncontrolled filesystem or credential access. Confirmed with the real pinned runtime (same model/prompt, isolated `HOME`/XDG, empty workdir): - `read: allow` → control: canary read executes, model returns `OK` - `read: ask` → headless: `tool_use(read,error)`, `step_finish(reason=tool-calls)`, exit 0, ~4 s, canary never leaves the sandbox - `read: deny` → changes the outbound envelope; gateway answers pre-auth HTTP 403 Live gateway with a synthetic non-credential key (same CLI and config surface): `ask` → 401, `allow` → 401, `deny` → 403. The failed run [39972207857](https://github.com/AhmedMahmoud2222/DCIM/actions/runs/39972207857) shows `provider_error` / `forbidden` / 403 for exactly that reason. Upstream: <anomalyco/opencode#50627> ## Change (diagnostic-only, one branch/PR) 1. **`read: 'ask'`** in `.github/scripts/opencode_native_smoke.py`; every other tool of 1.19.3 stays `deny` (`edit`, `bash`, `webfetch`, `external_directory`, `task`, `todowrite`). The transcript guard rejects **any** `tool_use` event (completed or error), and a `tool-calls` termination is not accepted. The CLI is always started with `stdin=subprocess.DEVNULL`, so headless `ask` cannot block. 2. **Credential-free compatibility preflight**: new `--preflight` mode sends the identical fixed envelope with a fixed synthetic placeholder. It passes only when the gateway reaches authentication (HTTP 401) and fails closed with `reason=config_envelope_rejected` on a policy rejection (403). The preflight **never reads `OPENCODE_API_KEY`**; the workflow maps the secret only in the following step, after the preflight passes. Both sanitized artifacts are uploaded with `if: always()`. 3. **Artifact**: closed field list gains `mode` (`preflight`/`live`). A passing probe records `status=ok`, `reason=credential_rejected_as_expected`, `error_class=auth_error`, `error_status_code=401`. 4. **`docs/diagnostics/opencode-free-tier-compatibility.md`**: 403 false-negative evidence, headless `ask` results, reconciliation with the production read policy, the outdated `/zen/v1` catalog fallback and model-proxy compatibility risks, and the recommended controlled next experiment. No production code, registry/health flags, proxy, sandbox, publisher or branch protection is touched. ## Security evidence - **Headless `ask` is not auto-approved**: with a scripted read request and a canary file, the read ends in `error` and the canary content never appears in any recorded request. Same with an open idle stdin pipe. Control `allow` *does* leak the canary, proving the detector. - **No hang**: both stdin modes finish in ~4 s; the runner adds `DEVNULL`, a bounded timeout and `timed_out` classification. - **Envelope regression guard**: preflight passes only on 401 (`auth_error`); 403 becomes `config_envelope_rejected` before the secret step. Statically tested that the preflight step has no `secrets.` reference and that `resolve_key('preflight', …)` ignores an environment key. - **Isolation unchanged**: empty workdir, dedicated `HOME`/XDG trees under `RUNNER_TEMP`, no repository source in model context, `contents: read` only, no publish permissions, fixed model and prompt, no untrusted input, sanitized closed artifact. ## Production reconciliation Production (`opencode_sandbox.py agent_config()`) uses `read: {'*': 'allow', '*.env': 'deny', '*.env.*': 'deny', '*.env.example': 'allow'}` inside a sanitized worktree (untrusted configs and credential-like files dropped), with `external_directory: deny`, a separate OS user and a loopback-only proxy. The diagnostic's `read: ask` is envelope-compatible with the free tier and executes no reads headless; it is not equivalent to production `allow`. A diagnostic-specific 403 from `read: deny` **must not** be read as production inference being unavailable. ## Verification - `tests/deployment/test_opencode_native_smoke.py`: **76 passed, 11 skipped** locally (skips are the POSIX stub end-to-end tests; Windows `nt`); new preflight unit, workflow-policy and stub e2e coverage. - `tests/deployment/test_workflow_action_pins.py`: 4 passed; `check_workflows.py`: all checks passed. - Deployment/opencode regressions: 155 passed, 11 skipped, 15 subtests passed; only the 3 known pre-existing `ReportMessageTests` failures that also fail on pristine `origin/main`. - CI for this PR runs the full deployment suites, including the POSIX preflight e2e. This is a Draft diagnostic PR. **Do not merge and do not dispatch it with a real key** until the independent review is complete. No model is activated. @claude — independent security review requested as a comment on this PR (HEAD `6d6a0ab`). Focus: headless `read: ask` safety, credential-free preflight correctness and fail-closed behavior, secret isolation, and the production-reconciliation reasoning.
2 parents b0c8596 + e52d627 commit 83fb214

5 files changed

Lines changed: 1285 additions & 77 deletions

File tree

‎.github/scripts/opencode_native_smoke.py‎

Lines changed: 132 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
#!/usr/bin/env python3
2-
"""Native OpenCode CLI connectivity smoke test (smoke v1.0).
2+
"""Native OpenCode CLI connectivity smoke test (smoke v1.1).
33
44
Diagnostic experiment, not production activation. It complements the direct
55
synthetic diagnostic (model_health_diagnostic.py): that script builds direct
@@ -22,25 +22,41 @@
2222
HOME/XDG_* reserved under a dedicated directory, disconnected from the
2323
repository checkout (repo source is used only to install the runtime, never
2424
loaded into model context). Every tool the pinned runtime exposes is denied
25-
at the config level — read, edit, bash, webfetch, external_directory, task
26-
and todowrite — so a malfunctioning model cannot read or write anything
27-
regardless of what the transcript later shows.
25+
at the config level except `read`, which is set to `ask` (headless-safe) to
26+
maintain free-tier compatibility with the live opencode.ai gateway: `read:
27+
ask` is not auto-approved in headless mode (validated against the real pinned
28+
CLI, exits 0 with `tool_use(read,error)` and no file-content leakage) and
29+
does not change the request envelope to trigger a pre-auth 403. The
30+
transcript-level guard rejects any tool-use event (completed or error), and
31+
all other tools remain denied. The workflow maps `OPENCODE_API_KEY` only in
32+
the secret-bearing step, after a credential-free compatibility preflight has
33+
passed the same envelope with a synthetic key.
2834
2935
Recording: sanitized evidence only — CLI version, model, ok/failed status,
3036
reason class, provider HTTP status class, elapsed time and event counts.
3137
Never the API key, prompt, URLs, response bodies, headers or stderr text.
3238
33-
Usage: opencode_native_smoke.py RESULT_JSON BINARY AGENT_HOME WORKDIR TIMEOUT_MIN
39+
Usage: opencode_native_smoke.py [--preflight] RESULT_JSON BINARY AGENT_HOME WORKDIR TIMEOUT_MIN
3440
All three paths are canonicalized to absolute before any subprocess runs (the
3541
inference run changes cwd to the workdir; a relative binary path with a slash
3642
would otherwise resolve from the wrong directory). The binary must be the
3743
checked-out, lockfile-pinned runtime; it is not user-configurable.
3844
39-
Environment: OPENCODE_API_KEY (read once, never printed, never written).
40-
41-
Exit code: 0 only when the CLI version matches the pin, exited 0, produced a
42-
coherent pure-text life cycle ending in step_finish(reason="stop"), and the
43-
run was marked ok. Any other outcome writes a sanitized record and exits 1.
45+
Preflight mode (--preflight): credential-free synthetic compatibility probe.
46+
It sends the exact same fixed request envelope with a non-credential synthetic
47+
key and passes only when the gateway reaches authentication (HTTP 401) instead
48+
of rejecting the envelope at the policy layer (HTTP 403). It never reads
49+
OPENCODE_API_KEY. This is the regression guard for the free-tier envelope
50+
incompatibility that made the merged diagnostic a false negative, and it must
51+
pass before the workflow maps the real secret.
52+
53+
Environment: OPENCODE_API_KEY (live mode only; read once, never printed, never
54+
written; ignored entirely in preflight mode).
55+
56+
Exit code: 0 only when the CLI version matches the pin and the run met its
57+
mode's objective (live: coherent pure-text life cycle ending in
58+
step_finish(reason="stop"); preflight: auth reached with 401). Any other
59+
outcome writes a sanitized record and exits 1.
4460
"""
4561
from __future__ import annotations
4662

@@ -51,7 +67,7 @@
5167
import sys
5268
import time
5369

54-
SMOKE_VERSION = '1.0'
70+
SMOKE_VERSION = '1.1'
5571

5672
# One fixed model, in the CLI selector (provider/model) form. The selector is
5773
# consumed by the CLI; the bare provider ID is never sent anywhere by us.
@@ -60,6 +76,11 @@
6076
# The exact fixed synthetic prompt from the diagnostic mandate.
6177
PROMPT = 'Respond with exactly OK'
6278

79+
# Preflight mode uses this fixed non-credential placeholder. It is not a secret,
80+
# cannot authenticate, and proves only that the request envelope is accepted
81+
# (auth layer reached) rather than policy-rejected before auth.
82+
SYNTHETIC_KEY = 'synthetic-compatibility-probe-not-a-credential'
83+
6384
# Pinned runtime version; must match .github/opencode/runtime/package.json.
6485
EXPECTED_OPENCODE_VERSION = '1.19.3'
6586

@@ -71,24 +92,29 @@
7192
ENABLED_PROVIDERS = ('opencode',)
7293

7394
# The fixed prompt needs no tools, so every tool the pinned runtime exposes is
74-
# denied before the transcript can ever show one. All seven keys below are
75-
# recognized permission kinds in opencode-ai 1.19.3 (validated against the
76-
# pinned binary's embedded code: read/edit/bash/webfetch plus the delegation
77-
# kinds external_directory, task and todowrite). read is denied too (B3): the
78-
# CLI inherits OPENCODE_API_KEY, so a filesystem-read tool running at all would
79-
# be an unnecessary exposure surface.
95+
# denied before the transcript can ever show one — except `read`, which is
96+
# `ask` (see the compatibility note below). All seven keys are recognized
97+
# permission kinds in opencode-ai 1.19.3 (validated against the pinned binary's
98+
# embedded code: read/edit/bash/webfetch plus the delegation kinds
99+
# external_directory, task and todowrite).
80100
#
81-
# Validated envelope note (pinned binary, 2026-10-23): read:'deny' changes the
82-
# outbound tool envelope; on the live opencode.ai gateway a synthetic invalid
83-
# key then receives HTTP 403 (policy layer) where read:'allow' produces HTTP 401
84-
# (upstream Invalid credential). The success path step_start -> text ->
85-
# step_finish(reason="stop"), exit 0 was verified with this exact hardened
86-
# config against a scripted provider stub, so status 'ok' remains meaningful;
87-
# under this config a 'forbidden' class therefore reflects credential/policy
88-
# state — it must never be read as model unavailability.
101+
# IMPORTANT (diagnostic compatibility, 2026-10-23): on OpenCode 1.19.3 the
102+
# free-tier gateway treats `read: 'deny'` as changing the outbound tool envelope
103+
# and returns HTTP 403 (policy rejection) before auth; the run fails with
104+
# `provider_error`/`forbidden` even though the network/key path is valid.
105+
# Headless validation with the real pinned binary + scripted stub (no TTY)
106+
# shows `read: 'ask'` does NOT auto-approve filesystem reads and does NOT hang:
107+
# it produces `tool_use(read,error)` and stops (`step_finish(reason=tool-calls)`)
108+
# without leaking file contents, and exits 0. On the live gateway with a
109+
# synthetic key, `read: 'ask'` yields HTTP 401 (auth envelope reached), same as
110+
# `read: 'allow'`. The runner's transcript-level `unexpected_tool_use` check
111+
# and `evaluate()` still reject every tool-use event, completed or error;
112+
# `read` remains not 'allow'. This is a diagnostic-only change: it reconciles
113+
# the native-CLI smoke with free-tier compatibility without granting
114+
# uncontrolled filesystem access or expanding the credential surface.
89115
PERMISSIONS = {
90116
'edit': 'deny',
91-
'read': 'deny',
117+
'read': 'ask',
92118
'bash': 'deny',
93119
'webfetch': 'deny',
94120
'external_directory': 'deny',
@@ -106,7 +132,7 @@
106132
})
107133

108134
RESULT_KEYS = frozenset({
109-
'smoke_version', 'opencode_expected_version', 'opencode_version',
135+
'smoke_version', 'mode', 'opencode_expected_version', 'opencode_version',
110136
'model', 'status', 'reason', 'error_class', 'error_status_code',
111137
'exit_code', 'timed_out', 'event_count', 'stderr_lines', 'elapsed_ms',
112138
})
@@ -299,7 +325,38 @@ def evaluate(lines: list[str], exit_code: int | None, timed_out: bool
299325
return 'ok', '', error_class, error_status_code
300326

301327

302-
def _write_result(path: str, *, opencode_version: str | None, status: str, reason: str,
328+
def resolve_key(mode: str, environ: dict) -> str:
329+
"""Return the credential for this mode.
330+
331+
Preflight never reads OPENCODE_API_KEY: it always uses the fixed synthetic
332+
placeholder, so a real secret cannot be exposed by the credential-free
333+
compatibility step even if the workflow environment leaked it.
334+
"""
335+
if mode == 'preflight':
336+
return SYNTHETIC_KEY
337+
return environ.get('OPENCODE_API_KEY', '')
338+
339+
340+
def probe_verdict(status: str, reason: str, error_class: str | None,
341+
error_status_code: int | None) -> tuple[str, str]:
342+
"""Map one synthetic-key run to the preflight objective.
343+
344+
Compatible: the gateway answered 401 — the request envelope (config, tools,
345+
fixed model/prompt) reached authentication and only the fake credential was
346+
rejected. Anything else fails closed: 403 means the envelope was rejected
347+
at the policy layer (the exact free-tier regression this guards against),
348+
and any other outcome is unexpected for a synthetic key.
349+
"""
350+
if (status == 'failed' and reason == 'provider_error'
351+
and error_class == 'auth_error' and error_status_code == 401):
352+
return 'ok', 'credential_rejected_as_expected'
353+
if status == 'failed' and error_class == 'forbidden':
354+
return 'failed', 'config_envelope_rejected'
355+
return 'failed', 'unexpected_probe_outcome'
356+
357+
358+
def _write_result(path: str, *, mode: str = 'live', opencode_version: str | None,
359+
status: str, reason: str,
303360
error_class: str | None, error_status_code: int | None,
304361
exit_code: int | None, timed_out: bool, event_count: int,
305362
stderr_lines: int, elapsed_ms: int | None) -> dict:
@@ -312,6 +369,7 @@ def _write_result(path: str, *, opencode_version: str | None, status: str, reaso
312369
"""
313370
record = {
314371
'smoke_version': SMOKE_VERSION,
372+
'mode': mode,
315373
'opencode_expected_version': EXPECTED_OPENCODE_VERSION,
316374
'opencode_version': opencode_version,
317375
'model': MODEL,
@@ -334,7 +392,7 @@ def _write_result(path: str, *, opencode_version: str | None, status: str, reaso
334392
def _summary(record: dict) -> str:
335393
"""One sanitized status line for the run log (also artifact-consistent)."""
336394
return (' '.join([
337-
f'native smoke: model={record["model"]}',
395+
f"native smoke: mode={record.get('mode', 'live')} model={record['model']}",
338396
'status ok' if record['status'] == 'ok' else 'status failed',
339397
f"reason={record['reason'] or '-'}",
340398
f"error_class={record['error_class'] or '-'}",
@@ -344,11 +402,21 @@ def _summary(record: dict) -> str:
344402

345403

346404
def main(argv: list[str]) -> int:
347-
if len(argv) != 6:
348-
print('usage: opencode_native_smoke.py RESULT_JSON BINARY AGENT_HOME WORKDIR TIMEOUT_MIN',
349-
file=sys.stderr)
405+
args = list(argv[1:])
406+
preflight = bool(args) and args[0] == '--preflight'
407+
if preflight:
408+
args = args[1:]
409+
if len(args) != 5:
410+
print('usage: opencode_native_smoke.py [--preflight] RESULT_JSON BINARY '
411+
'AGENT_HOME WORKDIR TIMEOUT_MIN', file=sys.stderr)
412+
return 2
413+
mode = 'preflight' if preflight else 'live'
414+
result_path, binary, agent_home, workdir = args[0], args[1], args[2], args[3]
415+
try:
416+
timeout_min = int(args[4])
417+
except ValueError:
418+
print('timeout must be an integer number of minutes', file=sys.stderr)
350419
return 2
351-
result_path, binary, agent_home, workdir, timeout_min = argv[1], argv[2], argv[3], argv[4], int(argv[5])
352420

353421
# Canonicalize before any subprocess runs. The inference run later changes
354422
# cwd to the smoke workdir; a relative binary containing '/' would then be
@@ -357,16 +425,17 @@ def main(argv: list[str]) -> int:
357425
binary = os.path.abspath(binary)
358426
agent_home = os.path.abspath(agent_home)
359427
workdir = os.path.abspath(workdir)
360-
key = os.environ.get('OPENCODE_API_KEY', '')
428+
key = resolve_key(mode, os.environ)
361429

362430
start = time.monotonic()
363431

364432
if not key:
365-
_write_result(result_path, opencode_version=None, status='failed',
366-
reason='missing_api_key', error_class=None,
367-
error_status_code=None, exit_code=None, timed_out=False,
368-
event_count=0, stderr_lines=0, elapsed_ms=None)
369-
print('native smoke: status failed reason=missing_api_key')
433+
_write_result(result_path, mode=mode, opencode_version=None,
434+
status='failed', reason='missing_api_key',
435+
error_class=None, error_status_code=None, exit_code=None,
436+
timed_out=False, event_count=0, stderr_lines=0,
437+
elapsed_ms=None)
438+
print(f'native smoke: mode={mode} status failed reason=missing_api_key')
370439
return 1
371440

372441
# No credential below this line until the inference env is built: the
@@ -381,19 +450,20 @@ def main(argv: list[str]) -> int:
381450
version = read_version(binary, home_env)
382451
except (VersionProbeError, OSError, ValueError) as error:
383452
reason = _esc_reason(error) or 'opencode_version_unverified'
384-
_write_result(result_path, opencode_version=None, status='failed',
385-
reason=reason, error_class=None, error_status_code=None,
386-
exit_code=None, timed_out=False, event_count=0,
387-
stderr_lines=0, elapsed_ms=None)
388-
print(f'native smoke: status failed reason={reason}')
453+
_write_result(result_path, mode=mode, opencode_version=None,
454+
status='failed', reason=reason, error_class=None,
455+
error_status_code=None, exit_code=None, timed_out=False,
456+
event_count=0, stderr_lines=0, elapsed_ms=None)
457+
print(f'native smoke: mode={mode} status failed reason={reason}')
389458
return 1
390459

391460
if version != EXPECTED_OPENCODE_VERSION:
392-
_write_result(result_path, opencode_version=version, status='failed',
393-
reason='opencode_version_mismatch', error_class=None,
394-
error_status_code=None, exit_code=None, timed_out=False,
395-
event_count=0, stderr_lines=0, elapsed_ms=None)
396-
print('native smoke: status failed reason=opencode_version_mismatch')
461+
_write_result(result_path, mode=mode, opencode_version=version,
462+
status='failed', reason='opencode_version_mismatch',
463+
error_class=None, error_status_code=None, exit_code=None,
464+
timed_out=False, event_count=0, stderr_lines=0,
465+
elapsed_ms=None)
466+
print(f'native smoke: mode={mode} status failed reason=opencode_version_mismatch')
397467
return 1
398468

399469
env = build_child_env(agent_home, key)
@@ -404,7 +474,7 @@ def main(argv: list[str]) -> int:
404474
exit_code: int | None = None
405475
try:
406476
completed = subprocess.run(command, capture_output=True, text=True,
407-
env=env, cwd=workdir,
477+
env=env, cwd=workdir, stdin=subprocess.DEVNULL,
408478
timeout=timeout_min * 60 + 90)
409479
lines = completed.stdout.splitlines()
410480
exit_code = completed.returncode
@@ -415,17 +485,23 @@ def main(argv: list[str]) -> int:
415485
timed_out = True
416486
except OSError:
417487
elapsed_ms = int((time.monotonic() - start) * 1000)
418-
_write_result(result_path, opencode_version=version, status='failed',
419-
reason='cli_launch_error', error_class=None,
420-
error_status_code=None, exit_code=None, timed_out=False,
421-
event_count=0, stderr_lines=0, elapsed_ms=elapsed_ms)
422-
print('native smoke: status failed reason=cli_launch_error')
488+
_write_result(result_path, mode=mode, opencode_version=version,
489+
status='failed', reason='cli_launch_error',
490+
error_class=None, error_status_code=None, exit_code=None,
491+
timed_out=False, event_count=0, stderr_lines=0,
492+
elapsed_ms=elapsed_ms)
493+
print(f'native smoke: mode={mode} status failed reason=cli_launch_error')
423494
return 1
424495
elapsed_ms = int((time.monotonic() - start) * 1000)
425496

426497
status, reason, error_class, error_status_code = evaluate(
427498
lines, exit_code, timed_out)
428-
record = _write_result(result_path, opencode_version=version,
499+
if mode == 'preflight':
500+
# The objective is envelope compatibility, not inference: a synthetic
501+
# key must reach auth (401) rather than be policy-rejected (403).
502+
status, reason = probe_verdict(status, reason, error_class,
503+
error_status_code)
504+
record = _write_result(result_path, mode=mode, opencode_version=version,
429505
status=status, reason=reason, error_class=error_class,
430506
error_status_code=error_status_code,
431507
exit_code=exit_code, timed_out=timed_out,

‎.github/workflows/opencode-native-smoke.yml‎

Lines changed: 29 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
# OpenCode native CLI connectivity smoke (workflow v1.0) — diagnostic only.
1+
# OpenCode native CLI connectivity smoke (workflow v1.1) — diagnostic only.
22
#
33
# Why: the direct synthetic diagnostic (model_health_diagnostic.py, a custom
44
# Python HTTP client) reports HTTP 403 for the allowlisted free models on GitHub
@@ -31,6 +31,13 @@
3131
# to the protected smoke step through the opencode-agent environment secret
3232
# and is never printed, logged or uploaded; the evidence artifact records
3333
# status classes and elapsed time only.
34+
#
35+
# Credential-free preflight: the step before the secret-bearing step sends the
36+
# identical fixed request envelope with a synthetic non-credential key. It
37+
# passes only when the gateway reaches authentication (HTTP 401) instead of
38+
# rejecting the envelope at the policy layer (HTTP 403). Free tier rejects the
39+
# `read: deny` envelope this way, which made an earlier diagnostic a false
40+
# negative; the preflight fails closed before OPENCODE_API_KEY is mapped.
3441
name: OpenCode Native CLI Smoke
3542

3643
on:
@@ -91,6 +98,21 @@ jobs:
9198
test -f "${BIN}"
9299
test "$("${BIN}" --version)" = "${OPENCODE_VERSION}"
93100
101+
# Credential-free compatibility preflight. No secret is mapped into this
102+
# step; the runner script ignores OPENCODE_API_KEY in this mode and uses
103+
# a fixed synthetic placeholder. It passes only when the request envelope
104+
# reaches authentication (HTTP 401) — a 403 means the gateway rejected
105+
# the envelope at the policy layer (the free-tier read-deny regression).
106+
- name: Synthetic compatibility preflight (no credential)
107+
run: |
108+
set -euo pipefail
109+
python3 .github/scripts/opencode_native_smoke.py --preflight \
110+
"${RUNNER_TEMP}/smoke-preflight.json" \
111+
".github/opencode/runtime/node_modules/opencode-linux-x64/bin/opencode" \
112+
"${RUNNER_TEMP}/preflight-home" \
113+
"${RUNNER_TEMP}/preflight-work" \
114+
2
115+
94116
# The OPENCODE_API_KEY secret exists only inside this step. The runner
95117
# script re-verifies the version itself, runs the native CLI in the
96118
# isolated workdir/home, and exits nonzero on any failure.
@@ -104,14 +126,17 @@ jobs:
104126
".github/opencode/runtime/node_modules/opencode-linux-x64/bin/opencode" \
105127
"${RUNNER_TEMP}/smoke-home" \
106128
"${RUNNER_TEMP}/smoke-work" \
107-
10
129+
5
108130
109131
# Preserved regardless of the run outcome so a failure always leaves
110-
# sanitized evidence (CLI version, model, status, elapsed, error class).
132+
# sanitized evidence (CLI version, model, mode, status, elapsed, error
133+
# class) for both the credential-free preflight and the live run.
111134
- name: Upload sanitized smoke evidence
112135
if: always()
113136
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v4
114137
with:
115138
name: opencode-native-smoke
116-
path: ${{ runner.temp }}/smoke-result.json
139+
path: |
140+
${{ runner.temp }}/smoke-preflight.json
141+
${{ runner.temp }}/smoke-result.json
117142
retention-days: 1

0 commit comments

Comments
 (0)