@jameslovespancakes/pi-plus 1.0.11 → 1.0.12

package/src/domains/workflows/runtime/discovery.ts

@@ -0,0 +1,137 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { LoadedWorkflow, WorkflowSourceIdentity } from "./types.ts";
+import type { PerfSink } from "./perf.ts";
+import { loadWorkflow, parseWorkflowModule } from "./workflow-module.ts";
+import { BUILTIN_SOURCE_ROOT, BUILTIN_WORKFLOW_DEFINITIONS, BUILTIN_WORKFLOW_FILES } from "./workflows.ts";
+import { captureTreeFingerprint } from "./tree-fingerprint.ts";
+import { FINGERPRINT_EXCLUDED_RELATIVE_PATHS } from "./resume-context.ts";
+import { unknownErrorMessage } from "./unknown-error.ts";
+import { workflowDebug } from "./debug.ts";
+
+export interface DiscoverWorkflowsOptions {
+  readonly refresh?: boolean;
+  readonly perf?: PerfSink;
+  readonly userWorkflowDir?: string;
+}
+
+const DISCOVERY_FINGERPRINT_MAX_BYTES = 32 << 20;
+const DISCOVERY_FINGERPRINT_MAX_FILES = 4096;
+
+const discoveryCache = new Map<string, Map<string, LoadedWorkflow>>();
+/** Best-effort dynamic load of every `*.ts` workflow in a directory. */
+async function loadDir(
+  dir: string,
+  sourceIdentity: (path: string) => WorkflowSourceIdentity,
+  excludeFiles: ReadonlySet<string> = new Set(),
+  provenanceRoot?: string,
+): Promise<LoadedWorkflow[]> {
+  let entries: string[];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+
+  const before = provenanceRoot ? await captureDiscoveryFingerprint(provenanceRoot) : undefined;
+  const modules: Array<{ readonly path: string; readonly module: Parameters<typeof loadWorkflow>[0] }> = [];
+  for (const name of entries) {
+    if (excludeFiles.has(name)) continue;
+    if (!name.endsWith(".ts") || name.startsWith("_") || name.startsWith(".")) continue;
+    try {
+      const path = join(dir, name);
+      const importUrl = pathToFileURL(path);
+      if (before?.kind === "verified") importUrl.searchParams.set("workflowSource", before.fingerprint);
+      const loaded: unknown = await import(importUrl.href);
+      const parsed = parseWorkflowModule(loaded);
+      if ("module" in parsed) modules.push({ path, module: parsed.module });
+      else workflowDebug(`skipped ${name}: ${parsed.reason}`);
+    } catch (error) {
+      // Drop-in loading depends on the runtime resolving TS + the bundled typebox.
+      // Failures here are non-fatal: the static registry still works.
+      workflowDebug(`skipped ${name}: ${unknownErrorMessage(error)}`);
+    }
+  }
+  return modules.map(({ path, module }) => loadWorkflow(module, sourceIdentity(path)));
+}
+
+async function captureDiscoveryFingerprint(root: string) {
+  return await captureTreeFingerprint({
+    root,
+    excludedRelativePaths: FINGERPRINT_EXCLUDED_RELATIVE_PATHS,
+    maxBytes: DISCOVERY_FINGERPRINT_MAX_BYTES,
+    maxFiles: DISCOVERY_FINGERPRINT_MAX_FILES,
+  });
+}
+
+/**
+ * All available workflows by name. Static registry wins on name collisions, so the
+ * bundled example is always the verified one even if a same-named file is dropped in.
+ */
+export async function discoverWorkflows(repoDir: string, options: DiscoverWorkflowsOptions = {}): Promise<Map<string, LoadedWorkflow>> {
+  const userWorkflowDir = options.userWorkflowDir ?? join(getAgentDir(), "workflows");
+  const cacheKey = `${repoDir}\0${userWorkflowDir}`;
+  const cached = discoveryCache.get(cacheKey);
+  if (cached && !options.refresh) {
+    options.perf?.counter("discovery.cache_hit");
+    return new Map(cached);
+  }
+
+  const byName = await timed(options.perf, "discovery.total_ms", async () => {
+    const next = new Map<string, LoadedWorkflow>();
+    const builtinSource = await captureDiscoveryFingerprint(BUILTIN_SOURCE_ROOT);
+    for (const definition of BUILTIN_WORKFLOW_DEFINITIONS) {
+      const source: WorkflowSourceIdentity =
+        builtinSource.kind === "verified"
+          ? {
+              kind: "file",
+              path: definition.path,
+              root: definition.root,
+              fingerprint: builtinSource.fingerprint,
+            }
+          : {
+              kind: "unverifiable",
+              reason: `built-in workflow source capture failed: ${builtinSource.reason}`,
+            };
+      next.set(definition.module.meta.name, loadWorkflow(definition.module, source));
+    }
+
+    const repoWorkflowDir = join(repoDir, "workflows");
+    const [repoDynamic, userDynamic] = await Promise.all([
+      timed(options.perf, "discovery.repo_dir_ms", () =>
+        loadDir(
+          repoWorkflowDir,
+          () => ({
+            kind: "unverifiable",
+            reason: "dynamic workflow module graphs are not loaded from an immutable source snapshot",
+          }),
+          BUILTIN_WORKFLOW_FILES,
+          repoDir,
+        ),
+      ),
+      timed(options.perf, "discovery.user_dir_ms", () =>
+        loadDir(userWorkflowDir, () => ({
+          kind: "unverifiable",
+          reason: "dynamic user workflow dependencies do not have a declared trusted source root",
+        })),
+      ),
+    ]);
+
+    for (const mod of repoDynamic) {
+      if (!next.has(mod.meta.name)) next.set(mod.meta.name, mod);
+    }
+    for (const mod of userDynamic) {
+      if (!next.has(mod.meta.name)) next.set(mod.meta.name, mod);
+    }
+    return next;
+  });
+
+  discoveryCache.set(cacheKey, byName);
+  return new Map(byName);
+}
+
+async function timed<T>(perf: PerfSink | undefined, name: string, fn: () => Promise<T>): Promise<T> {
+  return perf ? await perf.time(name, fn) : await fn();
+}

