march-cli 0.1.0

package/src/agent/turn/turn-runner.mjs

@@ -0,0 +1,103 @@
+import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
+import { closeAssistantReply, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
+
+export async function runRunnerTurn({
+  prompt,
+  userMessage,
+  options = {},
+  sessionBinding,
+  engine,
+  ui,
+  projectMarchDir,
+  memoryStore,
+  setModelCallKind,
+  onMidTurnRecallHints,
+  syncCurrentPiSidecar,
+  autoNameSession,
+  contextMode = "rebuild",
+}) {
+  const { userRecallHints = [], currentProject = "" } = options;
+  const activeSession = sessionBinding.get();
+  const turnState = createTurnEventState();
+  const midTurnRecallHints = [];
+  ui.turnStart();
+
+  const unsubscribe = activeSession.subscribe((event) => {
+    handleRunnerSessionEvent(event, { ui, engine, state: turnState });
+    if (event.type === "tool_execution_end") {
+      const hints = recallForAssistantState({ memoryStore, engine, turnState, currentProject });
+      if (hints.length > 0) {
+        midTurnRecallHints.push(...hints);
+        onMidTurnRecallHints?.(hints);
+        ui.memoryHint?.({ source: "assistant", hints });
+      }
+    }
+  });
+
+  try {
+    const attachmentReferences = resolveImageAttachmentReferences({
+      text: userMessage ?? prompt,
+      projectMarchDir,
+    });
+    setModelCallKind("user");
+    try {
+      if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
+      await activeSession.prompt(
+        contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
+        attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
+      );
+    } finally {
+      setModelCallKind("model");
+    }
+
+    closeAssistantReply({ ui, state: turnState });
+    const assistantRecallHints = recallForAssistantState({ memoryStore, engine, turnState, currentProject });
+    ui.memoryHint?.({ source: "assistant", hints: assistantRecallHints });
+    const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
+
+    engine.recordTurn({
+      userMessage: userMessage ?? prompt.slice(0, 300),
+      assistantMessage: turnState.draft,
+      userRecallHints,
+      assistantRecallHints: recordedAssistantRecallHints,
+    });
+
+    autoNameSession?.();
+    syncCurrentPiSidecar();
+    return { draft: turnState.draft };
+  } finally {
+    ui.turnEnd();
+    unsubscribe();
+  }
+}
+
+function recallForAssistantState({ memoryStore, engine, turnState, currentProject }) {
+  if (!memoryStore) return [];
+  return memoryStore.recallForAssistant(assistantRecallText(turnState), {
+    currentProject,
+    excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
+  });
+}
+
+function assistantRecallText(turnState) {
+  return [turnState.draft, turnState.thinkingAccumulator, turnState.thinkingText]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function uniqueHints(hints) {
+  const seen = new Set();
+  const unique = [];
+  for (const hint of hints) {
+    if (!hint?.id || seen.has(hint.id)) continue;
+    seen.add(hint.id);
+    unique.push(hint);
+  }
+  return unique;
+}
+
+function resetPiMessageHistory(session) {
+  if (Array.isArray(session?.agent?.state?.messages)) {
+    session.agent.state.messages = [];
+  }
+}

package/src/auth/login-command.mjs

@@ -0,0 +1,90 @@
+import { createInterface } from "node:readline";
+import { homedir } from "node:os";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+import { getMarchAuthPath } from "./storage.mjs";
+
+export async function runLoginCommand({
+  providerId,
+  homeDir = homedir(),
+  authPath = getMarchAuthPath(homeDir),
+  authStorage = AuthStorage.create(authPath),
+  input = process.stdin,
+  output = process.stdout,
+} = {}) {
+  const providers = authStorage.getOAuthProviders?.() ?? [];
+  const selectedProvider = providerId || await selectProvider({ providers, input, output });
+  if (!selectedProvider) {
+    output.write("Login cancelled.\n");
+    return 1;
+  }
+
+  if (!providers.some((provider) => provider.id === selectedProvider)) {
+    output.write(`Unknown OAuth provider: ${selectedProvider}\n`);
+    output.write(formatProviderList(providers));
+    return 1;
+  }
+
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`Logging in to ${selectedProvider}...\n`);
+    await authStorage.login(selectedProvider, {
+      onAuth: (info) => {
+        output.write(`\nOpen this URL in your browser:\n${info.url}\n`);
+        if (info.instructions) output.write(`${info.instructions}\n`);
+        output.write("\n");
+      },
+      onPrompt: (prompt) => ask(rl, `${prompt.message}${prompt.placeholder ? ` (${prompt.placeholder})` : ""}: `),
+      onManualCodeInput: () => ask(rl, "Paste redirect URL or code: "),
+      onProgress: (message) => output.write(`${message}\n`),
+      onSelect: async (prompt) => selectOption({ prompt, rl, output }),
+    });
+    output.write(`\nCredentials saved to ${authPath}\n`);
+    return 0;
+  } finally {
+    rl.close();
+  }
+}
+
+export function formatProviderList(providers) {
+  if (!providers.length) return "No OAuth providers are available.\n";
+  const lines = ["Available OAuth providers:"];
+  for (const provider of providers) {
+    lines.push(`  ${provider.id.padEnd(20)} ${provider.name}`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+async function selectProvider({ providers, input, output }) {
+  if (providers.length === 1) return providers[0].id;
+  output.write(`${formatProviderList(providers)}\n`);
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await ask(rl, `Enter provider id or number (1-${providers.length}): `);
+    return resolveSelection(answer, providers.map((provider) => ({ id: provider.id, label: provider.name })));
+  } finally {
+    rl.close();
+  }
+}
+
+async function selectOption({ prompt, rl, output }) {
+  output.write(`${prompt.message}\n`);
+  for (let i = 0; i < prompt.options.length; i++) {
+    const option = prompt.options[i];
+    output.write(`  ${i + 1}. ${option.label} (${option.id})\n`);
+  }
+  const answer = await ask(rl, `Enter option id or number (1-${prompt.options.length}): `);
+  return resolveSelection(answer, prompt.options);
+}
+
+function resolveSelection(answer, options) {
+  const trimmed = answer.trim();
+  const index = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(index) && String(index) === trimmed && index >= 1 && index <= options.length) {
+    return options[index - 1].id;
+  }
+  return options.some((option) => option.id === trimmed) ? trimmed : undefined;
+}
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}

