synomem 0.1.1 → 0.2.0

package/ARCHITECTURE.md

@@ -44,7 +44,7 @@ reconstruct one requested aggregate. Generated Markdown is never a machine query
 ## Authorization
 
 MCP servers bind one actor at startup, and tool inputs cannot override it. Humans have local
-administrative authority. Agents can manage their own notes, recipient memo state, and todos they
+administrative authority. Agents can manage their own notes and todos, recipient memo state, and tasks they
 created or received. System actors have no implicit agent or administrator authority. Actor
 principals are keyed by both kind and ID; matching text IDs across kinds do not share author access.
 
@@ -55,7 +55,7 @@ The filesystem owner remains the ultimate local authority.
 ## Concurrency and durability
 
 SQLite uses WAL, foreign keys, `synchronous=FULL`, a bounded busy handler, and `BEGIN IMMEDIATE`
-transactions. Actor-scoped idempotency protects retries. Note and todo revisions use aggregate
+transactions. Actor-scoped idempotency protects retries. Note, task, and todo revisions use aggregate
 versions so stale writes fail with `REVISION_CONFLICT` rather than overwriting concurrent state.
 
 V1 supports one machine and one filesystem owner. A future hosted service must enforce the same

package/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes will be documented here. The format follows
 
 ## [Unreleased]
 
+### Changed
+
+- The MCP server binds to an agent with `--agent-id`, reading the display name and actor kind from
+  the agent's profile. `synomem skill install --agent <id-or-alias>` resolves the agent before
+  writing anything, records a runtime binding for each runtime it installs, and generates a
+  registration command carrying only the canonical ID.
+
+## [0.2.0] - 2026-09-05
+
+### Added
+
+- Private todos as a distinct domain: a todo belongs to the agent that wrote it, is visible to no
+  one else, and cannot be assigned. Work meant for another agent is a task.
+- Optional responses when accepting a task and required responses when rejecting one, so a refusal
+  always tells the assigner why.
+- Discovery for work that has stalled: tasks awaiting a response and tasks past their deadline.
+- Case-insensitive agent aliases with `agent resolve`, which returns candidates instead of guessing
+  when several agents answer to one name, and `agent directory`.
+- Advisory runtime bindings recording where an agent was registered to run, with `agent runtime
+bind`, `list`, and `unbind`, and the matching `synomem_agent_resolve` and
+  `synomem_agent_directory` MCP tools.
+
+### Changed
+
+- Schema version 5 adds a normalized alias column with a unique index and an
+  `agent_runtime_bindings` table. Existing databases migrate in place.
+- Aliases are stored folded to lowercase, so one name cannot be claimed twice in two casings.
+
 ## [0.1.1] - 2026-09-04
 
 ### Fixed

package/README.md

@@ -69,11 +69,17 @@ synomem note create --as gracie \
   --title "Release invariant" \
   --body "Never publish without explicit maintainer authorization."
 
-synomem todo create codex \
+synomem task create codex \
   --from gracie --title "Review the migration" --due-date 2026-09-15
 
 synomem inbox codex
-synomem todo accept <todo-id> --as codex
+synomem task accept <task-id> --as codex --response "Starting after the tests."
+
+# A todo is private to the agent that wrote it; nobody else can assign one.
+synomem todo create --as codex --title "Re-read the migration notes"
+
+synomem agent resolve Mike
+synomem agent directory
 synomem list
 ```
 
@@ -87,15 +93,15 @@ terminal-capable agent. The Synomem package contains the portable
 installer for the six named local harnesses.
 
 ```text
