22 Commits

Include renames

Author	SHA1	Message	Date
PierrunoYTandClaude Opus 5.5	13e2596b2e	chore: move repository references to Twigpine/zero (#1105) ... Update the Go module path, imports, install scripts, docs, workflows, packaging and action defaults from Gitlawb/zero to Twigpine/zero. The npm scope (already @twigpine/zero on main, with its @gitlawb/zero migration notes), LICENSE, action author, the OpenGateway provider and historical CHANGELOG links are unchanged. The X-AIMLAPI-Integration-Repo header keeps Gitlawb/zero: it is what AIMLAPI sees for attribution, so changing it needs a maintainer's yes. docs/INSTALL.md keeps `go install github.com/Gitlawb/zero/...`, because every tagged release so far declares that module path. The Homebrew formula comment names the Twigpine/homebrew-tap tap. Co-authored-by: Claude Opus 5.5 <[email protected]>	2026-10-17 07:13:21 +08:00
Vasanth T	6b5852dc18	fix(sandbox): say when a session's sandbox enforcement is degraded (#1082) ... * fix(sandbox): say when a session's sandbox enforcement is degraded Only `zero doctor` and `zero sandbox policy` reported a degraded sandbox, so a TUI session or a `zero exec` run went ahead with the native sandbox effectively off and nobody saw it. Both now say so once, before the first prompt or tool call, naming the downgrade reason: exec on stderr next to the grant migration notice, the TUI as a system notice when it opens. The line comes from the session's own engine through Backend.BuildPlan, the plan `zero sandbox policy` prints, so the notice and the command that explains it cannot describe two different sandboxes. Only the degraded level speaks: a disabled sandbox is the user's choice, and the unelevated Windows tier still enforces the write jail. Exec tests that expect a quiet stderr now compare against the notice this host prints under the default policy, since they run on the host's own backend and a Linux runner without the helper is degraded while macOS and Windows are not. Fixes #1041 * fix(sandbox): say so when the nesting markers skip wrapping With ZERO_SANDBOXED and ZERO_SANDBOX_BACKEND set, BuildCommandPlan passes every command through unwrapped on the word of an outer sandbox nothing verifies (#727). The notice came from Backend.BuildPlan, which does not model that path, so a native backend reported full enforcement and a session started with the markers ran every command unwrapped in silence. The engine's notice now mirrors the runner and names the markers and the unverified outer sandbox. A disabled sandbox still says nothing. hostSandboxNotice builds its expectation through the engine too, and the tests that pin the notice clear the markers so a suite run inside a Zero sandbox does not change their answer. * fix(tui): say the startup notices again when a session is resumed /resume rebuilds the transcript from an empty one, so the startup notices went with the old transcript and the session it switched to ran under a degraded sandbox without a word. The model keeps the notices and puts them back first, before the resume summary. Rewind and compaction stay in the same session and keep the notice in the scrollback above their divider. Also pins why the notice can be decided once, at startup: grants made during a session only open the network or add allow and deny paths, never the mode, and every mode but disabled already needs the platform sandbox, so no grant reaches a degraded command plan the startup notice missed, and a deny path the backend cannot enforce is refused instead. * fix(tui): say the startup notices again when /new opens a session /new cleared the transcript and added only its own note, so the new session started under a degraded sandbox without a word, the same gap /resume had. It now puts the notices back first, the way /resume does. /clear stays in the same session and, like rewind and compaction, keeps the notice in the scrollback above its divider. * fix(modelregistry): start no background refresh when the fetch is turned off The TUI and exec each started a goroutine that called RefreshModelsDevCache, which reads ZERO_DISABLE_MODELS_FETCH and the cache path when it runs. A test that turned the fetch off through t.Setenv could finish and have the setting restored before that goroutine ran, and the refresh would then fetch into the developer's real cache. StartModelsDevRefresh reads the setting before starting anything, so with the fetch off no refresh exists to outlive the test. * test(cli): keep the degraded-notice tests out of the developer's user state runExecWithSandbox and the TUI launch test left the sandbox grant store and the models.dev cache at their defaults, so they read the developer's sandbox-grants.json and could migrate it, and could refresh the real models cache. Both now run under isolateCLIUserState, and both join TestCLILaunchHelpersLeaveUserStateAlone so the isolation is pinned for each of them. * fix(cli): stop exec when the degraded-sandbox notice cannot be written The notice goes out before any tool runs, and before MCP servers and plugins start through the same sandbox, but a failed write to stderr was ignored, so the run went ahead with reduced isolation and no warning delivered. It now stops with exitCrash, the way the image and reasoning-effort notices in the same function already do.	2026-10-12 09:36:52 +08:00
Gaurav Bhatia	7f8e5f08bb	feat(notify): make permission-prompt alerts on by default and discoverable (#1001) ... * feat(notify): make permission-prompt alerts on by default and discoverable The notify system existed but was silent unless the user hand-edited config.json, with no UI surface to discover or change it. - resolver: fall back to mode=both, focusMode=unfocused when the notify block is missing or empty (Fixes #579) - tui: add /notify slash command with popup picker, mirroring /theme; explicit choices persist via config.SetNotify - cli: add `zero config notify` to read/update/reset the preference (--mode, --focus, --reset, --json) - config: add SetNotify writer using the existing atomic-write helper, validating against the same vocab the resolver accepts The TUI effectiveTUINotifyMode default (empty -> both) now matches the resolver. exec_test.go seeds notify.mode=off where a test asserted silent stderr, which the old empty-default implicitly provided. * fix(notify): apply review feedback from CodeRabbit - cli: omitted --mode/--focus flags now preserve the current resolved value instead of wiping it (--reset remains the only clearing path); aligns the CLI with the TUI's mode-only preservation behavior - tui: reject /notify inputs with more than two tokens instead of silently accepting them - tui: apply /notify choices to the live notifier via the new notify.Notifier.Configure, so the change takes effect on the next permission prompt in the same session (the previous message claimed this but only the persisted value was updated) - notify: add Notifier.Configure (mutex-guarded policy swap that preserves sinks, focus state, and the writer) - tests: mode-only/focus-only CLI preservation, live-notifier apply, trailing-argument rejection, Configure immediate-effect + sink retention * fix(notify): read cfg under the lock in Notify Configure (334c688) made cfg mutable at runtime, but Notify still read n.cfg.Mode before acquiring n.mu — a data race with a concurrent Configure. Move the mode check inside the critical section and copy cfg to a local for all reads. Regression test TestConfigureConcurrentWithNotify runs Configure concurrently with Notify; verified it reports DATA RACE on the unfixed code and passes after the fix (go test -race -count=5). * fix(notify): keep defaults out of the resolver; preserve the user's own values Addresses the maintainer review (Vasanthdev2004) on PR #1001. All three findings share one root cause: the resolved config was treated as if it were the user's choice. - resolver: no longer defaults notify.mode/focusMode. The TUI's effectiveTUINotifyMode already maps empty -> both on its own, so the permission-prompt alert still works out of the box, while headless `zero exec` stays byte-identical to base (no BEL/OSC-9 on stderr under -o json), the exec empty-stderr fixture is restored, and the ZERO_NOTIFY_WEBHOOK_URL sink is not armed by an implicit default. - cli: `zero config notify` seeds omitted fields from the user's own file (new config.UserNotify), never from the resolved view — a project config's mode:off can no longer be copied into the user's global config, and blank stays blank instead of pinning today's default as an explicit choice. --reset remains the only clearing path. - tui: /notify mode-only changes preserve the focus stored in the user's own file (blank stays blank); the /notify picker enumerates the full 4x3 mode x focus space so every valid pair is a row, the current pair is always preselected, and Enter can never commit a setting the user did not choose. State view reads the stored pair. - tests: the three regressions from the review — exec writes nothing to stderr on a clean run (fixture restored + resolver empty-default test), a ProjectConfigPath test proving project notify cannot leak into the user file, and Enter on an open picker from a pair outside the old curated list (off, always) keeps the setting unchanged. * fix(cli): zero config notify no longer requires a configured provider The command resolved the full config (providers included) before touching notification settings, so a fresh user with no provider hit ErrNoActiveProvider and could not read, set, or reset their notify preference — the exact first-run user this feature targets (CodeRabbit review, PR #1001). The command manages a user preference, so it now talks only to the user's own config file (config.UserNotify / config.SetNotify) and never runs config resolution. Display reports the user's stored values — a project config that overrides notify for one repo is not shown here, matching the write path's source-of-truth from the maintainer review. * fix(notify): separate live session policy from persisted user preference Addresses the review from jatmn (PR #1001). The three notification states — stored user file, resolved startup pair, live session — are distinct contracts and must not be conflated: - handleNotifyCommand now keeps two focus values per update: the LIVE focus (in-session, initialized from the resolved pair, so a project's focus rule keeps applying) feeds the notifier's Configure and the status line; the PERSISTED focus seeds from the user's own file (config.UserNotify), so a mode-only /notify writes the mode while the user's focus value — blank included — is preserved and project values never leak into the global file. - /notify list reports the live pair (model fields), not the stored file, which can legitimately disagree under a project override. - the /notify picker preselects the live pair; committing a row is an explicit choice, so Enter on the preselected row keeps the setting. - /notify list requires exactly one token, matching /theme, /effort, and /style (rejects "/notify list junk"). - shell completions: config gained a notify child with its flags (--mode/--focus/--reset/--json), plus a completion-tree assertion for both contexts so new CLI surfaces cannot go stale. - help/copy pass: the CLI help now describes the stored global notification preference controlling BOTH the completion and needs-input alerts, --reset as returning the TUI to its effective default (headless unconfigured stays silent), lists all three focus values in /notify usage, and drops the stale "resolver default" wording from effectiveTUINotifyMode and the command doc. - tests: contract-matrix coverage with the three states deliberately disagreeing (blank user file + project-resolved off/focused) asserting list/picker/preselection/Enter, mode-only and explicit-pair updates on both live and persisted sides, and restart precedence; the SA4006 lint hits are resolved by asserting the returned live model. lint-static: 0 issues. Affected suites green under -race; the only remaining local failures are the known environment flakes (TestRunAuthOpenRouterSavesMintedKey on macOS keychain under a sanitized env, and TestLoadProviderCommand* 5s subprocess timeouts under full-suite load — both pass in isolation and fail identically on clean origin/main here). * fix(notify): close the remaining review findings (isolation, races, fidelity) Addresses the third review round (PR #1001) as one boundary pass: - BTW isolation: /notify mutations and the picker are now behind the existing btwCommandUnavailable guard (like /theme), because the side conversation shares the parent's notifier pointer — an unblocked /notify off inside BTW reconfigured the parent and wrote the global file while only the side's display changed. /notify list stays available. Regression: side-conversation attempt then return, checking the parent's actual notification output and the stored preference. - Serialization: new UpdateNotify runs read-merge-write as ONE transaction under a cross-process advisory lock (flock/LockFileEx on a .lock file beside the config, credstore's pattern), so two concurrent partial updates (--mode off vs --focus always) cannot interleave and silently undo each other's explicit change. The CLI and the TUI's mode-only persistence both go through it; the TUI's stale pre-read of the stored focus is gone (the merge reads under the lock). Verified 0/30 lost updates driving the real binary with two concurrent processes per round; a goroutine-level regression test asserts both explicit fields survive. - Fidelity: notification writes now edit ONLY the notify member's bytes (setNotifyJSONObject, on the existing byte-preserving JSON editor), so unrelated values survive with their explicit presence intact — including tools.deferThreshold: 0 and MCP disabled: false, which the typed serializer's omitempty cannot round-trip, and keys FileConfig does not model at all. A reset removes the notify member instead of leaving a {} husk. - Startup recovery: Resolve's ErrNoActiveProvider partial result now carries the parsed non-provider fields (notify, sandbox, tools, ...), and the setup-recovery branch that clears the resolved config keeps the notify block — a stored explicit mode:off no longer resurrects alerts through the provider-recovery path. Regression: stale activeProvider + stored off/always through recovery asserts the launched TUI receives the opt-out, not the both/unfocused default. - docs nits: zero config --help now describes both alert classes; the two remaining "resolver default" wordings updated. lint-static: 0 issues. Affected packages green under -race (the only local failure is the known TestRunAuthOpenRouterSavesMintedKey macOS keychain flake, which fails identically on clean origin/main here). * fix(config): notify reset removes every duplicate notify member A hand-edited config may contain duplicate notify members (JSON decoders tolerate them; the last occurrence wins). The reset path removed only the final member, so an earlier block survived and became the effective preference on the next decode — `zero config notify --reset` reported success while the old value still applied (CodeRabbit review, PR #1001). Loop the removal until no notify member remains, mirroring setPetPreferenceJSON's duplicate handling. The replace path still edits the LAST member, which is the one a decoder treats as effective, so an earlier duplicate stays inert there. Regression TestSetNotifyResetRemovesEveryDuplicateNotifyMember verifies the reset-orphaned failure output on the pre-fix code and passes after; it also pins the no-op reset and the last-member-replace behavior. * fix(config): join UpdateNotify release error; restore main's test surface CodeRabbit pass on the rebased head, three findings: - UpdateNotify discarded the advisory-lock release error while every other writer joins it into the result (errors.Join). A failed unlock would leave later config updates blocked while the caller is told success. Now named-result + deferred Join, matching SetPet et al. - The rebase had resolved model_test.go by taking the pre-rebase file, which silently dropped every test upstream added or changed since the fork point (composer blink/cursor suite, beginRun run-details, scrim-preserves-semantic-colors, session payload, Termux burst, ...). Rebuilt the file from origin/main plus only this branch's own additions (TestEffectiveTUINotifyMode), so main's newer assertions are back: the stale scrim assertion now expects semantic ANSI preservation, and the removed TestBeginRunResetsSidebarHidden stays removed exactly as upstream had already replaced it with TestBeginRunKeepsRunDetailsClosed. * fix(tui): restore pickerTheme's transcript append; pin the picker failure path Rebase regression (Vasanthdev2004, PR #1001): resolving the choosePicker conflict attached the shared transcript-append line to the new pickerNotify case, so the pickerTheme case lost it — a theme choice whose preference could not be saved fell out with the session theme changed and nothing reported, while the /theme text path kept its line, so no test went red. Restore main's line in the pickerTheme case. New regression TestThemePickerAppendNoteOnFailedSave drives the exact reported shape: UserConfigPath under a regular file (the write must fail), a pickerTheme item, choosePicker, and the could-not-save note asserted in the transcript. Verified it fails on the pre-fix code with the reviewer's own repro output and passes after. Also restores the TestEffectiveTUINotifyMode comment to the post-review wording (the default lives in the TUI, not config.Resolve, so headless runs stay silent); the model_test.go rebuild had pulled the older pre-notify phrasing back in. * test(tui): restore the default palette after the picker regression test Vasanthdev2004 follow-up (PR #1001): handleThemeCommand applies its theme to the package-level zeroTheme, so TestThemePickerAppendNoteOnFailedSave left dracula installed and the next palette-sensitive test (TestFocusedPermissionSelectedRowUsesSelectionTintNotBrandChip) read dracula's selection tint instead of the default. One line, the package's existing convention: defer applyTheme(themeDark, true), as every other theme-committing test already does. Verified the tint test fails in sequence before the defer and the full internal/tui suite passes under -race after. * fix(tui): label the effective-default notify mode as "(default)" jatmn round (PR #1001): the TUI printed the effective default mode as a bare "both" while the new CLI labeled the same configuration "mode: (default)" — the two first-party surfaces contradicted each other, and a user could not tell whether "both" was stored or effective. Focus already labeled its built-in default ("unfocused (default)"); mode now mirrors it. The model keeps the RAW configured mode (notifyConfiguredMode) alongside the effective one, so state output can distinguish "both because the user chose both" from "both because nothing is configured" — clearing to the raw value when an explicit choice is made. effectiveModeLabel renders the (default) tag on the /notify list card and the /notify change line, the same wording the CLI read path uses. No defaults are persisted; resolver and headless behavior untouched. Regression TestNotifyStateLabelsEffectiveDefaultMode pins the contract: unconfigured shows "both (default)", explicit stored "both" renders bare, an explicit /notify bell choice renders bare in both the change line and later state. Verified it fails on the pre-fix code and passes after. * fix(config): one lock authority; full-replace across duplicate notify keys jatmn round (PR #1001), two findings plus one documented precedence: - UpdateNotify took a SECOND lock primitive over the same config.json.lock. On Windows its LockFileEx range did not overlap lockutil's, so notify writes could race provider/theme/credential/MCP writes and silently discard them; on every platform it also bypassed the established no-follow path checks and the bounded wait. Delete filelock_unix.go / filelock_windows.go entirely and use the existing lockConfigFileFn authority every other mutator already shares. New regression TestUpdateNotifyRacesExistingConfigMutatorWithoutLoss holds notify vs SetTheme and requires both acknowledged edits to survive; the real binary also races 30/30 clean cross-process on the shared lock. - setNotifyJSONObject replaced only the last duplicate notify member, but Go's decoder MERGES the fields of duplicate members into one struct, so a replacement omitting a field inherited it from an earlier duplicate ({"notify":{"mode":"off"},"notify":{"focusMode":"focused"}} + SetNotify({FocusMode:"always"}) left mode "off" effective). The nonempty path now removes every duplicate and inserts the replacement fresh — full replace semantics, nothing inherited. UpdateNotify's partial merge is unaffected (it seeds omitted fields before the edit). Regression TestSetNotifyReplacementInheritsNoFieldFromEarlierDuplicate, verified failing on the pre-fix editor and passing after. - zero config notify --reset combined with --mode/--focus now documents its precedence: --reset wins, explicit values are ignored (the help previously did not define the combination). * fix(config): replace single notify member in place; reserve wipe for duplicates Vasanthdev2004 review note (PR #1001, non-blocking): the duplicate-key fix ran remove-and-reinsert for EVERY notify write, including the ordinary single-member file — insertJSONMember appends after the last member, so every /notify toggle moved the notify key to the end of the config object and collapsed its formatting while everything around kept theirs. Nothing was lost (member order carries no meaning), but a byte-preserving write should not reformat what it need not touch. setNotifyJSONObject now counts notify members first: exactly one is a positional value replace (key stays where the user put it, surrounding bytes untouched); two or more keeps the remove-every-duplicate-and-insert path, where Go's field-merging decode would otherwise let an earlier block leak fields into the replacement. Regression TestSetNotifySingleMemberReplacedInPlace asserts exact bytes through an in-place replace, verified failing on the over-eager version and passing after; the duplicate regression and the whole config suite stay green.	2026-10-12 09:23:37 +08:00
Anandan	9e609c5242	feat(exec): default headless runs to the turn-budget ceiling (#1049) ... * feat(config): report whether the tool-turn budget was explicitly set ResolvedConfig.MaxTurns is ambiguous today: a configured 80 and the built-in default 80 are indistinguishable, so a caller that wants a different default cannot tell "user chose this" from "nobody set it". FileConfig now records at each merge gate (config files, provider command, ZERO_MAX_TURNS, CLI overrides) when a source supplies a positive maxTurns, and Resolve surfaces it as MaxTurnsSet. * feat(exec): default headless runs to the turn-budget ceiling The shared 80-turn default is sized for the TUI, where the user can say "continue" and the run resumes. Headless exec has nobody to do that, so benchmark evals truncated at 80 turns mid-implementation. An unset budget now resolves to MaxTurnsCeiling for exec only; any explicit source (flag, mode preset, ZERO_MAX_TURNS, config file) and exec-profile budgets keep their precedence. The TUI default is unchanged. * test(cli,config): cover the headless turn-budget default * refactor(cli): extract the headless turn-budget decision	2026-09-15 08:37:09 +08:00
Vasanth T	378d538e24	perf(agent): execution profiles with one-shot posture escalation (PR10b+PR10c) (#740) ... * perf(agent): execution profiles, --exec-profile, bench passthrough, TUI /profile (PR10b+10c) * fix(execprofile): harden profiles against review findings - fast escalates on critical-risk mutations, not high: the sandbox marks every shell command high before command analysis, so a high trigger spent the one-shot on the first go test of any task - escalation can now restore the provider-default effort a profile displaced (PostureEscalation.RestoreDefaultEffort; a plain empty target means leave untouched) - TUI /turns while a profile is active pins the budget: disarms the escalation turn target (mirroring exec's explicit --max-turns rule) and profile reverts use touched bits instead of value equality, so explicit choices survive even when they coincide with profile values - spec-draft runs get the same escalation policy as the main run instead of the displaced budget with no safety net - bench validates and canonicalizes --exec-profile before spawning: an unknown name previously produced an exit-0 report full of millisecond usage-error walls - turn summary prints exec-profile alongside mode; zero exec rejects an inline-empty --exec-profile=; balanced trace label documented and pinned as deliberate attribution * fix(execprofile): explicit effort choices disarm the escalation effort restore An explicit effort set AFTER profile selection could be cleared by a mid-run escalation (the effort analog of the /turns pin, introduced by RestoreDefaultEffort): TUI /effort and Ctrl+T now disarm the restore on a policy clone, and the spec-draft path only arms it when no explicit --spec-reasoning-effort governs the draft. * fix(execprofile): address review findings on the profile surfaces - --use-spec projects away a profile's self-correct knob instead of silently arming an option the draft runner ignores (the explicit --self-correct --use-spec combination is already a parse-time error) - RunTurnBench canonicalizes and validates ExecProfile at the library boundary, so a direct caller's casing/whitespace cannot fork report labels and an unknown name fails before anything runs - reverting a profile whose displaced budget was zero clears ZERO_MAX_TURNS (SetMaxTurnsEnv ignores zero, so sub-agents would have kept the removed profile's budget) - the TUI effort-disarm test fails instead of skipping when the catalog stops filling low effort * fix(tui): reconcile an active profile's effort fill on model switch The fill is per-model, not a session preference: fast selected on a model without low fills nothing, and switching to a model that supports it should behave like selecting the profile there; the reverse switch must not keep sending a level the destination does not support. Both switch paths (the /model command and the cross-provider picker) now re-derive the fill, leaving explicitly touched efforts alone and keeping the escalation's effort restore in step. Also: the revert-env test asserts key removal via LookupEnv, and applyProfileTurnBudget's pinned-budget parameter is named and documented as covering mode presets, not just the flag. * fix(tui): void profile effort bookkeeping when the model-switch drop erases it The /model path's pre-existing unsupported-effort drop ran before the profile reconciliation and left contradictory state behind: a dropped touched override kept blocking the profile from governing, and a dropped profile fill left a stale applied value with the effort restore still armed. The drop itself is load-bearing (the TUI run path forwards the effort to the provider unfiltered), so instead of preserving a known-unsupported level, the voided choice now resets the profile's effort bookkeeping and the reconcile re-derives from scratch. The whole sequence lives in one ring-parameterized helper driven by the switch target's authoritative ring, unit-tested against synthetic rings for both the void-then-refill arc and the supported-override survival. * fix(tui): only drop an explicit effort when the target ring is authoritative A nil ring meant both a catalog model with no effort controls and a live-discovered custom model the catalog cannot vouch for. The drop now requires an authoritative ring (a resolved catalog entry, whose ring may legitimately be empty); an unknown ring preserves an explicit preference, matching the cross-provider picker's behavior, while the profile's own fill still applies only where support is known.	2026-07-19 00:53:17 +05:30
euxaristia	635c93af51	fix(agent): raise default and deep-mode turn budgets (#650) ... * fix(agent): raise default and deep-mode turn budgets The default per-run tool-turn budget of 50 was still too low for larger multi-step tasks that span several files: agents hit the ceiling and stopped with a "remaining work" summary instead of finishing. Raise the default from 50 to 80. The "deep" preset also carried MaxTurns: 50, identical to the default, so its "larger turn budget" promise no longer held on the turn-budget axis. Raise it to 160 so deep runs get a genuinely larger budget again. Users can still override per-session with /turns or --max-turns (bounded by MaxTurnsCeiling). * test(cli): expect deep-mode MaxTurns=160 after budget raise	2026-07-13 21:54:48 +08:00
Anandan	f1502f0bfe	Add local control browser and terminal tools (#319) ... * Add local control browser and terminal tools Add configurable local browser, desktop, and terminal control helpers with packaged helper discovery for install and release flows. Improve sandbox scope classification for local control commands and shared temporary paths. Add structured browser actions, terminal session line input/key normalization/read support, and artifact capture for local-control outputs. Tested: GOCACHE=/tmp/zero-go-cache go test ./internal/localcontrol ./internal/tools ./internal/cli ./internal/config -run 'Test.*LocalControl|TestTerminal|TestBrowser|TestDesktop|TestCapture' Tested: GOCACHE=/tmp/zero-go-cache go test ./internal/localcontrol ./internal/tools ./internal/cli ./internal/config ./internal/agent Tested: tuistory smoke launched bash, sent interactive input, waited for expected output, and captured a no-cursor snapshot Tested: git diff --cached --check * Fix npm wrapper helper manifest test on macOS Canonicalize expected helper paths in the npm wrapper manifest test so macOS /var and /private/var temp path aliases compare correctly. Tested: GOCACHE=/tmp/zero-go-cache go test ./internal/npmwrapper Tested: git diff --check * Harden local control review fixes Respect resolved local-control config before tool listing and filter validation while preserving stream-json usage error ordering. Harden browser, desktop, and artifact tool validation; guard Linux-only app launch behavior; clear stale helper manifests from the npm wrapper. Make helper packaging lockfile-based with npm ci and add installer/package tests for helper staging. Tested: focused local-control/tool/CLI/release/install/sandbox suite Tested: isolated full go test ./... Tested: macOS and Windows compile-only checks for touched packages	2026-06-26 08:22:56 +05:30
Vasanth T	46c44a8753	feat(swarm): let swarm members build (write + sandboxed shell) (#313) ... * feat(swarm): let swarm members build (write + sandboxed shell) Swarm subagents were effectively read-only: a member runs headless at "--auto low" (PermissionModeAuto), and ToolAdvertised strips every prompt-requiring tool from the model's list — so write_file/edit_file/ apply_patch/bash were never handed to the member. It only saw read/grep/ glob/plan tools, so it could not build and the orchestrator did all the writes itself. Add PermissionModeMemberAuto: a headless mode that ADVERTISES the in-workspace mutators (SideEffectWrite + SideEffectShell) on top of the Auto set, while behaving exactly like Auto everywhere else. The sandbox engine still decides at call time — in-workspace writes and sandbox-backed shell auto-allow; out-of-workspace writes, network, and destructive commands prompt and so are denied headless. member-auto normalizes to Auto in the sandbox layer, so no sandbox authority is widened beyond what an interactive auto agent already has. Scope: swarm members only. The launcher sets MemberAutonomy; the executor emits "--auto member" for a non-unsafe member (unsafe still -> high, plain specialists still -> low). Task-tool specialists are unchanged. Windows note: shell only auto-runs when the OS sandbox is active; without `zero sandbox setup` a member writes files but cannot run builds. * style: gofmt member_auto_test.go	2026-06-25 11:36:40 +05:30
KRATOS	474f494b93	Deep-audit remediation + sandbox hardening (batches 1–35) (#189) ... * audit batch 1: redact nested secrets fully; count image tokens in compaction estimate - secrets.Redact: replace longest matches first so a containing PRIVATE KEY block is redacted before a nested shorter match corrupts its exact string (audit medium internal/secrets/scanner.go:81) + regression test. - agent compaction estimateTokens: add a flat per-image token cost so an image-heavy context trends toward compaction instead of reading as ~0 (audit medium internal/agent/compaction.go:58) + test. - ledger: re-verify against current main; mark scanner.go:35 and redaction.go:362 already-fixed-on-main, record this batch's fixes. * audit batch 2: worktrees defaultRunGit separates stdout/stderr Capture git stdout and stderr into separate buffers instead of CombinedOutput, so parsed rev-parse output is not polluted by git warnings and CommandResult.Stderr carries the real error text (audit medium internal/worktrees/worktrees.go:247) + test. * audit: re-verify all 87 pending findings against current main Independent agent per file re-checked each open/partial finding against the actual current code (the 06-11 ledger was verified on a since-diverged branch), with an adversarial second pass on every already_fixed verdict. Authoritative result: 78 genuinely pending (66 still_open + 12 partial); 9 rows were already fixed on main and are reclassified. Full table in 2026-06-13-reverification.md. * audit batch 3 (agent): cancellation identity, always-allow w/o sandbox, compaction usage, dedup - loop.go: check ctx.Err() before collected.Error so a cancelled run returns context.Canceled (errors.Is holds) instead of a plain stringified error. - loop.go: 'Always allow' with no sandbox engine now allows THIS call instead of denying it (persistence is skipped when there's nowhere to persist). - loop.go: remove a duplicate schema["items"] assignment in propertyToRuntimeMap. - compaction.go: forward OnUsage (token accounting) through the summarizer while still omitting OnText, so compaction's token cost is counted in usage/budgets. - tests for all three behavioral fixes (each fails pre-fix). * audit batch 4 (cli): list-tools -o json, interrupted -o json terminal, surface session-record failures - exec --list-tools -o json now emits a JSON tool listing instead of falling through to the human-readable text (audit medium exec.go:182) + test. - interrupted run with -o json now emits a terminal error+done on stdout instead of only printing to stderr, so a JSON consumer sees a clean end (medium exec.go:500) + test. - execSessionRecorder: surface a latched session-append failure to stderr once at run end (deferred) instead of silently dropping it (medium exec_sessions.go:114/115) + test. - left app.go trailing-arg ignore as-is: documented-intentional, TUI has no argv prompt. * audit batch 5 (zerogit): status -z porcelain (renames + non-ASCII paths); document env-drop on plain Runner - parseStatus: switch `git status` to `--porcelain -z` and parse the NUL-delimited form (audit medium zerogit.go:212). Previously the default --short output was split on newlines, so a rename `R old -> new` was kept as one bogus path and a non-ASCII/whitespace filename arrived C-quoted+escaped (e.g. `"caf\303\251.txt"`). The -z form never quotes paths and emits a rename/copy as `XY <dest>\0<src>`, so we now record the destination verbatim and consume the source field. + TestParseStatusZHandlesRenamesAndSpecialPaths. - resolveRunners: document that the plain-Runner EnvRunner adapter intentionally drops env (audit low zerogit.go:417). The branch is reached only when a caller supplies a custom Runner without a RunGitEnv — in practice fake-Runner tests. Production leaves both nil and gets defaultRunGit/defaultRunGitEnv, which honor GIT_INDEX_FILE, so snapshot-diff isolation holds. Routing env calls to real git instead would break the fake-Runner test pattern and fix nothing in production. - update Inspect/Commit mock tests to the -z status format and the new command. * audit batch 6 (config): reject negative maxTurns; drop dead contract-gap helpers - FileConfig.UnmarshalJSON now rejects a negative maxTurns instead of letting the `MaxTurns > 0` merge gates silently drop it and fall back to the default, hiding the misconfiguration (audit medium resolver.go:136). 0 is left as the "unset" sentinel (omitempty) and still falls back to the default; the CLI --max-turns flag continues to reject 0 too since there it is distinguishable from absent. + TestResolveRejectsNegativeMaxTurns / ...ZeroFallsBackToDefault. - remove dead config/contracts.go (ContractGap, DefaultContractGaps, FindContractGapsByMilestone, ContractOwnerRuntime) and its test — referenced only by that test, never by production (audit low contracts.go:12). - NOT changed: ResolveMCP intentionally does not run the provider command (TestResolveMCPDoesNotRunProviderCommand guards this), so the "ZERO_PROVIDER_COMMAND MCP servers dropped" row is by-design, not a defect. * audit batch 7 (mcp): bound captured MCP server stderr connectStdio attached a plain bytes.Buffer as cmd.Stderr that is only ever read on initialize failure, yet it kept growing for the entire process lifetime as a long-lived server logged to stderr (audit medium client.go:98). Replace it with a concurrency-safe boundedBuffer capped at 64 KiB that keeps the head (enough for init-error diagnostics) and discards the rest, reporting full write lengths so os/exec never sees a short write. + TestBoundedBufferCapsRetainedBytes. Left as-is (not defects worth the risk in the MCP client): - client.go writer.write under client.mu: already designed to release the lock before the unbounded response wait; the residual concern is a server that stops draining stdin, an involved async rewrite for a theoretical deadlock. - readLoop not answering server-initiated requests (ping): responding safely needs re-locking around the shared writer; no configured server relies on it. * audit batch 8 (tools/providers): read_file truncation marker; drop dead provider branch - read_file: when a max_lines cut occurs, append an explicit "[truncated: N more line(s)... set start_line=X to continue]" marker to the output. Previously only the Result.Truncated flag was set, which is invisible in the rendered text, so the model could not distinguish a cut read from a complete one (audit low read_file.go:89). + TestReadFileToolMarksTruncation. - providers/factory: simplify `if !explicitProvider || isImplicitOpenAI(...)` to `if !explicitProvider` and delete the now-unused isImplicitOpenAI. The clause was dead: explicitProvider==true implies ProviderKind or Provider is set, but isImplicitOpenAI required both empty, so it could never contribute a case (audit low factory.go:118). Behavior-preserving; providers tests still green. * audit batch 9 (sessions): Tree builds from a single List() snapshot (no N+1 disk scans) Store.Tree recursed via ListChildren per node, and each ListChildren ran a full store.List() that re-read every metadata.json from disk — O(nodes * total-sessions) reads for one tree (audit medium lineage.go:140). Snapshot all sessions once, index children by parent in memory, and recurse over that. Child ordering is factored into sortChildSessions so ListChildren and Tree stay identical; path-scoped cycle detection (delete(seen,...)) is preserved. Existing tree/lineage tests still pass. Left as-is: store.go timestamp() second precision (RFC3339) — switching to RFC3339Nano would break lexical UpdatedAt ordering against existing second-precision records ("...00.5Z" sorts before "...00Z"), so it is not a safe one-line change. * audit batch 10 (specialist): serialize accounting dedup-then-append recordSpecialistStop and appendSpecialistUsageRollup checked for an existing event (specialistEventExists → ReadEvents) and then appended under SEPARATE store locks, so two concurrent finishers — a foreground onExit racing a TaskOutput poll, or a background reaper — could both pass the dedup check and write duplicate stop/usage events (audit medium accounting.go:72). Guard each check-then-append pair with a package-level accountingMu (Executor is used by value, so a struct field would not be shared). + TestRecordSpecialistStopDedupesUnderConcurrency (passes under -race). * audit batch 11 (zeroruntime/gemini): O(1) text accumulation; gemini cached-token counts - zeroruntime CollectStreamWithOptions accumulated assistant text with `collected.Text += event.Content`, reallocating the whole string on every chunk (O(n^2) over a long streamed response). Accumulate in a strings.Builder on the collector and materialize it once in flush, the single finalization point hit before every return (audit low helpers.go:104). Existing collect tests still pass. - gemini decoded usageMetadata without cachedContentTokenCount, so a cached-prompt response reported zero cached input tokens while the other providers report them (audit medium gemini/types.go:88). Decode the field and thread it through streamState into NormalizeUsage as CachedInputTokens. + extended TestStreamCompletionEmitsTextUsageAndReasoningTokens. * audit batch 12 (specialist): parse child stream without a line-length cap; drop dead helper - ParseStream used a bufio.Scanner capped at 1 MiB, so one large stream-json line from a child (a big tool result or final answer) hit bufio.ErrTooLong and aborted the entire specialist run (audit medium streamer.go:43). Switch to a bufio.Reader with ReadString, which has no per-line limit; the child is our own trusted subprocess, so its output length is the legitimate bound. Line numbering and blank-line/EOF handling are preserved. + TestParseStreamHandlesLineLargerThan1MiB. - remove dead formatTaskOutput (output_tool.go:244): zero callers and zero tests; it only forwarded to formatTaskOutputSummary, which is the one actually used. * audit batch 13 (background/specialist): kill background tasks as a process group Background children were launched in the parent's process group and terminated by signalling only the single PID, so any process the task forked was orphaned and outlived a cancel; the signal also risked hitting a recycled PID after the child was reaped (audit medium process_posix.go:38/50). - ConfigureChildProcessGroup (Setpgid on POSIX, no-op on Windows where taskkill /T already tree-kills) is applied at launch so the child leads its own group. - terminateProcess now SIGTERM/SIGKILLs the negative PID (the whole group), with a pid>1 guard so a bogus 0/1 can never expand to "our own group" or "everything", and treats ESRCH as already-gone. Liveness polls the group. Targeting a group (rarely recycled vs. a bare PID) also shrinks the reaped-then-recycled window. - specialist launchBackgroundProcess opts every child into its own group; on a SetPID failure it now kills the child + group, marks the task errored, and records the stop (deduped) instead of leaking an untracked orphan. - tests launch as group leaders; new TestTerminateProcessKillsForkedChildren proves a forked grandchild dies with the group. * audit batch 14 (sandbox): quote-aware shell segment splitting splitShellSegments used a quote-unaware strings.Replacer, so a shell operator inside quotes was treated as a separator: `git commit -m "use top | less"` split into a `less` segment and `echo "a; vim b"` into a `vim` segment, both falsely flagged as interactive (audit medium safe_command.go:138). Replace it with a quote-aware scanner that mirrors the shell: single quotes make everything literal; double quotes keep $(...)/`...` substitution active but treat |, ;, && as literal; unquoted text splits on the same operator set as before (;, |, ||, &&) plus substitution boundaries. Real unquoted operators still split, so an interactive program behind a separator — or inside a live `"$(...)"` substitution — is still caught (no new false negatives, the security-relevant direction). + TestDetectInteractiveQuoteAwareSeparators covering both directions. * audit batch 15 (cron): collapse DST fall-back repeated hour to one fire On a fall-back day the clock repeats an hour (e.g. 01:30 EDT then 01:30 EST), so Next("30 1 * * *", <01:30 EDT>) returned the same-day 01:30 EST — firing a daily job twice (audit medium schedule.go:171, which previously guarded only the spring-forward gap). Next now skips a match whose local wall-clock minute equals `after`'s but whose absolute time is later (the repeated-hour duplicate) and keeps searching. Normal forward search always advances the wall-clock, so this only triggers on the fall-back repeat; when the scheduler passes the last fire time as `after`, the repeated hour collapses to a single fire. + TestNextDSTFallBackDoesNotRepeatHour (spring-forward termination test still passes). Note: Next is stateless, so it dedupes relative to `after`; a caller that passes an arbitrary mid-hour "now" instead of the last fire time is out of scope here. * audit batch 16 (mcp): skip SSE notifications before the response; larger SSE buffer - decodeSSERPCMessage returned the first non-empty `message` event unconditionally, so a server-initiated notification/request arriving before the response made the caller see an id mismatch and fail (audit medium network_client.go:621). It now skips any message carrying a method (notifications/requests have one; a response does not) and returns the first real response; the caller's rpcIDMatches still validates the id. + TestDecodeSSERPCMessageSkipsNotifications. - raise the per-event SSE scanner cap from 1 MiB to a bounded 8 MiB so a large but legitimate MCP message no longer hits bufio.ErrTooLong and fails the request (audit medium network_client.go:637); still bounded against an unbounded server. Out of scope (kept): full reconnect of a persistent SSE stream after a fatal read error — a larger change than this remediation. * audit batch 17 (sessions): fsync session metadata before the atomic rename writeMetadata wrote the temp file with os.WriteFile (no sync) and renamed it into place, so a crash right after the rename could expose a metadata file whose bytes were never flushed — a torn or empty file that corrupts the whole session (audit medium store.go:632). Write+fsync the temp via a new writeFileSync helper before renaming, closing that window. + TestWriteFileSyncRoundTrips. Deliberately scoped: - Event-log appends (appendEventLocked) are NOT fsynced per append: that would add a disk flush to every event (every tool call), and a hard-crash loss of the log's unsynced tail is acceptable, whereas torn METADATA is not. Metadata is the integrity-critical part and is what this syncs. - Directory fsync is omitted for cross-platform simplicity (it errors on Windows); the file fsync already prevents the torn-contents failure, the serious case. Left for follow-up (in this bucket but not safe/clear wins here): - hooks append sequence still re-reads the file per append; the in-memory cache is cross-process-unsafe and the safe last-line read is fiddly for a low-volume log. - Fork event re-append/de-dup is nuanced usage-accounting and needs its own change. * audit batch 18 (agent): count tool-defs in compaction estimate; don't deny an always-allow on persist failure - maybeCompact's estimate omitted the tool definitions, which ride on every request, so the real input could exceed the model limit while the message-only estimate stayed under threshold and compaction never fired (audit medium compaction.go:58). partitionTools is now computed before maybeCompact (it does not depend on the messages) and the exposed tools' estimated tokens are added to both the threshold check and the post-compaction shrink check. + estimateToolDefTokens and TestEstimateToolDefTokensCountsDefinitions. - PermissionDecisionAlwaysAllow denied the call when persistPermissionGrant failed, overriding what the user explicitly allowed (audit medium loop.go:468). Persisting is now best-effort: a failure (or no sandbox engine) just means the grant is not remembered and the user is re-prompted next time, not denied now. This also drops the dead requestEvent.GrantMatched/Grant writes (audit low loop.go:473) — the emitted event derives them from the sandbox decision via buildPermissionEvent. Left intentional (documented, not defects): the reactive-retry path omits OnText to avoid duplicating mid-stream text (loop.go:183); OnContext/MeasureContext is a complete, tested context-breakdown scaffold awaiting a consumer (types.go:183). * audit batch 19 (usage): price escalated usage from the event's own model exec persists payload["model"] on --allow-escalation runs (the model can change mid-run), but BuildReport priced every event from the session's Metadata.ModelID and never read the payload, so usage from an escalated model was mis-priced at the base model (audit medium report.go:17). usageEventPayload now carries Model and BuildReport prefers it, falling back to the session model when absent (older events stay byte-identical and behave as before). + TestBuildReportPricesFromEventModelWhenPresent. * audit batch 20 (sessions): don't copy usage events into a fork (no double-count) Fork re-appended every parent event, including provider_usage, into the child, so a usage report aggregating the parent and the fork double-counted the parent's usage (audit medium store.go:387). Skip EventUsage when copying — it already counted against the parent and is not part of the conversation history a fork replays — and record the actual copied count in the fork marker. + TestStoreForkSkipsUsageEvents. * audit batch 21 (cli/skills): warn on duplicate skill names instead of silently dropping skills.Load deduplicates same-named skills (first directory wins) and records the dropped collisions via skills.Duplicates, but nothing surfaced them, so a shadowed skill just vanished with no signal — and Duplicates had no production caller (audit low skills.go:91). `skills list` now reports each collision to stderr (keeping stdout/--json clean), using Duplicates. + TestRunSkillsListWarnsOnDuplicateNames. Note: skills.Get is kept — it is a by-name accessor used throughout the package's tests, not dead code. * audit batch 22 (cli/cron): capture the run error from stream-json stdout Cron jobs run exec with --output-format stream-json, so a failure is reported as an `error` event on STDOUT, but the run record's Error was set only from stderr — so a failed job often recorded an empty/uninformative error while the real message sat unread in outBuf (audit low cron_run.go:150). On a non-zero exit, scan the stdout stream-json for the error event's message and prefer it, falling back to stderr. + extractStreamJSONError and TestExtractStreamJSONError. * audit batch 23 (sandbox): richer macOS seatbelt profile (signal + mach-lookup) The generated sandbox-exec profile was default-deny with only process/sysctl/file allowances, so two real gaps remained on macOS (sandbox quality report H1): - A sandboxed script could not signal the children it spawned — `kill` returned "Operation not permitted" under seatbelt, breaking common `cmd & ... kill`, test-runner, and timeout patterns. Add `(allow signal (target self) (target pgrp))`, which stays scoped to the command's own process group. - XPC to system daemons was denied, so keychain (securityd/trustd), user/group lookup (opendirectoryd), preferences (cfprefsd), network config (SystemConfiguration), launch services, and the pasteboard all failed. Add a curated `(allow mach-lookup ...)` allowlist (`sandboxMachServices`). Neither touches the file-write or network rules, so the workspace boundary is unchanged — verified on a real macOS host: `security`/`scutil`/`pbpaste`/self-kill now succeed while writes to $HOME and /etc are still denied. iokit-open was tried and dropped as unnecessary. + unit assertions (TestSandboxExecProfileGrantsSignalAndMachLookup) and extended the darwin integration test with a self-kill case and an outside-workspace deny check. * audit batch 24 (sandbox/tools): remove dead OnSandboxDecision hook RunOptions.OnSandboxDecision had no setter anywhere, yet registry.RunWithOptions spawned a goroutine (with panic recovery) for it on every sandboxed tool call — pure per-call overhead for an unreachable callback (sandbox report M1). The sandbox decision is already surfaced to observers via the permission event (buildPermissionEvent reads the decision), so this hook is redundant; delete the field and its call site. * audit batch 25 (sandbox/cli): exact-path grants — create and revoke by path The engine already matched ScopeFile grants and DeriveScope already produced them from path/file tool args, but the CLI could neither create one explicitly nor revoke a single one (sandbox report L3 / prompt 7). Add: - GrantStore.RevokePath(tool, path): revokes only the grant whose scope matches the given file/dir, leaving tool-wide and other-path grants intact (path canonicalized to absolute like stored scopes). + TestGrantStoreRevokePathRemovesOnlyMatchingScope. - `zero sandbox grants allow <tool> --path <p>`: persists an exact-file (ScopeFile) grant, path resolved to absolute so it matches lookups and revokes. - `zero sandbox grants revoke <tool> --path <p>`: revokes just that grant (default still revokes all grants for the tool). + TestRunSandboxGrantsCreateAndRevokeByPath. The TUI permission-card "Allow always (exact path)" option is intentionally left for the TUI feature branches (it overlaps #187/#188); the engine + CLI now cover the full create/match/revoke round-trip for file-scoped grants. * audit batch 26 (sandbox): Engine.Precheck — report violations before execution Add Engine.Precheck(ctx, request) []Violation, which reports the sandbox violations that would block a tool request before it runs (sandbox report / prompt 6). It reuses Evaluate so policy is not duplicated: an allowed or merely-prompted request yields no violations; a denied request yields its violation (via the shared violationsFromDecision helper, with a ViolationPolicyDenied fallback for a deny that carries no structured violation). A nil engine yields nothing. + TestEnginePrecheckReportsViolationsBeforeExecution. Wiring Precheck into the batch-confirmation prompt is intentionally left to the TUI branch: it touches prompt rendering, and short-circuiting the agent loop's deny path would skip the before/after-tool hooks that currently fire around a policy-denied call. The engine API is in place for that consumer. * audit batch 27 (sandbox): scoped-egress domain prompt with timeout + caching The scoped-egress proxy failed closed on any host outside the allowlist. Add an opt-in DomainPrompt callback (prompt 8): an UNKNOWN host (neither allowed nor explicitly denied) is authorized at request time via the callback instead of being refused outright. An explicitly denied host is still refused without prompting; the callback is bounded by PromptTimeout (default 60s, timeout/error => deny); decisions are cached for the proxy's lifetime so a host is prompted at most once. With no callback set the strict fail-closed behavior is unchanged. Wired through both the CONNECT and HTTP handlers via authorizeTarget. + TestEgressProxyAuthorizeDomainPrompt / ...TimeoutDenies / ...NilPromptFailsClosed. The user-facing prompt that supplies the callback is left to the permission UI (TUI) branch; the egress mechanism (callback + timeout + cache) is in place and tested. * audit batch 28 (sandbox): AST-based shell analysis (AnalyzeCommand) Add AnalyzeCommand(script) AnalysisResult, a static shell analyzer built on the mvdan.cc/sh/v3 parser (prompt 12). Walking the parsed command tree makes it a more precise second opinion than the regex detector: a program name only counts when it is an actual command, so `echo "vim ..."`, `printf 'open with vim'`, and `git commit -m "rm -rf /"` are clean, while real commands are flagged — interactive (editors/pagers + REPLs, with the same -e/script suppression as nonInteractiveREPLFlags), destructive (rm -rf/-fr, dd, mkfs, shred, ...), and network (curl/wget/ssh/nc/...). An unparseable script yields TooComplex so callers can treat it as higher-risk. + TestAnalyzeCommand (16 cases) / ...EmptyIsClean. Dependency: mvdan.cc/sh/v3 pinned to v3.11.0 — compatible with the existing go 1.24 directive (the latest v3.13.1 would have bumped the module to go 1.25). It is kept as a standalone analyzer for callers to consult; feeding it into Engine.Evaluate is deliberately not done here, since that would change allow/deny classification. * audit batch 29 (sandbox): unify proxy-env generation (ProxyEnv) Export ProxyEnv as the single source of truth for proxy-env injection (prompt 9 req 1), replacing the unexported scopedProxyEnv used by the sandboxed-shell path. + TestProxyEnv. Investigation that bounds the rest of prompt 9 (documented in the ProxyEnv doc): - web_fetch already honors HTTP_PROXY/HTTPS_PROXY — its transport clones http.DefaultTransport, whose Proxy is http.ProxyFromEnvironment. - MCP children already inherit the parent env (mergeProcessEnv appends os.Environ), so they pick up any proxy vars the agent has. So the only missing link to scope FetchUrl/MCP is a SESSION-level egress proxy whose address reaches the agent process. That is deliberately NOT wired here: doing it safely requires allowlisting the active LLM provider's own domain first, or the agent's provider calls would route through the scoped proxy and be denied — a correctness pitfall that also can't be verified end-to-end on this host. Flagged rather than shipped blind. * audit batch 30 (sandbox): Linux seccomp Unix-socket block — UNVERIFIED, needs Linux CI Adds a pure-Go (no cgo, no vendored binary) seccomp BPF filter that denies socket(AF_UNIX) with EPERM on x86-64/arm64, closing the Unix-socket gap bubblewrap's filesystem/network isolation leaves open (prompt 11): - internal/sandbox/seccomp.go: the classic-BPF program as a platform-neutral []sockFilter, built and UNIT-TESTED (structure + every jump offset in range — the classic way a hand-written BPF filter goes silently wrong). - seccomp_linux.go: ApplyUnixSocketBlock installs it via prctl(NO_NEW_PRIVS) + prctl(SET_SECCOMP, MODE_FILTER). seccomp_other.go is a no-op everywhere else. - cmd/zero-seccomp: a tiny linux-only exec wrapper that applies the filter then execs the real command (the standard way to install seccomp in a child with os/exec); degrades gracefully (warns + runs) if the kernel lacks seccomp. ⚠️ HONEST CAVEAT: I developed this on macOS and CANNOT run the actual AF_UNIX block here. darwin build, `GOOS=linux` cross-compile, vet, and the structure test all pass, but the unit test verifies the program's SHAPE, not that the kernel actually blocks AF_UNIX — that MUST be verified on Linux CI (create a Unix socket under the wrapper and assert EPERM). Safe to ship as-is: it is linux-only, no-op on every other platform, and not wired into the bwrap command yet (opt-in prefixing the sandboxed command with zero-seccomp is the remaining integration), so it cannot regress any current path. * audit batch 31 (sandbox): macOS denial log monitor (opt-in, default off) Re-adds the macOS seatbelt-denial monitor as an opt-in feature (prompt 10). When Policy.MonitorDenials is set, the sandbox-exec profile tags its default-deny with a marker and bash tails `log stream` for that tag during the command, appending any captured denials as a <sandbox_violations> block to the command's stderr so the model can see what was blocked. - DenialMonitor (darwin) tails/parses tagged denials with a capped, deduped ring buffer and noise filtering; no-op stub on other platforms. parseSandboxDenyLine is unit-tested. + profile-tag test + appendSandboxViolations test. - Default OFF: with MonitorTag empty, StartDenialMonitor is a no-op and the command path is byte-for-byte unchanged, so there is no regression or per-command overhead unless enabled. CAVEAT: on at least one macOS host (verified live) seatbelt denials are NOT delivered to the `log stream`-queryable unified log, so the monitor captures nothing there. It is the standard mechanism and works on macOS versions that do log denials; shipping it default-off means it never affects whether a command runs. * audit batch 32 (sandbox): wire seccomp Unix-socket block into bubblewrap (opt-in) Completes prompt 11: the zero-seccomp helper (which installs the AF_UNIX seccomp filter) is now actually invoked by the sandbox instead of only existing as a standalone binary. - bubblewrapCommandPlan, when Policy.BlockUnixSockets is set, ro-binds the discovered zero-seccomp helper into the sandbox at its host path and prefixes the command with it so the filter is installed before the real argv runs. - findSeccompHelper discovers the helper next to the running executable first, then on PATH; it returns "" when absent, so the sandbox degrades gracefully (runs without the extra filter — bubblewrap's fs/net isolation still applies) rather than failing the command. Exposed as a package var so the wiring is unit-tested on any OS. - Reachable from config: SandboxConfig.BlockUnixSockets and .MonitorDenials now map onto the policy in applyConfiguredSandboxPolicy (opt-in only — config can turn a hardening flag on, never off). Both default OFF. - Tests: helper-prefix present when enabled / absent by default; config flags apply independently and stay off when omitted. Default OFF and Linux-only effect; the runtime seccomp enforcement still needs a Linux host/CI to exercise end-to-end (the wiring and BPF program are unit-tested). * audit batch 33 (sandbox): enforce scoped/deny network policy in web_fetch & web_search Completes prompt 9: the built-in network tools now honor the SAME allow/deny/scoped policy the sandboxed shell egress proxy enforces, instead of bypassing it. Before this, web_fetch/web_search would reach any public host even when the policy was NetworkDeny or NetworkScoped — the egress proxy only constrained shell commands. - New shared gate Engine.NetworkHostAllowed(host) reuses the egress domain matcher (domainAllowed/normalizeDomains/effectiveNetwork) as the single source of truth: allow → all hosts; deny → none; scoped → only AllowedDomains minus DeniedDomains (empty allowlist collapses to deny). Disabled policy / nil engine impose nothing. - web_fetch is now sandbox-aware: the host is checked before the request AND on every redirect, so a denied/unlisted host fails closed before any dial. Plumbed via a networkPolicyGate so the no-sandbox path is byte-for-byte unchanged. - web_search is sandbox-aware: the configured backend's endpoint host is checked before the query leaves the machine; blocked under deny, and under scoped unless the backend host is allowlisted. - The registry already routes sandbox-aware tools through RunWithSandbox when an engine is present, so this activates automatically wherever the sandbox is wired. - Tests: engine gate matrix (deny/allow/scoped/denylist/empty/disabled/nil + host:port); web_fetch & web_search block denied/unlisted hosts without dialing and allow listed ones; endpoint-host parsing. * audit batch 34 (sandbox): prove network-policy wiring end-to-end + document opt-in flags Verification follow-up to batches 31-33; no behaviour change. - Adds a registry-level test that exercises the FULL chain for the scoped-network enforcement: registry.RunWithOptions -> engine.Evaluate (passes a scoped, egress-capable sandbox-exec backend) -> routes web_fetch through RunWithSandbox -> per-host allowlist blocks an unlisted host before any dial. This proves the Tool-interface value actually satisfies sandboxAwareTool at the registry boundary, not just in a direct method call. - Documents the two opt-in hardening flags (sandbox.blockUnixSockets, sandbox.monitorDenials) and the scoped web_fetch/web_search behaviour in the README so the config keys are discoverable. Both remain off by default. Confirmed wiring: agent loop forwards options.Sandbox to the registry; the registry routes sandbox-aware tools (web_fetch, web_search) through RunWithSandbox when an engine is present; MonitorTag is set only on the macOS sandbox-exec plan; the seccomp helper prefix is added only on the bubblewrap plan when BlockUnixSockets is set; both config flags map onto the policy via applyConfiguredSandboxPolicy. * audit batch 35 (sessions): fix Windows CI failure in TestWriteFileSyncRoundTrips The exact-permission assertion (perm == 0o600) added in batch 17 fails on windows-latest because Windows does not honor Unix permission bits: Go reports 0o666 for a writable file regardless of the mode passed to OpenFile. This was the sole cause of the failing Smoke (windows-latest) CI job; macOS and Ubuntu passed. Guard the perm check with runtime.GOOS != "windows" so it still verifies the mode on the platforms that enforce it, while the round-trip (write + read-back) is still asserted on every platform. * audit batch 36: address CodeRabbit review (5 findings) - background/process_posix: after SIGKILL, poll until the process group is actually gone (SIGKILL is async) and return an error if it survives past a second deadline, instead of returning nil while descendants still race. - sandbox/safe_command: only treat ')' as a substitution boundary when it closes an active $(...). A literal ')' (e.g. echo "a) less") no longer splits into a fake `less` segment and is no longer misflagged as interactive. Depth-tracked so nested $(...) still isolate their inner command. Direct splitShellSegments test (fails pre-fix: yields ["echo \"a", "less\""]). - cron/schedule: the DST fall-back collapse now only applies when `after` sits exactly on the minute boundary (its "last fire time" form). With sub-minute precision (e.g. 01:30:30 EDT) the first 01:30 fire already passed, so the repeated 01:30 EST is the legitimate next fire and is returned — restoring strictly-after semantics. New test fails pre-fix (skipped to next day). - config/types: maxTurns error message now reads "must be >= 0" to match the check (0 is accepted; only < 0 is rejected). Negative-maxTurns test asserts the message. - docs/audit: header date/branch metadata now matches the body (2026-06-13, fix/audit-batch) instead of the stale 2026-06-11/fix/audit-critical-high snapshot. Verified: gofmt clean; go vet clean; host + linux + windows builds; affected suites green. Each behavioural fix ships with a test confirmed to fail without the change. * audit batch 37: address CodeRabbit re-review (12 findings) Findings on the audit code from batches 21-36; each behavioural fix ships with a regression test (several confirmed to fail without the change). sandbox/analyzer (AnalyzeCommand): - Unwrap launcher prefixes (sudo/env/nice/bash -c/...) and recurse into `sh -c` payloads so `sudo rm -rf`, `env curl …`, `bash -c 'vim x'` classify on the real command, not the launcher. Mirrors DetectInteractiveCommand. - Honor rm's `--` end-of-options marker so `rm -- -rf` (delete a file named -rf) is not flagged destructive. sandbox/engine: NetworkHostAllowed now shares one backend-aware effective-mode helper with Evaluate, so scoped collapses to deny when the backend can't enforce scoped egress — the per-tool gate can no longer permit traffic the engine-level decision would fail closed. sandbox/egress: cache domain-prompt decisions by host:port, not host, so one "allow" can't authorize other ports on the same host. sandbox/safe_command: the segment splitter is now escape-aware (\| , \" ) so an escaped operator/quote can't manufacture a fake interactive segment. sandbox/log_monitor (darwin): Wait() the `log stream` child after draining stdout so the cancelled process isn't leaked as a zombie. tools/web_search: confine the search backend to same-host redirects (with a limit) so a redirect chain can't egress to a host the scoped/deny policy never authorized. cli/sandbox: an explicit empty --path (`--path=` / `--path ""`) now fails closed instead of silently widening an allow to tool-wide or a revoke to all-grants. cli/skills: warn on stderr when duplicate-skill detection fails instead of swallowing the error. specialist/exec: don't mask a failed orphan-kill — join the TerminateProcess error with the SetPID error so a surviving process is visible. background/process_posix: resolve the PGID and only group-signal when pid leads its own group; otherwise signal the individual PID. Avoids both a false-success on a non-leader ESRCH and the hazard of signalling an unrelated (possibly our own) group. Verified: gofmt + go vet clean; host + linux + windows builds; full go test ./... green. * audit batch 38: address CodeRabbit re-review round 2 (3 findings) Follow-ups to batch 37, each with a regression test: - safe_command (splitter): a ')' is now only a substitution boundary when it closes an active, UNQUOTED $(...). A quote-state stack saved at each '$(' lets a substitution run in a fresh quoting context and restores the outer quoting on its matching ')'. Fixes `echo $(printf "a) less")` splitting into a fake `less` segment, while still isolating the inner command of `echo "$(vim x)"`. - egress: deduplicate in-flight domain prompts per host:port. Concurrent requests for the same unknown target now wait on the first prompt and reuse its cached decision instead of each firing a prompt (a prompt storm) and racing to write the final decision. Race-tested with 25 concurrent authorizers → one prompt. - analyzer + safe_command: wrapper option-value consumption is now wrapper-specific (wrapperValueOptionsByProg) instead of a global option set. A valueless flag like `sudo -n` no longer swallows the real payload, so `sudo -n rm -rf` / `sudo -n curl …` are correctly classified destructive/network; `sudo -u root vim` still consumes its value. Shared by the AST analyzer and the regex detector so they can't diverge. Verified: gofmt + go vet clean; host + linux + windows builds; go test ./... and -race on sandbox/background all green. * audit batch 39: address CodeRabbit re-review round 3 (12 findings) All verified against current code; each behavioural fix has a regression test. Security / correctness: - tools/web_search: redirect policy now also refuses a scheme change, blocking a same-host https→http downgrade that would send the query + bearer token over plaintext. - sandbox/safe_command: a ')' is only a substitution boundary when it closes an active UNQUOTED $(...), and backticks now get the same quote-state save/restore as $( — so `echo "`a | less`"` and `echo "$(true | less)"` no longer hide the inner pager from interactive detection. - sandbox/analyzer + safe_command: wrapper option-value consumption stays wrapper-specific, and unwrapping no longer aborts on a dynamic ($x) wrapper arg once a wrapper is active, so `env "$opts" curl` / `sudo "$x" rm -rf` are still classified. - sandbox/egress: in-flight prompts deduped per host:port (carried from batch 38); the prompt callback is now cancellable (context cancelled on timeout) so a stuck prompt can abort instead of leaking; signature threaded through. - sandbox/runner: per-plan unique denial tag (pid+counter) so concurrent monitored sandbox-exec runs can't ingest each other's denials; helper selection now requires an executable regular file so a non-exec sibling degrades gracefully. - mcp/network_client: aggregate SSE event-size cap (not just per-line) so a server can't grow memory with many unterminated data: lines. - specialist/accounting: a previously-recorded stop/usage with an empty runId is a catch-all and now suppresses a later runId-bearing duplicate. - sessions/lineage: Tree fetches the root via Get() first so a corrupt root surfaces its real error instead of degrading to "not found". Docs/tests: - background/terminate: docstring now states the leader-only group-kill (PID-only fallback for non-leaders); test child-liveness probe uses ESRCH specifically. - cli/sandbox: grant usage strings include --path. Verified: gofmt + go vet clean; host + linux + windows builds; go test ./... and -race on sandbox/background all green. * audit batch 40: address CodeRabbit re-review round 4 (8 fixed, 1 skipped) Verified each against current code. Fixed: - sessions/lineage: PANIC FIX — store.Get returns (nil, nil) for a missing session, so the batch-39 root prefetch could nil-deref. Guard root == nil and return a not-found error. Regression test added (was a panic). - agent/compaction: the reactive recover() now records lowWaterMark in the SAME combined (messages + tool-defs) token domain maybeCompact uses, so the proactive shrink-guard compares like with like. recover() takes tools; callers pass request.Tools. - mcp/network_client: SSE aggregate counter no longer counts a joining newline for the first data line (only when prior content exists), avoiding premature rejects. - sessions/store: fsync the parent directory after the metadata rename so the rename is durable across a crash (no-op on Windows, which can't fsync a dir). - sandbox/egress: parse the target port with strconv.Atoi instead of net.LookupPort (no context-unaware resolver use). - sandbox/runner: escape the per-plan denial tag through sandboxProfileString when embedding it in the seatbelt profile. - sandbox/seccomp_linux: guard against an empty filter program before taking &kernelFilters[0] (defensive; the program is fixed non-empty today). - cli/cron_run_test: assert last-error-wins with two error events. - background/terminate, cli/sandbox usage, process_posix_test ESRCH (carried). Skipped (with reason): - zerogit worktree-rename (Y='R') test: git porcelain v1 -z only emits the rename-source field when the INDEX column is R/C; the worktree column never carries 'R' with a source field in v1, so the fixture would test output git doesn't produce, and making parseStatus consume on code[1]=='R' would risk mis-consuming the following entry for a plain ` R` status. Left as-is. Verified: gofmt + go vet clean; host + linux + windows builds; go test ./... and -race on sandbox/background all green. * audit batch 41: address CodeRabbit re-review round 5 (4 findings) All verified against current code; code fixes have regression tests. - agent/compaction: summarizeWithFallback's reduce pass no longer swallows ALL errors. A context-limit error still falls back to the joined partial summaries (documented "extreme" case), but a non-context failure (auth/network/provider) now surfaces unchanged, per the function's contract. Two tests (propagate vs. joined-fallback); the propagate test fails without the fix. - sandbox/safe_command + analyzer: wrapper value-consuming options now include the long spellings (sudo --user root, env --unset NAME, timeout --signal …), so a long flag's value is no longer mis-read as the program (interactive/destructive/ network detection bypass). A `--flag=value` token carries its own value and never consumes the next token. Tests for space and = forms in both the AST analyzer and the regex detector. - docs/audit: the status-ledger summary table's open/partial cells (64/14) were the lone outlier — the ledger's own narrative and 2026-06-13-reverification.md both state 66/12. Corrected to 66/12 (66+12+97 = 175); derivation: body 69 open + 18 partial minus the 9 already-fixed-on-main (3 open + 6 partial) = 66/12 = 78 pending, fixed 88+9 = 97. Added a comment documenting the summary-vs-body relationship. The reverification doc already states 66/12, so both now agree. Verified: gofmt + go vet clean; host + linux + windows builds; full go test ./... green. * audit batch 42: address CodeRabbit re-review round 6 (1 fixed, 1 kept w/ proof) CodeRabbit re-surfaced two "duplicate" refinements; CI was already green (its 6th pass was a COMMENT with no new findings). - cli/sandbox_test (TestRunSandboxGrantsRejectsEmptyPath): now seeds a tool-wide grant and asserts grant-store immutability after EACH rejected empty-`--path` call (reflect.DeepEqual before/after), so a mutation in one call can't be masked by a later one — and a buggy "revoke all" is actually observable (it's a no-op on an empty store). Stronger than the suggested patch. - zerogit.parseStatus: KEPT consuming the rename source on the index column only (code[0]), with an explanatory comment. Verified empirically that git porcelain v1 -z reports a rename/copy (and emits the extra source field) only in the index column: `git mv` → "R new\0old\0"; a worktree-only rename → " D old\0?? new\0" (delete + untracked, never "R" in code[1]). Consuming on code[1]=='R'/'C' would match no real git output and would only risk mis-consuming the next entry on malformed input, so the suggestion is declined as incorrect for v1. Verified: gofmt + go vet clean; host + linux + windows builds; affected suites green.	2026-06-13 21:32:48 +05:30
gnanam1990	24e15e2138	providers/openai: forward reasoning effort to the chat completions request ... zeroruntime.CompletionRequest had no effort field, so agent.Options.Reasoning Effort never reached the provider (cli/exec.go even noted it was 'not yet forwarded'). Add CompletionRequest.ReasoningEffort, thread it through every request the agent loop builds, and map it to OpenAI's reasoning_effort. The CLI gates the forwarded value against the resolved model: known non-reasoning models send nothing (matching the existing 'ignoring' advisory), known reasoning models send their effective level, and unknown custom endpoints forward the requested value as-is. Anthropic/Gemini mapping is handled separately.	2026-06-11 15:02:09 +05:30
KRATOS	58e209d021	Sound / completion notifier: terminal bell + OSC-9 on turn completion & awaiting-input (#149) ... * notify: dep-free terminal bell / OSC-9 completion notifier * config: notify.mode + notify.focusMode (validated, default off) * exec: --notify/--no-notify + completion notify on stderr * tui: focus reporting + completion/awaiting-input notifications * notify: fire on exec --use-spec completion; headless ignores focus; gate focus-reporting on enabled * notify: validate --notify value, skip notify on empty ask_user, deterministic resolver tests Addresses #149 review (CodeRabbit + @Vasanthdev2004): - parseExecArgs rejects an invalid --notify value (only off/bell/notify/both), so a CLI typo errors early instead of silently running with no notification. - TUI OnAskUser fires AwaitingInput only when len(request.Questions) > 0 — a request with no questions auto-resolves without prompting, so the bell/desktop notification was a false positive. - notify resolver tests pass Env: map[string]string{} so Resolve does not fall back to os.Getenv (deterministic, not ambient-env dependent).	2026-06-09 14:34:24 +05:30
KRATOSandGnanam	69810d5ab0	Mid-run model escalation: escalate_model tool + --allow-escalation (#146) ... * modelregistry: add UpgradeTargetID and Registry.UpgradeTarget escalation lookup * modelregistry: seed escalation chains in catalog decoration * modelregistry: verification gate for escalation upgrade map * agent: add ModelSwitcher option and ToolResult.RequestedModel field * agent: lift escalate_to_model meta into ToolResult.RequestedModel * agent: perform at-most-one mid-run model switch in the turn loop * tools: add SideEffectNone for control-only tools * tools: add escalate_model control tool (metadata + args) * cli: parse --allow-escalation exec flag * cli: document --allow-escalation in exec help * cli: register escalate_model tool under --allow-escalation * cli: wire model switcher for exec escalation * cli: guard byte-identical exec run without escalation flag * cli: attribute post-switch usage to the escalated model * tools: accept an explicit empty escalate_model reason reason is an optional, informational-only arg, but the previous arg parsing rejected an explicit reason:"" (non-empty-string check), failing the whole escalation. Switch to stringArgWithEmpty so an absent OR empty reason is accepted while a non-string value is still rejected. Add a test covering both the empty and absent forms. * agent: test (nil,nil) escalation switcher keeps original provider When a ModelSwitcher returns (nil, nil) — no error, no replacement — the loop's `else if newProvider != nil` guard already keeps the active provider, so the run continues on the original model. Add an agent-layer test that proves this (it panics if the nil guard is dropped), closing the gap the adversarial review flagged. Also note the deferred compaction limitation near the switch: the compactor's context-window budget is fixed at run start and not updated on a mid-run switch (needs a ModelSwitcher contract change to fix). * cli: gate usage model attribution on the escalation flag and harden tests FIX A (back-compat): the OnUsage closure wrote a "model" key into every persisted EventUsage payload unconditionally, diverging a non-escalation run from the byte-identical origin/main baseline. The model can only change mid-run under --allow-escalation, so include the "model" key only then. A new flag-OFF test asserts the persisted usage payload carries no "model" key (mutation-proven). Test hardening for the CLI escalation boundary: - Wire test: each newProvider build returns a DISTINCT provider with its own turn counter; assert the source provider served exactly the escalation turn and the escalated provider served exactly the post-switch answer. Fails if `provider = newProvider` is dropped. - Mixed usage attribution: emit usage pre- and post-switch and assert the first attributes to the original model, the second to the escalated target (the loop's ordering guarantee). - Switch-error path: a failed rebuild is non-fatal and post-error usage stays attributed to the original model (currentModel unchanged). - Top-tier decline end-to-end: a flag-on run that escalates while already top-tier performs no switch (newProvider built exactly once) and succeeds. * modelregistry: validate UpgradeTargetID resolves at registry construction * cli: update currentModel only when the switched provider is non-nil * sandbox: make 'none' a first-class side effect (control-only tools) --------- Co-authored-by: Gnanam <[email protected]>	2026-06-08 20:50:32 +05:30
3 people	68facda077	Image (multimodal) input: exec --image, stream-json images, TUI /image across all 3 providers (#143) ... * zeroruntime: add ImageBlock type and NormalizeImageMediaType * zeroruntime: add optional Images field to Message * zeroruntime: add SeedMessagesWithImages, delegate SeedMessages with nil * Emit Anthropic image source blocks for user image turns * Add inlineData part type to Gemini request schema * Serialize user image attachments as Gemini inlineData parts * test(openai): pin text-only chat request serialization before content refactor * feat(openai): allow structured multimodal content parts in chat request * feat(openai): map image attachments to image_url content parts * test(openai): assert image content parts serialize over the request body * modelregistry: add SupportsVision capability gate * Add shared image-file loader package * cli: parse repeatable exec --image flag into imagePaths * cli: resolve exec image attachments via shared loader with sniff and size cap * agent: thread image attachments through Options into the seeded user turn * cli: resolve and vision-gate exec image attachments into the agent run * cli: document exec --image flag in help output * streamjson: add InputImage type and InputEvent.Images field * streamjson: whitelist images field on message events only * streamjson: allow empty content on message events that carry images * streamjson: add ResolveImages to decode, normalize and cap input images * streamjson: cover image parse-and-resolve round-trip and text-only invariance * Add /image command definition to TUI * Add synchronous vision check for TUI model * Implement /image attach, clear, and non-vision refusal in TUI * Render pending image chips above the input in both skins * Thread pending images into the agent turn and clear on submit * Wire stream-json images through to the agent run Stream-json message images were parsed and validated but never reached agent.Options.Images: streamjson.ResolveImages had no production caller, so images sent over stream-json input were silently dropped. resolveExecPrompt now also returns the resolved stream-json images (nil for text input and for image-free stream-json input). The exec runner merges them with --image attachments before the vision gate, so both input sources flow through the same drop+warn and the same agent.Options.Images wiring. Adds an exec-level end-to-end test that feeds a base64 image on a stream-json message event via stdin on a vision model and asserts the image reaches the agent run (the provider request's user turn). * Re-check TUI vision support at submit, not only at /image attach A user could attach an image on a vision model and then switch to a non-vision model via /model before submitting; the images were threaded unconditionally into the agent turn, reaching a model that rejects them. The commandPrompt submit path now re-runs the vision check against the current effective model. When the active model can't accept images, the pending images are dropped (not threaded) and an inline notice mirroring the headless drop+warn wording is appended. Pending image state is still cleared after submit either way. Adds a test that attaches on a vision model, switches the model id to a non-vision one, submits, and asserts the run received no images, an inline notice was appended, and pending state was cleared. * Bound memory with an os.Stat size pre-check in imageinput.LoadFile LoadFile read the whole file into memory before checking the size cap, so a multi-gigabyte file allocated a huge buffer only to be discarded. Add an os.Stat size pre-check before os.ReadFile: a file whose size exceeds MaxImageBytes is rejected with the same 10 MiB-limit error before any read; a missing file surfaces the same not-found error. The existing post-read len(data) check is kept as a TOCTOU backstop in case the file grows between Stat and ReadFile. * OpenAI: only the user role emits image content-parts The Anthropic and Gemini providers only attach images in their user branches, but OpenAI funnels every role through a single mapMessage, which would emit image content-parts for any role carrying Images. Guard the content-parts path to the user role: a non-user message that happens to carry Images keeps the plain string/nil content path. Pins the invariant with TestMapMessageNonUserRolesNeverCarryImages, asserting assistant/tool/system messages with Images set still serialize plain content (no content-parts array). * Deep-copy image buffers so attachments are never aliased Add a shared CloneImageBlocks helper in zeroruntime that deep-copies a slice of ImageBlock including each Data byte slice (returning nil for nil/empty input). Use it in SeedMessagesWithImages so a seeded user turn owns an independent copy of the caller's image bytes, and in the agent loop's copyMessages so image bytes are deep-copied alongside ToolCalls instead of staying aliased across history/request/result copies. Tests assert that mutating the caller's original Data bytes after seeding leaves the seeded message unchanged, and that copyMessages produces independent image bytes. * Accept image-only stream-json turns and bound base64 image size Resolve stream-json images before the prompt in the exec input path and tolerate an empty prompt when images are present, so an image-only message event (empty content + one image) proceeds with prompt="" and the image reaches the agent run instead of being rejected. A turn carrying neither text nor images still errors. In ResolveImages, reject an oversized payload from its ENCODED length (DecodedLen) BEFORE the base64 decode so a huge blob never allocates a decode buffer just to be capped afterward; the post-decode length check stays as a backstop. Tests cover the image-only exec turn reaching the agent and the pre-decode oversize rejection (asserting the size gate fires before any decode). * Bound the image read in imageinput.LoadFile with a LimitReader Replace os.ReadFile with os.Open + io.ReadAll over an io.LimitReader(f, MaxImageBytes+1). The os.Stat pre-check is only a fast-path hint (a non-regular file reports a misleading size and the file can grow between stat and read); the LimitReader is the real bound, so at most one byte past the cap is ever buffered and an oversized or unbounded source can never allocate a multi-gigabyte buffer. The file is closed via defer and the existing size message is reused. * Fix RenderChat frame-height off-by-one with image chips cmdRegion emits TWO rows when ImageChips is set (a chip row above the input line), but the body/overlay height accounting assumed a one-row command region, overflowing the fixed frame by one line. Compute the fixed-row count from the actual command-region height (1 or 2 rows) so the composed frame stays exactly Height rows in both cases. A RenderChat test asserts the rendered frame line-count equals the requested height both with and without ImageChips set. * Reject an empty inline --image= value Route the inline --image= form through requiredInlineFlagValue, the same empty-rejection the other inline flags use, so --image= errors with "--image requires a value" instead of appending an empty image path. A parse test covers the empty inline value. * imageinput: reject non-regular files (FIFO/dir) before opening --------- Co-authored-by: KRATOS <[email protected]> Co-authored-by: Gnanam <[email protected]>	2026-06-08 18:49:09 +05:30
KRATOSandKRATOS	07d8ffc524	CLI wiring: skills/zeroline commands, --mode presets, exec checkpoints, sandbox --effective, sessions rewind (#128) ... * CLI wiring: skills/zeroline commands, --mode presets, exec checkpoints, sandbox --effective, sessions rewind Final module of the runtime-core split. Wires the new runtime features into the cli, PRESERVING main's merged specialist cli (the source branch predates specialist and drops it; this keeps it via a 3-way merge from the common base, adding the reskin features as ours/theirs-only changes). - skills command (internal/cli/skills.go) listing internal/skills; zeroline-skin TUI launcher (internal/cli/zeroline.go) via runInteractiveTUIWithSkin. - exec: --mode presets (smart/deep/fast/large/precise) via applyExecMode; model-registry alias resolution + deprecation/effort notices; ContextWindow sizing (modelContextWindow); before-mutation checkpoint recording in OnToolCall; enhanced tool-result output (ChangedFiles/Redacted/Display); permission-mode validation fix. - sandbox policy --effective (resolved guards); sessions rewind (executes the rewind plan); interactive TUI defaults to Ask mode (advertises write/edit/bash + gates via prompts). - internal/streamjson: EventCheckpoint/EventRestore + CheckpointInfo for structured checkpoint output. Specialist cli preserved (specialist.go + flags + runtime + tests all intact). build/vet/-race/full-suite + GOOS=windows build green; no new deps. * Address #128 review: make sessions rewind reachable + honor --exclude-target, mode/notice/redaction fixes - sessions: add "rewind" to the parser whitelist (isSessionsCommand) — it was wired in dispatch + help but parseSessionsArgs rejected it as 'unknown sessions command', so it was unreachable. Regression test TestRunSessionsRewindIsReachableAndHonorsExcludeTarget. - sessions rewind: honor --exclude-target — ApplyRewind keeps THROUGH a sequence, so when KeepTarget is false apply through TargetSequence-1, matching rewind-plan (previously rewind always applied TO the target, disagreeing with the plan). The test asserts --exclude-target keeps fewer events than the default. - sessions rewind: redact the session id in the success + not-found messages (consistent with every other human-readable path). - exec_parse: reject empty inline --mode= via requiredInlineFlagValue (was a silent no-op running defaults). - exec: notice writes (model-deprecation + reasoning-effort advisories) now treat write failures as exitCrash, consistent with the rest of the command. build/vet/-race/full-suite + GOOS=windows build green. --------- Co-authored-by: KRATOS <[email protected]>	2026-06-07 23:42:10 +05:30
Anandan	82314a703c	Add specialist authoring tools (#117) ... * Add specialist authoring tools * Harden specialist authoring boundaries	2026-06-07 15:21:09 +05:30
Anandan	936bbea59d	Add specialist background task tools (#115) ... * Add specialist background task tools * Address specialist background review feedback	2026-06-07 13:15:04 +05:30
Anandan	a60154b70a	Add specialist Task runtime (#113) ... * Add specialist Task runtime * Harden specialist resume identity	2026-06-07 12:39:29 +05:30
Anandan	561fe0b7ad	Add specialist lifecycle metadata (#106)	2026-06-07 11:06:30 +05:30
Anandan	ae6c9595db	feat(specialist): add exec metadata flags (#104) ... * Add specialist exec metadata flags * Address exec metadata review	2026-06-07 10:40:16 +05:30
Vasanth T	43c256068a	feat: make Go runtime the app path (#71) ... * feat: make go runtime the app path * fix: harden update semver parsing	2026-06-05 17:24:58 +05:30
Vasanth T	37f3cc17a5	feat: advance Go-first TUI and npm wrapper (#57) ... * feat: advance Go-first TUI and npm wrapper * fix: address wrapper and footer review feedback * feat: deepen Go TUI model and exec controls * fix: address coderabbit exec and model list feedback	2026-06-04 20:59:06 +05:30
Vasanth T	95700c0898	feat: wire Go CLI to real provider flow (#54) ... * feat: wire go cli to real provider flow * fix: address exec review feedback * test: harden exec provider assertions * chore: prevent coderabbit blocking reviews	2026-06-04 19:45:21 +05:30