talking-stick 0.4.11 → 0.4.13

package/README.md

@@ -2,7 +2,7 @@
 
 A CLI coordination tool that lets multiple AI coding agents share a single workspace without stepping on each other. One agent holds the stick at a time; handoffs carry structured context so the next agent doesn't have to re-derive it.
 
-**Version:** 0.4.1. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Gemini CLI, Grok Build, and OpenCode out of the box. Two agents in the same room can also chat out-of-band — without passing the stick — via `tt msg send/recv`.
+**Version:** 0.4.12. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Antigravity CLI (`agy`), Grok Build, and OpenCode out of the box. Gemini CLI identity is retained for existing sessions, but Gemini skill installation is deprecated in favor of Antigravity and the shared agents skill directory. Two agents in the same room can also chat out-of-band — without passing the stick — via `tt msg send/recv`.
 
 ## Quickstart
 
@@ -84,6 +84,8 @@ tt self-update
 tt uninstall --all
 ```
 
+Single-harness uninstalls for shared-reading harnesses leave `~/.agents/skills/talking-stick` in place because Codex, Antigravity, Grok, and OpenCode share that one skill location. Use `tt uninstall agents` or `tt uninstall --shared` to remove only the shared skill target.
+
 ## What it gives your agent
 
 Once installed, each agent harness has a skill that tells it to coordinate through the `tt` CLI:
@@ -163,17 +165,18 @@ For harnesses that only notice completed subprocesses, run `tt events --wait --a
 
 `tt install` installs or refreshes the bundled `talking-stick` skill. It does not add MCP servers. During install, uninstall, package update, and first run after an installed package version changes, `tt` removes stale MCP registrations written by older Talking Stick releases.
 
-- Claude Code: copied or linked into `~/.claude/skills/talking-stick`
-- Codex: copied or linked into `~/.codex/skills/talking-stick`
-- Gemini: installed with `gemini skills install ... --scope user` or linked with `gemini skills link ... --scope user`
-- Grok Build: copied or linked into `~/.grok/skills/talking-stick`, plus a trusted global session hook at `~/.grok/hooks/talking-stick-session.json`
-- OpenCode: copied or linked into the resolved OpenCode config directory, normally `~/.config/opencode/skills/talking-stick` and honoring `XDG_CONFIG_HOME`
+- Claude Code: copied or linked into `~/.claude/skills/talking-stick` because Claude Code does not read `~/.agents/skills`
+- Codex, Antigravity (`agy`), Grok Build, and OpenCode: copied or linked once into the shared `~/.agents/skills/talking-stick`
+- Grok Build: also installs a trusted global session hook at `~/.grok/hooks/talking-stick-session.json`
+- Gemini CLI: deprecated for skill installation; `tt install gemini` prints a deprecation notice and runs cleanup only
+
+By default, `tt install` links the bundled skill so local updates are picked up immediately. Pass `--copy` if you want a standalone snapshot.
 
-By default, `tt install` links the bundled skill into each harness so local updates are picked up immediately. Pass `--copy` if you want a standalone snapshot instead.
+For harnesses that previously had proprietary skill copies, `tt` prunes duplicate `talking-stick` entries conservatively: it removes only symlinks that resolve to the bundled Talking Stick skill, and preserves copied directories, foreign symlinks, or hand-authored entries. OpenCode cleanup checks both `~/.config/opencode/skills/talking-stick` (honoring `XDG_CONFIG_HOME`) and the older `~/.opencode/skills/talking-stick` location.
 
-Stale MCP cleanup is strict for OpenCode JSON entries: it removes only the canonical `mcp.talking-stick` value with `["tt", "mcp"]` and leaves hand-edited entries alone. Claude Code, Codex, and Gemini cleanup uses their own `mcp remove` commands when the old server name exists. Grok Build has no Talking Stick MCP registration path; install is native skill plus hook only. Every cleanup run appends JSONL audit entries to `${TALKING_STICK_DATA_DIR}/update-migrations.log`.
+Stale MCP cleanup is strict for OpenCode JSON entries: it removes only the canonical `mcp.talking-stick` value with `["tt", "mcp"]` and leaves hand-edited entries alone. Claude Code, Codex, and Gemini cleanup uses their own `mcp remove` commands when the old server name exists. Grok Build and Antigravity have no Talking Stick MCP registration path; install is native skill plus hook/shared skill only. Every cleanup run appends JSONL audit entries to `${TALKING_STICK_DATA_DIR}/update-migrations.log`.
 
