@robota-sdk/agent-command 3.0.0-beta.100

package/src/peers/peers-command.ts

@@ -0,0 +1,220 @@
+import type { ICommandHostAdapterAccess, ICommandHostAdapters } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+/** One row as the port hands it over. Derived, so it cannot drift from the adapter it reads. */
+type TPeerSummary = ReturnType<NonNullable<ICommandHostAdapters['localPeers']>['list']>[number];
+
+/**
+ * `/peers` (PEER-004, #1863) — which other live sessions this one can address.
+ *
+ * Discovery landed as a leaf (a guarded rendezvous directory, an entry per live session, liveness
+ * settled by pid AND process start time) and nothing called it: measured on this tree, no file
+ * outside the module and its tests referenced `announcePeer` or `openLocalPeerRendezvous`. This
+ * command is the surface that makes it observable, which is also what makes it falsifiable — a
+ * discovery layer nobody can look at is one nobody can catch being wrong.
+ *
+ * The command reads an injected adapter and touches no filesystem, for the same reason it never
+ * constructs a transport: the guarded directory, its permissions and the liveness rule are
+ * composition-root concerns and must have one owner.
+ */
+
+/** `dead` is not shown. An entry whose process is gone is debris, not a peer. */
+function addressable(peer: TPeerSummary): boolean {
+  return peer.liveness !== 'dead';
+}
+
+function describe(peer: TPeerSummary, ownSessionId: string): string {
+  const self = peer.sessionId === ownSessionId ? '  (this session)' : '';
+  // `unknown` is printed, never rounded to `alive`. A host that cannot read process start times
+  // answers `unknown` for every peer, and a reader who is not told that would take a stale entry for
+  // a live session.
+  const liveness = peer.liveness === 'unknown' ? '  liveness unknown' : '';
+  const status = peer.status === 'needs-input' ? 'needs input' : (peer.status ?? 'unknown');
+  return `  ${peer.sessionId}${peer.name ? `  ${peer.name}` : ''}  status ${status}${self ? '' : workspace(peer)}${liveness}${self}`;
+}
+
+type TDeviceSummary = ReturnType<
+  NonNullable<NonNullable<ICommandHostAdapters['localPeers']>['listDevices']>
+>[number];
+
+/** A linked device: its full id, since that is what `send` takes, and where it runs. */
+function describeDevice(device: TDeviceSummary): string {
+  const where = device.locality === 'same-host' ? 'on this machine' : 'on another machine';
+  return `  ${device.deviceId}${device.name ? `  ${device.name}` : ''}  ${where}`;
+}
+
+/** The relation this session verified. A claim it could not confirm is named as such, not shown. */
+function workspace(peer: TPeerSummary): string {
+  if (peer.workspaceClaim === 'mismatched') return '  workspace claim mismatched, not believed';
+  switch (peer.workspaceRelation) {
+    case undefined:
+      return '';
+    case 'unknown':
+      return '  workspace unknown';
+    default:
+      return `  ${peer.workspaceRelation.replace('-', ' ')}`;
+  }
+}
+
+/**
+ * PEER-006 — `/peers send <session-id> <text>`.
+ *
+ * Split on the FIRST run of whitespace only: everything after the session id is the message, spaces
+ * and all. Splitting on every space would silently truncate any message with more than one word,
+ * which is nearly all of them.
+ */
+function parseSend(args: string): { target: string; text: string } | undefined {
+  const trimmed = args.trim();
+  const at = trimmed.search(/\s/);
+  if (at === -1) return undefined;
+  const text = trimmed.slice(at).trim();
+  if (text === '') return undefined;
+  return { target: trimmed.slice(0, at), text };
+}
+
+/** A state the sender can act on, rendered as a sentence rather than a status word. */
+function describeSend(result: { state: string; reason?: string }, target: string): ICommandResult {
+  const reason = result.reason !== undefined ? ` ${result.reason}` : '';
+  switch (result.state) {
+    case 'acknowledged':
+    case 'delivered':
+      return { message: `Delivered to ${target}.`, success: true };
+    case 'pending':
+      // NOT reported as delivered. The peer has it and has not run it — usually because a turn is
+      // already running there — and telling the operator it landed would hide a wait they can see.
+      return {
+        message: `${target} has the message; it is waiting behind work already running there.`,
+        success: true,
+      };
+    case 'duplicate':
+      return { message: `${target} had already seen that message.`, success: true };
+    default:
+      return { message: `Not delivered to ${target}.${reason}`, success: false };
+  }
+}
+
+async function executeSend(
+  adapter: NonNullable<ICommandHostAdapters['localPeers']>,
+  args: string,
+): Promise<ICommandResult> {
+  if (adapter.send === undefined) {
+    return {
+      message: 'This environment can discover other sessions but cannot address them.',
+      success: false,
+    };
+  }
+  const parsed = parseSend(args);
+  if (parsed === undefined) {
+    return {
+      message: 'Usage: /peers send <session-id> <message>. Run /peers for the session ids.',
+      success: false,
+    };
+  }
+  return describeSend(await adapter.send(parsed.target, parsed.text), parsed.target);
+}
+
+/**
+ * `/peers send-file <session-id> <path>` — the operator sends a copy of a file.
+ *
+ * The operator typed the path, so any regular file they can read may go, including one outside the
+ * workspace or one that looks like it holds secrets: this is the one way to send those. Everything
+ * after the session id is the path, spaces and all.
+ */
+async function executeSendFile(
+  adapter: NonNullable<ICommandHostAdapters['localPeers']>,
+  args: string,
+  cwd: string,
+): Promise<ICommandResult> {
+  if (adapter.prepareFile === undefined) {
+    return { message: 'This environment cannot send files to other sessions.', success: false };
+  }
+  const parsed = parseSend(args);
+  if (parsed === undefined) {
+    return {
+      message: 'Usage: /peers send-file <session-id> <path>. Run /peers for the session ids.',
+      success: false,
+    };
+  }
+  const prepared = await adapter.prepareFile(parsed.target, parsed.text, {
+    origin: 'operator',
+    cwd,
+  });
+  if (!prepared.ok) return { message: `Not sent: ${prepared.reason}`, success: false };
+  const { file } = prepared;
+  const result = await file.send();
+  if (result.state === 'delivered' || result.state === 'acknowledged') {
+    return {
+      message: `Sent ${file.path} to ${parsed.target}: ${file.size} bytes, sha256 ${file.sha256}.`,
+      success: true,
+    };
+  }
+  const reason = result.reason !== undefined ? ` ${result.reason}` : '';
+  return { message: `${file.path} was not sent to ${parsed.target}.${reason}`, success: false };
+}
+
+export async function executePeersCommand(
+  context: ICommandHostAdapterAccess & { getCwd?(): string },
+  args = '',
+): Promise<ICommandResult> {
+  const adapter = context.getCommandHostAdapters?.().localPeers;
+  if (!adapter) {
+    return { message: 'Local peer discovery is not available in this environment.', success: true };
+  }
+
+  // `send` must be a WHOLE word: `startsWith('send')` would also claim a session id beginning with
+  // those four letters, and a uuid that happens to start `send…` is not a subcommand.
+  const trimmed = args.trim();
+  const sendFileVerb = /^send-file(?=\s|$)/.exec(trimmed);
+  if (sendFileVerb !== null) {
+    return executeSendFile(
+      adapter,
+      trimmed.slice(sendFileVerb[0].length),
+      context.getCwd?.() ?? '',
+    );
+  }
+  const sendVerb = /^send(?=\s|$)/.exec(trimmed);
+  if (sendVerb !== null) return executeSend(adapter, trimmed.slice(sendVerb[0].length));
+
+  const devices = adapter.listDevices?.() ?? [];
+  const discoveryOff = adapter.localDiscoveryOff;
+  if (discoveryOff !== undefined) {
+    const off = `Sessions on this host are not listed: local peer discovery is off for this session (${discoveryOff}).`;
+    return {
+      message:
+        devices.length === 0
+          ? `${off}\nNo device is linked right now.`
+          : `Linked devices:\n${devices.map(describeDevice).join('\n')}\n\n${off}` +
+            `\n\nSend to one: /peers send <device-id> <message>` +
+            `\nSend a file: /peers send-file <device-id> <path>`,
+      success: true,
+    };
+  }
+
+  const own = adapter.ownSessionId();
+  // The workspace-judged listing when the host has one; it reads git, so only this view asks for it.
+  const peers = (
+    adapter.listWithWorkspace !== undefined ? await adapter.listWithWorkspace() : adapter.list()
+  ).filter(addressable);
+  const others = peers.filter((peer) => peer.sessionId !== own);
+
+  if (others.length === 0 && devices.length === 0) {
+    return {
+      message:
+        'No other live session is announced. Start a second session on this host, as this user, ' +
+        'and it appears here.',
+      success: true,
+    };
+  }
+
+  const sections = [`Live sessions:\n${peers.map((peer) => describe(peer, own)).join('\n')}`];
+  if (devices.length > 0) {
+    sections.push(`Linked devices:\n${devices.map(describeDevice).join('\n')}`);
+  }
+  const target = devices.length > 0 ? '<session-or-device-id>' : '<session-id>';
+  return {
+    message:
+      `${sections.join('\n\n')}\n\nSend to one: /peers send ${target} <message>` +
+      `\nSend a file: /peers send-file ${target} <path>`,
+    success: true,
+  };
+}

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

