@uniqbit/mate-core 0.18.3-canary.0 → 0.18.3

package/src/opencode/companion-hooks.ts

@@ -1,8 +1,6 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs";
 import path from "node:path";
 
-import type { Cleanup, Context } from "@opencode/plugin/promise/plugin";
+import type { Context } from "@opencode/plugin/promise/plugin";
 
 import {
   companionForkRefusal,
@@ -11,6 +9,8 @@ import {
 } from "../runtime/companion-sync";
 import { hasLaunchEnvironment } from "../runtime/env";
 import { MATE_ENV } from "../runtime/env-names";
+import { resolveProjection } from "../runtime/projection";
+import { readWrapStateSync } from "../runtime/wrap-state";
 import {
   buildArtifactError,
   extractPatchPaths,
@@ -20,103 +20,13 @@ import {
   type CompanionContext,
 } from "./companion-policy";
 
-const REACT_DOCTOR_VERSION = "0.9.13";
-
-const REACT_DOCTOR_NON_LINT_FAILURES = [
-  /No React dependency found/i,
-  /Could not resolve config/i,
-  /is not a git repository/i,
-];
-
-const REACT_DOCTOR_EDIT_TOOLS = new Set(["write", "edit", "apply_patch"]);
-const REACT_DOCTOR_ARGS = [
-  "--yes",
-  "--verbose",
-  "--scope",
-  "changed",
-  "--base",
-  "HEAD",
-  "--blocking",
-  "warning",
-  "--no-score",
-  "--max-duration",
-  "30",
-];
-
-export type CommandResult = { exitCode: number | null; output: string };
-export type CommandRunner = (
-  command: string,
-  args: string[],
-  cwd: string,
-) => Promise<CommandResult>;
-type SessionPrompt = Pick<Context["session"], "prompt">;
-
-/** Combined stdout and stderr; rejects only when the process cannot be spawned. */
-export const runCommand: CommandRunner = (command, args, cwd) =>
-  new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    let output = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk: string) => (output += chunk));
-    child.stderr.setEncoding("utf8").on("data", (chunk: string) => (output += chunk));
-    child.once("error", reject);
-    child.once("close", (exitCode) => resolve({ exitCode, output: output.trim() }));
-  });
-
-function reactDoctorCommand(repo: string): { command: string; args: string[] } {
-  const localBin = path.join(repo, "node_modules", ".bin", "react-doctor");
-  const mateBin = process.env.MATE_REACT_DOCTOR_BIN_PATH;
-  const doctorBin = mateBin && fs.existsSync(mateBin) ? mateBin : localBin;
-  return fs.existsSync(doctorBin)
-    ? { command: doctorBin, args: REACT_DOCTOR_ARGS }
-    : {
-        command: "npx",
-        args: ["--yes", `react-doctor@${REACT_DOCTOR_VERSION}`, ...REACT_DOCTOR_ARGS],
-      };
-}
-
-/**
- * Tracks edited sessions and scans each at most once per idle, never twice
- * concurrently for the same session.
- */
-export function createReactDoctorScanner(
-  context: CompanionContext,
-  session: SessionPrompt,
-  run: CommandRunner = runCommand,
-) {
-  const dirtySessions = new Set<string>();
-  const scansInFlight = new Set<string>();
-
-  return {
-    markEdited(tool: string, sessionID: string): void {
-      if (REACT_DOCTOR_EDIT_TOOLS.has(tool)) dirtySessions.add(sessionID);
-    },
-    async idle(sessionID: string): Promise<void> {
-      const repo = context.repositoryPath;
-      if (!repo || scansInFlight.has(sessionID) || !dirtySessions.delete(sessionID)) return;
-      scansInFlight.add(sessionID);
-      try {
-        const { command, args } = reactDoctorCommand(repo);
-        const { exitCode, output } = await run(command, args, repo);
-        if (exitCode === 0 || !output) return;
-        if (REACT_DOCTOR_NON_LINT_FAILURES.some((re) => re.test(output))) return;
-
-        await session
-          .prompt({
-            sessionID,
-            text:
-              "React Doctor found issues in the changed files. Review this output and fix " +
-              "the regressions before finishing. For confirmed issues that cannot be fixed " +
-              "now, create GitHub issues with the rule, file/line, confidence, impact, and " +
-              `proposed fix.\n\n${output}`,
-          } as never)
-          .catch(() => {});
-      } catch {
-        /** Never break the session because a diagnostic scan failed. */
-      } finally {
-        scansInFlight.delete(sessionID);
-      }
-    },
-  };
+/** The Working Repository above `directory`, when it is wrapped for OpenCode. */
+export function repositoryWrappedForOpenCode(directory: string): string | undefined {
+  const projection = resolveProjection(directory);
+  if (!projection || !readWrapStateSync(projection.repoRoot).runtimes.has("opencode")) {
+    return undefined;
+  }
+  return projection.repoRoot;
 }
 
 /**
@@ -126,14 +36,17 @@ export function createReactDoctorScanner(
 const repairedCompanions = new Set<string>();
 
 /**
- * Session start is the only point at which the companion may move without
- * invalidating a read the session has already taken. The launch-environment
- * gate comes first so a Managed Session does no Git work at all; the consent
- * gate is the operation's own.
+ * A fetch at session start, for a location Session Prepare does not serve.
+ * In a repository wrapped for OpenCode the plugin's background sync performs
+ * the same unattended operation, so this one steps aside. Elsewhere it only
+ * tries the companion lock: a held lock means another sync is already on it.
+ * The launch-environment gate comes first so a Managed Session does no Git
+ * work at all; the consent gate is the operation's own.
  */
 export async function repairCompanionGitOnce(
   context: CompanionContext,
   env: Record<string, string | undefined> = process.env,
+  directory?: string,
 ): Promise<string[]> {
   if (
     !context.companionPath ||
@@ -141,6 +54,7 @@ export async function repairCompanionGitOnce(
       (env[MATE_ENV.repositoryPath] !== undefined || env[MATE_ENV.gitAutoMode] !== "1"))
   )
     return [];
+  if (directory && repositoryWrappedForOpenCode(directory)) return [];
   if (repairedCompanions.has(context.companionPath)) return [];
   repairedCompanions.add(context.companionPath);
 
@@ -149,7 +63,10 @@ export async function repairCompanionGitOnce(
    * unattended. The V2 server API has no toast; the notes reach the operator
    * through the persisted record and the TUI's staleness lines.
    */
-  return unattendedSyncStalenessLines(await syncCompanionUnattended(context.companionPath));
+  return unattendedSyncStalenessLines(
+    await syncCompanionUnattended(context.companionPath, { lock: "try" }),
+    "opencode",
+  );
 }
 
 /** Test seam: the once-per-session guard is process-wide by design. */
@@ -200,11 +117,6 @@ export async function guardToolInput(
   }
 }
 
-export type CompanionHooksOptions = {
-  /** Test seam for the React Doctor process. */
-  run?: CommandRunner;
-};
-
 /**
  * Registers the companion guardrails on an OpenCode V2 plugin context.
  * The caller resolves `context` and skips this when no companion resolved.
@@ -212,34 +124,14 @@ export type CompanionHooksOptions = {
 export async function registerCompanionHooks(
   api: Context,
   context: CompanionContext,
-  options: CompanionHooksOptions = {},
-): Promise<Cleanup | undefined> {
+): Promise<void> {
   /**
    * Anything escaping the repair would cost the session every guardrail
    * below to save a synchronization that is optional by design.
    */
-  await repairCompanionGitOnce(context).catch(() => []);
+  await repairCompanionGitOnce(context, process.env, api.location.directory).catch(() => []);
 
   await api.tool.hook("execute.before", (event) =>
     guardToolInput(context, event.tool, event.input),
   );
-
-  if (!context.repositoryPath || !context.reactDoctorEnabled) return;
-
-  const scanner = createReactDoctorScanner(context, api.session, options.run);
-  await api.tool.hook("execute.after", (event) => {
-    if (event.status === "completed") scanner.markEdited(event.tool, event.sessionID);
-  });
-
-  const controller = new AbortController();
-  void (async () => {
-    try {
-      for await (const event of api.event.subscribe({ signal: controller.signal })) {
-        if (event.type === "session.idle") await scanner.idle(event.data.sessionID);
-      }
-    } catch {
-      /** Plugin shutdown aborts the subscription; event delivery is best effort. */
-    }
-  })();
-  return () => controller.abort();
 }