package/src/auth/storage.mjs

@@ -0,0 +1,33 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+
+export function getMarchAuthPath(homeDir = homedir()) {
+  return resolve(homeDir, ".march", "auth.json");
+}
+
+export function createMarchAuthStorage({
+  providers = {},
+  homeDir = homedir(),
+  authStorage = null,
+} = {}) {
+  const resolvedAuthStorage = authStorage ?? AuthStorage.create(getMarchAuthPath(homeDir));
+
+  for (const profile of Object.values(providers ?? {})) {
+    if (!profile || typeof profile !== "object") continue;
+    const type = profile.type ?? profile.provider;
+    const profileKey = profile.auth?.method === "apiKey" ? profile.auth?.apiKey : null;
+    if (type && profileKey) resolvedAuthStorage.setRuntimeApiKey(type, profileKey);
+  }
+  const hasStoredAuth = Boolean(resolvedAuthStorage.list?.().length);
+  const hasConfiguredProvider = Object.values(providers ?? {}).some((profile) => {
+    if (!profile || typeof profile !== "object") return false;
+    return Boolean(profile.auth?.apiKey);
+  });
+  return {
+    authStorage: resolvedAuthStorage,
+    authPath: getMarchAuthPath(homeDir),
+    hasAuth: hasStoredAuth || hasConfiguredProvider,
+    diagnostics: [],
+  };
+}

package/src/cli/args.mjs