-Human CLI invocations also perform a silent best-effort sync for already-installed file-based skills in Claude Code, Codex, Grok Build, and OpenCode. If the installed skill is a copy, it is refreshed from the bundled skill; if it is a stale symlink, it is relinked. Missing harness config directories and missing skill installs are skipped. Gemini skills are managed by Gemini's own registry, so use `tt install gemini` after updating when needed.
+Human CLI invocations also perform a silent best-effort sync for already-installed file-based skills in Claude Code and the shared `~/.agents/skills/talking-stick` target. If the installed skill is a copy, it is refreshed from the bundled skill; if it is a stale symlink, it is relinked. Missing skill installs are skipped. Gemini skill sync is deprecated; use Antigravity/shared install instead.
 
 ## Human CLI
 
@@ -190,7 +193,7 @@ tt state [path]                                           # full room state
 tt events [path] [--after N] [--limit N] [--wait|--follow] [--event TYPE[,TYPE]] [--target self|any|agent]  # room event log; --wait/--follow long-polls
 tt msg send <recipient|room> <body...> [--interrupt] [--stdin] [--path DIR]  # send an OOB message
 tt msg recv [--wait|--follow] [--from agent] [--after N] [--target self|any|agent] [--path DIR]  # receive OOB messages
-tt instructions show [path] [--harness claude|codex|gemini|grok|opencode|all] [--scope effective|bundled|user|project]  # show collaboration prompt
+tt instructions show [path] [--harness claude|codex|antigravity|gemini|grok|opencode|all] [--scope effective|bundled|user|project]  # show collaboration prompt
 tt instructions edit [path] [--user|--project]             # edit user or project prompt
 tt instructions reset [path] (--user|--project)            # delete a user or project prompt
 tt release [path] --status TEXT --next-action TEXT        # normal handoff
@@ -201,7 +204,7 @@ tt takeover [path] [--reason TEXT]                        # alias for take
 tt notes add <body> [--turn N] [--path DIR] [--stdin]     # leave an async note
 tt notes list [--all] [--after ID] [--limit N] [--path DIR] # read notes
 tt install <harness...> | --all [--print] [--copy] [--link]  # install skill and clean stale MCP entries
