@uniqbit/mate-core 0.18.4 → 1.0.0-canary.0

package/src/hooks/companion-instructions.ts

@@ -0,0 +1,190 @@
+/** Delivers the Companion Instructions to a Claude main thread or subagent. */
+import { errorMessage } from "../runtime/error-message";
+import { planClaudeInstructions } from "../runtime/claude-delivery-plan";
+import {
+  COMPANION_INSTRUCTIONS_BUDGET,
+  buildCompanionInstructions,
+  companionInstructionsUnavailableLine,
+  type CompanionInstructionsInput,
+  type InstructionReader,
+} from "../runtime/companion-instructions";
+import { MATE_ENV, hasLaunchEnvironment } from "../runtime/env";
+import { FRAMEWORK_NAME } from "../runtime/framework";
+import { PROJECTED_FLAG } from "../runtime/projected-flag";
+import { resolveProjection } from "../runtime/projection";
+import { managedSessionKind, type SessionKind } from "../runtime/session-kind";
+import { hookOutcome, runHook, type HookCall, type HookEnv } from "./hook-io";
+
+export interface InstructionHookPayload {
+  hookSpecificOutput?: { hookEventName: InstructionEvent; additionalContext: string };
+  systemMessage?: string;
+}
+
+export interface InstructionHookInput {
+  hook_event_name?: string;
+  agent_type?: string;
+  cwd?: string;
+}
+
+/** A hook run, with the shim arguments already read. */
+export interface InstructionHookCall extends Omit<HookCall, "argv"> {
+  /** The copy a wrap carries, marked `--projected`. */
+  projected: boolean;
+  /** Where the projection resolves; the event's `cwd` when unset. */
+  directory?: string;
+}
+
+export interface InstructionHookDeps {
+  read?: InstructionReader;
+  resolveProjection?: typeof resolveProjection;
+}
+
+/**
+ * Agents never given a copy, since Claude Code's matchers cannot exclude them:
+ * Explore and Plan skip project memory by design, and a fork inherits its
+ * parent's context, which already holds the instructions.
+ */
+const SKIPPED_AGENTS = new Set(["Explore", "Plan", "fork"]);
+
+type InstructionEvent = "SessionStart" | "SubagentStart";
+
+const INPUT_FIELDS = ["hook_event_name", "agent_type", "cwd"] as const;
+
+function normalizeInput(raw: unknown): InstructionHookInput {
+  const input: InstructionHookInput = {};
+  if (!raw || typeof raw !== "object") return input;
+  for (const field of INPUT_FIELDS) {
+    const value = (raw as Record<string, unknown>)[field];
+    if (typeof value === "string") input[field] = value;
+  }
+  return input;
+}
+
+function sessionKind(env: HookEnv): SessionKind {
+  if (!hasLaunchEnvironment(env)) return "unmanaged";
+  return managedSessionKind(Boolean(env[MATE_ENV.repositoryPath]));
+}
+
+/**
+ * A copy runs only because the bundled plugin or a Claude wrap installed it, so
+ * a session with no launch environment is planned as Claude-wrapped without
+ * reading the Checkout's manifest: a linked worktree runs the main checkout's
+ * wrapped settings and has none of its own.
+ */
+function ownsEvent(event: InstructionEvent, kind: SessionKind, projected: boolean): boolean {
+  const owners = planClaudeInstructions(kind, true);
+  if (event === "SessionStart") return owners.main === "wrap-session-hook" && projected;
+  if (owners.subagents === "plugin-subagent-hook") return !projected;
+  if (owners.subagents === "wrap-subagent-hook") return projected;
+  return false;
+}
+
+/** A launch sets every path; a partial one is not completed from a projection, which may name another repository. */
+function launchReaderInput(env: HookEnv): CompanionInstructionsInput | null {
+  const companionPath = env[MATE_ENV.companionPath];
+  const id = env[MATE_ENV.repositoryId];
+  const repoPath = env[MATE_ENV.repositoryPath];
+  const wrapperBinPath = env[MATE_ENV.wrapperBinPath];
+  if (!companionPath || !id || !repoPath || !wrapperBinPath) return null;
+  return { companionPath, repository: { id, path: repoPath }, wrapperBinPath };
+}
+
+/** The environment always wins: a managed session never reads the projection. */
+function readerInput(
+  env: HookEnv,
+  kind: SessionKind,
+  cwd: string,
+  resolve: typeof resolveProjection,
+): CompanionInstructionsInput | null {
+  if (kind !== "unmanaged") return launchReaderInput(env);
+  const projection = resolve(cwd);
+  if (!projection) return null;
+  return {
+    companionPath: projection.companionPath,
+    /** A linked worktree on a projection copied from the main checkout names itself, not that checkout. */
+    repository: { id: projection.repositoryId, path: projection.repoRoot },
+    wrapperBinPath: projection.wrapperBinPath,
+  };
+}
+
+function oversizeMessage(source: string): string {
+  const marker = FRAMEWORK_NAME.toUpperCase();
+  const budget = COMPANION_INSTRUCTIONS_BUDGET.toLocaleString("en-US");
+  return `${FRAMEWORK_NAME}: the ${marker}:COMPANION block in ${source} leaves no room within the ${budget}-character budget, so the instructions exceed it; Claude Code may deliver them as a file preview. Shorten the block.`;
+}
+
+function evaluate(
+  { env, cwd, projected, directory }: InstructionHookCall,
+  input: InstructionHookInput,
+  deps: InstructionHookDeps,
+): InstructionHookPayload | null {
+  const resolve = deps.resolveProjection ?? resolveProjection;
+  const read = deps.read ?? buildCompanionInstructions;
+  const event = input.hook_event_name;
+  if (event !== "SessionStart" && event !== "SubagentStart") return null;
+  if (event === "SubagentStart" && SKIPPED_AGENTS.has(input.agent_type ?? "")) return null;
+
+  const kind = sessionKind(env);
+  if (!ownsEvent(event, kind, projected)) return null;
+
+  const reader = readerInput(env, kind, directory || input.cwd || cwd, resolve);
+  if (!reader) return null;
+
+  const result = read(reader);
+  if (result.kind === "unavailable") {
+    const line = companionInstructionsUnavailableLine(result);
+    return instructionOutput(event, line, line);
+  }
+  const warning = result.oversized ? oversizeMessage(result.source) : undefined;
+  return instructionOutput(event, result.text, warning);
+}
+
+function instructionOutput(
+  event: InstructionEvent,
+  additionalContext: string,
+  systemMessage?: string,
+): InstructionHookPayload {
+  return {
+    hookSpecificOutput: { hookEventName: event, additionalContext },
+    ...(systemMessage ? { systemMessage } : {}),
+  };
+}
+
+function failure(error: unknown): InstructionHookPayload {
+  return {
+    systemMessage: `${FRAMEWORK_NAME}: companion instructions hook failed: ${errorMessage(error)}`,
+  };
+}
+
+/**
+ * Its own hook output, apart from the Agent Guidance's: Claude Code caps each
+ * output at 10,000 characters. A missing `AGENTS.md` is stated as a fact, never
+ * as an instruction to stop: a SessionStart hook cannot block, and a pause
+ * would stall a `-p` or SDK session.
+ */
+export function instructionHookPayload(
+  call: InstructionHookCall,
+  deps: InstructionHookDeps = {},
+): InstructionHookPayload | null {
+  try {
+    return evaluate(call, normalizeInput(call.input), deps);
+  } catch (error) {
+    return failure(error);
+  }
+}
+
+/** Plugin-shim entry; exits zero even when reading its input fails. */
+export function run(argv: readonly string[] = process.argv.slice(2)): Promise<number> {
+  return runHook(
+    (input) =>
+      hookOutcome(
+        instructionHookPayload({
+          env: process.env,
+          cwd: process.cwd(),
+          projected: argv.includes(PROJECTED_FLAG),
+          input,
+        }),
+      ),
+    (error) => hookOutcome(failure(error)),
+  );
+}

