chainlesschain 0.165.5 → 0.165.8

package/src/commands/agent.js

@@ -30,6 +30,11 @@ import {
   transformBackgroundLaunchArgv,
 } from "../lib/background-command-argv.js";
 import { resolveSessionBudgetRootOptions } from "../lib/session-budget-production-root.js";
+import {
+  captureClaudeStorageLaunchEnvironment,
+  restoreClaudeStorageLaunchEnvironment,
+  validateClaudeStorageLaunchEnvironment,
+} from "../lib/claude-project-auto-memory.js";
 
 /**
  * Resolve + validate `--add-dir` values into absolute, existing, de-duped
@@ -445,7 +450,7 @@ export function registerAgentCommand(program) {
     )
     .option(
       "--output-style <name>",
-      "Apply a named output-style persona (.claude/output-styles/<name>.md or a built-in: explanatory | learning)",
+      "Apply a named output-style persona (.claude/output-styles/<name>.md or a built-in: concise | explanatory | learning)",
     )
     .option(
       "--input-format <fmt>",
@@ -465,6 +470,10 @@ export function registerAgentCommand(program) {
       "--include-partial-messages",
       "Emit live assistant-text deltas as stream_event lines (requires --output-format stream-json)",
     )
+    .option(
+      "--include-hook-events",
+      "Emit redacted hook and subagent lifecycle events (requires --output-format stream-json)",
+    )
     .option(
       "--goal [id]",
       "Bind a cc goal into the run (id, or omit the value to auto-resolve the active goal)",
@@ -530,7 +539,11 @@ export function registerAgentCommand(program) {
     )
     .option(
       "--remote-control",
-      "Route confirm-tier approvals to paired mobile/web devices — prints a pairing URI/QR. Headless waits for the remote allow/deny (fail-closed on timeout); interactive races the terminal prompt (first answer wins; also /remote-control)",
+      "Route confirm-tier approvals to paired mobile/web devices — requires a relay or explicit LAN opt-in; headless waits fail-closed, interactive races the terminal prompt (also /remote-control)",
+    )
+    .option(
+      "--remote-control-allow-lan",
+      "Permit --remote-control to expose its authenticated WS endpoint on a trusted LAN",
     )
     .option(
       "--channels <list>",
@@ -616,6 +629,20 @@ export function registerAgentCommand(program) {
       false,
     )
     .action(async (task, options, command) => {
+      // These variables select canonical config/session storage. Capture and
+      // validate them before any project settings file can merge an arbitrary
+      // `env` map; settings remain useful for child tools but never acquire
+      // launcher authority over transcript or automatic-memory placement.
+      const claudeStorageLaunchEnv = captureClaudeStorageLaunchEnvironment();
+      try {
+        validateClaudeStorageLaunchEnvironment(claudeStorageLaunchEnv, {
+          cwd: process.cwd(),
+        });
+      } catch (error) {
+        process.stderr.write(`Error: ${error.message}\n`);
+        process.exitCode = 1;
+        return;
+      }
       // Scope is immutable session authority. Resolve every scope/fork
       // conflict before worktree creation, session forking, bootstrap, or any
       // other externally visible setup performed by this action.
@@ -632,18 +659,16 @@ export function registerAgentCommand(program) {
       // --capabilities: print the machine-readable manifest and exit — no
       // config, no bootstrap, no network (gap-analysis 2026-07-11 快速收益 #6).
       if (options.capabilities) {
-        const { buildAgentCapabilities } = await import(
-          "../lib/headless-manifest.js"
-        );
+        const { buildAgentCapabilities } =
+          await import("../lib/headless-manifest.js");
         console.log(JSON.stringify(buildAgentCapabilities(), null, 2));
         return;
       }
       let toolAdmission = null;
       if (process.env.CC_TOOL_ADMISSION) {
         try {
-          const { parseToolAdmissionConfig } = await import(
-            "../lib/agent-tool-admission.js"
-          );
+          const { parseToolAdmissionConfig } =
+            await import("../lib/agent-tool-admission.js");
           toolAdmission = parseToolAdmissionConfig(
             process.env.CC_TOOL_ADMISSION,
           );
@@ -720,9 +745,8 @@ export function registerAgentCommand(program) {
       // screen readers (mono theme + no repainting status line). Applied
       // before anything renders.
       {
-        const { screenReaderRequested, applyScreenReaderMode } = await import(
-          "../lib/accessibility.js"
-        );
+        const { screenReaderRequested, applyScreenReaderMode } =
+          await import("../lib/accessibility.js");
         if (screenReaderRequested(options)) {
           applyScreenReaderMode();
         }
@@ -755,9 +779,8 @@ export function registerAgentCommand(program) {
       };
       if (options.worktree !== undefined || backgroundRequested) {
         try {
-          const { resolveBackgroundWorktreePolicy } = await import(
-            "../lib/background-worktree-policy.js"
-          );
+          const { resolveBackgroundWorktreePolicy } =
+            await import("../lib/background-worktree-policy.js");
           worktreeDecision = resolveBackgroundWorktreePolicy({
             background: backgroundRequested,
             worktree: options.worktree,
@@ -809,9 +832,8 @@ export function registerAgentCommand(program) {
       };
       if (worktreeDecision.enabled) {
         try {
-          const { setupAgentWorktree, finishAgentWorktree } = await import(
-            "../lib/agent-worktree.js"
-          );
+          const { setupAgentWorktree, finishAgentWorktree } =
+            await import("../lib/agent-worktree.js");
           _finishAgentWorktreeFn = finishAgentWorktree;
           const detectedRepoRoot = worktreeDecision.repoRoot || invocationCwd;
           const worktreeCwd =
@@ -839,9 +861,8 @@ export function registerAgentCommand(program) {
             const { loadHooks } = await import("../lib/settings-hooks.cjs");
             _worktreeSettingsHooks =
               loadHooks({ cwd: _worktree.repoRoot }).hooks || null;
-            const { runWorktreeCreateHooks, dispatchAsyncHooks } = await import(
-              "../lib/settings-hook-events.js"
-            );
+            const { runWorktreeCreateHooks, dispatchAsyncHooks } =
+              await import("../lib/settings-hook-events.js");
             runWorktreeCreateHooks(_worktreeSettingsHooks, {
               worktreePath: _worktree.path,
               branch: _worktree.branch,
@@ -849,9 +870,8 @@ export function registerAgentCommand(program) {
               cwd: _worktree.path,
             });
             if (!_worktreeAsyncSupervisor) {
-              const { AsyncHookSupervisor } = await import(
-                "../lib/async-hook-supervisor.js"
-              );
+              const { AsyncHookSupervisor } =
+                await import("../lib/async-hook-supervisor.js");
               _worktreeAsyncSupervisor = new AsyncHookSupervisor({
                 persistStats: true,
               });
@@ -936,9 +956,8 @@ export function registerAgentCommand(program) {
       // Claude-Code parity: auto-checkpoint defaults ON inside a git repo
       // (shadow-commit engine, zero working-tree touch); explicit
       // --checkpoint / --no-checkpoint always wins.
-      const { resolveAutoCheckpoint } = await import(
-        "../lib/auto-checkpoint-default.js"
-      );
+      const { resolveAutoCheckpoint } =
+        await import("../lib/auto-checkpoint-default.js");
       const autoCheckpoint = resolveAutoCheckpoint({
         flagValue: options.checkpoint,
         flagSource: command?.getOptionValueSource?.("checkpoint"),
@@ -965,15 +984,13 @@ export function registerAgentCommand(program) {
         if (headlessIntent) {
           // Headless replays the JSONL store only, so resolve "most recent"
           // from there 鈥?a DB-only id would resume into an empty transcript.
-          const { getLastSessionId } = await import(
-            "../harness/jsonl-session-store.js"
-          );
+          const { getLastSessionId } =
+            await import("../harness/jsonl-session-store.js");
           options.session = getLastSessionId();
         } else {
           // Interactive: picker across both stores (agent REPL rebuilds either).
-          const { pickRecentSession } = await import(
-            "../lib/session-picker.js"
-          );
+          const { pickRecentSession } =
+            await import("../lib/session-picker.js");
           const picked = await pickRecentSession(ctx, {
             message: "Resume which agent session?",
           });
@@ -996,9 +1013,8 @@ export function registerAgentCommand(program) {
       // a no-op (silent) for a fresh run.
       if (options.forkSession && options.session) {
         const store = await import("../harness/jsonl-session-store.js");
-        const { applyForkSession } = await import(
-          "../runtime/headless-runner.js"
-        );
+        const { applyForkSession } =
+          await import("../runtime/headless-runner.js");
         const fork = applyForkSession(
           {
             forkSession: true,
@@ -1020,16 +1036,16 @@ export function registerAgentCommand(program) {
         }
       }
 
-      // --include-partial-messages only makes sense for NDJSON output: the
-      // stream-input mode is always NDJSON, otherwise require stream-json
-      // explicitly (fail fast rather than silently dropping the deltas).
+      // Event projections only make sense for NDJSON output: the stream-input
+      // mode is always NDJSON, otherwise require stream-json explicitly (fail
+      // fast rather than silently dropping an opt-in machine contract).
       if (
-        options.includePartialMessages &&
+        (options.includePartialMessages || options.includeHookEvents) &&
         options.inputFormat !== "stream-json" &&
         options.outputFormat !== "stream-json"
       ) {
         process.stderr.write(
-          "--include-partial-messages requires --output-format stream-json.\n",
+          "--include-partial-messages and --include-hook-events require --output-format stream-json.\n",
         );
         await _finishWorktree();
         process.exit(1);
@@ -1054,6 +1070,12 @@ export function registerAgentCommand(program) {
       // block below may default options.model 鈥?so vision input can tell an
       // explicit model from a settings default.
       const explicitCliModel = options.model;
+      // Launcher environment is captured before a settings file can merge its
+      // own `env` map. In particular, a checked-in project settings file must
+      // not manufacture ANTHROPIC_MODEL / CLAUDE_CODE_* launcher authority.
+      const startupAnthropicModel = process.env.ANTHROPIC_MODEL;
+      const startupAnthropicDefaultModel = process.env.ANTHROPIC_DEFAULT_MODEL;
+      let settingsModel = null;
 
       // --settings native config overrides: a .claude/settings.json-shaped file
       // (and the discovered .claude settings) may set `model` + `env` for this
@@ -1064,9 +1086,8 @@ export function registerAgentCommand(program) {
       let settingsSandbox = null;
       let managedSettingsSandbox = null;
       try {
-        const { loadSettingsConfig } = await import(
-          "../lib/settings-loader.cjs"
-        );
+        const { loadSettingsConfig } =
+          await import("../lib/settings-loader.cjs");
         const sc = loadSettingsConfig({
           cwd: process.cwd(),
           unattendedActionPolicy: options.unattended
@@ -1084,7 +1105,10 @@ export function registerAgentCommand(program) {
         for (const [k, v] of Object.entries(sc.env || {})) {
           process.env[k] = v;
         }
-        if (!options.model && sc.model) options.model = sc.model;
+        if (!options.model && sc.model) {
+          options.model = sc.model;
+          settingsModel = sc.model;
+        }
         settingsSandbox = sc.sandbox || null;
         managedSettingsSandbox = sc.managedSandbox || null;
       } catch (error) {
@@ -1095,6 +1119,8 @@ export function registerAgentCommand(program) {
         }
         // User/project settings overrides remain best-effort. Organization
         // managed settings are handled above and may never fail open.
+      } finally {
+        restoreClaudeStorageLaunchEnvironment(claudeStorageLaunchEnv);
       }
 
       let resolvedAgentSandbox;
@@ -1190,7 +1216,7 @@ export function registerAgentCommand(program) {
       // flags there, and BEFORE every dispatch (headless/stream/REPL) since
       // they all read options.provider/model/baseUrl/apiKey.
       {
-        const { applyConfigLlmDefaults, reconcileConfigLlmProvider } =
+        const { applyAgentModelDefaults, reconcileConfigLlmProvider } =
           await import("../lib/llm-config-defaults.js");
 
         // Self-repair a MISLABELED config (provider disagrees with the provider
@@ -1218,8 +1244,16 @@ export function registerAgentCommand(program) {
           }
         }
 
-        applyConfigLlmDefaults(options, repairedLlm, {
-          explicitModel: explicitCliModel, // settings-file model must not ride
+        applyAgentModelDefaults(options, repairedLlm, {
+          explicitModel: explicitCliModel,
+          anthropicModel: startupAnthropicModel,
+          anthropicDefaultModel: startupAnthropicDefaultModel,
+          settingsModel,
+          // ANTHROPIC_DEFAULT_MODEL is deliberately a new-session fallback;
+          // a resume/continue keeps its recorded model unless a higher source
+          // explicitly replaces it.
+          isNewSession:
+            !options.session && !options.continue && !options.resume,
         });
 
         // Also reconcile the RESOLVED options: the editor panel may have already
@@ -1243,9 +1277,8 @@ export function registerAgentCommand(program) {
       // never pollutes spawned-bin test stderr.
       if (!process.env.VITEST && !process.env.VITEST_WORKER_ID) {
         try {
-          const { maybeWarnDeprecatedModel } = await import(
-            "../lib/model-deprecation.js"
-          );
+          const { maybeWarnDeprecatedModel } =
+            await import("../lib/model-deprecation.js");
           maybeWarnDeprecatedModel({ model: options.model });
         } catch {
           /* fail-open: a deprecation notice must never affect the run */