-tt uninstall <harness...> | --all [--print]               # remove skill and stale MCP entries
+tt uninstall <harness...|agents> | --all | --shared [--print] # remove skill and stale MCP entries
 tt self-update [--print] [--manager npm|pnpm|yarn|bun]    # update to the latest published tt
 ```
 
@@ -217,7 +220,7 @@ By default, `tt` behaves like a human CLI and resolves to `human:<username>` onl
 
 Harness-aware CLI identity is resolved before the human fallback:
 
-- Known harness environment markers such as `CLAUDECODE=1`, `CODEX_THREAD_ID`, `GEMINI_CLI=1`, `CMUX_AGENT_LAUNCH_KIND=grok`, or `OPENCODE=1` make `tt` derive a harness-style identity automatically. The cmux Grok marker is optional; Grok Build also works without cmux by walking process ancestry for a `grok` root process.
+- Known harness environment markers such as `CLAUDECODE=1`, `CODEX_THREAD_ID`, `ANTIGRAVITY_AGENT=1`, `ANTIGRAVITY_CONVERSATION_ID`, `ANTIGRAVITY_TRAJECTORY_ID`, `GEMINI_CLI=1`, `CMUX_AGENT_LAUNCH_KIND=grok`, or `OPENCODE=1` make `tt` derive a harness-style identity automatically. Antigravity uses `ANTIGRAVITY_CONVERSATION_ID` as the preferred session anchor, falling back to `ANTIGRAVITY_TRAJECTORY_ID` and then `agy` process ancestry. The cmux Grok marker is optional; Grok Build also works without cmux by walking process ancestry for a `grok` root process.
 - Grok Build's installed hook records hook-only `GROK_SESSION_ID` context into `${TALKING_STICK_DATA_DIR}/grok-sessions.jsonl`, letting later Grok-launched `tt` calls upgrade from process identity to the real Grok session id. `GROK_SESSION_ID` by itself is not treated as a normal shell marker, and the hook is not required for basic Grok detection.
 - Set `TT_HARNESS_AGENT_ID=<agent-id>` if the harness wants to export the exact agent id directly.
 - Set `TT_HARNESS_EXPORT=1` only when you need ancestry-based harness detection without a known harness environment marker.

package/dist/cli/install-commands.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
-import { SUPPORTED_HARNESSES, detectHarness, parseHarnessList, planGrokSessionHookInstall, planGrokSessionHookUninstall, planUninstall, runAction } from "../install.js";
-import { planSkillInstall, planSkillUninstall } from "../skill-install.js";
+import { SUPPORTED_HARNESSES, detectHarness, isDeprecatedHarness, parseHarnessList, planGrokSessionHookInstall, planGrokSessionHookUninstall, planUninstall, runAction } from "../install.js";
+import { removeDuplicateSkillInstalls, planSkillInstall, planSkillUninstall, planSharedSkillUninstall, resolveDuplicateSkillTargetPaths } from "../skill-install.js";
 import { resolveDataDir } from "../config.js";
 import { FileAuditLog, defaultAuditLogPath } from "../install-audit.js";
 import { removeStaleMcpRegistrations } from "../install-migration.js";
@@ -15,32 +15,44 @@ export async function runInstallCommand(parsed) {
         skipMissing: true
     };
     if (dryRun) {
-        for (const action of planInstallActions(harnesses, installOptions)) {
+        printDeprecatedHarnessNotices(harnesses);
+        for (const action of dedupeInstallActions(planInstallActions(harnesses, installOptions))) {
             printActionPlan(action);
         }
         for (const action of planCleanupActions(harnesses, installOptions)) {
             printActionPlan(action);
         }
+        printDuplicateSkillCleanupPlan(harnesses, installOptions);
         return;
     }
-    const results = (await Promise.all(harnesses.map((harness) => runSkillInstall(harness, installOptions)))).flat();
+    printDeprecatedHarnessNotices(harnesses);
+    const results = await runSkillInstallActions(dedupeInstallActions(planInstallActions(harnesses, installOptions)), installOptions);
     reportInstallResults(results, "install");
     reportCleanupResults(await runCleanup(harnesses, "manual", installOptions), "install");
     printInstructionHint(results);
 }
 export async function runUninstallCommand(parsed) {
-    const harnesses = selectHarnesses(parsed);
+    const { harnesses, removeShared } = selectUninstallTargets(parsed);
     const dryRun = hasOption(parsed, "print");
     const installOptions = { skipMissing: true };
-    const actions = planUninstallActions(harnesses, installOptions);
+    const actions = [
+        ...planUninstallActions(harnesses, installOptions),
+        ...(removeShared ? [planSharedSkillUninstall(installOptions)] : [])
+    ];
     if (dryRun) {
+        printDeprecatedHarnessNotices(harnesses);
         for (const action of actions) {
             printActionPlan(action);
         }
+        printSharedSkillLeftHint(harnesses, removeShared);
         return;
     }
     const results = (await Promise.all(harnesses.map((harness) => runSkillUninstall(harness, installOptions)))).flat();
+    if (removeShared) {
+        results.push(await runAction(planSharedSkillUninstall(installOptions), installOptions));
+    }
     reportInstallResults(results, "uninstall");
+    printSharedSkillLeftHint(harnesses, removeShared);
     reportCleanupResults(await runCleanup(harnesses, "uninstall", installOptions), "uninstall");
 }
 export async function runInstallSkillCommand(parsed) {
@@ -48,21 +60,25 @@ export async function runInstallSkillCommand(parsed) {
     const dryRun = hasOption(parsed, "print");
     const link = resolveSkillInstallLinkMode(parsed);
     const installOptions = { link, skipMissing: true };
-    const actions = harnesses.map((harness) => planSkillInstall(harness, installOptions));
+    const actions = dedupeInstallActions(harnesses.map((harness) => planSkillInstall(harness, installOptions)));
     if (dryRun) {
         for (const action of actions) {
             printActionPlan(action);
         }
         return;
     }
+    printDeprecatedHarnessNotices(harnesses);
     const results = await Promise.all(actions.map((action) => runAction(action, installOptions)));
     reportInstallResults(results, "install");
 }
 export async function runUninstallSkillCommand(parsed) {
-    const harnesses = selectHarnesses(parsed);
+    const { harnesses, removeShared } = selectUninstallTargets(parsed);
     const dryRun = hasOption(parsed, "print");
     const installOptions = { skipMissing: true };
-    const actions = harnesses.map((harness) => planSkillUninstall(harness, installOptions));
+    const actions = [
+        ...harnesses.map((harness) => planSkillUninstall(harness, installOptions)),
+        ...(removeShared ? [planSharedSkillUninstall(installOptions)] : [])
+    ];
     if (dryRun) {
         for (const action of actions) {
             printActionPlan(action);
@@ -71,6 +87,7 @@ export async function runUninstallSkillCommand(parsed) {
     }
     const results = await Promise.all(actions.map((action) => runAction(action, installOptions)));
     reportInstallResults(results, "uninstall");
+    printSharedSkillLeftHint(harnesses, removeShared);
 }
 export async function runSelfUpdateCommand(parsed, cliEntryUrl) {
     const dryRun = hasOption(parsed, "print");
@@ -137,6 +154,27 @@ function resolveSkillInstallLinkMode(parsed) {
 function planInstallActions(harnesses, installOptions) {
     return harnesses.flatMap((harness) => planInstallActionsForHarness(harness, installOptions));
 }
+function dedupeInstallActions(actions) {
+    const seen = new Set();
+    const result = [];
+    for (const action of actions) {
+        const key = installActionDedupeKey(action);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(action);
+    }
+    return result;
+}
+function installActionDedupeKey(action) {
+    if (action.kind === "file-patch") {
+        return `${action.kind}:${action.operation ?? "op"}:${action.filePath}`;
+    }
+    if (action.kind === "exec") {
+        return `${action.kind}:${action.operation ?? "op"}:${action.command}:${action.args.join("\0")}`;
+    }
+    return `${action.kind}:${action.harness}:${action.message}`;
+}
 function planUninstallActions(harnesses, installOptions) {
     return harnesses.flatMap((harness) => [
         planSkillUninstall(harness, {
@@ -157,8 +195,7 @@ function planUninstallActions(harnesses, installOptions) {
 function planCleanupActions(harnesses, installOptions) {
     return harnesses.map((harness) => planUninstall(harness, installOptions));
 }
-async function runSkillInstall(harness, installOptions) {
-    const actions = planInstallActionsForHarness(harness, installOptions);
+async function runSkillInstallActions(actions, installOptions) {
     return Promise.all(actions.map((action) => runAction(action, installOptions)));
 }
 async function runSkillUninstall(harness, installOptions) {
@@ -186,16 +223,24 @@ function planInstallActionsForHarness(harness, installOptions) {
 }
 async function runCleanup(harnesses, reason, installOptions) {
     const dataDir = resolveDataDir();
-    return removeStaleMcpRegistrations({
+    const audit = new FileAuditLog(defaultAuditLogPath(dataDir));
+    const mcpResults = await removeStaleMcpRegistrations({
         harnesses,
         reason,
-        audit: new FileAuditLog(defaultAuditLogPath(dataDir)),
+        audit,
         installOptions
     });
+    const skillResults = removeDuplicateSkillInstalls({
+        harnesses,
+        reason,
+        audit,
+        ...installOptions
+    });
+    return [...mcpResults, ...skillResults];
 }
 function selectHarnesses(parsed) {
     if (hasOption(parsed, "all")) {
-        const detected = SUPPORTED_HARNESSES.filter((harness) => detectHarness(harness).detected);
+        const detected = SUPPORTED_HARNESSES.filter((harness) => !isDeprecatedHarness(harness) && detectHarness(harness).detected);
         return [...detected];
     }
     if (parsed.positionals.length === 0) {
@@ -203,6 +248,38 @@ function selectHarnesses(parsed) {
     }
     return parseHarnessList(parsed.positionals);
 }
+function selectUninstallTargets(parsed) {
+    if (hasOption(parsed, "all")) {
+        return { harnesses: [...SUPPORTED_HARNESSES], removeShared: true };
+    }
+    const removeShared = hasOption(parsed, "shared") || parsed.positionals.includes("agents");
+    const harnessTokens = parsed.positionals.filter((value) => value !== "agents");
+    if (harnessTokens.length === 0) {
+        if (removeShared)
+            return { harnesses: [], removeShared: true };
+        throw new Error(`Specify at least one harness (${SUPPORTED_HARNESSES.join(", ")}, agents) or pass --all to target every installed one.`);
+    }
+    return {
+        harnesses: parseHarnessList(harnessTokens),
+        removeShared
+    };
+}
+function printDeprecatedHarnessNotices(harnesses) {
+    if (!harnesses.includes("gemini"))
+        return;
+    process.stdout.write("[gemini] deprecated: Gemini CLI skill install is deprecated; use `tt install antigravity`.\n");
+}
+function printSharedSkillLeftHint(harnesses, removeShared) {
+    if (removeShared)
+        return;
+    if (!harnesses.some((harness) => harness === "codex" ||
+        harness === "grok" ||
+        harness === "opencode" ||
+        harness === "antigravity")) {
+        return;
+    }
+    process.stdout.write("Left ~/.agents/skills/talking-stick (shared with other agents). Run `tt uninstall --all` or `tt uninstall agents` to remove the shared skill.\n");
+}
 function printActionPlan(action) {
     if (action.kind === "skip") {
         return;
@@ -213,6 +290,13 @@ function printActionPlan(action) {
     }
     process.stdout.write(`[${action.harness}] ${action.description}\n`);
 }
+function printDuplicateSkillCleanupPlan(harnesses, installOptions) {
+    for (const harness of harnesses) {
+        for (const targetPath of resolveDuplicateSkillTargetPaths(harness, installOptions)) {
+            process.stdout.write(`[${harness}] remove duplicate skill symlink ${targetPath} if it points at bundled skill\n`);
+        }
+    }
+}
 function runInheritIo(command, args) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, { stdio: "inherit", shell: false });
@@ -238,21 +322,26 @@ function reportInstallResults(results, mode) {
         throw new Error(`${mode} completed with failures.`);
     }
 }
-function printInstructionHint(results) {
-    if (!results.some((result) => result.ok && !result.skipped)) {
+export function printInstructionHint(results) {
+    const changed = new Set(["added", "updated", "ok"]);
+    if (!results.some((result) => result.ok && changed.has(result.status))) {
         return;
     }
     process.stdout.write("Customize collaboration instructions with: tt instructions edit\n");
 }
-function reportCleanupResults(results, mode) {
+export function reportCleanupResults(results, mode) {
     let anyFailed = false;
     for (const result of results) {
-        process.stdout.write(`[${result.harness}] mcp-cleanup ${result.action}: ${result.message}\n`);
+        if (result.action === "absent" || result.action === "skipped") {
+            continue;
+        }
+        const label = result.target_type === "skill" ? "skill-cleanup" : "mcp-cleanup";
+        process.stdout.write(`[${result.harness}] ${label} ${result.action}: ${result.message}\n`);
         if (result.action === "failed")
             anyFailed = true;
     }
     if (anyFailed) {
-        throw new Error(`${mode} completed with MCP cleanup failures.`);
+        throw new Error(`${mode} completed with cleanup failures.`);
     }
 }
 function formatInstallStatus(status) {

package/dist/cli/output.js

@@ -164,7 +164,7 @@ Commands:
   tt events [path] [--after N] [--limit N] [--wait|--follow] [--event TYPE[,TYPE]] [--target self|any|agent]
   tt msg send <recipient|room> <body...> [--interrupt] [--stdin] [--path DIR]
   tt msg recv [--wait|--follow] [--from agent] [--after N] [--target self|any|agent] [--path DIR]
-  tt instructions show [path] [--harness claude|codex|gemini|grok|opencode|all] [--scope effective|bundled|user|project]
+  tt instructions show [path] [--harness claude|codex|antigravity|gemini|grok|opencode|all] [--scope effective|bundled|user|project]
   tt instructions edit [path] [--user|--project]
   tt instructions reset [path] (--user|--project)
   tt release [path] (--status TEXT --next-action TEXT | --stdin)
@@ -175,7 +175,7 @@ Commands:
   tt notes add <body> [--turn N] [--path DIR] [--stdin]
   tt notes list [--all] [--after NOTE_ID] [--limit N] [--path DIR]
   tt install <harness...> | --all [--print] [--copy] [--link]
-  tt uninstall <harness...> | --all [--print]
+  tt uninstall <harness...|agents> | --all | --shared [--print]
   tt self-update [--print] [--manager npm|pnpm|yarn|bun]
 
 Harnesses: ${SUPPORTED_HARNESSES.join(", ")}

package/dist/cli/parser.js

@@ -16,6 +16,7 @@ const BOOLEAN_FLAGS = new Set([
     "project",
     "quiet",
     "room",
+    "shared",
     "stdin",
     "text",
     "user",

package/dist/cli/registry.js

@@ -39,7 +39,7 @@ export const COMMAND_REGISTRY = [
         needsRuntime: false,
         startupMaintenance: false,
         internal: false,
-        usage: "tt uninstall <harness...> | --all [--print]",
+        usage: "tt uninstall <harness...|agents> | --all | --shared [--print]",
         description: "Remove the Talking Stick skill and stale MCP registrations.",
         handler: ({ parsed }) => runUninstallCommand(parsed)
     },

package/dist/harness-model.js

@@ -0,0 +1,44 @@
+export const HARNESS_SKILL_MODELS = {
+    "claude-code": {
+        identity: "claude",
+        commandLabels: ["claude", "claude-code"],
+        skillLoadingModel: "proprietary"
+    },
+    codex: {
+        identity: "codex",
+        commandLabels: ["codex"],
+        skillLoadingModel: "shared+proprietary"
+    },
+    antigravity: {
+        identity: "antigravity",
+        commandLabels: ["agy", "antigravity"],
+        skillLoadingModel: "shared"
+    },
+    grok: {
+        identity: "grok",
+        commandLabels: ["grok"],
+        skillLoadingModel: "shared+proprietary"
+    },
+    opencode: {
+        identity: "opencode",
+        commandLabels: ["opencode"],
+        skillLoadingModel: "shared+proprietary"
+    },
+    gemini: {
+        identity: "gemini",
+        commandLabels: ["gemini"],
+        skillLoadingModel: "deprecated",
+        deprecated: true
+    }
+};
+export const SUPPORTED_HARNESSES = Object.keys(HARNESS_SKILL_MODELS);
+export const FILE_SKILL_HARNESSES = SUPPORTED_HARNESSES.filter((harness) => HARNESS_SKILL_MODELS[harness].skillLoadingModel !== "deprecated");
+export const HARNESS_CLI_HARNESSES = Array.from(new Set(SUPPORTED_HARNESSES.map((harness) => HARNESS_SKILL_MODELS[harness].identity)));
+export const HARNESS_COMMAND_MAPPING = Object.fromEntries(SUPPORTED_HARNESSES.flatMap((harness) => HARNESS_SKILL_MODELS[harness].commandLabels.map((label) => [
+    label,
+    HARNESS_SKILL_MODELS[harness].identity
+])));
+export function isDeprecatedHarness(harness) {
+    const model = HARNESS_SKILL_MODELS[harness];
+    return model.deprecated === true;
+}

package/dist/identity.js

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { findGrokSessionRecord, resolveGrokSessionLogPath } from "./grok-session-store.js";
+import { HARNESS_COMMAND_MAPPING } from "./harness-model.js";
 import { resolveContextPath } from "./path-resolution.js";
 import { createSystemProcessInspector } from "./process-utils.js";
 const HARNESS_CLI_EXPORT_ENV = "TT_HARNESS_EXPORT";
@@ -233,14 +234,6 @@ function deriveHarnessDisplayName(agentId) {
     const prefix = agentId.split(":")[0]?.trim();
     return prefix && prefix.length > 0 ? prefix : "harness";
 }
-const HARNESS_COMMAND_MAPPING = {
-    claude: "claude",
-    "claude-code": "claude",
-    codex: "codex",
-    gemini: "gemini",
-    grok: "grok",
-    opencode: "opencode"
-};
 function detectHarnessViaAncestry(pid, inspector, maxDepth = 10) {
     let currentPid = pid;
     for (let i = 0; i < maxDepth; i++) {
@@ -279,6 +272,16 @@ function detectHarnessSignal(env) {
             pidHint: null
         };
     }
+    if (env.ANTIGRAVITY_AGENT === "1" ||
+        nonEmpty(env.ANTIGRAVITY_CONVERSATION_ID) ||
+        nonEmpty(env.ANTIGRAVITY_TRAJECTORY_ID)) {
+        return {
+            harness: "antigravity",
+            sessionId: nonEmpty(env.ANTIGRAVITY_CONVERSATION_ID) ??
+                nonEmpty(env.ANTIGRAVITY_TRAJECTORY_ID),
+            pidHint: null
+        };
+    }
     if (env.GEMINI_CLI === "1") {
         return { harness: "gemini", sessionId: null, pidHint: null };
     }

package/dist/index.js

@@ -4,10 +4,11 @@ export { applyPragmas, assertLocalFilesystem, detectFilesystemType, migrate, ope
 export { ProtocolError, isProtocolError } from "./errors.js";
 export { deriveHarnessCliIdentity, deriveHumanCliIdentity, deriveMcpHarnessIdentity } from "./identity.js";
 export { ancestorPaths, canonicalizeContextPath, resolveContextPath, resolveWorkspaceRoot } from "./path-resolution.js";
-export { DEFAULT_MAX_INSTRUCTION_FILE_BYTES, DEFAULT_INSTRUCTIONS_MARKDOWN, editInstructions, extractHarnessInstructions, normalizeInstructionHarness, parseInstructionScope, resetInstructions, resolveInstructionHarness, resolveInstructionPaths, showInstructions } from "./instructions.js";
+export { DEFAULT_MAX_INSTRUCTION_FILE_BYTES, DEFAULT_INSTRUCTIONS_MARKDOWN, HARNESS_ALIASES, INSTRUCTION_HARNESSES, editInstructions, extractHarnessInstructions, normalizeInstructionHarness, parseInstructionScope, resetInstructions, resolveInstructionHarness, resolveInstructionPaths, showInstructions } from "./instructions.js";
 export { SUPPORTED_HARNESSES, buildGrokSessionHookConfig, DEFAULT_GROK_SESSION_HOOK_COMMAND, GROK_SESSION_HOOK_EVENTS, GROK_SESSION_HOOK_FILE, MissingHarnessError, detectHarness, parseHarnessList, planGrokSessionHookInstall, planGrokSessionHookUninstall, planUninstall, resolveGrokSessionHookPath, resolveHarnessConfigDir, resolveOpencodeConfigDir, resolveOpencodeConfigPath, runAction, skipAction } from "./install.js";
 export { DEFAULT_GROK_SESSION_RECORD_MAX_AGE_MS, appendGrokSessionRecord, findGrokSessionRecord, isGrokSessionEndEvent, readGrokSessionRecords, resolveGrokSessionLogPath } from "./grok-session-store.js";
-export { DEFAULT_SKILL_NAME, planSkillInstall, planSkillUninstall, resolveBundledSkillPath, resolveSkillTargetPath, syncInstalledSkills } from "./skill-install.js";
+export { FILE_SKILL_HARNESSES, DEFAULT_SKILL_NAME, removeDuplicateSkillInstalls, planSkillInstall, planSkillUninstall, planSharedSkillUninstall, resolveBundledSkillPath, resolveDuplicateSkillTargetPaths, resolveLegacyOpencodeSkillTargetPath, resolvePrimarySkillTargetPath, resolveSharedAgentsSkillsDir, resolveSharedSkillTargetPath, resolveSkillTargetPath, skillLoadingModel, syncInstalledSkills } from "./skill-install.js";
+export { HARNESS_CLI_HARNESSES, HARNESS_COMMAND_MAPPING, HARNESS_SKILL_MODELS, isDeprecatedHarness } from "./harness-model.js";
 export { readPackageVersion, readUpdateMigrationState, resolveUpdateMigrationStatePath, runFirstRunMcpMigration, runStaleMcpCleanup, writeUpdateMigrationState } from "./update-migration.js";
 export { createSystemProcessInspector, terminateKnownProcess } from "./process-utils.js";
 export { clearCliSessionLease, findCliSessionByRoom, findCliSessionForContextPath, readCliSessions, removeCliSession, removeCliSessionsForRoom, resolveCliSessionPath, upsertCliSession, upsertJoinedCliSession, writeCliSessions } from "./session-store.js";

package/dist/install-migration.js

@@ -20,12 +20,18 @@ export async function removeStaleMcpRegistrations(options) {
             package_version_to: options.packageVersionTo,
             harness,
             config_path: result.configPath,
+            target_type: "mcp",
             action: result.action,
             server_name: result.serverName,
             detail: result.message
         });
     }
-    return results.map(({ harness, action, message }) => ({ harness, action, message }));
+    return results.map(({ harness, action, message }) => ({
+        harness,
+        action,
+        message,
+        target_type: "mcp"
+    }));
 }
 async function removeOneHarness(harness, installOptions, strict) {
     const action = planUninstall(harness, installOptions);

package/dist/install.js

@@ -3,7 +3,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { writeFileAtomic } from "./atomic-write.js";
-export const SUPPORTED_HARNESSES = ["claude-code", "codex", "gemini", "grok", "opencode"];
+import { SUPPORTED_HARNESSES } from "./harness-model.js";
+export { SUPPORTED_HARNESSES, isDeprecatedHarness } from "./harness-model.js";
 export const DEFAULT_SERVER_NAME = "talking-stick";
 // Legacy MCP command retained only to identify stale config entries for removal.
 export const DEFAULT_SERVER_COMMAND = ["tt", "mcp"];
@@ -127,6 +128,8 @@ function resolveHarnessConfigDirFromResolved(harness, resolved) {
             return path.join(resolved.homeDir, ".claude");
         case "codex":
             return path.join(resolved.homeDir, ".codex");
+        case "antigravity":
+            return path.join(resolved.homeDir, ".agents");
         case "gemini":
             return path.join(resolved.homeDir, ".gemini");
         case "grok":
@@ -166,6 +169,8 @@ export function planUninstall(harness, options = {}) {
                 operation: "uninstall",
                 serverName: resolved.serverName
             };
+        case "antigravity":
+            return skipAction(harness, "legacy Talking Stick cleanup is not applicable for antigravity");
         case "gemini":
             if (resolved.skipMissing && !resolved.hooks.which("gemini")) {
                 return skipAction(harness, "gemini not on PATH");
@@ -225,6 +230,7 @@ export function planGrokSessionHookInstall(options = {}) {
         harness: "grok",
         filePath,
         description: `write Grok session hook ${filePath}`,
+        operation: "install",
         inspect: () => inspectGrokSessionHook(filePath, resolved),
         apply: () => writeGrokSessionHook(filePath, resolved)
     };
@@ -381,6 +387,12 @@ export function detectHarness(harness, options = {}) {
                 return { harness, detected: true, evidence: configDir };
             return { harness, detected: false, evidence: "codex not on PATH and no config directory" };
         }
+        case "antigravity": {
+            const bin = resolved.hooks.which("agy");
+            if (bin)
+                return { harness, detected: true, evidence: bin };
+            return { harness, detected: false, evidence: "agy not on PATH" };
+        }
         case "gemini": {
             const bin = resolved.hooks.which("gemini");
             if (bin)
@@ -569,6 +581,8 @@ export async function runAction(action, options = {}) {
     }
 }
 async function inspectExecAction(action, resolved) {
+    if (action.inspect)
+        return action.inspect();
     if (!action.operation || !action.serverName)
         return "unknown";
     if (action.harness === "gemini") {
@@ -615,6 +629,9 @@ function formatMcpActionMessage(action, status, fallback) {
                     break;
             }
         }
+        if (action.kind === "exec" && status === "already_present") {
+            return "skill is already installed.";
+        }
         return fallback ?? "ok";
     }
     const target = `MCP server '${action.serverName}'`;
@@ -642,6 +659,8 @@ function mcpConfigLocation(action) {
             return "Claude Code user config";
         case "codex":
             return "Codex global config";
+        case "antigravity":
+            return "Antigravity shared config";
         case "gemini":
             return "Gemini user config";
         case "grok":

package/dist/instructions.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { resolveDataDir } from "./config.js";
+import { HARNESS_CLI_HARNESSES } from "./harness-model.js";
 import { resolveContextPath } from "./path-resolution.js";
 export const DEFAULT_MAX_INSTRUCTION_FILE_BYTES = 256 * 1024;
 export const DEFAULT_INSTRUCTIONS_MARKDOWN = `# Talking Stick collaboration instructions
