takomi 2.0.6 → 2.1.0

package/.pi/extensions/oauth-router/state.ts

@@ -0,0 +1,174 @@
+import { existsSync, readFileSync } from "node:fs";
+import { STATE_PATH, writeJsonFile } from "./config.ts";
+import type { RouterAccountState, RouterRuntimeState, RoutingPolicyName } from "./types.ts";
+
+const DEFAULT_STATE: RouterRuntimeState = {
+  version: 1,
+  policy: "round-robin",
+  rrCursor: 0,
+  weightedCursor: 0,
+  accounts: {},
+};
+
+function normalizeAccountState(accountId: string, input?: Partial<RouterAccountState>): RouterAccountState {
+  return {
+    accountId,
+    authHealth: input?.authHealth === "invalid" ? "invalid" : "ok",
+    cooldownUntil: Number.isFinite(input?.cooldownUntil) ? input?.cooldownUntil : undefined,
+    penaltyUntil: Number.isFinite(input?.penaltyUntil) ? input?.penaltyUntil : undefined,
+    lastUsedAt: Number.isFinite(input?.lastUsedAt) ? input?.lastUsedAt : undefined,
+    lastTriedAt: Number.isFinite(input?.lastTriedAt) ? input?.lastTriedAt : undefined,
+    lastModel: typeof input?.lastModel === "string" ? input.lastModel : undefined,
+    lastStatus: Number.isFinite(input?.lastStatus) ? input?.lastStatus : undefined,
+    lastError: typeof input?.lastError === "string" ? input.lastError : undefined,
+    failures: Number.isFinite(input?.failures) ? input!.failures! : 0,
+    rateLimitCount: Number.isFinite(input?.rateLimitCount) ? input!.rateLimitCount! : 0,
+    authFailureCount: Number.isFinite(input?.authFailureCount) ? input!.authFailureCount! : 0,
+    successCount: Number.isFinite(input?.successCount) ? input!.successCount! : 0,
+  };
+}
+
+export class RouterStateStore {
+  private data: RouterRuntimeState;
+
+  constructor(initialPolicy: RoutingPolicyName) {
+    this.data = this.load(initialPolicy);
+  }
+
+  private load(initialPolicy: RoutingPolicyName): RouterRuntimeState {
+    if (!existsSync(STATE_PATH)) {
+      const initial = { ...DEFAULT_STATE, policy: initialPolicy } satisfies RouterRuntimeState;
+      writeJsonFile(STATE_PATH, initial, true);
+      return initial;
+    }
+
+    try {
+      const parsed = JSON.parse(readFileSync(STATE_PATH, "utf8")) as Partial<RouterRuntimeState>;
+      const accounts = Object.fromEntries(
+        Object.entries(parsed.accounts ?? {}).map(([accountId, state]) => [accountId, normalizeAccountState(accountId, state)]),
+      );
+      return {
+        version: 1,
+        policy:
+          parsed.policy === "weighted-round-robin" || parsed.policy === "round-robin" ? parsed.policy : initialPolicy,
+        rrCursor: Number.isFinite(parsed.rrCursor) ? parsed.rrCursor : 0,
+        weightedCursor: Number.isFinite(parsed.weightedCursor) ? parsed.weightedCursor : 0,
+        accounts,
+      };
+    } catch {
+      const initial = { ...DEFAULT_STATE, policy: initialPolicy } satisfies RouterRuntimeState;
+      writeJsonFile(STATE_PATH, initial, true);
+      return initial;
+    }
+  }
+
+  private save() {
+    writeJsonFile(STATE_PATH, this.data, true);
+  }
+
+  snapshot(): RouterRuntimeState {
+    return JSON.parse(JSON.stringify(this.data)) as RouterRuntimeState;
+  }
+
+  getPolicy(defaultPolicy: RoutingPolicyName): RoutingPolicyName {
+    if (this.data.policy !== "round-robin" && this.data.policy !== "weighted-round-robin") {
+      this.data.policy = defaultPolicy;
+      this.save();
+    }
+    return this.data.policy;
+  }
+
+  setPolicy(policy: RoutingPolicyName) {
+    this.data.policy = policy;
+    this.save();
+  }
+
+  getCursor(policy: RoutingPolicyName): number {
+    return policy === "weighted-round-robin" ? this.data.weightedCursor : this.data.rrCursor;
+  }
+
+  advanceCursor(policy: RoutingPolicyName, next: number) {
+    if (policy === "weighted-round-robin") {
+      this.data.weightedCursor = next;
+    } else {
+      this.data.rrCursor = next;
+    }
+    this.save();
+  }
+
+  ensureAccount(accountId: string): RouterAccountState {
+    if (!this.data.accounts[accountId]) {
+      this.data.accounts[accountId] = normalizeAccountState(accountId);
+      this.save();
+    }
+    return this.data.accounts[accountId]!;
+  }
+
+  pruneAccountIds(validIds: string[]) {
+    const valid = new Set(validIds);
+    for (const id of Object.keys(this.data.accounts)) {
+      if (!valid.has(id)) delete this.data.accounts[id];
+    }
+    this.save();
+  }
+
+  markAttempt(accountId: string, modelId: string) {
+    const account = this.ensureAccount(accountId);
+    account.lastTriedAt = Date.now();
+    account.lastModel = modelId;
+    this.save();
+  }
+
+  markSuccess(accountId: string, status?: number) {
+    const account = this.ensureAccount(accountId);
+    account.authHealth = "ok";
+    account.lastUsedAt = Date.now();
+    account.lastStatus = status;
+    account.lastError = undefined;
+    account.penaltyUntil = undefined;
+    account.failures = 0;
+    account.successCount += 1;
+    this.save();
+  }
+
+  markRateLimit(accountId: string, retryAfterMs: number, status = 429, message = "Rate limited") {
+    const account = this.ensureAccount(accountId);
+    const now = Date.now();
+    account.lastStatus = status;
+    account.lastError = message;
+    account.cooldownUntil = now + Math.max(1_000, retryAfterMs);
+    account.failures += 1;
+    account.rateLimitCount += 1;
+    this.save();
+  }
+
+  markAuthFailure(accountId: string, status = 401, message = "Authentication failed") {
+    const account = this.ensureAccount(accountId);
+    account.authHealth = "invalid";
+    account.lastStatus = status;
+    account.lastError = message;
+    account.failures += 1;
+    account.authFailureCount += 1;
+    account.cooldownUntil = undefined;
+    account.penaltyUntil = undefined;
+    this.save();
+  }
+
+  markTransientFailure(accountId: string, penaltyMs: number, status = 500, message = "Transient upstream failure") {
+    const account = this.ensureAccount(accountId);
+    account.lastStatus = status;
+    account.lastError = message;
+    account.penaltyUntil = Date.now() + Math.max(1_000, penaltyMs);
+    account.failures += 1;
+    this.save();
+  }
+
+  clearHealth(accountId: string) {
+    const account = this.ensureAccount(accountId);
+    account.authHealth = "ok";
+    account.cooldownUntil = undefined;
+    account.penaltyUntil = undefined;
+    account.lastError = undefined;
+    this.save();
+  }
+}

