@crouton-kit/humanloop 0.1.0

package/dist/tui/render.d.ts

@@ -0,0 +1,5 @@
+import type { TuiState } from '../types.js';
+export declare function flush(lines: string[]): void;
+export declare function renderOverview(state: TuiState): string[];
+export declare function renderItemReview(state: TuiState): string[];
+export declare function renderFinal(state: TuiState): string[];

package/dist/tui/render.js

@@ -0,0 +1,279 @@
+import stringWidth from 'string-width';
+import { getTerminalSize } from './terminal.js';
+// ── ANSI helpers ─────────────────────────────────────────────────────────────
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+const DIM = `${ESC}2m`;
+const ITALIC = `${ESC}3m`;
+const GREEN = `${ESC}32m`;
+const YELLOW = `${ESC}33m`;
+const BLUE = `${ESC}34m`;
+const MAGENTA = `${ESC}35m`;
+const CYAN = `${ESC}36m`;
+const GRAY = `${ESC}90m`;
+const BG_BLUE = `${ESC}44m`;
+const WHITE = `${ESC}37m`;
+function truncate(text, maxWidth) {
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    let w = 0;
+    let i = 0;
+    for (; i < text.length; i++) {
+        const cw = stringWidth(text[i]);
+        if (w + cw + 1 > maxWidth)
+            break;
+        w += cw;
+    }
+    return text.slice(0, i) + '…';
+}
+function padRight(text, width) {
+    const w = stringWidth(text);
+    if (w >= width)
+        return text;
+    return text + ' '.repeat(width - w);
+}
+function hline(width, char = '─') {
+    return char.repeat(width);
+}
+function wrap(text, maxWidth) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        const candidate = current ? `${current} ${word}` : word;
+        if (stringWidth(candidate) <= maxWidth) {
+            current = candidate;
+        }
+        else {
+            if (current)
+                lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.length > 0 ? lines : [''];
+}
+function hardWrap(text, maxWidth) {
+    if (maxWidth < 1)
+        return [text];
+    const segments = text.split('\n');
+    const out = [];
+    for (const seg of segments) {
+        if (seg.length === 0) {
+            out.push('');
+            continue;
+        }
+        let current = '';
+        let currentW = 0;
+        for (const ch of seg) {
+            const cw = stringWidth(ch);
+            if (currentW + cw > maxWidth) {
+                out.push(current);
+                current = ch;
+                currentW = cw;
+            }
+            else {
+                current += ch;
+                currentW += cw;
+            }
+        }
+        out.push(current);
+    }
+    return out;
+}
+// ── Frame buffer ─────────────────────────────────────────────────────────────
+let prevFrame = [];
+export function flush(lines) {
+    const { rows } = getTerminalSize();
+    process.stdout.write('\x1b[?2026h');
+    for (let i = 0; i < rows; i++) {
+        const line = i < lines.length ? lines[i] : '';
+        if (prevFrame[i] !== line) {
+            process.stdout.write(`${ESC}${i + 1};1H${ESC}2K${line}`);
+        }
+    }
+    process.stdout.write('\x1b[?2026l');
+    prevFrame = [...lines];
+}
+// ── Renderers ────────────────────────────────────────────────────────────────
+export function renderOverview(state) {
+    const { cols, rows } = getTerminalSize();
+    const lines = [];
+    const title = `${BOLD}${CYAN} Decisions ${RESET}`;
+    const progress = `${state.answers.size}/${state.questions.length} answered`;
+    lines.push('');
+    lines.push(`  ${title}  ${DIM}${progress}${RESET}`);
+    lines.push(`  ${DIM}${hline(Math.min(cols - 4, 60))}${RESET}`);
+    lines.push('');
+    for (let i = 0; i < state.questions.length; i++) {
+        const q = state.questions[i];
+        const answer = state.answers.get(q.id);
+        const icon = answer ? `${GREEN}✓${RESET}` : `${DIM}○${RESET}`;
+        const label = q.type === 'validation' ? q.statement : q.question;
+        const typeTag = `${DIM}[${q.type}]${RESET}`;
+        const cursor = i === state.currentIndex ? `${CYAN}▸${RESET} ` : '  ';
+        lines.push(`  ${cursor}${icon} ${truncate(label, cols - 20)} ${typeTag}`);
+        if (answer) {
+            const summary = answerSummary(answer);
+            lines.push(`      ${DIM}${truncate(summary, cols - 10)}${RESET}`);
+        }
+    }
+    lines.push('');
+    lines.push(`  ${DIM}${hline(Math.min(cols - 4, 60))}${RESET}`);
+    lines.push(`  ${DIM}enter${RESET} review  ${DIM}j/k${RESET} navigate  ${DIM}q${RESET} finish`);
+    while (lines.length < rows)
+        lines.push('');
+    return lines;
+}
+export function renderItemReview(state) {
+    const { cols, rows } = getTerminalSize();
+    const lines = [];
+    const q = state.questions[state.currentIndex];
+    const visual = state.visuals.get(q.id);
+    const answer = state.answers.get(q.id);
+    const maxW = Math.min(cols - 4, 76);
+    // Header
+    const pos = `${state.currentIndex + 1}/${state.questions.length}`;
+    lines.push('');
+    lines.push(`  ${BOLD}${CYAN}[${pos}]${RESET} ${DIM}${q.type}${RESET}`);
+    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    lines.push('');
+    // Question / Statement
+    const headline = q.type === 'validation' ? q.statement : q.question;
+    for (const line of wrap(headline, maxW)) {
+        lines.push(`  ${BOLD}${line}${RESET}`);
+    }
+    for (const line of wrap(q.rationale, maxW)) {
+        lines.push(`  ${ITALIC}${GRAY}${line}${RESET}`);
+    }
+    lines.push('');
+    // Visual context
+    if (visual) {
+        if (visual.status === 'loading') {
+            lines.push(`  ${DIM}loading context...${RESET}`);
+        }
+        else if (visual.status === 'error') {
+            lines.push(`  ${YELLOW}visual context unavailable${RESET}`);
+        }
+        else if (state.detailExpanded) {
+            lines.push(`  ${DIM}── context ${hline(maxW - 12)}${RESET}`);
+            for (const vl of visual.content.split('\n')) {
+                lines.push(`  ${vl}`);
+            }
+            lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+        }
+        else {
+            lines.push(`  ${DIM}[space] expand context${RESET}`);
+        }
+        lines.push('');
+    }
+    // Input mode
+    if (state.inputMode) {
+        lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+        const label = state.inputMode.kind === 'comment' ? 'Comment'
+            : state.inputMode.kind === 'freetext' ? 'Response'
+                : 'Custom option';
+        lines.push(`  ${YELLOW}${label}:${RESET}`);
+        const bufLines = hardWrap(state.inputMode.buffer, maxW - 1);
+        for (let i = 0; i < bufLines.length; i++) {
+            const isLast = i === bufLines.length - 1;
+            lines.push(`  ${bufLines[i]}${isLast ? '█' : ''}`);
+        }
+        lines.push('');
+        lines.push(`  ${DIM}enter${RESET} submit  ${DIM}esc${RESET} cancel`);
+    }
+    else {
+        // Actions
+        lines.push(...renderActions(q, state.selectedAction, answer));
+    }
+    // Footer
+    while (lines.length < rows - 1)
+        lines.push('');
+    const footerParts = [
+        `${DIM}n/p${RESET} prev/next`,
+        `${DIM}space${RESET} expand`,
+        `${DIM}q${RESET} overview`,
+    ];
+    lines.push(`  ${footerParts.join('  ')}`);
+    return lines;
+}
+function renderActions(q, selectedAction, existing) {
+    const lines = [];
+    if (q.type === 'validation') {
+        const actions = [
+            { key: '1', label: 'Approve', desc: 'accept as stated' },
+            { key: '2', label: 'Approve + comment', desc: 'accept with note' },
+            { key: '3', label: 'Reject', desc: 'do not accept as stated' },
+            { key: '4', label: 'Comment', desc: 'feedback without decision' },
+        ];
+        for (let i = 0; i < actions.length; i++) {
+            const a = actions[i];
+            const cursor = i === selectedAction ? `${CYAN}▸${RESET}` : ' ';
+            const keyBadge = `${DIM}[${a.key}]${RESET}`;
+            lines.push(`  ${cursor} ${keyBadge} ${a.label} ${DIM}— ${a.desc}${RESET}`);
+        }
+    }
+    else if (q.type === 'choice') {
+        for (let i = 0; i < q.options.length; i++) {
+            const cursor = i === selectedAction ? `${CYAN}▸${RESET}` : ' ';
+            const keyBadge = `${DIM}[${i + 1}]${RESET}`;
+            lines.push(`  ${cursor} ${keyBadge} ${q.options[i]}`);
+        }
+        const otherIdx = q.options.length;
+        const cursor = otherIdx === selectedAction ? `${CYAN}▸${RESET}` : ' ';
+        lines.push(`  ${cursor} ${DIM}[${otherIdx + 1}]${RESET} ${ITALIC}Other (custom)${RESET}`);
+    }
+    else {
+        lines.push(`  ${DIM}[r]${RESET} Enter response`);
+    }
+    if (existing) {
+        lines.push('');
+        lines.push(`  ${GREEN}Current: ${answerSummary(existing)}${RESET}`);
+    }
+    return lines;
+}
+export function renderFinal(state) {
+    const { cols, rows } = getTerminalSize();
+    const lines = [];
+    const maxW = Math.min(cols - 4, 60);
+    const total = state.questions.length;
+    const answered = state.answers.size;
+    lines.push('');
+    lines.push(`  ${BOLD}${CYAN} Summary ${RESET}`);
+    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    lines.push('');
+    lines.push(`  ${answered}/${total} questions answered`);
+    lines.push('');
+    for (const q of state.questions) {
+        const answer = state.answers.get(q.id);
+        const icon = answer ? `${GREEN}✓${RESET}` : `${YELLOW}○${RESET}`;
+        const label = q.type === 'validation' ? q.statement : q.question;
+        lines.push(`  ${icon} ${truncate(label, maxW - 4)}`);
+        if (answer) {
+            lines.push(`    ${DIM}${truncate(answerSummary(answer), maxW - 6)}${RESET}`);
+        }
+    }
+    lines.push('');
+    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    if (answered < total) {
+        lines.push(`  ${YELLOW}${total - answered} unanswered — press p to go back${RESET}`);
+    }
+    lines.push(`  ${DIM}enter${RESET} submit  ${DIM}p${RESET} go back`);
+    while (lines.length < rows)
+        lines.push('');
+    return lines;
+}
+function answerSummary(a) {
+    switch (a.type) {
+        case 'validation':
+            return a.approved
+                ? (a.comment ? `approved: "${a.comment}"` : 'approved')
+                : (a.comment ? `commented: "${a.comment}"` : 'commented');
+        case 'choice':
+            return a.isCustom ? `custom: "${a.selected}"` : a.selected;
+        case 'freetext':
+            return a.response;
+    }
+}

