@caddis/cli 0.0.0 → 0.1.0

package/bundles/antigravity-plugin/skills/writing-plans/SKILL.md

@@ -0,0 +1,384 @@
+---
+name: writing-plans
+context: fork
+description: Use when you have a spec or requirements for a multi-step task, before touching code
+---
+
+# Writing Plans
+
+## Overview
+
+Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
+
+Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
+
+**Announce at start:** "I'm using the writing-plans skill to create the implementation plan."
+
+**Context:** This should be run in a dedicated worktree (created by brainstorming skill).
+
+**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
+
+**Document metadata:** Before creating or updating a plan, apply `.github/instructions/document-frontmatter.instructions.md`. The YAML frontmatter block must be the first content in the file. New plans require `Original Author`, `Creation Date`, and `Creating Model`; revised plans must preserve those fields and add or update `Last Author`, `Last Updated`, and `Last Model Used`.
+
+## Bite-Sized Task Granularity
+
+**Each step is one action (2-5 minutes):**
+- "Write the failing test" - step
+- "Run it to make sure it fails" - step
+- "Implement the minimal code to make the test pass" - step
+- "Run the tests and make sure they pass" - step
+- "Commit" - step
+
+## Plan Document Header
+
+**Every plan MUST start with this header (YAML frontmatter first, then title):**
+
+```markdown
+---
+chain_id: <chain_id>
+type: plan
+status: current
+approval: pending
+Original Author: <active author or agent name>
+Creation Date: <YYYY-MM-DDTHH:MM:SSZ>
+Creating Model: <exact runtime model identifier or display name>
+---
+
+# [Feature Name] Implementation Plan
+
+> **For the implementing agent:** Follow this plan task-by-task, executing each step sequentially.
+
+**Goal:** [One sentence describing what this builds]
+
+**Architecture:** [2-3 sentences about approach]
+
+**Tech Stack:** [Key technologies/libraries]
+
+---
+```
+
+> ⚠️ The YAML frontmatter block (`---` delimiters) is required for Orchestrator artefact contract validation. Do NOT use blockquote-style metadata (`> **approval:** pending`) — it will not be parsed.
+> Preserve the original metadata fields on later edits, and add or update `Last Author`, `Last Updated`, and `Last Model Used` when the plan is revised. Use full ISO 8601 UTC timestamps for `Creation Date` and `Last Updated`.
+
+## Task Structure
+
+```markdown
+### Task N: [Component Name]
+
+**Files:**
+- Create: `exact/path/to/file.py`
+- Modify: `exact/path/to/existing.py:123-145`
+- Test: `tests/exact/path/to/test.py`
+
+**Step 1: Write the failing test**
+
+```python
+def test_specific_behavior():
+    result = function(input)
+    assert result == expected
+```
+
+**Step 2: Run test to verify it fails**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: FAIL with "function not defined"
+
+**Step 3: Write minimal implementation**
+
+```python
+def function(input):
+    return expected
+```
+
+**Step 4: Run test to verify it passes**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: PASS
+
+**Step 5: Commit**
+
+```bash
+git add tests/path/test.py src/path/file.py
+git commit -m "feat: add specific feature"
+```
+```
+
+## Manual Execution Protocol
+
+**Every plan MUST include a Manual Execution Protocol section** at the top (after header, before phases). This tells the user exactly how to run each phase session:
+
+```markdown
+## Manual Execution Protocol
+
+For each phase below, follow this workflow:
+
+1. **Open** a new chat session with the agent specified in the phase header
+2. **Load skills** listed in the phase's "Skills to load" section
+3. **Attach files** listed in the phase's "Files to attach" section
+4. **Paste** the self-contained Phase Prompt into the chat
+5. **Validate** using the phase's Validation Checklist — every item must pass
+6. **Get green light** before moving to the next phase
+
+**Drift rule:** If you find bugs introduced by Phase N, fix them in the SAME session
+before starting Phase N+1. Never carry implementation debt forward between phases.
+
+**Dependency sequencing rule:** Write phases in execution order \u2014 every phase's dependencies must appear before that phase in the plan. If Phase 3 requires output from Phase 4, reorder before writing. No forward dependencies.
+```
+
+## Phase 0 — Context & Decisions
+
+**Every multi-phase plan MUST include a Phase 0** before the implementation phases. Phase 0 is not an implementation phase — it is a ground-truth inventory that prevents agents from making assumptions.
+
+Phase 0 contains four mandatory tables:
+
+### Technology Decision Table
+
+```markdown
+### Technology Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Charting library | Recharts | Tree-shakeable, React-native, typed API |
+| Animation | Framer Motion | AnimatePresence for tab transitions, spring physics |
+| State management | Zustand | Lightweight, no boilerplate, devtools support |
+| ... | ... | ... |
+```
+
+Every technology choice that is NOT already in `project-config.md` must appear here with a rationale.
+
+### Data Parity / Availability Matrix
+
+```markdown
+### Data Availability
+
+| Feature / Tab | Data Field | Available? | Strategy |
+|---------------|-----------|------------|----------|
+| Executive Overview | `ceoInsight` | ✅ Full | Live API |
+| Product Deep-Dive | `satisfactionScores` | ❌ Empty `{}` | Show empty state: "Coming in future release" |
+| Geography | `byGeography` | ⚠️ Partial (was present May-Oct) | Show empty state with explanation |
+| ... | ... | ... | ... |
+```
+
+For any data field that may be empty, partial, or absent: document the exact empty state message text.
+
+### Existing Scaffold Audit
+
+```markdown
+### Existing Scaffold — DO NOT Recreate
+
+| File | Purpose | Current State |
+|------|---------|---------------|
+| `frontend/src/api/client.ts` | API client with JWT auth | ✅ Working — build on top |
+| `frontend/src/types/nps.ts` | 30+ TypeScript interfaces | ✅ Working — import, don't recreate |
+| `frontend/src/components/layout/AppShell.tsx` | App shell | ⚠️ Cold zinc theme — needs warm overhaul |
+| ... | ... | ... |
+```
+
+The "Current State" column tells agents what exists and whether to modify or leave it alone.
+
+### Dependency Split
+
+```markdown
+### Dependencies
+
+**Already installed** (DO NOT reinstall):
+- react, react-dom, typescript, vite
+- @tanstack/react-query, @tanstack/react-router
+- tailwindcss, zustand
+
+**Not yet installed** (install in Phase 1):
+- recharts, framer-motion, leaflet, react-leaflet
+- d3-force, d3-scale
+```
+
+## Enhanced Per-Phase Template
+
+**Every implementation phase MUST use this structure.** The sections OUTSIDE the prompt block are for the user (what to prepare before opening a session). The prompt block is for the agent (what to paste into the session).
+
+```markdown
+## Phase N — {Name}
+
+**Agent:** `@{agent-name}`
+**Objective:** {One sentence describing what this phase builds}
+
+### Skills to load
+
+- `.github/skills/{path}/SKILL.md` — {why}
+- `.github/skills/{path}/SKILL.md` — {why}
+
+### Instructions to follow
+
+- `.github/instructions/{name}.instructions.md`
+- `.github/instructions/{name}.instructions.md`
+
+### Files to attach
+
+- `path/to/file.ext` — {why this file is needed}
+- `path/to/file.ext` (from Phase N-1)
+- `.github/plans/{this-plan}.md` (this file)
+
+### Phase Prompt
+
+\`\`\`
+{Self-contained prompt — copy-paste ready. 30-60 lines.
+References plan sections for detail. Does NOT duplicate code blocks.
+Includes PRINCIPLES, SKILLS TO READ, IMPORTANT warnings, and numbered deliverable list.}
+\`\`\`
+
+### What to build
+
+#### N.1 {Deliverable Name}
+
+**File:** `exact/path/to/file.ext`
+
+{Component interface / function signature}
+
+**Data binding:**
+- Uses `data.field.path` for {purpose}
+- Uses `data.other.field` for {purpose}
+
+**Behavior:**
+- {Specific interactive behavior}
+- {Animation spec with exact values}
+
+**Empty state:** When `data.field` is `{}` or `[]`:
+> "{Exact message text to display}"
+
+**IMPORTANT:** {Trap-specific warning — e.g., "DO NOT recreate api/client.ts",
+"field uses snake_case in BOTH API and TS types — no transformation needed"}
+
+#### N.2 {Next Deliverable}
+...
+
+### Validation Checklist — Phase N complete when
+
+- [ ] `npm run build` succeeds (or equivalent build command)
+- [ ] {Specific behavioral criterion — e.g., "KpiFlipCard flip animation works independently on each card"}
+- [ ] {Data binding criterion — e.g., "NpsSummaryTable renders 5 rows with correct data from surveys + trend"}
+- [ ] {Visual criterion — e.g., "Dark mode: all components render correctly with soft dark tokens"}
+- [ ] {Integration criterion — e.g., "Row click switches to Tab 2 and scrolls to chart"}
+- [ ] Zero hardcoded data — all from props/hooks
+- [ ] Zero hardcoded colors — all from CSS vars or constants
+```
+
+### Key rules for the "What to build" subsections
+
+1. **Data binding is mandatory for UI components.** Every component spec must list the exact JSON field paths it consumes (e.g., `surveys.{product}.nps`, `trend.historicalNPS.byProduct.{product}`). This eliminates the #1 implementer failure mode: guessing which field to bind.
+
+2. **Empty state specs are mandatory.** For every data field that might be empty, specify the exact message text. Do NOT say "show appropriate empty state" — write the message.
+
+3. **IMPORTANT warnings for traps.** If a file already exists and must NOT be recreated, say so. If a field uses unexpected casing (snake_case where camelCase is expected), warn explicitly. These prevent the most common implementation errors.
+
+4. **Complete code blocks when the component is foundational.** For theme files, config files, utility functions, and CSS — include the full source code in the plan. For application components — specify interface, behavior, and data binding; let the agent write the implementation.
+
+## Remember
+- Exact file paths always
+- Complete code in plan (not "add validation")
+- Exact commands with expected output
+- Reference relevant skills with @ syntax
+- DRY, YAGNI, TDD, frequent commits
+- **Every phase MUST end with a numbered exit gate task** (e.g., "Task N.X: Exit Gate") that includes pass/fail checks, commit message format, and an explicit "STOP — do not proceed to next phase" instruction
+- **Every phase/step must specify the executing agent and include a ready-to-use prompt with `═══ PROMPT START` / `═══ PROMPT END` markers**
+- **Use 4-backtick fences (`` ```` ``) for the outer prompt block** so nested code blocks render correctly
+- **After writing all phases, run the Cross-Reference Audit against ALL source documents**
+- **Every plan MUST include a Manual Execution Protocol and Phase 0 — Context & Decisions**
+- **Every UI phase MUST include data binding specs (exact JSON paths) per component**
+- **Every data field that might be empty MUST have an explicit empty state message**
+- **Drift rule: fix bugs from Phase N before starting Phase N+1**
+
+## Cross-Reference Audit
+
+**Run this AFTER all phases are written, BEFORE finalizing the plan.**
+
+Walk through every FR, NFR, risk, and design decision from ALL input documents. For each, verify it maps to a specific, actionable plan step. Output a traceability matrix:
+
+```markdown
+## Source Document Traceability
+
+| Requirement | Source | Plan Phase/Step | Status |
+|-------------|--------|-----------------|--------|
+| FR-101 | PRD §3.1 | Phase 1, Step 2 | ✅ Covered |
+| NFR-208 | PRD §4.2 | Phase 5, Step 1 | ✅ Covered |
+| Risk-003 | Arch §9 | Phase 3, Step 3 | ✅ Covered |
+| ALT-002 | Arch §7.4 | N/A | ⚠️ Out of Scope — rationale: deferred to v2 |
+```
+
+**Rules:**
+- A requirement without a plan step → add a step or mark "Out of Scope" with rationale
+- A cited section reference (§N) → verify the section number matches the actual document
+- Zero-tolerance: no unmapped requirements in a finalized plan
+
+## Agent & Prompt Assignment
+
+**Every phase/step MUST include a ready-to-use prompt block.** This is non-negotiable because plans are executed across multiple sessions by different agents.
+
+### Prompt Block Template
+
+> **CRITICAL**: Use 4-backtick fences (` ```` `) for the outer prompt block so nested code blocks (yaml, python, etc.) inside the prompt render correctly. Add `═══ PROMPT START` and `═══ PROMPT END` markers so users can clearly see where to copy from/to.
+
+```markdown
+### Ready-to-Use Prompt (Phase N — Step M)
+
+> **How to use:** Copy the prompt block below (between ═══ START and ═══ END markers) into a new chat session. **Include all code blocks** — they're context for the agent, not for you to apply manually.
+> **Agent:** `@{agent-name}` (see `.github/agents/{agent-name}.agent.md`)
+> **Skills to load:** `.github/skills/{skill-path}/SKILL.md`
+> **Instructions (auto-applied):** `{instruction1}.instructions.md`, `{instruction2}.instructions.md`
+> **Project config:** `.github/project-config.md` (profile: `{profile}`)
+
+> ═══ PROMPT START — Copy everything between START and END into a new chat ═══
+
+\`\`\`\`
+{One-sentence task description}
+
+**Agent context:** You are the `@{agent-name}` agent. Load `.github/project-config.md` before starting.
+
+**Read these files FIRST (in order):**
+1. `.github/plans/{plan-file}.md` — **THIS PLAN** — read "Phase N — Step M"
+2. {Architecture/PRD doc} — {specific sections}
+3. {Target file(s)} — current state
+
+**What to do:**
+- {Actionable instruction 1}
+- {Actionable instruction 2}
+
+**Acceptance criteria:**
+- {Testable criterion 1}
+- {Testable criterion 2}
+
+**Scope boundary:**
+- Exit gate: Task N.X (the last task in this phase)
+- Do NOT proceed to Phase N+1 after the exit gate passes
+- Do NOT offer additional work beyond the exit gate tasks
+- Commit with: `feat({feature}): Phase N — {description}` and STOP
+\`\`\`\`
+
+> ═══ PROMPT END ═══════════════════════════════════════════════════════════
+```
+
+### Agent Selection Guide
+
+| Task Type | Agent | Agent File |
+|-----------|-------|------------|
+| Models, services, logic | `@implement` | `implement.agent.md` |
+| Streamlit UI, components | `@streamlit-developer` | `streamlit-developer.agent.md` |
+| Tests, fixtures | `@tester` | `tester.agent.md` |
+| SQL queries, schema | `@sql-expert` | `sql-expert.agent.md` |
+| Docs, README | `@docs` | `docs.agent.md` |
+| Code review | `@code-review` | `code-review.agent.md` |
+
+## Execution Handoff
+
+After saving the plan, offer execution choice:
+
+**"Plan complete and saved to `.github/plans/<filename>.md`. Two execution options:**
+
+**1. This session** — I implement each task sequentially, reviewing between tasks
+
+**2. Separate session** — Open a new session with the `@implement` agent and provide the plan path
+
+**Which approach?"**
+
+**If separate session chosen:**
+- Guide them to open new session
+- Reference the `@implement` agent (`.github/agents/implement.agent.md`)
+- Provide the plan file path for the implementing agent to read