-Set up Synomem for this agent and runtime. Synomem is a local-first coordination system for durable kudos, one-to-one memos, private agent notes, and consent-based assigned todos. It uses an append-only SQLite database under ~/.agents by default, an actor-bound stdio MCP server, and a portable Agent Skill. Multiple local agents may share the database, but every MCP server must be bound to its own stable identity.
+Set up Synomem for this agent and runtime. Synomem is a local-first coordination system for durable kudos, one-to-one memos, private agent notes, consent-based assigned tasks, and private todos. It uses an append-only SQLite database under ~/.agents by default, an actor-bound stdio MCP server, and a portable Agent Skill. Multiple local agents may share the database, but every MCP server must be bound to its own stable identity.
 
 Work autonomously through the safe, reversible steps below. Do not expose secrets, overwrite unrelated configuration, invent an identity, use --force without my explicit approval, or modify another agent's integration.
 
 1. Verify Node.js 22.13+ and npm are available. Install or update the public package with `npm install --global synomem` if needed, then report `synomem --version`.
 2. Preserve an existing `SYNOMEM_HOME`; otherwise use the default ~/.agents. Run `synomem init`, then `synomem doctor`. Never point tests or experiments at another Synomem home.
 3. Run `synomem agent list`. Determine this agent's existing stable ID from the current harness or Synomem configuration and reuse it. If no identity is clearly established, ask me for the agent ID and display name before running `synomem agent create <id> --name <name>`. Never silently merge or rename identities.
-4. Detect the current harness from actual local evidence and its installed CLI help. Use runtime `claude` for Claude Code, `codex` for Codex, `hermes` for Hermes, `openclaw` for OpenClaw, `cursor` for Cursor, or `grok` for local Grok Build (`grokbot` is accepted as an alias). Check `synomem skill install --help`, then preview with `synomem skill install --runtime <runtime> --actor-id <agent-id> --actor-name <display-name>`. Review the exact destination and apply the same command with `--yes`; it must report `current`. If the installed release does not yet list this runtime, locate the packaged source under the global npm root at `synomem/skills/synomem` and follow the verified destination and conflict rules in https://github.com/Coaden/synomem/blob/main/docs/skill.md instead. Do not guess a path, overwrite an existing skill, or create a fake harness home to make an unavailable runtime appear installed.
-5. Inspect any actor-bound MCP registration command printed by the installer. Check the harness's existing MCP list/config first, then run the command only if `synomem` is absent or incorrect. Do not create duplicates. Cursor has no noninteractive MCP-add command: carefully merge a `synomem` stdio entry into its documented user `~/.cursor/mcp.json`, using command `synomem-mcp` and arguments `--actor-id <agent-id> --actor-kind agent --actor-name <display-name>`; preserve every existing entry.
+4. Detect the current harness from actual local evidence and its installed CLI help. Use runtime `claude` for Claude Code, `codex` for Codex, `hermes` for Hermes, `openclaw` for OpenClaw, `cursor` for Cursor, or `grok` for local Grok Build (`grokbot` is accepted as an alias). Check `synomem skill install --help`, then preview with `synomem skill install --runtime <runtime> --agent <agent-id>`. Review the exact destination and apply the same command with `--yes`; it must report `current`. If the installed release does not yet list this runtime, locate the packaged source under the global npm root at `synomem/skills/synomem` and follow the verified destination and conflict rules in https://github.com/Coaden/synomem/blob/main/docs/skill.md instead. Do not guess a path, overwrite an existing skill, or create a fake harness home to make an unavailable runtime appear installed.
+5. Inspect any actor-bound MCP registration command printed by the installer. Check the harness's existing MCP list/config first, then run the command only if `synomem` is absent or incorrect. Do not create duplicates. Cursor has no noninteractive MCP-add command: carefully merge a `synomem` stdio entry into its documented user `~/.cursor/mcp.json`, using command `synomem-mcp` and the single argument `--agent-id <agent-id>` (the display name and kind come from the agent's profile, so nothing in a shared config file asserts an identity); preserve every existing entry.
 6. Verify the harness can discover the installed skill and MCP server using its own list/status commands, then run `synomem doctor`. Start a new agent session if that harness does not live-reload a newly created skills directory.
 7. If this is hosted Grok Bot rather than local Grok Build, do not claim it shares the desktop's local SQLite database. Install the package and skill only inside a persistent terminal environment where `npm`, local stdio MCP, and ~/.grok are actually available. Otherwise provide the skill URL https://github.com/Coaden/synomem/blob/main/skills/synomem/SKILL.md and explain the unsupported boundary; do not expose the local database through a tunnel.
 8. Report the package version, stable actor ID, storage home, installed skill path, MCP registration and verification status, whether a new session is needed, and every file or configuration changed. Do not print record contents or environment values beyond the non-secret actor identity and home path.
@@ -130,13 +136,20 @@ await client.notes.revise({
   body: 'Never publish or create a release without explicit maintainer authorization.',
 });
 
