@openlap/openlap 1.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,78 @@
+# openlap
+
+Product requirements that agents read. Write a lap, agent builds it.
+
+A lap is one goal, issues to implement, and verification criteria. Agents pick the next open lap and work through it. When they commit, criteria auto-check via webhook. No dashboard, no CLI -- just the MCP server.
+
+Live at [openlap.app](https://openlap.app)
+
+## Install
+
+1. Admin installs the GitHub App (once per org): https://github.com/apps/openlap-app/installations/new
+2. Add the MCP server:
+
+```bash
+claude mcp add --transport http lap https://openlap.app/mcp
+```
+
+3. Open Claude Code. First message triggers GitHub login in browser. Done.
+
+For project-scoped briefings (filters context to one repo):
+
+```bash
+claude mcp add --transport http --scope project lap "https://openlap.app/mcp?project=owner/repo"
+```
+
+Project scope overrides global when both exist.
+
+4. Register your repo as a project (once per repo):
+
+```
+create_project owner/repo
+```
+
+## What agents see
+
+**Briefings** -- computed context injected into tool descriptions. Agents see project health, the focused lap's unchecked criteria, staleness signals, and priority collisions without calling any tool. Briefings refresh mid-session after mutations.
+
+**Laps** -- sorted by priority (0=focus, 1=urgent, 2=high, 3=normal). Agents work on the first open lap. Each lap has a goal, body, and structured criteria.
+
+**Criteria** -- verification checks on each lap. Agents prove work by committing with `LAP-NNN #N` in the commit message:
+
+```bash
+git commit -m "LAP-010 #1 #2 add auth middleware"
+```
+
+The GitHub webhook auto-checks the referenced criteria. When all code criteria pass, the lap auto-closes to done. If manual criteria remain (screenshots, design review), the lap moves to review for human verification.
+
+**Focus mode** -- set priority=0 on one lap per project. Its unchecked criteria appear in briefings automatically, so agents know what to verify from `tools/list` alone.
+
+## Develop
+
+Prerequisites: Go 1.23+, a GitHub App.
+
+```bash
+export BASE_URL=http://localhost:7784
+export DB_PATH=./openlap.db
+cd cmd/anylap && go run .
+```
+
+Local MCP (overrides the remote server):
+
+```bash
+claude mcp add --transport http lap http://localhost:7784/mcp
+```
+
+## Deploy
+
+Hetzner. `sky ship --app openlap-1`. Secrets via `sky deploy --app openlap-1`.
+
+## Architecture
+
+```
+Agent -> MCP (openlap.app/mcp) -> SQLite
+```
+
+One Go binary serves REST API + MCP protocol. OAuth 2.1 with PKCE, chaining to GitHub for identity. GitHub App installation = team boundary. SQLite with Litestream S3 backup.
+
+See CLAUDE.md for technical reference.

package/dist/channel.d.ts

@@ -0,0 +1,53 @@
+interface ChannelUpdate {
+    id: string;
+    session_id?: string;
+    project_name: string;
+    display_name?: string;
+    body: string;
+    health: string;
+    created_at: string;
+}
+interface PresenceEvent {
+    action: "join" | "leave" | "timeout";
+    display_name: string;
+    channel: string;
+}
+interface JoinResponse {
+    channel: string;
+    present: string[];
+    recent: Array<{
+        id: string;
+        project_name?: string;
+        body: string;
+        health: string;
+        created_at: string;
+    }>;
+}
+type UpdateCallback = (channel: string, update: ChannelUpdate) => void;
+type PresenceCallback = (channel: string, event: PresenceEvent) => void;
+export declare class ChannelManager {
+    private baseUrl;
+    private channels;
+    private seenIds;
+    private onUpdate;
+    private onPresence;
+    private getToken;
+    private mySessionId;
+    private heartbeatInterval;
+    constructor(baseUrl: string, onUpdate: UpdateCallback, getToken: () => string | undefined, onPresence?: PresenceCallback);
+    setSessionId(sessionId: string): void;
+    join(channel: string, name?: string): Promise<JoinResponse | null>;
+    leave(channel: string): Promise<void>;
+    mute(channel: string): boolean;
+    focus(channel: string): boolean;
+    getFocusedChannel(): string | undefined;
+    isJoined(channel: string): boolean;
+    isMuted(channel: string): boolean;
+    private connectSSE;
+    private readStream;
+    private handleSSEEvent;
+    private startHeartbeat;
+    private stopHeartbeat;
+    stop(): void;
+}
+export {};

package/dist/channel.js

@@ -0,0 +1,256 @@
+// v2: ChannelManager replaces FeedManager.
+// Adds: join/leave via server API, mute/focus as local state,
+// heartbeat loop, echo suppression by session_id.
+export class ChannelManager {
+    baseUrl;
+    channels = new Map();
+    seenIds = new Set();
+    onUpdate;
+    onPresence;
+    getToken;
+    mySessionId;
+    heartbeatInterval = null;
+    constructor(baseUrl, onUpdate, getToken, onPresence) {
+        this.baseUrl = baseUrl;
+        this.onUpdate = onUpdate;
+        this.onPresence = onPresence;
+        this.getToken = getToken;
+    }
+    setSessionId(sessionId) {
+        this.mySessionId = sessionId;
+    }
+    // join calls the server API to register presence, then opens SSE.
+    async join(channel, name) {
+        if (this.channels.has(channel))
+            return null;
+        const token = this.getToken();
+        const headers = { "Content-Type": "application/json" };
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        try {
+            const res = await fetch(`${this.baseUrl}/api/channels/${encodeURIComponent(channel)}/join`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ name: name ?? undefined }),
+            });
+            if (!res.ok) {
+                process.stderr.write(`[openlap] join ${channel} failed: ${res.status}\n`);
+                return null;
+            }
+            const data = (await res.json());
+            process.stderr.write(`[openlap] joined ${channel} (${data.present?.length ?? 0} present)\n`);
+            // Start SSE subscription
+            const controller = new AbortController();
+            this.channels.set(channel, { controller, muted: false, focused: false });
+            this.connectSSE(channel, controller);
+            // Start heartbeat if first channel
+            if (this.channels.size === 1) {
+                this.startHeartbeat();
+            }
+            return data;
+        }
+        catch (err) {
+            process.stderr.write(`[openlap] join ${channel} error: ${err}\n`);
+            return null;
+        }
+    }
+    // leave calls the server API to remove presence, then closes SSE.
+    async leave(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return;
+        state.controller.abort();
+        this.channels.delete(channel);
+        // Stop heartbeat if no channels
+        if (this.channels.size === 0) {
+            this.stopHeartbeat();
+        }
+        const token = this.getToken();
+        const headers = {};
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        try {
+            await fetch(`${this.baseUrl}/api/channels/${encodeURIComponent(channel)}/leave`, {
+                method: "POST",
+                headers,
+            });
+            process.stderr.write(`[openlap] left ${channel}\n`);
+        }
+        catch {
+            // best effort
+        }
+    }
+    // mute stops forwarding notifications but stays present (heartbeat continues).
+    mute(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return false;
+        state.muted = true;
+        process.stderr.write(`[openlap] muted ${channel}\n`);
+        return true;
+    }
+    // focus unmutes a channel and sets it as the focused channel for briefings.
+    focus(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return false;
+        // Unmute the focused channel
+        state.focused = true;
+        state.muted = false;
+        // Unfocus all others (only one focused at a time)
+        for (const [name, s] of this.channels) {
+            if (name !== channel)
+                s.focused = false;
+        }
+        process.stderr.write(`[openlap] focused ${channel}\n`);
+        return true;
+    }
+    getFocusedChannel() {
+        for (const [name, state] of this.channels) {
+            if (state.focused)
+                return name;
+        }
+        return undefined;
+    }
+    isJoined(channel) {
+        return this.channels.has(channel);
+    }
+    isMuted(channel) {
+        return this.channels.get(channel)?.muted ?? false;
+    }
+    // SSE connection for a channel
+    connectSSE(channel, controller) {
+        const url = `${this.baseUrl}/feed/${channel}/sse`;
+        const headers = {};
+        const token = this.getToken();
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        fetch(url, { headers, signal: controller.signal })
+            .then((res) => {
+            if (!res.ok || !res.body)
+                throw new Error(`SSE connect failed: ${res.status}`);
+            return this.readStream(channel, res.body, controller);
+        })
+            .catch((err) => {
+            if (err.name === "AbortError")
+                return;
+            if (this.channels.has(channel)) {
+                setTimeout(() => this.connectSSE(channel, controller), 5000);
+            }
+        });
+    }
+    async readStream(channel, body, controller) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let eventType = "";
+        let eventData = "";
+        let eventId = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        eventType = line.slice(7);
+                    }
+                    else if (line.startsWith("data: ")) {
+                        eventData = line.slice(6);
+                    }
+                    else if (line.startsWith("id: ")) {
+                        eventId = line.slice(4);
+                    }
+                    else if (line === "") {
+                        this.handleSSEEvent(channel, eventType, eventData, eventId);
+                        eventType = "";
+                        eventData = "";
+                        eventId = "";
+                    }
+                }
+            }
+        }
+        catch {
+            // stream ended
+        }
+        // Reconnect if still joined
+        if (this.channels.has(channel) && !controller.signal.aborted) {
+            setTimeout(() => this.connectSSE(channel, controller), 5000);
+        }
+    }
+    handleSSEEvent(channel, eventType, data, id) {
+        if (eventType === "update" && data && id) {
+            if (this.seenIds.has(id))
+                return;
+            this.seenIds.add(id);
+            // Cap seen set
+            if (this.seenIds.size > 500) {
+                const iter = this.seenIds.values();
+                for (let i = 0; i < 100; i++)
+                    iter.next();
+                const toKeep = new Set();
+                for (const v of iter)
+                    toKeep.add(v);
+                this.seenIds = toKeep;
+            }
+            try {
+                const update = JSON.parse(data);
+                // Echo suppression: skip own posts
+                if (this.mySessionId && update.session_id === this.mySessionId)
+                    return;
+                // Mute check: skip if channel is muted
+                if (this.channels.get(channel)?.muted)
+                    return;
+                this.onUpdate(channel, update);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        if (eventType === "presence" && data) {
+            try {
+                const event = JSON.parse(data);
+                event.channel = channel;
+                this.onPresence?.(channel, event);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+    }
+    // Heartbeat: POST /api/presence/heartbeat every 30s
+    startHeartbeat() {
+        if (this.heartbeatInterval)
+            return;
+        this.heartbeatInterval = setInterval(async () => {
+            const token = this.getToken();
+            if (!token)
+                return;
+            try {
+                await fetch(`${this.baseUrl}/api/presence/heartbeat`, {
+                    method: "POST",
+                    headers: { "Authorization": `Bearer ${token}` },
+                });
+            }
+            catch {
+                // heartbeat failure is not critical
+            }
+        }, 30_000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    stop() {
+        this.stopHeartbeat();
+        for (const [, state] of this.channels) {
+            state.controller.abort();
+        }
+        this.channels.clear();
+    }
+}

package/dist/feed.d.ts

@@ -11,7 +11,8 @@ export declare class FeedManager {
     private streams;
     private seenIds;
     private callback;
-    constructor(baseUrl: string, callback: UpdateCallback);
+    private getToken;
+    constructor(baseUrl: string, callback: UpdateCallback, getToken?: () => string | undefined);
     /**
      * Subscribe to a tag's feed if not already subscribed.
      */

package/dist/feed.js

@@ -5,9 +5,11 @@ export class FeedManager {
     streams = new Map();
     seenIds = new Set();
     callback;
-    constructor(baseUrl, callback) {
+    getToken;
+    constructor(baseUrl, callback, getToken) {
         this.baseUrl = baseUrl;
         this.callback = callback;
+        this.getToken = getToken;
     }
     /**
      * Subscribe to a tag's feed if not already subscribed.
@@ -22,7 +24,12 @@ export class FeedManager {
     }
     connect(tag, controller) {
         const url = `${this.baseUrl}/feed/${tag}/sse`;
-        fetch(url, { signal: controller.signal })
+        const headers = {};
+        const token = this.getToken?.();
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        fetch(url, { headers, signal: controller.signal })
             .then((res) => {
             if (!res.ok || !res.body) {
                 throw new Error(`SSE connect failed: ${res.status}`);

package/dist/index.js

@@ -6,44 +6,37 @@ if (command === "setup") {
     console.log("Setting up openlap...");
     console.log("");
     try {
-        // Add new "openlap" entry first (safe -- if this fails, old config still works)
-        let added = false;
+        // Add MCP server entry
         try {
-            execSync(`claude mcp add -s user openlap -- npx -y @openlap/openlap`, { stdio: "pipe" });
-            added = true;
+            execSync(`claude mcp add -s user openlap -- openlap`, { stdio: "pipe" });
             console.log("Added openlap MCP server.");
         }
         catch (err) {
             const msg = err instanceof Error ? err.stderr?.toString() ?? err.message : String(err);
             if (msg.includes("already exists")) {
-                console.log("openlap MCP server already installed.");
-                added = true;
+                console.log("openlap MCP server already configured.");
             }
             else {
                 throw err;
             }
         }
-        // Only remove old entries after new one is confirmed
-        if (added) {
-            // Remove old "anylap" entry if present (migration from @openlap/anylap)
-            try {
-                execSync("claude mcp remove anylap", { stdio: "pipe" });
-                console.log("Migrated: removed old 'anylap' entry.");
-            }
-            catch {
-                // Not present, fine
-            }
-            // Remove old "lap" HTTP entry if present (migration from direct HTTP setup)
-            try {
-                execSync("claude mcp remove lap", { stdio: "pipe" });
-                console.log("Migrated: removed old 'lap' HTTP entry.");
-            }
-            catch {
-                // Not present, fine
-            }
+        // Remove old entries
+        try {
+            execSync("claude mcp remove anylap", { stdio: "pipe" });
+            console.log("Migrated: removed old 'anylap' entry.");
+        }
+        catch { }
+        try {
+            execSync("claude mcp remove lap", { stdio: "pipe" });
+            console.log("Migrated: removed old 'lap' HTTP entry.");
         }
+        catch { }
+        console.log("");
+        console.log("Done. Start Claude Code with live feeds:");
+        console.log("");
+        console.log("  claude --dangerously-load-development-channels");
         console.log("");
-        console.log("Done. Open Claude Code -- first message triggers GitHub login.");
+        console.log("First session triggers GitHub login in browser.");
     }
     catch {
         console.error("Failed to add MCP server. Is Claude Code installed?");
@@ -76,5 +69,26 @@ if (command && command !== "serve") {
     console.error("Run 'npx @openlap/openlap help' for usage.");
     process.exit(1);
 }
+// -- Auto-update -------------------------------------------------------------
+try {
+    const { readFileSync } = await import("fs");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const current = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+    const latest = execSync("npm view @openlap/openlap version", {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (latest && latest !== current) {
+        process.stderr.write(`[openlap] updating ${current} -> ${latest}\n`);
+        execSync("npm install -g @openlap/openlap@latest", { stdio: "pipe", timeout: 30000 });
+        process.stderr.write(`[openlap] updated to ${latest}\n`);
+    }
+}
+catch {
+    // not critical
+}
 const { startProxy } = await import("./proxy.js");
 await startProxy();

package/dist/proxy.js

@@ -3,31 +3,45 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import { FileOAuthProvider } from "./auth.js";
 import { detectProject, autoSave } from "./git.js";
+import { ChannelManager } from "./channel.js";
 import { FeedManager } from "./feed.js";
-const BASE_URL = process.env.ANYLAP_URL ?? "https://openlap.app";
+const BASE_URL = process.env.OPENLAP_URL ?? "https://openlap.app";
 // Tools that accept a 'project' parameter
 const PROJECT_TOOLS = new Set([
     "list_laps", "get_lap", "create_lap", "save_lap", "update_lap",
     "post_update", "list_updates",
     "create_project", "update_project", "remove_project",
+    "check_lap", "post_channel",
 ]);
+// v2 channel tools handled locally by the proxy
+const PROXY_CHANNEL_TOOLS = new Set([
+    "join_channel", "leave_channel", "mute_channel", "focus_channel",
+]);
+function getAuthToken() {
+    try {
+        const data = JSON.parse(readFileSync(join(homedir(), ".openlap", "auth.json"), "utf-8"));
+        return data?.tokens?.access_token;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function startProxy() {
     const authProvider = new FileOAuthProvider();
     // -- Connect to remote MCP server ----------------------------------------
     const remoteTransport = new StreamableHTTPClientTransport(new URL(`${BASE_URL}/mcp`), { authProvider });
     const remote = new Client({ name: "openlap-proxy", version: "1.0.0" }, { capabilities: {} });
-    // Try connecting -- if auth is needed, the provider opens the browser
     try {
         await remote.connect(remoteTransport);
     }
     catch (err) {
-        // After redirectToAuthorization, the SDK throws UnauthorizedError.
-        // We have the auth code from the callback -- finish the flow.
         if (authProvider.authCode) {
             await remoteTransport.finishAuth(authProvider.authCode);
-            // Retry connection
             await remote.connect(remoteTransport);
         }
         else {
@@ -36,7 +50,15 @@ export async function startProxy() {
             process.exit(1);
         }
     }
-    // -- Auto-detect project from git remote ----------------------------------
+    // -- Version + project -------------------------------------------------------
+    try {
+        const { dirname } = await import("path");
+        const { fileURLToPath } = await import("url");
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        const ver = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+        process.stderr.write(`[openlap] v${ver}\n`);
+    }
+    catch { }
     const detectedProject = detectProject();
     if (detectedProject) {
         process.stderr.write(`[openlap] project: ${detectedProject}\n`);
@@ -48,19 +70,19 @@ export async function startProxy() {
             experimental: { "claude/channel": {} },
         },
     });
-    // -- Experimental: dynamic feed subscription ------------------------------
-    const feeds = new FeedManager(BASE_URL, (tag, update) => {
+    // -- v2: ChannelManager ---------------------------------------------------
+    const channels = new ChannelManager(BASE_URL, (channel, update) => {
         const who = update.project_name || "unknown";
         const health = update.health && update.health !== "on_track" ? ` [${update.health}]` : "";
-        const content = `[${who}]${health} ${update.body}`;
-        process.stderr.write(`[openlap] feed ${tag}: ${content}\n`);
+        const displayName = update.display_name ? `${update.display_name}` : who;
+        const content = `[${channel}] ${displayName}${health}: ${update.body}`;
         server.notification({
             method: "notifications/claude/channel",
             params: {
                 content,
                 meta: {
                     update_id: update.id,
-                    tag,
+                    tag: channel,
                     created_at: update.created_at,
                     health: update.health ?? "on_track",
                 },
@@ -70,7 +92,31 @@ export async function startProxy() {
                 process.stderr.write(`[openlap] notification error: ${err}\n`);
             }
         });
+    }, getAuthToken, (channel, event) => {
+        // Presence events
+        const content = `[${channel}] ${event.display_name} ${event.action === "join" ? "joined" : event.action === "timeout" ? "timed out" : "left"}`;
+        server.notification({
+            method: "notifications/claude/channel",
+            params: { content, meta: { tag: channel, action: event.action } },
+        }).catch(() => { });
     });
+    // -- v1 compat: FeedManager for old track subscriptions -------------------
+    const feeds = new FeedManager(BASE_URL, (tag, update) => {
+        const who = update.project_name || "unknown";
+        const health = update.health && update.health !== "on_track" ? ` [${update.health}]` : "";
+        const content = `[${who}]${health} ${update.body}`;
+        server.notification({
+            method: "notifications/claude/channel",
+            params: {
+                content,
+                meta: { update_id: update.id, tag, created_at: update.created_at, health: update.health ?? "on_track" },
+            },
+        }).catch((err) => {
+            if (!String(err).includes("Not connected")) {
+                process.stderr.write(`[openlap] notification error: ${err}\n`);
+            }
+        });
+    }, getAuthToken);
     // Forward tool listing from remote
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         const result = await remote.listTools();
@@ -80,28 +126,67 @@ export async function startProxy() {
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
         const { name } = req.params;
         const args = { ...(req.params.arguments ?? {}) };
-        // Auto-inject project if not provided and detectable
+        // -- v2 proxy-side channel tools (handled locally) ----------------------
+        if (name === "join_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            const result = await channels.join(channel, args.name);
+            return { content: [{ type: "text", text: JSON.stringify(result ?? { error: "already joined or failed" }) }] };
+        }
+        if (name === "leave_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            await channels.leave(channel);
+            return { content: [{ type: "text", text: JSON.stringify({ status: "left", channel }) }] };
+        }
+        if (name === "mute_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            const ok = channels.mute(channel);
+            return { content: [{ type: "text", text: ok ? `Muted ${channel}. Still present, notifications paused.` : `Not in ${channel}.` }] };
+        }
+        if (name === "focus_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            const ok = channels.focus(channel);
+            return { content: [{ type: "text", text: ok ? `Focused on ${channel}. Unmuted and pinned to briefings.` : `Not in ${channel}.` }] };
+        }
+        // -- Auto-inject project ------------------------------------------------
         if (detectedProject && PROJECT_TOOLS.has(name) && !args.project) {
             args.project = detectedProject;
         }
-        // Auto-save before post_update
-        if (name === "post_update" && typeof args.body === "string") {
+        // -- Auto-inject channel from project for post_channel ------------------
+        if (name === "post_channel" && !args.channel && detectedProject) {
+            args.channel = detectedProject;
+        }
+        // -- Auto-save before post_update and post_channel ----------------------
+        if ((name === "post_update" || name === "post_channel") && typeof args.body === "string") {
             const saved = autoSave(args.body);
             if (saved) {
                 process.stderr.write(`[openlap] auto-saved: ${saved}\n`);
             }
         }
-        // Forward to remote
+        // -- Forward to remote --------------------------------------------------
         const result = await remote.callTool({ name, arguments: args });
-        // Experimental: auto-subscribe to feeds from tool usage
+        // v1 compat: auto-subscribe to feeds from track tool usage
         if (typeof args.tag === "string" && args.tag) {
-            feeds.subscribe(args.tag);
+            if (!channels.isJoined(args.tag)) {
+                feeds.subscribe(args.tag);
+            }
         }
         if (name === "get_track" && typeof args.name === "string" && args.name) {
-            feeds.subscribe(args.name);
+            if (!channels.isJoined(args.name)) {
+                feeds.subscribe(args.name);
+            }
         }
         if (name === "create_track" && typeof args.name === "string" && args.name) {
-            feeds.subscribe(args.name);
+            if (!channels.isJoined(args.name)) {
+                feeds.subscribe(args.name);
+            }
         }
         return {
             content: result.content,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlap/openlap",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Local MCP proxy for openlap.app -- auto-save, live feeds, project detection, one install",
   "type": "module",
   "main": "dist/index.js",