feat: pursue a goal autonomously

.changeset/autonomous-goal-mode.md

@@ -0,0 +1,15 @@
+---
+"@moonshot-ai/agent-core": minor
+"@moonshot-ai/kimi-code-sdk": minor
+"@moonshot-ai/kimi-code": minor
+---
+
+Add experimental goal mode for longer tasks that need more than one turn. Turn it on with `KIMI_CODE_EXPERIMENTAL_GOAL_COMMAND=1` before you start Kimi.
+
+Use `/goal <objective>` in the TUI when you want Kimi to keep working on one task across turns. For example:
+
+```text
+/goal Fix the failing checkout test
+```
+
+Kimi shows the goal in the TUI and keeps progress visible while it works. Use `/goal status`, `/goal pause`, `/goal resume`, `/goal cancel`, and `/goal replace <objective>` to manage the goal. This feature is still experimental. Try it and tell us what would make it more useful.

apps/kimi-code/src/cli/goal-prompt.ts

@@ -0,0 +1,102 @@
+import type { GoalSnapshot } from '@moonshot-ai/kimi-code-sdk';
+
+import { parseGoalCommand } from '#/tui/commands/index';
+
+/**
+ * Headless goal-mode support for the `kimi -p "/goal <objective>"` prompt path.
+ *
+ * The goal driver keeps the prompt's turn-run alive across continuation turns
+ * until the goal reaches a terminal state, so the existing prompt-turn waiter
+ * already blocks until then. This module adds the create-on-entry parsing, a
+ * machine-readable summary, and the terminal-status → exit-code mapping.
+ */
+
+export interface HeadlessGoalCreate {
+  readonly objective: string;
+  readonly replace: boolean;
+}
+
+/**
+ * Exit codes by final goal status. The lifecycle has only one success outcome
+ * (`complete` → 0) and two resumable stopped states: `blocked` (the system
+ * stopped pursuing — the model's UpdateGoal, a budget, or an error) and `paused`
+ * (a turn abort / SIGINT). Both are non-zero — the goal did not complete. An absent goal
+ * (should not happen on the create path) maps to success.
+ */
+export const GOAL_EXIT_CODES = {
+  complete: 0,
+  blocked: 3,
+  paused: 6,
+} as const;
+
+export function goalExitCode(status: string | undefined): number {
+  switch (status) {
+    case 'blocked':
+      return GOAL_EXIT_CODES.blocked;
+    case 'paused':
+      return GOAL_EXIT_CODES.paused;
+    default:
+      return GOAL_EXIT_CODES.complete;
+  }
+}
+
+const GOAL_PREFIX = /^\/goal(\s|$)/;
+
+/**
+ * Parses a headless prompt into a goal-create request, or `undefined` when the
+ * prompt is not a `/goal` create command (so the caller runs it as a normal
+ * prompt). Non-create goal subcommands are not supported headless and fall
+ * through to normal prompt handling.
+ */
+export function parseHeadlessGoalCreate(
+  prompt: string,
+  flagEnabled: boolean,
+): HeadlessGoalCreate | undefined {
+  if (!flagEnabled) return undefined;
+  const trimmed = prompt.trim();
+  if (!GOAL_PREFIX.test(trimmed)) return undefined;
+  const args = trimmed.replace(/^\/goal/, '').trim();
+  const parsed = parseGoalCommand(args);
+  if (parsed.kind !== 'create') return undefined;
+  return { objective: parsed.objective, replace: parsed.replace };
+}
+
+export interface GoalSummary {
+  readonly type: 'goal.summary';
+  readonly goalId: string | null;
+  readonly status: string | null;
+  readonly reason: string | null;
+  readonly turnsUsed: number | null;
+  readonly tokensUsed: number | null;
+  readonly wallClockMs: number | null;
+}
+
+export function goalSummaryJson(goal: GoalSnapshot | null): GoalSummary {
+  if (goal === null) {
+    return {
+      type: 'goal.summary',
+      goalId: null,
+      status: null,
+      reason: null,
+      turnsUsed: null,
+      tokensUsed: null,
+      wallClockMs: null,
+    };
+  }
+  return {
+    type: 'goal.summary',
+    goalId: goal.goalId,
+    status: goal.status,
+    reason: goal.terminalReason ?? null,
+    turnsUsed: goal.turnsUsed,
+    tokensUsed: goal.tokensUsed,
+    wallClockMs: goal.wallClockMs,
+  };
+}
+
+export function formatGoalSummaryText(goal: GoalSnapshot | null): string {
+  if (goal === null) return 'Goal: no goal found.';
+  const parts = [`Goal [${goal.status}]`];
+  if (goal.terminalReason !== undefined) parts.push(goal.terminalReason);
+  return `${parts.join(': ')} (turns: ${goal.turnsUsed}, tokens: ${goal.tokensUsed})`;
+}

