owflow 0.5.0 → 0.7.0

package/dist/tools/fork_task.js

@@ -1,14 +1,24 @@
-import { tool } from "@opencode-ai/plugin";
-import path from "node:path";
-import { forkTask } from "../utils/fork-task.js";
+import { tool } from '@opencode-ai/plugin';
+import path from 'node:path';
+import { forkTask } from '../utils/fork-task.js';
+import { RESEARCH_DIRECTORY_NAME, TASKS_DIRECTORY_NAME, workflowRelativePath } from '../utils/workflow-paths.js';
 export const fork_task = tool({
-    description: "Fork a research task: copy the whole source task directory into a new date-prefixed directory named from the slug, then trim the copied state so the fork continues from the chosen completed step (fork point) onwards. The source task is never modified.",
+    description: 'Fork a research task: copy the whole source task directory into a new date-prefixed directory named from the slug, then trim the copied state so the fork continues from the chosen completed step (fork point) onwards. The source task is never modified.',
     args: {
-        taskRoot: tool.schema.string().describe("Project-relative root of all tasks (typically '.owflow/tasks')"),
-        source: tool.schema.string().describe("Source task path or identifier under .owflow/tasks/research/"),
-        slug: tool.schema.string().describe("Lowercase-kebab-case slug for the fork name, 3-5 words, WITHOUT the date prefix (derived by the agent from a short descriptive name)"),
-        from: tool.schema.string().describe("Fork point: a completed step slug from the source task's completed_phases (e.g. 'synthesis-complete'); the fork continues from the step after it"),
-        intent: tool.schema.string().optional().describe("Optional one-line description of what the fork should explore; stamped into the fork's orchestrator.options.fork_information.intent"),
+        taskRoot: tool.schema.string().describe(`Project-relative root of all tasks (typically '${workflowRelativePath(TASKS_DIRECTORY_NAME)}')`),
+        source: tool.schema
+            .string()
+            .describe(`Source task path or identifier under ${workflowRelativePath(TASKS_DIRECTORY_NAME, RESEARCH_DIRECTORY_NAME)}/`),
+        slug: tool.schema
+            .string()
+            .describe('Lowercase-kebab-case slug for the fork name, 3-5 words, WITHOUT the date prefix (derived by the agent from a short descriptive name)'),
+        from: tool.schema
+            .string()
+            .describe("Fork point: a completed step slug from the source task's completed_phases (e.g. 'synthesis-complete'); the fork continues from the step after it"),
+        intent: tool.schema
+            .string()
+            .optional()
+            .describe("Optional one-line description of what the fork should explore; stamped into the fork's orchestrator.options.fork_information.intent"),
     },
     async execute(args, context) {
         try {
@@ -23,10 +33,10 @@ export const fork_task = tool({
             return {
                 output: [
                     `FORK CREATED`,
-                    `Fork path: ${path.relative(context.directory, result.forkPath).split(path.sep).join("/")}`,
+                    `Fork path: ${path.relative(context.directory, result.forkPath).split(path.sep).join('/')}`,
                     `Fork point: ${result.forkPoint}`,
                     ...(args.intent ? [`Intent: ${args.intent}`] : []),
-                ].join("\n"),
+                ].join('\n'),
             };
         }
         catch (error) {

package/dist/tools/verify_template.d.ts

@@ -0,0 +1,11 @@
+export declare const verify_template: {
+    description: string;
+    args: {
+        filePath: import("zod").ZodString;
+        templateName: import("zod").ZodString;
+    };
+    execute(args: {
+        filePath: string;
+        templateName: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};

package/dist/tools/verify_template.js

@@ -1,40 +1,55 @@
-import { tool } from "@opencode-ai/plugin";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { findStructuralErrors, parseYamlFile, } from "../utils/yaml-structure.js";
+import { tool } from '@opencode-ai/plugin';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findStructuralErrors, parseYamlFile } from '../utils/yaml-structure.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const verify_template = tool({
-    description: "Check if file in the given path exists and follows correct YAML structure by checking against the template file from /templates.",
+    description: 'Check if file in the given path exists and follows correct YAML structure by checking against the template file from /templates.',
     args: {
-        filePath: tool.schema.string().describe("Path to the file to check"),
-        templateName: tool.schema.string().describe("Name of the template from /templates (e.g. orchestrator-state-development.yml)"),
+        filePath: tool.schema.string().describe('Path to the file to check'),
+        templateName: tool.schema.string().describe('Name of the template from /templates (e.g. orchestrator-state-development.yml)'),
     },
     async execute({ filePath, templateName }, context) {
         const absolutePath = path.resolve(context.directory, filePath);
         if (!fs.existsSync(absolutePath)) {
-            return { output: `File not found at ${filePath}. Hint: Double-check the path, create the file if it's missing, or verify you are in the correct directory.` };
+            return {
+                output: `File not found at ${filePath}. Hint: Double-check the path, create the file if it's missing, or verify you are in the correct directory.`,
+            };
         }
-        const templatePath = path.join(__dirname, "../templates", templateName);
-        if (!fs.existsSync(templatePath)) {
-            return { output: `Template '${templateName}' not found. Hint: Verify the template name is correct and exists in the /templates folder (e.g., 'orchestrator-state-development.yml').` };
+        const templatesDir = path.resolve(process.env.OWFLOW_TEMPLATES_DIR ?? path.join(__dirname, '../templates'));
+        const safeTemplateName = path.basename(templateName);
+        const templatePath = path.resolve(templatesDir, safeTemplateName);
+        if (templateName !== safeTemplateName ||
+            templateName.includes('..') ||
+            !templatePath.startsWith(templatesDir + path.sep) ||
+            !fs.existsSync(templatePath)) {
+            return {
+                output: `Template '${templateName}' not found. Hint: Verify the template name is correct and exists in the /templates folder (e.g., 'orchestrator-state-development.yml').`,
+            };
         }
         let targetYaml;
         const parsedTarget = parseYamlFile(absolutePath);
         if (!parsedTarget.ok) {
-            return { output: `YAML Syntax Error in ${filePath}: ${parsedTarget.error}. Hint: Check the file content for invalid YAML formatting, such as incorrect indentation or unescaped strings, and fix them.` };
+            return {
+                output: `YAML Syntax Error in ${filePath}: ${parsedTarget.error}. Hint: Check the file content for invalid YAML formatting, such as incorrect indentation or unescaped strings, and fix them.`,
+            };
         }
         targetYaml = parsedTarget.data;
         let templateYaml;
         const parsedTemplate = parseYamlFile(templatePath);
         if (!parsedTemplate.ok) {
-            return { output: `Internal Error: Failed to parse reference template YAML '${templateName}': ${parsedTemplate.error}. Hint: The template file itself contains invalid YAML syntax.` };
+            return {
+                output: `Internal Error: Failed to parse reference template YAML '${templateName}': ${parsedTemplate.error}. Hint: The template file itself contains invalid YAML syntax.`,
+            };
         }
         templateYaml = parsedTemplate.data;
         const errors = findStructuralErrors(templateYaml, targetYaml);
         if (errors.length > 0) {
-            return { output: `YAML Structure Validation Failed. Your file is missing the following required keys:\n- ${errors.join("\n- ")}\n\nHint: Update the file at ${filePath} to include these missing keys so it matches the structure of '${templateName}'.` };
+            return {
+                output: `YAML Structure Validation Failed. Your file is missing the following required keys:\n- ${errors.join('\n- ')}\n\nHint: Update the file at ${filePath} to include these missing keys so it matches the structure of '${templateName}'.`,
+            };
         }
-        return { output: "File exists and follows the correct YAML structure." };
-    }
+        return { output: 'File exists and follows the correct YAML structure.' };
+    },
 });

package/dist/tui/hooks-dialogs.d.ts

@@ -0,0 +1,20 @@
+import type { TuiPluginApi } from '@opencode-ai/plugin/tui';
+import { type HookEventName, type HookRunLogRecord, type HookRuntimeEntry } from '../types/hook-types.js';
+import { type ActiveHookRow } from './hooks-presenter.js';
+import { type SidebarTheme, type SolidRuntime } from './primitives.js';
+export interface ActiveDialogHandle {
+    readonly event: HookEventName;
+    readonly row: ActiveHookRow;
+    readonly notBefore: number;
+    readonly sessionID?: string;
+    readonly dispose: () => void;
+}
+export declare const getActiveDialogHandle: () => ActiveDialogHandle | undefined;
+export declare const buildHookLogsBody: (record: HookRunLogRecord, theme: SidebarTheme, solid: SolidRuntime, onClose: () => void, maxHeight: number, _renderer?: {
+    requestRender: () => void;
+}) => unknown;
+export declare const buildHookRunDetailBody: (record: HookRunLogRecord, logFile: string, theme: SidebarTheme, solid: SolidRuntime, onShowLogs: () => void, onClose: () => void, totalRunsInSession?: number, _renderer?: {
+    requestRender: () => void;
+}) => unknown;
+export declare const resolveSessionRecords: (logFile: string, row: ActiveHookRow, notBefore: number, sessionID?: string, statusFile?: string, fallbackEntry?: HookRuntimeEntry) => readonly HookRunLogRecord[];
+export declare const openHookLogPopup: (api: TuiPluginApi, solid: SolidRuntime, logFile: string, row: ActiveHookRow, theme: SidebarTheme, notBefore: number, sessionID?: string, statusFile?: string, fallbackEntry?: HookRuntimeEntry) => void;

package/dist/tui/hooks-dialogs.js

@@ -0,0 +1,181 @@
+import { HookEvent, HookRunState } from '../types/hook-types.js';
+import { formatHookLogsMessage, formatHookRunSummary } from './hooks-presenter.js';
+import { el, txt } from './primitives.js';
+import { readHookStatusSnapshot, readSessionHookLogs } from '../hooks/hooks-persistence.js';
+const SHOW_LOGS_LABEL = 'View logs';
+const DETAIL_DIALOG_SIZE = 'large';
+let currentDialogHandle;
+export const getActiveDialogHandle = () => currentDialogHandle;
+const buildHeader = (solid, titleText, theme, onClose) => el(solid, 'box', { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', width: '100%', gap: 1 }, [
+    txt(solid, titleText, theme.text, { flexGrow: 1, textAlign: 'center' }),
+    txt(solid, 'esc', theme.textMuted, { flexShrink: 0, onMouseUp: onClose }),
+]);
+export const buildHookLogsBody = (record, theme, solid, onClose, maxHeight, _renderer) => {
+    const fullText = formatHookLogsMessage(record);
+    const bodyNode = txt(solid, fullText, theme.text, { width: '100%', textAlign: 'left' });
+    const scrollbox = el(solid, 'scrollbox', { width: '100%', height: maxHeight, focused: true }, [bodyNode]);
+    return el(solid, 'box', {
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        width: '100%',
+        paddingLeft: 2,
+        paddingRight: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        gap: 1,
+    }, [buildHeader(solid, `Hook logs: ${record.name}`, theme, onClose), scrollbox]);
+};
+export const buildHookRunDetailBody = (record, logFile, theme, solid, onShowLogs, onClose, totalRunsInSession = 0, _renderer) => {
+    const buttonLabel = txt(solid, SHOW_LOGS_LABEL, theme.selectedListItemText, { flexShrink: 0 });
+    const button = el(solid, 'box', {
+        backgroundColor: theme.primary,
+        paddingLeft: 3,
+        paddingRight: 3,
+        alignItems: 'center',
+        justifyContent: 'center',
+        onMouseUp: onShowLogs,
+        onMouseOver: () => {
+            solid.setProp(button, 'backgroundColor', theme.backgroundElement);
+            solid.setProp(buttonLabel, 'fg', theme.primary);
+        },
+        onMouseOut: () => {
+            solid.setProp(button, 'backgroundColor', theme.primary);
+            solid.setProp(buttonLabel, 'fg', theme.selectedListItemText);
+        },
+    }, [buttonLabel]);
+    const formatDetails = (rec, totalRuns) => [formatHookRunSummary(rec), `Runs in session: ${totalRuns}`, `Log file: ${logFile}`].join('\n');
+    const detailsText = formatDetails(record, totalRunsInSession);
+    const detailsNode = txt(solid, detailsText, theme.textMuted, { width: '100%', textAlign: 'center' });
+    return el(solid, 'box', {
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        width: '100%',
+        paddingLeft: 2,
+        paddingRight: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        gap: 1,
+    }, [
+        buildHeader(solid, `Hook run: ${record.name}`, theme, onClose),
+        detailsNode,
+        el(solid, 'box', { flexDirection: 'row', alignItems: 'center', justifyContent: 'center', width: '100%' }, [button]),
+    ]);
+};
+const createIdleRecord = (row, sessionID) => ({
+    version: 1,
+    runId: `${row.event}#idle`,
+    pid: process.pid,
+    workspace: '',
+    event: row.event,
+    hook: row.name,
+    name: row.name,
+    ...(sessionID !== undefined ? { sessionID } : {}),
+    startedAt: 0,
+    finishedAt: 0,
+    durationMs: 0,
+    status: HookRunState.IDLE,
+});
+export const resolveSessionRecords = (logFile, row, notBefore, sessionID, statusFile, fallbackEntry) => {
+    let records = [];
+    try {
+        records = readSessionHookLogs(logFile, row.event, notBefore, sessionID);
+    }
+    catch { }
+    let entry = fallbackEntry;
+    if (statusFile) {
+        try {
+            const snap = readHookStatusSnapshot(statusFile);
+            if (snap.kind === 'ok' && snap.snapshot.hooks[row.event]) {
+                entry = snap.snapshot.hooks[row.event];
+            }
+        }
+        catch { }
+    }
+    if (entry && entry.status !== HookRunState.IDLE) {
+        const belongs = sessionID && entry.sessionID ? entry.sessionID === sessionID : true;
+        const lastRecord = records[records.length - 1];
+        const shouldAppend = entry.status === HookRunState.PENDING
+            ? lastRecord?.status !== HookRunState.PENDING
+            : lastRecord === undefined || lastRecord.startedAt < entry.startedAt;
+        if (belongs && shouldAppend) {
+            const now = Date.now();
+            const exitCode = entry.exitCode;
+            const runtimeRecord = {
+                version: 1,
+                runId: `${row.event}#${entry.status}`,
+                pid: process.pid,
+                workspace: '',
+                event: row.event,
+                hook: row.name,
+                name: row.name,
+                ...(entry.sessionID !== undefined ? { sessionID: entry.sessionID } : sessionID !== undefined ? { sessionID } : {}),
+                startedAt: entry.startedAt,
+                finishedAt: entry.finishedAt ?? now,
+                durationMs: entry.durationMs ?? Math.max(0, (entry.finishedAt ?? now) - entry.startedAt),
+                status: entry.status,
+                ...(exitCode !== undefined ? { exitCode } : {}),
+                ...(entry.reason !== undefined ? { reason: entry.reason } : {}),
+            };
+            records = [...records, runtimeRecord];
+        }
+    }
+    return records;
+};
+export const openHookLogPopup = (api, solid, logFile, row, theme, notBefore, sessionID, statusFile, fallbackEntry) => {
+    currentDialogHandle?.dispose();
+    const records = resolveSessionRecords(logFile, row, notBefore, sessionID, statusFile, fallbackEntry);
+    try {
+        const targetRecord = records[records.length - 1] ?? createIdleRecord(row, sessionID);
+        const h = api.renderer.height;
+        const maxHeight = Math.max(4, Math.floor(((h > 0 ? h : 24) * 3) / 4) - 8);
+        const onClose = () => {
+            currentDialogHandle?.dispose();
+            api.ui.dialog.clear();
+        };
+        const showLogs = () => {
+            try {
+                currentDialogHandle?.dispose();
+                const latestRecords = resolveSessionRecords(logFile, row, notBefore, sessionID, statusFile, fallbackEntry);
+                const effective = latestRecords[latestRecords.length - 1] ?? targetRecord;
+                const logsHandle = {
+                    event: row.event,
+                    row,
+                    notBefore,
+                    ...(sessionID !== undefined ? { sessionID } : {}),
+                    dispose: () => {
+                        if (currentDialogHandle === logsHandle) {
+                            currentDialogHandle = undefined;
+                        }
+                    },
+                };
+                currentDialogHandle = logsHandle;
+                api.ui.dialog.replace(() => {
+                    const logsBody = buildHookLogsBody(effective, theme, solid, onClose, maxHeight, api.renderer);
+                    return logsBody;
+                }, logsHandle.dispose);
+                api.ui.dialog.setSize(DETAIL_DIALOG_SIZE);
+            }
+            catch { }
+        };
+        const detailHandle = {
+            event: row.event,
+            row,
+            notBefore,
+            ...(sessionID !== undefined ? { sessionID } : {}),
+            dispose: () => {
+                if (currentDialogHandle === detailHandle) {
+                    currentDialogHandle = undefined;
+                }
+            },
+        };
+        currentDialogHandle = detailHandle;
+        api.ui.dialog.replace(() => {
+            const detailBody = buildHookRunDetailBody(targetRecord, logFile, theme, solid, showLogs, onClose, records.length, api.renderer);
+            return detailBody;
+        }, detailHandle.dispose);
+        api.ui.dialog.setSize(DETAIL_DIALOG_SIZE);
+    }
+    catch { }
+};

package/dist/tui/hooks-presenter.d.ts

@@ -0,0 +1,15 @@
+import { HookRunState, type HookEventName, type HookRunLogRecord } from '../types/hook-types.js';
+import type { SidebarTheme } from './primitives.js';
+export interface ActiveHookRow {
+    readonly name: string;
+    readonly event: HookEventName;
+}
+export interface ActiveHooksView {
+    readonly title: string;
+    readonly rows: readonly ActiveHookRow[];
+}
+export declare const buildActiveHooksView: (directory: string) => ActiveHooksView;
+export declare const statusLabelFor: (status: HookRunState | undefined) => string;
+export declare const colorForStatus: (status: HookRunState | undefined, theme: SidebarTheme) => unknown;
+export declare const formatHookRunSummary: (record: HookRunLogRecord, maxChars?: number) => string;
+export declare const formatHookLogsMessage: (record: HookRunLogRecord) => string;

package/dist/tui/hooks-presenter.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import { scanHooks } from '../hooks/hooks-registry.js';
+import { HookDigestMode, HookRunState } from '../types/hook-types.js';
+import { hooksDirectory } from '../utils/workflow-paths.js';
+const ACTIVE_HOOKS_TITLE = 'Active hooks:';
+const RUN_SUMMARY_MAX_CHARS = 4_000;
+export const buildActiveHooksView = (directory) => {
+    const scan = scanHooks(hooksDirectory(directory), { mode: HookDigestMode.Report });
+    return {
+        title: ACTIVE_HOOKS_TITLE,
+        rows: scan.entries.map((entry) => ({
+            name: path.basename(entry.path, path.extname(entry.path)),
+            event: entry.event,
+        })),
+    };
+};
+export const statusLabelFor = (status) => {
+    switch (status) {
+        case HookRunState.PENDING:
+            return 'In progress';
+        case HookRunState.SUCCESS:
+            return 'Success';
+        case HookRunState.FAILURE:
+            return 'Error';
+        default:
+            return 'Idle';
+    }
+};
+export const colorForStatus = (status, theme) => {
+    switch (status) {
+        case HookRunState.PENDING:
+            return theme.warning;
+        case HookRunState.SUCCESS:
+            return theme.success;
+        case HookRunState.FAILURE:
+            return theme.error;
+        default:
+            return theme.textMuted;
+    }
+};
+const truncateMessage = (message, maxChars) => {
+    if (message.length <= maxChars)
+        return message;
+    const suffix = '\n[message truncated]';
+    return message.slice(0, Math.max(0, maxChars - suffix.length)) + suffix;
+};
+export const formatHookRunSummary = (record, maxChars = RUN_SUMMARY_MAX_CHARS) => {
+    const timestamp = record.finishedAt || record.startedAt;
+    const timeLabel = timestamp > 0 ? new Date(timestamp).toISOString() : 'none';
+    const lines = [
+        `Event:  ${record.event}`,
+        `Status: ${statusLabelFor(record.status)} — ${record.durationMs} ms`,
+        `Time:   ${timeLabel}`,
+        `Session: ${record.sessionID ?? 'none'}`,
+        `Exit:   ${record.exitCode ?? 'none'}`,
+    ];
+    return truncateMessage(lines.join('\n'), maxChars);
+};
+export const formatHookLogsMessage = (record) => {
+    const sections = [];
+    if (record.stderr !== undefined && record.stderr.trim().length > 0)
+        sections.push(`--- stderr ---\n${record.stderr.trimEnd()}`);
+    if (record.stdout !== undefined && record.stdout.trim().length > 0)
+        sections.push(`--- stdout ---\n${record.stdout.trimEnd()}`);
+    if (sections.length === 0 && record.reason !== undefined && record.reason.trim().length > 0)
+        sections.push(record.reason.trimEnd());
+    if (sections.length === 0)
+        sections.push('No output captured for this run.');
+    return sections.join('\n\n');
+};

package/dist/tui/hooks-sidebar.d.ts

@@ -0,0 +1,10 @@
+import type { HookRunState, HookRuntimeEntry } from '../types/hook-types.js';
+import { type ActiveHookRow, type ActiveHooksView } from './hooks-presenter.js';
+import { type SidebarTheme, type SolidRuntime } from './primitives.js';
+export interface SidebarRenderHandle {
+    readonly root: unknown;
+    readonly applyStatuses: (snapshotEntries: ReadonlyMap<string, HookRuntimeEntry>) => boolean;
+    readonly disposed: () => boolean;
+    readonly dispose: () => void;
+}
+export declare const materializeSidebar: (view: ActiveHooksView, theme: SidebarTheme, solid: SolidRuntime, onRowClick: (row: ActiveHookRow, theme: SidebarTheme) => void, onRowHover: () => void, interactive: boolean, notBefore: number, sessionID?: string, initialStates?: ReadonlyMap<string, HookRunState>) => SidebarRenderHandle;

package/dist/tui/hooks-sidebar.js

@@ -0,0 +1,104 @@
+import { colorForStatus, statusLabelFor } from './hooks-presenter.js';
+import { el, txt } from './primitives.js';
+const EMPTY_HOOKS_NAME = '(none)';
+const OPEN_HINT = '›';
+export const materializeSidebar = (view, theme, solid, onRowClick, onRowHover, interactive, notBefore, sessionID, initialStates) => {
+    const rows = new Map();
+    const colors = new Map();
+    const sessionStates = new Map(initialStates);
+    const root = el(solid, 'box', { flexDirection: 'column' }, [el(solid, 'text', { fg: theme.text }, [view.title])]);
+    let isDisposed = false;
+    const dispose = () => {
+        if (isDisposed)
+            return;
+        isDisposed = true;
+        rows.clear();
+        colors.clear();
+        sessionStates.clear();
+    };
+    if (typeof solid.onCleanup === 'function') {
+        try {
+            solid.onCleanup(dispose);
+        }
+        catch { }
+    }
+    if (view.rows.length === 0) {
+        solid.insert(root, txt(solid, EMPTY_HOOKS_NAME, theme.textMuted));
+    }
+    else {
+        for (const row of view.rows) {
+            const initialStatus = sessionStates.get(row.event);
+            const initialKey = initialStatus ?? 'idle';
+            const orb = txt(solid, '•', colorForStatus(initialStatus, theme), { flexShrink: 0 });
+            const name = txt(solid, row.name, theme.text);
+            const label = txt(solid, statusLabelFor(initialStatus), theme.textMuted);
+            const hint = interactive ? txt(solid, OPEN_HINT, theme.textMuted, { flexShrink: 0 }) : undefined;
+            const line = el(solid, 'box', {
+                flexDirection: 'row',
+                gap: 1,
+                ...(interactive
+                    ? {
+                        onMouseUp: () => {
+                            if (!isDisposed)
+                                onRowClick(row, theme);
+                        },
+                        onMouseOver: () => {
+                            if (isDisposed)
+                                return;
+                            solid.setProp(line, 'backgroundColor', theme.backgroundElement);
+                            solid.setProp(name, 'fg', theme.primary);
+                            solid.setProp(hint, 'fg', theme.primary);
+                            onRowHover();
+                        },
+                        onMouseOut: () => {
+                            if (isDisposed)
+                                return;
+                            solid.setProp(line, 'backgroundColor', undefined);
+                            solid.setProp(name, 'fg', theme.text);
+                            solid.setProp(hint, 'fg', theme.textMuted);
+                            onRowHover();
+                        },
+                    }
+                    : {}),
+            }, [orb, name, label, hint]);
+            solid.insert(root, line);
+            rows.set(row.event, { orb, label });
+            colors.set(row.event, initialKey);
+        }
+    }
+    const applyStatuses = (snapshotEntries) => {
+        if (isDisposed)
+            return false;
+        try {
+            let changed = false;
+            for (const [event, entry] of snapshotEntries) {
+                const belongs = sessionID !== undefined && sessionID.length > 0
+                    ? entry.sessionID === sessionID || (entry.sessionID === undefined && entry.startedAt >= notBefore)
+                    : entry.startedAt >= notBefore;
+                if (belongs) {
+                    sessionStates.set(event, entry.status);
+                }
+            }
+            for (const [event, nodes] of rows) {
+                const status = sessionStates.get(event);
+                const key = status ?? 'idle';
+                if (colors.get(event) === key)
+                    continue;
+                solid.setProp(nodes.orb, 'fg', colorForStatus(status, theme));
+                solid.setProp(nodes.label, 'content', statusLabelFor(status));
+                colors.set(event, key);
+                changed = true;
+            }
+            return changed;
+        }
+        catch {
+            return false;
+        }
+    };
+    return {
+        root,
+        applyStatuses,
+        disposed: () => isDisposed || Boolean(root?.isDestroyed),
+        dispose,
+    };
+};

package/dist/tui/primitives.d.ts

@@ -0,0 +1,21 @@
+import type { TuiPluginApi } from '@opencode-ai/plugin/tui';
+export interface SolidRuntime {
+    readonly createElement: (tag: string) => unknown;
+    readonly insert: (parent: unknown, child: unknown) => unknown;
+    readonly setProp: (node: unknown, name: string, value: unknown) => unknown;
+    readonly onCleanup?: (fn: () => void) => void;
+}
+export interface SidebarTheme {
+    readonly text: unknown;
+    readonly textMuted: unknown;
+    readonly primary: unknown;
+    readonly selectedListItemText: unknown;
+    readonly backgroundElement: unknown;
+    readonly warning: unknown;
+    readonly success: unknown;
+    readonly error: unknown;
+}
+export type SolidElement = ReturnType<TuiPluginApi['ui']['Dialog']>;
+export declare const el: (solid: SolidRuntime, tag: string, props: Record<string, unknown>, children?: readonly unknown[]) => unknown;
+export declare const txt: (solid: SolidRuntime, content: string, fg: unknown, extra?: Record<string, unknown>) => unknown;
+export declare const loadSolidRuntime: (importSolid?: () => Promise<unknown>, importSolidJs?: () => Promise<unknown>) => Promise<SolidRuntime | null>;

package/dist/tui/primitives.js

@@ -0,0 +1,47 @@
+export const el = (solid, tag, props, children = []) => {
+    const node = solid.createElement(tag);
+    for (const [k, v] of Object.entries(props)) {
+        if (v !== undefined) {
+            try {
+                solid.setProp(node, k, v);
+            }
+            catch { }
+        }
+    }
+    for (const child of children) {
+        if (child !== undefined)
+            solid.insert(node, child);
+    }
+    return node;
+};
+export const txt = (solid, content, fg, extra = {}) => el(solid, 'text', { fg, content, ...extra });
+export const loadSolidRuntime = async (importSolid = () => import('@opentui/solid'), importSolidJs = () => import('solid-js')) => {
+    try {
+        const runtime = (await importSolid());
+        let onCleanup;
+        if (typeof runtime.onCleanup === 'function') {
+            onCleanup = runtime.onCleanup;
+        }
+        else {
+            try {
+                const solidJs = (await importSolidJs());
+                if (typeof solidJs.onCleanup === 'function') {
+                    onCleanup = solidJs.onCleanup;
+                }
+            }
+            catch { }
+        }
+        return typeof runtime.createElement === 'function' && typeof runtime.insert === 'function' && typeof runtime.setProp === 'function'
+            ? {
+                createElement: runtime.createElement,
+                insert: runtime.insert,
+                setProp: runtime.setProp,
+                ...(onCleanup !== undefined ? { onCleanup } : {}),
+            }
+            : null;
+    }
+    catch (error) {
+        console.warn('[owflow] Failed to import @opentui/solid', error);
+        return null;
+    }
+};

package/dist/tui.d.ts

@@ -0,0 +1,12 @@
+import type { TuiPluginApi } from '@opencode-ai/plugin/tui';
+import { buildHookLogsBody, buildHookRunDetailBody, getActiveDialogHandle, type ActiveDialogHandle } from './tui/hooks-dialogs.js';
+import { buildActiveHooksView, colorForStatus, formatHookLogsMessage, formatHookRunSummary, statusLabelFor, type ActiveHookRow, type ActiveHooksView } from './tui/hooks-presenter.js';
+import { type SidebarRenderHandle } from './tui/hooks-sidebar.js';
+import { type SidebarTheme, type SolidRuntime } from './tui/primitives.js';
+export { buildActiveHooksView, buildHookLogsBody, buildHookRunDetailBody, colorForStatus, formatHookLogsMessage, formatHookRunSummary, getActiveDialogHandle, statusLabelFor, type ActiveDialogHandle, type ActiveHookRow, type ActiveHooksView, type SidebarRenderHandle, type SidebarTheme, type SolidRuntime, };
+export declare const registerActiveHooksSidebar: (api: TuiPluginApi, directory: string, loadSolid?: () => Promise<SolidRuntime | null>) => Promise<boolean>;
+declare const _default: {
+    id: string;
+    tui: (api: TuiPluginApi) => Promise<void>;
+};
+export default _default;