package/bundles/antigravity-plugin/statusline-command-agy.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# caddis status line for Antigravity (agy). Shipped IN the agy plugin bundle (lands at
+# ~/.gemini/config/plugins/caddis/statusline-command-agy.sh on install). Wire it once per machine in
+# ~/.gemini/antigravity-cli/settings.json — use the SHORT bash path (agy runs the command via cmd.exe,
+# where a bare `bash` is not on PATH and quoted spaced paths break):
+#   "statusLine": {"type":"command",
+#     "command":"C:\\PROGRA~1\\Git\\bin\\bash.exe ~/.gemini/config/plugins/caddis/statusline-command-agy.sh",
+#     "enabled":true}
+# Reads agy's status JSON on stdin and prints one compact, colorized line, styled like the Claude Code
+# status line (statusline-command.sh):  dir · branch ±dirty · model · ctx% · mode · q%
+# agy's payload field names differ from Claude Code's — this is a sibling, not a copy.
+input=$(cat)
+
+# Parse the agy status JSON via Python; emit shell var assignments to eval into scope.
+eval "$(python -c '
+import sys, json, shlex
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    d = {}
+def g(*keys):
+    v = d
+    for k in keys:
+        if not isinstance(v, dict): return ""
+        v = v.get(k)
+    if v is None or v is False or v == "": return ""
+    return str(v)
+cwd      = g("workspace","current_dir") or g("cwd")
+branch   = g("vcs","branch")
+model    = g("model","display_name") or g("model","id")
+used_pct = g("context_window","used_percentage")
+mode     = g("execution_mode")
+# quota: agy sends {name: {remaining_fraction, reset_time, ...}}. Show the BINDING (min-remaining) as a %.
+quota_pct = ""
+q = d.get("quota")
+if isinstance(q, dict) and q:
+    fr = [v.get("remaining_fraction") for v in q.values()
+          if isinstance(v, dict) and isinstance(v.get("remaining_fraction"), (int, float))]
+    if fr:
+        quota_pct = str(int(round(min(fr) * 100)))
+for name, val in [
+    ("cwd",cwd),("branch",branch),("model",model),("used_pct",used_pct),("mode",mode),("quota_pct",quota_pct),
+]:
+    print(f"{name}={shlex.quote(val)}")
+' <<< "$input")"
+
+# Fall back to git for branch when the payload omits it.
+if [ -z "$branch" ] && [ -n "$cwd" ]; then
+  branch=$(git -C "$cwd" --no-optional-locks rev-parse --abbrev-ref HEAD 2>/dev/null || true)
+fi
+
+# Uncommitted-change count (time-to-commit signal), from git.
+dirty=""
+if [ -n "$cwd" ]; then
+  n=$(git -C "$cwd" --no-optional-locks status --porcelain 2>/dev/null | grep -c . || true)
+  [ -n "$n" ] && [ "$n" -gt 0 ] 2>/dev/null && dirty="$n"
+fi
+
+# Colors (ANSI).
+C_DIM=$'\033[2m'; C_CYAN=$'\033[36m'; C_YEL=$'\033[33m'; C_RED=$'\033[31m'; C_GRN=$'\033[32m'; C_RST=$'\033[0m'
+
+# Context %: green < 50, yellow < 80, red >= 80. (used_pct may be a float string.)
+ctx_int="${used_pct%%.*}"; ctxcol="$C_GRN"
+if [ -n "$ctx_int" ] 2>/dev/null; then
+  if   [ "$ctx_int" -ge 80 ] 2>/dev/null; then ctxcol="$C_RED"
+  elif [ "$ctx_int" -ge 50 ] 2>/dev/null; then ctxcol="$C_YEL"; fi
+fi
+# Quota % REMAINING: red <= 15, yellow <= 40, else green.
+qcol="$C_GRN"
+if [ -n "$quota_pct" ] 2>/dev/null; then
+  if   [ "$quota_pct" -le 15 ] 2>/dev/null; then qcol="$C_RED"
+  elif [ "$quota_pct" -le 40 ] 2>/dev/null; then qcol="$C_YEL"; fi
+fi
+
+sep="${C_DIM} · ${C_RST}"
+segs=()
+[ -n "$cwd" ]      && segs+=("${C_DIM}$(basename "$cwd")${C_RST}")
+if [ -n "$branch" ]; then
+  b="${C_CYAN}${branch}${C_RST}"; [ -n "$dirty" ] && b="${b} ${C_YEL}±${dirty}${C_RST}"; segs+=("$b")
+fi
+[ -n "$model" ]    && segs+=("$model")
+[ -n "$ctx_int" ]  && segs+=("${ctxcol}ctx ${ctx_int}%${C_RST}")
+[ -n "$mode" ]     && segs+=("${C_DIM}${mode}${C_RST}")
+[ -n "$quota_pct" ] && segs+=("${qcol}q ${quota_pct}%${C_RST}")
+
+out=""
+for i in "${!segs[@]}"; do
+  [ "$i" -gt 0 ] && out="${out}${sep}"
+  out="${out}${segs[$i]}"
+done
+printf '%b' "$out"