@@ -1331,9 +1364,8 @@ export function registerAgentCommand(program) {
       // stdin; output is always NDJSON. Routed before single-prompt handling
       // so stdin is consumed as events, not as one prompt.
       if (options.inputFormat === "stream-json") {
-        const { runAgentHeadlessStream } = await import(
-          "../runtime/headless-stream.js"
-        );
+        const { runAgentHeadlessStream } =
+          await import("../runtime/headless-stream.js");
         const { parseToolList } = await import("../runtime/headless-runner.js");
         const cwd = process.cwd();
         let outcome;
@@ -1374,6 +1406,7 @@ export function registerAgentCommand(program) {
             // (flag absent) leaves the default-on path byte-identical.
             projectMemory: options.projectMemory,
             includePartialMessages: options.includePartialMessages === true,
+            includeHookEvents: options.includeHookEvents === true,
             goal: options.goal,
             mcpConfig: options.mcpConfig || null,
             useRegisteredMcp: options.mcp !== false,
@@ -1383,6 +1416,7 @@ export function registerAgentCommand(program) {
             cwd,
             permissionPromptTool: options.permissionPromptTool || null,
             remoteControl: options.remoteControl === true,
+            remoteControlAllowLan: options.remoteControlAllowLan === true,
             interactiveApprovals: options.interactiveApprovals === true,
             settingsFile: options.settings || null,
             outputStyle: options.outputStyle || null,
@@ -1401,6 +1435,7 @@ export function registerAgentCommand(program) {
             // into the system prompt, and a per-turn `structured_result` event is
             // appended after each turn (parity with single-prompt --json-schema).
             jsonSchema: options.jsonSchema || null,
+            claudeStorageLaunchEnv,
           });
         } catch (err) {
           process.stderr.write(
@@ -1564,9 +1599,8 @@ export function registerAgentCommand(program) {
         const resumeRequested =
           Boolean(options.continue) || options.resume !== undefined;
         if (resumeRequested && options.session) {
-          const { sessionHasPersistedEvidence } = await import(
-            "../harness/jsonl-session-store.js"
-          );
+          const { sessionHasPersistedEvidence } =
+            await import("../harness/jsonl-session-store.js");
           if (!sessionHasPersistedEvidence(options.session)) {
             process.stderr.write(
               `Note: no headless transcript for session "${options.session}" 鈥?` +
@@ -1574,16 +1608,14 @@ export function registerAgentCommand(program) {
             );
           }
         }
-        const { runAgentHeadless, parseToolList } = await import(
-          "../runtime/headless-runner.js"
-        );
+        const { runAgentHeadless, parseToolList } =
+          await import("../runtime/headless-runner.js");
         // --goal-condition: validate the spec up front so a bad prefix fails
         // fast (before any model call) with a clear message.
         if (options.goalCondition) {
           try {
-            const { parseGoalCondition } = await import(
-              "../lib/goal-condition-engine.js"
-            );
+            const { parseGoalCondition } =
+              await import("../lib/goal-condition-engine.js");
             parseGoalCondition(options.goalCondition);
           } catch (e) {
             process.stderr.write(`--goal-condition: ${e.message}\n`);
@@ -1651,6 +1683,8 @@ export function registerAgentCommand(program) {
           projectMemory: options.projectMemory,
           // --include-partial-messages: live token deltas as stream_event lines
           includePartialMessages: options.includePartialMessages === true,
+          // --include-hook-events: redacted lifecycle/progress NDJSON lines
+          includeHookEvents: options.includeHookEvents === true,
           // --goal [id]: bind a cc goal into the run (Phase 1)
           goal: options.goal,
           // --goal-assess: run-end LLM progress assessment (Phase 2)
@@ -1685,6 +1719,7 @@ export function registerAgentCommand(program) {
           permissionPromptTool: options.permissionPromptTool || null,
           // --remote-control: approvals from paired mobile/web devices
           remoteControl: options.remoteControl === true,
+          remoteControlAllowLan: options.remoteControlAllowLan === true,
           // --strict-mcp-config: only --mcp-config servers (ignore registered + IDE)
           strictMcpConfig: options.strictMcpConfig === true,
           // --settings: extra .claude/settings.json permission rules
@@ -1701,6 +1736,7 @@ export function registerAgentCommand(program) {
             : undefined,
           // --fallback-model: retry once on a backup model on transient errors
           chatFn: fallbackChatFn,
+          claudeStorageLaunchEnv,
         };
 
         // --json-schema: structured output. Accepts a file path OR inline JSON.
@@ -1836,6 +1872,11 @@ export function registerAgentCommand(program) {
         // === false suppresses the auto-loaded rules.md + cc.md/CLAUDE.md block
         // in the REPL's composed system prompt. Absent (undefined) = default-on.
         projectMemory: options.projectMemory,
+        // Output styles and the one-shot settings layer are also consumed by
+        // the interactive REPL. Keep them on the runtime-policy allowlist so
+        // `--output-style concise` and `--settings` are not silently dropped.
+        outputStyle: options.outputStyle || null,
+        settingsFile: options.settings || null,
         // --fallback-model also applies interactively (wrapper built in the
         // REPL). Pass the fully resolved chain (flag + config default).
         fallbackModels: fallbackModels.length ? fallbackModels : null,
@@ -1854,12 +1895,14 @@ export function registerAgentCommand(program) {
         // --remote-control: start the paired-device approval bridge for the
         // interactive session too (terminal prompt races the device).
         remoteControl: options.remoteControl === true,
+        remoteControlAllowLan: options.remoteControlAllowLan === true,
         // --channels: inbound channel listeners (webhook/telegram) whose
         // events become user turns in this session.
         channels: options.channels || null,
         observabilityScope: hasObservabilityScope
           ? observabilityScope
           : undefined,
+        claudeStorageLaunchEnv,
       });
       await runtime.startAgentSession();
       // Interactive session ended (REPL closed) — settle the worktree.

package/src/commands/background-session.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { readPrLinkLedger } from "../lib/pr-link-ledger.js";
@@ -350,22 +350,112 @@ export async function retryBackgroundNeedsInputNotification(
 export const LOG_TRUNCATION_NOTICE =
   "--- log truncated/rotated, resuming from tail ---";
 const TRUNCATION_RESUME_TAIL_BYTES = 4096;
+export const MAX_BACKGROUND_LOG_DELTA_BYTES = 1024 * 1024;
+
+function backgroundLogSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return null;
+  }
+}
+
+function completeUtf8PrefixLength(buffer) {
+  if (buffer.length === 0) return 0;
+  let leadIndex = buffer.length - 1;
+  let continuationBytes = 0;
+  while (
+    leadIndex >= 0 &&
+    (buffer[leadIndex] & 0xc0) === 0x80 &&
+    continuationBytes < 3
+  ) {
+    continuationBytes += 1;
+    leadIndex -= 1;
+  }
+  if (leadIndex < 0) return buffer.length;
+  const lead = buffer[leadIndex];
+  const expectedBytes =
+    (lead & 0x80) === 0
+      ? 1
+      : (lead & 0xe0) === 0xc0
+        ? 2
+        : (lead & 0xf0) === 0xe0
+          ? 3
+          : (lead & 0xf8) === 0xf0
+            ? 4
+            : 1;
+  return buffer.length - leadIndex < expectedBytes ? leadIndex : buffer.length;
+}
+
+function readBackgroundLogRange(
+  file,
+  start,
+  length,
+  preserveTrailingUtf8 = false,
+) {
+  if (length <= 0) return { text: "", bytesRead: 0 };
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const buffer = Buffer.allocUnsafe(length);
+    let bytesRead = 0;
+    while (bytesRead < length) {
+      const count = readSync(
+        fd,
+        buffer,
+        bytesRead,
+        length - bytesRead,
+        start + bytesRead,
+      );
+      if (count === 0) break;
+      bytesRead += count;
+    }
+    const completeBytes = preserveTrailingUtf8
+      ? completeUtf8PrefixLength(buffer.subarray(0, bytesRead))
+      : bytesRead;
+    return {
+      text: buffer.subarray(0, completeBytes).toString("utf8"),
+      bytesRead: completeBytes,
+    };
+  } catch {
+    return { text: "", bytesRead: 0 };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
 
 export function readLogFromOffset(file, offset) {
-  if (!existsSync(file)) return { text: "", offset };
-  const text = readFileSync(file, "utf8");
-  if (offset > text.length) {
+  const normalizedOffset = Number.isSafeInteger(offset)
+    ? Math.max(0, offset)
+    : 0;
+  const size = backgroundLogSize(file);
+  if (size === null) return { text: "", offset: normalizedOffset };
+  if (normalizedOffset > size) {
     // Gap 3: the log shrank under us (rotation/truncation). Resetting the
     // offset to 0 used to REPLAY the entire new file into the follow stream;
     // resume from the current tail instead, with an explicit marker.
-    const from = Math.max(0, text.length - TRUNCATION_RESUME_TAIL_BYTES);
+    const from = Math.max(0, size - TRUNCATION_RESUME_TAIL_BYTES);
+    const tail = readBackgroundLogRange(file, from, size - from);
     return {
-      text: `\n${LOG_TRUNCATION_NOTICE}\n${text.slice(from)}`,
-      offset: text.length,
+      text: `\n${LOG_TRUNCATION_NOTICE}\n${tail.text}`,
+      offset: from + tail.bytesRead,
       truncated: true,
     };
   }
-  return { text: text.slice(offset), offset: text.length };
+  const length = Math.min(
+    size - normalizedOffset,
+    MAX_BACKGROUND_LOG_DELTA_BYTES,
+  );
+  const delta = readBackgroundLogRange(
+    file,
+    normalizedOffset,
+    length,
+    normalizedOffset + length < size,
+  );
+  return {
+    text: delta.text,
+    offset: normalizedOffset + delta.bytesRead,
+  };
 }
 
 /** Content-free JSONL authority exposed at the real background attach seam. */
@@ -390,7 +480,7 @@ async function followBackgroundAgent(id, options = {}) {
   const initial = readBackgroundAgentLog(id, { lines });
   if (initial)
     process.stdout.write(initial.endsWith("\n") ? initial : `${initial}\n`);
-  let offset = existsSync(logFile) ? readFileSync(logFile, "utf8").length : 0;
+  let offset = backgroundLogSize(logFile) ?? 0;
 
   if (options.follow === false || state.status !== "running") {
     return state;
@@ -597,7 +687,7 @@ export async function interactiveAttach(id, state, options = {}) {
   if (initial)
     process.stdout.write(initial.endsWith("\n") ? initial : `${initial}\n`);
   const logFile = logPath(id);
-  let offset = existsSync(logFile) ? readFileSync(logFile, "utf8").length : 0;
+  let offset = backgroundLogSize(logFile) ?? 0;
   logger.log(
     chalk.gray(
       `Attached to ${id} (interactive). Type a prompt to continue the session; /stop · /status · Ctrl-C detaches.`,

package/src/commands/git.js

@@ -15,12 +15,51 @@ import {
   gitInit,
   isGitRepo,
 } from "../lib/git-integration.js";
+import {
+  parseGitLabMergeRequestReference,
+  renderGitLabMergeRequestFooter,
+} from "../lib/gitlab-mr-worktree.js";
 
 export function registerGitCommand(program) {
   const git = program
     .command("git")
     .description("Git integration for knowledge base versioning");
 
+  git
+    .command("gitlab-mr <reference>")
+    .description("Render a local GitLab MR/worktree footer (no network I/O)")
+    .option("--worktree <path>", "Worktree path to include in the footer")
+    .option("--host <host>", "Default GitLab host for project!iid shorthand")
+    .option("--json", "Output the normalized local display model as JSON")
+    .action((reference, options) => {
+      try {
+        const mr = parseGitLabMergeRequestReference(reference, {
+          defaultHost: options.host,
+        });
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ...mr,
+                ...(options.worktree ? { worktreePath: options.worktree } : {}),
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        logger.log(
+          renderGitLabMergeRequestFooter(mr, {
+            worktreePath: options.worktree,
+          }),
+        );
+      } catch (error) {
+        logger.error(`GitLab MR footer failed: ${error.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   // git status
   git
     .command("status")

package/src/commands/mcp.js

@@ -632,6 +632,10 @@ export function registerMcpCommand(program) {
       "--client-id <id>",
       "Use a pre-registered client_id instead of dynamic registration",
     )
+    .option(
+      "--redirect-uri <url>",
+      "Exact pre-registered http://127.0.0.1:<port>/<path> callback URI",
+    )
     .option(
       "--port <n>",
       "Localhost callback port",
@@ -662,6 +666,7 @@ export function registerMcpCommand(program) {
         const rec = await oauth.authorizeInteractive(url, {
           scope: options.scope,
           clientId: options.clientId,
+          redirectUri: options.redirectUri,
           port: options.port,
           writeOut: (s) => process.stdout.write(s),
         });