package/.pi/extensions/oauth-router/types.ts

@@ -0,0 +1,153 @@
+import type { Api, AssistantMessage, Context, Model, SimpleStreamOptions } from "@mariozechner/pi-ai";
+
+export type RouterUpstreamApi = "openai-completions" | "openai-responses" | "openai-codex-responses";
+export type RouterAuthMode = "oauth" | "api-key";
+export type RoutingPolicyName = "round-robin" | "weighted-round-robin";
+export type AuthHealth = "ok" | "invalid";
+
+export interface RouterModelConfig {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: Array<"text" | "image">;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  compat?: Record<string, unknown>;
+  route?: {
+    upstreamIds?: string[];
+  };
+}
+
+export interface RouterUpstreamConfig {
+  id: string;
+  label: string;
+  description?: string;
+  baseUrl: string;
+  api: RouterUpstreamApi;
+  authMode: RouterAuthMode;
+  oauthProviderId?: string;
+  enabled: boolean;
+  modelIds: string[];
+  headers?: Record<string, string>;
+}
+
+export interface RouterConfig {
+  version: 1;
+  providerName: "oauth-router";
+  policy: RoutingPolicyName;
+  tokenRefreshSkewMs: number;
+  rateLimitCooldownMs: number;
+  transientPenaltyMs: number;
+  models: RouterModelConfig[];
+  upstreams: RouterUpstreamConfig[];
+}
+
+export interface StoredRouterAccount {
+  id: string;
+  label: string;
+  provider: string;
+  upstreamId: string;
+  access: string;
+  refresh: string;
+  expires: number;
+  enabled: boolean;
+  weight: number;
+  createdAt: number;
+  updatedAt: number;
+  meta?: Record<string, unknown>;
+}
+
+export interface RouterCredentialStore {
+  version: 1;
+  accounts: StoredRouterAccount[];
+}
+
+export interface RouterAccountState {
+  accountId: string;
+  authHealth: AuthHealth;
+  cooldownUntil?: number;
+  penaltyUntil?: number;
+  lastUsedAt?: number;
+  lastTriedAt?: number;
+  lastModel?: string;
+  lastStatus?: number;
+  lastError?: string;
+  failures: number;
+  rateLimitCount: number;
+  authFailureCount: number;
+  successCount: number;
+}
+
+export interface RouterRuntimeState {
+  version: 1;
+  policy: RoutingPolicyName;
+  rrCursor: number;
+  weightedCursor: number;
+  accounts: Record<string, RouterAccountState>;
+}
+
+export interface RouterStatusRow {
+  id: string;
+  label: string;
+  upstream: string;
+  provider: string;
+  enabled: boolean;
+  weight: number;
+  authHealth: AuthHealth;
+  cooldownUntil?: number;
+  penaltyUntil?: number;
+  lastUsedAt?: number;
+  lastStatus?: number;
+  failures: number;
+  rateLimitCount: number;
+  authFailureCount: number;
+  successCount: number;
+  expires: number;
+}
+
+export interface EligibleAccount {
+  account: StoredRouterAccount;
+  upstream: RouterUpstreamConfig;
+  modelConfig: RouterModelConfig;
+  state: RouterAccountState;
+}
+
+export interface DelegateSelection {
+  account: StoredRouterAccount;
+  upstream: RouterUpstreamConfig;
+  modelConfig: RouterModelConfig;
+  apiKey: string;
+  headers: Record<string, string>;
+  delegatedModel: Model<Api>;
+}
+
+export interface FailureClassification {
+  kind: "rate-limit" | "auth" | "transient" | "fatal";
+  status?: number;
+  retryAfterMs?: number;
+  message: string;
+}
+
+export interface StreamAttemptResult {
+  completed: boolean;
+  emittedMeaningfulOutput: boolean;
+  failure?: FailureClassification;
+}
+
+export interface RouterStreamInput {
+  model: Model<Api>;
+  context: Context;
+  options?: SimpleStreamOptions;
+}
+
+export interface RouterErrorMessageInput {
+  model: Model<Api>;
+  message: string;
+  stopReason?: AssistantMessage["stopReason"];
+}