package/src/opencode/companion-policy.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { persistedCompanionGitStalenessLines } from "../runtime/companion-sync";
 import { resolveCompanionRuntime, type CompanionRuntimeContext } from "../runtime/env";
 import { projectionFreshness, projectionStalenessLines } from "../runtime/freshness";
+import { readSessionNotes } from "./session-notes";
 
 export type CompanionContext = CompanionRuntimeContext & {
   agentsMd: string;
@@ -189,14 +190,29 @@ export function readContext(
     }
   }
 
-  return {
-    ...context,
-    agentsMd,
-    stalenessLines: projection
-      ? [
-          ...projectionStalenessLines(projection, projectionFreshness(projection)),
-          ...persistedCompanionGitStalenessLines(context.companionPath),
-        ]
-      : [],
-  };
+  return { ...context, agentsMd, stalenessLines: stalenessLinesFor(context, projection) };
+}
+
+function stalenessLinesFor(
+  context: CompanionRuntimeContext,
+  projection: ReturnType<typeof resolveCompanionRuntime>["projection"],
+): string[] {
+  if (!projection) return [];
+  /** A sync note repeats the persisted Git line it came from. */
+  return [
+    ...new Set([
+      ...projectionStalenessLines(projection, projectionFreshness(projection)),
+      ...persistedCompanionGitStalenessLines(context.companionPath, undefined, "opencode"),
+      ...(context.repositoryPath ? readSessionNotes(context.repositoryPath) : []),
+    ]),
+  ];
+}
+
+/** The session state alone, cheap enough for the TUI to poll: no `AGENTS.md` read, no Git. */
+export function readStalenessLines(
+  env: Record<string, string | undefined> = process.env,
+  cwd: string = process.cwd(),
+): string[] {
+  const { context, projection } = resolveCompanionRuntime(env, cwd);
+  return stalenessLinesFor(context, projection);
 }

