talking-stick 0.1.4 → 0.3.0

package/dist/cli/registry.js

@@ -1,19 +1,10 @@
-import { runStdioServer } from "../index.js";
 import { runGuardCommand } from "./guardian.js";
-import { runInstallCommand, runInstallSkillCommand, runSelfUpdateCommand, runUninstallCommand, runUninstallSkillCommand } from "./install-commands.js";
+import { runInstallCommand, runMcpMigrationCommand, runSelfUpdateCommand, runUninstallCommand } from "./install-commands.js";
+import { handleMsgCommand } from "./msg-commands.js";
 import { handleNotesCommand } from "./notes-commands.js";
 import { handleEventsCommand, handleJoinCommand, handleKickCommand, handleLeaveCommand, handleListCommand, handleStateCommand, handleWhoAmICommand } from "./room-commands.js";
 import { handleAssignCommand, handlePassCommand, handleReleaseCommand, handleTakeCommand, handleWaitCommand } from "./turn-commands.js";
 export const COMMAND_REGISTRY = [
-    {
-        name: "mcp",
-        needsRuntime: false,
-        startupMaintenance: false,
-        internal: true,
-        usage: "tt mcp",
-        description: "Run the MCP server over stdio.",
-        handler: () => runStdioServer()
-    },
     {
         name: "guard",
         needsRuntime: false,
@@ -29,7 +20,7 @@ export const COMMAND_REGISTRY = [
         startupMaintenance: false,
         internal: false,
         usage: "tt install <harness...> | --all [--print] [--copy] [--link]",
-        description: "Install Talking Stick into harness MCP configs and skills.",
+        description: "Install the Talking Stick skill and remove stale MCP registrations.",
         handler: ({ parsed }) => runInstallCommand(parsed)
     },
     {
@@ -38,35 +29,26 @@ export const COMMAND_REGISTRY = [
         startupMaintenance: false,
         internal: false,
         usage: "tt uninstall <harness...> | --all [--print]",
-        description: "Remove Talking Stick from harness MCP configs and skills.",
+        description: "Remove the Talking Stick skill and stale MCP registrations.",
         handler: ({ parsed }) => runUninstallCommand(parsed)
     },
     {
-        name: "install-skill",
+        name: "self-update",
         needsRuntime: false,
         startupMaintenance: false,
         internal: false,
-        usage: "tt install-skill <harness...> | --all [--print] [--copy] [--link]",
-        description: "Install the bundled Talking Stick skill.",
-        handler: ({ parsed }) => runInstallSkillCommand(parsed)
+        usage: "tt self-update [--print] [--manager npm|pnpm|yarn|bun]",
+        description: "Update the globally installed tt package.",
+        handler: ({ parsed, cliEntryUrl }) => runSelfUpdateCommand(parsed, cliEntryUrl)
     },
     {
-        name: "uninstall-skill",
+        name: "migrate-mcp",
         needsRuntime: false,
         startupMaintenance: false,
-        internal: false,
-        usage: "tt uninstall-skill <harness...> | --all [--print]",
-        description: "Remove the bundled Talking Stick skill.",
-        handler: ({ parsed }) => runUninstallSkillCommand(parsed)
-    },
-    {
-        name: "self-update",
-        needsRuntime: false,
-        startupMaintenance: true,
-        internal: false,
-        usage: "tt self-update [--print] [--manager npm|pnpm|yarn|bun]",
-        description: "Update the globally installed tt package.",
-        handler: ({ parsed, cliEntryUrl }) => runSelfUpdateCommand(parsed, cliEntryUrl)
+        internal: true,
+        usage: "tt migrate-mcp [--reason update|first-run|uninstall|manual] [--quiet]",
+        description: "Remove stale Talking Stick MCP registrations.",
+        handler: ({ parsed }) => runMcpMigrationCommand(parsed)
     },
     {
         name: "whoami",
@@ -127,16 +109,25 @@ export const COMMAND_REGISTRY = [
         needsRuntime: true,
         startupMaintenance: true,
         internal: false,
-        usage: "tt events [path] [--after N] [--limit N]",
+        usage: "tt events [path] [--after N] [--limit N] [--wait|--follow] [--event TYPE[,TYPE]] [--target self|any|agent]",
         description: "Show room events.",
         handler: ({ runtime, parsed }) => handleEventsCommand(requireRuntime(runtime), parsed)
     },
+    {
+        name: "msg",
+        needsRuntime: true,
+        startupMaintenance: true,
+        internal: false,
+        usage: "tt msg <send|recv> [...]",
+        description: "Send or receive transient messages on a room's event stream.",
+        handler: ({ runtime, parsed }) => handleMsgCommand(requireRuntime(runtime), parsed)
+    },
     {
         name: "wait",
         needsRuntime: true,
         startupMaintenance: true,
         internal: false,
-        usage: "tt wait [path] [--timeout 30s]",
+        usage: "tt wait [path] [--timeout 110s]",
         description: "Wait until this agent can claim the stick.",
         handler: ({ runtime, parsed, cliEntryUrl }) => handleWaitCommand(requireRuntime(runtime), parsed, false, cliEntryUrl)
     },

package/dist/cli/room-commands.js

@@ -1,8 +1,9 @@
 import { deriveCliIdentity, resolveCliIdentity } from "./identity.js";
 import { removeCliSession, removeCliSessionsForRoom, resolveCliSessionPath } from "../index.js";
 import { stopGuardian } from "./guardian.js";
-import { getStringOption, hasOption, parseOptionalInteger } from "./parser.js";
+import { getStringOption, hasOption, normalizeBooleanFlag, parseOptionalInteger } from "./parser.js";
 import { formatRelativeTime, printResult } from "./output.js";
+import { parseEventTypeFilter, runEventStream } from "./event-stream.js";
 import { resolveSessionForReads, upsertSessionFromJoin } from "./session.js";
 export function handleListCommand(runtime, parsed) {
     const contextPath = parsed.positionals[0] ?? process.cwd();
@@ -126,9 +127,19 @@ export function handleStateCommand(runtime, parsed) {
         return lines.join("\n");
     });
 }
-export function handleEventsCommand(runtime, parsed) {
+export async function handleEventsCommand(runtime, parsed) {
+    normalizeBooleanFlag(parsed, "wait");
+    normalizeBooleanFlag(parsed, "follow");
     const identity = deriveCliIdentity(parsed);
     const session = resolveSessionForReads(runtime, parsed, identity);
+    if (hasOption(parsed, "wait") || hasOption(parsed, "follow")) {
+        await runEventStream(runtime, parsed, identity, session.room_id, {
+            event_type: parseEventTypeFilter(getStringOption(parsed, "event")),
+            default_target: "self",
+            force_tail_cursor: false
+        });
+        return;
+    }
     const events = runtime.commands.getRoomEvents({
         room_id: session.room_id,
         agent_id: identity.agent_id,

package/dist/cli/startup-maintenance.js

@@ -1,7 +1,20 @@
 import { syncInstalledSkills } from "../skill-install.js";
+import { runFirstRunMcpMigration } from "../update-migration.js";
+import { detectInstallSource, resolveCurrentBinaryPath } from "../self-update.js";
 import { isKnownHarnessCliEnv } from "./identity.js";
 import { getCommand } from "./registry.js";
-export function runStartupMaintenance(parsed, env = process.env) {
+export async function runStartupMaintenance(parsed, cliEntryUrl, env = process.env) {
+    if (shouldRunFirstRunMcpMigration(parsed, cliEntryUrl, env)) {
+        try {
+            await runFirstRunMcpMigration({
+                installOptions: { env }
+            });
+        }
+        catch {
+            // Startup cleanup is best-effort. Explicit install, uninstall, and
+            // self-update paths surface cleanup failures directly.
+        }
+    }
     if (!shouldAutoSyncInstalledSkills(parsed, env)) {
         return;
     }
@@ -13,6 +26,19 @@ export function runStartupMaintenance(parsed, env = process.env) {
         // unrelated tt command fail.
     }
 }
+export function shouldRunFirstRunMcpMigration(parsed, cliEntryUrl, env = process.env) {
+    if (env.TALKING_STICK_DISABLE_MCP_MIGRATION?.trim()) {
+        return false;
+    }
+    const command = getCommand(parsed.name);
+    if (!command?.startupMaintenance) {
+        return false;
+    }
+    const source = detectInstallSource({
+        binaryPath: resolveCurrentBinaryPath(cliEntryUrl)
+    });
+    return source !== "dev" && source !== "unknown";
+}
 export function shouldAutoSyncInstalledSkills(parsed, env = process.env) {
     if (env.TALKING_STICK_DISABLE_SKILL_SYNC?.trim()) {
         return false;

package/dist/cli.js

@@ -11,10 +11,10 @@ import { runStartupMaintenance } from "./cli/startup-maintenance.js";
 export { checkGuardianLiveness } from "./cli/guardian.js";
 export { parseHandoffJson } from "./cli/handoff.js";
 export { formatRelativeTime, shouldUseJson } from "./cli/output.js";
-export { shouldAutoSyncInstalledSkills } from "./cli/startup-maintenance.js";
+export { shouldAutoSyncInstalledSkills, shouldRunFirstRunMcpMigration } from "./cli/startup-maintenance.js";
 export async function runCli(argv = process.argv.slice(2)) {
     const parsed = parseCommand(argv);
-    runStartupMaintenance(parsed);
+    await runStartupMaintenance(parsed, import.meta.url);
     if (!parsed.name || parsed.name === "help" || parsed.name === "--help") {
         printHelp();
         return;

package/dist/commands.js

@@ -82,6 +82,21 @@ export class TalkingStickCommands {
     getRoomEvents(input) {
         return this.service.getRoomEvents(input);
     }
+    sendMessage(identity, input) {
+        return this.service.sendMessage({
+            agent_id: identity.agent_id,
+            room_id: input.room_id,
+            body: input.body,
+            to_agent_id: input.to_agent_id,
+            delivery_hint: input.delivery_hint
+        });
+    }
+    waitForEvents(input) {
+        return this.service.waitForEvents(input);
+    }
+    getLatestEventSeq(input) {
+        return this.service.getLatestEventSeq(input);
+    }
     addNote(identity, input) {
         return this.service.addNote({
             agent_id: identity.agent_id,

package/dist/config.js

@@ -4,8 +4,11 @@ export const defaultPolicy = {
     ownerLeaseTtlMs: 45 * 60 * 1000,
     heartbeatIntervalMs: 5 * 60 * 1000,
     claimTtlMs: 20 * 60 * 1000,
-    waitForTurnMaxWaitMs: 30 * 1000,
+    waitForTurnMaxWaitMs: 110 * 1000,
     waitForTurnPollMs: 250,
+    waitForEventsMaxWaitMs: 110 * 1000,
+    waitForEventsPollMs: 250,
+    waitForEventsBatchLimit: 100,
     presenceTtlMs: 4 * 60 * 60 * 1000,
     waiterGraceMs: 10 * 1000,
     idleRoomTtlMs: 7 * 24 * 60 * 60 * 1000

package/dist/db.js

@@ -96,6 +96,13 @@ const migrations = [
         up: `
       ALTER TABLE room_members ADD COLUMN last_wait_at TEXT;
     `
+    },
+    {
+        id: 5,
+        name: "room_events_payload_json",
+        up: `
+      ALTER TABLE room_events ADD COLUMN payload_json TEXT;
+    `
     }
 ];
 export function resolveDatabasePath(options = {}) {

package/dist/identity.js

@@ -127,13 +127,13 @@ function harnessAgentId(harness, sessionId, hostId, username) {
 function resolveHarnessSessionId(signal, env, parentPid, parentInspection, username, hostId, inspector) {
     if (signal.sessionId)
         return `harness:${signal.sessionId}`;
-    const terminalId = resolveTerminalSessionId(env);
-    if (terminalId)
-        return terminalId;
     const harnessRoot = findHarnessRootInAncestry(signal.harness, parentPid, parentInspection, inspector);
     if (harnessRoot) {
         return `pid:${harnessRoot.pid}@${harnessRoot.startTime}`;
     }
+    const terminalId = resolveTerminalSessionId(env);
+    if (terminalId)
+        return terminalId;
     if (parentInspection?.startTime) {
         return `pid:${parentPid}@${parentInspection.startTime}`;
     }
@@ -224,7 +224,7 @@ function detectHarnessSignal(env) {
     if (env.CLAUDECODE === "1") {
         return {
             harness: "claude",
-            sessionId: null,
+            sessionId: nonEmpty(env.CLAUDE_CODE_SESSION_ID),
             pidHint: parsePositiveInteger(env.CMUX_CLAUDE_PID)
         };
     }

package/dist/index.js

@@ -4,9 +4,9 @@ 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 { createMcpServer, runStdioServer } from "./mcp-server.js";
-export { SUPPORTED_HARNESSES, MissingHarnessError, detectHarness, parseHarnessList, planInstall, planUninstall, resolveHarnessConfigDir, resolveOpencodeConfigDir, resolveOpencodeConfigPath, runAction, skipAction } from "./install.js";
+export { SUPPORTED_HARNESSES, MissingHarnessError, detectHarness, parseHarnessList, planUninstall, resolveHarnessConfigDir, resolveOpencodeConfigDir, resolveOpencodeConfigPath, runAction, skipAction } from "./install.js";
 export { DEFAULT_SKILL_NAME, planSkillInstall, planSkillUninstall, resolveBundledSkillPath, resolveSkillTargetPath, syncInstalledSkills } from "./skill-install.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";
 export { TalkingStickService, createDefaultProcessLivenessChecker } from "./service.js";

package/dist/install-audit.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+export class FileAuditLog {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    append(entry) {
+        const fullEntry = { ts: entry.ts ?? new Date().toISOString(), ...entry };
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.appendFileSync(this.filePath, `${JSON.stringify(fullEntry)}\n`, "utf8");
+    }
+}
+export class NoopAuditLog {
+    append() {
+        // intentionally blank
+    }
+}
+export function defaultAuditLogPath(dataDir) {
+    return path.join(dataDir, "update-migrations.log");
+}

package/dist/install-migration.js

@@ -0,0 +1,84 @@
+import { SUPPORTED_HARNESSES, planUninstall, runAction } from "./install.js";
+import { NoopAuditLog } from "./install-audit.js";
+export async function removeStaleMcpRegistrations(options) {
+    const audit = options.audit ?? new NoopAuditLog();
+    const strict = options.strict ?? true;
+    const harnesses = options.harnesses === undefined || options.harnesses === "all"
+        ? [...SUPPORTED_HARNESSES]
+        : options.harnesses;
+    const installOptions = {
+        skipMissing: true,
+        ...(options.installOptions ?? {})
+    };
+    const results = [];
+    for (const harness of harnesses) {
+        const result = await removeOneHarness(harness, installOptions, strict);
+        results.push(result);
+        audit.append({
+            reason: options.reason,
+            package_version_from: options.packageVersionFrom,
+            package_version_to: options.packageVersionTo,
+            harness,
+            config_path: result.configPath,
+            action: result.action,
+            server_name: result.serverName,
+            detail: result.message
+        });
+    }
+    return results.map(({ harness, action, message }) => ({ harness, action, message }));
+}
+async function removeOneHarness(harness, installOptions, strict) {
+    const action = planUninstall(harness, installOptions);
+    if (action.kind === "skip") {
+        return {
+            harness,
+            action: "skipped",
+            message: action.message,
+            serverName: installOptions.serverName ?? "talking-stick"
+        };
+    }
+    if (action.kind === "file-patch") {
+        const state = action.inspect ? action.inspect() : "unknown";
+        const serverName = action.serverName ?? "talking-stick";
+        if (state === "absent") {
+            return {
+                harness,
+                action: "absent",
+                message: `${harness}: no Talking Stick MCP entry to remove`,
+                configPath: action.filePath,
+                serverName
+            };
+        }
+        if (strict && state !== "present") {
+            return {
+                harness,
+                action: "preserved",
+                message: `${harness}: hand-edited entry left alone (state=${state})`,
+                configPath: action.filePath,
+                serverName
+            };
+        }
+    }
+    const installResult = await runAction(action, installOptions);
+    return mapInstallResult(harness, action, installResult);
+}
+function mapInstallResult(harness, action, result) {
+    let serverName = "talking-stick";
+    if ("serverName" in action && typeof action.serverName === "string") {
+        serverName = action.serverName;
+    }
+    const configPath = action.kind === "file-patch" ? action.filePath : undefined;
+    if (!result.ok) {
+        return { harness, action: "failed", message: result.message, configPath, serverName };
+    }
+    switch (result.status) {
+        case "already_absent":
+            return { harness, action: "absent", message: result.message, configPath, serverName };
+        case "removed":
+            return { harness, action: "removed", message: result.message, configPath, serverName };
+        case "skipped":
+            return { harness, action: "skipped", message: result.message, configPath, serverName };
+        default:
+            return { harness, action: "failed", message: result.message, configPath, serverName };
+    }
+}

package/dist/install.js

@@ -115,75 +115,6 @@ function resolveHarnessConfigDirFromResolved(harness, resolved) {
             throw new Error(`Unknown harness: ${harness}`);
     }
 }
-export function planInstall(harness, options = {}) {
-    const resolved = resolveOptions(options);
-    const [serverBin, ...serverArgs] = resolved.serverCommand;
-    if (!serverBin)
-        throw new Error("serverCommand must include at least the binary");
-    switch (harness) {
-        case "claude-code":
-            if (resolved.skipMissing && !resolved.hooks.which("claude")) {
-                return skipAction(harness, "claude not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "claude",
-                args: ["mcp", "add", "-s", "user", resolved.serverName, "--", serverBin, ...serverArgs],
-                description: `claude mcp add -s user ${resolved.serverName} -- ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "codex":
-            if (resolved.skipMissing && !resolved.hooks.which("codex")) {
-                return skipAction(harness, "codex not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "codex",
-                args: ["mcp", "add", resolved.serverName, "--", serverBin, ...serverArgs],
-                description: `codex mcp add ${resolved.serverName} -- ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "gemini":
-            if (resolved.skipMissing && !resolved.hooks.which("gemini")) {
-                return skipAction(harness, "gemini not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "gemini",
-                args: ["mcp", "add", "-s", "user", "-t", "stdio", resolved.serverName, serverBin, ...serverArgs],
-                description: `gemini mcp add -s user -t stdio ${resolved.serverName} ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "opencode": {
-            const filePath = resolveOpencodeConfigPath(options);
-            const configDir = path.dirname(filePath);
-            if (resolved.skipMissing && !resolved.hooks.pathExists(configDir)) {
-                return skipAction(harness, `opencode config directory not found: ${configDir}`);
-            }
-            return {
-                kind: "file-patch",
-                harness,
-                filePath,
-                description: `merge mcp.${resolved.serverName} into ${filePath}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                inspect: () => inspectOpencodeConfig(filePath, resolved),
-                apply: () => patchOpencodeConfig(filePath, resolved, "install")
-            };
-        }
-        default:
-            throw new Error(`Unknown harness: ${harness}`);
-    }
-}
 export function planUninstall(harness, options = {}) {
     const resolved = resolveOptions(options);
     switch (harness) {