package/.pi/extensions/takomi-runtime/command-text.ts

@@ -0,0 +1,130 @@
+import type { VibeLifecycleStage } from "../../../src/pi-takomi-core";
+import type { TakomiRuntimeCommandState } from "./commands";
+import type { TakomiSubagentController } from "./subagent-types";
+
+export type TakomiCompletion = {
+  value: string;
+  label: string;
+  description: string;
+};
+
+const ROOT_COMPLETIONS: TakomiCompletion[] = [
+  { value: "genesis", label: "genesis", description: "Run the Genesis planning stage" },
+  { value: "design", label: "design", description: "Run UI/UX design from approved scope" },
+  { value: "build", label: "build", description: "Implement against the agreed UI" },
+  { value: "plan", label: "plan", description: "Create or update the orchestration plan" },
+  { value: "mode", label: "mode", description: "Set direct, orchestrate, or review mode" },
+  { value: "gate", label: "gate", description: "Set auto or review-gated execution" },
+  { value: "subagents", label: "subagents", description: "Control subagent usage and view" },
+  { value: "routing", label: "routing", description: "Install/update Takomi model routing policy" },
+];
+
+const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
+  mode: [
+    { value: "direct", label: "direct", description: "Handle work directly unless delegation is explicit" },
+    { value: "orchestrate", label: "orchestrate", description: "Plan and delegate broad work" },
+    { value: "review", label: "review", description: "Inspect outputs and route fixes" },
+  ],
+  gate: [
+    { value: "review", label: "review", description: "Return to the user after each task" },
+    { value: "auto", label: "auto", description: "Continue approved plans automatically" },
+  ],
+  subagents: [
+    { value: "status", label: "status", description: "Show active subagents" },
+    { value: "on", label: "on", description: "Allow subagent delegation" },
+    { value: "off", label: "off", description: "Disable subagent delegation" },
+    { value: "expand", label: "expand", description: "Expand native tool results" },
+    { value: "collapse", label: "collapse", description: "Collapse native tool results" },
+    { value: "toggle", label: "toggle", description: "Toggle native tool result expansion" },
+  ],
+};
+
+const SUBCOMMAND_ALIASES: Record<string, string> = {
+  subagent: "subagents",
+};
+
+function normalizeSubcommand(value: string): string {
+  return SUBCOMMAND_ALIASES[value] ?? value;
+}
+
+function matchesToken(completion: TakomiCompletion, token: string): boolean {
+  const lowered = token.toLowerCase();
+  return !lowered || completion.value.toLowerCase().startsWith(lowered) || completion.label.toLowerCase().startsWith(lowered);
+}
+
+function withArgumentPrefix(parent: string, completions: TakomiCompletion[], token: string): TakomiCompletion[] {
+  return completions
+    .filter((completion) => matchesToken(completion, token))
+    .map((completion) => ({
+      ...completion,
+      value: `${parent} ${completion.value}`,
+    }));
+}
+
+export function commandHelp(): string {
+  return [
+    "Takomi commands:",
+    "/takomi genesis [prompt]",
+    "/takomi design [prompt]",
+    "/takomi build [prompt]",
+    "/takomi plan [title]",
+    "/takomi mode <direct|orchestrate|review>",
+    "/takomi gate <auto|review>",
+    "/takomi subagents <on|off|status|expand|collapse|toggle>",
+    "/takomi routing <policy text>",
+    "/takomi-status",
+    "/takomi-reset",
+  ].join("\n");
+}
+
+export function workflowPrompt(stage: VibeLifecycleStage, suppliedPrompt?: string): string {
+  const suffix = suppliedPrompt?.trim() ? `\n\nPrompt: ${suppliedPrompt.trim()}` : "";
+  const lines = {
+    genesis: [
+      "Takomi Genesis is active.",
+      "Use existing markdown/project context when no extra prompt is supplied.",
+      "Strictly follow the Genesis playbook: clarify scope, create or update planning docs, and do not implement code yet.",
+    ],
+    design: [
+      "Takomi Design is active.",
+      "Focus on UI/UX only: agreed screens, visual direction, interaction states, mockups, and build constraints.",
+      "Do not drift into route/API architecture unless the user explicitly asks.",
+    ],
+    build: [
+      "Takomi Build is active.",
+      "Implement against the approved UI and continuously cross-check code against design artifacts and acceptance criteria.",
+    ],
+  }[stage];
+  return [...lines, suffix].filter(Boolean).join("\n");
+}
+
+export function statusText(state: TakomiRuntimeCommandState, subagentController: TakomiSubagentController): string {
+  return [
+    `Takomi: ${state.enabled ? "on" : "off"}`,
+    `Mode: ${state.role}`,
+    `Stage: ${state.stage ?? "-"}`,
+    `Workflow: ${state.workflow ?? "-"}`,
+    `Plan bias: ${state.planMode ? "on" : "off"}`,
+    `Execution gate: ${state.launchMode === "manual" ? "review" : "auto"}`,
+    `Subagents: ${state.subagentsEnabled ? "on" : "off"}`,
+    state.activeSessionId ? `Session: ${state.activeSessionId}` : "",
+    "",
+    subagentController.getStatusSummary(),
+  ].filter(Boolean).join("\n");
+}
+
+export function completions(argumentPrefix: string): TakomiCompletion[] {
+  const input = argumentPrefix.trimStart();
+  const parts = input.split(/\s+/).filter(Boolean);
+  const hasTrailingSpace = /\s$/.test(input);
+
+  if (parts.length === 0) return ROOT_COMPLETIONS;
+  if (parts.length === 1 && !hasTrailingSpace) {
+    return ROOT_COMPLETIONS.filter((completion) => matchesToken(completion, parts[0]));
+  }
+
+  const parent = normalizeSubcommand(parts[0]);
+  const nested = SUBCOMMAND_COMPLETIONS[parent] ?? [];
+  const token = hasTrailingSpace ? "" : parts[parts.length - 1] ?? "";
+  return withArgumentPrefix(parent, nested, token);
+}