@@ -0,0 +1,276 @@
+import { describe, expect, it, vi } from 'vitest';
+import type {
+  ICommandHostContext,
+  IEditCheckpointRestoreResult,
+  IPermissionRuleLayer,
+  IPermissionsCommandState,
+} from '@robota-sdk/agent-framework';
+import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
+import { createPermissionsCommandModule } from '../permissions-command-module.js';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+type TPermissionModeName = 'plan' | 'default' | 'acceptEdits' | 'bypassPermissions';
+type TSetPermissionModeSpy = ReturnType<typeof vi.fn<(nextMode: TPermissionModeName) => void>>;
+
+function createCheckpointResult(): IEditCheckpointRestoreResult {
+  return {
+    target: {
+      id: 'checkpoint_1',
+      sessionId: 'session_1',
+      sequence: 1,
+      prompt: 'edit files',
+      createdAt: '2026-05-03T00:00:00.000Z',
+      fileCount: 1,
+    },
+    restoredCheckpointCount: 0,
+    restoredFileCount: 0,
+    removedCheckpointCount: 0,
+  };
+}
+
+function createCommandHostContext(options?: {
+  mode?: TPermissionModeName;
+  sessionAllowed?: readonly string[];
+  rules?: { allow: string[]; deny: string[]; ask: string[] };
+  denials?: IPermissionsCommandState['recentDenials'];
+  layers?: readonly IPermissionRuleLayer[];
+  retryDenial?: (index: number) => IPermissionsCommandState['recentDenials'][number] | undefined;
+}): ReturnType<typeof createTestCommandHost> & { setPermissionMode: TSetPermissionModeSpy } {
+  let mode = options?.mode ?? 'default';
+  const setPermissionMode = vi.fn((nextMode: TPermissionModeName) => {
+    mode = nextMode;
+  });
+
+  return {
+    ...createTestCommandHost({
+      overrides: {
+        getSession: () => {
+          throw new Error('permissions command should use the permission mode adapter');
+        },
+        getCommandHostAdapters: () => ({
+          permissionMode: {
+            getPermissionMode: () => mode,
+            setPermissionMode,
+            listSessionAllowedTools: () => options?.sessionAllowed ?? [],
+            getPermissionRules: () => options?.rules ?? { allow: [], deny: [], ask: [] },
+            listRecentDenials: () => options?.denials ?? [],
+            retryDenial: (index: number) => options?.retryDenial?.(index),
+          },
+          ...(options?.layers !== undefined
+            ? { permissionRules: { readLayers: () => options.layers! } }
+            : {}),
+        }),
+        getContextState: () => ({
+          usedTokens: 0,
+          maxTokens: 1,
+          usedPercentage: 0,
+          remainingPercentage: 100,
+        }),
+        getAutoCompactThreshold: () => 0.835,
+        compactContext: async () => undefined,
+        getCwd: () => '/workspace',
+        listEditCheckpoints: () => [],
+        restoreEditCheckpoint: async () => createCheckpointResult(),
+        rollbackEditCheckpoint: async () => createCheckpointResult(),
+        getUsedMemoryReferences: () => [],
+        recordMemoryEvent: () => undefined,
+        listBackgroundTasks: () => [],
+        readBackgroundTaskLog: async () => ({ taskId: 'task_1', lines: [] }),
+        cancelBackgroundTask: async () => undefined,
+        closeBackgroundTask: async () => undefined,
+      },
+    }),
+    setPermissionMode,
+  };
+}
+
+describe('createPermissionsCommandModule', () => {
+  it('provides permissions metadata and user-only executable command from one module owner', () => {
+    const module = createPermissionsCommandModule();
+    const command = module.systemCommands?.[0];
+    const entry = module.commandSources?.[0]?.getCommands()[0];
+
+    expect(module.name).toBe('agent-command-permissions');
+    expect(entry).toEqual(
+      expect.objectContaining({
+        name: 'permissions',
+        description: 'Show/change permission mode and permission rules',
+        argumentHint: 'plan | default | acceptEdits | bypassPermissions | auto',
+        source: 'permissions',
+        modelInvocable: false,
+      }),
+    );
+    expect(entry?.subcommands?.map((subcommand) => subcommand.name)).toEqual([
+      'plan',
+      'default',
+      'acceptEdits',
+      'bypassPermissions',
+      'auto',
+    ]);
+    expect(command).toEqual(
+      expect.objectContaining({
+        name: 'permissions',
+        description: 'Show/change permission mode and permission rules',
+        argumentHint: 'plan | default | acceptEdits | bypassPermissions | auto',
+        lifecycle: 'inline',
+        modelInvocable: false,
+      }),
+    );
+    expect(command?.subcommands).toEqual(entry?.subcommands);
+  });
+
+  it('reports no session-approved tools when the command allowlist is empty', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute('permissions', createCommandHostContext(), '');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe(
+      'Permission mode: default\n\nRules: none configured.\n\nNo session-approved tools.\n\nRecent denials: none.',
+    );
+    expect(result?.data).toEqual({ mode: 'default', sessionAllowed: [] });
+  });
+
+  it('reports session-approved tools when present', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute(
+      'permissions',
+      createCommandHostContext({ mode: 'acceptEdits', sessionAllowed: ['Bash', 'Read'] }),
+      '',
+    );
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('Approved this session ("allow always"): Bash, Read');
+    expect(result?.data).toEqual({ mode: 'acceptEdits', sessionAllowed: ['Bash', 'Read'] });
+  });
+
+  it('lists the effective rules under the settings file each comes from, and recent denials (issue #3082)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+    const at = new Date(2026, 8, 25, 9, 5, 7).getTime();
+    const result = await executor.execute(
+      'permissions',
+      createCommandHostContext({
+        rules: { allow: ['Read', 'mcp__docs__*'], deny: ['Bash(rm *)'], ask: ['Bash(git push*)'] },
+        layers: [
+          {
+            source: '~/.fixture-state/settings.json',
+            scope: 'user',
+            allow: ['Read'],
+            deny: ['Bash(rm *)'],
+            ask: [],
+          },
+          {
+            source: '.fixture-state/settings.json',
+            scope: 'project',
+            allow: ['Read', 'Stale'],
+            deny: [],
+            ask: ['Bash(git push*)'],
+          },
+        ],
+        denials: [{ toolName: 'Bash', argument: 'rm -rf ~', reason: 'policy', at }],
+      }),
+      '',
+    );
+    expect(result?.message).toContain(
+      [
+        'Rules (checked deny, then ask, then allow):',
+        '  ~/.fixture-state/settings.json [user]',
+        '    deny: Bash(rm *)',
+        '    allow: Read',
+        '  .fixture-state/settings.json [project]',
+        '    ask: Bash(git push*)',
+        '    allow: Read',
+        '  this session (CLI flags, preset, commands)',
+        '    allow: mcp__docs__*',
+      ].join('\n'),
+    );
+    // A layer's rule the session does not enforce is not listed as if it were.
+    expect(result?.message).not.toContain('Stale');
+    expect(result?.message).toContain(
+      'Recent denials (most recent first):\n  1. 09:05:07  Bash(rm -rf ~) — denied by a rule or the mode',
+    );
+  });
+
+  it('updates valid permission modes through the SDK command adapter', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+    const context = createCommandHostContext();
+
+    const result = await executor.execute('permissions', context, 'plan');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toMatch(/^Permission mode set to: plan\nPermission mode: plan\n/);
+    expect(result?.data).toEqual({ mode: 'plan', sessionAllowed: [] });
+    expect(context.setPermissionMode).toHaveBeenCalledWith('plan');
+  });
+
+  it('rejects invalid permission modes without writing state', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+    const context = createCommandHostContext();
+
+    const result = await executor.execute('permissions', context, 'invalid');
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toBe(
+      'Invalid mode. Valid: plan | default | acceptEdits | bypassPermissions | auto',
+    );
+    expect(context.setPermissionMode).not.toHaveBeenCalled();
+  });
+
+  it('reports a mode the session refuses instead of throwing', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+    const context = createCommandHostContext();
+    context.setPermissionMode.mockImplementation(() => {
+      throw new Error('Auto mode is unavailable: this session has no permission classifier.');
+    });
+
+    const result = await executor.execute('permissions', context, 'auto');
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toBe(
+      'Auto mode is unavailable: this session has no permission classifier.',
+    );
+  });
+
+  it('retries a classifier denial by the number /permissions shows (issue #3082)', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createPermissionsCommandModule().systemCommands ?? []),
+    ]);
+    const denial = {
+      toolName: 'Bash',
+      argument: 'npm publish',
+      reason: 'classifier' as const,
+      detail: 'publishes a package',
+      at: new Date(2026, 8, 25, 13, 4, 5).getTime(),
+    };
+    const retryDenial = vi.fn((index: number) => (index === 0 ? denial : undefined));
+    const context = createCommandHostContext({ denials: [denial], retryDenial });
+
+    const listed = await executor.execute('permissions', context, '');
+    expect(listed?.message).toContain(
+      '1. 13:04:05  Bash(npm publish) — blocked by the auto-mode classifier: publishes a package',
+    );
+    expect(listed?.message).toContain('/permissions retry <n>');
+
+    const retried = await executor.execute('permissions', context, 'retry 1');
+    expect(retried?.success).toBe(true);
+    expect(retried?.message).toContain('Bash(npm publish) will run once');
+    expect(retryDenial).toHaveBeenCalledWith(0);
+
+    const missing = await executor.execute('permissions', context, 'retry 2');
+    expect(missing?.success).toBe(false);
+    expect(missing?.message).toMatch(/^Usage: \/permissions retry <n>/);
+  });
+});