apps/kimi-code/src/cli/run-prompt.ts

@@ -10,6 +10,7 @@ import {
   KimiHarness,
   log,
   type Event,
+  type GoalSnapshot,
   type HookResultEvent,
   type Session,
   type SessionStatus,
@@ -19,6 +20,13 @@ import {
 import { CLI_SHUTDOWN_TIMEOUT_MS } from '#/constant/app';
 
 import type { CLIOptions, PromptOutputFormat } from './options';
+import {
+  formatGoalSummaryText,
+  goalExitCode,
+  goalSummaryJson,
+  parseHeadlessGoalCreate,
+  type HeadlessGoalCreate,
+} from './goal-prompt';
 import { createCliTelemetryBootstrap, initializeCliTelemetry } from './telemetry';
 import { createKimiCodeHostIdentity } from './version';
 
@@ -102,16 +110,17 @@ export async function runPrompt(
   try {
     await harness.ensureConfigFile();
     const config = await harness.getConfig();
-    const { session, resumed, restorePermission, telemetryModel } = await resolvePromptSession(
-      harness,
-      opts,
-      workDir,
-      config.defaultModel,
-      stderr,
-      (restorePermission) => {
-        restorePromptSessionPermission = restorePermission;
-      },
-    );
+    const { session, resumed, restorePermission, telemetryModel, goalModel } =
+      await resolvePromptSession(
+        harness,
+        opts,
+        workDir,
+        config.defaultModel,
+        stderr,
+        (restorePermission) => {
+          restorePromptSessionPermission = restorePermission;
+        },
+      );
     restorePromptSessionPermission = restorePermission;
 
     initializeCliTelemetry({
@@ -132,7 +141,17 @@ export async function runPrompt(
     });
 
     const outputFormat = opts.outputFormat ?? 'text';
-    await runPromptTurn(session, opts.prompt!, outputFormat, stdout, stderr);
+    // Headless goal mode: `kimi -p "/goal <objective>"`. The goal driver keeps
+    // the turn-run alive across continuation turns, so the normal prompt-turn
+    // waiter blocks until the goal is terminal; we then emit a summary and set a
+    // distinct exit code.
+    const flagMap = await harness.getExperimentalFlags();
+    const goalCreate = parseHeadlessGoalCreate(opts.prompt!, flagMap['goal-command'] === true);
+    if (goalCreate !== undefined) {
+      await runHeadlessGoal(session, goalCreate, goalModel, outputFormat, stdout, stderr);
+    } else {
+      await runPromptTurn(session, opts.prompt!, outputFormat, stdout, stderr);
+    }
     writeResumeHint(session.id, outputFormat, stdout, stderr);
 
     withTelemetryContext({ sessionId: session.id }).track('exit', {
@@ -143,11 +162,55 @@ export async function runPrompt(
   }
 }
 
+async function runHeadlessGoal(
+  session: Session,
+  goal: HeadlessGoalCreate,
+  model: string | undefined,
+  outputFormat: PromptOutputFormat,
+  stdout: PromptOutput,
+  stderr: PromptOutput,
+): Promise<void> {
+  requireConfiguredModel(model);
+  await session.createGoal({
+    objective: goal.objective,
+    replace: goal.replace,
+  });
+  let completedSnapshot: GoalSnapshot | null = null;
+  const unsubscribeGoalEvents = session.onEvent((event) => {
+    if (
+      event.type === 'goal.updated' &&
+      event.change?.kind === 'completion' &&
+      event.snapshot !== null
+    ) {
+      completedSnapshot = event.snapshot;
+    }
+  });
+  try {
+    // The objective is sent as the normal prompt; goal continuation keeps the
+    // turn alive until a terminal state is reached.
+    await runPromptTurn(session, goal.objective, outputFormat, stdout, stderr);
+  } finally {
+    unsubscribeGoalEvents();
+    const snapshot = completedSnapshot ?? (await session.getGoal()).goal;
+    if (outputFormat === 'stream-json') {
+      stdout.write(`${JSON.stringify(goalSummaryJson(snapshot))}\n`);
+    } else {
+      stderr.write(`${formatGoalSummaryText(snapshot)}\n`);
+    }
+    // Map the terminal goal status to a distinct, non-fatal exit code. A turn
+    // that threw (error / cancellation) already propagates its own exit path.
+    if (snapshot !== null && snapshot.status !== 'complete') {
+      process.exitCode = goalExitCode(snapshot.status);
+    }
+  }
+}
+
 interface ResolvedPromptSession {
   readonly session: Session;
   readonly resumed: boolean;
   readonly restorePermission: () => Promise<void>;
   readonly telemetryModel?: string;
+  readonly goalModel?: string;
 }
 
 async function resolvePromptSession(
@@ -191,6 +254,7 @@ async function resolvePromptSession(
       resumed: true,
       restorePermission,
       telemetryModel: configuredModel(opts.model, status.model, defaultModel),
+      goalModel: configuredModel(opts.model, status.model),
     };
   }
 
@@ -214,6 +278,7 @@ async function resolvePromptSession(
         resumed: true,
         restorePermission,
         telemetryModel: configuredModel(opts.model, status.model, defaultModel),
+        goalModel: configuredModel(opts.model, status.model),
       };
     }
     stderr.write(`No sessions to continue under "${workDir}"; starting a fresh session.\n`);
@@ -222,7 +287,13 @@ async function resolvePromptSession(
   const model = requireConfiguredModel(opts.model, defaultModel);
   const session = await harness.createSession({ workDir, model, permission: 'auto' });
   installHeadlessHandlers(session);
-  return { session, resumed: false, restorePermission: async () => {}, telemetryModel: model };
+  return {
+    session,
+    resumed: false,
+    restorePermission: async () => {},
+    telemetryModel: model,
+    goalModel: model,
+  };
 }
 
 async function forcePromptPermission(

apps/kimi-code/src/tui/commands/complete-args.ts

@@ -0,0 +1,41 @@
+import type { AutocompleteItem } from '@earendil-works/pi-tui';
+
+/**
+ * A completable token (subcommand or flag) for a slash command's argument
+ * position. Generic across commands — any `KimiSlashCommand` can build a
+ * `getArgumentCompletions` from a list of these via {@link completeLeadingArg}.
+ */
+export interface ArgCompletionSpec {
+  /** The token inserted on completion, e.g. `pause` or `resume`. */
+  readonly value: string;
+  /** Short description shown in the autocomplete menu. */
+  readonly description: string;
+}
+
+/**
+ * Generic leading-token completer for slash-command arguments.
+ *
+ * pi-tui passes `argumentPrefix` = everything typed after `/<command> `. We only
+ * complete the *first* token: once the user has typed a space after it (moved on
+ * to an objective, a flag value, etc.) we return `null` so completion never
+ * clobbers free text. Matching is case-insensitive prefix match on `value`.
+ */
+export function completeLeadingArg(
+  specs: readonly ArgCompletionSpec[],
+  argumentPrefix: string,
+): AutocompleteItem[] | null {
+  if (argumentPrefix.includes(' ')) return null;
+  const lower = argumentPrefix.toLowerCase();
+  const items = specs
+    .filter((spec) => spec.value.toLowerCase().startsWith(lower))
+    .map((spec) => ({ value: spec.value, label: spec.value, description: spec.description }));
+  // Nothing left to complete: the user has finished typing a token that is the
+  // sole remaining match (e.g. `status`). Keeping the menu open here would make
+  // Enter confirm the no-op completion instead of submitting the command, so we
+  // suppress it. (A space after the token already returns null above.)
+  const [only] = items;
+  if (items.length === 1 && only !== undefined && only.value.toLowerCase() === lower) {
+    return null;
+  }
+  return items.length > 0 ? items : null;
+}

apps/kimi-code/src/tui/commands/dispatch.ts

@@ -34,6 +34,7 @@ import {
   showPermissionPicker,
   showSettingsSelector,
 } from './config';
+import { handleGoalCommand } from './goal';
 import { handleProviderCommand } from './provider';
 import { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
 import { handlePluginsCommand } from './plugins';
@@ -73,6 +74,7 @@ export {
   showUsage,
 } from './info';
 export { handlePluginsCommand } from './plugins';
+export { handleGoalCommand } from './goal';
 export {
   handleExportDebugZipCommand,
   handleExportMdCommand,
@@ -101,6 +103,7 @@ export interface SlashCommandHost {
   track(event: string, props?: Record<string, unknown>): void;
   mountEditorReplacement(panel: Component & Focusable): void;
   restoreEditor(): void;
+  restoreInputText(text: string): void;
 
   // Session
   requireSession(): Session;
@@ -270,6 +273,9 @@ async function handleBuiltInSlashCommand(
     case 'compact':
       await handleCompactCommand(host, args);
       return;
+    case 'goal':
+      await handleGoalCommand(host, args);
+      return;
     case 'init':
       await handleInitCommand(host);
       return;