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

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

@@ -0,0 +1,138 @@
+/**
+ * BEHAVIOR-2437: `/git` — one command whose `execute` parses its verb (`status` | `diff` | `commit`),
+ * with the three verbs on `subcommands` for `/help` and autocomplete. Host-only (`modelInvocable:
+ * false`); the confirmation lives in the `commit` verb, because `requiresPermission` is not enforced
+ * on the user path (`SystemCommandExecutor.executeCommand` calls `execute` directly).
+ */
+import { executeGitCommit } from './git-commit.js';
+
+import { createGitProcess, executeGitDiff, executeGitStatus } from '@robota-sdk/agent-framework';
+
+import type {
+  ICommandHostUserInteraction,
+  ICommandHostWorkspace,
+  ICommandModule,
+  IGitProcessPort,
+  ISystemCommand,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandResult, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export const GIT_COMMAND_DESCRIPTION =
+  'Show the git status, view a diff, or commit the staged changes after confirming';
+export const GIT_COMMAND_ARGUMENT_HINT =
+  'status | diff [--staged | <rev> | <a>..<b>] [-- <path> ...] | commit [<subject>]';
+export const GIT_COMMAND_USAGE =
+  'Usage: /git status | /git diff [--staged | <rev> | <a>..<b>] [-- <path> ...] | /git commit [<subject>]';
+
+const SOURCE = 'git';
+
+function verbEntry(name: string, description: string, argumentHint?: string): ICommand {
+  return {
+    name,
+    description,
+    source: SOURCE,
+    modelInvocable: false,
+    ...(argumentHint ? { argumentHint } : {}),
+  };
+}
+
+export function createGitCommandEntry(): ICommand {
+  return {
+    name: 'git',
+    displayName: 'Git',
+    description: GIT_COMMAND_DESCRIPTION,
+    source: SOURCE,
+    modelInvocable: false,
+    argumentHint: GIT_COMMAND_ARGUMENT_HINT,
+    subcommands: [
+      verbEntry('status', 'Show the branch and the staged, unstaged and untracked paths'),
+      verbEntry(
+        'diff',
+        'Show the unstaged diff, the staged diff, or a diff against one or two revisions',
+        '[--staged | <rev> | <a>..<b>] [-- <path> ...]',
+      ),
+      verbEntry(
+        'commit',
+        'Commit the staged changes with a Conventional Commits subject, after confirming',
+        '[<subject>]',
+      ),
+    ],
+  };
+}
+
+/** What the verbs need from the host: the working directory and the ask-the-user port. */
+export type TGitCommandContext = Pick<ICommandHostWorkspace, 'getCwd'> &
+  ICommandHostUserInteraction;
+
+export async function executeGitCommand(
+  context: TGitCommandContext,
+  args: string,
+  port: IGitProcessPort = createGitProcess(),
+): Promise<ICommandResult> {
+  const trimmed = args.trim();
+  const split = trimmed.search(/\s/);
+  const verb = split === -1 ? trimmed : trimmed.slice(0, split);
+  const rest = split === -1 ? '' : trimmed.slice(split + 1).trim();
+  const cwd = context.getCwd();
+
+  switch (verb) {
+    case 'status':
+      if (rest.length > 0) {
+        return {
+          success: false,
+          message: `\`/git status\` takes no arguments.\n${GIT_COMMAND_USAGE}`,
+        };
+      }
+      return executeGitStatus(port, cwd);
+    case 'diff':
+      return executeGitDiff(port, cwd, rest);
+    case 'commit':
+      return executeGitCommit(port, cwd, rest, context.getUserInteraction());
+    default:
+      return {
+        success: false,
+        message:
+          verb.length === 0
+            ? GIT_COMMAND_USAGE
+            : `Unknown /git verb "${verb}".\n${GIT_COMMAND_USAGE}`,
+      };
+  }
+}
+
+function createGitSystemCommand(port: IGitProcessPort): ISystemCommand {
+  const entry = createGitCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    argumentHint: entry.argumentHint,
+    example: '/git status',
+    subcommands: entry.subcommands,
+    requiresPermission: true,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'blocking',
+    execute: (context, args) => executeGitCommand(context, args, port),
+  };
+}
+
+export class GitCommandSource implements ICommandSource {
+  readonly name = SOURCE;
+
+  getCommands(): ICommand[] {
+    return [createGitCommandEntry()];
+  }
+}
+
+export interface IGitCommandModuleOptions {
+  /** The process seam; the production `createGitProcess()` by default, injectable for tests. */
+  port?: IGitProcessPort;
+}
+
+export function createGitCommandModule(options: IGitCommandModuleOptions = {}): ICommandModule {
+  return {
+    name: 'agent-command-git',
+    commandSources: [new GitCommandSource()],
+    systemCommands: [createGitSystemCommand(options.port ?? createGitProcess())],
+  };
+}