package/src/permissions/index.ts

@@ -0,0 +1,6 @@
+export {
+  createPermissionsCommandEntry,
+  createPermissionsCommandModule,
+  PermissionsCommandSource,
+} from './permissions-command-module.js';
+export { executePermissionsCommand } from './permissions-command.js';

package/src/permissions/permissions-command-module.ts

@@ -0,0 +1,55 @@
+import {
+  buildPermissionModeSubcommands,
+  PERMISSION_MODE_ARGUMENT_HINT,
+  PERMISSIONS_COMMAND_DESCRIPTION,
+} from '@robota-sdk/agent-framework';
+
+import { executePermissionsCommand } from './permissions-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createPermissionsCommandEntry(): ICommand {
+  return {
+    name: 'permissions',
+    displayName: 'Permissions',
+    description: PERMISSIONS_COMMAND_DESCRIPTION,
+    source: 'permissions',
+    argumentHint: PERMISSION_MODE_ARGUMENT_HINT,
+    subcommands: buildPermissionModeSubcommands('permissions'),
+    // User-only: edits permission rules; permission widening is the user's.
+    modelInvocable: false,
+  };
+}
+
+function createPermissionsSystemCommand(): ISystemCommand {
+  const entry = createPermissionsCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: true,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    subcommands: entry.subcommands,
+    lifecycle: 'inline',
+    execute: executePermissionsCommand,
+  };
+}
+
+export class PermissionsCommandSource implements ICommandSource {
+  readonly name = 'permissions';
+
+  getCommands(): ICommand[] {
+    return [createPermissionsCommandEntry()];
+  }
+}
+
+export function createPermissionsCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-permissions',
+    commandSources: [new PermissionsCommandSource()],
+    systemCommands: [createPermissionsSystemCommand()],
+  };
+}

