@robota-sdk/agent-command 3.0.0-beta.76 → 3.0.0-beta.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-command",
-  "version": "3.0.0-beta.76",
+  "version": "3.0.0-beta.77",
   "description": "Consolidated command module implementations for Robota SDK CLI",
   "type": "module",
   "main": "dist/node/index.js",
@@ -24,19 +24,19 @@
     "src"
   ],
   "dependencies": {
-    "@robota-sdk/agent-core": "3.0.0-beta.76",
-    "@robota-sdk/agent-framework": "3.0.0-beta.76",
-    "@robota-sdk/agent-interface-transport": "3.0.0-beta.76",
-    "@robota-sdk/agent-preset": "3.0.0-beta.76"
+    "@robota-sdk/agent-core": "3.0.0-beta.77",
+    "@robota-sdk/agent-framework": "3.0.0-beta.77",
+    "@robota-sdk/agent-interface-transport": "3.0.0-beta.77",
+    "@robota-sdk/agent-preset": "3.0.0-beta.77"
   },
   "devDependencies": {
     "@types/node": "^22.19.21",
-    "rimraf": "^6.1.3",
+    "rimraf": "^5.0.10",
     "tsdown": "^0.22.2",
     "typescript": "^5.9.3",
     "vitest": "^3.2.6"
   },
-  "license": "MIT",
+  "license": "AGPL-3.0-only OR LicenseRef-Commercial",
   "publishConfig": {
     "access": "public"
   },

package/src/agent/agent-command-parser.ts

@@ -1,4 +1,4 @@
-import type { TBackgroundTaskIsolation } from '@robota-sdk/agent-framework';
+import type { TBackgroundTaskIsolation } from '@robota-sdk/agent-interface-transport';
 
 const DEFAULT_AGENT_TYPE = 'general-purpose';
 

package/src/agent/agent-command.ts

@@ -3,8 +3,9 @@ import { summarizeBackgroundJobGroup } from '@robota-sdk/agent-framework';
 import { parseParallelRequests, parseRunRequest, tokenizeArgs } from './agent-command-parser.js';
 
 import type { IAgentRunRequest } from './agent-command-parser.js';