package/src/opencode/index.ts

@@ -5,12 +5,6 @@
  * test). Must not reach OpenTUI or Solid: the Mate TUI plugin lives on the
  * `./opencode/tui` subpath.
  */
-export {
-  createReactDoctorScanner,
-  guardToolInput,
-  registerCompanionHooks,
-  type CommandRunner,
-  type CompanionHooksOptions,
-} from "./companion-hooks";
+export { guardToolInput, registerCompanionHooks } from "./companion-hooks";
 export { resolveOpenCodeGuidance, type OpenCodeGuidanceResolution } from "./projected-guidance";
 export * from "./companion-policy";

package/src/opencode/session-notes.ts

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { repoLocalDirPath } from "../runtime/repo-local";
+import { writeAtomic } from "../runtime/write-atomic";
+
+/**
+ * The last plugin prepare's operator notes, per phase. The V2 server API has
+ * no toast, so the TUI reads them with its staleness lines and toasts new ones.
+ */
+export type SessionNotePhase = "prepare" | "sync";
+
+type SessionNotes = Partial<Record<SessionNotePhase, string[]>>;
+
+function notesPath(repoPath: string): string {
+  return path.join(repoLocalDirPath(repoPath), "session-notes.json");
+}
+
+function readAll(repoPath: string): SessionNotes {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(notesPath(repoPath), "utf8")) as unknown;
+    return typeof parsed === "object" && parsed !== null ? (parsed as SessionNotes) : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Per notes file, the record still in flight. Each record reads the file and
+ * writes it back; the background sync's report can overlap the next prepare's,
+ * and an unordered write would bring back notes the other just cleared.
+ */
+const inFlight = new Map<string, Promise<void>>();
+
+/** Replaces one phase's notes; an empty list clears them. Best-effort. */
+export function recordSessionNotes(
+  repoPath: string,
+  phase: SessionNotePhase,
+  notes: readonly string[],
+): Promise<void> {
+  const target = notesPath(repoPath);
+  const recorded = (inFlight.get(target) ?? Promise.resolve()).then(() =>
+    writeNotes(repoPath, target, phase, notes),
+  );
+  inFlight.set(target, recorded);
+  void recorded.then(() => {
+    if (inFlight.get(target) === recorded) inFlight.delete(target);
+  });
+  return recorded;
+}
+
+async function writeNotes(
+  repoPath: string,
+  target: string,
+  phase: SessionNotePhase,
+  notes: readonly string[],
+): Promise<void> {
+  const next: SessionNotes = { ...readAll(repoPath), [phase]: [...notes] };
+  try {
+    if (Object.values(next).every((lines) => !lines?.length)) {
+      await fsp.rm(target, { force: true });
+      return;
+    }
+    await fsp.mkdir(path.dirname(target), { recursive: true });
+    await writeAtomic(target, `${JSON.stringify(next, null, 2)}\n`);
+  } catch {
+    /* the log already carries the notes */
+  }
+}
+
+export function readSessionNotes(repoPath: string): string[] {
+  return Object.values(readAll(repoPath)).flatMap((lines) =>
+    Array.isArray(lines) ? lines.filter((line) => typeof line === "string") : [],
+  );
+}