package/dist/tui/terminal.d.ts

@@ -0,0 +1,20 @@
+export interface Key {
+    upArrow: boolean;
+    downArrow: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    tab: boolean;
+    backspace: boolean;
+}
+export type KeypressHandler = (input: string, key: Key) => void;
+export declare function parseKeypress(data: Buffer): {
+    input: string;
+    key: Key;
+};
+export declare function setupTerminal(): void;
+export declare function restoreTerminal(): void;
+export declare function getTerminalSize(): {
+    cols: number;
+    rows: number;
+};

package/dist/tui/terminal.js

@@ -0,0 +1,68 @@
+function emptyKey() {
+    return {
+        upArrow: false,
+        downArrow: false,
+        return: false,
+        escape: false,
+        ctrl: false,
+        tab: false,
+        backspace: false,
+    };
+}
+export function parseKeypress(data) {
+    const str = data.toString('utf8');
+    const key = emptyKey();
+    if (str === '\x1b[A') {
+        key.upArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[B') {
+        key.downArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\r' || str === '\n') {
+        key.return = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b') {
+        key.escape = true;
+        return { input: '', key };
+    }
+    if (str === '\t') {
+        key.tab = true;
+        return { input: '', key };
+    }
+    if (str === '\x7f' || str === '\b') {
+        key.backspace = true;
+        return { input: '', key };
+    }
+    if (str.length === 1 && str.charCodeAt(0) < 32) {
+        key.ctrl = true;
+        const ch = String.fromCharCode(str.charCodeAt(0) + 64).toLowerCase();
+        return { input: ch, key };
+    }
+    return { input: str, key };
+}
+export function setupTerminal() {
+    if (!process.stdin.isTTY) {
+        throw new Error('hl requires an interactive terminal (TTY)');
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdout.write('\x1b[?25l'); // hide cursor
+    process.stdout.write('\x1b[?1049h'); // alt screen
+    process.stdout.write('\x1b[2J\x1b[H'); // clear
+}
+export function restoreTerminal() {
+    process.stdout.write('\x1b[?25h'); // show cursor
+    process.stdout.write('\x1b[?1049l'); // restore screen
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+}
+export function getTerminalSize() {
+    return {
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+    };
+}

package/dist/tui/tmux.d.ts

@@ -0,0 +1,6 @@
+import type { DecisionsOutput } from '../types.js';
+export interface TmuxDispatchOpts {
+    sessionId?: string;
+    visuals: boolean;
+}
+export declare function dispatchToTmuxPane(file: string, opts: TmuxDispatchOpts): Promise<DecisionsOutput>;

package/dist/tui/tmux.js

@@ -0,0 +1,54 @@
+import { execFileSync } from 'child_process';
+import { existsSync, mkdtempSync, readFileSync, rmdirSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+function shellQuote(s) {
+    if (s.length > 0 && /^[a-zA-Z0-9_\-./:@%+=]+$/.test(s))
+        return s;
+    return "'" + s.replace(/'/g, `'\\''`) + "'";
+}
+function buildChildCmd(file, resultPath, opts) {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        throw new Error('Cannot determine hl script path from process.argv[1]');
+    }
+    const parts = [
+        shellQuote(process.execPath),
+        shellQuote(scriptPath),
+        'create',
+        shellQuote(file),
+        '--write-to',
+        shellQuote(resultPath),
+    ];
+    if (opts.sessionId) {
+        parts.push('--session-id', shellQuote(opts.sessionId));
+    }
+    if (!opts.visuals) {
+        parts.push('--no-visuals');
+    }
+    return parts.join(' ');
+}
+export async function dispatchToTmuxPane(file, opts) {
+    const dir = mkdtempSync(join(tmpdir(), 'hl-'));
+    const resultPath = join(dir, 'result.json');
+    const cmd = buildChildCmd(file, resultPath, opts);
+    execFileSync('tmux', ['split-window', '-h', '-d', cmd], { stdio: 'ignore' });
+    await new Promise((resolve) => {
+        const poll = setInterval(() => {
+            if (existsSync(resultPath)) {
+                clearInterval(poll);
+                resolve();
+            }
+        }, 150);
+    });
+    const json = readFileSync(resultPath, 'utf8');
+    try {
+        unlinkSync(resultPath);
+    }
+    catch { /* ignore */ }
+    try {
+        rmdirSync(dir);
+    }
+    catch { /* ignore */ }
+    return JSON.parse(json);
+}

package/dist/types.d.ts

@@ -0,0 +1,76 @@
+export type QuestionType = 'validation' | 'choice' | 'freetext';
+export interface ValidationQuestion {
+    id: string;
+    type: 'validation';
+    statement: string;
+    rationale: string;
+}
+export interface ChoiceQuestion {
+    id: string;
+    type: 'choice';
+    question: string;
+    rationale: string;
+    options: string[];
+}
+export interface FreetextQuestion {
+    id: string;
+    type: 'freetext';
+    question: string;
+    rationale: string;
+}
+export type Question = ValidationQuestion | ChoiceQuestion | FreetextQuestion;
+export interface DecisionsInput {
+    title?: string;
+    questions: Question[];
+}
+export interface ValidationAnswer {
+    id: string;
+    type: 'validation';
+    approved: boolean;
+    comment?: string;
+}
+export interface ChoiceAnswer {
+    id: string;
+    type: 'choice';
+    selected: string;
+    isCustom: boolean;
+    comment?: string;
+}
+export interface FreetextAnswer {
+    id: string;
+    type: 'freetext';
+    response: string;
+}
+export type Answer = ValidationAnswer | ChoiceAnswer | FreetextAnswer;
+export interface DecisionsOutput {
+    answers: Answer[];
+    completedAt: string;
+}
+export interface VisualBlock {
+    questionId: string;
+    content: string;
+    status: 'loading' | 'ready' | 'error';
+}
+export type Phase = 'overview' | 'item-review' | 'final';
+export type InputMode = null | {
+    kind: 'comment';
+    buffer: string;
+} | {
+    kind: 'freetext';
+    buffer: string;
+} | {
+    kind: 'custom-option';
+    buffer: string;
+};
+export interface TuiState {
+    phase: Phase;
+    currentIndex: number;
+    questions: Question[];
+    answers: Map<string, Answer>;
+    visuals: Map<string, VisualBlock>;
+    inputMode: InputMode;
+    selectedAction: number;
+    detailExpanded: boolean;
+    scrollOffset: number;
+    persist?: () => void;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// ── Input: what the agent writes ─────────────────────────────────────────────
+export {};

package/dist/visuals/generate.d.ts

@@ -0,0 +1,4 @@
+import type { Question, VisualBlock } from '../types.js';
+import type { ConversationMessage } from '../conversation/reader.js';
+export type VisualUpdateCallback = (questionId: string, block: VisualBlock) => void;
+export declare function generateVisuals(questions: Question[], conversation: ConversationMessage[], onUpdate: VisualUpdateCallback, width?: number): Promise<void>;

package/dist/visuals/generate.js

@@ -0,0 +1,129 @@
+import { query } from '@r-cli/sdk';
+import { execSync } from 'child_process';
+const VISUAL_SYSTEM_PROMPT = `You're briefing a CTO-level engineer in the 30 seconds before they decide. They've been off this problem for days; they need a fast re-ground in what *already exists* — the files, data flow, or constraint they're deciding inside of — not a lecture on tradeoffs.
+
+# Length
+
+Target 15–25 lines. Hard cap 30. A tight paragraph with two file refs is often perfect — don't pad.
+
+# What to write
+
+Lead with *what is*, not *what could be*. Name the actual files, functions, tables, or data structures in play. Reference them as \`path/to/file.ts:123\` so they can jump to it. Skip preamble. Skip "here are the tradeoffs." Skip explaining the alternative — they're deciding, they know the alternative exists.
+
+If one sentence captures the current state, write one sentence. If they need to see a flow, draw it. If they need to compare 3+ options across same dimensions, use a table. Don't reach for a directive unless it genuinely clarifies — plain prose + bullet lists is the default.
+
+# Directives (termrender-flavored markdown)
+
+  :::panel{title="T" color="c"}   Bordered box (colors: red|green|yellow|blue|magenta|cyan|white|gray)
+  :::tree{color="c"}               Indented hierarchy (2-space indent = nesting)
+  :::table                         Markdown table with borders
+  :::note / :::warning             Callouts
+
+Each opens with ::: and closes with :::. Standard markdown also works: **bold**, *italic*, \`code\`, bullets.
+
+# Critical: ASCII art must live inside a :::panel
+
+Plain text outside directives gets reflowed — box-drawing will be destroyed. If you draw a flow diagram or ASCII box, wrap it in \`:::panel\` to preserve it verbatim.
+
+# Grounding — the single most important rule
+
+**Only name files, functions, variables, or patterns that actually appear in the conversation history provided.** Do not invent plausible-sounding file paths, class names, or dependencies. If the conversation doesn't ground a fact, don't assert it. When in doubt, speak at a higher level of abstraction ("the state file," "the render loop") rather than making up a specific identifier.
+
+If the conversation doesn't contain enough context to write a grounded briefing, write a very short briefing that honestly reflects what little is known — a one-paragraph summary is better than a confident fabrication.
+
+# Hard rules
+
+- Never nest directives (no :::panel containing :::table)
+- Never wrap output in backtick fences
+- Never repeat the question/statement text
+- Never write "tradeoffs to consider" or "here are some options"
+- Never describe an alternative architecture — just describe the current one
+- Never recommend an option or tell the user how to decide. They are the decider. You describe.
+- Never ask the user a question back. You are producing a briefing, not a conversation.
+- Do NOT use these section headings: **Recommendation:**, **Decide by:**, **Trade-off:**, **Why it matters:**, **What you're locking in:**. These invite editorializing. Use neutral labels like **Current state:**, **Constraint:**, or none at all.
+- 30 lines maximum`;
+async function callHaiku(prompt, systemPrompt) {
+    try {
+        const session = await query({
+            prompt,
+            options: {
+                model: 'haiku',
+                maxTurns: 1,
+                systemPrompt,
+            },
+        });
+        let text = '';
+        for await (const msg of session) {
+            if (msg.type === 'assistant' && msg.message?.content) {
+                for (const block of msg.message.content) {
+                    if (block.type === 'text')
+                        text += block.text;
+                }
+            }
+        }
+        return text.trim() || null;
+    }
+    catch (err) {
+        process.stderr.write(`[hl] Haiku call failed: ${err instanceof Error ? err.message : err}\n`);
+        return null;
+    }
+}
+function renderWithTermrender(markdown, width) {
+    // First attempt
+    const result = tryTermrender(markdown, width);
+    if (result !== null)
+        return result;
+    // Fallback: strip all directives and render as plain markdown
+    const stripped = markdown.replace(/^:{3,}\w*.*$/gm, '').trim();
+    const fallback = tryTermrender(stripped, width);
+    return fallback ?? markdown;
+}
+function tryTermrender(markdown, width) {
+    try {
+        return execSync(`termrender -w ${width}`, {
+            input: markdown,
+            encoding: 'utf8',
+            timeout: 5000,
+            env: { ...process.env, TERMRENDER_COLOR: '1' },
+        }).trimEnd();
+    }
+    catch (err) {
+        const stderr = err.stderr || '';
+        process.stderr.write(`[hl] termrender: ${stderr.split('\n')[0]}\n`);
+        return null;
+    }
+}
+export async function generateVisuals(questions, conversation, onUpdate, width = 72) {
+    const conversationText = conversation
+        .map(m => `${m.role}: ${m.content}`)
+        .join('\n\n');
+    const tasks = questions.map(async (question) => {
+        const questionText = question.type === 'validation'
+            ? `Decision to validate: "${question.statement}"\nRationale: ${question.rationale}`
+            : `Question: "${question.question}"\nRationale: ${question.rationale}${question.type === 'choice'
+                ? `\nOptions: ${question.options.join(', ')}`
+                : ''}`;
+        const prompt = `Here is the conversation so far:\n\n${conversationText}\n\n---\n\nGenerate a visual context block for this decision point:\n\n${questionText}`;
+        const result = await callHaiku(prompt, VISUAL_SYSTEM_PROMPT);
+        if (result) {
+            const cleaned = result
+                .replace(/^```[\w]*\n?/gm, '')
+                .replace(/^```\s*$/gm, '')
+                .trim();
+            const rendered = renderWithTermrender(cleaned, width);
+            onUpdate(question.id, {
+                questionId: question.id,
+                content: rendered,
+                status: 'ready',
+            });
+        }
+        else {
+            onUpdate(question.id, {
+                questionId: question.id,
+                content: '',
+                status: 'error',
+            });
+        }
+    });
+    await Promise.all(tasks);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@crouton-kit/humanloop",
+  "version": "0.1.0",
+  "description": "Human-in-the-loop decision TUI — agents write questions, humans answer them",
+  "type": "module",
+  "bin": {
+    "hl": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "commands"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "link": "npm link"
+  },
+  "dependencies": {
+    "@r-cli/sdk": "^1.3.0",
+    "commander": "^13.0.0",
+    "string-width": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  }
+}