package/src/git/git-commit.ts

@@ -0,0 +1,254 @@
+/**
+ * BEHAVIOR-2437: `/git commit [<subject>]` — the staged set, and only ever the staged set.
+ *
+ * No `-a`, no `add`, no paths. Nothing staged is answered with guidance that says why; the subject
+ * is held to the Conventional Commits v1.0.0 MUST rules and nothing more (the commitlint conventions
+ * are warnings, never refusals); the confirmation lists the message and exactly the files
+ * `git diff --cached --name-status` reports; an absent `IUserInteraction` is a cancellation — the
+ * `/doctor repair` precedent — never a guess. Only after "Yes" does `git commit -m <subject>` run.
+ */
+import { confirmAction, isConfirmed, textAction } from '@robota-sdk/agent-core';
+
+import {
+  gitFailureMessage,
+  parseStatusPorcelainV2,
+  GIT_STATUS_ARGS,
+} from '@robota-sdk/agent-framework';
+
+import type { IGitProcessPort } from '@robota-sdk/agent-framework';
+import type { IUserInteraction } from '@robota-sdk/agent-core';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+const GIT_COMMIT_CONVENTIONAL_TYPES: readonly string[] = [
+  'build',
+  'chore',
+  'ci',
+  'docs',
+  'feat',
+  'fix',
+  'perf',
+  'refactor',
+  'revert',
+  'style',
+  'test',
+];
+const GIT_COMMIT_SUBJECT_LIMIT = 72;
+
+export type TConventionalSubjectCheck =
+  { ok: true; warnings: readonly string[] } | { ok: false; reason: string };
+
+/** `<type>[(scope)][!]: <description>` — the MUST rules, and only those. */
+const CONVENTIONAL_SUBJECT = /^([^\s():!]+)(\(([^\s()]+)\))?(!)?: (.*)$/;
+
+export function validateConventionalSubject(subject: string): TConventionalSubjectCheck {
+  if (subject.trim().length === 0) return { ok: false, reason: 'the subject is empty' };
+  const separator = subject.indexOf(': ');
+  if (separator === -1) {
+    return {
+      ok: false,
+      reason:
+        'the subject has no `: ` type separator — the form is `<type>[(scope)][!]: <description>`',
+    };
+  }
+  const match = CONVENTIONAL_SUBJECT.exec(subject);
+  if (!match) {
+    return {
+      ok: false,
+      reason:
+        'the part before `: ` must be a type word with an optional `(scope)` and `!` — the form is `<type>[(scope)][!]: <description>`',
+    };
+  }
+  const type = match[1] ?? '';
+  const description = match[5] ?? '';
+  if (description.trim().length === 0) {
+    return { ok: false, reason: 'the description after `: ` is empty' };
+  }
+  const warnings: string[] = [];
+  if (!GIT_COMMIT_CONVENTIONAL_TYPES.includes(type)) {
+    warnings.push(
+      `type "${type}" is not one of the conventional types (${GIT_COMMIT_CONVENTIONAL_TYPES.join(', ')})`,
+    );
+  }
+  if (subject.length > GIT_COMMIT_SUBJECT_LIMIT) {
+    warnings.push(
+      `the subject is ${subject.length} characters; ${GIT_COMMIT_SUBJECT_LIMIT} is the conventional limit`,
+    );
+  }
+  if (subject.endsWith('.')) warnings.push('the subject ends with a period');
+  return { ok: true, warnings };
+}
+
+/** The inline subject: an optional leading `-m`, then one matching pair of outer quotes stripped. */
+export function normalizeCommitSubject(args: string): string {
+  let subject = args.trim();
+  if (subject === '-m') return '';
+  if (subject.startsWith('-m ')) subject = subject.slice('-m '.length).trim();
+  if (
+    subject.length >= 2 &&
+    (subject.startsWith('"') || subject.startsWith("'")) &&
+    subject.endsWith(subject[0] ?? '')
+  ) {
+    subject = subject.slice(1, -1).trim();
+  }
+  return subject;
+}
+
+function cancelled(message: string): ICommandResult {
+  return { success: false, message, data: { git: 'commit', committed: false } };
+}
+
+async function askSubject(ui: IUserInteraction): Promise<string | undefined> {
+  const response = await ui.ask(
+    textAction('git-commit-subject', 'Commit message', {
+      description: 'Conventional Commits form: <type>[(scope)][!]: <description>',
+      placeholder: 'feat: describe the change',
+    }),
+  );
+  if (response.type !== 'answer') return undefined;
+  const text = response.text ?? response.values[0] ?? '';
+  return normalizeCommitSubject(text);
+}
+
+type TStagedCheck = { staged: true } | { staged: false; result: ICommandResult };
+
+/** Step 1 — the staged set decides everything; exit 1 means something is staged. */
+async function checkStaged(port: IGitProcessPort, cwd: string): Promise<TStagedCheck> {
+  const staged = await port.run(['diff', '--cached', '--quiet'], { cwd });
+  if (staged.kind === 'failed' || (staged.exitCode !== 0 && staged.exitCode !== 1)) {
+    return {
+      staged: false,
+      result: {
+        success: false,
+        message: gitFailureMessage('diff --cached', staged) ?? 'git failed',
+      },
+    };
+  }
+  if (staged.exitCode === 1) return { staged: true };
+  const status = await port.run(GIT_STATUS_ARGS, { cwd });
+  const failure = gitFailureMessage('status', status);
+  if (failure !== undefined || status.kind !== 'exited') {
+    return { staged: false, result: { success: false, message: failure ?? 'git status failed' } };
+  }
+  const summary = parseStatusPorcelainV2(status.stdout);
+  return {
+    staged: false,
+    result: {
+      success: false,
+      message: `Nothing is staged (${summary.unstaged.length} unstaged, ${summary.untracked.length} untracked). Stage files with \`git add\` or \`/shell git add ...\` and run \`/git commit\` again.`,
+      data: {
+        git: 'commit',
+        committed: false,
+        unstaged: summary.unstaged.length,
+        untracked: summary.untracked.length,
+      },
+    },
+  };
+}
+
+type TSubjectResolution = { subject: string } | { result: ICommandResult };
+
+/** Step 2 — the subject: inline, or asked for as free text; then the MUST rules. */
+async function resolveSubject(
+  args: string,
+  ui: IUserInteraction | undefined,
+): Promise<TSubjectResolution> {
+  let subject = normalizeCommitSubject(args);
+  if (subject.length === 0) {
+    if (ui === undefined) {
+      return {
+        result: cancelled(
+          'Commit cancelled: a commit message was needed and none could be asked for (no interactive session). Run `/git commit <subject>`.',
+        ),
+      };
+    }
+    const asked = await askSubject(ui);
+    if (asked === undefined || asked.length === 0)
+      return { result: cancelled('Commit cancelled.') };
+    subject = asked;
+  }
+  return { subject };
+}
+
+/** Step 3 — what is confirmed is what is committed: the listing comes from git, not from a guess. */
+async function confirmCommit(
+  port: IGitProcessPort,
+  cwd: string,
+  subject: string,
+  warnings: readonly string[],
+  ui: IUserInteraction | undefined,
+): Promise<
+  { confirmed: true; files: readonly string[] } | { confirmed: false; result: ICommandResult }
+> {
+  if (ui === undefined) {
+    return {
+      confirmed: false,
+      result: cancelled(
+        'Commit cancelled: a confirmation was needed and none could be asked for (no interactive session).',
+      ),
+    };
+  }
+  const listing = await port.run(['diff', '--cached', '--name-status'], { cwd });
+  const listingFailure = gitFailureMessage('diff --cached --name-status', listing);
+  if (listingFailure !== undefined || listing.kind !== 'exited') {
+    return {
+      confirmed: false,
+      result: { success: false, message: listingFailure ?? 'git failed' },
+    };
+  }
+  const files = listing.stdout
+    .split('\n')
+    .filter((line) => line.length > 0)
+    .map((line) => line.replace(/\t/g, ' '));
+  const description = [
+    `Message: ${subject}`,
+    ...warnings.map((warning) => `Warning: ${warning}`),
+    `Staged (${files.length}):`,
+    ...files.map((file) => `  ${file}`),
+  ].join('\n');
+  const response = await ui.ask(
+    confirmAction('git-commit', `Commit ${files.length} staged file(s)?`, {
+      description,
+      defaultYes: false,
+    }),
+  );
+  if (!isConfirmed(response)) return { confirmed: false, result: cancelled('Commit cancelled.') };
+  return { confirmed: true, files };
+}
+
+export async function executeGitCommit(
+  port: IGitProcessPort,
+  cwd: string,
+  args: string,
+  ui: IUserInteraction | undefined,
+): Promise<ICommandResult> {
+  const staged = await checkStaged(port, cwd);
+  if (!staged.staged) return staged.result;
+
+  const resolved = await resolveSubject(args, ui);
+  if (!('subject' in resolved)) return resolved.result;
+  const { subject } = resolved;
+  const check = validateConventionalSubject(subject);
+  if (!check.ok) {
+    return {
+      success: false,
+      message: `Commit refused: ${check.reason}.`,
+      data: { git: 'commit', committed: false, subject },
+    };
+  }
+
+  const confirmation = await confirmCommit(port, cwd, subject, check.warnings, ui);
+  if (!confirmation.confirmed) return confirmation.result;
+
+  // Step 4 — exactly `commit -m <subject>`: never `-a`, never `add`.
+  const commit = await port.run(['commit', '-m', subject], { cwd });
+  const failure = gitFailureMessage('commit', commit);
+  if (failure !== undefined || commit.kind !== 'exited') {
+    return { success: false, message: failure ?? 'git commit failed' };
+  }
+  const firstLine = commit.stdout.split('\n').find((line) => line.trim().length > 0) ?? '';
+  return {
+    success: true,
+    message: `Committed: ${firstLine.length > 0 ? firstLine : subject}`,
+    data: { git: 'commit', committed: true, subject, files: confirmation.files },
+  };
+}

