opencode-skills-antigravity 1.0.13 → 1.0.14

package/bundled-skills/macos-spm-app-packaging/assets/templates/package_app.sh

@@ -0,0 +1,206 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+CONF=${1:-release}
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+cd "$ROOT"
+
+APP_NAME=${APP_NAME:-MyApp}
+BUNDLE_ID=${BUNDLE_ID:-com.example.myapp}
+MACOS_MIN_VERSION=${MACOS_MIN_VERSION:-14.0}
+MENU_BAR_APP=${MENU_BAR_APP:-0}
+SIGNING_MODE=${SIGNING_MODE:-}
+APP_IDENTITY=${APP_IDENTITY:-}
+
+if [[ -f "$ROOT/version.env" ]]; then
+  source "$ROOT/version.env"
+else
+  MARKETING_VERSION=${MARKETING_VERSION:-0.1.0}
+  BUILD_NUMBER=${BUILD_NUMBER:-1}
+fi
+
+ARCH_LIST=( ${ARCHES:-} )
+if [[ ${#ARCH_LIST[@]} -eq 0 ]]; then
+  HOST_ARCH=$(uname -m)
+  ARCH_LIST=("$HOST_ARCH")
+fi
+
+for ARCH in "${ARCH_LIST[@]}"; do
+  swift build -c "$CONF" --arch "$ARCH"
+done
+
+APP="$ROOT/${APP_NAME}.app"
+rm -rf "$APP"
+mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources" "$APP/Contents/Frameworks"
+
+# Convert Icon.icon to Icon.icns if present (requires iconutil).
+ICON_SOURCE="$ROOT/Icon.icon"
+ICON_TARGET="$ROOT/Icon.icns"
+if [[ -f "$ICON_SOURCE" ]]; then
+  iconutil --convert icns --output "$ICON_TARGET" "$ICON_SOURCE"
+fi
+
+LSUI_VALUE="false"
+if [[ "$MENU_BAR_APP" == "1" ]]; then
+  LSUI_VALUE="true"
+fi
+
+BUILD_TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+GIT_COMMIT=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+
+cat > "$APP/Contents/Info.plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key><string>${APP_NAME}</string>
+    <key>CFBundleDisplayName</key><string>${APP_NAME}</string>
+    <key>CFBundleIdentifier</key><string>${BUNDLE_ID}</string>
+    <key>CFBundleExecutable</key><string>${APP_NAME}</string>
+    <key>CFBundlePackageType</key><string>APPL</string>
+    <key>CFBundleShortVersionString</key><string>${MARKETING_VERSION}</string>
+    <key>CFBundleVersion</key><string>${BUILD_NUMBER}</string>
+    <key>LSMinimumSystemVersion</key><string>${MACOS_MIN_VERSION}</string>
+    <key>LSUIElement</key><${LSUI_VALUE}/>
+    <key>CFBundleIconFile</key><string>Icon</string>
+    <key>BuildTimestamp</key><string>${BUILD_TIMESTAMP}</string>
+    <key>GitCommit</key><string>${GIT_COMMIT}</string>
+</dict>
+</plist>
+PLIST
+
+build_product_path() {
+  local name="$1"
+  local arch="$2"
+  case "$arch" in
+    arm64|x86_64) echo ".build/${arch}-apple-macosx/$CONF/$name" ;;
+    *) echo ".build/$CONF/$name" ;;
+  esac
+}
+
+verify_binary_arches() {
+  local binary="$1"; shift
+  local expected=("$@")
+  local actual
+  actual=$(lipo -archs "$binary")
+  local actual_count expected_count
+  actual_count=$(wc -w <<<"$actual" | tr -d ' ')
+  expected_count=${#expected[@]}
+  if [[ "$actual_count" -ne "$expected_count" ]]; then
+    echo "ERROR: $binary arch mismatch (expected: ${expected[*]}, actual: ${actual})" >&2
+    exit 1
+  fi
+  for arch in "${expected[@]}"; do
+    if [[ "$actual" != *"$arch"* ]]; then
+      echo "ERROR: $binary missing arch $arch (have: ${actual})" >&2
+      exit 1
+    fi
+  done
+}
+
+install_binary() {
+  local name="$1"
+  local dest="$2"
+  local binaries=()
+  for arch in "${ARCH_LIST[@]}"; do
+    local src
+    src=$(build_product_path "$name" "$arch")
+    if [[ ! -f "$src" ]]; then
+      echo "ERROR: Missing ${name} build for ${arch} at ${src}" >&2
+      exit 1
+    fi
+    binaries+=("$src")
+  done
+  if [[ ${#ARCH_LIST[@]} -gt 1 ]]; then
+    lipo -create "${binaries[@]}" -output "$dest"
+  else
+    cp "${binaries[0]}" "$dest"
+  fi
+  chmod +x "$dest"
+  verify_binary_arches "$dest" "${ARCH_LIST[@]}"
+}
+
+install_binary "$APP_NAME" "$APP/Contents/MacOS/$APP_NAME"
+
+# Bundle app resources (if any).
+APP_RESOURCES_DIR="$ROOT/Sources/$APP_NAME/Resources"
+if [[ -d "$APP_RESOURCES_DIR" ]]; then
+  cp -R "$APP_RESOURCES_DIR/." "$APP/Contents/Resources/"
+fi
+
+# SwiftPM resource bundles are emitted next to the built binary.
+PREFERRED_BUILD_DIR="$(dirname "$(build_product_path "$APP_NAME" "${ARCH_LIST[0]}")")"
+shopt -s nullglob
+SWIFTPM_BUNDLES=("${PREFERRED_BUILD_DIR}/"*.bundle)
+shopt -u nullglob
+if [[ ${#SWIFTPM_BUNDLES[@]} -gt 0 ]]; then
+  for bundle in "${SWIFTPM_BUNDLES[@]}"; do
+    cp -R "$bundle" "$APP/Contents/Resources/"
+  done
+fi
+
+# Embed frameworks if any exist in the build folder.
+FRAMEWORK_DIRS=(".build/$CONF" ".build/${ARCH_LIST[0]}-apple-macosx/$CONF")
+for dir in "${FRAMEWORK_DIRS[@]}"; do
+  if compgen -G "${dir}/*.framework" >/dev/null; then
+    cp -R "${dir}/"*.framework "$APP/Contents/Frameworks/"
+    chmod -R a+rX "$APP/Contents/Frameworks"
+    install_name_tool -add_rpath "@executable_path/../Frameworks" "$APP/Contents/MacOS/$APP_NAME"
+    break
+  fi
+done
+
+if [[ -f "$ICON_TARGET" ]]; then
+  cp "$ICON_TARGET" "$APP/Contents/Resources/Icon.icns"
+fi
+
+# Ensure contents are writable before stripping attributes and signing.
+chmod -R u+w "$APP"
+
+# Strip extended attributes to prevent AppleDouble files that break code sealing.
+xattr -cr "$APP"
+find "$APP" -name '._*' -delete
+
+ENTITLEMENTS_DIR="$ROOT/.build/entitlements"
+DEFAULT_ENTITLEMENTS="$ENTITLEMENTS_DIR/${APP_NAME}.entitlements"
+mkdir -p "$ENTITLEMENTS_DIR"
+
+APP_ENTITLEMENTS=${APP_ENTITLEMENTS:-$DEFAULT_ENTITLEMENTS}
+if [[ ! -f "$APP_ENTITLEMENTS" ]]; then
+  cat > "$APP_ENTITLEMENTS" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Add entitlements here if needed. -->
+</dict>
+</plist>
+PLIST
+fi
+
+if [[ "$SIGNING_MODE" == "adhoc" || -z "$APP_IDENTITY" ]]; then
+  CODESIGN_ARGS=(--force --sign "-")
+else
+  CODESIGN_ARGS=(--force --timestamp --options runtime --sign "$APP_IDENTITY")
+fi
+
+# Sign embedded frameworks and their nested binaries before the app bundle.
+sign_frameworks() {
+  local fw
+  for fw in "$APP/Contents/Frameworks/"*.framework; do
+    if [[ ! -d "$fw" ]]; then
+      continue
+    fi
+    while IFS= read -r -d '' bin; do
+      codesign "${CODESIGN_ARGS[@]}" "$bin"
+    done < <(find "$fw" -type f -perm -111 -print0)
+    codesign "${CODESIGN_ARGS[@]}" "$fw"
+  done
+}
+sign_frameworks
+
+codesign "${CODESIGN_ARGS[@]}" \
+  --entitlements "$APP_ENTITLEMENTS" \
+  "$APP"
+
+echo "Created $APP"

package/bundled-skills/macos-spm-app-packaging/assets/templates/setup_dev_signing.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Setup stable development code signing to reduce keychain prompts.
+set -euo pipefail
+
+APP_NAME=${APP_NAME:-MyApp}
+CERT_NAME="${APP_NAME} Development"
+
+if security find-certificate -c "$CERT_NAME" >/dev/null 2>&1; then
+  echo "Certificate '$CERT_NAME' already exists."
+  echo "Export this in your shell profile:"
+  echo "  export APP_IDENTITY='$CERT_NAME'"
+  exit 0
+fi
+
+echo "Creating self-signed certificate '$CERT_NAME'..."
+
+TEMP_CONFIG=$(mktemp)
+trap "rm -f $TEMP_CONFIG" EXIT
+
+cat > "$TEMP_CONFIG" <<EOFCONF
+[ req ]
+distinguished_name = req_distinguished_name
+x509_extensions = v3_req
+prompt = no
+
+[ req_distinguished_name ]
+CN = $CERT_NAME
+O = ${APP_NAME} Development
+C = US
+
+[ v3_req ]
+keyUsage = critical,digitalSignature
+extendedKeyUsage = codeSigning
+EOFCONF
+
+openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 \
+    -nodes -keyout /tmp/dev.key -out /tmp/dev.crt \
+    -config "$TEMP_CONFIG" 2>/dev/null
+
+openssl pkcs12 -export -out /tmp/dev.p12 \
+    -inkey /tmp/dev.key -in /tmp/dev.crt \
+    -passout pass: 2>/dev/null
+
+security import /tmp/dev.p12 -k ~/Library/Keychains/login.keychain-db \
+  -T /usr/bin/codesign -T /usr/bin/security
+
+rm -f /tmp/dev.{key,crt,p12}
+
+echo ""
+echo "Trust this certificate for code signing in Keychain Access."
+echo "Then export in your shell profile:"
+echo "  export APP_IDENTITY='$CERT_NAME'"

package/bundled-skills/macos-spm-app-packaging/assets/templates/sign-and-notarize.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_NAME=${APP_NAME:-MyApp}
+APP_IDENTITY=${APP_IDENTITY:-"Developer ID Application: Example (TEAMID)"}
+APP_BUNDLE="${APP_NAME}.app"
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+source "$ROOT/version.env"
+ZIP_NAME="${APP_NAME}-${MARKETING_VERSION}.zip"
+
+if [[ -z "${APP_STORE_CONNECT_API_KEY_P8:-}" || -z "${APP_STORE_CONNECT_KEY_ID:-}" || -z "${APP_STORE_CONNECT_ISSUER_ID:-}" ]]; then
+  echo "Missing APP_STORE_CONNECT_* env vars (API key, key id, issuer id)." >&2
+  exit 1
+fi
+
+echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > /tmp/app-store-connect-key.p8
+trap 'rm -f /tmp/app-store-connect-key.p8 /tmp/${APP_NAME}Notarize.zip' EXIT
+
+ARCHES_VALUE=${ARCHES:-"arm64 x86_64"}
+ARCH_LIST=( ${ARCHES_VALUE} )
+for ARCH in "${ARCH_LIST[@]}"; do
+  swift build -c release --arch "$ARCH"
+done
+ARCHES="${ARCHES_VALUE}" "$ROOT/Scripts/package_app.sh" release
+
+ENTITLEMENTS_DIR="$ROOT/.build/entitlements"
+APP_ENTITLEMENTS="${APP_ENTITLEMENTS:-${ENTITLEMENTS_DIR}/${APP_NAME}.entitlements}"
+
+codesign --force --timestamp --options runtime --sign "$APP_IDENTITY" \
+  --entitlements "$APP_ENTITLEMENTS" \
+  "$APP_BUNDLE"
+
+DITTO_BIN=${DITTO_BIN:-/usr/bin/ditto}
+"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "/tmp/${APP_NAME}Notarize.zip"
+
+xcrun notarytool submit "/tmp/${APP_NAME}Notarize.zip" \
+  --key /tmp/app-store-connect-key.p8 \
+  --key-id "$APP_STORE_CONNECT_KEY_ID" \
+  --issuer "$APP_STORE_CONNECT_ISSUER_ID" \
+  --wait
+
+xcrun stapler staple "$APP_BUNDLE"
+
+xattr -cr "$APP_BUNDLE"
+find "$APP_BUNDLE" -name '._*' -delete
+
+"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "$ZIP_NAME"
+
+spctl -a -t exec -vv "$APP_BUNDLE"
+stapler validate "$APP_BUNDLE"
+
+echo "Done: $ZIP_NAME"

package/bundled-skills/macos-spm-app-packaging/assets/templates/version.env

@@ -0,0 +1,2 @@
+MARKETING_VERSION=0.1.0
+BUILD_NUMBER=1

package/bundled-skills/macos-spm-app-packaging/references/packaging.md

@@ -0,0 +1,17 @@
+# Packaging notes
+
+## Build output paths
+SwiftPM places binaries under:
+- `.build/<arch>-apple-macosx/<config>/<AppName>` for arch-specific builds
+- `.build/<config>/<AppName>` for some products (frameworks/tools)
+
+Use `ARCHES="arm64 x86_64"` with `swift build` to produce universal binaries.
+
+## Common environment variables (used by templates)
+- `APP_NAME`: App/binary name (for example, `MyApp`).
+- `BUNDLE_ID`: Bundle identifier (for example, `com.example.myapp`).
+- `ARCHES`: Space-separated architectures (default: host arch).
+- `SIGNING_MODE`: `adhoc` to avoid keychain prompts in dev.
+- `APP_IDENTITY`: Codesigning identity name for release builds.
+- `MACOS_MIN_VERSION`: Minimum macOS version for Info.plist.
+- `MENU_BAR_APP`: Set to `1` to add `LSUIElement` to Info.plist.

package/bundled-skills/macos-spm-app-packaging/references/release.md

@@ -0,0 +1,32 @@
+# Release and notarization notes
+
+## Notarization requirements
+- Install Xcode Command Line Tools (for `xcrun` and `notarytool`).
+- Provide App Store Connect API credentials:
+  - `APP_STORE_CONNECT_API_KEY_P8`
+  - `APP_STORE_CONNECT_KEY_ID`
+  - `APP_STORE_CONNECT_ISSUER_ID`
+- Provide a Developer ID Application identity in `APP_IDENTITY`.
+
+## Sparkle appcast (optional)
+- Install Sparkle tools so `generate_appcast` is on PATH.
+- Provide `SPARKLE_PRIVATE_KEY_FILE` (ed25519 key).
+- The appcast script uses your zip artifact to create an updated `appcast.xml`.
+- Sparkle compares `sparkle:version` (derived from `CFBundleVersion`), so bump `BUILD_NUMBER` for every release.
+
+## Tag and GitHub release (optional)
+Use a versioned git tag and publish a GitHub release with the notarized zip (and appcast if you host it on GitHub Releases).
+
+Example flow:
+```
+git tag v<version>
+git push origin v<version>
+
+gh release create v<version> CodexBar-<version>.zip appcast.xml \
+  --title "AppName <version>" \
+  --notes-file CHANGELOG.md
+```
+
+Notes:
+- If you serve appcast from GitHub Releases or raw URLs, ensure the release is published and assets are accessible (no 404s).
+- Prefer using a curated release notes file rather than dumping the full changelog.

package/bundled-skills/macos-spm-app-packaging/references/scaffold.md

@@ -0,0 +1,79 @@
+# Scaffold a SwiftPM macOS app (no Xcode)
+
+## Steps
+1) Create a repo and initialize SwiftPM:
+```
+mkdir MyApp
+cd MyApp
+swift package init --type executable
+```
+
+2) Update `Package.swift` to target macOS and define an executable target for the app.
+
+3) Create the app entry point under `Sources/MyApp/`.
+- Use SwiftUI if you want a windowed app with minimal AppKit glue.
+- Use AppKit if you want a menu bar or accessory-style app.
+
+4) If you need app resources, add:
+```
+resources: [.process("Resources")]
+```
+and create `Sources/MyApp/Resources/`.
+
+5) Add a `version.env` file (used by packaging templates):
+```
+MARKETING_VERSION=0.1.0
+BUILD_NUMBER=1
+```
+
+6) Copy script templates from `assets/templates/` into your repo (for example, `Scripts/`).
+
+## Minimal Package.swift (example)
+```
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "MyApp",
+    platforms: [.macOS(.v14)],
+    targets: [
+        .executableTarget(
+            name: "MyApp",
+            path: "Sources/MyApp",
+            resources: [
+                .process("Resources")
+            ])
+    ]
+)
+```
+
+## Minimal SwiftUI entry point (example)
+```
+import SwiftUI
+
+@main
+struct MyApp: App {
+    var body: some Scene {
+        WindowGroup {
+            Text("Hello")
+        }
+    }
+}
+```
+
+## Minimal AppKit entry point (example)
+```
+import AppKit
+
+final class AppDelegate: NSObject, NSApplicationDelegate {
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        // Initialize app state here.
+    }
+}
+
+let app = NSApplication.shared
+let delegate = AppDelegate()
+app.delegate = delegate
+app.setActivationPolicy(.regular)
+app.run()
+```

package/bundled-skills/orchestrate-batch-refactor/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: "orchestrate-batch-refactor"
+description: "Plan and execute large refactors with dependency-aware work packets and parallel analysis."
+risk: safe
+source: "Dimillian/Skills (MIT)"
+date_added: "2026-03-25"
+---
+
+# Orchestrate Batch Refactor
+
+## Overview
+
+Use this skill to run high-throughput refactors safely.
+Analyze scope in parallel, synthesize a single plan, then execute independent work packets with sub-agents.
+
+## When to Use
+
+- When a refactor spans many files or subsystems and needs clear work partitioning.
+- When you need dependency-aware planning before parallel implementation.
+
+## Inputs
+
+- Repo path and target scope (paths, modules, or feature area)
+- Goal type: refactor, rewrite, or hybrid
+- Constraints: behavior parity, API stability, deadlines, test requirements
+
+## When to Use Parallelization
+
+- Use this skill for medium/large scope touching many files or subsystems.
+- Skip multi-agent execution for tiny edits or highly coupled single-file work.
+
+## Core Workflow
+
+1. Define scope and success criteria.
+   - List target paths/modules and non-goals.
+   - State behavior constraints (for example: preserve external behavior).
+2. Run parallel analysis first.
+   - Split target scope into analysis lanes.
+   - Spawn `explorer` sub-agents in parallel to analyze each lane.
+   - Ask each agent for: intent map, coupling risks, candidate work packets, required validations.
+3. Build one dependency-aware plan.
+   - Merge explorer output into a single work graph.
+   - Create work packets with clear file ownership and validation commands.
+   - Sequence packets by dependency level; run only independent packets in parallel.
+4. Execute with worker agents.
+   - Spawn one `worker` per independent packet.
+   - Assign explicit ownership (files/responsibility).
+   - Instruct every worker that they are not alone in the codebase and must ignore unrelated edits.
+5. Integrate and verify.
+   - Review packet outputs, resolve overlaps, and run validation gates.
+   - Run targeted tests per packet, then broader suite for integrated scope.
+6. Report and close.
+   - Summarize packet outcomes, key refactors, conflicts resolved, and residual risks.
+
+## Work Packet Rules
+
+- One owner per file per execution wave.
+- No parallel edits on overlapping file sets.
+- Keep packet goals narrow and measurable.
+- Include explicit done criteria and required checks.
+- Prefer behavior-preserving refactors unless user explicitly requests behavior change.
+
+## Planning Contract
+
+Every packet must include:
+
+1. Packet ID and objective.
+2. Owned files.
+3. Dependencies (none or packet IDs).
+4. Risks and invariants to preserve.
+5. Required checks.
+6. Integration notes for main thread.
+
+Use [`references/work-packet-template.md`](references/work-packet-template.md) for the exact shape.
+
+## Agent Prompting Contract
+
+- Use the prompt templates in [`references/agent-prompt-templates.md`](references/agent-prompt-templates.md).
+- Explorer prompts focus on analysis and decomposition.
+- Worker prompts focus on implementation and validation with strict ownership boundaries.
+
+## Safety Guardrails
+
+- Do not start worker execution before plan synthesis is complete.
+- Do not parallelize across unresolved dependencies.
+- Do not claim completion if any required packet check fails.
+- Stop and re-plan when packet boundaries cause repeated merge conflicts.
+
+## Validation Strategy
+
+Run in this order:
+
+1. Packet-level checks (fast and scoped).
+2. Cross-packet integration checks.
+3. Full project safety checks when scope is broad.
+
+Prefer fast feedback loops, but never skip required behavior checks.

package/bundled-skills/orchestrate-batch-refactor/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Batch Refactor Orchestrator"
+  short_description: "Plan and parallelize large refactors safely."
+  default_prompt: "Use $orchestrate-batch-refactor to analyze target scope, plan parallel workstreams, and execute multi-agent refactors safely."

package/bundled-skills/orchestrate-batch-refactor/references/agent-prompt-templates.md

@@ -0,0 +1,53 @@
+# Agent Prompt Templates
+
+Use these templates when spawning sub-agents.
+
+## Explorer Prompt Template
+
+```
+Analyze the target scope and return decomposition guidance only.
+
+Scope:
+- Paths/modules: <fill>
+- Goal: <refactor|rewrite|hybrid>
+- Constraints: <behavior/API/test constraints>
+
+Return:
+1. Intent map (what each area currently does)
+2. Coupling and dependency risks
+3. Candidate work packets with non-overlapping ownership
+4. Validation commands per packet
+5. Recommended execution order
+```
+
+## Worker Prompt Template
+
+```
+You own this packet and are not alone in the codebase.
+Ignore unrelated edits by others and do not touch files outside ownership.
+
+Packet:
+- ID: <fill>
+- Objective: <fill>
+- Owned files: <fill>
+- Dependencies already completed: <fill>
+- Invariants to preserve: <fill>
+- Required checks: <fill>
+
+Execution requirements:
+1. Implement only the packet objective.
+2. Preserve specified invariants and external behavior.
+3. Run required checks and report exact results.
+4. Summarize changed files and any integration notes.
+```
+
+## Main Thread Synthesis Prompt Template
+
+```
+Merge explorer outputs into a single dependency-aware plan.
+Produce:
+1. Packet table with ownership and dependencies
+2. Parallel execution waves (no overlap per wave)
+3. Validation matrix by packet and integration stage
+4. Risk list with mitigation actions
+```

package/bundled-skills/orchestrate-batch-refactor/references/work-packet-template.md

@@ -0,0 +1,31 @@
+# Work Packet Template
+
+Use this template to define each packet before spawning workers.
+
+## Packet
+
+- `id`:
+- `objective`:
+- `mode`: `refactor` | `rewrite` | `hybrid`
+- `owner_agent_type`: `worker`
+- `owned_files`:
+- `dependencies`:
+- `invariants_to_preserve`:
+- `out_of_scope`:
+- `required_checks`:
+- `integration_notes`:
+- `done_criteria`:
+
+## Example
+
+- `id`: `P3`
+- `objective`: "Extract duplicated parsing logic from thread reducers into shared helper"
+- `mode`: `refactor`
+- `owner_agent_type`: `worker`
+- `owned_files`: `src/features/threads/hooks/threadReducer/*.ts`
+- `dependencies`: `P1`
+- `invariants_to_preserve`: "Thread ordering and hidden-thread filtering behavior"
+- `out_of_scope`: "UI rendering components"
+- `required_checks`: `npm run typecheck`, `npm run test -- src/features/threads/hooks`
+- `integration_notes`: "Main thread verifies no overlapping helper names with existing util package"
+- `done_criteria`: "No duplicated parsing block remains; all required checks pass"