@@ -12,7 +13,7 @@ On freshly invoked multi-agent tasks, give peers a short window to join before d
 
 Use phase names in handoffs when they clarify the work: draft, adversarial review, convergence, implementation, implementation review, test review, and release. These phases are vocabulary, not protocol state.
 
-Claude and Codex are peers of comparable capability; neither outranks the other. Split work evenly between them rather than routing by stereotype, and have all models plan, implement, and evaluate together: any harness can draft, review, converge, implement, or release. Gemini and OpenCode start with conservative local guidance until project dogfood says otherwise.
+Claude and Codex are peers of comparable capability; neither outranks the other. Split work evenly between them rather than routing by stereotype, and have all models plan, implement, and evaluate together: any harness can draft, review, converge, implement, or release. Antigravity and OpenCode start with conservative local guidance until project dogfood says otherwise.
 
 For multi-agent design work, prefer independent read-only drafts first, then adversarial review and convergence. Do not impose a draft file structure on the workspace by default. If scratch draft files are useful, delete superseded pre-convergence drafts after the converged plan exists unless the operator asks to keep them.
 
@@ -26,9 +27,9 @@ Take a full, even share of planning, implementation, and evaluation. Watch for s
 
 Take a full, even share of planning, implementation, and evaluation. Watch for over-indexing on mechanics when the operator still needs to decide direction. Make the next phase explicit in the handoff.
 