-await client.todos.create({
+// A task is assigned to someone else and needs their consent.
+await client.tasks.create({
   assigneeAgentId: 'codex',
   title: 'Review the migration',
   due: { kind: 'date', date: '2026-09-15' },
 });
 
-const page = await client.items.list({ kinds: ['memo', 'todo'], limit: 10 });
+// A todo is the agent's own reminder, visible to no one else.
+await client.todos.create({
+  title: 'Re-read the migration notes',
+  due: { kind: 'date', date: '2026-09-14' },
+});
+
+const page = await client.items.list({ kinds: ['memo', 'task'], limit: 10 });
 const changes = await client.items.changes({ after: page.watermark });
 
 await client.close();
@@ -147,7 +160,7 @@ The library performs no filesystem work at import time and never terminates its
 ## Context-safe reads
 
 `client.items.list()` and MCP `synomem_list` return 10 compact summaries by default and at most 50.
-Summaries omit message bodies, kudos reasons and evidence, note bodies, todo descriptions, source,
+Summaries omit message bodies, kudos reasons and evidence, note bodies, task and todo details, source,
 and metadata. Fetch one authorized detail record with `items.get(id)` or `synomem_get`.
 
 Incremental reads return at most 20 changes by default and 100 at most. List and change responses
@@ -176,9 +189,9 @@ bounded reads. See [the MCP guide](docs/mcp.md).
 The package includes [`skills/synomem`](skills/synomem). Installation is explicit and dry-run first:
 
 ```bash
-synomem skill install --runtime codex --actor-id codex --actor-name "Codex"
-synomem skill install --runtime codex --actor-id codex --actor-name "Codex" --yes
-synomem skill install --runtime hermes --actor-id mycroft --actor-name "Mycroft" --yes
+synomem skill install --runtime codex --agent codex
+synomem skill install --runtime codex --agent codex --yes
+synomem skill install --runtime hermes --agent mycroft --yes
 synomem skill status
 ```
 
@@ -197,8 +210,8 @@ are `claude`, `codex`, `hermes`, `openclaw`, `cursor`, and `grok`; `grokbot` ali
     ├── profile.json
     ├── WINS.md
     ├── MEMORY.md
-    ├── TODOS.md
-    ├── inbox/{kudos,memos,todos}/
+    ├── TASKS.md
+    ├── inbox/{kudos,memos,tasks}/
     └── NOTES.md
 ```
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAKA,OAAO,EAAE,OAAO,EAA0B,MAAM,WAAW,CAAC;AAE5D,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAIhG,OAAO,EAA4C,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE9F,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AASrB,OAAO,KAAK,EACV,aAAa,EAQd,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAkB,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1E,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE;QACjC,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,aAAa,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,eAAe,CAAC;KAClC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7D,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE;QACvB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,aAAa,CAAC;QACrB,MAAM,EAAE,YAAY,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,KAAK,OAAO,CAAC,aAAa,GAAG,YAAY,CAAC,CAAC;CAC7C;AAkND,wBAAgB,SAAS,CACvB,EAAE,GAAE,KAAiB,EACrB,cAAc,GAAE,qBAAgD,EAChE,YAAY,GAAE,eAAoB,GACjC,OAAO,CAi1CT;AAED,wBAAsB,MAAM,CAC1B,IAAI,WAAe,EACnB,EAAE,GAAE,KAAiB,EACrB,cAAc,GAAE,qBAAgD,EAChE,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,MAAM,CAAC,CAqBjB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAKA,OAAO,EAAE,OAAO,EAA0B,MAAM,WAAW,CAAC;AAE5D,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAIhG,OAAO,EAA4C,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE9F,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AASrB,OAAO,KAAK,EACV,aAAa,EAQd,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAkB,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1E,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE;QACjC,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,aAAa,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,eAAe,CAAC;KAClC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7D,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE;QACvB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,aAAa,CAAC;QACrB,MAAM,EAAE,YAAY,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,KAAK,OAAO,CAAC,aAAa,GAAG,YAAY,CAAC,CAAC;CAC7C;AAkND,wBAAgB,SAAS,CACvB,EAAE,GAAE,KAAiB,EACrB,cAAc,GAAE,qBAAgD,EAChE,YAAY,GAAE,eAAoB,GACjC,OAAO,CA8qDT;AAED,wBAAsB,MAAM,CAC1B,IAAI,WAAe,EACnB,EAAE,GAAE,KAAiB,EACrB,cAAc,GAAE,qBAAgD,EAChE,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,MAAM,CAAC,CAqBjB"}

package/dist/cli.js

@@ -62,7 +62,7 @@ function defaultActor(env, fallbackKind, fallbackId) {
         return actor(fallbackKind, fallbackId);
     return actor(env.SYNOMEM_ACTOR_KIND?.trim() || fallbackKind, id, env.SYNOMEM_ACTOR_NAME?.trim());
 }
-function todoDue(options) {
+function taskDue(options) {
     if (options.dueDate && options.dueAt)
         throw new SynomemError('INVALID_INPUT', 'Use due-date or due-at, not both.');
     if (options.dueDate)
@@ -444,32 +444,64 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--yes', 'apply the displayed plan', false)
         .option('--force', 'replace a conflicting synomem directory', false)
         .option('--link', 'symlink to the packaged skill instead of copying it', false)
-        .option('--actor-id <id>', 'print actor-bound MCP registration commands')
-        .option('--actor-name <name>', 'display name used in MCP registration commands')
-        .action((options, command) => {
+        .option('--agent <id-or-alias>', 'bind this installation to an agent')
+        .action(async (options, command) => {
         const global = globals(command);
+        const runtimes = skillRuntimes(options.runtime);
+        /*
+         * The agent is resolved BEFORE anything is written. An ambiguous or
+         * unknown name then stops the command with a name to fix, rather than
+         * leaving a skill installed and pointed at an agent that does not
+         * exist.
+         */
+        let agentId;
+        if (options.agent) {
+            agentId = await withClient(global.home, defaultActor(env, 'system', 'cli'), async (client) => {
+                const resolution = await client.agents.resolve(options.agent);
+                if (!resolution.match) {
+                    throw new SynomemError('AGENT_NOT_FOUND', resolution.candidates.length
+                        ? `"${options.agent}" matches ${resolution.candidates.length} agents: ${resolution.candidates
+                            .map((candidate) => candidate.id)
+                            .join(', ')}. Name one of them.`
+                        : `Unknown agent: ${options.agent}`);
+                }
+                return resolution.match.id;
+            });
+        }
         const result = installSkill({
-            runtimes: skillRuntimes(options.runtime),
+            ...(runtimes ? { runtimes } : {}),
             apply: options.yes,
             force: options.force,
             link: options.link,
-            actorId: options.actorId,
-            actorName: options.actorName,
+            ...(agentId ? { agentId } : {}),
         });
+        // Bindings follow what was actually installed, and only on a real run:
+        // a dry run must not claim a binding it did not make, and a runtime
+        // whose harness is not present here is not somewhere this agent runs.
+        if (agentId && options.yes) {
+            const installed = result.locations
+                .filter((location) => location.state !== 'unavailable')
+                .map((location) => location.runtime);
+            if (installed.length) {
+                await withClient(global.home, defaultActor(env, 'system', 'cli'), async (client) => {
+                    for (const runtime of installed) {
+                        await client.agents.bindRuntime({ agentId, runtime });
+                    }
+                });
+            }
+        }
         output(io, global.json, result, formatSkillResult(result, 'install'));
     });
     skillCommand
         .command('status')
         .description('Show installed, stale, missing, or conflicting skill copies')
         .option('--runtime <runtime>', `${skillRuntimeHelp} (repeatable)`, collect, [])
-        .option('--actor-id <id>', 'print actor-bound MCP registration commands')
-        .option('--actor-name <name>', 'display name used in MCP registration commands')
+        .option('--agent <id>', 'print the registration command for this agent')
         .action((options, command) => {
         const global = globals(command);
         const result = skillStatus({
             runtimes: skillRuntimes(options.runtime),
-            actorId: options.actorId,
-            actorName: options.actorName,
+            ...(options.agent ? { agentId: options.agent } : {}),
         });
         output(io, global.json, result, formatSkillResult(result, 'status'));
     });
@@ -526,6 +558,84 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         }));
         output(io, global.json, profile, `Updated ${profile.displayName} (${profile.id})`);
     });
+    agentCommand
+        .command('resolve <name>')
+        .description('Resolve a name or alias to one agent, or list the candidates')
+        .action(async (name, _options, command) => {
+        const global = globals(command);
+        const resolution = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.resolve(name));
+        // An ambiguous name is a question, not a failure: exit zero and show the
+        // candidates so the caller can pick one.
+        const human = resolution.match
+            ? `${resolution.match.displayName} (${resolution.match.id})`
+            : resolution.candidates.length
+                ? `"${resolution.query}" is ambiguous. Candidates:\n${resolution.candidates
+                    .map((profile) => `  ${profile.id}  ${profile.displayName}`)
+                    .join('\n')}`
+                : `No agent answers to "${resolution.query}".`;
+        output(io, global.json, resolution, human);
+    });
+    agentCommand
+        .command('directory')
+        .description('List agents with their runtime bindings')
+        .action(async (_options, command) => {
+        const global = globals(command);
+        const entries = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.directory());
+        const human = entries.length
+            ? entries
+                .map((entry) => {
+                const runtimes = entry.runtimeBindings.length
+                    ? entry.runtimeBindings
+                        .map((binding) => `    ${binding.runtime}${binding.profile ? `/${binding.profile}` : ''}` +
+                        // Last-seen is advisory, so it is labelled as an
+                        // observation rather than a status.
+                        `${binding.lastSeenAt ? `  last seen ${binding.lastSeenAt}` : '  not yet seen'}`)
+                        .join('\n')
+                    : '    no runtime bindings';
+                return `${entry.profile.id}  ${entry.profile.displayName}\n${runtimes}`;
+            })
+                .join('\n')
+            : 'No agents configured.';
+        output(io, global.json, { entries }, human);
+    });
+    const runtimeCommand = agentCommand.command('runtime').description('Record where an agent runs');
+    runtimeCommand
+        .command('bind <agent>')
+        .description('Bind an agent to a runtime')
+        .requiredOption('--runtime <name>', 'runtime family, e.g. claude-code')
+        .option('--profile <name>', 'named configuration within the runtime')
+        .option('--installation <id>', 'hosted installation this binding belongs to')
+        .action(async (agent, options, command) => {
+        const global = globals(command);
+        const binding = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.bindRuntime({
+            agentId: agent,
+            runtime: options.runtime,
+            ...(options.profile ? { profile: options.profile } : {}),
+            ...(options.installation ? { installationId: options.installation } : {}),
+        }));
+        output(io, global.json, binding, `Bound ${binding.agentId} to ${binding.runtime}${binding.profile ? `/${binding.profile}` : ''} (${binding.id})`);
+    });
+    runtimeCommand
+        .command('list <agent>')
+        .description('List an agent runtime bindings')
+        .action(async (agent, _options, command) => {
+        const global = globals(command);
+        const bindings = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.bindings(agent));
+        const human = bindings.length
+            ? bindings
+                .map((binding) => `${binding.id}  ${binding.runtime}${binding.profile ? `/${binding.profile}` : ''}  bound ${binding.boundAt}`)
+                .join('\n')
+            : 'No runtime bindings.';
+        output(io, global.json, { bindings }, human);
+    });
+    runtimeCommand
+        .command('unbind <binding-id>')
+        .description('Remove a runtime binding')
+        .action(async (bindingId, _options, command) => {
+        const global = globals(command);
+        const removed = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.unbindRuntime(bindingId));
+        output(io, global.json, { removed }, removed ? `Removed binding ${bindingId}.` : `No binding ${bindingId}.`);
+    });
     const kudosCommand = program.command('kudos').description('Give and manage agent recognition');
     kudosCommand
         .command('give <recipient>')
@@ -555,7 +665,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     });
     program
         .command('inbox [agent]')
-        .description('Show pending kudos, memos, and todos for an agent')
+        .description('Show pending kudos, memos, and tasks for an agent')
         .option('--as <agent-id>', 'defaults to the positional agent')
         .option('--limit <number>', 'maximum results (default 10, maximum 50)', '10')
         .option('--cursor <cursor>', 'opaque cursor returned by the previous page')
@@ -584,7 +694,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     program
         .command('list')
         .description('List compact summaries across all record types')
-        .option('--kind <kind>', 'kudos, memo, note, or todo (repeatable)', collect, [])
+        .option('--kind <kind>', 'kudos, memo, note, or task (repeatable)', collect, [])
         .option('--participant <agent>')
         .option('--actor <id>')
         .option('--tag <tag>')
@@ -755,8 +865,100 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         }));
         output(io, global.json, record, `Archived note ${id}.`);
     });
-    const todoCommand = program.command('todo').description('Create and manage agent todos');
+    const todoCommand = program
+        .command('todo')
+        .description('Create and manage your own private reminders');
     todoCommand
+        .command('create')
+        .requiredOption('--as <actor-id>')
+        .option('--actor-kind <kind>', 'human, agent, or system', 'agent')
+        .requiredOption('--title <title>')
+        .option('--details <text>', 'private working detail')
+        .option('--priority <number>', '1 highest, 4 lowest', '3')
+        .option('--due-date <date>')
+        .option('--due-at <datetime>')
+        .option('--time-zone <iana-zone>')
+        .option('--tag <tag>', 'tag (repeatable)', collect, [])
+        .option('--idempotency-key <key>')
+        .action(async (options, command) => {
+        const global = globals(command);
+        const result = await withClient(global.home, actor(options.actorKind, options.as), (client) => client.todos.create({
+            title: options.title,
+            ...(options.details ? { details: options.details } : {}),
+            priority: Number(options.priority),
+            ...((due) => (due ? { due } : {}))(taskDue(options)),
+            ...(options.tag.length ? { tags: options.tag } : {}),
+            ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
+        }));
+        output(io, global.json, result, `${result.deduplicated ? 'Found existing' : 'Created'} private todo\nTitle: ${result.record.current.title}\nID: ${result.record.event.id}`);
+    });
+    todoCommand
+        .command('list')
+        .requiredOption('--as <actor-id>')
+        .option('--actor-kind <kind>', 'human, agent, or system', 'agent')
+        .option('--status <status>')
+        .option('--limit <number>', 'maximum results', '10')
+        .action(async (options, command) => {
+        const global = globals(command);
+        const page = await withClient(global.home, actor(options.actorKind, options.as), (client) => client.todos.list({
+            ...(options.status ? { status: options.status } : {}),
+            limit: Number(options.limit),
+        }));
+        output(io, global.json, page, page.items.length
+            ? page.items
+                .map((item) => `${item.id}  ${item.status.padEnd(9)}  ${item.title}`)
+                .join('\n')
+            : 'No todos.');
+    });
+    todoCommand
+        .command('show <todo-id>')
+        .requiredOption('--as <actor-id>')
+        .option('--actor-kind <kind>', 'human, agent, or system', 'agent')
+        .action(async (id, options, command) => {
+        const global = globals(command);
+        const record = await withClient(global.home, actor(options.actorKind, options.as), (client) => client.todos.get(id));
+        output(io, global.json, record, `${record.current.title}\nStatus: ${record.status}\nPriority: ${record.current.priority}\nVersion: ${record.current.version}${record.current.details ? `\n\n${record.current.details}` : ''}`);
+    });
+    for (const operation of ['complete', 'reopen', 'cancel', 'archive']) {
+        todoCommand
+            .command(`${operation} <todo-id>`)
+            .requiredOption('--as <actor-id>')
+            .option('--actor-kind <kind>', 'human, agent, or system', 'agent')
+            .option('--note <text>')
+            .option('--reason <text>')
+            .option('--idempotency-key <key>')
+            .action(async (id, options, command) => {
+            const global = globals(command);
+            const record = await withClient(global.home, actor(options.actorKind, options.as), (client) => operation === 'complete'
+                ? client.todos.complete({
+                    todoId: id,
+                    ...(options.note ? { note: options.note } : {}),
+                    ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
+                })
+                : operation === 'cancel'
+                    ? client.todos.cancel({
+                        todoId: id,
+                        ...(options.reason ? { reason: options.reason } : {}),
+                        ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
+                    })
+                    : operation === 'archive'
+                        ? client.todos.archive({
+                            todoId: id,
+                            ...(options.idempotencyKey
+                                ? { idempotencyKey: options.idempotencyKey }
+                                : {}),
+                        })
+                        : client.todos.reopen({
+                            todoId: id,
+                            ...(options.idempotencyKey
+                                ? { idempotencyKey: options.idempotencyKey }
+                                : {}),
+                        }));
+            output(io, global.json, record, `Todo ${id} is now ${record.status}.`);
+        });
+    }
+    const taskCommand = program.command('task').description('Create and manage agent tasks');
+    taskCommand
         .command('create <assignee>')
         .requiredOption('--from <actor-id>')
         .option('--actor-kind <kind>', 'human, agent, or system', 'agent')
@@ -771,39 +973,39 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--idempotency-key <key>')
         .action(async (assignee, options, command) => {
         const global = globals(command);
-        const result = await withClient(global.home, actor(options.actorKind, options.from), (client) => client.todos.create({
+        const result = await withClient(global.home, actor(options.actorKind, options.from), (client) => client.tasks.create({
             assigneeAgentId: assignee,
             title: options.title,
             ...(options.description ? { description: options.description } : {}),
             priority: Number(options.priority),
-            ...((due) => (due ? { due } : {}))(todoDue(options)),
+            ...((due) => (due ? { due } : {}))(taskDue(options)),
             ...(options.tag.length ? { tags: options.tag } : {}),
             visibility: options.visibility,
             ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
         }));
-        output(io, global.json, result, `${result.deduplicated ? 'Found existing' : 'Created'} todo for ${result.record.event.assigneeDisplayName}\nTitle: ${result.record.current.title}\nID: ${result.record.event.id}`);
+        output(io, global.json, result, `${result.deduplicated ? 'Found existing' : 'Created'} task for ${result.record.event.assigneeDisplayName}\nTitle: ${result.record.current.title}\nID: ${result.record.event.id}`);
     });
-    todoCommand
+    taskCommand
         .command('list')
         .option('--assignee <agent>')
         .option('--status <status>')
         .option('--limit <number>', 'maximum results', '10')
         .action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.todos.list({
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.tasks.list({
             ...(options.assignee ? { participantAgentId: options.assignee } : {}),
             ...(options.status ? { status: options.status } : {}),
             limit: Number(options.limit),
         }));
-        output(io, global.json, page, page.items.map(lineForItem).join('\n') || 'No todos found.');
+        output(io, global.json, page, page.items.map(lineForItem).join('\n') || 'No tasks found.');
     });
-    todoCommand.command('show <todo-id>').action(async (id, _options, command) => {
+    taskCommand.command('show <task-id>').action(async (id, _options, command) => {
         const global = globals(command);
-        const record = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.todos.get(id));
+        const record = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.tasks.get(id));
         output(io, global.json, record, `${record.current.title}\nID: ${record.event.id}\nStatus: ${record.status}\nVersion: ${record.current.version}`);
     });
-    todoCommand
-        .command('update <todo-id>')
+    taskCommand
+        .command('update <task-id>')
         .requiredOption('--as <actor-id>')
         .option('--actor-kind <kind>', 'agent or human', 'agent')
         .requiredOption('--expected-version <number>')
@@ -818,9 +1020,9 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--idempotency-key <key>')
         .action(async (id, options, command) => {
         const global = globals(command);
-        const parsedDue = todoDue(options);
-        const record = await withClient(global.home, actor(options.actorKind, options.as), (client) => client.todos.update({
-            todoId: id,
+        const parsedDue = taskDue(options);
+        const record = await withClient(global.home, actor(options.actorKind, options.as), (client) => client.tasks.update({
+            taskId: id,
             expectedVersion: Number(options.expectedVersion),
             ...(options.title ? { title: options.title } : {}),
             ...(options.description !== undefined ? { description: options.description } : {}),
@@ -829,52 +1031,59 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
             ...(options.visibility ? { visibility: options.visibility } : {}),
             ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
         }));
-        output(io, global.json, record, `Updated todo ${id} to version ${record.current.version}.`);
+        output(io, global.json, record, `Updated task ${id} to version ${record.current.version}.`);
     });
     for (const operation of ['accept', 'reject', 'complete', 'reopen', 'cancel']) {
-        todoCommand
-            .command(`${operation} <todo-id>`)
+        const command_ = taskCommand
+            .command(`${operation} <task-id>`)
             .requiredOption('--as <actor-id>')
             .option('--actor-kind <kind>', 'agent or human', 'agent')
             .option('--note <text>')
             .option('--reason <text>')
-            .option('--idempotency-key <key>')
-            .action(async (id, options, command) => {
+            .option('--idempotency-key <key>');
+        // Rejecting requires saying why; accepting may. Marked required at the
+        // parser so the CLI refuses before touching the store.
+        if (operation === 'reject') {
+            command_.requiredOption('--response <text>', 'why the task is being refused');
+        }
+        else if (operation === 'accept') {
+            command_.option('--response <text>', 'conditions, timing, or partial capability');
+        }
+        command_.action(async (id, options, command) => {
             const global = globals(command);
             const record = await withClient(global.home, actor(options.actorKind, options.as), (client) => operation === 'accept'
-                ? client.todos.accept({
-                    todoId: id,
+                ? client.tasks.accept({
+                    taskId: id,
+                    ...(options.response ? { response: options.response } : {}),
                     ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
                 })
                 : operation === 'reject'
-                    ? client.todos.reject({
-                        todoId: id,
-                        ...(options.reason ? { reason: options.reason } : {}),
+                    ? client.tasks.reject({
+                        taskId: id,
+                        response: options.response ?? options.reason ?? '',
                         ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
                     })
                     : operation === 'complete'
-                        ? client.todos.complete({
-                            todoId: id,
+                        ? client.tasks.complete({
+                            taskId: id,
                             ...(options.note ? { note: options.note } : {}),
-                            ...(options.idempotencyKey
-                                ? { idempotencyKey: options.idempotencyKey }
-                                : {}),
+                            ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
                         })
                         : operation === 'cancel'
-                            ? client.todos.cancel({
-                                todoId: id,
+                            ? client.tasks.cancel({
+                                taskId: id,
                                 ...(options.reason ? { reason: options.reason } : {}),
                                 ...(options.idempotencyKey
                                     ? { idempotencyKey: options.idempotencyKey }
                                     : {}),
                             })
-                            : client.todos.reopen({
-                                todoId: id,
+                            : client.tasks.reopen({
+                                taskId: id,
                                 ...(options.idempotencyKey
                                     ? { idempotencyKey: options.idempotencyKey }
                                     : {}),
                             }));
-            output(io, global.json, record, `Todo ${id} is ${record.status}.`);
+            output(io, global.json, record, `Task ${id} is ${record.status}.`);
         });
     }
     kudosCommand
@@ -1011,14 +1220,34 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     program
         .command('mcp')
         .description('Run the actor-bound MCP server over stdio')
-        .requiredOption('--actor-id <id>')
-        .requiredOption('--actor-kind <kind>', 'human, agent, or system')
-        .option('--actor-name <display-name>')
+        .option('--agent-id <id>', 'bound agent, whose identity is read from Synomem')
+        .option('--actor-id <id>', 'bound non-agent actor ID')
+        .option('--actor-kind <kind>', 'human or system')
+        .option('--actor-name <display-name>', 'display name for a non-agent actor')
         .action(async (options, command) => {
         const global = globals(command);
+        // An agent's name comes from its profile, never from the command line:
+        // the name is written into every event the session appends, and a
+        // harness must not be able to sign another agent's name to work.
+        const bound = options.agentId
+            ? await withClient(global.home, defaultActor(env, 'system', 'cli'), async (client) => {
+                const resolution = await client.agents.resolve(options.agentId);
+                if (!resolution.match) {
+                    throw new SynomemError('AGENT_NOT_FOUND', resolution.candidates.length
+                        ? `"${options.agentId}" matches ${resolution.candidates.length} agents: ${resolution.candidates
+                            .map((candidate) => candidate.id)
+                            .join(', ')}. Name one of them.`
+                        : `Unknown agent: ${options.agentId}`);
+                }
+                return actor('agent', resolution.match.id, resolution.match.displayName);
+            })
+            : undefined;
+        if (!bound && !(options.actorId && options.actorKind)) {
+            throw new SynomemError('INVALID_INPUT', 'Specify --agent-id, or --actor-id with --actor-kind for a non-agent actor.');
+        }
         await startMcpServer({
             ...(global.home ? { home: global.home } : {}),
-            actor: actor(options.actorKind, options.actorId, options.actorName),
+            actor: bound ?? actor(options.actorKind, options.actorId, options.actorName),
         });
     });
     return program;