@@ -0,0 +1,71 @@
+import { parseArgs } from "node:util";
+
+export function parseCliArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      model: { type: "string", short: "m" },
+      provider: { type: "string" },
+      resume: { type: "string" },
+      json: { type: "boolean" },
+      extension: { type: "string", short: "e", multiple: true },
+      extension: { type: "string", short: "e", multiple: true },
+      config: { type: "boolean" },
+      "dump-context": { type: "boolean" },
+      "pi-sessions": { type: "boolean" },
+      "pi-runtime-host": { type: "boolean" },
+      "shell-runtime": { type: "boolean" },
+      "no-shell-runtime": { type: "boolean" },
+      "permission-mode": { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  const commandName = ["login", "provider", "websearch"].includes(positionals[0]) ? positionals[0] : null;
+
+  return {
+    command: commandName ? { name: commandName, args: positionals.slice(1) } : null,
+    model: values.model ?? null,
+    provider: values.provider,
+    resume: values.resume,
+    json: values.json ?? false,
+    extensions: values.extension ?? [],
+    dumpContext: values["dump-context"] ?? false,
+    providerConfig: values.config ?? false,
+    piSessions: values["pi-sessions"] ?? false,
+    piRuntimeHost: values["pi-runtime-host"] ?? false,
+    shellRuntime: values["no-shell-runtime"] ? false : true,
+    permissionMode: values["permission-mode"] ?? "bypassPermissions",
+    help: values.help ?? false,
+    prompt: commandName ? "" : positionals.join(" "),
+  };
+}
+
+export function showHelp() {
+  process.stdout.write(`march — terminal-native coding agent
+
+Usage:
+  march [options] [prompt]
+  march [options]            (starts REPL)
+  march login [provider]     Login to an OAuth provider
+  march provider --config    Configure provider credentials
+  march websearch --config  Configure web search credentials
+
+Options:
+  -m, --model <id>     Initial model ID override
+  --provider <name>    Initial provider override
+  --resume <id>        Resume a pi session by default
+  --json               JSON output mode (no TUI)
+  --config             With provider/websearch command, open configuration
+  --dump-context       Write every prompt sent to the model under .march/context-dumps/
+  --pi-sessions        Force pi JSONL SessionManager persistence
+  --pi-runtime-host    Force pi AgentSessionRuntime host path
+  --shell-runtime      Enable interactive PTY shell tools (default)
+  --no-shell-runtime   Disable interactive PTY shell tools and shell pane
+  --permission-mode <mode>  Permission mode: default, bypassPermissions, dontAsk (default: bypassPermissions)
+  -e, --extension <path>
+                       Load a pi extension path in the default runtime host (repeatable)
+  -h, --help           Show this help
+`);
+}

package/src/cli/commands/copy-command.mjs