package/src/git/index.ts

@@ -0,0 +1,20 @@
+// The git process port and the status/diff readers moved to `@robota-sdk/agent-framework` (#3282
+// §4c) so the Project panel's session-level reads and this command run through the exact same
+// functions; re-exported here so an existing `from '@robota-sdk/agent-command'` import keeps working.
+export {
+  createGitProcess,
+  gitEnvironment,
+  type ICreateGitProcessOptions,
+  type IGitProcessPort,
+  type IGitProcessRunOptions,
+  type TGitProcessFailureReason,
+  type TGitProcessOutcome,
+} from '@robota-sdk/agent-framework';
+export {
+  createGitCommandEntry,
+  createGitCommandModule,
+  executeGitCommand,
+  GitCommandSource,
+  type IGitCommandModuleOptions,
+  type TGitCommandContext,
+} from './git-command-module.js';

package/src/goal/__tests__/goal-command.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { executeGoalCommand } from '../goal-command.js';
+
+import type { IGoalState } from '@robota-sdk/agent-interface-session';
+import {
+  createTestCommandHost,
+  type ICreateTestCommandHostOptions,
+} from '@robota-sdk/agent-framework/testing';
+
+function goal(overrides: Partial<IGoalState> = {}): IGoalState {
+  return {
+    id: 'g1',
+    objective: 'write a file',
+    status: 'active',
+    iterations: 1,
+    maxIterations: 25,
+    startedAt: '2026-06-27T00:00:00.000Z',
+    progress: [{ iteration: 1, signal: 'continue', reason: 'started' }],
+    ...overrides,
+  };
+}
+
+function host(overrides: ICreateTestCommandHostOptions['overrides'] = {}) {
+  // ARCH-029: the partial is now an OVERRIDE over a conformant host, not a cast that turns the
+  // check off. A fixture that names three members no longer claims to satisfy 46.
+  return createTestCommandHost({ overrides });
+}
+
+describe('executeGoalCommand', () => {
+  it('assigns a goal from the objective text', async () => {
+    const setGoal = vi.fn().mockResolvedValue(goal());
+    const result = await executeGoalCommand(host({ setGoal }), 'write a file');
+    expect(setGoal).toHaveBeenCalledWith('write a file');
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('pursuing autonomously');
+    expect(result.data).toMatchObject({ goalId: 'g1' });
+  });
+
+  it('shows status when given "status"', async () => {
+    const result = await executeGoalCommand(host({ getGoalState: () => goal() }), 'status');
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('write a file');
+    expect(result.message).toContain('Iterations: 1 / 25');
+  });
+
+  it('reports no goal when status is requested with none set', async () => {
+    const result = await executeGoalCommand(host({ getGoalState: () => null }), 'status');
+    expect(result.message).toBe('No goal is set.');
+  });
+
+  it('cancels an active goal', async () => {
+    const cancelGoal = vi
+      .fn()
+      .mockReturnValue(goal({ status: 'stopped', stopReason: 'cancelled' }));
+    const result = await executeGoalCommand(host({ cancelGoal }), 'cancel');
+    expect(cancelGoal).toHaveBeenCalled();
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Goal cancelled');
+  });
+
+  it('reports failure when cancelling with no active goal', async () => {
+    const result = await executeGoalCommand(host({ cancelGoal: () => null }), 'stop');
+    expect(result.success).toBe(false);
+  });
+
+  it('shows usage on an empty argument', async () => {
+    const result = await executeGoalCommand(host({}), '');
+    expect(result.message).toContain('Usage');
+  });
+
+  it('surfaces an invalid-objective error as a failed result (not a crash)', async () => {
+    const setGoal = vi
+      .fn()
+      .mockRejectedValue(new Error('A goal objective must be a non-empty string.'));
+    const result = await executeGoalCommand(host({ setGoal }), 'x');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('non-empty');
+  });
+});

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