-import type { IAgentJobHostContext, ISubagentJobState } from '@robota-sdk/agent-framework';
+import type { IAgentJobHostContext } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type { ISubagentJobState } from '@robota-sdk/agent-interface-transport';
 
 function formatError<TError>(error: TError): string {
   return error instanceof Error ? error.message : String(error);

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

@@ -1,15 +1,12 @@
 import { describe, expect, it, vi } from 'vitest';
-import type {
-  IBackgroundTaskState,
-  ICommandHostContext,
-  ICommandSessionRuntime,
-} from '@robota-sdk/agent-framework';
+import type { ICommandHostContext, ICommandSessionRuntime } from '@robota-sdk/agent-framework';
 import {
   BackgroundCommandSource,
   createBackgroundCommandEntry,
   createBackgroundCommandModule,
   executeBackgroundCommand,
 } from '../index.js';
+import type { IBackgroundTaskState } from '@robota-sdk/agent-interface-transport';
 
 function createSessionRuntime(): ICommandSessionRuntime {
   return {

package/src/default/__tests__/default-command-modules.test.ts

@@ -40,8 +40,8 @@ describe('createDefaultCommandModules — PRESET-004 module-selection delta', ()
 
   it('TC-04: neither enabled nor disabled given → full default set unchanged (no-regression)', () => {
     const names = moduleNames(baseOptions);
-    // No-regression: the default set length is the documented 21 modules.
-    expect(names).toHaveLength(21);
+    // No-regression: the default set length is the documented 24 modules.
+    expect(names).toHaveLength(24);
     expect(names).toEqual([
       'agent-command-skills',
       'agent-command-help',
@@ -51,6 +51,9 @@ describe('createDefaultCommandModules — PRESET-004 module-selection delta', ()
       'agent-command-preset',
       'agent-command-language',
       'agent-command-background',
+      'agent-command-goal',
+      'agent-command-shell',
+      'agent-command-editor',
       'agent-command-memory',
       'agent-command-user-local',
       'agent-command-compact',

package/src/default/default-command-modules.ts

@@ -2,7 +2,9 @@ import { createAgentCommandModule } from '../agent/index.js';
 import { createBackgroundCommandModule } from '../background/index.js';
 import { createCompactCommandModule } from '../compact/index.js';
 import { createContextCommandModule } from '../context/index.js';
+import { createEditorCommandModule } from '../editor/index.js';
 import { createExitCommandModule } from '../exit/index.js';
+import { createGoalCommandModule } from '../goal/index.js';
 import { createHelpCommandModule } from '../help/index.js';
 import { createLanguageCommandModule } from '../language/index.js';
 import { createMemoryCommandModule } from '../memory/index.js';
@@ -16,6 +18,7 @@ import { createRewindCommandModule } from '../rewind/index.js';
 import { createScheduleCommandModule } from '../schedule/index.js';
 import { createSessionCommandModule } from '../session/index.js';
 import { createSettingsCommandModule } from '../settings/index.js';
+import { createShellCommandModule } from '../shell/index.js';
 import { createSkillsCommandModule } from '../skills/index.js';
 import { createStatusLineCommandModule } from '../statusline/index.js';
 import { createUserLocalCommandModule } from '../user-local/index.js';
@@ -79,6 +82,9 @@ export function createDefaultCommandModules({
     createPresetCommandModule(),
     createLanguageCommandModule(),
     createBackgroundCommandModule(),
+    createGoalCommandModule(),
+    createShellCommandModule(),
+    createEditorCommandModule(),
     createMemoryCommandModule(),
     createUserLocalCommandModule(),
     createCompactCommandModule(),

package/src/editor/__tests__/editor-command-functional.test.ts

@@ -0,0 +1,91 @@
+/**
+ * TERM-004: `/editor` — framework functional test.
+ *
+ * Drives the command through a REAL InteractiveSession with an injected fake handoff and a FAKE
+ * editor (a tiny script that writes known content to its file arg). Verifies the round-trip: the
+ * command opens the editor via `runWithTerminal`, captures the saved text, and cleans up — without a
+ * real interactive editor (which is a manual gate, TERM-002).
+ */
+import { chmodSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { scriptedSession, type ScriptedSessionHarness } from '@robota-sdk/agent-framework/testing';
+
+import { createEditorCommandModule } from '../editor-command-module.js';
+
+import type { ITerminalHandoff } from '@robota-sdk/agent-interface-transport';
+
+const TEST_TIMEOUT = 20_000;
+
+function fakeHandoff(canHandoff: boolean): ITerminalHandoff {
+  return {
+    canHandoffTerminal: canHandoff,
+    async runWithTerminal<T>(fn: () => Promise<T>): Promise<T> {
+      return fn();
+    },
+  };
+}
+
+/** Write a fake `$EDITOR`: a script that writes `content` into the file it is given as $1. */
+function installFakeEditor(content: string): string {
+  const dir = mkdtempSync(join(tmpdir(), 'robota-fake-editor-'));
+  const script = join(dir, 'fake-editor.sh');
+  writeFileSync(script, `#!/bin/sh\nprintf '%s' '${content}' > "$1"\n`, 'utf8');
+  chmodSync(script, 0o755);
+  return script;
+}
+
+const origEditor = process.env.EDITOR;
+const origVisual = process.env.VISUAL;
+
+let h: ScriptedSessionHarness | undefined;
+afterEach(async () => {
+  await h?.dispose();
+  h = undefined;
+  if (origEditor === undefined) delete process.env.EDITOR;
+  else process.env.EDITOR = origEditor;
+  if (origVisual === undefined) delete process.env.VISUAL;
+  else process.env.VISUAL = origVisual;
+});
+
+describe('/editor command (framework functional)', () => {
+  it(
+    'opens the editor via the handoff and returns the saved text',
+    async () => {
+      delete process.env.VISUAL;
+      process.env.EDITOR = installFakeEditor('composed in editor');
+      h = scriptedSession({
+        turns: [{ text: 'unused' }],
+        terminalHandoff: fakeHandoff(true),
+        commandModules: [createEditorCommandModule()],
+      });
+
+      const result = await h.command('editor', '');
+
+      expect(result?.success).toBe(true);
+      expect(result?.message).toBe('composed in editor');
+      expect((result?.data as { content: string }).content).toBe('composed in editor');
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    'is unavailable when there is no interactive terminal',
+    async () => {
+      process.env.EDITOR = installFakeEditor('unused');
+      h = scriptedSession({
+        turns: [{ text: 'unused' }],
+        commandModules: [createEditorCommandModule()],
+      });
+
+      const result = await h.command('editor', '');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toMatch(/unavailable/i);
+    },
+    TEST_TIMEOUT,
+  );
+});

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

@@ -0,0 +1,47 @@
+/**
+ * TERM-004: `/editor` command module — a framework-level consumer of the terminal-handoff capability.
+ */
+import { EDITOR_COMMAND_DESCRIPTION, executeEditorCommand } from './editor-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+
+export function createEditorCommandEntry(): ICommand {
+  return {
+    name: 'editor',
+    displayName: 'Editor',
+    description: EDITOR_COMMAND_DESCRIPTION,
+    source: 'editor',
+    modelInvocable: false,
+  };
+}
+
+function createEditorSystemCommand(): ISystemCommand {
+  const entry = createEditorCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: executeEditorCommand,
+  };
+}
+
+export class EditorCommandSource implements ICommandSource {
+  readonly name = 'editor';
+
+  getCommands(): ICommand[] {
+    return [createEditorCommandEntry()];
+  }
+}
+
+export function createEditorCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-editor',
+    commandSources: [new EditorCommandSource()],
+    systemCommands: [createEditorSystemCommand()],
+  };
+}

package/src/editor/editor-command.ts

@@ -0,0 +1,53 @@
+/**
+ * TERM-004: `/editor` — compose a message/prompt in `$EDITOR` via the terminal-handoff capability,
+ * then return the saved text. The temp file is pre-filled with any args and removed afterward.
+ */
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { resolveEditor } from './resolve-editor.js';
+import { spawnInherited } from '../shell/spawn-inherited.js';
+
+import type { ICommandHostContext } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+
+export const EDITOR_COMMAND_DESCRIPTION =
+  'Compose a message in $EDITOR (optionally pre-filled with `/editor <text>`), then return it.';
+
+export async function executeEditorCommand(
+  context: ICommandHostContext,
+  args: string,
+): Promise<ICommandResult> {
+  if (context.canHandoffTerminal?.() !== true || context.runWithTerminal === undefined) {
+    return {
+      message: 'An editor is unavailable here (no interactive terminal).',
+      success: false,
+    };
+  }
+
+  const editor = resolveEditor();
+  const dir = mkdtempSync(join(tmpdir(), 'robota-editor-'));
+  const file = join(dir, 'message.md');
+  writeFileSync(file, args ?? '', 'utf8');
+
+  try {
+    const exitCode = await context.runWithTerminal(async () =>
+      spawnInherited(editor.command, [...editor.args, file], context.getCwd()),
+    );
+    if (exitCode !== 0) {
+      return {
+        message: `Editor exited without saving (code ${exitCode}).`,
+        success: false,
+        data: { exitCode },
+      };
+    }
+    const content = readFileSync(file, 'utf8').replace(/\s+$/u, '');
+    if (content.length === 0) {
+      return { message: 'Editor closed with empty content; nothing composed.', success: false };
+    }
+    return { message: content, success: true, data: { content } };
+  } finally {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 20 });
+  }
+}

package/src/editor/index.ts

@@ -0,0 +1,7 @@
+export { resolveEditor, type IResolvedEditor } from './resolve-editor.js';
+export { executeEditorCommand, EDITOR_COMMAND_DESCRIPTION } from './editor-command.js';
+export {
+  EditorCommandSource,
+  createEditorCommandEntry,
+  createEditorCommandModule,
+} from './editor-command-module.js';

package/src/editor/resolve-editor.ts

@@ -0,0 +1,21 @@
+/**
+ * TERM-004: editor-selection seam. Resolves `$VISUAL` → `$EDITOR` → `vi` (POSIX-first; a Windows
+ * default is a TERM-007 concern). Splits on whitespace so `"code -w"` / `"subl -w"` style values work.
+ */
+export interface IResolvedEditor {
+  command: string;
+  args: readonly string[];
+}
+
+export function resolveEditor(): IResolvedEditor {
+  const visual = process.env.VISUAL?.trim();
+  const editor = process.env.EDITOR?.trim();
+  const chosen =
+    visual !== undefined && visual.length > 0
+      ? visual
+      : editor !== undefined && editor.length > 0
+        ? editor
+        : 'vi';
+  const parts = chosen.split(/\s+/).filter((p) => p.length > 0);
+  return { command: parts[0] ?? 'vi', args: parts.slice(1) };
+}

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import type { ICommandHostContext } from '@robota-sdk/agent-framework';
 import {
   ExitCommandSource,
   createExitCommandEntry,
@@ -6,6 +7,12 @@ import {
   executeExitCommand,
 } from '../index.js';
 
+function contextWithAnswer(value: string): ICommandHostContext {
+  return {
+    getUserInteraction: () => ({ ask: async () => ({ type: 'answer', values: [value] }) }),
+  } as unknown as ICommandHostContext;
+}
+
 describe('exit command module', () => {
   it('provides command metadata and executable registration from one module', () => {
     const entry = createExitCommandEntry();
@@ -23,8 +30,8 @@ describe('exit command module', () => {
     expect(module.commandSources?.flatMap((source) => source.getCommands())).toEqual([entry]);
   });
 
-  it('returns the session exit effect without owning process exit', () => {
-    const result = executeExitCommand({} as never, '');
+  it('proceeds to exit with no renderer attached (no human to confirm)', async () => {
+    const result = await executeExitCommand({} as never, '');
 
     expect(result).toEqual({
       success: true,
@@ -32,4 +39,16 @@ describe('exit command module', () => {
       effects: [{ type: 'session-exit-requested' }],
     });
   });
+
+  it('confirms before exiting and proceeds on yes (CMD-004)', async () => {
+    const result = await executeExitCommand(contextWithAnswer('yes'), '');
+    expect(result.effects).toEqual([{ type: 'session-exit-requested' }]);
+  });
+
+  it('cancels the exit when the user declines (CMD-004)', async () => {
+    const result = await executeExitCommand(contextWithAnswer('no'), '');
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Exit cancelled.');
+    expect(result.effects).toBeUndefined();
+  });
 });

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

@@ -3,11 +3,7 @@ import { EXIT_COMMAND_DESCRIPTION } from '@robota-sdk/agent-framework';
 import { executeExitCommand } from './exit-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type {
-  ICommand,
-  ICommandInteractionHint,
-  ICommandSource,
-} from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
 
 export function createExitCommandEntry(): ICommand {
   return {
@@ -41,15 +37,10 @@ export class ExitCommandSource implements ICommandSource {
   }
 }
 
-const EXIT_INTERACTION_HINTS: Record<string, ICommandInteractionHint> = {
-  exit: { type: 'confirm', message: 'Exit the session?' },
-};
-
 export function createExitCommandModule(): ICommandModule {
   return {
     name: 'agent-command-exit',
     commandSources: [new ExitCommandSource()],
     systemCommands: [createExitSystemCommand()],
-    interactionHints: EXIT_INTERACTION_HINTS,
   };
 }

package/src/exit/exit-command.ts

@@ -1,9 +1,23 @@
+import { confirmAction, isConfirmed } from '@robota-sdk/agent-core';
 import { createSessionExitRequestedEffect } from '@robota-sdk/agent-framework';
 
 import type { ICommandHostContext } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
 
-export function executeExitCommand(_context: ICommandHostContext, _args: string): ICommandResult {
+export async function executeExitCommand(
+  context: ICommandHostContext,
+  _args: string,
+): Promise<ICommandResult> {
+  // Confirm only when an interactive renderer is attached. With no human (headless/automation) the
+  // user explicitly invoked /exit, so proceed — the confirm is an interactive safety prompt, not a gate.
+  const ui = context.getUserInteraction?.();
+  if (ui) {
+    const response = await ui.ask(confirmAction('exit', 'Exit the session?'));
+    if (!isConfirmed(response)) {
+      return { success: true, message: 'Exit cancelled.' };
+    }
+  }
+
   return {
     success: true,
     message: 'Exit requested.',

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

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { executeGoalCommand } from '../goal-command.js';
+
+import type { ICommandHostContext } from '@robota-sdk/agent-framework';
+import type { IGoalState } from '@robota-sdk/agent-interface-transport';
+
+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: Partial<ICommandHostContext> = {}): ICommandHostContext {
+  return overrides as unknown as ICommandHostContext;
+}
+
+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,48 @@
+/**
+ * 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-transport';
+
+export function createGoalCommandEntry(): ICommand {
+  return {
+    name: 'goal',
+    displayName: 'Autonomous Goal',
+    description: GOAL_COMMAND_DESCRIPTION,
+    source: 'goal',
+    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,70 @@
+/**
+ * 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 type { ICommandHostContext } from '@robota-sdk/agent-framework';
+import type { ICommandResult, IGoalState } from '@robota-sdk/agent-interface-transport';
+
+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: ICommandHostContext,
+  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?.() ?? null;
+    return goal
+      ? { message: formatGoalState(goal), success: true, data: { status: goal.status } }
+      : { message: 'No goal is set.', success: true };
+  }
+
+  if (verb === 'cancel' || verb === 'stop') {
+    const stopped = context.cancelGoal?.() ?? null;
+    return stopped
+      ? { message: `Goal cancelled: ${stopped.objective}`, success: true }
+      : { message: 'No active goal to cancel.', success: false };
+  }
+
+  if (!context.setGoal) {
+    return { message: 'Goal pursuit is not available in this session.', 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/index.ts

@@ -1,8 +1,10 @@
 export * from './agent/index.js';
 export * from './default/index.js';
 export * from './background/index.js';
+export * from './goal/index.js';
 export * from './compact/index.js';
 export * from './context/index.js';
+export * from './editor/index.js';
 export * from './exit/index.js';
 export * from './help/index.js';
 export * from './language/index.js';
@@ -11,6 +13,7 @@ export * from './mode/index.js';
 export * from './permissions/index.js';
 export * from './plugin/index.js';
 export * from './preset/index.js';
+export * from './shell/index.js';
 export * from './provider/index.js';
 export * from './reset/index.js';
 export * from './rewind/index.js';