@@ -0,0 +1,73 @@
+import { spawn, spawnSync } from "node:child_process";
+
+export function copyLastAssistantMessage({ engine, writeClipboard = writeSystemClipboard } = {}) {
+  const message = findLastAssistantMessage(engine);
+  if (!message) return ["Error: no assistant response to copy"];
+  const result = writeClipboard(message);
+  if (result?.ok === false) return [`Error: ${result.message}`];
+  return [`Copied last assistant response (${message.length} chars)`];
+}
+
+export function findLastAssistantMessage(engine) {
+  const turns = engine?.turns ?? [];
+  for (let i = turns.length - 1; i >= 0; i -= 1) {
+    const text = turns[i]?.assistantMessage;
+    if (typeof text === "string" && text.trim()) return text;
+  }
+  return "";
+}
+
+export function writeSystemClipboard(text, { platform = process.platform } = {}) {
+  const command = clipboardCommand(platform);
+  if (!command) return { ok: false, message: `clipboard is not supported on ${platform}` };
+  const result = spawnSync(command.bin, command.args, {
+    input: text,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  if (result.error) return { ok: false, message: result.error.message };
+  if (result.status !== 0) {
+    const stderr = (result.stderr || "").trim();
+    return { ok: false, message: stderr || `${command.bin} exited ${result.status}` };
+  }
+  return { ok: true };
+}
+
+export function writeSystemClipboardAsync(text, { platform = process.platform } = {}) {
+  const command = clipboardCommand(platform);
+  if (!command) return Promise.resolve({ ok: false, message: `clipboard is not supported on ${platform}` });
+  return new Promise((resolve) => {
+    let settled = false;
+    let stderr = "";
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const child = spawn(command.bin, command.args, {
+      windowsHide: true,
+      stdio: ["pipe", "ignore", "pipe"],
+    });
+    child.stderr?.setEncoding?.("utf8");
+    child.stderr?.on("data", (chunk) => { stderr += chunk; });
+    child.on("error", (err) => done({ ok: false, message: err.message }));
+    child.on("close", (status) => {
+      if (status === 0) done({ ok: true });
+      else done({ ok: false, message: stderr.trim() || `${command.bin} exited ${status}` });
+    });
+    child.stdin?.on("error", (err) => done({ ok: false, message: err.message }));
+    child.stdin?.end(text, "utf8");
+  });
+}
+
+function clipboardCommand(platform) {
+  if (platform === "win32") {
+    return {
+      bin: "powershell.exe",
+      args: ["-NoProfile", "-Command", "Set-Clipboard -Value ([Console]::In.ReadToEnd())"],
+    };
+  }
+  if (platform === "darwin") return { bin: "pbcopy", args: [] };
+  return { bin: "sh", args: ["-lc", "command -v wl-copy >/dev/null && wl-copy || xclip -selection clipboard || xsel --clipboard --input"] };
+}

package/src/cli/commands/export-command.mjs

@@ -0,0 +1,206 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export function parseExportCommand(input) {
+  if (input !== "/export" && !input.startsWith("/export ")) return { type: "none" };
+  const args = input.slice("/export".length).trim().split(/\s+/).filter(Boolean);
+  if (args.length === 0) return { type: "error", message: "usage: /export jsonl|html|gist <jsonl|html>" };
+  if (args[0] === "gist") {
+    if (args.length !== 2) return { type: "error", message: "usage: /export gist <jsonl|html>" };
+    if (args[1] !== "jsonl" && args[1] !== "html") return { type: "error", message: `unsupported gist export format: ${args[1]}` };
+    return { type: "gist", format: args[1] };
+  }
+  if (args.length > 1) return { type: "error", message: "usage: /export jsonl|html|gist <jsonl|html>" };
+  if (args[0] !== "jsonl" && args[0] !== "html") return { type: "error", message: `unsupported export format: ${args[0]}` };
+  return { type: args[0] };
+}
+
+export async function handleExportCommand(command, { runner, sessionState, sessionSource = "pi", projectMarchDir, now = new Date(), env = process.env, fetchImpl = globalThis.fetch } = {}) {
+  if (command.type === "error") return [`Error: ${command.message}`];
+  if (command.type !== "jsonl" && command.type !== "html" && command.type !== "gist") return [];
+
+  const options = {
+    engine: runner.engine,
+    sessionStats: runner.getSessionStats?.(),
+    sessionState,
+    sessionSource,
+    projectMarchDir,
+    now,
+  };
+  if (command.type === "gist") {
+    try {
+      const result = await createSessionGist({ ...options, format: command.format, env, fetchImpl });
+      return [`Created Gist: ${result.url}`];
+    } catch (err) {
+      return [`Error: ${err.message}`];
+    }
+  }
+  const result = command.type === "jsonl"
+    ? exportSessionJsonl(options)
+    : exportSessionHtml(options);
+  return [`Exported ${command.type.toUpperCase()}: ${result.path} (${result.turnCount} turns)`];
+}
+
+export function exportSessionJsonl({ engine, sessionStats, sessionState, sessionSource = "pi", projectMarchDir, now = new Date() }) {
+  const exportDir = join(projectMarchDir ?? join(engine.cwd, ".march"), "exports");
+  mkdirSync(exportDir, { recursive: true });
+  const sessionId = sessionStats?.sessionId ?? sessionState?.sessionId ?? "session";
+  const filename = `${formatTimestamp(now)}_${sanitizeFilename(sessionId)}.jsonl`;
+  const path = join(exportDir, filename);
+  const records = buildSessionJsonlRecords({ engine, sessionStats, sessionState, sessionSource, now });
+  writeFileSync(path, records.map((record) => JSON.stringify(record)).join("\n") + "\n", "utf8");
+  return { path, turnCount: engine.turns.length };
+}
+
+export function exportSessionHtml({ engine, sessionStats, sessionState, sessionSource = "pi", projectMarchDir, now = new Date() }) {
+  const exportDir = join(projectMarchDir ?? join(engine.cwd, ".march"), "exports");
+  mkdirSync(exportDir, { recursive: true });
+  const sessionId = sessionStats?.sessionId ?? sessionState?.sessionId ?? "session";
+  const filename = `${formatTimestamp(now)}_${sanitizeFilename(sessionId)}.html`;
+  const path = join(exportDir, filename);
+  const records = buildSessionJsonlRecords({ engine, sessionStats, sessionState, sessionSource, now });
+  writeFileSync(path, buildSessionHtml(records), "utf8");
+  return { path, turnCount: engine.turns.length };
+}
+
+export async function createSessionGist({ engine, sessionStats, sessionState, sessionSource = "pi", now = new Date(), format = "html", env = process.env, fetchImpl = globalThis.fetch }) {
+  const token = env.GITHUB_TOKEN || env.GH_TOKEN;
+  if (!token) throw new Error("GITHUB_TOKEN or GH_TOKEN is required for /export gist");
+  if (typeof fetchImpl !== "function") throw new Error("fetch is not available for /export gist");
+
+  const records = buildSessionJsonlRecords({ engine, sessionStats, sessionState, sessionSource, now });
+  const session = records.find((record) => record.type === "session") ?? {};
+  const sessionId = session.sessionId ?? "session";
+  const extension = format === "html" ? "html" : "jsonl";
+  const filename = `${formatTimestamp(now)}_${sanitizeFilename(sessionId)}.${extension}`;
+  const content = format === "html"
+    ? buildSessionHtml(records)
+    : records.map((record) => JSON.stringify(record)).join("\n") + "\n";
+  const response = await fetchImpl(`${env.GITHUB_API_URL || "https://api.github.com"}/gists`, {
+    method: "POST",
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Content-Type": "application/json",
+      "User-Agent": "march-cli",
+    },
+    body: JSON.stringify({
+      description: `March session export: ${session.sessionName || sessionId}`,
+      public: false,
+      files: {
+        [filename]: { content },
+      },
+    }),
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(`GitHub Gist create failed (${response.status}): ${body.message || response.statusText || "unknown error"}`);
+  }
+  if (!body.html_url) throw new Error("GitHub Gist create response did not include html_url");
+  return { url: body.html_url, filename };
+}
+
+export function buildSessionJsonlRecords({ engine, sessionStats, sessionState, sessionSource = "pi", now = new Date() }) {
+  const sessionId = sessionStats?.sessionId ?? sessionState?.sessionId ?? null;
+  const records = [
+    {
+      type: "session",
+      exportedAt: now.toISOString(),
+      sessionId,
+      sessionName: engine.sessionName || null,
+      source: sessionSource,
+      cwd: engine.cwd,
+      provider: engine.provider,
+      modelId: engine.modelId,
+      thinkingLevel: engine.thinkingLevel,
+      sessionFile: sessionStats?.sessionFile ?? null,
+      stats: sessionStats ? {
+        userMessages: sessionStats.userMessages,
+        assistantMessages: sessionStats.assistantMessages,
+        toolCalls: sessionStats.toolCalls,
+        totalMessages: sessionStats.totalMessages,
+        tokens: sessionStats.tokens,
+        cost: sessionStats.cost,
+      } : null,
+    },
+  ];
+
+  for (const turn of engine.turns) {
+    records.push({
+      type: "turn",
+      index: turn.index,
+      userMessage: turn.userMessage ?? "",
+      assistantMessage: turn.assistantMessage ?? "",
+    });
+  }
+
+  return records;
+}
+
+export function buildSessionHtml(records) {
+  const session = records.find((record) => record.type === "session") ?? {};
+  const turns = records.filter((record) => record.type === "turn");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(session.sessionName || session.sessionId || "March session")}</title>
+  <style>
+    :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    body { margin: 0; padding: 32px; line-height: 1.5; background: Canvas; color: CanvasText; }
+    main { max-width: 920px; margin: 0 auto; }
+    h1 { font-size: 28px; margin: 0 0 8px; }
+    .meta { color: color-mix(in srgb, CanvasText 65%, Canvas); margin-bottom: 24px; }
+    .turn { border-top: 1px solid color-mix(in srgb, CanvasText 20%, Canvas); padding: 20px 0; }
+    .label { font-weight: 700; margin: 16px 0 6px; }
+    pre { white-space: pre-wrap; word-wrap: break-word; margin: 0; padding: 12px; border-radius: 8px; background: color-mix(in srgb, CanvasText 8%, Canvas); }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>${escapeHtml(session.sessionName || "March session")}</h1>
+    <div class="meta">${escapeHtml(formatSessionMeta(session))}</div>
+    ${turns.map(formatTurnHtml).join("\n")}
+  </main>
+</body>
+</html>
+`;
+}
+
+function formatTurnHtml(turn) {
+  return `<section class="turn">
+  <h2>Turn ${escapeHtml(String(turn.index))}</h2>
+  <div class="label">User</div>
+  <pre>${escapeHtml(turn.userMessage)}</pre>
+  <div class="label">Assistant</div>
+  <pre>${escapeHtml(turn.assistantMessage || "(no assistant message)")}</pre>
+</section>`;
+}
+
+function formatSessionMeta(session) {
+  return [
+    session.sessionId ? `session ${session.sessionId}` : null,
+    session.source ? `source ${session.source}` : null,
+    session.provider && session.modelId ? `${session.provider}/${session.modelId}` : null,
+    session.thinkingLevel ? `thinking ${session.thinkingLevel}` : null,
+    session.exportedAt ? `exported ${session.exportedAt}` : null,
+  ].filter(Boolean).join(" | ");
+}
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function formatTimestamp(date) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+
+function sanitizeFilename(value) {
+  return String(value || "session").replace(/[^a-zA-Z0-9._-]/g, "_");
+}

package/src/cli/commands/extensions-command.mjs

@@ -0,0 +1,53 @@
+export function listExtensionPathsCommand(extensionPaths = [], diagnostics = [], lifecycleState = null) {
+  const lines = [];
+
+  if (extensionPaths.length === 0) {
+    lines.push("(no configured extension paths)");
+  } else {
+    lines.push(
+      "Configured extension paths:",
+      ...extensionPaths.map((extensionPath, index) => `${index + 1}. ${extensionPath}`),
+      "(paths are passed to the pi runtime host; this list does not guarantee successful extension startup)",
+    );
+  }
+
+  if (lifecycleState) {
+    lines.push(
+      "March lifecycle hooks:",
+      `- status: ${lifecycleState.status}`,
+      `- registered hooks: ${lifecycleState.registeredHookCount}`,
+      `- policy: ${lifecycleState.policy?.mode ?? "unknown"}; blocking by default: ${lifecycleState.policy?.defaultBlocking ? "yes" : "no"}`,
+    );
+    const deniedEffects = lifecycleState.policy?.deniedEffects ?? [];
+    if (deniedEffects.length > 0) {
+      lines.push(`- denied effects: ${deniedEffects.join(", ")}`);
+    }
+    const lifecycleDiagnostics = uniqueLifecycleDiagnostics(lifecycleState.diagnostics ?? [], diagnostics);
+    if (lifecycleDiagnostics.length > 0) {
+      lines.push("March lifecycle diagnostics:");
+      for (const diagnostic of lifecycleDiagnostics) {
+        lines.push(`- ${diagnostic.type ?? "info"}: ${diagnostic.message ?? String(diagnostic)}`);
+      }
+    }
+  }
+
+  if (diagnostics.length === 0) {
+    lines.push("(no extension diagnostics)");
+    return lines;
+  }
+
+  lines.push("Extension diagnostics:");
+  for (const diagnostic of diagnostics) {
+    lines.push(`- ${diagnostic.type ?? "info"}: ${diagnostic.message ?? String(diagnostic)}`);
+  }
+  return lines;
+}
+
+function uniqueLifecycleDiagnostics(lifecycleDiagnostics, extensionDiagnostics) {
+  const extensionKeys = new Set(extensionDiagnostics.map(formatDiagnosticKey));
+  return lifecycleDiagnostics.filter((diagnostic) => !extensionKeys.has(formatDiagnosticKey(diagnostic)));
+}
+
+function formatDiagnosticKey(diagnostic) {
+  return `${diagnostic?.type ?? "info"}:${diagnostic?.message ?? String(diagnostic)}`;
+}

package/src/cli/commands/help-command.mjs

@@ -0,0 +1,7 @@
+export function formatHelpLines() {
+  return [
+    "Commands: /new, /exit, /help, /hotkeys, /templates, /export jsonl, /export html, /export gist <jsonl|html>, /settings, /extensions, /providers, /providers <name>, /model, /models, /session, /status, /shell, /shell spawn [name], /save, /name, /copy, /mouse",
+    "Sessions: /session opens previous sessions and restores the selected one.",
+    "Shortcuts: Tab = toggle Do/Discuss, Esc = abort turn, Ctrl+C = abort turn / press twice to exit when idle, Ctrl+O = toggle tool output, Alt+S = shell pane, Alt+N = next shell, Alt+K/J = shell scroll, PageUp/PageDown = output scroll, Ctrl+G = external editor, Shift+Tab = thinking selector, Ctrl+T = thinking selector, Ctrl+L = model selector",
+  ];
+}