@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/harness/mission-store.js

@@ -0,0 +1,297 @@
+/** Durable, single-host mission coordination. The store directory is operator-owned. */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+export class MissionBusyError extends Error {
+    constructor() { super('Mission mutation locked; retry. An abandoned lock requires operator inspection.'); }
+}
+function bounded(value, label, max = 4096) {
+    if (typeof value !== 'string' || !value.trim() || value.length > max || value.includes('\0'))
+        throw new Error(`Invalid ${label}`);
+}
+function validate(m) {
+    if (!m || m.schema !== 1 || !Number.isSafeInteger(m.revision) || m.revision < 0 || !['ready', 'claimed', 'running', 'handoff', 'completed'].includes(m.status))
+        throw new Error('Invalid mission record');
+    bounded(m.id, 'mission id', 256);
+    const op = m.operation;
+    if (!op || !path.isAbsolute(op.workspace) || !Number.isInteger(op.timeoutMs) || op.timeoutMs < 100 || op.timeoutMs > 43200000)
+        throw new Error('Invalid mission operation');
+    bounded(op.command, 'command');
+    if (Buffer.byteLength(JSON.stringify(op)) > 262144)
+        throw new Error('Mission operation exceeds size limit');
+    if (!Array.isArray(op.args) || op.args.length > 256 || op.args.some(a => typeof a !== 'string' || a.length > 65536 || a.includes('\0')))
+        throw new Error('Invalid operation arguments');
+    if (!Number.isFinite(m.updatedAt))
+        throw new Error('Invalid update time');
+    if (m.result && (typeof m.result.success !== 'boolean' || typeof m.result.stdout !== 'string' || typeof m.result.stderr !== 'string' || !Number.isInteger(m.result.exitCode) || m.result.stdout.length > 1000000 || m.result.stderr.length > 1000000 || (m.result.truncated !== undefined && typeof m.result.truncated !== 'boolean')))
+        throw new Error('Invalid mission result');
+    if (m.review && (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(m.review.commit) || typeof m.review.author !== 'string' || (m.review.reviewer !== undefined && (typeof m.review.reviewer !== 'string' || m.review.reviewer === m.review.author))))
+        throw new Error('Invalid review');
+    if (m.acknowledgedBy !== undefined && (m.status !== 'completed' || typeof m.acknowledgedBy !== 'string'))
+        throw new Error('Invalid acknowledgement');
+    if (m.result && m.status !== 'completed')
+        throw new Error('Result on unfinished mission');
+    if (m.handoff)
+        validateHandoff(m.handoff);
+    if (m.authority) {
+        bounded(m.authority.owner, 'owner', 256);
+        bounded(m.authority.generation, 'generation', 256);
+    }
+    if (['claimed', 'running'].includes(m.status) && (!m.authority || !Number.isFinite(m.expiresAt)))
+        throw new Error('Invalid mission lease');
+}
+function validateHandoff(handoff) {
+    if (!handoff)
+        throw new Error('Missing handoff');
+    bounded(handoff.nextAction, 'next action');
+    for (const entries of [handoff.succeeded, handoff.failed, handoff.keyFiles, handoff.deadEnds]) {
+        if (!Array.isArray(entries) || entries.length > 32)
+            throw new Error('Invalid handoff list');
+        for (const entry of entries)
+            bounded(entry, 'handoff item');
+    }
+}
+export class MissionStore {
+    directory;
+    now;
+    constructor(directory, now = Date.now) {
+        this.directory = directory;
+        this.now = now;
+    }
+    file(id) {
+        bounded(id, 'mission id', 256);
+        return path.join(this.directory, `${createHash('sha256').update(id).digest('hex')}.json`);
+    }
+    get(id) {
+        const file = this.file(id);
+        const m = this.read(file);
+        if (m.id !== id)
+            throw new Error('Mission identity mismatch');
+        return m;
+    }
+    read(file) {
+        if (!fs.lstatSync(file).isFile())
+            throw new Error('Mission must be a regular file');
+        if (fs.statSync(file).size > 3_000_000)
+            throw new Error('Mission record exceeds size limit');
+        const m = JSON.parse(fs.readFileSync(file, 'utf8'));
+        validate(m);
+        if (path.basename(this.file(m.id)) !== path.basename(file))
+            throw new Error('Mission identity mismatch');
+        return m;
+    }
+    /** Metadata only in the result. Validate at most one bounded record per page slot. */
+    list(options = {}) {
+        const limit = options.limit ?? 25;
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+            throw new Error('Mission list limit must be 1..100');
+        if (options.cursor !== undefined && !/^[a-f0-9]{64}$/.test(options.cursor))
+            throw new Error('Invalid mission list cursor');
+        const page = { missions: [], errors: [] };
+        let directory;
+        try {
+            directory = fs.opendirSync(this.directory);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return page;
+            throw error;
+        }
+        // Scan names only; retain at most limit + 1 names regardless of store size.
+        const names = [];
+        try {
+            for (let entry = directory.readSync(); entry !== null; entry = directory.readSync()) {
+                if (!/^[a-f0-9]{64}\.json$/.test(entry.name) || (options.cursor !== undefined && entry.name.slice(0, 64) <= options.cursor))
+                    continue;
+                if (names.length === limit + 1 && entry.name >= names[names.length - 1])
+                    continue;
+                names.push(entry.name);
+                names.sort();
+                if (names.length > limit + 1)
+                    names.pop();
+            }
+        }
+        finally {
+            directory.closeSync();
+        }
+        const now = this.now();
+        for (const name of names.slice(0, limit)) {
+            try {
+                const m = this.read(path.join(this.directory, name));
+                const active = m.status === 'claimed' || m.status === 'running';
+                page.missions.push({
+                    id: m.id, revision: m.revision, status: m.status, updatedAt: m.updatedAt,
+                    ...(m.authority ? { owner: m.authority.owner } : {}),
+                    ...(active ? { expiresAt: m.expiresAt, leaseExpired: m.expiresAt <= now } : {}),
+                    ...(m.result ? { success: m.result.success } : {}),
+                    acknowledged: m.acknowledgedBy !== undefined,
+                });
+            }
+            catch {
+                // Parser/validation errors can embed record contents. Never return them.
+                page.errors.push({ file: name, error: 'Invalid or unreadable mission record' });
+            }
+        }
+        if (names.length > limit)
+            page.nextCursor = names[limit - 1].slice(0, 64);
+        return page;
+    }
+    /** Synchronous critical section, exclusive across processes; never steal a mutation lock. */
+    change(id, update) {
+        fs.mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        const file = this.file(id);
+        const lock = `${file}.lock`;
+        let fd;
+        try {
+            fd = fs.openSync(lock, 'wx', 0o600);
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                throw new MissionBusyError();
+            throw error;
+        }
+        let temp;
+        try {
+            fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: this.now() }));
+            const current = fs.existsSync(file) ? this.get(id) : undefined;
+            const next = update(current);
+            next.revision = (current?.revision ?? -1) + 1;
+            next.updatedAt = this.now();
+            validate(next);
+            const content = JSON.stringify(next);
+            if (Buffer.byteLength(content) > 3_000_000)
+                throw new Error('Mission record exceeds size limit');
+            temp = `${file}.${randomUUID()}.tmp`;
+            const out = fs.openSync(temp, 'wx', 0o600);
+            try {
+                fs.writeFileSync(out, content);
+                fs.fsyncSync(out);
+            }
+            finally {
+                fs.closeSync(out);
+            }
+            fs.renameSync(temp, file);
+            if (process.platform !== 'win32') {
+                const dir = fs.openSync(this.directory, 'r');
+                try {
+                    fs.fsyncSync(dir);
+                }
+                finally {
+                    fs.closeSync(dir);
+                }
+            }
+            return next;
+        }
+        finally {
+            if (temp && fs.existsSync(temp))
+                fs.unlinkSync(temp);
+            fs.closeSync(fd);
+            fs.unlinkSync(lock);
+        }
+    }
+    create(id, operation) {
+        return this.change(id, current => {
+            if (current)
+                throw new Error('Mission already exists');
+            return { schema: 1, id, revision: 0, status: 'ready', operation, updatedAt: this.now() };
+        });
+    }
+    claim(id, owner, leaseMs = 60000) {
+        bounded(owner, 'owner', 256);
+        this.lease(leaseMs);
+        return this.change(id, m => {
+            if (!m)
+                throw new Error('Unknown mission');
+            if (m.status === 'completed')
+                throw new Error('Mission already completed');
+            if (m.status === 'running')
+                throw new Error('Running mission requires reconciliation before retry');
+            if (m.authority && (m.expiresAt ?? 0) > this.now())
+                throw new Error('Mission already claimed');
+            delete m.review;
+            m.authority = { owner, generation: randomUUID() };
+            m.expiresAt = this.now() + leaseMs;
+            m.status = 'claimed';
+            return m;
+        });
+    }
+    lease(ms) { if (!Number.isInteger(ms) || ms < 1000 || ms > 3600000)
+        throw new Error('Lease must be 1000..3600000 ms'); }
+    owned(m, a) {
+        if (!m || m.authority?.owner !== a.owner || m.authority.generation !== a.generation || (m.expiresAt ?? 0) <= this.now())
+            throw new Error('Stale or expired mission authority');
+    }
+    renew(id, a, leaseMs = 60000) {
+        this.lease(leaseMs);
+        return this.change(id, m => { this.owned(m, a); if (!['claimed', 'running'].includes(m.status))
+            throw new Error('Mission is not active'); m.expiresAt = this.now() + leaseMs; return m; });
+    }
+    start(id, a) {
+        return this.change(id, m => { this.owned(m, a); if (m.status !== 'claimed')
+            throw new Error('Mission already started'); m.status = 'running'; delete m.review; return m; });
+    }
+    complete(id, a, result) {
+        return this.change(id, m => { this.owned(m, a); if (m.status !== 'running')
+            throw new Error('Mission is not running'); m.result = { ...result, stdout: result.stdout.slice(0, 100000), stderr: result.stderr.slice(0, 100000), truncated: result.stdout.length > 100000 || result.stderr.length > 100000 }; m.status = 'completed'; delete m.expiresAt; return m; });
+    }
+    handoff(id, a, handoff) {
+        validateHandoff(handoff);
+        return this.change(id, m => { this.owned(m, a); if (m.status !== 'claimed')
+            throw new Error('Stop execution before handoff'); m.handoff = handoff; m.status = 'handoff'; delete m.review; delete m.authority; delete m.expiresAt; return m; });
+    }
+    /** Explicit operator reconciliation only; an ambiguous effect is never retried automatically. */
+    reconcile(id, generation, resolution, note) {
+        bounded(note, 'reconciliation evidence');
+        if (!['retry', 'completed'].includes(resolution))
+            throw new Error('Invalid reconciliation resolution');
+        return this.change(id, m => {
+            if (!m || m.status !== 'running' || m.authority?.generation !== generation || (m.expiresAt ?? 0) > this.now())
+                throw new Error('Only expired running missions can be reconciled');
+            m.handoff = { succeeded: [], failed: [], keyFiles: [], deadEnds: [], nextAction: note };
+            m.status = resolution === 'retry' ? 'ready' : 'completed';
+            delete m.review;
+            delete m.authority;
+            delete m.expiresAt;
+            return m;
+        });
+    }
+    acknowledge(id, consumer) {
+        bounded(consumer, 'consumer', 256);
+        return this.change(id, m => { if (!m || m.status !== 'completed')
+            throw new Error('Mission is not completed'); m.acknowledgedBy = consumer; return m; });
+    }
+    submit(id, a, commit) {
+        if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(commit))
+            throw new Error('Expected full commit SHA');
+        return this.change(id, m => {
+            if (m?.status === 'completed') {
+                if (m.authority?.owner !== a.owner || m.authority.generation !== a.generation)
+                    throw new Error('Stale mission authority');
+            }
+            else {
+                this.owned(m, a);
+            }
+            if (!['claimed', 'completed'].includes(m.status))
+                throw new Error('Review requires a claimed or completed mission');
+            m.review = { commit, author: a.owner };
+            return m;
+        });
+    }
+    approve(id, reviewer, expectedCommit) {
+        bounded(reviewer, 'reviewer', 256);
+        return this.change(id, m => {
+            if (!m || !['claimed', 'completed'].includes(m.status) || (m.status === 'claimed' && (m.expiresAt ?? 0) <= this.now()))
+                throw new Error('Review requires active ownership or a completed mission');
+            const actualCommit = execFileSync('git', ['rev-parse', '--verify', 'HEAD'], { cwd: m.operation.workspace, encoding: 'utf8', timeout: 5000 }).trim();
+            const dirty = execFileSync('git', ['status', '--porcelain', '--untracked-files=normal'], { cwd: m.operation.workspace, encoding: 'utf8', timeout: 5000 }).trim();
+            if (dirty)
+                throw new Error('Review requires a clean worktree');
+            if (!m?.review || m.review.author === reviewer || m.review.commit !== expectedCommit || actualCommit !== expectedCommit)
+                throw new Error('Review requires an independent reviewer and unchanged commit');
+            m.review.reviewer = reviewer;
+            return m;
+        });
+    }
+}
+//# sourceMappingURL=mission-store.js.map