package/src/hooks/hook-io.ts

@@ -0,0 +1,63 @@
+/** Stdin and stdout of a Claude hook shim. */
+
+export type HookEnv = Record<string, string | undefined>;
+
+/** One run of a hook shim: its environment, directory, shim arguments and stdin payload. */
+export interface HookCall {
+  env: HookEnv;
+  cwd: string;
+  argv: readonly string[];
+  input: unknown;
+}
+
+export interface HookOutcome {
+  exitCode: number;
+  stdout: string;
+}
+
+/** A hook's JSON output line, or nothing. Always exit zero: a hook must never block the session. */
+export function hookOutcome(output: object | null): HookOutcome {
+  return { exitCode: 0, stdout: output ? `${JSON.stringify(output)}\n` : "" };
+}
+
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) return "";
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+/** The hook payload on stdin; input that is not JSON reads as `null`, no event. */
+async function readHookInput(): Promise<unknown> {
+  const raw = await readStdin();
+  try {
+    return JSON.parse(raw) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A hook shim's whole run: read the payload, build the outcome, write it.
+ * `onError` turns a failure in either step into an outcome, so the shim still exits zero.
+ */
+export async function runHook(
+  build: (input: unknown) => HookOutcome | Promise<HookOutcome>,
+  onError: (error: unknown) => HookOutcome,
+): Promise<number> {
+  let outcome: HookOutcome;
+  try {
+    outcome = await build(await readHookInput());
+  } catch (error) {
+    outcome = onError(error);
+  }
+  writeHookStdout(outcome.stdout);
+  return outcome.exitCode;
+}
+
+/** Swallows stdout errors: a parent that stopped reading would otherwise end the write in an uncaught `EPIPE`. */
+function writeHookStdout(stdout: string): void {
+  if (!stdout) return;
+  process.stdout.on("error", () => {});
+  process.stdout.write(stdout);
+}

package/src/hooks/session-banner.ts

@@ -1,5 +1,8 @@
-// Show the active Mate companion paths in Claude Code, and repair the
-// companion's Git state before the session reads it.
+/**
+ * Show the active Mate companion paths in Claude Code, and repair the
+ * companion's Git state before the session reads it.
+ */
+import { errorMessage } from "../runtime/error-message";
 import { unmanagedClaudeDelivery } from "../runtime/claude-delivery-plan";
 import {
   syncCompanionUnattended,
@@ -7,24 +10,11 @@ import {
   type UnattendedSyncOptions,
 } from "../runtime/companion-sync";
 import { hasLaunchEnvironment, resolveCompanionRuntime } from "../runtime/env";
+import { FRAMEWORK_NAME } from "../runtime/framework";
 import { projectionFreshness, projectionStalenessLines } from "../runtime/freshness";
 import { mateVersion } from "../runtime/install";
-import type { HookEnv } from "./validate-artifact-path";
-
-export interface BannerOutcome {
-  exitCode: number;
-  stdout: string;
-}
-
-/**
- * Marks the copy a wrap inlines into the Working Repository's settings. A
- * managed launch loads the plugin's own copy *and* that document, and both
- * registrations resolve to the same command against the same environment, so
- * nothing inside the process tells them apart. The flag is what keeps the
- * banner from printing twice in exactly the session that is configured
- * correctly — the projected copy defers, the launch's own copy prints.
- */
-export const PROJECTED_BANNER_FLAG = "--projected";
+import { PROJECTED_FLAG } from "../runtime/projected-flag";
+import { hookOutcome, runHook, type HookEnv, type HookOutcome } from "./hook-io";
 
 /**
  * Resolves in-process from either source — no subprocess in either branch.
@@ -36,13 +26,11 @@ export async function buildBanner(
   cwd: string = process.cwd(),
   argv: readonly string[] = [],
   syncOptions: UnattendedSyncOptions = {},
-): Promise<BannerOutcome> {
-  if (argv.includes(PROJECTED_BANNER_FLAG) && hasLaunchEnvironment(env)) {
-    return { exitCode: 0, stdout: "" };
-  }
+): Promise<HookOutcome> {
+  if (argv.includes(PROJECTED_FLAG) && hasLaunchEnvironment(env)) return hookOutcome(null);
 
   const { context, projection } = resolveCompanionRuntime(env, cwd);
-  if (!context.repositoryPath || !context.companionPath) return { exitCode: 0, stdout: "" };
+  if (!context.repositoryPath || !context.companionPath) return hookOutcome(null);
 
   /**
    * Repaired before the session reads the companion, so its first reads are
@@ -78,12 +66,16 @@ export async function buildBanner(
   /** `systemMessage` only: the model must never be told to run the command. */
   for (const note of gitNotes) lines.push(`  ${note}`);
 
-  return { exitCode: 0, stdout: JSON.stringify({ systemMessage: lines.join("\n") }) + "\n" };
+  return hookOutcome({ systemMessage: lines.join("\n") });
 }
 
-// Plugin-shim entry.
-export async function run(argv: readonly string[] = process.argv.slice(2)): Promise<number> {
-  const outcome = await buildBanner(process.env, process.cwd(), argv);
-  if (outcome.stdout) process.stdout.write(outcome.stdout);
-  return outcome.exitCode;
+/** Plugin-shim entry; exits zero even when the banner fails. */
+export function run(argv: readonly string[] = process.argv.slice(2)): Promise<number> {
+  return runHook(
+    () => buildBanner(process.env, process.cwd(), argv),
+    (error) =>
+      hookOutcome({
+        systemMessage: `${FRAMEWORK_NAME}: session banner failed: ${errorMessage(error)}`,
+      }),
+  );
 }

package/src/hooks/session-guidance.ts

@@ -1,27 +1,6 @@
 // Deliver the companion guidance to a Claude session Mate did not launch.
-import { currentAudienceLayer, readLayerGuidanceSync } from "../runtime/audience-layer";
-import { resolveProjection } from "../runtime/projection";
 import { buildProjectedGuidance } from "../runtime/projected-guidance";
-import { readWrapStateSync } from "../runtime/wrap-state";
-import type { HookEnv } from "./validate-artifact-path";
-
-export interface GuidanceOutcome {
-  exitCode: number;
-  stdout: string;
-}
-
-/**
- * The guidance of the audience this checkout is wrapped for, from its layer.
- * The wrap is the only source: an inherited `MATE_AUDIENCE` selects nothing.
- */
-function wrappedAudienceGuidance(cwd: string): string {
-  const projection = resolveProjection(cwd);
-  if (!projection) return "";
-  const audience = readWrapStateSync(projection.repoRoot).audience;
-  if (!audience) return "";
-  const layer = currentAudienceLayer(projection.companionPath, audience);
-  return layer ? readLayerGuidanceSync(layer, "CLAUDE.md") : "";
-}
+import { hookOutcome, type HookEnv, type HookOutcome } from "./hook-io";
 
 /**
  * `SessionStart.additionalContext` is the file-based form of the managed
@@ -33,21 +12,16 @@ function wrappedAudienceGuidance(cwd: string): string {
  * Emits nothing rather than a note when no companion resolves: an unwrapped
  * repository must read exactly as it did before the hook existed.
  */
-export function buildSessionGuidance(env: HookEnv, cwd: string = process.cwd()): GuidanceOutcome {
-  const companionGuidance = buildProjectedGuidance(env, cwd);
-  if (!companionGuidance) return { exitCode: 0, stdout: "" };
-  const layer = wrappedAudienceGuidance(cwd);
-  const guidance = layer ? `${companionGuidance}\n\n${layer}` : companionGuidance;
+export function buildSessionGuidance(env: HookEnv, cwd: string = process.cwd()): HookOutcome {
+  const guidance = buildProjectedGuidance(env, cwd);
+  if (!guidance) return hookOutcome(null);
 
-  return {
-    exitCode: 0,
-    stdout: `${JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: "SessionStart",
-        additionalContext: guidance,
-      },
-    })}\n`,
-  };
+  return hookOutcome({
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: guidance,
+    },
+  });
 }
 
 // Plugin-shim entry.

package/src/hooks/session-prepare.ts

@@ -1,8 +1,11 @@
 /** Prepares a plain Claude session in a Claude-wrapped repository as `mate claude` would. */
 import fs from "node:fs";
 
+import { errorMessage } from "../runtime/error-message";
 import { unmanagedClaudeDelivery } from "../runtime/claude-delivery-plan";
 import { hasLaunchEnvironment } from "../runtime/env";
+import { FRAMEWORK_NAME } from "../runtime/framework";
+import { PROJECTED_FLAG } from "../runtime/projected-flag";
 import { resolveProjection } from "../runtime/projection";
 import { runtimeDirectoryPath, runtimeMateBin } from "../runtime/runtime-directory";
 import {
@@ -12,12 +15,8 @@ import {
   type PrepareRun,
   type PrepareRunner,
 } from "../runtime/session-prepare-runner";
-import type { HookEnv } from "./validate-artifact-path";
-
-export interface SessionPrepareHookOutcome {
-  exitCode: number;
-  stdout: string;
-}
+import { instructionHookPayload, type InstructionHookDeps } from "./companion-instructions";
+import { hookOutcome, runHook, type HookCall, type HookEnv, type HookOutcome } from "./hook-io";
 
 export interface SessionPrepareHookDeps {
   /** The runtime-directory launcher; `null` until a `mate` run wrote it. */
@@ -25,6 +24,8 @@ export interface SessionPrepareHookDeps {
   runner: (mateBin: string, repoPath: string) => PrepareRunner;
   startSync: (mateBin: string, repoPath: string) => void;
   timeoutMs: number;
+  /** The main thread's instruction read, after the prepare. */
+  instructions?: InstructionHookDeps;
 }
 
 export const sessionPrepareHookDeps: SessionPrepareHookDeps = {
@@ -37,12 +38,9 @@ export const sessionPrepareHookDeps: SessionPrepareHookDeps = {
   timeoutMs: PREPARE_TIMEOUT_MS,
 };
 
-const INERT: SessionPrepareHookOutcome = { exitCode: 0, stdout: "" };
-
 /** `systemMessage` only: the model must never be told to repair the companion. */
-function operatorMessage(lines: string[]): SessionPrepareHookOutcome {
-  if (lines.length === 0) return INERT;
-  return { exitCode: 0, stdout: `${JSON.stringify({ systemMessage: lines.join("\n") })}\n` };
+function operatorMessage(lines: string[]): HookOutcome {
+  return hookOutcome(lines.length > 0 ? { systemMessage: lines.join("\n") } : null);
 }
 
 async function runLocalPhase(
@@ -54,10 +52,18 @@ async function runLocalPhase(
   try {
     return await pending;
   } catch (error) {
-    return { ok: false, notes: [error instanceof Error ? error.message : String(error)] };
+    return { ok: false, notes: [errorMessage(error)] };
   }
 }
 
+/** The local phase's notes, and the Git sync it leaves for the caller to start. */
+interface Prepared {
+  notes: string[];
+  startSync: () => void;
+}
+
+const NO_SYNC = (): void => {};
+
 /**
  * Inert under a launch environment or where the plan gives it nothing to own.
  * Awaits the local phase within a bound, then starts Git sync detached. Always
@@ -67,35 +73,116 @@ export async function runSessionPrepareHook(
   env: HookEnv,
   cwd: string = process.cwd(),
   deps: SessionPrepareHookDeps = sessionPrepareHookDeps,
-): Promise<SessionPrepareHookOutcome> {
-  if (hasLaunchEnvironment(env)) return INERT;
-  const projectDir = env.CLAUDE_PROJECT_DIR || cwd;
+): Promise<HookOutcome> {
+  const prepared = await guardedPrepare(env, cwd, deps);
+  return operatorMessage([...prepared.notes, ...startSync(prepared)]);
+}
+
+/** The folder the prepare runs in, and the main thread's instructions are read from. */
+function prepareDirectory(env: HookEnv, cwd: string): string {
+  return env.CLAUDE_PROJECT_DIR || cwd;
+}
+
+function prepareFailure(error: unknown): string {
+  return `${FRAMEWORK_NAME}: session prepare failed: ${errorMessage(error)}`;
+}
+
+/** A prepare that throws becomes a note, so the instructions after it still go out. */
+async function guardedPrepare(
+  env: HookEnv,
+  cwd: string,
+  deps: SessionPrepareHookDeps,
+): Promise<Prepared> {
+  try {
+    return await prepare(env, cwd, deps);
+  } catch (error) {
+    return { notes: [prepareFailure(error)], startSync: NO_SYNC };
+  }
+}
+
+/** A sync that fails to start becomes a note. */
+function startSync(prepared: Prepared): string[] {
+  try {
+    prepared.startSync();
+    return [];
+  } catch (error) {
+    return [prepareFailure(error)];
+  }
+}
+
+async function prepare(env: HookEnv, cwd: string, deps: SessionPrepareHookDeps): Promise<Prepared> {
+  const nothing = { notes: [], startSync: NO_SYNC };
+  if (hasLaunchEnvironment(env)) return nothing;
+  const projectDir = prepareDirectory(env, cwd);
   const projection = resolveProjection(projectDir);
-  if (!projection) return INERT;
+  if (!projection) return nothing;
   const plan = unmanagedClaudeDelivery(projection.repoRoot);
   const reconciles = plan.reconcile === "prepare-hook";
   const syncs = plan.gitSync === "prepare-hook";
-  if (!reconciles && !syncs) return INERT;
+  if (!reconciles && !syncs) return nothing;
 
   const mateBin = deps.mateBin();
   if (!mateBin) {
-    return operatorMessage([
-      `mate: session prepare skipped: ${runtimeDirectoryPath()} is missing; run \`mate\` once to repair it.`,
-    ]);
+    return {
+      notes: [
+        `${FRAMEWORK_NAME}: session prepare skipped: ${runtimeDirectoryPath()} is missing; run \`${FRAMEWORK_NAME}\` once to repair it.`,
+      ],
+      startSync: NO_SYNC,
+    };
   }
 
   const local = reconciles
     ? await runLocalPhase(deps, mateBin, projectDir)
     : { ok: true, notes: [] };
-  if (syncs) deps.startSync(mateBin, projectDir);
-
   const verdict = local.ok ? "warning" : "failed";
-  return operatorMessage(local.notes.map((note) => `mate: session prepare ${verdict}: ${note}`));
+  return {
+    notes: local.notes.map((note) => `${FRAMEWORK_NAME}: session prepare ${verdict}: ${note}`),
+    startSync: syncs ? () => deps.startSync(mateBin, projectDir) : NO_SYNC,
+  };
+}
+
+/**
+ * Legacy rule: wraps before `--projected` registered this copy bare, and only
+ * this hook re-wraps them. So a bare copy counts as the wrap's unless
+ * `CLAUDE_PLUGIN_ROOT`, set for plugin hooks only, marks it as the plugin's.
+ */
+function isWrapCopy({ argv, env }: HookCall): boolean {
+  return argv.includes(PROJECTED_FLAG) || !env.CLAUDE_PLUGIN_ROOT;
+}
+
+/**
+ * The prepare, the main thread's Companion Instructions, then the Git sync, in
+ * one hook: Claude Code runs an event's hooks in parallel, and the prepare and
+ * a fast-forward both rewrite the files the instructions are read from. Only
+ * the wrap's copy runs any. Input that is not a JSON object is no event.
+ */
+export async function runSessionStartHook(
+  call: HookCall,
+  deps: SessionPrepareHookDeps = sessionPrepareHookDeps,
+): Promise<HookOutcome> {
+  const { env, cwd, input } = call;
+  if (!input || typeof input !== "object" || Array.isArray(input)) return hookOutcome(null);
+  if (!isWrapCopy(call)) return hookOutcome(null);
+  const prepared = await guardedPrepare(env, cwd, deps);
+  const { hookSpecificOutput, systemMessage } =
+    instructionHookPayload(
+      { env, cwd, input, projected: true, directory: prepareDirectory(env, cwd) },
+      deps.instructions,
+    ) ?? {};
+  const notes = [...prepared.notes, ...startSync(prepared)];
+  const messages = systemMessage ? [...notes, systemMessage] : notes;
+  if (!hookSpecificOutput) return operatorMessage(messages);
+  return hookOutcome({
+    hookSpecificOutput,
+    ...(messages.length > 0 ? { systemMessage: messages.join("\n") } : {}),
+  });
 }
 
-/** Plugin-shim entry. */
-export async function run(): Promise<number> {
-  const outcome = await runSessionPrepareHook(process.env);
-  if (outcome.stdout) process.stdout.write(outcome.stdout);
-  return outcome.exitCode;
+/** Plugin-shim entry; exits zero even when reading its input fails. */
+export function run(argv: readonly string[] = process.argv.slice(2)): Promise<number> {
+  return runHook(
+    (input) => runSessionStartHook({ env: process.env, cwd: process.cwd(), argv, input }),
+    (error) =>
+      operatorMessage([`${FRAMEWORK_NAME}: session start hook failed: ${errorMessage(error)}`]),
+  );
 }