synomem 0.1.0 → 0.2.0

package/dist/cli.js

@@ -50,7 +50,19 @@ function actor(kind, id, displayName) {
         ...(displayName ? { displayName } : {}),
     };
 }
-function todoDue(options) {
+/**
+ * The acting identity for commands that do not take an explicit actor.
+ * Local storage accepts any actor, so these fall back to the historical CLI defaults; a remote
+ * backend binds the credential to one actor, so SYNOMEM_ACTOR_ID/KIND/NAME must be able to
+ * override them or those commands cannot authenticate.
+ */
+function defaultActor(env, fallbackKind, fallbackId) {
+    const id = env.SYNOMEM_ACTOR_ID?.trim();
+    if (!id)
+        return actor(fallbackKind, fallbackId);
+    return actor(env.SYNOMEM_ACTOR_KIND?.trim() || fallbackKind, id, env.SYNOMEM_ACTOR_NAME?.trim());
+}
+function taskDue(options) {
     if (options.dueDate && options.dueAt)
         throw new SynomemError('INVALID_INPUT', 'Use due-date or due-at, not both.');
     if (options.dueDate)
@@ -272,7 +284,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         if (persisted?.backend.kind === 'remote') {
             throw new SynomemError('INVALID_INPUT', 'The init command requires a local backend.');
         }
-        await withClient(options.home, actor('system', 'cli'), async (client) => {
+        await withClient(options.home, defaultActor(env, 'system', 'cli'), async (client) => {
             const info = await client.info();
             if (info.backend !== 'local') {
                 throw new SynomemError('INVALID_INPUT', 'The init command requires a local backend.');
@@ -414,7 +426,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--description <text>')
         .action(async (id, options, command) => {
         const global = globals(command);
-        const profile = await withClient(global.home, actor('system', 'cli'), (client) => client.agents.create({
+        const profile = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.create({
             id,
             displayName: options.name,
             ...(options.alias.length ? { aliases: options.alias } : {}),
@@ -432,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'));
     });
@@ -481,7 +525,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('List known agent identities')
         .action(async (_options, command) => {
         const global = globals(command);
-        const agents = await withClient(global.home, actor('system', 'cli'), (client) => client.agents.list());
+        const agents = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.list());
         const human = agents.length
             ? agents
                 .map((profile) => `${profile.id}  ${profile.displayName}${profile.aliases?.length ? `  aliases: ${profile.aliases.join(', ')}` : ''}`)
@@ -494,7 +538,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('Show one agent profile, resolving aliases')
         .action(async (id, _options, command) => {
         const global = globals(command);
-        const profile = await withClient(global.home, actor('system', 'cli'), (client) => client.agents.get(id));
+        const profile = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.get(id));
         output(io, global.json, profile, `${profile.displayName} (${profile.id})\n${profile.description ?? 'No description.'}`);
     });
     agentCommand
@@ -507,13 +551,91 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .action(async (id, options, command) => {
         const global = globals(command);
         const hasAliases = options.clearAliases || options.alias.length > 0;
-        const profile = await withClient(global.home, actor('system', 'cli'), (client) => client.agents.update(id, {
+        const profile = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.agents.update(id, {
             ...(options.name ? { displayName: options.name } : {}),
             ...(hasAliases ? { aliases: options.clearAliases ? [] : options.alias } : {}),
             ...(options.description !== undefined ? { description: options.description } : {}),
         }));
         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>')
@@ -543,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')
@@ -564,7 +686,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     });
     addListOptions(kudosCommand.command('list').description('List and filter kudos')).action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, actor('human', 'local-cli'), (client) => client.kudos.list(listInput(options)));
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.kudos.list(listInput(options)));
         output(io, global.json, page, page.items.length
             ? `${page.items.map(lineForSummary).join('\n')}${page.hasMore ? `\nNext cursor: ${page.nextCursor}` : ''}`
             : 'No kudos found.');
@@ -572,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>')
@@ -583,7 +705,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--offset <number>', 'deprecated offset', '0')
         .action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, actor('human', 'local-cli'), (client) => client.items.list(itemListInput(options)));
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.items.list(itemListInput(options)));
         output(io, global.json, page, page.items.length
             ? `${page.items.map(lineForItem).join('\n')}${page.hasMore ? `\nNext cursor: ${page.nextCursor}` : ''}`
             : 'No items found.');
@@ -596,7 +718,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--limit <number>', 'maximum changes (default 20, maximum 100)', '20')
         .action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, actor('human', 'local-cli'), (client) => client.items.changes({
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.items.changes({
             limit: Number(options.limit),
             ...(options.kind.length ? { kinds: options.kind } : {}),
             ...(options.after ? { after: options.after } : {}),
@@ -639,7 +761,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--cursor <cursor>')
         .action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, actor('human', 'local-cli'), (client) => client.memos.list({
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.memos.list({
             ...(options.participant ? { participantAgentId: options.participant } : {}),
             ...(options.status ? { status: options.status } : {}),
             limit: Number(options.limit),
@@ -649,7 +771,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     });
     memoCommand.command('show <memo-id>').action(async (id, _options, command) => {
         const global = globals(command);
-        const record = await withClient(global.home, actor('human', 'local-cli'), (client) => client.memos.get(id));
+        const record = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.memos.get(id));
         output(io, global.json, record, `${record.event.subject}\nID: ${record.event.id}\nStatus: ${record.status}\n\n${record.event.body}`);
     });
     for (const operation of ['read', 'archive']) {
@@ -697,7 +819,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--limit <number>', 'maximum results', '10')
         .action(async (options, command) => {
         const global = globals(command);
-        const page = await withClient(global.home, actor('human', 'local-cli'), (client) => client.notes.list({
+        const page = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.notes.list({
             ...(options.owner ? { participantAgentId: options.owner } : {}),
             ...(options.status ? { status: options.status } : {}),
             limit: Number(options.limit),
@@ -706,7 +828,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     });
     noteCommand.command('show <note-id>').action(async (id, _options, command) => {
         const global = globals(command);
-        const record = await withClient(global.home, actor('human', 'local-cli'), (client) => client.notes.get(id));
+        const record = await withClient(global.home, defaultActor(env, 'human', 'local-cli'), (client) => client.notes.get(id));
         output(io, global.json, record, `${record.current.title}\nID: ${record.event.id}\nVersion: ${record.current.version}\n\n${record.current.body}`);
     });
     noteCommand
@@ -743,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')
@@ -759,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, actor('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, actor('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>')
@@ -806,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 } : {}),
@@ -817,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
@@ -870,7 +1091,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('Show one kudos item and its current state')
         .action(async (id, _options, command) => {
         const global = globals(command);
-        const record = await withClient(global.home, actor('system', 'cli'), (client) => client.kudos.get(id));
+        const record = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.kudos.get(id));
         output(io, global.json, record, showRecord(record));
     });
     kudosCommand
@@ -913,7 +1134,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         const global = globals(command);
         if (!agentId)
             throw new SynomemError('INVALID_INPUT', 'Specify an agent.');
-        const details = await withClient(global.home, actor('system', 'cli'), async (client) => {
+        const details = await withClient(global.home, defaultActor(env, 'system', 'cli'), async (client) => {
             const profile = await client.agents.get(agentId);
             const info = await client.info();
             if (info.backend !== 'local') {
@@ -942,7 +1163,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
     });
     addListOptions(kudosCommand.command('stats').description('Show aggregate kudos statistics')).action(async (options, command) => {
         const global = globals(command);
-        const stats = await withClient(global.home, actor('system', 'cli'), (client) => client.stats(listInput(options)));
+        const stats = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.stats(listInput(options)));
         output(io, global.json, stats, `Total: ${stats.total}\nActive: ${stats.active}\nAcknowledged: ${stats.acknowledged}\nRevoked: ${stats.revoked}`);
     });
     program
@@ -950,7 +1171,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('Regenerate current-state and filesystem projections from canonical events')
         .action(async (_options, command) => {
         const global = globals(command);
-        const result = await withClient(global.home, actor('system', 'cli'), (client) => client.rebuild());
+        const result = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.rebuild());
         output(io, global.json, result, `Rebuilt ${result.generated.length} file(s); removed ${result.removed.length} stale file(s).`);
     });
     program
@@ -958,7 +1179,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('Create a transactionally consistent SQLite backup')
         .action(async (destination, _options, command) => {
         const global = globals(command);
-        const path = await withClient(global.home, actor('system', 'cli'), (client) => {
+        const path = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => {
             if (!client.backup) {
                 throw new SynomemError('INVALID_INPUT', 'Filesystem backup is available only with the local backend.');
             }
@@ -973,7 +1194,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .option('--output <path>', 'write to an explicit destination instead of stdout')
         .action(async (options, command) => {
         const global = globals(command);
-        const content = await withClient(global.home, actor('system', 'cli'), (client) => client.export(options.format));
+        const content = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.export(options.format));
         if (options.output) {
             const destination = resolve(options.output);
             atomicWriteFile(destination, content, 0o600);
@@ -988,7 +1209,7 @@ export function createCli(io = defaultIo, serviceFactory = configuredServiceFact
         .description('Run safe diagnostics')
         .action(async (_options, command) => {
         const global = globals(command);
-        const result = await withClient(global.home, actor('system', 'cli'), (client) => client.doctor());
+        const result = await withClient(global.home, defaultActor(env, 'system', 'cli'), (client) => client.doctor());
         const human = result.diagnostics
             .map((item) => `${item.level.toUpperCase().padEnd(7)} ${item.code}: ${item.message}`)
             .join('\n');
@@ -999,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;