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

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,11 +1,6 @@
 // Deliver the companion guidance to a Claude session Mate did not launch.
 import { buildProjectedGuidance } from "../runtime/projected-guidance";
-import type { HookEnv } from "./validate-artifact-path";
-
-export interface GuidanceOutcome {
-  exitCode: number;
-  stdout: string;
-}
+import { hookOutcome, type HookEnv, type HookOutcome } from "./hook-io";
 
 /**
  * `SessionStart.additionalContext` is the file-based form of the managed
@@ -17,19 +12,16 @@ export interface GuidanceOutcome {
  * 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 {
+export function buildSessionGuidance(env: HookEnv, cwd: string = process.cwd()): HookOutcome {
   const guidance = buildProjectedGuidance(env, cwd);
-  if (!guidance) return { exitCode: 0, stdout: "" };
+  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)}`]),
+  );
 }

package/src/hooks/validate-artifact-path.ts

@@ -12,12 +12,15 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+import { artifactRefusal, resolveArtifactTarget } from "../runtime/artifact-refusal";
+import { checkCommitAttribution } from "../runtime/commit-attribution-guard";
 import { gitEnvironment } from "../runtime/companion-git";
 import { companionForkRefusal } from "../runtime/companion-sync";
 import { readCompanionRuntimeContext } from "../runtime/env";
 import { companionLinkPath } from "../runtime/repo-local";
-
-export type HookEnv = Record<string, string | undefined>;
+import { checkSecretAccess, type SecretToolCall } from "../runtime/secret-guard";
+import { stripHeredocBodies } from "../runtime/shell-heredoc";
+import type { HookEnv } from "./hook-io";
 
 export interface HookOutcome {
   exitCode: number;
@@ -44,8 +47,9 @@ const ARTIFACT_PATH_MARKERS = [
   "/docs/prd/",
 ];
 
-const MD_REDIRECT_PATTERN = />{1,2}\s*([^\s;|&<>]+\.md)\b/g;
-const MD_TEE_PATTERN = /\btee\s+(?:-a\s+)?([^\s;|&<>]+\.md)\b/g;
+/** `[ \t]`, not `\s`: a redirect or `tee` names its target on its own line. */
+const MD_REDIRECT_PATTERN = />{1,2}[ \t]*([^\s;|&<>]+\.md)\b/g;
+const MD_TEE_PATTERN = /\btee[ \t]+(?:-a[ \t]+)?([^\s;|&<>]+\.md)\b/g;
 
 export function artifactLikePath(filePath: string): boolean {
   if (!filePath) return false;
@@ -118,11 +122,6 @@ function claudeConfigRoot(env: HookEnv): string {
   return path.normalize(path.join(env.HOME || os.homedir(), ".claude"));
 }
 
-function normalizePath(filePath: string, ctx: GuardContext): string {
-  if (path.isAbsolute(filePath)) return path.normalize(filePath);
-  return path.normalize(path.join(ctx.repoRoot, filePath));
-}
-
 function isUnder(target: string, root: string): boolean {
   const relative = path.relative(path.normalize(root), path.normalize(target));
   return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
@@ -181,17 +180,14 @@ function isProductDocumentationPath(target: string, ctx: GuardContext): boolean
   return false;
 }
 
-function blockWrite(target: string, companion: string): HookOutcome {
-  const lines = [
-    "Mate guardrail: artifact writes must go to the companion framework path.",
-    ` target: ${target}`,
-    ` companion: ${companion}`,
-    "Use an absolute path under MATE_ARTIFACT_PATH instead.",
-  ];
-  if (path.basename(target) === "CLAUDE.md") {
-    lines.push(`Note: CLAUDE.md already lives in the companion repo at ${companion}/CLAUDE.md.`);
-  }
-  return { exitCode: 2, stderr: lines.join("\n") + "\n" };
+function blockWrite(target: string, resolved: string, ctx: GuardContext): HookOutcome {
+  const refusal = artifactRefusal({
+    target,
+    resolved,
+    companion: ctx.companion,
+    repoRoot: ctx.repoRoot,
+  });
+  return { exitCode: 2, stderr: `${refusal}\n` };
 }
 
 function checkFilePath(
@@ -201,7 +197,7 @@ function checkFilePath(
 ): HookOutcome | null {
   if (!filePath) return null;
 
-  const normalized = normalizePath(filePath, ctx);
+  const normalized = resolveArtifactTarget(filePath, ctx.repoRoot);
   if (isCompanionPath(normalized, ctx)) return null;
 
   if (isUnder(normalized, claudeConfigRoot(ctx.env))) return null;
@@ -219,7 +215,7 @@ function checkFilePath(
     return null;
   }
 
-  return blockWrite(filePath, ctx.companion);
+  return blockWrite(filePath, normalized, ctx);
 }
 
 /**
@@ -234,17 +230,19 @@ async function checkForkedCompanion(
   ctx: GuardContext,
 ): Promise<HookOutcome | null> {
   if (!filePath || !artifactLikePath(filePath)) return null;
-  if (!isCompanionPath(normalizePath(filePath, ctx), ctx)) return null;
+  if (!isCompanionPath(resolveArtifactTarget(filePath, ctx.repoRoot), ctx)) return null;
 
   const refusal = await companionForkRefusal(ctx.env, ctx.companion);
   return refusal ? { exitCode: 2, stderr: `${refusal}\n` } : null;
 }
 
+/** Heredoc bodies are what a command writes, not what it runs: they are not scanned. */
 export function commandMatches(command: string): string[] {
   const targets: string[] = [];
+  const commandText = stripHeredocBodies(command);
   for (const pattern of [MD_REDIRECT_PATTERN, MD_TEE_PATTERN]) {
     const matcher = new RegExp(pattern.source, pattern.flags);
-    for (const match of command.matchAll(matcher)) {
+    for (const match of commandText.matchAll(matcher)) {
       const target = match[1].trim().replace(/^["']+|["']+$/g, "");
       if (target) targets.push(target);
     }
@@ -252,6 +250,53 @@ export function commandMatches(command: string): string[] {
   return targets;
 }
 
+/** Claude tool payloads in the shape the shared secret guard reads. */
+function secretToolCall(
+  toolName: string,
+  toolInput: Record<string, unknown>,
+  ctx: GuardContext,
+): SecretToolCall | null {
+  const text = (value: unknown) => (typeof value === "string" ? value : "");
+  const target = (value: unknown) =>
+    text(value) ? resolveArtifactTarget(text(value), ctx.repoRoot) : "";
+  switch (toolName) {
+    case "Read":
+      return { kind: "read", paths: [target(toolInput.file_path)] };
+    case "Write":
+      return {
+        kind: "write",
+        writes: [{ path: target(toolInput.file_path), content: text(toolInput.content) }],
+      };
+    case "Edit":
+      return {
+        kind: "write",
+        writes: [{ path: target(toolInput.file_path), content: text(toolInput.new_string) }],
+      };
+    case "MultiEdit": {
+      const edits = Array.isArray(toolInput.edits) ? toolInput.edits : [];
+      const content = edits
+        .map((edit) => (edit && typeof edit === "object" ? text(edit.new_string) : ""))
+        .join("\n");
+      return { kind: "write", writes: [{ path: target(toolInput.file_path), content }] };
+    }
+    case "NotebookEdit":
+      return {
+        kind: "write",
+        writes: [{ path: target(toolInput.notebook_path), content: text(toolInput.new_source) }],
+      };
+    case "Bash":
+      return { kind: "shell", command: text(toolInput.command) };
+    case "Grep":
+      return {
+        kind: "search",
+        paths: [target(toolInput.path)],
+        globs: [text(toolInput.glob)],
+      };
+    default:
+      return null;
+  }
+}
+
 /**
  * Fails open only when no Mate context resolves from either source; in a
  * wrapped Working Repository the guard runs without a launch.
@@ -273,6 +318,16 @@ export async function evaluate(
       ? (input.tool_input as Record<string, unknown>)
       : {};
 
+  /** Secrets first: a secret refusal wins over every artifact-placement verdict. */
+  const secretCall = secretToolCall(toolName, toolInput, ctx);
+  if (secretCall) {
+    const refusal = await checkSecretAccess(secretCall, {
+      companionPath: ctx.companion,
+      isCompanionPath: (target) => isCompanionPath(target, ctx),
+    });
+    if (refusal) return { exitCode: 2, stderr: `${refusal}\n` };
+  }
+
   if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
     const filePath = String(toolInput.file_path ?? "");
     /** The path refusal wins when both apply: its message is not replaced. */
@@ -282,6 +337,9 @@ export async function evaluate(
 
   if (toolName === "Bash") {
     const command = String(toolInput.command ?? "");
+    const attribution = checkCommitAttribution(command);
+    if (attribution) return { exitCode: 2, stderr: `${attribution}\n` };
+
     const targets = commandMatches(command);
     for (const target of targets) {
       const outcome = checkFilePath(target, ctx);

package/src/index.ts

@@ -39,13 +39,17 @@ export type {
   McpService,
   Plugin,
   PluginCliCommand,
+  PluginDirectoryContribution,
   PluginPolicy,
   PluginRegistration,
   ProviderHosting,
   ProviderPlugin,
+  RuntimeContributions,
+  RuntimeContributionsByRuntime,
   SetupContext,
   TemplatesService,
 } from "./tools/setup/plugin";
+export type { SessionKind } from "./runtime/session-kind";
 export type {
   FrameworkType,
   FrameworkConfig,