package/src/opencode/session-prepare.ts

@@ -0,0 +1,139 @@
+import type { Cleanup, Context } from "@opencode/plugin/promise/plugin";
+
+import {
+  PREPARE_TIMEOUT_MS,
+  type PrepareRun,
+  type PrepareRunner,
+} from "../runtime/session-prepare-runner";
+import { recordSessionNotes, type SessionNotePhase } from "./session-notes";
+
+/**
+ * Plugin side of `mate session prepare`: a bare OpenCode session in a wrapped
+ * repo gets a managed launch's local prepare, then a background Git sync.
+ * Spawned, so a crash or stale module never reaches the shared service.
+ */
+
+export interface SessionPrepareOptions {
+  directory: string;
+  repoPath: string;
+  companionPath: string;
+  /** Mate-declared MCP servers; only these are held back until the local phase ends. */
+  mateServers: readonly string[];
+  run: PrepareRunner;
+  log?: (line: string) => void;
+  timeoutMs?: number;
+  debounceMs?: number;
+}
+
+const PREPARE_DEBOUNCE_MS = 5_000;
+
+/** Keyed by companion: several repositories, and several locations, share one companion. */
+const lastSynced = new Map<string, number>();
+
+/** Test seam: the debounce is process-wide. */
+export function resetPrepareDebounce(): void {
+  lastSynced.clear();
+}
+
+function logger(options: SessionPrepareOptions): (line: string) => void {
+  return options.log ?? ((line: string) => console.error(line));
+}
+
+/** Logs the notes and records them for the TUI's toast. */
+async function report(
+  options: SessionPrepareOptions,
+  run: PrepareRun,
+  phase: SessionNotePhase,
+): Promise<void> {
+  const log = logger(options);
+  const verdict = run.ok ? "warning" : "failed";
+  for (const note of run.notes) log(`mate: session ${phase} ${verdict}: ${note}`);
+  await recordSessionNotes(options.repoPath, phase, run.notes);
+}
+
+function failedRun(error: unknown): PrepareRun {
+  return { ok: false, notes: [error instanceof Error ? error.message : String(error)] };
+}
+
+/** No remote: OpenCode holds MCP servers and skills until `setup` returns. */
+async function prepareLocal(options: SessionPrepareOptions): Promise<void> {
+  const run = await options
+    .run({ sync: false, timeoutMs: options.timeoutMs ?? PREPARE_TIMEOUT_MS })
+    .catch(failedRun);
+  await report(options, run, "prepare");
+}
+
+/** Never awaited: the session runs on while the companion is fetched. */
+function startSync(api: Context, options: SessionPrepareOptions): void {
+  lastSynced.set(options.companionPath, Date.now());
+  void options
+    .run({ sync: true })
+    .catch(failedRun)
+    .then(async (run) => {
+      await report(options, run, "sync");
+      if (!run.changed) return;
+      await api.mcp.reload().catch(() => {});
+      logger(options)("mate: companion updated; MCP servers reloaded.");
+    });
+}
+
+function eventDirectory(event: unknown): string | undefined {
+  const record = event as {
+    location?: { directory?: string };
+    data?: { location?: { directory?: string } };
+  };
+  return record.location?.directory ?? record.data?.location?.directory;
+}
+
+/**
+ * Holds the Mate MCP servers back, runs the local phase before `setup`
+ * returns, releases them, then syncs the companion in the background; syncs
+ * again on new sessions of this location. Neither a failed nor a slow prepare
+ * keeps the session from starting, and none is ever terminated.
+ */
+export async function registerSessionPrepare(
+  api: Context,
+  options: SessionPrepareOptions,
+): Promise<Cleanup> {
+  const held = new Set(options.mateServers);
+  let gated = held.size > 0;
+  if (gated) {
+    await api.mcp.transform((editor) => {
+      if (!gated) return;
+      for (const name of held) {
+        if (editor.get(name)) {
+          editor.update(name, (config) => {
+            config.disabled = true;
+          });
+        }
+      }
+    });
+  }
+
+  try {
+    await prepareLocal(options);
+  } finally {
+    if (gated) {
+      gated = false;
+      await api.mcp.reload().catch(() => {});
+    }
+  }
+  startSync(api, options);
+
+  const controller = new AbortController();
+  const debounceMs = options.debounceMs ?? PREPARE_DEBOUNCE_MS;
+  void (async () => {
+    try {
+      for await (const event of api.event.subscribe({ signal: controller.signal })) {
+        if (event.type !== "session.created") continue;
+        if (eventDirectory(event) !== options.directory) continue;
+        const last = lastSynced.get(options.companionPath) ?? 0;
+        if (Date.now() - last < debounceMs) continue;
+        startSync(api, options);
+      }
+    } catch {
+      /* subscription closed: the location is shutting down */
+    }
+  })();
+  return () => controller.abort();
+}