package/bundles/antigravity-plugin/warm_start_agy.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""caddis warm-start hook for agy (Antigravity) — PreInvocation event.
+
+Ports the relay half of claude-harness/hooks/inject_relay.py. agy has NO SessionStart event, so the
+nearest equivalent is PreInvocation with `invocationNum == 1` — the first model turn of a session.
+On that turn only, the workspace's relay doc is injected as an ephemeral step so a fresh agy session
+resumes with zero re-discovery. Every later invocation emits nothing (re-injecting the relay on every
+turn would burn context and drown the conversation).
+
+Self-contained (the agy bundle ships neither claude-harness/hooks/ nor scripts/), stdlib-only.
+
+agy PreInvocation stdin (camelCase protojson):
+  {"invocationNum": 1, "initialNumSteps": N, "conversationId": "…", "workspacePaths": ["…"], …}
+  NOTE: cwd is the PLUGIN dir, not the workspace — the repo root comes from workspacePaths[0].
+
+agy PreInvocation stdout:
+  {"injectSteps": [{"ephemeralMessage": "…"}]}   — or nothing at all.
+
+Fail open: any error, missing relay, or non-first invocation prints NOTHING and exits 0.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+
+_ARTIFACT_DIRS = (".caddis", ".claudster")
+
+INJECT_MAX_LINES = 120      # same budget as the Claude Code hook
+INJECT_MAX_CHARS = 24000    # hard backstop: an ephemeralMessage should never be a context bomb
+
+
+def _first_existing(paths: list[str]) -> str:
+    for p in paths:
+        try:
+            if os.path.isfile(p):
+                return p
+        except Exception:
+            continue
+    return ""
+
+
+def _branch_slug(root: str) -> str:
+    """Filesystem-safe current branch name, or "" when it can't be determined (best-effort)."""
+    try:
+        branch = subprocess.run(
+            ["git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, timeout=3,
+        ).stdout.strip()
+    except Exception:
+        return ""
+    if not branch or branch == "HEAD":
+        return ""
+    return "".join(c if (c.isalnum() or c in "-_.") else "-" for c in branch)
+
+
+def resolve_relay(root: str) -> str:
+    """First existing relay doc for `root`, else "".
+
+    Preference order mirrors inject_relay.py:
+      1. <artifact-dir>/relay/<branch>.md   (per-branch team mode — .caddis, then .claudster)
+      2. <artifact-dir>/relay.md            (solo/default — .caddis, then .claudster)
+      3. .claude/relay/<branch>.md          (legacy per-branch)
+      4. relay.md                           (legacy repo root)
+    """
+    slug = _branch_slug(root)
+    candidates: list[str] = []
+    if slug:
+        candidates += [os.path.join(root, d, "relay", f"{slug}.md") for d in _ARTIFACT_DIRS]
+    candidates += [os.path.join(root, d, "relay.md") for d in _ARTIFACT_DIRS]
+    if slug:
+        candidates.append(os.path.join(root, ".claude", "relay", f"{slug}.md"))
+    candidates.append(os.path.join(root, "relay.md"))
+    return _first_existing(candidates)
+
+
+def truncate_relay(text: str) -> str:
+    """Cap the injected doc.
+
+    Line pass (from inject_relay.py): over INJECT_MAX_LINES, replace the unbounded `## Done` bullets
+    with a one-liner so `## Next step` / the resume prompt is never pushed off-screen; if the section
+    headers can't be found, keep the text as-is rather than lose data. Char pass: a hard tail-cut so a
+    pathological relay can't blow up the ephemeral message.
+    """
+    lines = text.splitlines()
+    if len(lines) > INJECT_MAX_LINES:
+        done_idx = next_step_idx = read_first_idx = None
+        for i, line in enumerate(lines):
+            s = line.strip()
+            if done_idx is None and s.startswith("## Done"):
+                done_idx = i
+            elif next_step_idx is None and s.startswith("## Next step"):
+                next_step_idx = i
+            elif read_first_idx is None and s.startswith("## Read first on resume"):
+                read_first_idx = i
+                break
+        if done_idx is not None and next_step_idx is not None and read_first_idx is not None:
+            omitted = len([l for l in lines[done_idx + 1:next_step_idx] if l.strip().startswith("-")])
+            summary = f"- [Done section truncated — {omitted} bullets omitted to save context; see git log]"
+            text = "\n".join(lines[:done_idx + 1] + [summary, ""] + lines[next_step_idx:])
+    if len(text) > INJECT_MAX_CHARS:
+        text = text[:INJECT_MAX_CHARS] + "\n\n[…relay truncated — read the file for the rest]"
+    return text
+
+
+def main() -> None:
+    try:
+        _reconfig = getattr(sys.stdout, "reconfigure", None)
+        if _reconfig:
+            try:
+                _reconfig(encoding="utf-8")
+            except Exception:
+                pass
+        try:
+            data = json.load(sys.stdin)
+        except Exception:
+            return
+        if not isinstance(data, dict):
+            return
+        # SessionStart equivalent: the FIRST invocation only. Anything else (or an unparseable
+        # invocationNum) injects nothing.
+        try:
+            if int(data.get("invocationNum")) != 1:
+                return
+        except Exception:
+            return
+        workspaces = data.get("workspacePaths") or []
+        if not (isinstance(workspaces, list) and workspaces):
+            return
+        root = str(workspaces[0])
+        relay = resolve_relay(root)
+        if not relay:
+            return
+        text = open(relay, encoding="utf-8").read().strip()
+        if not text:
+            return
+        message = ("=== relay.md (session resume — read before acting) ===\n\n"
+                   + truncate_relay(text))
+        payload = json.dumps({"injectSteps": [{"ephemeralMessage": message}]})
+        sys.stdout.write(payload)
+    except Exception:
+        return  # fail open: no injection is always better than a broken invocation
+    finally:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/bundles/manifest.json

@@ -0,0 +1,6 @@
+{
+  "poolVersion": "1.3.39",
+  "bundles": {
+    "antigravity-plugin": "1.3.39"
+  }
+}