package/dist/harness/tool-harness.d.ts

@@ -0,0 +1,56 @@
+import type { ToolResult } from '../types/index.js';
+import type { CodeBuddyTool } from '../codebuddy/tool-definitions/types.js';
+export interface ToolHarnessOptions {
+    cwd: string;
+    tools: readonly CodeBuddyTool[];
+    /** Must use the host's normal permission and validation pipeline. */
+    dispatch: (name: string, args: Record<string, unknown>, signal: AbortSignal) => Promise<ToolResult>;
+    /** Only tools proven safe for concurrent reads; other calls form FIFO barriers. */
+    parallelTools?: readonly string[];
+}
+export interface HarnessWaitResult {
+    sessionId: string;
+    status: 'running' | 'completed';
+    output: string;
+    result?: ToolResult;
+}
+/** Model-independent tool harness. No LLM client, process-global cwd, or global tool index. */
+export declare class ToolHarness {
+    private readonly options;
+    private readonly id;
+    private readonly catalog;
+    private readonly tools;
+    private readonly executions;
+    private disposed;
+    readonly cwd: string;
+    constructor(options: ToolHarnessOptions);
+    search(query: string, maxResults?: number): {
+        parameters: unknown;
+        name: string;
+        description: string;
+        score: number;
+    }[];
+    call(name: string, args?: Record<string, unknown>, signal?: AbortSignal): Promise<ToolResult>;
+    /** Start an isolated JavaScript cell. Effects always route through call(). */
+    start(code: string, options?: {
+        timeoutMs?: number;
+        typecheck?: boolean;
+    }): string;
+    /** Consume only new explicit yield output; the final result includes the complete bounded output. */
+    wait(sessionId: string, yieldTimeMs?: number): Promise<HarnessWaitResult>;
+    cancel(sessionId: string): void;
+    exec(code: string, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        typecheck?: boolean;
+    }): Promise<ToolResult>;
+    dispose(): Promise<void>;
+}
+/** Bind an existing agent, preserving ToolHandler's policy, approvals and project scope. */
+export declare function createAgentToolHarness(agent: {
+    getMemoryScope(): {
+        cwd: string;
+        botId?: string;
+    };
+    executeToolByName(name: string, args: Record<string, unknown>, extra?: Record<string, unknown>): Promise<ToolResult>;
+}, tools?: readonly CodeBuddyTool[]): Promise<ToolHarness>;