package/src/opencode/tui.tsx

@@ -4,10 +4,10 @@
  * OpenCode V2 TUI plugin module (`{ id, setup }`), OpenCode 2.x only.
  * Solid JSX, not React: `key` is not a reconciliation prop here and `TextProps`
  * does not accept it, so the jsx-key rules cannot be satisfied — only suppressed.
- * Static arrays render through `.map`; a reactive one would need `<For>`.
+ * Arrays render through `.map`: Solid re-runs it whole on a store change, fine for a few lines.
  */
 import { mateVersion } from "../runtime/install";
-import { readContext } from "./companion-policy";
+import { readContext, readStalenessLines } from "./companion-policy";
 
 /** Minimal structural slice of the OpenCode V2 TUI API; the published SDK ships no V2 TUI types. */
 export type MateTuiApi = {
@@ -20,6 +20,14 @@ export type MateTuiApi = {
   };
   ui: {
     slot(claim: MateSlotClaim): () => void;
+    toast: { show(options: { title?: string; message: string; variant?: "warning" }): void };
+  };
+  storage: {
+    /** A host Solid store: reads inside a render are reactive. */
+    memory<Value extends object>(
+      key: string,
+      options: { readonly initial: Value },
+    ): readonly [Value, (mutation: (draft: Value) => void) => void];
   };
 };
 
