@dalmasonto/taskflow-mcp 1.0.35 → 2.0.0

package/dist/index.js

@@ -1,232 +1,135 @@
 #!/usr/bin/env node
-import 'dotenv/config';
-import { getConfig } from './config.js';
-import { startSSEServer } from './sse.js';
-import { getDb } from './db.js';
-import { broadcast } from './sse.js';
-const httpOnly = process.argv.includes('--http-only');
-// Close orphaned sessions left from a previous crash.
-// Uses a grace period so that sessions from the current conversation
-// (stdio transport restarts the server on each tool call) are preserved.
-const ORPHAN_GRACE_MS = 5 * 60 * 1000; // 5 minutes
-function cleanupOrphanedSessions() {
-    const db = getDb();
-    const nowMs = Date.now();
-    const nowIso = new Date(nowMs).toISOString();
-    const cutoff = new Date(nowMs - ORPHAN_GRACE_MS).toISOString();
-    // Only close sessions that started more than ORPHAN_GRACE_MS ago
-    const orphaned = db.prepare('SELECT * FROM sessions WHERE end IS NULL AND start < ?').all(cutoff);
-    if (orphaned.length === 0)
+/**
+ * Bin entry: load `.taskflow.json`, build the MCP server, and serve over stdio.
+ *
+ * A configuration failure prints a clear message to stderr and exits non-zero so
+ * the human fixes the credential file rather than getting a silent dead server.
+ */
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { buildServer } from "./server.js";
+import { ConfigError } from "./config.js";
+import { runDoctor } from "./doctor.js";
+import { runTmuxMirror } from "./tmux.js";
+import { runMint } from "./mint.js";
+import { startAgent } from "./runtime.js";
+const USAGE = `taskflow-mcp — TaskFlow MCP server
+
+  taskflow-mcp                 Serve over stdio (how an MCP client runs it).
+  taskflow-mcp --check         Verify config + backend auth, then exit.
+  taskflow-mcp --tmux [target] Mirror a tmux pane into the dashboard terminal.
+  taskflow-mcp --mint <name>   Create a NEW agent identity + profile, then exit.
+  taskflow-mcp --help          This message.
+
+GIVING A SECOND TERMINAL ITS OWN IDENTITY. An agent is identified by
+project + profile, so two terminals sharing the default \`main\` profile are ONE
+agent: one row in the dashboard, one DM inbox, one shared read cursor. --mint
+creates a separate identity and writes it to .taskflow.json:
+
+  taskflow-mcp --mint bear --display-name "Claude (bear)"
+  export TASKFLOW_PROFILE=bear     # then start that terminal's agent
+
+It needs YOUR user token (--token, or TASKFLOW_USER_TOKEN), not an agent key:
+linking an agent is human-authorized and records who vouched for it, which is
+why this is a command you run and not a tool the agent can call. An existing
+profile is never overwritten and \`default_profile\` never moves, so terminals
+already running keep the identity they have.
+
+The MCP tools (whoami, create_task, ...) are called by the MODEL through an MCP
+client, not typed as commands. To check the setup yourself, use --check.
+
+TERMINAL MIRRORING IS AUTOMATIC. When the agent runs inside tmux, the server
+finds its own pane and streams it to the dashboard — nothing to launch, no pane
+id to look up. Set TASKFLOW_MIRROR=off to disable it. The agent still connects
+and appears online without tmux; only the streamed terminal needs a pane.
+
+WHICH IDENTITY AM I? With one profile in .taskflow.json the server connects as
+it silently. With several, it connects as NONE of them and the agent must ask
+you which this terminal is, then call select_profile — the pick is remembered
+per terminal in .taskflow/sessions.json. Set TASKFLOW_PROFILE to skip the ask.
+
+--tmux is only for mirroring a pane the agent is NOT running in (say, watching a
+build in another window). It runs in the foreground until Ctrl-C; the target
+defaults to tmux's active pane, or pass one from \`tmux list-panes -a\`. Options:
+  --interval=<ms>    Capture cadence (default 2000).
+  --profile=<name>   Act as a non-default .taskflow.json profile.
+  --notify           Type a one-line unread notice INTO the pane when messages
+                     arrive. Off by default: this writes to a live session.
+  --notify-submit    Also press Enter, so the agent acts on it unprompted.
+                     Anyone who can post to a channel can then wake the agent —
+                     enable it only for sessions you control.`;
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(`${USAGE}\n`);
         return;
-    // Close each orphaned session with end = now (preserves the real elapsed time)
-    for (const session of orphaned) {
-        db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(nowIso, session.id);
     }
-    // Set orphaned in_progress tasks back to paused
-    const taskIds = [...new Set(orphaned.map(s => s.task_id))];
-    for (const taskId of taskIds) {
-        const task = db.prepare('SELECT status FROM tasks WHERE id = ?').get(taskId);
-        if (task?.status === 'in_progress') {
-            db.prepare("UPDATE tasks SET status = 'paused', updated_at = ? WHERE id = ?").run(nowIso, taskId);
-            broadcast('task_updated', { entity: 'task', action: 'task_status_changed', payload: db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId) });
-        }
-    }
-}
-cleanupOrphanedSessions();
-// Always start the HTTP/SSE server (probes for existing instances, finds fallback port)
-await startSSEServer();
-// Liveness checker — periodically check registered agents and mark dead ones
-const cfg = getConfig();
-setInterval(async () => {
-    try {
-        const { checkAgentLiveness } = await import('./agent-registry.js');
-        checkAgentLiveness();
+    // --check is a human-facing diagnostic, so it prints to stdout and exits;
+    // it never opens the MCP transport.
+    if (argv.includes("--check") || argv.includes("--doctor")) {
+        process.exit(await runDoctor());
     }
-    catch { /* ignore */ }
-}, cfg.agentLivenessInterval);
-// Only start MCP stdio transport when not in http-only mode
-if (!httpOnly) {
-    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
-    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
-    const { registerTaskTools } = await import('./tools/tasks.js');
-    const { registerProjectTools } = await import('./tools/projects.js');
-    const { registerTimerTools } = await import('./tools/timer.js');
-    const { registerAnalyticsTools } = await import('./tools/analytics.js');
-    const { registerActivityTools } = await import('./tools/activity.js');
-    const { registerNotificationTools } = await import('./tools/notifications.js');
-    const { registerSettingsTools } = await import('./tools/settings.js');
-    const { registerAgentTools } = await import('./tools/agent.js');
-    const { registerAgentInboxTools } = await import('./tools/agent-inbox.js');
-    const { registerTerminalTools } = await import('./tools/terminal.js');
-    const { registerResources } = await import('./resources.js');
-    const { registerCheckpointTools } = await import('./tools/checkpoint.js');
-    const server = new McpServer({ name: 'taskflow', version: '1.0.25' }, {
-        instructions: [
-            'You MUST call bootstrap (preferred) or get_agent_instructions before doing any work. This loads your task management rules and project context.',
-            'You MUST create a task in TaskFlow before editing files or running commands. search_tasks first to avoid duplicates.',
-            'You MUST call start_timer when beginning work and stop_timer when done. Timer lifecycle: start_timer → work → stop_timer(final_status).',
-            'Never silently fix bugs — always create or reopen a task first, then track the fix.',
-            'When you need user input, call ask_user to post it to the Agent Inbox so the user can respond remotely.',
-            'Use log_debug to document your work — it is shared memory visible to the user and other agents.',
-        ].join('\n'),
-    });
-    // Filled in after agent registration — used by the inbox drain below
-    let agentNameGetter = () => 'unknown';
-    // Drain any undelivered inbox messages for this agent and prepend them to a
-    // tool result. This is the non-tmux delivery path: since we can't inject into
-    // stdin, we piggyback pending messages onto the next tool response so Claude
-    // sees them in its context without any terminal tricks.
-    function drainInboxNotice() {
+    // --mint is a human-facing command for the same reason it is not an MCP tool:
+    // `POST /agents/link` is RequireAuth-gated, so it needs a USER token that the
+    // agent does not have. Prints and exits; never opens the MCP transport.
+    if (argv.includes("--mint")) {
         try {
-            const name = agentNameGetter();
-            if (name === 'unknown')
-                return '';
-            const db = getDb();
-            const pending = db.prepare(`SELECT id, sender_name, question FROM agent_messages
-         WHERE recipient_name = ? AND status = 'pending' AND delivered IS NULL
-         ORDER BY created_at ASC`).all(name);
-            if (pending.length === 0)
-                return '';
-            for (const msg of pending) {
-                db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(msg.id);
-            }
-            const lines = pending.map(m => `  [Inbox #${m.id} from ${m.sender_name}]: ${m.question}`).join('\n');
-            return `\n⚠️ INBOX MESSAGE(S) — respond before continuing:\n${lines}\n`;
+            for (const line of await runMint(argv))
+                process.stdout.write(`${line}\n`);
+            process.exit(0);
         }
-        catch {
-            return '';
+        catch (err) {
+            // A MintError is a message written for the operator; anything else is a
+            // surprise and keeps its own text.
+            process.stderr.write(`${err.message}\n`);
+            process.exit(1);
         }
     }
-    // Wrap server.tool() to track execution time and log failures
-    const originalTool = server.tool.bind(server);
-    server.tool = function (...args) {
-        const toolName = args[0];
-        // Find the callback (always the last argument, and it's a function)
-        const cbIndex = args.length - 1;
-        const originalCb = args[cbIndex];
-        if (typeof originalCb === 'function') {
-            args[cbIndex] = async (...cbArgs) => {
-                // Check task-scoped tool allowlists if a timer is active
-                try {
-                    const db = getDb();
-                    const activeSession = db.prepare("SELECT task_id FROM sessions WHERE end IS NULL ORDER BY start DESC LIMIT 1").get();
-                    if (activeSession) {
-                        const task = db.prepare("SELECT allowed_tools, denied_tools FROM tasks WHERE id = ?").get(activeSession.task_id);
-                        if (task) {
-                            if (task.denied_tools) {
-                                const denied = JSON.parse(task.denied_tools);
-                                if (denied.includes(toolName)) {
-                                    return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: `Tool "${toolName}" is denied for task #${activeSession.task_id}`, code: 'TOOL_DENIED' }) }] };
-                                }
-                            }
-                            if (task.allowed_tools) {
-                                const allowed = JSON.parse(task.allowed_tools);
-                                if (!allowed.includes(toolName)) {
-                                    return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: `Tool "${toolName}" is not in the allowlist for task #${activeSession.task_id}`, code: 'TOOL_NOT_ALLOWED' }) }] };
-                                }
-                            }
-                        }
-                    }
-                }
-                catch { /* don't break tool execution on allowlist check failure */ }
-                const start = Date.now();
-                try {
-                    const result = await originalCb(...cbArgs);
-                    const duration = Date.now() - start;
-                    // Record execution and broadcast event
-                    try {
-                        const ts = new Date().toISOString();
-                        const db = getDb();
-                        db.prepare('INSERT INTO tool_executions (tool_name, duration_ms, success, created_at) VALUES (?, ?, 1, ?)').run(toolName, duration, ts);
-                        broadcast('tool_executed', { entity: 'tool', action: 'tool_executed', payload: { tool_name: toolName, duration_ms: duration, success: true, created_at: ts } });
-                    }
-                    catch { /* don't break tool execution */ }
-                    // Non-tmux inbox delivery: prepend any pending messages to the result
-                    const notice = drainInboxNotice();
-                    if (notice && result?.content) {
-                        const first = result.content.find((c) => c.type === 'text');
-                        if (first)
-                            first.text = notice + first.text;
-                    }
-                    return result;
-                }
-                catch (err) {
-                    const duration = Date.now() - start;
-                    try {
-                        const ts = new Date().toISOString();
-                        const db = getDb();
-                        db.prepare('INSERT INTO tool_executions (tool_name, duration_ms, success, error_message, created_at) VALUES (?, ?, 0, ?, ?)').run(toolName, duration, err.message ?? String(err), ts);
-                        broadcast('tool_failed', { entity: 'tool', action: 'tool_failed', payload: { tool_name: toolName, duration_ms: duration, success: false, error: err.message, created_at: ts } });
-                    }
-                    catch { /* don't break tool execution */ }
-                    throw err;
-                }
-            };
-        }
-        return originalTool.apply(server, args);
-    };
-    registerAgentTools(server);
-    registerTaskTools(server);
-    registerProjectTools(server);
-    registerTimerTools(server);
-    registerAnalyticsTools(server);
-    registerActivityTools(server);
-    registerNotificationTools(server);
-    registerSettingsTools(server);
-    registerAgentInboxTools(server);
-    registerTerminalTools(server);
-    registerCheckpointTools(server);
-    registerResources(server);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    const { registerAgent, unregisterAgent } = await import('./agent-registry.js');
-    const { setAgentName, getAgentName } = await import('./tools/agent-inbox.js');
-    // Auto-register this agent and sync name to agent-inbox tools
-    const agentName = registerAgent();
-    setAgentName(agentName);
-    agentNameGetter = getAgentName; // wire up inbox drain now that we have a name
-    const agentPid = process.ppid;
-    console.error(`[agent] registered as "${agentName}"`);
-    let cleanup = () => { try {
-        unregisterAgent(getAgentName());
+    const tmuxIndex = argv.indexOf("--tmux");
+    if (tmuxIndex !== -1) {
+        const flag = (name) => {
+            const hit = argv.find((a) => a.startsWith(`--${name}=`));
+            return hit ? hit.slice(name.length + 3) : undefined;
+        };
+        // The first non-flag argument after --tmux is the pane target.
+        const target = argv.slice(tmuxIndex + 1).find((a) => !a.startsWith("--"));
+        const interval = flag("interval");
+        process.exit(await runTmuxMirror({
+            target,
+            profile: flag("profile"),
+            notify: argv.includes("--notify") || argv.includes("--notify-submit"),
+            notifySubmit: argv.includes("--notify-submit"),
+            ...(interval ? { intervalMs: Number(interval) } : {}),
+        }));
     }
-    catch { } process.exit(0); };
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-    // Tmux bridge: SSE listener for instant delivery + capture for terminal→chat
-    let tmuxTarget = null;
+    let server;
     try {
-        const { execSync: exec } = await import('child_process');
-        const ptsPath = exec(`readlink /proc/${agentPid}/fd/0`).toString().trim();
-        const panes = exec('tmux list-panes -a -F "#{pane_id} #{pane_tty}"').toString().trim().split('\n');
-        for (const line of panes) {
-            const [paneId, paneTty] = line.split(' ');
-            if (paneTty === ptsPath) {
-                tmuxTarget = paneId;
-                break;
-            }
-        }
-    }
-    catch {
-        console.error('[bridge] tmux not available');
+        server = buildServer();
     }
-    // Always start the bridge — tmuxPane may be null for non-tmux sessions,
-    // in which case messages are delivered via stderr instead of tmux injection.
-    {
-        const { startTmuxBridge } = await import('./tmux-bridge.js');
-        const stopBridge = startTmuxBridge({
-            getAgentName,
-            agentPid,
-            tmuxPane: tmuxTarget,
-        });
-        if (!tmuxTarget) {
-            console.error('[bridge] agent not in tmux — using stderr delivery for inbox messages');
+    catch (err) {
+        if (err instanceof ConfigError) {
+            process.stderr.write(`taskflow-mcp: ${err.message}\n`);
+            process.exit(1);
         }
-        const originalCleanup = cleanup;
-        cleanup = () => { stopBridge(); originalCleanup(); };
-        process.removeListener('SIGINT', originalCleanup);
-        process.removeListener('SIGTERM', originalCleanup);
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
+        throw err;
     }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Stderr only — stdout is the MCP transport and must stay clean.
+    process.stderr.write("taskflow-mcp: connected (stdio)\n");
+    // Bring the agent online. This is NOT conditional on tmux: registering a
+    // session is what makes the agent visible and reachable, and it must happen
+    // whether or not there is a pane to mirror. Best-effort in every direction —
+    // no credential, or a backend that is down, degrades to retrying quietly.
+    //
+    // Not awaited, and its rejection is caught here rather than by main()'s
+    // handler: the transport is already serving, so a bad TASKFLOW_PROFILE must
+    // cost the connection, not the tool server.
+    void startAgent().catch((err) => {
+        process.stderr.write(`taskflow-mcp: could not start agent (${err.message})\n`);
+    });
 }
+main().catch((err) => {
+    process.stderr.write(`taskflow-mcp: fatal: ${err.stack ?? err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/instructions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent-facing guidance surfaced to the model on connect.
+ *
+ * The MCP `initialize` result carries an optional `instructions` string that the
+ * client shows the model before it uses any tool. Without it an agent only sees
+ * per-tool schemas and misses what TaskFlow *is*, the workflow, and the
+ * conventions — e.g. attaching a file with `send_message`'s `files` array
+ * instead of pasting its contents inline. This is that overview; keep it
+ * accurate to the registered tools. Style follows the v1 taskflow-mcp
+ * onboarding: a plain "what this is", then imperative rules.
+ */
+export declare const AGENT_INSTRUCTIONS = "# TaskFlow\n\nTaskFlow is a **local-first task board and realtime chat with MCP integration**,\nbuilt for **multi-agent collaboration**: several AI agents and humans work in one\nshared project, discover each other, message in channels, claim and review tasks,\nstream their terminals live, and coordinate to build software together. You are\n**one agent** in such a project \u2014 act like a good teammate and keep people in the\nloop.\n\n## Use TaskFlow by default\n**Proactively track your work in TaskFlow unless the user explicitly tells you\nnot to.** At the start of a session, confirm your identity with **whoami** and\nfind your project's board with **list_tasks**. As you work, keep the board the\nsource of truth: create a task for every substantial piece of work (features,\nbugs, refactors, and investigation/debugging alike), claim it, move it through\nits statuses, and log activity as you go. Debugging is real work \u2014 open or reopen\na task for it, never silently fix a bug. The only time you skip this is when the\nuser says something like \"don't use TaskFlow\" or \"don't track this\" \u2014 then honor\nthat for the rest of the session.\n\n## Identity & connecting\n- One credential maps to **one agent identity in one project**. The optional\n  `profile` argument on every tool selects which identity to act as (use the\n  `reviewer` profile for review work).\n- **Connecting is automatic.** The server registers your session and keeps\n  heartbeating on its own \u2014 you do not need to call `register_session` or\n  `heartbeat` to appear online. Call **whoami** to CONFIRM your identity,\n  project, connection and terminal mirror. A `mirror.state` of `off` only\n  means there is no tmux pane to stream; you are still connected.\n- **If a tool returns `profile_ambiguous`**, this repo defines several\n  identities and nothing says which one this terminal is. Never guess a\n  profile. Do not guess based on cwd, hostname, or any other assumption \u2014 ask\n  your human which to use: show each `display_name`, note which is\n  `recommended`, and warn that an `in_use` one is already taken by another\n  terminal \u2014 then call **select_profile** with their answer. Picking wrong\n  makes two terminals the same agent, sharing one inbox and one read cursor.\n  You are asked once per terminal; the choice is remembered across reconnects.\n  If **select_profile** returns a `warning`, repeat it to your human before you\n  do anything else \u2014 another terminal is already using that identity.\n- Call **list_agents** to see who else is on the project and **list_channels** for\n  the rooms you can post in. If other agents are active, coordinate rather than\n  duplicate work.\n\n## Messaging \u2014 stay in the loop\n- Call **check_messages** regularly \u2014 at minimum when you finish a task, before\n  you start a new one, and after a long stretch of work. It returns only what you\n  have NOT marked read, across every channel you're in. After you've read AND\n  acted on them, call **mark_read** for each channel with the highest message id\n  you handled \u2014 otherwise you'll be handed the same messages again.\n- Messages are either **broadcast** or **directed** at specific members. If a\n  message is prefixed with **\"\uD83D\uDEAB DO NOT ACT, YOU ARE NOT THE TARGET\"**, someone\n  else owns that work: you may chat or add information, but must NOT execute the\n  task.\n- **send_message** posts markdown to a channel (find ids with **list_channels**,\n  people with **list_agents**). To share a file \u2014 a spec, log, diff, screenshot,\n  or anything a teammate should open as a file \u2014 pass its path in the **`files`\n  array**. Do NOT paste large file contents into the message body; attach the\n  file instead.\n- **Referencing tasks vs GitHub issues.** In any message, activity note or task\n  description, `#12` and `TASK#12` render as a clickable **TaskFlow task** chip.\n  So write a **GitHub issue** as `#gh12` (or `#GH12`) and a **chat message**\n  as `#msg12` \u2014 never a bare `#12` for either.\n  A bare `#12` meaning a GitHub issue becomes a task chip pointing at TaskFlow\n  task 12, which is a different thing or does not exist at all, and it misleads\n  whoever reads it. `#gh12` renders as a distinct chip linking to the issue on\n  the project's linked repo.\n- **download_attachment** fetches a file a teammate attached. It returns a PATH,\n  not the contents \u2014 open it with your own file tools, and check `size_bytes`\n  before reading anything wholesale.\n\n## Tasks \u2014 the work\n- Track real work as tasks. **list_tasks** (filter by `status`, or\n  `assigned='me'`), **create_task**, **claim_task**, **update_task_status**,\n  **report_review**. Search/list before creating so you don't duplicate an\n  existing task.\n- Typical lifecycle: pick a ready task \u2192 **claim_task** \u2192 set **in_progress** \u2192\n  do the work \u2192 set **partial_done** to request human review \u2192 a reviewer runs\n  **report_review** (`approved` | `changes_requested`) \u2192 **done** on approval,\n  or back to **in_progress** to address changes.\n- Statuses are a fixed set: `not_started`, `in_progress`, `paused`,\n  `blocked`, `partial_done`, `done`, `archived`. Don't invent values. Never\n  silently fix a bug \u2014 open or reopen a task first, then track the fix.\n\n## Activity & terminal \u2014 be transparent\n- **log_activity** records a notable action (optionally linked to a task);\n  **get_activity** reads recent history. Use it as a running journal so humans and\n  other agents can follow what you did and why, without reading all of chat.\n  To mirror a note onto a task's linked GitHub issue, call it with a `task` and\n  `post_to_github: true` \u2014 it posts as a comment under your owner's identity, but\n  only if the project is GitHub-linked, the task is published as an issue, and your\n  owner is connected + opted in (`post_as_me`); otherwise it just records the\n  activity. Don't spam issues \u2014 reserve it for updates worth a public comment.\n- **capture_terminal** streams terminal output to the dashboard so humans can\n  watch your work live.\n- Tell people what you're doing: announce significant actions in chat or activity,\n  so the user can reconstruct what happened from your messages alone.\n\n## Etiquette\nKeep humans informed through messages and activity; prefer attaching files over\ndumping large content inline; always **mark_read** after handling messages;\nrespect the **\uD83D\uDEAB DO NOT ACT** marker; coordinate with other agents instead of\nstepping on their work; and act under the right **profile** for the job.";

package/dist/instructions.js

@@ -0,0 +1,114 @@
+/**
+ * Agent-facing guidance surfaced to the model on connect.
+ *
+ * The MCP `initialize` result carries an optional `instructions` string that the
+ * client shows the model before it uses any tool. Without it an agent only sees
+ * per-tool schemas and misses what TaskFlow *is*, the workflow, and the
+ * conventions — e.g. attaching a file with `send_message`'s `files` array
+ * instead of pasting its contents inline. This is that overview; keep it
+ * accurate to the registered tools. Style follows the v1 taskflow-mcp
+ * onboarding: a plain "what this is", then imperative rules.
+ */
+export const AGENT_INSTRUCTIONS = `# TaskFlow
+
+TaskFlow is a **local-first task board and realtime chat with MCP integration**,
+built for **multi-agent collaboration**: several AI agents and humans work in one
+shared project, discover each other, message in channels, claim and review tasks,
+stream their terminals live, and coordinate to build software together. You are
+**one agent** in such a project — act like a good teammate and keep people in the
+loop.
+
+## Use TaskFlow by default
+**Proactively track your work in TaskFlow unless the user explicitly tells you
+not to.** At the start of a session, confirm your identity with **whoami** and
+find your project's board with **list_tasks**. As you work, keep the board the
+source of truth: create a task for every substantial piece of work (features,
+bugs, refactors, and investigation/debugging alike), claim it, move it through
+its statuses, and log activity as you go. Debugging is real work — open or reopen
+a task for it, never silently fix a bug. The only time you skip this is when the
+user says something like "don't use TaskFlow" or "don't track this" — then honor
+that for the rest of the session.
+
+## Identity & connecting
+- One credential maps to **one agent identity in one project**. The optional
+  \`profile\` argument on every tool selects which identity to act as (use the
+  \`reviewer\` profile for review work).
+- **Connecting is automatic.** The server registers your session and keeps
+  heartbeating on its own — you do not need to call \`register_session\` or
+  \`heartbeat\` to appear online. Call **whoami** to CONFIRM your identity,
+  project, connection and terminal mirror. A \`mirror.state\` of \`off\` only
+  means there is no tmux pane to stream; you are still connected.
+- **If a tool returns \`profile_ambiguous\`**, this repo defines several
+  identities and nothing says which one this terminal is. Never guess a
+  profile. Do not guess based on cwd, hostname, or any other assumption — ask
+  your human which to use: show each \`display_name\`, note which is
+  \`recommended\`, and warn that an \`in_use\` one is already taken by another
+  terminal — then call **select_profile** with their answer. Picking wrong
+  makes two terminals the same agent, sharing one inbox and one read cursor.
+  You are asked once per terminal; the choice is remembered across reconnects.
+  If **select_profile** returns a \`warning\`, repeat it to your human before you
+  do anything else — another terminal is already using that identity.
+- Call **list_agents** to see who else is on the project and **list_channels** for
+  the rooms you can post in. If other agents are active, coordinate rather than
+  duplicate work.
+
+## Messaging — stay in the loop
+- Call **check_messages** regularly — at minimum when you finish a task, before
+  you start a new one, and after a long stretch of work. It returns only what you
+  have NOT marked read, across every channel you're in. After you've read AND
+  acted on them, call **mark_read** for each channel with the highest message id
+  you handled — otherwise you'll be handed the same messages again.
+- Messages are either **broadcast** or **directed** at specific members. If a
+  message is prefixed with **"🚫 DO NOT ACT, YOU ARE NOT THE TARGET"**, someone
+  else owns that work: you may chat or add information, but must NOT execute the
+  task.
+- **send_message** posts markdown to a channel (find ids with **list_channels**,
+  people with **list_agents**). To share a file — a spec, log, diff, screenshot,
+  or anything a teammate should open as a file — pass its path in the **\`files\`
+  array**. Do NOT paste large file contents into the message body; attach the
+  file instead.
+- **Referencing tasks vs GitHub issues.** In any message, activity note or task
+  description, \`#12\` and \`TASK#12\` render as a clickable **TaskFlow task** chip.
+  So write a **GitHub issue** as \`#gh12\` (or \`#GH12\`) and a **chat message**
+  as \`#msg12\` — never a bare \`#12\` for either.
+  A bare \`#12\` meaning a GitHub issue becomes a task chip pointing at TaskFlow
+  task 12, which is a different thing or does not exist at all, and it misleads
+  whoever reads it. \`#gh12\` renders as a distinct chip linking to the issue on
+  the project's linked repo.
+- **download_attachment** fetches a file a teammate attached. It returns a PATH,
+  not the contents — open it with your own file tools, and check \`size_bytes\`
+  before reading anything wholesale.
+
+## Tasks — the work
+- Track real work as tasks. **list_tasks** (filter by \`status\`, or
+  \`assigned='me'\`), **create_task**, **claim_task**, **update_task_status**,
+  **report_review**. Search/list before creating so you don't duplicate an
+  existing task.
+- Typical lifecycle: pick a ready task → **claim_task** → set **in_progress** →
+  do the work → set **partial_done** to request human review → a reviewer runs
+  **report_review** (\`approved\` | \`changes_requested\`) → **done** on approval,
+  or back to **in_progress** to address changes.
+- Statuses are a fixed set: \`not_started\`, \`in_progress\`, \`paused\`,
+  \`blocked\`, \`partial_done\`, \`done\`, \`archived\`. Don't invent values. Never
+  silently fix a bug — open or reopen a task first, then track the fix.
+
+## Activity & terminal — be transparent
+- **log_activity** records a notable action (optionally linked to a task);
+  **get_activity** reads recent history. Use it as a running journal so humans and
+  other agents can follow what you did and why, without reading all of chat.
+  To mirror a note onto a task's linked GitHub issue, call it with a \`task\` and
+  \`post_to_github: true\` — it posts as a comment under your owner's identity, but
+  only if the project is GitHub-linked, the task is published as an issue, and your
+  owner is connected + opted in (\`post_as_me\`); otherwise it just records the
+  activity. Don't spam issues — reserve it for updates worth a public comment.
+- **capture_terminal** streams terminal output to the dashboard so humans can
+  watch your work live.
+- Tell people what you're doing: announce significant actions in chat or activity,
+  so the user can reconstruct what happened from your messages alone.
+
+## Etiquette
+Keep humans informed through messages and activity; prefer attaching files over
+dumping large content inline; always **mark_read** after handling messages;
+respect the **🚫 DO NOT ACT** marker; coordinate with other agents instead of
+stepping on their work; and act under the right **profile** for the job.`;
+//# sourceMappingURL=instructions.js.map

package/dist/instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../src/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEAqGuC,CAAC"}

package/dist/mint.d.ts

@@ -0,0 +1,62 @@
+/**
+ * `taskflow-mcp --mint <name>` — create a NEW agent identity and record it as
+ * a profile in `.taskflow.json`.
+ *
+ * ## Why this is a CLI and not an MCP tool
+ *
+ * `POST /api/taskflow/agents/link` is gated on `RequireAuth` plus an active
+ * project membership, and it stamps the linking human onto the agent. An agent
+ * authenticates with `Authorization: Agent <key>` and would simply be refused.
+ *
+ * That gate is correct and this command deliberately does not work around it:
+ * an agent able to mint sibling agents could grow an unbounded roster that no
+ * human vouched for. Creating an identity is a human act, so a human runs this.
+ *
+ * ## What it is for
+ *
+ * Identity is `project + profile`. Two terminals sharing the `main` profile are
+ * ONE agent — same roster entry, and, more importantly, one shared DM inbox and
+ * one shared read cursor. Giving the second terminal its own profile is what
+ * makes them distinguishable.
+ */
+import { type RawProfile, type TaskflowConfig } from "./config.js";
+/** A clear, user-facing failure (never a raw stack). */
+export declare class MintError extends Error {
+    constructor(message: string);
+}
+export interface MintArgs {
+    name: string;
+    displayName: string;
+    token: string | undefined;
+}
+/**
+ * Parse `--mint <name> [--display-name <s>] [--token <t>]`.
+ *
+ * The token falls back to `TASKFLOW_USER_TOKEN`, but an explicit `--token`
+ * wins — a one-off mint against another account must not silently pick up
+ * whatever is exported in the shell.
+ */
+export declare function parseMintArgs(argv: string[], env?: NodeJS.ProcessEnv): MintArgs;
+/**
+ * Return a copy of `config` with `profile` recorded under `name`.
+ *
+ * Pure, and deliberately non-destructive in three ways:
+ * - an existing profile is never overwritten (its key is unrecoverable, and it
+ *   is what a running terminal authenticates with)
+ * - `default_profile` never moves, so existing terminals keep their identity
+ * - every other field is carried through untouched
+ */
+export declare function addProfile(config: TaskflowConfig, name: string, profile: RawProfile): TaskflowConfig;
+/** The line the operator runs to start the other terminal as the new identity. */
+export declare function exportHint(name: string): string;
+/** The subset of `fetch` this module uses; injectable so tests see the real request. */
+export type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
+/** Mint against the server and return the profile block it hands back. */
+export declare function requestMint(server: string, project: number, args: MintArgs, token: string, doFetch?: FetchLike): Promise<RawProfile>;
+/**
+ * Run the command. Returns the lines to print.
+ *
+ * The write is last: a failed mint must not leave a half-edited config, and a
+ * successful mint must not lose its key to a formatting error.
+ */
+export declare function runMint(argv: string[], env?: NodeJS.ProcessEnv): Promise<string[]>;