klyro 0.1.4 → 0.1.5

package/dist/tools/shell/shell-exec.js

@@ -8,7 +8,9 @@
  *   - Non-zero exit is returned as a successful tool call (with exitCode in
  *     the output). The agent reads exitCode to decide what to do next.
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
@@ -19,37 +21,99 @@ const InputSchema = z.object({
     timeoutMs: z.number().int().min(1).max(600_000).optional().describe('Timeout in milliseconds (default 30000, max 600000)'),
     env: z.record(z.string(), z.string()).optional().describe('Extra env vars merged onto process.env'),
 });
-const DEFAULT_TIMEOUT_MS = 30_000;
-const MAX_OUTPUT_BYTES = 128 * 1024;
-// Hard-coded dangerous patterns. These are non-overridable in MVP.
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 600_000;
+const MAX_OUTPUT_CHARS = 30_000; // head+tail cap per 3.3
+const FULL_OUTPUT_DIR = (() => {
+    try {
+        const home = os.homedir() || process.cwd();
+        return path.join(home, '.klyro', 'tool-output');
+    }
+    catch {
+        return path.join(process.cwd(), '.klyro', 'tool-output');
+    }
+})();
+// Persistent cwd across calls (3.3)
+let persistentCwd = null;
+// Filtered env — only safe vars, secrets stripped
+const ALLOWED_ENV_PREFIXES = ['PATH', 'HOME', 'USER', 'SHELL', 'TERM', 'LANG', 'NODE_', 'NPM_', 'PNPM_', 'YARN_'];
+function filteredEnv(extra) {
+    const out = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (k.startsWith('KLYRO_') && k.includes('API_KEY'))
+            continue;
+        if (k.includes('SECRET') || k.includes('TOKEN') || k === 'ANTHROPIC_API_KEY' || k === 'OPENAI_API_KEY')
+            continue;
+        if (ALLOWED_ENV_PREFIXES.some((p) => k.startsWith(p)) || k === 'PWD' || k === 'TMPDIR' || k === 'TEMP') {
+            out[k] = v;
+        }
+    }
+    // Always allow basic
+    out.PATH = process.env.PATH;
+    if (extra)
+        Object.assign(out, extra);
+    return out;
+}
+// Interactive command detection (3.3)
+const INTERACTIVE_PATTERNS = [/^\s*vim\b/, /^\s*nano\b/, /^\s*htop\b/, /^\s*less\b/, /^\s*more\b/, /^\s*ssh\b/, /^\s*tmux\b/];
+// Hard-coded dangerous patterns. These are non-overridable, configurable via --yolo only.
 const DANGEROUS_PATTERNS = [
     { pattern: /rm\s+-rf?\s+\//, reason: 'recursive delete at filesystem root' },
+    { pattern: /rm\s+-rf?\s+\/\/+/, reason: 'recursive delete at filesystem root (//)' },
+    { pattern: /rm\s+-rf?\s+\/\*/, reason: 'recursive delete at filesystem root (/*)' },
+    { pattern: /rm\s+-rf?\s+\.\s*($|[;&|])/, reason: 'recursive delete current directory' },
+    { pattern: /rm\s+-rf?\s+\*\s*($|[;&|])/, reason: 'recursive delete all files via *' },
+    { pattern: /rm\s+-rf?\s+\.\/\*\s*($|[;&|])/, reason: 'recursive delete all files' },
     { pattern: /del\s+\/s\s+\/q\s+[a-z]:\\/i, reason: 'recursive delete on Windows drive root' },
     { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/, reason: 'fork bomb' },
+    { pattern: /bomb\(\)\s*\{\s*bomb\|bomb/, reason: 'fork bomb variant' },
     { pattern: />\s*\/dev\/sd[a-z]/, reason: 'overwrite raw block device' },
     { pattern: /mkfs(\.|\s)/, reason: 'format filesystem' },
     { pattern: /dd\s+.*of=\/dev\//, reason: 'dd write to device' },
+    { pattern: /chmod\s+-R\s+777\s+\//, reason: 'chmod 777 on root' },
+    { pattern: /curl.*\|\s*(sh|bash|python|perl|ruby)/i, reason: 'curl|sh to unknown host' },
+    { pattern: /rm\s+-rf\s+--no-preserve-root\s+\//, reason: 'recursive delete --no-preserve-root' },
 ];
 export const shellExecTool = defineTool({
     name: 'shell_exec',
-    description: 'Execute a shell command. Default timeout 30s. Output is truncated at 128 KiB. Returns exitCode (or null if killed by signal). Non-zero exit code is NOT a tool error — the tool succeeds and the agent sees the exit code in the output.',
+    description: 'Execute a shell command. Default timeout 120s (max 600s). Output head+tail 30k chars, full to ~/.klyro/tool-output/<id>.txt. Persistent cwd, filtered env, tree-kill on timeout.',
     inputSchema: InputSchema,
+    permission: 'execute',
+    isConcurrencySafe: false,
+    renderCall: (input) => `$ ${input.command.slice(0, 80)}`,
+    renderResult: (output) => `exit ${output.exitCode} (${output.durationMs}ms${output.timedOut ? ' timedOut' : ''})`,
     execute: async (input, ctx) => {
         return safe(async () => {
+            // Interactive detection
+            for (const pat of INTERACTIVE_PATTERNS) {
+                if (pat.test(input.command)) {
+                    throw Object.assign(new Error(`Interactive command blocked: ${input.command.split(' ')[0]} — hint: use non-interactive mode or run in background`), { code: TOOL_ERROR_CODES.COMMAND_DENIED });
+                }
+            }
             for (const { pattern, reason } of DANGEROUS_PATTERNS) {
                 if (pattern.test(input.command)) {
-                    return {
-                        ok: false,
-                        error: { code: TOOL_ERROR_CODES.COMMAND_DENIED, message: `Command blocked: ${reason}` },
-                    };
+                    throw Object.assign(new Error(`Command blocked: ${reason}`), { code: TOOL_ERROR_CODES.COMMAND_DENIED });
                 }
             }
-            let cwd = ctx.cwd;
+            // Persistent cwd
+            let cwd = persistentCwd ?? ctx.cwd;
             if (input.cwd) {
                 cwd = resolveWithinCwd(ctx.cwd, input.cwd).resolved;
+                persistentCwd = cwd;
+            }
+            else if (input.command.trim().startsWith('cd ')) {
+                const m = /^\s*cd\s+(.+?)\s*(?:&&|;|$)/.exec(input.command);
+                if (m?.[1]) {
+                    try {
+                        const target = m[1].replace(/^["']|["']$/g, '');
+                        const resolved = resolveWithinCwd(cwd, target).resolved;
+                        persistentCwd = resolved;
+                    }
+                    catch { /* ignore */ }
+                }
             }
-            const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-            const env = { ...process.env, ...(input.env ?? {}) };
+            const timeoutMs = Math.min(input.timeoutMs ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+            const env = filteredEnv(input.env);
             const start = Date.now();
             const child = spawn(input.command, {
                 cwd,
@@ -61,20 +125,29 @@ export const shellExecTool = defineTool({
             });
             const stdoutChunks = [];
             const stderrChunks = [];
+            const fullStdout = [];
+            const fullStderr = [];
             let totalOut = 0;
             let totalErr = 0;
             let truncated = false;
             child.stdout?.on('data', (chunk) => {
-                if (totalOut + chunk.length > MAX_OUTPUT_BYTES) {
+                fullStdout.push(chunk);
+                if (totalOut + chunk.length > MAX_OUTPUT_CHARS) {
                     truncated = true;
+                    // Keep head+tail: drop middle, keep first half and last half later
+                    if (stdoutChunks.length < 10)
+                        stdoutChunks.push(chunk);
                     return;
                 }
                 stdoutChunks.push(chunk);
                 totalOut += chunk.length;
             });
             child.stderr?.on('data', (chunk) => {
-                if (totalErr + chunk.length > MAX_OUTPUT_BYTES) {
+                fullStderr.push(chunk);
+                if (totalErr + chunk.length > MAX_OUTPUT_CHARS) {
                     truncated = true;
+                    if (stderrChunks.length < 10)
+                        stderrChunks.push(chunk);
                     return;
                 }
                 stderrChunks.push(chunk);
@@ -100,7 +173,7 @@ export const shellExecTool = defineTool({
                     // -SIGKILL signals the group so children go too.
                     if (process.platform === 'win32') {
                         try {
-                            require('node:child_process').spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
+                            spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
                         }
                         catch { /* already gone */ }
                     }
@@ -116,8 +189,39 @@ export const shellExecTool = defineTool({
                 child.on('error', () => finish({ code: null, signal: null, timedOut: false }));
             });
             const { code: exitCode, signal, timedOut } = outcome;
-            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
-            const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+            const fullOutBuf = Buffer.concat(fullStdout);
+            const fullErrBuf = Buffer.concat(fullStderr);
+            // Write full output to ~/.klyro/tool-output/<id>.txt for 3.3
+            const outId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            try {
+                const fs = await import('node:fs/promises');
+                const path = await import('node:path');
+                await fs.mkdir(FULL_OUTPUT_DIR, { recursive: true });
+                const fullPath = path.join(FULL_OUTPUT_DIR, `${outId}.txt`);
+                const fullContent = `STDOUT:\n${fullOutBuf.toString('utf-8')}\n\nSTDERR:\n${fullErrBuf.toString('utf-8')}\n`;
+                await fs.writeFile(fullPath, fullContent, 'utf-8');
+            }
+            catch { /* ignore */ }
+            // Head+tail truncation: keep first 15k and last 15k chars
+            let stdout;
+            let stderr;
+            if (truncated) {
+                const fullOutStr = fullOutBuf.toString('utf-8');
+                const fullErrStr = fullErrBuf.toString('utf-8');
+                const headTail = (s) => {
+                    if (s.length <= MAX_OUTPUT_CHARS)
+                        return s;
+                    const head = s.slice(0, 15000);
+                    const tail = s.slice(-15000);
+                    return head + `\n... [truncated ${s.length - 30000} chars, full at ~/.klyro/tool-output/${outId}.txt]\n` + tail;
+                };
+                stdout = headTail(fullOutStr);
+                stderr = headTail(fullErrStr);
+            }
+            else {
+                stdout = Buffer.concat(stdoutChunks).toString('utf-8');
+                stderr = Buffer.concat(stderrChunks).toString('utf-8');
+            }
             return {
                 command: input.command,
                 exitCode,

package/dist/tools/types.d.ts

@@ -33,6 +33,21 @@ export interface ToolContext {
     signal?: AbortSignal;
     /** True when running headless (CI, pipe). Tools should avoid prompts. */
     nonInteractive?: boolean;
+    /** Current session id (for tracing). */
+    sessionId?: string;
+    /** Permissions snapshot for this turn. */
+    permissions?: {
+        mode?: string;
+        allow?: string[];
+        deny?: string[];
+    };
+    /** Logger (pino-like) */
+    logger?: {
+        debug: (msg: string, data?: unknown) => void;
+        info: (msg: string, data?: unknown) => void;
+    };
+    /** Emit KlyroEvent */
+    emit?: (ev: import('../events/catalog.js').KlyroEvent) => void;
 }
 /**
  * A typed tool definition. TInput is the validated input shape; TOutput is
@@ -45,6 +60,16 @@ export interface Tool<TInput, TOutput> {
     description: string;
     /** Zod schema for runtime validation. */
     inputSchema: z.ZodType<TInput>;
+    /** Permission class: read | edit | execute | admin */
+    permission?: 'read' | 'edit' | 'execute' | 'admin';
+    /** True if tool is safe to run in parallel with others */
+    isConcurrencySafe?: boolean;
+    /** Render call for approval UI */
+    renderCall?: (input: TInput) => string;
+    /** Render result for UI */
+    renderResult?: (output: TOutput) => string;
+    /** Truncate large results to maxResultTokens (default 8k) */
+    truncate?: (output: TOutput, maxTokens: number) => TOutput | string;
     /** Execute the tool. Must never throw — return a ToolResult instead. */
     execute(input: TInput, ctx: ToolContext): Promise<ToolResult<TOutput>>;
 }

package/dist/trace/writer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 3.1 — TraceWriter (JSONL, fsync on tool results)
+ */
+import type { KlyroEvent } from '../events/catalog.js';
+export declare class TraceWriter {
+    private filePath;
+    constructor(sessionId: string, dir?: string);
+    init(): Promise<void>;
+    write(ev: KlyroEvent): Promise<void>;
+    close(): Promise<void>;
+    get path(): string;
+    readAll(): Promise<KlyroEvent[]>;
+}

package/dist/trace/writer.js

@@ -0,0 +1,53 @@
+/**
+ * 3.1 — TraceWriter (JSONL, fsync on tool results)
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export class TraceWriter {
+    filePath;
+    constructor(sessionId, dir) {
+        const base = dir ?? path.join(process.cwd(), '.klyro', 'traces');
+        this.filePath = path.join(base, `${sessionId}.jsonl`);
+    }
+    async init() {
+        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+        // Ensure file exists
+        try {
+            await fs.appendFile(this.filePath, '', 'utf-8');
+        }
+        catch { /* ignore */ }
+    }
+    async write(ev) {
+        const line = JSON.stringify(ev) + '\n';
+        await fs.appendFile(this.filePath, line, 'utf-8');
+        // fsync on tool results for crash safety
+        if (ev.type === 'tool.result') {
+            try {
+                const handle = await fs.open(this.filePath, 'r+');
+                try {
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    async close() {
+        // No persistent handle to close
+    }
+    get path() {
+        return this.filePath;
+    }
+    // For tests: read back
+    async readAll() {
+        try {
+            const raw = await fs.readFile(this.filePath, 'utf-8');
+            return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/tui/app.d.ts

@@ -1,14 +1,6 @@
 /**
  * Ink app root — status line + scrollable transcript + input box.
- *
- * Owns the session state machine:
- *   - transcript: array of TranscriptItem (rendered by <Transcript/>)
- *   - status: snapshot for the <StatusLine/>
- *   - input: the current input-box buffer
- *
- * The actual agent loop runs externally; the app just listens for
- * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
- * translates them into transcript/status updates.
+ * 1.4: history per project, multiline, Ctrl+C double, slash registry, Windows handling
  */
 import React from 'react';
 import { type StatusSnapshot } from './status.js';
@@ -18,18 +10,12 @@ import type { PlanStep } from '../agent/runtime.js';
 export interface AppProps {
     initialModel: string;
     maxSteps: number;
-    /** Working directory to display in the header. */
     cwd: string;
-    /** Called when the user submits a non-slash prompt. */
     onPrompt: (text: string) => void | Promise<void>;
-    /** Called when the user types a slash command. */
     onSlash: (cmd: import('../cli/slash/parser.js').SlashCommand) => void | Promise<void>;
-    /** Initial state (e.g. when resuming a session). */
     initialTranscript?: TranscriptItem[];
     initialStatus?: Partial<StatusSnapshot>;
-    /** Optional approval bridge — when set, the modal prompts inline. */
     approvalBridge?: TuiApprovalBridge;
-    /** Called once after mount with direct hooks; also installs global compat hooks. */
     onMounted?: (hooks: {
         append: (i: TranscriptItem) => void;
         updateStatus: (s: Partial<StatusSnapshot>) => void;

package/dist/tui/app.js

@@ -1,15 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Ink app root — status line + scrollable transcript + input box.
- *
- * Owns the session state machine:
- *   - transcript: array of TranscriptItem (rendered by <Transcript/>)
- *   - status: snapshot for the <StatusLine/>
- *   - input: the current input-box buffer
- *
- * The actual agent loop runs externally; the app just listens for
- * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
- * translates them into transcript/status updates.
+ * 1.4: history per project, multiline, Ctrl+C double, slash registry, Windows handling
  */
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
@@ -19,11 +11,60 @@ import { Header } from './header.js';
 import { ApprovalModal, TuiApprovalBridge } from './approval.js';
 import { PlanView } from './plan.js';
 import { parse as parseSlash } from '../cli/slash/parser.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawnSync } from 'node:child_process';
 let _itemCounter = 0;
 function nextId(prefix) {
     _itemCounter += 1;
     return `${prefix}-${_itemCounter}`;
 }
+function getGitBranch(cwd) {
+    try {
+        const r = spawnSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf-8', timeout: 800, windowsHide: true });
+        if (r.status === 0 && r.stdout)
+            return r.stdout.trim().slice(0, 40);
+    }
+    catch { /* ignore */ }
+    return '';
+}
+function getHistoryPath() {
+    const home = os.homedir() || process.cwd();
+    return path.join(home, '.klyro', 'history');
+}
+function loadHistory(cwd) {
+    try {
+        const raw = fs.readFileSync(getHistoryPath(), 'utf-8');
+        const lines = raw.split('\n').filter(Boolean);
+        const out = [];
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.cwd === cwd && typeof obj.text === 'string')
+                    out.push(obj.text);
+            }
+            catch {
+                // legacy plain text per line
+                if (line.trim())
+                    out.push(line.trim());
+            }
+        }
+        return out.slice(-200);
+    }
+    catch {
+        return [];
+    }
+}
+function appendHistory(cwd, text) {
+    try {
+        const p = getHistoryPath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const entry = JSON.stringify({ cwd, text, ts: Date.now() });
+        fs.appendFileSync(p, entry + '\n', 'utf-8');
+    }
+    catch { /* ignore */ }
+}
 export function App(props) {
     const [transcript, setTranscript] = useState(props.initialTranscript ?? []);
     const [input, setInput] = useState('');
@@ -41,14 +82,21 @@ export function App(props) {
         status: 'idle',
         ...props.initialStatus,
     });
-    // Track bridge state to disable the input box while a prompt is up.
+    const [history, setHistory] = useState(() => loadHistory(props.cwd));
+    const historyIndexRef = useRef(-1);
+    const lastCtrlCRef = useRef(0);
+    const [gitBranch, setGitBranch] = useState(() => getGitBranch(props.cwd));
+    const [queued, setQueued] = useState(null);
+    useEffect(() => {
+        const t = setInterval(() => setGitBranch(getGitBranch(props.cwd)), 5000);
+        return () => clearInterval(t);
+    }, [props.cwd]);
     useEffect(() => {
         return bridge.subscribe((p) => setAwaitingApproval(p !== null));
     }, [bridge]);
     const append = useCallback((item) => {
         setTranscript((prev) => {
             const last = prev[prev.length - 1];
-            // Only coalesce when IDs match — separate turns have different IDs
             if (last?.kind === 'text' &&
                 item.kind === 'text' &&
                 last.role === 'assistant' &&
@@ -66,13 +114,10 @@ export function App(props) {
         setPlan(p);
         setPlanExpanded(true);
     }, []);
-    // Stabilize onMounted to avoid re-installing hooks on every parent re-render
     const onMountedRef = useRef(props.onMounted);
     useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
     useEffect(() => {
-        // Instance-local hooks via callback (preferred)
         onMountedRef.current?.({ append, updateStatus, updatePlan });
-        // Global compat hooks for tests / legacy callers (single instance at a time)
         globalThis.__klyroAppAppend = append;
         globalThis.__klyroAppStatus = updateStatus;
         globalThis.__klyroAppPlan = updatePlan;
@@ -82,21 +127,131 @@ export function App(props) {
             delete globalThis.__klyroAppPlan;
         };
     }, [append, updateStatus, updatePlan]);
+    // Handle Windows raw-mode fallback warning
+    const [rawModeWarning, setRawModeWarning] = useState(null);
+    useEffect(() => {
+        try {
+            const stdin = process.stdin;
+            if (stdin.isTTY && typeof stdin.setRawMode !== 'function') {
+                setRawModeWarning('Raw mode not available (mintty) — input may be limited');
+            }
+        }
+        catch { /* ignore */ }
+    }, []);
+    // Queue next message if typed during stream (2.4)
+    useEffect(() => {
+        if (queued && status.status !== 'running' && !awaitingApproval) {
+            const toSend = queued;
+            setQueued(null);
+            const trimmed = toSend.trim();
+            if (!trimmed)
+                return;
+            append({ id: nextId('text'), kind: 'text', text: toSend, role: 'user' });
+            const cmd = parseSlash(trimmed);
+            if (cmd.kind === 'prompt')
+                void props.onPrompt(cmd.text);
+            else if (cmd.kind === 'plan') {
+                if (plan.length > 0)
+                    setPlanExpanded((v) => !v);
+            }
+            else
+                void props.onSlash(cmd);
+        }
+    }, [queued, status.status, awaitingApproval, plan.length, append]);
     useInput((inputStr, key) => {
-        if (status.status === 'running' || awaitingApproval)
+        if (awaitingApproval)
+            return;
+        if (status.status === 'running') {
+            if (key.ctrl && inputStr === 'c') {
+                void props.onSlash({ kind: 'quit' });
+                return;
+            }
+            if (key.return) {
+                const value = input.trim();
+                if (!value)
+                    return;
+                setQueued(value);
+                setInput('');
+                append({ id: nextId('text'), kind: 'text', text: `queued: ${value.slice(0, 80)}`, role: 'assistant' });
+                return;
+            }
+            if (!key.ctrl && !key.meta) {
+                // Show typing indicator but don't change input (queued mode)
+                return;
+            }
+            return;
+        }
+        // History navigation
+        if (key.upArrow) {
+            if (history.length === 0)
+                return;
+            if (historyIndexRef.current === -1)
+                historyIndexRef.current = history.length - 1;
+            else if (historyIndexRef.current > 0)
+                historyIndexRef.current--;
+            setInput(history[historyIndexRef.current] ?? '');
+            return;
+        }
+        if (key.downArrow) {
+            if (historyIndexRef.current === -1)
+                return;
+            historyIndexRef.current++;
+            if (historyIndexRef.current >= history.length) {
+                historyIndexRef.current = -1;
+                setInput('');
+            }
+            else {
+                setInput(history[historyIndexRef.current] ?? '');
+            }
+            return;
+        }
+        // Ctrl+R search — simple: cycle history
+        if (key.ctrl && inputStr === 'r') {
+            if (history.length === 0)
+                return;
+            const term = input.toLowerCase();
+            for (let i = history.length - 1; i >= 0; i--) {
+                if (history[i].toLowerCase().includes(term)) {
+                    setInput(history[i]);
+                    return;
+                }
+            }
             return;
+        }
         if (key.return) {
-            const value = input.trim();
-            setInput('');
-            if (!value)
+            // Multiline: trailing \ or Shift+Enter (where supported, key.shift is true)
+            // Ink's key object has `shift` for Shift+Enter on some terminals
+            const isShiftEnter = key.shift === true;
+            if (isShiftEnter || input.endsWith('\\')) {
+                // Replace trailing \ with newline, or just add newline for Shift+Enter
+                if (input.endsWith('\\'))
+                    setInput((v) => v.slice(0, -1) + '\n');
+                else
+                    setInput((v) => v + '\n');
+                return;
+            }
+            const value = input;
+            // Preserve newlines for bracketed paste — don't trim inner newlines, only outer
+            const trimmedOuter = value.replace(/^\s+|\s+$/g, '');
+            if (!trimmedOuter) {
+                setInput('');
                 return;
+            }
+            // Check for Ctrl+C double at empty prompt handled below, but here handle submit
+            setInput('');
+            historyIndexRef.current = -1;
+            // Save to history
+            setHistory((prev) => {
+                const next = [...prev, value];
+                appendHistory(props.cwd, value);
+                return next.slice(-200);
+            });
             append({ id: nextId('text'), kind: 'text', text: value, role: 'user' });
-            const cmd = parseSlash(value);
+            const cmd = parseSlash(trimmedOuter);
             if (cmd.kind === 'prompt') {
                 void props.onPrompt(cmd.text);
             }
             else if (cmd.kind === 'plan') {
-                // Local UI command — toggle the plan view inline.
                 if (plan.length > 0)
                     setPlanExpanded((v) => !v);
             }
@@ -109,13 +264,39 @@ export function App(props) {
             setInput((v) => v.slice(0, -1));
             return;
         }
+        // Ctrl+C double at empty prompt exits
         if (key.ctrl && inputStr === 'c') {
+            if (input === '') {
+                const now = Date.now();
+                if (now - lastCtrlCRef.current < 1500) {
+                    void props.onSlash({ kind: 'quit' });
+                    return;
+                }
+                lastCtrlCRef.current = now;
+                append({ id: nextId('text'), kind: 'text', text: '(press Ctrl+C again to exit)', role: 'assistant' });
+                return;
+            }
+            // Single Ctrl+C cancels input
+            setInput('');
+            return;
+        }
+        if (key.ctrl && inputStr === 'd') {
             void props.onSlash({ kind: 'quit' });
             return;
         }
+        if (key.ctrl && inputStr === 'l') {
+            // Clear — keep session but clear transcript marker
+            append({ id: nextId('text'), kind: 'text', text: '(cleared)', role: 'assistant' });
+            return;
+        }
+        // Handle bracketed paste: inputStr may contain \r\n or multiple lines
         if (!key.ctrl && !key.meta) {
-            setInput((v) => v + inputStr);
+            // Preserve all characters including newlines from paste
+            // Normalize \r\n to \n
+            const normalized = inputStr.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            setInput((v) => v + normalized);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { cwd: props.cwd, model: status.model, step: status.step, maxSteps: status.maxSteps }), _jsx(StatusLine, { snapshot: status }), plan.length > 0 ? (_jsx(PlanView, { steps: plan, expanded: planExpanded, onToggle: () => setPlanExpanded((v) => !v) })) : null, _jsx(Transcript, { items: transcript }), awaitingApproval ? _jsx(ApprovalModal, { bridge: bridge }) : null, _jsxs(Box, { borderStyle: "single", borderColor: awaitingApproval ? 'yellow' : 'gray', paddingX: 1, children: [_jsx(Text, { color: "gray", children: awaitingApproval ? '! ' : '> ' }), _jsx(Text, { children: awaitingApproval ? '(awaiting approval — see above)' : input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] })] }));
+    const promptStr = `klyro › ${path.basename(props.cwd)}${gitBranch ? ` (${gitBranch})` : ''}`;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { cwd: props.cwd, model: status.model, step: status.step, maxSteps: status.maxSteps }), rawModeWarning ? _jsx(Box, { children: _jsx(Text, { color: "yellow", children: rawModeWarning }) }) : null, _jsx(StatusLine, { snapshot: status }), plan.length > 0 ? (_jsx(PlanView, { steps: plan, expanded: planExpanded, onToggle: () => setPlanExpanded((v) => !v) })) : null, _jsx(Transcript, { items: transcript }), awaitingApproval ? _jsx(ApprovalModal, { bridge: bridge }) : null, _jsxs(Box, { borderStyle: "single", borderColor: awaitingApproval ? 'yellow' : 'gray', paddingX: 1, children: [_jsx(Text, { color: "gray", children: awaitingApproval ? '! ' : `${promptStr} ` }), _jsx(Text, { children: awaitingApproval ? '(awaiting approval — see above)' : input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "Tab: slash completion \u00B7 Shift+Enter: newline \u00B7 Ctrl+C twice: exit \u00B7 Ctrl+R: history" }) })] }));
 }