@@ -31,13 +39,26 @@ export type MateSlotClaim = {
 
 export type MateTuiPluginModule = {
   id: string;
-  setup(api: MateTuiApi): void | Promise<void>;
+  setup(api: MateTuiApi): void | (() => void) | Promise<void | (() => void)>;
 };
 
+/** A background sync finishes after the first render; the lines must follow it. */
+export const STALENESS_POLL_MS = 5_000;
+
+type SessionNotes = { lines: string[] };
+
 const MIDNIGHT_PURPLE_BRIGHT = "#c084fc";
 const MATE_VERSION = process.env.MATE_VERSION ?? mateVersion();
 
-function SessionContext({ api, sidebar = false }: { api: MateTuiApi; sidebar?: boolean }) {
+function SessionContext({
+  api,
+  notes,
+  sidebar = false,
+}: {
+  api: MateTuiApi;
+  notes: SessionNotes;
+  sidebar?: boolean;
+}) {
   const context = readContext();
   const text = api.theme.text;
   const warning = text.feedback?.warning?.base ?? text.muted;
@@ -54,21 +75,47 @@ function SessionContext({ api, sidebar = false }: { api: MateTuiApi; sidebar?: b
       <text fg={MIDNIGHT_PURPLE_BRIGHT}>mate v{MATE_VERSION}</text>
       <text fg={text.muted}>repo: {context.repositoryPath}</text>
       <text fg={text.muted}>mate: {context.companionPath}</text>
-      {context.stalenessLines.map((note) => (
+      {notes.lines.map((note) => (
         <text fg={warning}>{note}</text>
       ))}
     </box>
   );
 }
 
-function setup(api: MateTuiApi): void {
+/** Polls the session lines; a line that appears after startup is also raised as a toast. */
+function setup(api: MateTuiApi): (() => void) | undefined {
   const context = readContext();
   if (!context.companionPath || !context.repositoryPath) {
-    return;
+    return undefined;
   }
 
-  api.ui.slot({ prepend: "home.footer", render: () => <SessionContext api={api} /> });
-  api.ui.slot({ append: "sidebar.content", render: () => <SessionContext api={api} sidebar /> });
+  const [notes, setNotes] = api.storage.memory<SessionNotes>("mate-session-notes", {
+    initial: { lines: context.stalenessLines },
+  });
+  setNotes((draft) => {
+    draft.lines = context.stalenessLines;
+  });
+  const timer = setInterval(() => {
+    const lines = readStalenessLines();
+    if (lines.join("\n") === notes.lines.join("\n")) return;
+    const shown = new Set(notes.lines);
+    const added = lines.filter((line) => !shown.has(line));
+    setNotes((draft) => {
+      draft.lines = lines;
+    });
+    for (const message of added) api.ui.toast.show({ title: "mate", message, variant: "warning" });
+  }, STALENESS_POLL_MS);
+  timer.unref?.();
+
+  api.ui.slot({
+    prepend: "home.footer",
+    render: () => <SessionContext api={api} notes={notes} />,
+  });
+  api.ui.slot({
+    append: "sidebar.content",
+    render: () => <SessionContext api={api} notes={notes} sidebar />,
+  });
+  return () => clearInterval(timer);
 }
 
 const plugin: MateTuiPluginModule = {

package/src/runtime/claude-delivery-plan.ts

@@ -0,0 +1,73 @@
+import type { ClaudeHookGroup } from "./claude-hook-group";
+import { NOT_WRAPPED, readWrapStateSync, type WrapState } from "./wrap-state";
+
+/**
+ * Claude Delivery Plan: the owner of each Claude contribution, as one pure
+ * function. Callers act on it and decide no ownership. In `runtime/` so hooks
+ * may import it.
+ */
+
+/**
+ * `managed-repo`: `mate claude` with a Working Repository; its prepare just
+ * reconciled the Claude wrap, which the launcher asserts. `managed-companion`:
+ * a companion-scoped launch. `unmanaged`: a session with no launch environment.
+ */
+export type SessionKind = "managed-repo" | "managed-companion" | "unmanaged";
+
+export interface ClaudeDeliveryPlan {
+  /** Capability hook groups; `launchSettingsExclude` is what `--settings` must not repeat. */
+  readonly hooks: {
+    readonly owner: "wrap" | "settings" | "none";
+    readonly launchSettingsExclude: readonly ClaudeHookGroup[];
+  };
+  /** Mate MCP servers. */
+  readonly mcp: "wrap" | "mcp-config" | "none";
+  /** Companion directory access. */
+  readonly dirAccess: "wrap" | "add-dir" | "none";
+  /** Wrap reconciliation. */
+  readonly reconcile: "attended-prepare" | "prepare-hook" | "none";
+  /** Companion Git synchronization. */
+  readonly gitSync: "launch-preflight" | "prepare-hook" | "banner";
+}
+
+export function planClaudeDelivery(kind: SessionKind, wrap: WrapState): ClaudeDeliveryPlan {
+  switch (kind) {
+    case "managed-repo":
+      return {
+        hooks: { owner: "wrap", launchSettingsExclude: wrap.carriedClaudeHookGroups },
+        mcp: "wrap",
+        dirAccess: "wrap",
+        reconcile: "attended-prepare",
+        gitSync: "launch-preflight",
+      };
+    case "managed-companion":
+      return {
+        hooks: { owner: "settings", launchSettingsExclude: [] },
+        mcp: "mcp-config",
+        dirAccess: "add-dir",
+        reconcile: "none",
+        gitSync: "launch-preflight",
+      };
+    case "unmanaged":
+      return wrap.runtimes.has("claude")
+        ? {
+            hooks: { owner: "wrap", launchSettingsExclude: [] },
+            mcp: "wrap",
+            dirAccess: "wrap",
+            reconcile: "prepare-hook",
+            gitSync: "prepare-hook",
+          }
+        : {
+            hooks: { owner: "none", launchSettingsExclude: [] },
+            mcp: "none",
+            dirAccess: "none",
+            reconcile: "none",
+            gitSync: "banner",
+          };
+  }
+}
+
+/** For session-start hooks: a plain session's plan from a lenient read; no root, not wrapped. */
+export function unmanagedClaudeDelivery(repoRoot: string | undefined): ClaudeDeliveryPlan {
+  return planClaudeDelivery("unmanaged", repoRoot ? readWrapStateSync(repoRoot) : NOT_WRAPPED);
+}