Release v1.25.0 — sanitized source snapshot (2026-07-24)

Author: marmutapp

CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to SuperBased Observer are documented here.
 
+## [1.25.0] — 2026-07-24
+
+### Added
+
+- **feat(terminal): dashboard-launched terminals joinable by default.**
+  `/api/attach/sessions` widened to every live daemon-owned run kind
+  (fresh/handoff/attach/resume) — a terminal launched from the dashboard is
+  now itself a Jump-in candidate, not just an `--attach` session. A handoff
+  terminal's row keys by the FORKED session (not the source it continued
+  from), so it's joined from the fork's session detail once correlation links
+  it. `JumpInButton`'s copy and newest-row selection (picking the most
+  recently created live row when more than one matches a session) were
+  updated to match the wider row set.
+- **feat(attach): attach-by-default for all 19 CLI launchers.** Every
+  `observer <verb>` launcher (claude, codex, opencode, cursor, copilot-cli,
+  kilo, cline-cli, hermes, gemini, openclaw, pi, antigravity-cli, qwen, kiro,
+  grok, kimi, devin, qoder, goose) now attaches by default the same way
+  claude/codex have — a shared launcher gate plus 19 new integration-registry
+  Attach rows (tool key → launcher verb). Auto-resume-on-daemon-restart stays
+  gated to the two tools with a verified native resume (claude, codex) — every
+  other launcher gets an honest degraded-mortality notice instead (a daemon
+  restart ends the session outright; `observer <verb> --continue-from
+  <session-id>` is the manual fork fallback). Proxy env forwarding and
+  `[terminal.attach].route_proxy` / `--no-proxy` remain claude/codex-scoped —
+  every other tool's daemon-spawned inner launcher handles its own
+  base-URL routing itself. Note the attached child inherits the DAEMON's
+  environment, not the launching shell's — a credential exported only in the
+  launching shell won't reach it (config-file/OAuth auth unaffected; export
+  it where `observer start` runs, or use `--no-attach`). `JumpInButton`'s verb map extended to cover
+  all 19 tools.
+
 ## [1.24.1] — 2026-07-24
 
 ### Added