@@ -0,0 +1,49 @@
+/**
+ * GOAL-001: `/goal` command module registration.
+ */
+
+import { executeGoalCommand, GOAL_COMMAND_DESCRIPTION } from './goal-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createGoalCommandEntry(): ICommand {
+  return {
+    name: 'goal',
+    displayName: 'Autonomous Goal',
+    description: GOAL_COMMAND_DESCRIPTION,
+    source: 'goal',
+    // User-only: assigning an autonomous goal widens what the agent pursues without asking; the user sets it.
+    modelInvocable: false,
+  };
+}
+
+function createGoalSystemCommand(): ISystemCommand {
+  const entry = createGoalCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: executeGoalCommand,
+  };
+}
+
+export class GoalCommandSource implements ICommandSource {
+  readonly name = 'goal';
+
+  getCommands(): ICommand[] {
+    return [createGoalCommandEntry()];
+  }
+}
+
+export function createGoalCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-goal',
+    commandSources: [new GoalCommandSource()],
+    systemCommands: [createGoalSystemCommand()],
+  };
+}

package/src/goal/goal-command.ts

@@ -0,0 +1,69 @@
+/**
+ * GOAL-001: the `/goal` slash command. Assigns an autonomous objective the agent pursues across
+ * turns until satisfied or a bound fires. Delegates to the framework-owned goal controller via the
+ * command host context; all loop logic lives in agent-framework.
+ */
+
+import { isGoalCancelVerb } from '@robota-sdk/agent-framework';
+
+import type { ICommandHostGoal } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { IGoalState } from '@robota-sdk/agent-interface-session';
+
+export const GOAL_COMMAND_DESCRIPTION =
+  'Assign an autonomous goal the agent pursues across turns until satisfied.';
+
+const GOAL_COMMAND_USAGE =
+  'Usage:\n  /goal <objective>   assign a goal and pursue it autonomously\n' +
+  '  /goal status        show the current goal and progress\n' +
+  '  /goal cancel        stop the current goal';
+
+function formatGoalState(goal: IGoalState): string {
+  const lines = [
+    `Goal: ${goal.objective}`,
+    `Status: ${goal.status}${goal.stopReason ? ` (${goal.stopReason})` : ''}`,
+    `Iterations: ${goal.iterations} / ${goal.maxIterations}`,
+  ];
+  const last = goal.progress[goal.progress.length - 1];
+  if (last?.reason) lines.push(`Latest: ${last.reason}`);
+  return lines.join('\n');
+}
+
+export async function executeGoalCommand(
+  context: ICommandHostGoal,
+  args: string,
+): Promise<ICommandResult> {
+  const trimmed = args.trim();
+  const verb = trimmed.split(/\s+/)[0]?.toLowerCase() ?? '';
+
+  if (trimmed.length === 0 || verb === 'help') {
+    return { message: GOAL_COMMAND_USAGE, success: true };
+  }
+
+  if (verb === 'status') {
+    const goal = context.getGoalState();
+    return goal
+      ? { message: formatGoalState(goal), success: true, data: { status: goal.status } }
+      : { message: 'No goal is set.', success: true };
+  }
+
+  if (isGoalCancelVerb(trimmed)) {
+    const stopped = context.cancelGoal();
+    return stopped
+      ? { message: `Goal cancelled: ${stopped.objective}`, success: true }
+      : { message: 'No active goal to cancel.', success: false };
+  }
+
+  let goal: IGoalState;
+  try {
+    goal = await context.setGoal(trimmed);
+  } catch (error) {
+    // allow-fallback: surface an invalid-objective error to the user as a failed command result, not a crash
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+  return {
+    message: `Goal set — pursuing autonomously (up to ${goal.maxIterations} iterations):\n${goal.objective}`,
+    success: true,
+    data: { goalId: goal.id },
+  };
+}

package/src/goal/index.ts

@@ -0,0 +1,6 @@
+export {
+  createGoalCommandModule,
+  createGoalCommandEntry,
+  GoalCommandSource,
+} from './goal-command-module.js';
+export { executeGoalCommand, GOAL_COMMAND_DESCRIPTION } from './goal-command.js';

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

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { createHandoffCommandModule } from '../handoff-command-module.js';
+
+describe('/handoff command module', () => {
+  it('is user-only: never model-invocable, and palette metadata matches the executable', () => {
+    const module = createHandoffCommandModule();
+    const palette = module.commandSources?.[0]?.getCommands()[0];
+    const executable = module.systemCommands?.[0];
+    expect(executable?.modelInvocable).toBe(false);
+    expect(palette?.modelInvocable).toBe(false);
+    expect(executable?.userInvocable).toBe(true);
+    expect(palette?.userInvocable).toBe(true);
+    expect(executable?.description).toBe(palette?.description);
+  });
+
+  it('tells the model what it does and which command to suggest, since it cannot run it', () => {
+    const description =
+      createHandoffCommandModule().commandSources?.[0]?.getCommands()[0]?.description;
+    expect(description).toContain('/handoff <session-or-device-id>');
+    expect(description).toMatch(/another linked device/);
+    expect(description).toMatch(/user-only/i);
+    expect(description).toContain('saved, not started');
+  });
+});