package/src/permissions/permissions-command.ts

@@ -0,0 +1,89 @@
+import {
+  formatCommandPermissionsMessage,
+  formatInvalidPermissionModeMessage,
+  isPermissionMode,
+  parsePermissionModeArgument,
+  readCommandPermissionsState,
+  retryCommandPermissionDenial,
+  writeCommandPermissionMode,
+} from '@robota-sdk/agent-framework';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostSessionAccess,
+} from '@robota-sdk/agent-framework';
+import type { TPermissionMode } from '@robota-sdk/agent-core';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+/** Switch the mode, or the refusal to show when the session will not enter it. */
+export function tryWritePermissionMode(
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess,
+  mode: TPermissionMode,
+): ICommandResult | undefined {
+  try {
+    writeCommandPermissionMode(context, mode);
+    return undefined;
+  } catch (error) {
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+}
+
+function executeRetry(
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess,
+  args: string,
+): ICommandResult {
+  const position = Number(args.trim().split(/\s+/)[1]);
+  const denial = retryCommandPermissionDenial(context, position);
+  if (denial === undefined) {
+    return {
+      message:
+        'Usage: /permissions retry <n>, where <n> numbers a call blocked by the auto-mode ' +
+        'classifier in /permissions.',
+      success: false,
+    };
+  }
+  const call =
+    denial.argument !== undefined ? `${denial.toolName}(${denial.argument})` : denial.toolName;
+  return {
+    message: `${call} will run once, without the classifier, when the model tries it again.`,
+    success: true,
+  };
+}
+
+export function executePermissionsCommand(
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess,
+  args: string,
+): ICommandResult {
+  const arg = parsePermissionModeArgument(args);
+  if (arg === 'retry') return executeRetry(context, args);
+  if (arg !== undefined) {
+    if (!isPermissionMode(arg)) {
+      return {
+        message: formatInvalidPermissionModeMessage(),
+        success: false,
+      };
+    }
+
+    const refused = tryWritePermissionMode(context, arg);
+    if (refused !== undefined) return refused;
+    const state = readCommandPermissionsState(context);
+    return {
+      message: `Permission mode set to: ${arg}\n${formatCommandPermissionsMessage(state)}`,
+      success: true,
+      data: {
+        mode: state.mode,
+        sessionAllowed: state.sessionAllowed,
+      },
+    };
+  }
+
+  const state = readCommandPermissionsState(context);
+  return {
+    message: formatCommandPermissionsMessage(state),
+    success: true,
+    data: {
+      mode: state.mode,
+      sessionAllowed: state.sessionAllowed,
+    },
+  };
+}