@robota-sdk/agent-command 3.0.0-beta.79 → 3.0.0-beta.81

package/src/schedule/schedule-command.ts

@@ -2,10 +2,12 @@
  * FLOW-005: `/schedule` and `/monitor` command executors — create agent-wake background tasks.
  */
 
+import { MonitorCommandRefusedError } from '@robota-sdk/agent-framework';
 import { parseScheduleSpec } from './schedule-spec-parser.js';
 
 import type { IAgentJobHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { IBackgroundTaskState } from '@robota-sdk/agent-interface-execution';
 
 const MAX_LABEL_LENGTH = 48;
 
@@ -14,13 +16,89 @@ function labelFor(prefix: string, instruction: string): string {
   return `${prefix}: ${snippet}${instruction.length > MAX_LABEL_LENGTH ? '…' : ''}`;
 }
 
+// SELFHOST-012: management subcommands over the existing scheduler. Create (FLOW-005) stays the default form —
+// a create spec always begins with `in`/`cron`, so these keywords never collide with it.
+const MANAGE_USAGE =
+  'Usage: /schedule list | pause <id> | resume <id> | edit <id> <spec>  (or a create spec: in <N><s|m|h|d> … | cron "<expr>" …)';
+
+/** One-line list view: id, status, cadence, label, and next-fire time. The `[status]` already conveys paused. */
+function formatScheduleList(schedules: IBackgroundTaskState[]): string {
+  if (schedules.length === 0) return 'No schedules.';
+  return schedules
+    .map((s) => {
+      // `listSchedules()` only ever returns scheduled-kind tasks; the kind check is what lets
+      // TypeScript narrow to the member that carries `schedule`/`nextFireAt` (#2079).
+      const cadence =
+        s.kind === 'scheduled' ? (s.schedule?.cronExpression ?? '(unknown)') : '(unknown)';
+      const when = s.kind === 'scheduled' && s.nextFireAt ? `next ${s.nextFireAt}` : '—';
+      return `- ${s.id} [${s.status}] ${cadence} — ${s.label} (${when})`;
+    })
+    .join('\n');
+}
+
+async function executeScheduleManagement(
+  host: IAgentJobHostContext,
+  action: string,
+  rest: string,
+  now: number,
+): Promise<ICommandResult | undefined> {
+  if (action === 'list') {
+    const schedules = host.listSchedules();
+    return {
+      message: formatScheduleList(schedules),
+      success: true,
+      data: { count: schedules.length },
+    };
+  }
+  if (action === 'pause' || action === 'resume') {
+    const id = rest.split(/\s+/)[0];
+    if (!id) return { message: MANAGE_USAGE, success: false };
+    if (action === 'pause') {
+      await host.pauseSchedule(id);
+      return { message: `Schedule paused: ${id}`, success: true, data: { taskId: id } };
+    }
+    await host.resumeSchedule(id);
+    return { message: `Schedule resumed: ${id}`, success: true, data: { taskId: id } };
+  }
+  if (action === 'edit') {
+    const idSpaceIdx = rest.indexOf(' ');
+    const id = idSpaceIdx === -1 ? rest : rest.slice(0, idSpaceIdx);
+    const spec = idSpaceIdx === -1 ? '' : rest.slice(idSpaceIdx + 1).trim();
+    if (!id || !spec) return { message: MANAGE_USAGE, success: false };
+    const parsed = parseScheduleSpec(spec, now);
+    if (!parsed.ok) return { message: parsed.error, success: false };
+    await host.editSchedule(id, {
+      cronExpression: parsed.spec.cronExpression,
+      agentInstruction: parsed.spec.instruction,
+      // CMD-009: `list` renders the label, so it must follow the instruction it summarizes.
+      label: labelFor('Scheduled', parsed.spec.instruction),
+    });
+    return {
+      message: `Schedule updated: ${id} (cron \`${parsed.spec.cronExpression}\`).`,
+      success: true,
+      data: { taskId: id, cronExpression: parsed.spec.cronExpression },
+    };
+  }
+  return undefined; // not a management subcommand — fall through to create
+}
+
 export async function executeScheduleCommand(
   host: IAgentJobHostContext,
   args: string,
   now: number = Date.now(),
 ): Promise<ICommandResult> {
+  const trimmed = args.trim();
+  const spaceIdx = trimmed.indexOf(' ');
+  const action = (spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx)).toLowerCase();
+  const rest = spaceIdx === -1 ? '' : trimmed.slice(spaceIdx + 1).trim();
+
+  const managed = await executeScheduleManagement(host, action, rest, now);
+  if (managed) return managed;
+
+  // Default: create (FLOW-005 form). On a parse failure also surface the management usage — a mistyped
+  // subcommand (e.g. `pasue <id>`) falls through here, and the create-only error hides list/pause/resume/edit.
   const parsed = parseScheduleSpec(args, now);
-  if (!parsed.ok) return { message: parsed.error, success: false };
+  if (!parsed.ok) return { message: `${parsed.error}\n${MANAGE_USAGE}`, success: false };
 
   const { cronExpression, instruction, recurring } = parsed.spec;
   const task = await host.spawnScheduledWake({
@@ -43,7 +121,10 @@ const MONITOR_USAGE = 'Usage: /monitor "<command>" "<pattern>" <instruction>';
 function parseMonitorArgs(
   args: string,
 ): { command: string; matchPattern: string; instruction: string } | null {
-  const match = /^["']([^"']+)["']\s+["']([^"']+)["']\s+(.+)$/.exec(args.trim());
+  // `(\S.*)` — not `(.+)`: `\s+(.+)` is ambiguous (`.` also matches spaces), so a failing input
+  // runs in O(n^2). Requiring a non-space first character pins the split point after the greedy
+  // `\s+` and makes the match linear, without changing which inputs are accepted.
+  const match = /^["']([^"']+)["']\s+["']([^"']+)["']\s+(\S.*)$/.exec(args.trim());
   if (!match) return null;
   const instruction = match[3]!.trim();
   if (instruction.length === 0) return null;
@@ -57,12 +138,20 @@ export async function executeMonitorCommand(
   const parsed = parseMonitorArgs(args);
   if (!parsed) return { message: MONITOR_USAGE, success: false };
 
-  const task = await host.spawnMonitorWake({
-    label: labelFor('Monitor', parsed.instruction),
-    command: parsed.command,
-    matchPattern: parsed.matchPattern,
-    agentInstruction: parsed.instruction,
-  });
+  let task: IBackgroundTaskState;
+  try {
+    task = await host.spawnMonitorWake({
+      label: labelFor('Monitor', parsed.instruction),
+      command: parsed.command,
+      matchPattern: parsed.matchPattern,
+      agentInstruction: parsed.instruction,
+    });
+  } catch (error) {
+    if (error instanceof MonitorCommandRefusedError) {
+      return { message: error.message, success: false };
+    }
+    throw error;
+  }
 
   return {
     message: `Monitoring \`${parsed.command}\` for /${parsed.matchPattern}/ — task ${task.id}.`,

package/src/schedule/schedule-spec-parser.ts

@@ -50,7 +50,11 @@ export function parseScheduleSpec(args: string, now: number): TScheduleParseResu
 
   if (trimmed.startsWith('cron ')) {
     const rest = trimmed.slice(5).trim();
-    const quoted = /^["']([^"']+)["']\s+(.+)$/.exec(rest);
+    // `(\S.*)` — not `(.+)`: `\s+(.+)` is ambiguous (`.` also matches spaces), so a failing
+    // input runs in O(n^2). Requiring the instruction to start with a non-space pins the split
+    // point after the greedy `\s+`, making the match linear. Behaviour is unchanged because the
+    // greedy `\s+` already consumed every leading space and the capture is trimmed below.
+    const quoted = /^["']([^"']+)["']\s+(\S.*)$/.exec(rest);
     if (!quoted) {
       return { ok: false, error: `cron form needs a quoted expression. ${USAGE}` };
     }

package/src/session/__tests__/rename-host-persistence.test.ts

@@ -0,0 +1,72 @@
+/**
+ * CMD-004 Phase 2 (TC-10) — red-first `/rename` host-side persistence proof.
+ *
+ * Pre-Stage-B, `executeRenameCommand` only RETURNS the `session-renamed` effect and the mutation
+ * lives in the TUI renderer (`useSideEffects.ts` calls `interactiveSession.setName`), so a session
+ * with NO TUI attached renames nothing — these tests were recorded FAILING against that state
+ * (evidence in the spec's Evidence Log). Stage B makes the HOST execute the rename inside the
+ * `executeCommand` pipeline (direct-on-session action), strips the applied action from the returned
+ * result (so the TUI's duplicate application cannot fire — no double rename), and broadcasts
+ * `session_renamed` so every attached surface updates its title.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { InteractiveSession } from '@robota-sdk/agent-framework';
+import type { ISessionRenamedEvent } from '@robota-sdk/agent-interface-session';
+import { createSessionCommandModule } from '../session-command-module.js';
+
+function createRuntimeSession(): Record<string, unknown> {
+  return {
+    run: vi.fn().mockResolvedValue('answer'),
+    abort: vi.fn(),
+    clearHistory: vi.fn(),
+    getHistory: vi.fn().mockReturnValue([]),
+    injectMessage: vi.fn(),
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 0,
+      usedPercentage: 0,
+      remainingPercentage: 100,
+    }),
+    getSessionId: () => 'session_rename_tc10',
+    getMessageCount: () => 0,
+    getSystemMessage: vi.fn().mockReturnValue('system'),
+    getToolSchemas: vi.fn().mockReturnValue([]),
+    getEventService: () => ({ subscribe: () => {}, unsubscribe: () => {} }),
+  };
+}
+
+describe('CMD-004 TC-10 — /rename persists host-side without any TUI handler', () => {
+  it('mutates the session name via executeCommand alone and broadcasts session_renamed', async () => {
+    const session = new InteractiveSession({
+      session: createRuntimeSession() as never,
+      commandModules: [createSessionCommandModule()],
+    });
+    const renamedEvents: ISessionRenamedEvent[] = [];
+    session.on('session_renamed', (event) => renamedEvents.push(event));
+
+    const result = await session.executeCommand('rename', 'My Renamed Session');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe('Session renamed to "My Renamed Session".');
+    // The HOST executed the mutation — no surface handler involved (the defect this TC pins).
+    expect(session.getName()).toBe('My Renamed Session');
+    // Broadcast so every attached surface (incl. co-driving ones) updates its title.
+    expect(renamedEvents).toEqual([{ name: 'My Renamed Session' }]);
+    // The applied host action is CONSUMED from the returned result — no surface can double-apply it.
+    expect(result?.hostActions).toBeUndefined();
+  });
+
+  it('applies the rename exactly once (single-execution guard)', async () => {
+    const session = new InteractiveSession({
+      session: createRuntimeSession() as never,
+      commandModules: [createSessionCommandModule()],
+    });
+    const setNameSpy = vi.spyOn(session, 'setName');
+
+    await session.executeCommand('rename', 'once');
+
+    expect(setNameSpy).toHaveBeenCalledTimes(1);
+    expect(setNameSpy).toHaveBeenCalledWith('once');
+  });
+});

package/src/session/__tests__/session-command-module.test.ts

@@ -1,10 +1,21 @@
 import { describe, expect, it, vi } from 'vitest';
-import type { ICommandHostContext, ICommandSessionRuntime } from '@robota-sdk/agent-framework';
+import { calculateModelCost } from '@robota-sdk/agent-core';
+import type {
+  ICommandCostBudget,
+  ICommandCostBudgetAdapter,
+  ICommandHostContext,
+  ICommandSessionRuntime,
+  ISessionUsageRecord,
+} from '@robota-sdk/agent-framework';
 import { InteractiveSession, SystemCommandExecutor } from '@robota-sdk/agent-framework';
 import { createSessionCommandModule } from '../session-command-module.js';
+import {
+  createTestCommandHost,
+  createTestSessionRuntime,
+} from '@robota-sdk/agent-framework/testing';
 
-function createRuntime(): ICommandSessionRuntime {
-  return {
+function createRuntime() {
+  return createTestSessionRuntime({
     clearHistory: vi.fn(),
     compact: async () => undefined,
     getContextState: () => ({
@@ -21,31 +32,33 @@ function createRuntime(): ICommandSessionRuntime {
     getAutoCompactThreshold: () => false,
     getFullHistory: () => [],
     getHistory: () => [],
-  };
+  });
 }
 
-function createCommandContext(): ICommandHostContext {
+function createCommandContext() {
   const runtime = createRuntime();
-  return {
-    getSession: () => runtime,
-    getContextState: () => runtime.getContextState(),
-    getAutoCompactThreshold: () => 0.835,
-    compactContext: async () => undefined,
-    getCwd: () => '/workspace',
-    listEditCheckpoints: () => [],
-    restoreEditCheckpoint: async () => {
-      throw new Error('not used');
-    },
-    rollbackEditCheckpoint: async () => {
-      throw new Error('not used');
+  return createTestCommandHost({
+    overrides: {
+      getSession: () => runtime,
+      getContextState: () => runtime.getContextState(),
+      getAutoCompactThreshold: () => 0.835,
+      compactContext: async () => undefined,
+      getCwd: () => '/workspace',
+      listEditCheckpoints: () => [],
+      restoreEditCheckpoint: async () => {
+        throw new Error('not used');
+      },
+      rollbackEditCheckpoint: async () => {
+        throw new Error('not used');
+      },
+      getUsedMemoryReferences: () => [],
+      recordMemoryEvent: () => undefined,
+      listBackgroundTasks: () => [],
+      readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
+      cancelBackgroundTask: async () => undefined,
+      closeBackgroundTask: async () => undefined,
     },
-    getUsedMemoryReferences: () => [],
-    recordMemoryEvent: () => undefined,
-    listBackgroundTasks: () => [],
-    readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
-    cancelBackgroundTask: async () => undefined,
-    closeBackgroundTask: async () => undefined,
-  };
+  });
 }
 
 describe('createSessionCommandModule', () => {
@@ -81,6 +94,7 @@ describe('createSessionCommandModule', () => {
     expect(module.commandSources?.[0]?.getCommands().map((item) => item.name)).toEqual([
       'clear',
       'rename',
+      'cd',
       'resume',
       'cost',
       'validate-session',
@@ -88,6 +102,7 @@ describe('createSessionCommandModule', () => {
     expect(module.systemCommands?.map((item) => item.name)).toEqual([
       'clear',
       'rename',
+      'cd',
       'resume',
       'cost',
       'validate-session',
@@ -108,6 +123,8 @@ describe('createSessionCommandModule', () => {
         modelInvocable: false,
       }),
     );
+    expect(entry?.argumentHint).toBe('<name>');
+    expect(command?.argumentHint).toBe(entry?.argumentHint);
   });
 
   it('provides resume metadata and user-only executable command from the same module owner', () => {
@@ -133,7 +150,7 @@ describe('createSessionCommandModule', () => {
     );
   });
 
-  it('provides cost metadata and user-only executable command from the same module owner', () => {
+  it('provides cost metadata and a model-invocable report with a user-only budget from the same module owner', () => {
     const module = createSessionCommandModule();
     const command = module.systemCommands?.find((item) => item.name === 'cost');
     const entry = module.commandSources?.[0]?.getCommands().find((item) => item.name === 'cost');
@@ -143,7 +160,7 @@ describe('createSessionCommandModule', () => {
         name: 'cost',
         description: expect.stringContaining('token usage'),
         source: 'session',
-        modelInvocable: false,
+        modelInvocable: true,
       }),
     );
     expect(command).toEqual(
@@ -151,9 +168,15 @@ describe('createSessionCommandModule', () => {
         name: 'cost',
         lifecycle: 'inline',
         userInvocable: true,
-        modelInvocable: false,
+        modelInvocable: true,
       }),
     );
+    expect(entry?.argumentHint).toBe('[budget [<amount>|clear]]');
+    expect(command?.argumentHint).toBe(entry?.argumentHint);
+    expect(entry?.subcommands).toEqual([
+      expect.objectContaining({ name: 'budget', modelInvocable: false }),
+    ]);
+    expect(command?.subcommands).toEqual(entry?.subcommands);
   });
 
   it('provides validate-session metadata and user-only executable command from the same module owner', () => {
@@ -197,7 +220,6 @@ describe('createSessionCommandModule', () => {
     expect(result).toEqual({
       success: true,
       message: 'Conversation cleared.',
-      effects: [{ type: 'conversation-history-cleared' }],
     });
   });
 
@@ -217,7 +239,7 @@ describe('createSessionCommandModule', () => {
     const result = await executor.execute('clear', context, '');
 
     expect(clearConversationHistory).toHaveBeenCalledTimes(1);
-    expect(result?.effects).toEqual([{ type: 'conversation-history-cleared' }]);
+    expect(result?.success).toBe(true);
   });
 
   it('CMD-004: cancels the clear when the user declines', async () => {
@@ -239,11 +261,18 @@ describe('createSessionCommandModule', () => {
     expect(result?.message).toBe('Clear cancelled.');
   });
 
-  it('falls back to runtime clearHistory when the host has not implemented the richer API', async () => {
+  it('ARCH-029 TC-09: /clear takes the host path only — it never reaches past it into the runtime', async () => {
+    // The deleted fallback called `getSession().clearHistory()` when the host member was absent.
+    // Those are not the same operation: the host's clear also broadcasts `history_cleared` to
+    // every attached surface (CMD-004 Stage E), so the fallback cleared ONE surface and left the
+    // others still showing the transcript. With the member required there is one path, and this
+    // pins that the runtime is not reached behind the host's back.
     const runtime = createRuntime();
+    const clearConversationHistory = vi.fn();
     const context = {
       ...createCommandContext(),
       getSession: () => runtime,
+      clearConversationHistory,
     };
     const executor = new SystemCommandExecutor([
       ...(createSessionCommandModule().systemCommands ?? []),
@@ -251,7 +280,8 @@ describe('createSessionCommandModule', () => {
 
     const result = await executor.execute('clear', context, '');
 
-    expect(runtime.clearHistory).toHaveBeenCalledTimes(1);
+    expect(clearConversationHistory).toHaveBeenCalledTimes(1);
+    expect(runtime.clearHistory).not.toHaveBeenCalled();
     expect(result?.success).toBe(true);
   });
 
@@ -266,6 +296,8 @@ describe('createSessionCommandModule', () => {
       injectMessage: vi.fn(),
       getSystemMessage: vi.fn().mockReturnValue('system'),
       getToolSchemas: vi.fn().mockReturnValue([]),
+      // SELFHOST-004 P6: the span collector subscribes to the session bus each turn.
+      getEventService: () => ({ subscribe: () => {}, unsubscribe: () => {} }),
     };
     const session = new InteractiveSession({
       session: runtime as never,
@@ -279,7 +311,6 @@ describe('createSessionCommandModule', () => {
     expect(result).toEqual({
       success: true,
       message: 'Conversation cleared.',
-      effects: [{ type: 'conversation-history-cleared' }],
     });
     expect(clearHistory).toHaveBeenCalledTimes(1);
     expect(session.getFullHistory()).toEqual([]);
@@ -296,7 +327,7 @@ describe('createSessionCommandModule', () => {
       success: true,
       message: 'Session renamed to "my-session".',
       data: { name: 'my-session' },
-      effects: [{ type: 'session-renamed', name: 'my-session' }],
+      hostActions: [{ type: 'session-rename', name: 'my-session' }],
     });
   });
 
@@ -324,7 +355,7 @@ describe('createSessionCommandModule', () => {
       success: true,
       message: 'Opening session picker...',
       data: { triggerResumePicker: true },
-      effects: [{ type: 'session-picker-requested' }],
+      uiIntents: [{ type: 'show-session-picker' }],
     });
   });
 
@@ -341,18 +372,27 @@ describe('createSessionCommandModule', () => {
     expect(result?.message).toContain('not yet available');
   });
 
-  it('shows token counts and estimated cost when session has usage data', async () => {
-    const runtime = {
-      ...createRuntime(),
-      getSessionTokenUsage: () => ({ inputTokens: 45_000, outputTokens: 12_000 }),
-      getModelId: () => 'claude-sonnet-4-5',
-    };
-    const context = { ...createCommandContext(), getSession: () => runtime };
+  function costContext(records: readonly ISessionUsageRecord[], modelId = 'claude-sonnet-4-5') {
+    const runtime = { ...createRuntime(), getModelId: () => modelId };
+    return { ...createCommandContext(), getSession: () => runtime, getSessionUsage: () => records };
+  }
+
+  async function cost(records: readonly ISessionUsageRecord[], modelId?: string) {
     const executor = new SystemCommandExecutor([
       ...(createSessionCommandModule().systemCommands ?? []),
     ]);
+    return executor.execute('cost', costContext(records, modelId), '');
+  }
+
+  const advisorRecord: ISessionUsageRecord = {
+    promptTokens: 5_000,
+    completionTokens: 2_000,
+    costUsd: 1.5,
+    source: { scope: 'tool', id: 'advisor:big-model', label: 'Advisor (big-model)' },
+  };
 
-    const result = await executor.execute('cost', context, '');
+  it('shows token counts and estimated cost when session has usage data', async () => {
+    const result = await cost([{ promptTokens: 45_000, completionTokens: 12_000 }]);
 
     expect(result?.success).toBe(true);
     expect(result?.message).toContain('45,000');
@@ -363,16 +403,127 @@ describe('createSessionCommandModule', () => {
     expect((result?.data as Record<string, unknown>)?.estimatedCostUsd).toBeDefined();
   });
 
-  it('sets a monthly budget via /cost budget subcommand', async () => {
+  it('totals main and advisor usage, pricing the advisor on its own model', async () => {
+    const own = calculateModelCost('claude-sonnet-4-5', 40_000, 10_000)!;
+    const result = await cost([{ promptTokens: 40_000, completionTokens: 10_000 }, advisorRecord]);
+    const data = result?.data as Record<string, unknown>;
+
+    expect(data.inputTokens).toBe(45_000);
+    expect(data.outputTokens).toBe(12_000);
+    expect(data.estimatedCostUsd).toBeCloseTo(own + 1.5, 10);
+    expect(result?.message).toContain('mixed: claude-sonnet-4-5, Advisor (big-model)');
+  });
+
+  it('keeps the advisor price when the main model has none, and says the total is partial', async () => {
+    const result = await cost(
+      [{ promptTokens: 40_000, completionTokens: 10_000 }, advisorRecord],
+      'unpriced-model',
+    );
+    const data = result?.data as Record<string, unknown>;
+    expect(data.estimatedCostUsd).toBe(1.5);
+    expect(data.costPartial).toBe(true);
+    expect(result?.message).toContain('some usage could not be priced');
+  });
+
+  it('does not price an unpriced advisor model at the main model rate', async () => {
+    const own = calculateModelCost('claude-sonnet-4-5', 40_000, 10_000)!;
+    const { costUsd: _price, ...unpricedAdvisor } = advisorRecord;
+    const result = await cost([
+      { promptTokens: 40_000, completionTokens: 10_000 },
+      unpricedAdvisor,
+    ]);
+    const data = result?.data as Record<string, unknown>;
+    expect(data.estimatedCostUsd).toBeCloseTo(own, 10);
+    expect(data.costPartial).toBe(true);
+  });
+
+  /**
+   * CMD-007 (issue #2058): the command talks to an injected `ICommandCostBudgetAdapter` and never to
+   * the filesystem — so the tests hold the budget in memory, with no casts and no temp directory.
+   * The file adapter's own policy (atomic write, symlink refusal) is tested where it lives, in agent-cli.
+   */
+  function memoryBudgetAdapter(initial?: ICommandCostBudget): ICommandCostBudgetAdapter & {
+    writes: string[];
+  } {
+    let stored = initial;
+    const adapter = {
+      writes: [] as string[],
+      read: () => stored,
+      write: (budget: ICommandCostBudget) => {
+        adapter.writes.push(`write:${budget.monthly}`);
+        stored = budget;
+      },
+      clear: () => {
+        adapter.writes.push('clear');
+        stored = undefined;
+      },
+    };
+    return adapter;
+  }
+
+  function budgetContext(adapter: ICommandCostBudgetAdapter | undefined) {
+    return {
+      ...createCommandContext(),
+      getCommandHostAdapters: () => (adapter ? { costBudget: adapter } : {}),
+    };
+  }
+
+  it('sets a monthly budget via /cost budget subcommand through the injected adapter', async () => {
     const executor = new SystemCommandExecutor([
       ...(createSessionCommandModule().systemCommands ?? []),
     ]);
-    const context = { ...createCommandContext(), getCwd: () => '/tmp/robota-test-budget' };
+    const adapter = memoryBudgetAdapter();
 
-    const result = await executor.execute('cost', context, 'budget 5.00');
+    const result = await executor.execute('cost', budgetContext(adapter), 'budget 5.00');
 
     expect(result?.success).toBe(true);
     expect(result?.message).toContain('$5.00');
+    expect(adapter.read()).toEqual({ monthly: 5 });
+  });
+
+  it('reads back a persisted budget and clears it through the adapter (set → restart → read)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createSessionCommandModule().systemCommands ?? []),
+    ]);
+    // "restart": a fresh context over the same stored document
+    const adapter = memoryBudgetAdapter({ monthly: 5 });
+    const shown = await executor.execute('cost', budgetContext(adapter), 'budget');
+    expect(shown?.message).toContain('Monthly budget: $5.00');
+
+    const cleared = await executor.execute('cost', budgetContext(adapter), 'budget clear');
+    expect(cleared?.success).toBe(true);
+    expect(adapter.writes).toEqual(['clear']);
+    const after = await executor.execute('cost', budgetContext(adapter), 'budget');
+    expect(after?.message).toContain('No budget set');
+  });
+
+  it("surfaces the adapter's typed write failure instead of a filesystem error", async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createSessionCommandModule().systemCommands ?? []),
+    ]);
+    const refusing: ICommandCostBudgetAdapter = {
+      read: () => undefined,
+      write: () => {
+        throw new Error('Refused: budget.json is a symbolic link');
+      },
+      clear: () => {
+        throw new Error('Refused: budget.json is a symbolic link');
+      },
+    };
+    for (const args of ['budget clear', 'budget 5.00']) {
+      const result = await executor.execute('cost', budgetContext(refusing), args);
+      expect(result?.success).toBe(false);
+      expect(result?.message).toContain('symbolic link');
+    }
+  });
+
+  it('says budget persistence is unavailable when the host composed no adapter', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createSessionCommandModule().systemCommands ?? []),
+    ]);
+    const result = await executor.execute('cost', budgetContext(undefined), 'budget 5.00');
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain('not available');
   });
 
   it('rejects invalid budget amount', async () => {
@@ -421,3 +572,17 @@ describe('createSessionCommandModule', () => {
     });
   });
 });
+
+describe('/cd (issue #3081)', () => {
+  it('requests the host-executed move with the path as typed, and is user-only', async () => {
+    const module = createSessionCommandModule();
+    const entry = module.commandSources?.[0]?.getCommands().find((item) => item.name === 'cd');
+    const command = module.systemCommands?.find((item) => item.name === 'cd');
+    expect(entry?.modelInvocable).toBe(false);
+    expect(entry?.userInvocable).toBe(true);
+    const result = await command!.execute({} as never, ' ../api ');
+    expect(result.hostActions).toEqual([{ type: 'workspace-move', path: '../api' }]);
+    const usage = await command!.execute({} as never, '   ');
+    expect(usage.success).toBe(false);
+  });
+});