package/.pi/extensions/takomi-runtime/commands.ts

@@ -0,0 +1,179 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type {
+  TakomiLaunchMode,
+  TakomiRole,
+  TakomiWorkflowId,
+  VibeLifecycleStage,
+} from "../../../src/pi-takomi-core";
+import { commandHelp, completions, statusText, workflowPrompt } from "./command-text";
+import type { TakomiSubagentController } from "./subagent-types";
+import { installTakomiRoutingPolicy } from "./routing-policy";
+
+export type TakomiRuntimeCommandState = {
+  enabled: boolean;
+  autoOrch: boolean;
+  launchMode: TakomiLaunchMode;
+  planMode: boolean;
+  role: TakomiRole;
+  stage?: VibeLifecycleStage;
+  workflow?: TakomiWorkflowId;
+  activeSessionId?: string;
+  subagentsEnabled: boolean;
+};
+
+type RegisterTakomiCommandOptions = {
+  getState(): TakomiRuntimeCommandState;
+  updateState(ctx: ExtensionContext, mutator: () => void, message?: string | (() => string)): Promise<void>;
+  resetRuntime(ctx: ExtensionCommandContext): Promise<void>;
+  setStageAndWorkflow(stage: VibeLifecycleStage, options?: { preserveRole?: boolean }): void;
+  createPlanSession(ctx: ExtensionCommandContext, title?: string): Promise<string>;
+  hasGenesisArtifacts(cwd: string): Promise<boolean>;
+  subagentController: TakomiSubagentController;
+};
+
+export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomiCommandOptions): void {
+  async function handleStage(ctx: ExtensionCommandContext, stage: VibeLifecycleStage, prompt?: string): Promise<void> {
+    await options.updateState(ctx, () => {
+      options.getState().enabled = true;
+      options.setStageAndWorkflow(stage, { preserveRole: stage === "genesis" && options.getState().role === "orchestrator" });
+      options.getState().planMode = stage !== "build";
+    }, workflowPrompt(stage, prompt));
+  }
+
+  async function handleMode(ctx: ExtensionCommandContext, mode?: string): Promise<void> {
+    if (mode !== "direct" && mode !== "orchestrate" && mode !== "review") {
+      ctx.ui.notify("Usage: /takomi mode <direct|orchestrate|review>", "warning");
+      return;
+    }
+    const hasGenesis = await options.hasGenesisArtifacts(ctx.cwd);
+    await options.updateState(ctx, () => {
+      const state = options.getState();
+      state.enabled = true;
+      if (mode === "direct") {
+        state.autoOrch = false;
+        state.planMode = false;
+        state.role = "general";
+      } else if (mode === "orchestrate") {
+        state.autoOrch = true;
+        state.planMode = true;
+        state.role = "orchestrator";
+        state.stage = hasGenesis ? "build" : "genesis";
+        state.workflow = hasGenesis ? "vibe-build" : "vibe-genesis";
+      } else {
+        state.autoOrch = false;
+        state.planMode = true;
+        state.launchMode = "manual";
+        state.role = "review";
+      }
+    }, () => `Takomi mode set to ${mode}`);
+  }
+
+  async function handleGate(ctx: ExtensionCommandContext, gate?: string): Promise<void> {
+    if (gate !== "auto" && gate !== "review") {
+      ctx.ui.notify("Usage: /takomi gate <auto|review>", "warning");
+      return;
+    }
+    await options.updateState(ctx, () => {
+      const state = options.getState();
+      state.enabled = true;
+      state.launchMode = gate === "review" ? "manual" : "auto";
+      state.autoOrch = gate === "auto";
+    }, () => `Takomi execution gate set to ${gate}`);
+  }
+
+  async function handleRouting(ctx: ExtensionCommandContext, body?: string): Promise<void> {
+    if (!body?.trim()) {
+      ctx.ui.notify("Usage: /takomi routing <policy text>\nTip: paste the policy after the command, or say: Update Takomi routing logic: \"\"\"...\"\"\"", "warning");
+      return;
+    }
+    try {
+      const result = await installTakomiRoutingPolicy(ctx.cwd, body);
+      const detected = result.detectedDefaults.length ? `\n\nDetected defaults:\n- ${result.detectedDefaults.join("\n- ")}` : "\n\nNo model names were auto-detected; saved policy only.";
+      ctx.ui.notify(`Takomi routing policy updated.\n\nPolicy: ${result.policyPath}\nSettings: ${result.settingsPath}${detected}`, "info");
+    } catch (error) {
+      ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+    }
+  }
+
+  async function handleSubagents(ctx: ExtensionCommandContext, action?: string): Promise<void> {
+    const controller = options.subagentController;
+    if (action === "on" || action === "off") {
+      await options.updateState(ctx, () => {
+        options.getState().subagentsEnabled = action === "on";
+      }, `Takomi subagents ${action}`);
+      return;
+    }
+    if (action === "status" || !action) {
+      ctx.ui.notify(statusText(options.getState(), controller), controller.hasRuns() ? "info" : "warning");
+      return;
+    }
+    if (action === "expand" || action === "fullscreen") {
+      ctx.ui.setToolsExpanded(true);
+      ctx.ui.notify("Expanded native tool results for Takomi subagent output.", "info");
+      return;
+    }
+    if (action === "collapse") {
+      ctx.ui.setToolsExpanded(false);
+      ctx.ui.notify("Collapsed native tool results.", "info");
+      return;
+    }
+    if (action === "toggle") {
+      const expanded = !ctx.ui.getToolsExpanded();
+      ctx.ui.setToolsExpanded(expanded);
+      ctx.ui.notify(`${expanded ? "Expanded" : "Collapsed"} native tool results.`, "info");
+      return;
+    }
+    if (action === "next" || action === "prev") {
+      ctx.ui.notify("Takomi now uses Pi's native inline result UI. Subagent navigation is handled by the transcript/tool results.", "info");
+      return;
+    }
+    ctx.ui.notify("Usage: /takomi subagents <on|off|status|expand|collapse|toggle>", "warning");
+  }
+
+  pi.registerCommand("takomi", {
+    description: "Takomi lifecycle entrypoint",
+    getArgumentCompletions: completions,
+    handler: async (args, ctx) => {
+      const [subcommand = "", ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      const tail = rest.join(" ");
+      if (!subcommand) {
+        await options.updateState(ctx, () => {
+          options.getState().enabled = true;
+        }, commandHelp());
+        return;
+      }
+      if (subcommand === "genesis") return handleStage(ctx, "genesis", tail);
+      if (subcommand === "design") return handleStage(ctx, "design", tail);
+      if (subcommand === "build") return handleStage(ctx, "build", tail);
+      if (subcommand === "plan" || subcommand === "kickoff" || subcommand === "lifecycle" || subcommand === "autoorch") {
+        const summary = await options.createPlanSession(ctx, tail || undefined);
+        ctx.ui.notify(summary, "info");
+        return;
+      }
+      if (subcommand === "mode") return handleMode(ctx, rest[0]);
+      if (subcommand === "gate") return handleGate(ctx, rest[0]);
+      if (subcommand === "routing" || subcommand === "route" || subcommand === "models") return handleRouting(ctx, tail);
+      if (subcommand === "subagents" || subcommand === "subagent") return handleSubagents(ctx, rest[0]);
+      if (subcommand === "status") {
+        ctx.ui.notify(statusText(options.getState(), options.subagentController), "info");
+        return;
+      }
+      if (subcommand === "reset") return options.resetRuntime(ctx);
+      ctx.ui.notify(commandHelp(), "warning");
+    },
+  });
+
+  pi.registerCommand("takomi-status", {
+    description: "Show Takomi lifecycle, gate, session, and subagent status",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(statusText(options.getState(), options.subagentController), "info");
+    },
+  });
+
+  pi.registerCommand("takomi-reset", {
+    description: "Reset Takomi runtime state to defaults",
+    handler: async (_args, ctx) => {
+      await options.resetRuntime(ctx);
+    },
+  });
+}