package/src/domains/workflows/runtime/dynamax-shortcuts.ts

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { Key, type KeyId } from "@earendil-works/pi-tui";
+import { workflowDebug } from "./debug.ts";
+
+export const DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT = "ctrl+shift+m" satisfies KeyId;
+export const DEFAULT_REVIEW_RESULTS_SHORTCUT = "ctrl+shift+r" satisfies KeyId;
+
+const CONFIG_FILE_NAME = "pi-workflow-engine.json";
+
+export interface DynamaxShortcuts {
+  inspector: KeyId | null;
+  results: KeyId | null;
+}
+
+interface DynamaxShortcutConfig {
+  inspector?: unknown;
+  results?: unknown;
+}
+
+export function dynamaxShortcutsConfigPath(agentDir: string = getAgentDir()): string {
+  return join(agentDir, "extensions", CONFIG_FILE_NAME);
+}
+
+export function resolveDynamaxShortcuts(configPath: string = dynamaxShortcutsConfigPath()): DynamaxShortcuts {
+  if (!existsSync(configPath)) return defaultDynamaxShortcuts();
+
+  const config = readShortcutConfig(configPath);
+  if (!config) return defaultDynamaxShortcuts();
+
+  const shortcuts = {
+    inspector: shortcutFromConfig("inspector", config.inspector, DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT, configPath),
+    results: shortcutFromConfig("results", config.results, DEFAULT_REVIEW_RESULTS_SHORTCUT, configPath),
+  };
+  if (shortcuts.inspector && shortcuts.results && shortcutIdentity(shortcuts.inspector) === shortcutIdentity(shortcuts.results)) {
+    workflowDebug(`duplicate shortcut ${shortcuts.inspector} in ${configPath}; disabling the results shortcut`);
+    return { inspector: shortcuts.inspector, results: null };
+  }
+  return shortcuts;
+}
+
+function readShortcutConfig(configPath: string): DynamaxShortcutConfig | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    warnUsingDefaults("Could not read", configPath);
+    return null;
+  }
+
+  const shortcuts = isRecord(parsed) ? parsed.shortcuts : undefined;
+  if (shortcuts === undefined) return {};
+  if (!isRecord(shortcuts)) {
+    warnUsingDefaults("Invalid", configPath);
+    return null;
+  }
+
+  return shortcuts;
+}
+
+function shortcutFromConfig(
+  name: keyof DynamaxShortcutConfig,
+  configured: unknown,
+  fallback: KeyId,
+  configPath: string,
+): KeyId | null {
+  if (configured === null) return null;
+  if (configured === undefined) return fallback;
+  if (typeof configured === "string") {
+    const normalized = configured.trim();
+    if (isKeyId(normalized)) return normalized;
+  }
+  workflowDebug(`invalid ${name} shortcut in ${configPath}; using ${fallback}`);
+  return fallback;
+}
+
+const MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
+const NAMED_BASE_KEYS = new Set<string>(Object.values(Key).flatMap((value) => (typeof value === "string" ? [String(value)] : [])));
+
+function isKeyId(value: string): value is KeyId {
+  return parseKeyId(value) !== undefined;
+}
+
+function parseKeyId(value: string): { readonly modifiers: readonly string[]; readonly base: string } | undefined {
+  const seen = new Set<string>();
+  let base = value;
+  while (true) {
+    const separator = base.indexOf("+");
+    if (separator < 0) break;
+    const modifier = base.slice(0, separator);
+    if (!MODIFIERS.has(modifier) || seen.has(modifier)) break;
+    seen.add(modifier);
+    base = base.slice(separator + 1);
+  }
+  return isBaseKey(base) ? { modifiers: [...seen], base } : undefined;
+}
+
+function isBaseKey(value: string): boolean {
+  return /^[a-z0-9]$/.test(value) || NAMED_BASE_KEYS.has(value);
+}
+
+function shortcutIdentity(shortcut: KeyId): string {
+  const parsed = parseKeyId(shortcut);
+  if (!parsed) return shortcut;
+  let base = parsed.base;
+  if (base === "esc") base = "escape";
+  else if (base === "return") base = "enter";
+  return `${[...parsed.modifiers].sort().join("+")}+${base}`;
+}
+
+function defaultDynamaxShortcuts(): DynamaxShortcuts {
+  return { inspector: DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT, results: DEFAULT_REVIEW_RESULTS_SHORTCUT };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function warnUsingDefaults(reason: "Could not read" | "Invalid", configPath: string): void {
+  workflowDebug(`${reason} config at ${configPath}; using default shortcuts`);
+}

package/src/domains/workflows/runtime/dynamax.ts

@@ -0,0 +1,330 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { CustomEditor, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { EditorComponent, KeyId } from "@earendil-works/pi-tui";
+import { resolveDynamaxShortcuts, type DynamaxShortcuts } from "./dynamax-shortcuts.ts";
+import { sessionKey } from "./session-identity.ts";
+import { unknownErrorMessage } from "./unknown-error.ts";
+import {
+  decorateDynamaxEditor,
+  resolveDynamaxEffect,
+  type DynamaxAnimationScheduler,
+  type DynamaxEditorDecoration,
+  type DynamaxEffect,
+} from "./ui/dynamax-editor-decoration.ts";
+
+export interface DynamaxState {
+  sticky: boolean;
+  oneShotPending: boolean;
+  turnActive: boolean;
+}
+
+export interface DynamaxRuntime {
+  state: DynamaxState;
+  runningWorkflow?: string;
+}
+
+export type DynamaxRuntimeStore = Map<string, DynamaxRuntime>;
+
+export interface DynamaxRegistrationOptions {
+  openInspector?: (ctx: ExtensionContext) => Promise<void> | void;
+  effect?: DynamaxEffect;
+  animationScheduler?: DynamaxAnimationScheduler;
+}
+
+export const DYNAMAX_TOKEN_PATTERN = /(^|[^A-Za-z0-9_])dynamax([^A-Za-z0-9_]|$)/i;
+export const DYNAMAX_STATUS_KEY = "dynamax";
+
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
+
+interface DynamaxEditorInstallation {
+  factory: EditorFactory;
+  previousFactory: EditorFactory | undefined;
+  decorations: Set<DynamaxEditorDecoration>;
+}
+
+function disposeDynamaxDecorations(decorations: Set<DynamaxEditorDecoration>): void {
+  for (const decoration of decorations) decoration.dispose();
+  decorations.clear();
+}
+
+export const ADAPTIVE_WORKFLOW_GUIDANCE = `
+Adaptive multi-pass workflows are optional. Use a simple single-pass fan-out when it is sufficient. When the first pass may expose gaps, conflicts, weak claims, or missing evidence:
+- run the bounded first-pass agents;
+- give their surviving results to a structured gap-analysis agent so the LLM decides what needs follow-up;
+- put a hard maxItems bound on LLM-authored task arrays and defensively slice them before fan-out;
+- use ordinary TypeScript conditionals or bounded loops to launch follow-up agents only when gaps exist;
+- synthesize the first-pass and follow-up results together.
+Do not generate a second pass when the first pass is sufficient, and do not invent iteration, quorum, graph, reduction, or retry primitives for this pattern.`;
+
+export const DYNAMAX_REMINDER = `
+## dynamax workflow opt-in
+
+The user has opted into dynamax multi-agent orchestration. The workflow tool is permitted for this task. You may either run an existing named workflow or author a new inline workflow script when that best serves the user's request.
+
+Inline workflow rules:
+- Use the injected Type object for schemas, for example Type.Object({ ok: Type.Boolean() }); do not import typebox.
+- Do not use import statements or dynamic import() in inline workflow scripts.
+- Set profile to "small", "medium", or "big" on each agent() call so routing remains explicit; use model/thinkingLevel only for an intentional override.
+- Subagents receive no skills by default. Add \`skills: ["skill-name"]\` per agent only when that stage should load that skill; grant the smallest useful set.
+- Provide exactly one of workflow.name or workflow.script.
+
+${ADAPTIVE_WORKFLOW_GUIDANCE}
+`;
+
+const DYNAMAX_CONTEXT_CUSTOM_TYPE = "workflow-dynamax-reminder";
+
+export function createDynamaxState(): DynamaxState {
+  return { sticky: false, oneShotPending: false, turnActive: false };
+}
+
+export function createDynamaxRuntime(): DynamaxRuntime {
+  return { state: createDynamaxState() };
+}
+
+export function getDynamaxRuntime(store: DynamaxRuntimeStore, ctx: Pick<ExtensionContext, "sessionManager">): DynamaxRuntime {
+  const key = sessionKey(ctx);
+  const existing = store.get(key);
+  if (existing) return existing;
+  const runtime = createDynamaxRuntime();
+  store.set(key, runtime);
+  return runtime;
+}
+
+export function hasDynamaxToken(text: string): boolean {
+  return DYNAMAX_TOKEN_PATTERN.test(text);
+}
+
+export function markDynamaxOneShot(state: DynamaxState): void {
+  state.oneShotPending = true;
+}
+
+export function enableDynamaxSticky(state: DynamaxState): void {
+  state.sticky = true;
+}
+
+export function clearDynamax(state: DynamaxState): void {
+  state.sticky = false;
+  state.oneShotPending = false;
+  state.turnActive = false;
+}
+
+export function isDynamaxActive(state: DynamaxState): boolean {
+  return state.sticky || state.oneShotPending || state.turnActive;
+}
+
+export function describeDynamaxState(state: DynamaxState): string {
+  const sticky = state.sticky ? "on" : "off";
+  const oneShot = state.oneShotPending ? "pending" : "clear";
+  const turn = state.turnActive ? "; active for current turn" : "";
+  return `sticky ${sticky}; one-shot ${oneShot}${turn}`;
+}
+
+export function dynamaxWidgetLine(state: DynamaxState, shortcut: KeyId | null, runningWorkflow?: string): string {
+  const modes = [
+    runningWorkflow ? `running ${runningWorkflow}` : undefined,
+    state.sticky ? "sticky on" : undefined,
+    !state.sticky && state.turnActive ? "active this turn" : undefined,
+    state.oneShotPending ? "one-shot pending" : undefined,
+  ].filter((value): value is string => value !== undefined);
+  const mode = modes.join(" + ") || "off";
+  const inspectorHint = shortcut ? `${shortcut} board` : "/workflow";
+  return `dynamax: ${mode} | ${inspectorHint}`;
+}
+
+export function appendDynamaxSystemReminder(systemPrompt: string, state: DynamaxState): string {
+  if (!state.sticky && !state.oneShotPending) return systemPrompt;
+  state.oneShotPending = false;
+  state.turnActive = true;
+  return `${systemPrompt}\n\n${DYNAMAX_REMINDER.trim()}`;
+}
+
+export function appendDynamaxContextReminder(messages: AgentMessage[], state: DynamaxState): AgentMessage[] {
+  if (!state.sticky) return messages;
+  return [...messages, createDynamaxContextMessage()];
+}
+
+export function registerDynamax(
+  pi: ExtensionAPI,
+  shortcuts: DynamaxShortcuts = resolveDynamaxShortcuts(),
+  options: DynamaxRegistrationOptions = {},
+): void {
+  const runtimes: DynamaxRuntimeStore = new Map();
+  const effect = options.effect ?? resolveDynamaxEffect();
+  let editorInstallation: DynamaxEditorInstallation | undefined;
+  const openInspector =
+    options.openInspector ??
+    ((ctx: ExtensionContext): void => {
+      ctx.ui.notify("No workflow inspector is available yet", "warning");
+    });
+  const installEditor = (ctx: ExtensionContext): void => {
+    if (ctx.mode !== "tui" || effect === "off") return;
+    const previousFactory = ctx.ui.getEditorComponent();
+    if (editorInstallation && editorInstallation.factory === previousFactory) return;
+
+    const decorations = new Set<DynamaxEditorDecoration>();
+    const installation: DynamaxEditorInstallation = {
+      previousFactory,
+      decorations,
+      factory: (tui, theme, keybindings) => {
+        const decorate = (editor: EditorComponent): EditorComponent => {
+          const decoration = decorateDynamaxEditor(editor, () => tui.requestRender(), {
+            effect,
+            scheduler: options.animationScheduler,
+            isActive: () => editorInstallation === installation && ctx.ui.getEditorComponent() === installation.factory,
+          });
+          decorations.add(decoration);
+          return decoration.editor;
+        };
+        if (!previousFactory) return decorate(new CustomEditor(tui, theme, keybindings));
+
+        let editor: EditorComponent;
+        try {
+          editor = previousFactory(tui, theme, keybindings);
+        } catch (error) {
+          ctx.ui.notify(
+            `Dynamax could not compose the existing custom editor (${unknownErrorMessage(error)}); using pi's stock-compatible CustomEditor so highlighting stays enabled`,
+            "warning",
+          );
+          installation.previousFactory = undefined;
+          return decorate(new CustomEditor(tui, theme, keybindings));
+        }
+
+        try {
+          return decorate(editor);
+        } catch (error) {
+          ctx.ui.notify(
+            `Dynamax could not decorate the existing custom editor (${unknownErrorMessage(error)}); using pi's stock-compatible CustomEditor so highlighting stays enabled`,
+            "warning",
+          );
+          return decorate(new CustomEditor(tui, theme, keybindings));
+        }
+      },
+    };
+
+    try {
+      ctx.ui.setEditorComponent(installation.factory);
+    } catch (error) {
+      disposeDynamaxDecorations(decorations);
+      ctx.ui.notify(`Dynamax highlighting could not be installed: ${unknownErrorMessage(error)}`, "error");
+      throw error;
+    }
+    editorInstallation = installation;
+  };
+  const uninstallEditor = (ctx: ExtensionContext): void => {
+    const installation = editorInstallation;
+    if (!installation) return;
+    editorInstallation = undefined;
+    disposeDynamaxDecorations(installation.decorations);
+    if (ctx.mode === "tui" && ctx.ui.getEditorComponent() === installation.factory) {
+      ctx.ui.setEditorComponent(installation.previousFactory);
+    }
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    installEditor(ctx);
+    updateDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx), shortcuts);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    uninstallEditor(ctx);
+    clearDynamaxSurfaces(ctx);
+  });
+
+  pi.on("input", (event, ctx) => {
+    if (event.source === "extension") return { action: "continue" };
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    if (hasDynamaxToken(event.text)) {
+      markDynamaxOneShot(runtime.state);
+      updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    }
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    const systemPrompt = appendDynamaxSystemReminder(event.systemPrompt, runtime.state);
+    if (systemPrompt === event.systemPrompt) return undefined;
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    return { systemPrompt };
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    runtime.runningWorkflow = undefined;
+    if (!runtime.state.sticky) runtime.state.turnActive = false;
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    if (event.toolName !== "workflow") return undefined;
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    runtime.runningWorkflow = workflowLabel(event.args);
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    return undefined;
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    if (event.toolName !== "workflow") return undefined;
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    runtime.runningWorkflow = undefined;
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    return undefined;
+  });
+
+  pi.on("context", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    const messages = appendDynamaxContextReminder(event.messages, runtime.state);
+    if (messages === event.messages) return undefined;
+    return { messages };
+  });
+
+  if (shortcuts.inspector) {
+    pi.registerShortcut(shortcuts.inspector, {
+      description: "Open workflow inspector",
+      handler: async (ctx) => {
+        await openInspector(ctx);
+      },
+    });
+  }
+
+}
+
+export function updateDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">, runtime: DynamaxRuntime, shortcuts: DynamaxShortcuts): void {
+  if (!ctx.hasUI) return;
+  if (!isDynamaxActive(runtime.state) && !runtime.runningWorkflow) {
+    clearDynamaxSurfaces(ctx);
+    return;
+  }
+
+  const status = dynamaxWidgetLine(runtime.state, shortcuts.inspector, runtime.runningWorkflow);
+  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, status);
+}
+
+export function clearDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">): void {
+  if (!ctx.hasUI) return;
+  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, undefined);
+}
+
+function workflowLabel(args: unknown): string {
+  if (!isRecord(args)) return "workflow";
+  const name = args.name;
+  if (typeof name === "string" && name.trim()) return name.trim();
+  const script = args.script;
+  if (typeof script === "string" && script.trim()) return "inline workflow";
+  return "workflow";
+}
+
+function createDynamaxContextMessage(): AgentMessage {
+  return {
+    role: "custom",
+    customType: DYNAMAX_CONTEXT_CUSTOM_TYPE,
+    content: DYNAMAX_REMINDER.trim(),
+    display: false,
+    details: { dynamax: true, sticky: true },
+    timestamp: Date.now(),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}