-## Gemini
+## Antigravity
 
-Use broad context review and exploration conservatively until the project has stronger Gemini-specific dogfood. Keep handoffs concrete and do not assume responsibility that the operator assigned to another harness.
+Use broad context review and exploration conservatively until the project has stronger Antigravity-specific dogfood. Keep handoffs concrete and do not assume responsibility that the operator assigned to another harness.
 
 ## Grok
 
@@ -38,11 +39,17 @@ Use Grok Build as a first-class local coding harness. Keep coordination safety a
 
 Use terminal-native local exploration and implementation conservatively until the project has stronger OpenCode-specific dogfood. Keep coordination safety ahead of speed.
 `;
-const HARNESS_ALIASES = {
+export const INSTRUCTION_HARNESSES = [
+    ...HARNESS_CLI_HARNESSES,
+    "all"
+];
+export const HARNESS_ALIASES = {
     all: "all",
     base: "all",
     claude: "claude",
     "claude-code": "claude",
+    antigravity: "antigravity",
+    agy: "antigravity",
     codex: "codex",
     gemini: "gemini",
     grok: "grok",
@@ -114,7 +121,7 @@ export function resolveInstructionHarness(explicitHarness, identity) {
 export function normalizeInstructionHarness(value) {
     const normalized = HARNESS_ALIASES[normalizeKey(value)];
     if (!normalized) {
-        throw new Error(`--harness must be one of claude, codex, gemini, grok, opencode, all (got ${value}).`);
+        throw new Error(`--harness must be one of claude, codex, antigravity, gemini, grok, opencode, all (got ${value}).`);
     }
     return normalized;
 }
@@ -219,6 +226,8 @@ function parseHarnessHeader(line) {
         return "claude";
     if (key.startsWith("codex"))
         return "codex";
+    if (key.startsWith("antigravity") || key === "agy")
+        return "antigravity";
     if (key.startsWith("gemini"))
         return "gemini";
     if (key.startsWith("grok"))