browser-extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "SuperBased Observer — Browser Capture",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "Opt-in, passive observability of your own AI chatbot web usage (ChatGPT, Claude, Perplexity, Gemini, Copilot). Captures per-turn metadata + estimated tokens locally; nothing leaves your machine except to your local observer daemon.",
   "minimum_chrome_version": "111",
   "permissions": [

cmd/observer/antigravity.go

@@ -30,6 +30,8 @@ func newAntigravityCmd() *cobra.Command {
 		carry        string
 		fromMessage  int
 		fromTime     string
+		attach       *bool
+		noAttach     *bool
 	)
 	cmd := &cobra.Command{
 		Use:     "antigravity-cli [-- agy-args...]",
@@ -46,6 +48,27 @@ func newAntigravityCmd() *cobra.Command {
 			"to separate observer flags from agy flags. NEVER touches API keys.",
 		SilenceErrors: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			// Attach gate (attach-all-launchers): default-on attach hands the PTY
+			// to the daemon. Seed-only spec (agy is native-exempt — no proxy env,
+			// no escape-hatch flag). No -p/--prompt headless predicate: this
+			// launcher only grounds -i/--prompt-interactive + a bare positional
+			// seed, so a headless one-shot flag is NOT grounded here — the
+			// handoff-fork family is the only incompatible mode (both-TTY guard
+			// covers scripted runs).
+			outcome, aErr := launcherAttach(cmd.Context(), launcherAttachSpec{
+				tool:         "antigravity-cli",
+				configPath:   configPath,
+				flagAttach:   *attach,
+				flagNoAttach: *noAttach,
+				incompatible: continueFamilyEngaged(continueFrom, carry, fromMessage, fromTime),
+				passthrough:  antigravityAttachPassthrough(binPath),
+				toolArgs:     args,
+				stderr:       cmd.ErrOrStderr(),
+			})
+			if outcome.handled {
+				return aErr
+			}
+
 			bin, err := resolveToolBin("antigravity-cli", binPath, "--agy-path", configPath, cmd.ErrOrStderr())
 			if err != nil {
 				return err
@@ -92,6 +115,17 @@ func newAntigravityCmd() *cobra.Command {
 	cmd.Flags().StringVar(&carry, "carry", "", "Carry mode for --continue-from: metadata|distilled|distilled_tail|full|full_cache (default from [handoff] config)")
 	cmd.Flags().IntVar(&fromMessage, "from-message", 0, "With --continue-from: fork after this 1-based transcript message (default: last message)")
 	cmd.Flags().StringVar(&fromTime, "from-time", "", "With --continue-from: fork after the last message at or before this RFC3339 time")
+	attach, noAttach = registerAttachFlags(cmd, "antigravity-cli")
 	cmd.Flags().SetInterspersed(false)
 	return cmd
 }
+
+// antigravityAttachPassthrough forwards the --agy-path wrapper flag to the
+// daemon-spawned inner `observer antigravity-cli` launcher when set (nil
+// otherwise).
+func antigravityAttachPassthrough(agyPath string) []string {
+	if agyPath != "" {
+		return []string{"--agy-path", agyPath}
+	}
+	return nil
+}

cmd/observer/attach_client.go

@@ -77,11 +77,24 @@ type attachLaunch struct {
 
 // nativeResumeHint composes the daemon-exit resume guidance from the tool's
 // grounded ResumeSpec (session-attach design §2.4). When native resume is not
-// yet grounded it degrades to a generic, honest phrase rather than asserting a
-// resume command the tool may not support. Dispatch is on the ResumeSpec shape,
-// never a tool-name branch (CLAUDE.md #3).
+// yet grounded — the ResumeNone case that now covers 17 of the 19 attachable
+// launchers (attach-all-launchers) — it degrades HONESTLY: for a launchable
+// tool it points at the manual `observer <verb> --continue-from <id>` handover
+// fork (the real mortality backstop for a daemon-restart-ends-the-session
+// tool), and only falls back to the fully-generic phrase when even the launch
+// verb is unknown. Dispatch is on the capability SHAPE (ResumeSpec kind +
+// Handoff.Launch presence), never a tool-name branch (CLAUDE.md #3). This is
+// the ONE seam where the "daemon restart = session over" reality lands for a
+// ResumeNone tool — reportAttachResult's daemon-exit / conn-lost / input-stall
+// branches interpolate it.
 func nativeResumeHint(capab integration.Capability) string {
 	if capab.Resume.Kind != integration.ResumeNative || capab.Resume.Subcommand == "" {
+		if capab.Handoff.Launch != nil && capab.Handoff.Launch.Subcommand != "" {
+			return fmt.Sprintf(
+				"start a new session (`observer %s --continue-from <session-id>` carries a distilled handover)",
+				capab.Handoff.Launch.Subcommand,
+			)
+		}
 		return "resume it natively to continue"
 	}
 	switch capab.Resume.IDMechanism {
@@ -103,20 +116,25 @@ func nativeResumeHint(capab integration.Capability) string {
 //
 //   - --no-proxy-route  when the escape hatch is engaged (the inner launcher
 //     then skips base-URL / `-c openai_base_url` injection);
-//   - --proxy <url>     when the operator overrode the proxy URL;
+//   - <proxyFlag> <url> when the operator overrode the proxy URL — the flag
+//     NAME is the inner launcher's own proxy-override spelling (`--proxy` for
+//     most, `--proxy-url` for hermes/pi), passed in so shared code never
+//     branches on tool identity (CLAUDE.md #3); emitted only when BOTH
+//     proxyFlag and proxyOverride are non-empty (a seed-only launcher with no
+//     proxy flag passes proxyFlag="" and the override is dropped);
 //   - --config <path>   when the outer invocation used a non-default config;
 //   - passthrough...    launcher-specific wrapper flags the inner launcher
 //     should honor (e.g. --claude-path/--codex-path, --no-app-server-check),
 //     enumerated explicitly by each launcher (B2-6);
 //   - -- <toolArgs...>  the operator's trailing tool args (`observer codex
 //     --attach -- --model X`), so launcher state is not dropped.
-func attachExtraArgs(noProxyRoute bool, proxyOverride, configPath string, passthrough, toolArgs []string) []string {
+func attachExtraArgs(noProxyRoute bool, proxyOverride, proxyFlag, configPath string, passthrough, toolArgs []string) []string {
 	var args []string
 	if noProxyRoute {
 		args = append(args, "--no-proxy-route")
 	}
-	if proxyOverride != "" {
-		args = append(args, "--proxy", proxyOverride)
+	if proxyOverride != "" && proxyFlag != "" {
+		args = append(args, proxyFlag, proxyOverride)
 	}
 	if configPath != "" {
 		args = append(args, "--config", configPath)

cmd/observer/attach_client_unix.go

@@ -77,6 +77,16 @@ func runAttachSession(ctx context.Context, in attachLaunch) error {
 	}
 	subcommand := capab.Attach.Subcommand
 
+	// canAutoResume gates the daemon-death AUTO-resume loop on the tool's native
+	// resume capability (attach-all-launchers §3). Only a ResumeNative tool has
+	// an inner launcher that registers `--resume` and can reattach its REAL
+	// transcript, so injectResumeArg's `--resume <id>` argv is only parseable
+	// there. For the 17 ResumeNone launchers a daemon restart ENDS the session
+	// (honest mortality) — offerAutoResume/resumeSpawn stay unreachable and the
+	// ResumeNone hint (nativeResumeHint → `--continue-from`) lands instead.
+	// Dispatch on the capability SHAPE, never a tool-name branch (CLAUDE.md #3).
+	canAutoResume := capab.Resume.Kind == integration.ResumeNative
+
 	// Attach drives a live TUI: require a real terminal on both ends.
 	stdinFd := int(os.Stdin.Fd())
 	stdoutFd := int(os.Stdout.Fd())
@@ -141,9 +151,12 @@ func runAttachSession(ctx context.Context, in attachLaunch) error {
 		}
 
 		// Daemon-death. Auto-resume only with a REAL correlated id (the abstain
-		// rule — no fabricated target) and within the retry cap; otherwise the
-		// honest resume hint.
-		if currentID == "" || autoResumes >= maxAutoResumes {
+		// rule — no fabricated target), a tool that can natively resume
+		// (canAutoResume — a ResumeNone tool's inner launcher can't parse the
+		// injected `--resume`), and within the retry cap; otherwise the honest
+		// resume hint (nativeResumeHint degrades to `--continue-from` for a
+		// ResumeNone launcher).
+		if currentID == "" || !canAutoResume || autoResumes >= maxAutoResumes {
 			return reportAttachResult(in.stderr, subcommand, capab, res.status, res.attachErr)
 		}
 		if !offerAutoResume(ctx, in.stderr, sockPath, subcommand, currentID, attachsock.Dial) {

cmd/observer/attach_host.go

@@ -248,6 +248,17 @@ func validateAttachCapability(req attachsock.SpawnRequest) error {
 		return fmt.Errorf("attach: subcommand %q does not match tool %q's grounded attach subcommand %q",
 			req.Subcommand, req.Tool, capab.Attach.Subcommand)
 	}
+	// Resume defense in depth (attach-all-launchers §3): a socket client is
+	// untrusted, so refuse a resume spawn (manual --resume OR an AutoResume) for
+	// a tool with no grounded native resume. The 17 ResumeNone launchers now
+	// attachable have no `--resume` argv, so composing one for their inner
+	// launcher would fail with a cobra unknown-flag error inside the PTY. Branch
+	// on the capability SHAPE, never the tool name (CLAUDE.md #3). The client
+	// gate + resumableSessionSet already prevent this; this is the daemon-side
+	// backstop against a spoofed request.
+	if req.ResumeSession != "" && capab.Resume.Kind != integration.ResumeNative {
+		return fmt.Errorf("attach: tool %q has no native resume capability", req.Tool)
+	}
 	return nil
 }