package/dist/harness/tool-harness.js

@@ -0,0 +1,153 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { BM25Index } from '../tools/tool-search.js';
+import { CodeExecTool, attachCodeExecRuntime, clearCodeExecSession } from '../tools/code-exec-tool.js';
+import { TOOL_METADATA } from '../tools/metadata.js';
+import { BoundedOutput } from '../utils/bounded-output.js';
+/** Model-independent tool harness. No LLM client, process-global cwd, or global tool index. */
+export class ToolHarness {
+    options;
+    id = randomUUID();
+    catalog = new BM25Index();
+    tools;
+    executions = new Map();
+    disposed = false;
+    cwd;
+    constructor(options) {
+        this.options = options;
+        this.cwd = path.resolve(options.cwd);
+        this.tools = new Map(options.tools.filter(tool => !['code_exec', 'exec'].includes(tool.function.name))
+            .map(tool => [tool.function.name, tool]));
+        this.catalog.index([...this.tools.values()].map(tool => ({
+            name: tool.function.name, description: tool.function.description ?? '', parameters: tool.function.parameters,
+        })));
+    }
+    search(query, maxResults = 10) {
+        return this.catalog.search(query, maxResults).map(result => ({ ...result, parameters: this.catalog.getTool(result.name)?.parameters }));
+    }
+    async call(name, args = {}, signal = new AbortController().signal) {
+        if (this.disposed || signal.aborted)
+            return { success: false, error: 'Harness call cancelled' };
+        if (!args || typeof args !== 'object' || Array.isArray(args))
+            return { success: false, error: 'Tool arguments must be an object' };
+        if (name === 'tool_search') {
+            if (typeof args.query !== 'string' || !args.query.trim() || args.query.length > 2000)
+                return { success: false, error: 'query must be a nonempty string of at most 2000 characters' };
+            if (args.max_results !== undefined && (typeof args.max_results !== 'number' || !Number.isInteger(args.max_results) || args.max_results < 1 || args.max_results > 50))
+                return { success: false, error: 'max_results must be an integer between 1 and 50' };
+            const tools = this.search(args.query, typeof args.max_results === 'number' ? args.max_results : 10);
+            return { success: true, output: JSON.stringify(tools), data: { tools, names: tools.map(tool => tool.name) } };
+        }
+        if (!this.tools.has(name))
+            return { success: false, error: `Tool is not available: ${name}` };
+        try {
+            return await this.options.dispatch(name, args, signal);
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /** Start an isolated JavaScript cell. Effects always route through call(). */
+    start(code, options = {}) {
+        if (this.disposed)
+            throw new Error('Harness is disposed');
+        for (const [id, execution] of this.executions) {
+            if (this.executions.size < 32)
+                break;
+            if (execution.result && !execution.waiting)
+                this.executions.delete(id);
+        }
+        if (this.executions.size >= 32)
+            throw new Error('Harness execution limit reached');
+        const sessionId = randomUUID();
+        const execution = {
+            controller: new AbortController(), output: new BoundedOutput(64 * 1024), completed: Promise.resolve(), waiting: false,
+        };
+        const context = attachCodeExecRuntime({ cwd: this.cwd, sessionId: this.id }, {
+            scopeId: `harness:${this.id}`, sessionId: this.id, cwd: this.cwd,
+            availableTools: [...new Set([...this.tools.keys(), 'tool_search'])],
+            toolCatalog: [...this.tools.values()].map(tool => ({ name: tool.function.name, description: tool.function.description, parameters: tool.function.parameters })),
+            toolMetadata: [...this.tools.values()].map(tool => ({ name: tool.function.name, description: tool.function.description ?? '' })),
+            parallelTools: this.options.parallelTools,
+            executor: (name, args, signal) => this.call(name, args, signal),
+            abortSignal: execution.controller.signal,
+            onOutput: delta => { execution.output.append(delta); execution.notify?.(); },
+        });
+        execution.completed = new CodeExecTool().execute({ code, typecheck: options.typecheck, ...(options.timeoutMs !== undefined ? { timeout_ms: options.timeoutMs } : {}) }, context)
+            .then(result => { execution.result = result; })
+            .catch(error => { execution.result = { success: false, error: error instanceof Error ? error.message : String(error) }; });
+        this.executions.set(sessionId, execution);
+        return sessionId;
+    }
+    /** Consume only new explicit yield output; the final result includes the complete bounded output. */
+    async wait(sessionId, yieldTimeMs = 1000) {
+        const execution = this.executions.get(sessionId);
+        if (!execution)
+            throw new Error('Unknown harness execution');
+        if (execution.waiting)
+            throw new Error('Only one consumer may wait on an execution');
+        if (!Number.isFinite(yieldTimeMs) || yieldTimeMs < 0 || yieldTimeMs > 60000)
+            throw new Error('yieldTimeMs must be between 0 and 60000');
+        execution.waiting = true;
+        let timer;
+        try {
+            if (!execution.result && !execution.output.retainedBytes) {
+                await Promise.race([execution.completed, new Promise(resolve => { execution.notify = resolve; timer = setTimeout(resolve, yieldTimeMs); })]);
+            }
+            return { sessionId, status: execution.result ? 'completed' : 'running', output: execution.output.drain(), ...(execution.result ? { result: execution.result } : {}) };
+        }
+        finally {
+            clearTimeout(timer);
+            execution.waiting = false;
+            execution.notify = undefined;
+        }
+    }
+    cancel(sessionId) {
+        const execution = this.executions.get(sessionId);
+        if (!execution)
+            throw new Error('Unknown harness execution');
+        execution.controller.abort();
+    }
+    async exec(code, options = {}) {
+        if (options.signal?.aborted)
+            return { success: false, error: 'Harness call cancelled' };
+        const sessionId = this.start(code, options);
+        const execution = this.executions.get(sessionId);
+        const abort = () => execution.controller.abort();
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        try {
+            await execution.completed;
+            return execution.result;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+            this.executions.delete(sessionId);
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+        for (const execution of this.executions.values())
+            execution.controller.abort();
+        await Promise.all([...this.executions.values()].map(execution => execution.completed));
+        this.executions.clear();
+        clearCodeExecSession(this.id);
+    }
+}
+/** Bind an existing agent, preserving ToolHandler's policy, approvals and project scope. */
+export async function createAgentToolHarness(agent, tools) {
+    const catalog = tools ?? await (await import('../codebuddy/tools.js')).getAllCodeBuddyTools();
+    const scope = agent.getMemoryScope();
+    const cwd = path.resolve(scope.cwd);
+    const botId = scope.botId;
+    return new ToolHarness({ cwd, tools: catalog, parallelTools: TOOL_METADATA.filter(tool => tool.fleetSafe === true && tool.effect === 'read').map(tool => tool.name), dispatch: (name, args, abortSignal) => {
+            const currentScope = agent.getMemoryScope();
+            if (path.resolve(currentScope.cwd) !== cwd)
+                return Promise.resolve({ success: false, error: 'Agent workspace changed; create a new harness' });
+            if (currentScope.botId !== botId)
+                return Promise.resolve({ success: false, error: 'Agent bot changed; create a new harness' });
+            return agent.executeToolByName(name, args, { abortSignal });
+        } });
+}
+//# sourceMappingURL=tool-harness.js.map

package/dist/hooks/use-enhanced-input.js

@@ -3,8 +3,18 @@ import { deleteCharBefore, deleteCharAfter, deleteWordBefore, deleteWordAfter, i
 import { useInputHistory } from "./use-input-history.js";
 import { getHistoryManager } from "../utils/history-manager.js";
 export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, disabled = false, multiline = false, } = {}) {
-    const [input, setInputState] = useState("");
-    const [cursorPosition, setCursorPositionState] = useState(0);
+    const [input, updateInput] = useState('');
+    const inputRef = useRef('');
+    const setInputState = useCallback((text) => {
+        inputRef.current = text;
+        updateInput(text);
+    }, []);
+    const [cursorPosition, updateCursor] = useState(0);
+    const cursorRef = useRef(0);
+    const setCursorPositionState = useCallback((position) => {
+        cursorRef.current = position;
+        updateCursor(position);
+    }, []);
     const [isReverseSearchActive, setIsReverseSearchActive] = useState(false);
     const [reverseSearchPrompt, setReverseSearchPrompt] = useState("");
     const isMultilineRef = useRef(multiline);
@@ -18,7 +28,7 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, disabled =
         }
     }, [cursorPosition, isNavigatingHistory, setOriginalInput]);
     const setCursorPosition = useCallback((position) => {
-        setCursorPositionState(Math.max(0, Math.min(input.length, position)));
+        setCursorPositionState(Math.max(0, Math.min(inputRef.current.length, position)));
     }, [input.length]);
     const clearInput = useCallback(() => {
         setInputState("");
@@ -26,12 +36,13 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, disabled =
         setOriginalInput("");
     }, [setOriginalInput]);
     const insertAtCursor = useCallback((text) => {
-        const result = insertText(input, cursorPosition, text);
+        const result = insertText(inputRef.current, cursorRef.current, text);
         setInputState(result.text);
         setCursorPositionState(result.position);
         setOriginalInput(result.text);
     }, [input, cursorPosition, setOriginalInput]);
     const handleSubmit = useCallback(() => {
+        const input = inputRef.current;
         if (input.trim()) {
             addToHistory(input);
             onSubmit?.(input);
@@ -41,6 +52,25 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, disabled =
     const handleInput = useCallback((inputChar, key) => {
         if (disabled)
             return;
+        // Read synchronously updated refs: multiple events may arrive before React
+        // commits a render (fast typing, Windows Terminal and pasted input).
+        const input = inputRef.current;
+        const cursorPosition = cursorRef.current;
+        // Ink 4 parses CRLF as Ctrl+M, and LF (Ctrl+J) as literal text.
+        // Normalize Enter without executing embedded newlines in pasted content.
+        if (inputChar === '\r\n' || (key.ctrl && inputChar === 'm')) {
+            key = { ...key, return: true };
+        }
+        if (inputChar === '\n' || (key.ctrl && inputChar === 'j')) {
+            const result = insertText(input, cursorPosition, '\n');
+            setInputState(result.text);
+            setCursorPositionState(result.position);
+            setOriginalInput(result.text);
+            return;
+        }
+        if (inputChar.length > 1 && !key.ctrl && !key.meta) {
+            inputChar = inputChar.replace(/\r\n?/g, '\n');
+        }
         // Handle Ctrl+C - check multiple ways it could be detected
         if ((key.ctrl && inputChar === "c") || inputChar === "\x03") {
             setInputState("");
@@ -71,6 +101,20 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, disabled =
             }
             return;
         }
+        // In a multiline draft, arrows move within the draft instead of replacing
+        // it with history. History remains available on a single-line prompt.
+        if (input.includes('\n') && !isNavigatingHistory() && (key.upArrow || key.downArrow) && !key.ctrl && !key.meta) {
+            const before = input.slice(0, cursorPosition).split('\n');
+            const row = before.length - 1;
+            const column = before[row]?.length ?? 0;
+            const lines = input.split('\n');
+            const target = row + (key.upArrow ? -1 : 1);
+            if (target >= 0 && target < lines.length) {
+                const offset = lines.slice(0, target).reduce((sum, line) => sum + line.length + 1, 0);
+                setCursorPositionState(offset + Math.min(column, lines[target]?.length ?? 0));
+            }
+            return;
+        }
         // Handle history navigation
         if ((key.upArrow || key.name === 'up') && !key.ctrl && !key.meta) {
             const historyInput = navigateHistory("up");

package/dist/hooks/use-input-handler.d.ts

@@ -38,6 +38,7 @@ export declare function useInputHandler({ agent, chatHistory, setChatHistory, se
     availableModels: ModelOption[];
     agent: CodeBuddyAgent;
     autoEditEnabled: boolean;
+    queuedMessageCount: number;
     handleInputSubmit: (userInput: string) => Promise<void>;
 };
 export {};