@bahulam/code 0.1.12 → 0.1.14

package/src/terminal/repl.mjs

@@ -71,6 +71,7 @@ import { PluginRegistry } from '../plugins/registry.mjs';
 import { SessionManager } from '../core/session-manager.mjs';
 import { parseArgs } from '../config/cli-args.mjs';
 import { pickModelOverridesForm } from './repl-model-form.mjs';
+import { isRawMultilinePasteChunk, normalizePastedText, pastedTextLabel } from './paste-input.mjs';
 import {
   MODEL_CATEGORY_ORDER,
   formatCategoryBadge,
@@ -183,6 +184,7 @@ import {
   moveToContent,
   prepareInputPrompt,
   redrawDockFrame,
+  redrawDockInput,
   renderDockInput,
   unmountInputDock,
 } from '../ui/input-dock.mjs';
@@ -1558,11 +1560,35 @@ function subAgentRunId(data = {}) {
   return data?.run_id || data?.sub_agent_run_id || null;
 }
 
+function activeSubAgentRunsMap() {
+  const runs = session.activeSubAgentRuns;
+  if (runs instanceof Map) return runs;
+
+  const restored = new Map();
+  if (Array.isArray(runs)) {
+    for (const item of runs) {
+      if (Array.isArray(item) && item.length >= 2) {
+        restored.set(item[0], item[1]);
+      } else if (item && typeof item === 'object') {
+        const runId = item.runId || item.run_id || item.id;
+        if (runId) restored.set(runId, item);
+      }
+    }
+  } else if (runs && typeof runs === 'object') {
+    for (const [key, value] of Object.entries(runs)) {
+      if (value && typeof value === 'object') restored.set(key, value);
+    }
+  }
+
+  session.activeSubAgentRuns = restored;
+  return restored;
+}
+
 function normalizeSubAgentRunData(data = {}) {
   if (!data || typeof data !== 'object') return data;
   const runId = subAgentRunId(data);
   if (!runId) return data;
-  const laneRun = session.activeSubAgentRuns?.get(runId);
+  const laneRun = activeSubAgentRunsMap().get(runId);
   const patch = {};
   if (!data.run_id) patch.run_id = runId;
   if (laneRun?.type && !data.sub_agent) patch.sub_agent = laneRun.type;
@@ -1590,7 +1616,7 @@ function ensureFoldedSubAgentTools(agentType, key = agentType, data = {}) {
   let fold = runtime.foldedSubAgentToolMap.get(key);
   if (!fold) {
     const runId = subAgentRunId(data);
-    const laneRun = runId ? session.activeSubAgentRuns?.get(runId) : null;
+    const laneRun = runId ? activeSubAgentRunsMap().get(runId) : null;
     fold = {
       key,
       runId,
@@ -1603,7 +1629,7 @@ function ensureFoldedSubAgentTools(agentType, key = agentType, data = {}) {
     runtime.foldedSubAgentToolMap.set(key, fold);
   } else {
     const runId = subAgentRunId(data);
-    const laneRun = runId ? session.activeSubAgentRuns?.get(runId) : null;
+    const laneRun = runId ? activeSubAgentRunsMap().get(runId) : null;
     if (runId && !fold.runId) fold.runId = runId;
     if (laneRun) fold.label = subAgentLaneLabel(laneRun);
     if (laneRun?.query && !fold.query) fold.query = laneRun.query;
@@ -1613,8 +1639,8 @@ function ensureFoldedSubAgentTools(agentType, key = agentType, data = {}) {
 }
 
 function createSubAgentLane(agentType, query, runId, data = {}) {
-  session.activeSubAgentRuns = session.activeSubAgentRuns || new Map();
-  const sameTypeOrdinals = [...session.activeSubAgentRuns.values()]
+  const activeRuns = activeSubAgentRunsMap();
+  const sameTypeOrdinals = [...activeRuns.values()]
     .filter(run => run.type === agentType)
     .map(run => Number(run.ordinal || 1));
   const ordinal = sameTypeOrdinals.length ? Math.max(...sameTypeOrdinals) + 1 : 1;
@@ -1630,16 +1656,14 @@ function createSubAgentLane(agentType, query, runId, data = {}) {
     // the close line agree even for the first run of a batch.
     forceOrdinal: Number(data?.parallel_batch) > 1,
   };
-  session.activeSubAgentRuns.set(runId, lane);
+  activeRuns.set(runId, lane);
   ensureFoldedSubAgentTools(agentType, runId, { type: agentType, query, run_id: runId });
   _syncSubAgentWindow();
   return lane;
 }
 
 function activeSubAgentLanes() {
-  return session.activeSubAgentRuns instanceof Map
-    ? [...session.activeSubAgentRuns.values()]
-    : [];
+  return [...activeSubAgentRunsMap().values()];
 }
 
 function subAgentLaneLabel(lane, lanes = activeSubAgentLanes()) {
@@ -2321,8 +2345,8 @@ function renderEvent(event) {
       // concurrent runs of the same type are only distinguishable by the
       // backend-issued run_id; label lanes explore#1 / explore#2 when
       // more than one run is active. Solo runs render exactly as before.
-      session.activeSubAgentRuns = session.activeSubAgentRuns || new Map();
-      const hadActiveRuns = session.activeSubAgentRuns.size > 0;
+      const activeRuns = activeSubAgentRunsMap();
+      const hadActiveRuns = activeRuns.size > 0;
       if (!hadActiveRuns) {
         stopSpinner();
         clearPendingHead();
@@ -2330,7 +2354,8 @@ function renderEvent(event) {
       }
       const runId = data?.run_id || `${agentType}:${Date.now().toString(36)}`;
       const lane = createSubAgentLane(agentType, query, runId, data);
-      const parallel = session.activeSubAgentRuns.size > 1 || lane.forceOrdinal;
+      const activeRunsAfterStart = activeSubAgentRunsMap();
+      const parallel = activeRunsAfterStart.size > 1 || lane.forceOrdinal;
       const label = subAgentLaneLabel(lane);
       renderBlockBoundary('subagent');
       process.stderr.write(renderSubAgentOpen({ id: runId, type: label, query, parentDepth: parallel ? 0 : undefined }).replace(/^\n/, '') + '\n');
@@ -2341,7 +2366,7 @@ function renderEvent(event) {
       // inner tool calls stream here instead of flooding the transcript.
       setSubAgentWindowActive(true);
       if (hadActiveRuns) {
-        updateSpinner(`${session.activeSubAgentRuns.size} agents running`);
+        updateSpinner(`${activeRunsAfterStart.size} agents running`);
       } else {
         // Phase per sub-agent run: the status line counts elapsed time and
         // tool calls live ("plan agent · 4 calls · 32s") for the whole run.
@@ -2366,16 +2391,17 @@ function renderEvent(event) {
       if (!eventRunId && hasParallelSubAgentRuns()) {
         break;
       }
-      const laneRun = session.activeSubAgentRuns?.get(eventRunId);
+      const laneRun = activeSubAgentRunsMap().get(eventRunId);
       if (laneRun) laneRun.tools++;
       foldSubAgentToolProgress(eventData);
-      const laneParallel = (session.activeSubAgentRuns?.size || 0) > 1;
+      const activeRuns = activeSubAgentRunsMap();
+      const laneParallel = activeRuns.size > 1;
       if (laneParallel) {
         bumpSpinnerProgress();
         const activeLanes = activeSubAgentLanes();
         const lanes = activeLanes
           .map(r => `${subAgentLaneLabel(r, activeLanes)} ${r.tools}`).join(' · ');
-        updateSpinner(`${session.activeSubAgentRuns.size} agents · ${lanes}`);
+        updateSpinner(`${activeRuns.size} agents · ${lanes}`);
         break;
       }
       // Feed the live window from THIS event — it always fires (55/55 in
@@ -2432,16 +2458,17 @@ function renderEvent(event) {
       // Retire this run's display lane; while sibling runs are still
       // active keep the shared window/spinner alive for them.
       const eventRunId = subAgentRunId(eventData);
-      const doneRun = session.activeSubAgentRuns?.get(eventRunId);
+      const activeRuns = activeSubAgentRunsMap();
+      const doneRun = activeRuns.get(eventRunId);
       const doneLabel = doneRun ? subAgentLaneLabel(doneRun) : agentType;
       const doneFold = eventRunId ? removeFoldedSubAgentTools(eventRunId) : null;
       if (doneFold) {
         doneFold.agentType = doneLabel;
         doneFold.label = doneLabel;
       }
-      if (eventRunId) session.activeSubAgentRuns?.delete(eventRunId);
-      else session.activeSubAgentRuns?.clear();
-      const siblingsActive = (session.activeSubAgentRuns?.size || 0) > 0;
+      if (eventRunId) activeRuns.delete(eventRunId);
+      else activeRuns.clear();
+      const siblingsActive = activeRuns.size > 0;
       // In verbose mode each sub-agent tool already rendered a full
       // transcript card live — flushing the fold would list every tool a
       // second time. The fold batch is the durable record ONLY when tools
@@ -2732,17 +2759,18 @@ function renderEvent(event) {
       // late events land correctly instead of corrupting fresh state —
       // but only for ONE turn boundary: if they're still around at the
       // next complete with no closure, force-clean to avoid stale lanes.
-      const lanesLive = (session.activeSubAgentRuns?.size || 0) > 0;
+      const activeRuns = activeSubAgentRunsMap();
+      const lanesLive = activeRuns.size > 0;
       if (lanesLive && !session._lanesPreservedAtTurnEnd) {
         session._lanesPreservedAtTurnEnd = true;
-        const n = session.activeSubAgentRuns.size;
+        const n = activeRuns.size;
         process.stderr.write(`  ${c.dim(`${n} agent run${n === 1 ? '' : 's'} still active in background — progress continues below`)}\n`);
       } else {
         session._lanesPreservedAtTurnEnd = false;
         if (showSubAgentTools(getVerbosity())) resetFoldedSubAgentTools();
         else flushFoldedSubAgentTools();
         resetSubAgents();
-        session.activeSubAgentRuns?.clear();
+        activeRuns.clear();
         setSubAgentWindowActive(false);
       }
       session.inSubAgent = false;
@@ -4297,11 +4325,13 @@ export async function startTerminalRepl() {
       options: Array.isArray(req?.options) ? req.options : [],
       context: req?.context || '',
     });
+    if (isInputDockMounted()) redrawDockInput();
     if (res?.answer) {
       process.stderr.write(`  ${c.green('✓')} ${c.dim('answered:')} ${c.brand(res.answer)}\n`);
     } else {
       process.stderr.write(`  ${c.dim('Question declined — agent proceeds with its own judgment.')}\n`);
     }
+    if (isInputDockMounted()) redrawDockInput();
     return res;
   };
 
@@ -4857,6 +4887,9 @@ export async function startTerminalRepl() {
   let _bracketedPasteStartLine = '';
   let _bracketedPasteStartCursor = 0;
   let _promptHasInsertedPaste = false;
+  let _suppressRawPasteLines = false;
+  let _pastedInputValue = '';
+  let _pastedInputLabel = '';
   const _pasteEndListeners = new Set();
   function onBracketedPasteEnd(cb) { _pasteEndListeners.add(cb); return () => _pasteEndListeners.delete(cb); }
   function isInBracketedPaste() { return _inBracketedPaste; }
@@ -4876,7 +4909,25 @@ export async function startTerminalRepl() {
       while (i < s.length) {
         if (!_inBracketedPaste) {
           const start = s.indexOf(PASTE_BEGIN, i);
-          if (start === -1) return;
+          if (start === -1) {
+            if (isRawMultilinePasteChunk(s)) {
+              _suppressRawPasteLines = true;
+              const baseLine = String(rl?.line || '');
+              const baseCursor = typeof rl?.cursor === 'number' ? rl.cursor : baseLine.length;
+              setImmediate(() => {
+                try {
+                  insertPromptText(normalizePastedText(s), {
+                    baseLine,
+                    baseCursor,
+                    fromPaste: true,
+                  });
+                } finally {
+                  _suppressRawPasteLines = false;
+                }
+              });
+            }
+            return;
+          }
           _inBracketedPaste = true;
           _bracketedPasteBuffer = '';
           _suppressBracketedPasteLines = true;
@@ -5138,7 +5189,11 @@ export async function startTerminalRepl() {
     const line = String(baseLine || '');
     const cursor = typeof baseCursor === 'number' ? Math.max(0, Math.min(line.length, baseCursor)) : line.length;
     const next = `${line.slice(0, cursor)}${payload}${line.slice(cursor)}`;
-    if (fromPaste) _promptHasInsertedPaste = true;
+    if (fromPaste) {
+      _promptHasInsertedPaste = true;
+      _pastedInputValue = next;
+      _pastedInputLabel = pastedTextLabel(payload);
+    }
     replaceReadlineLine(next, cursor + payload.length);
     renderIdleDockInput();
   }
@@ -5178,15 +5233,28 @@ export async function startTerminalRepl() {
 
   function renderIdleDockInput() {
     if (!isInputDockMounted()) return false;
+    const line = rl.line || '';
+    let displayLine = line;
+    let displayCursor = typeof rl.cursor === 'number' ? rl.cursor : null;
+    let fixedRows = null;
+    if (_pastedInputValue && line === _pastedInputValue) {
+      displayLine = _pastedInputLabel;
+      displayCursor = _pastedInputLabel.length;
+      fixedRows = 1;
+    } else if (_pastedInputValue) {
+      _pastedInputValue = '';
+      _pastedInputLabel = '';
+    }
     // rl.cursor is readline's byte offset within rl.line. Threading it
     // through to focusDockInput makes arrow-key navigation visually move
     // the terminal cursor within the buffer instead of always landing at
     // the end of the string.
-    return renderDockInput(userPrompt(), rl.line || '', {
+    return renderDockInput(userPrompt(), displayLine, {
       context: buildContextStrip(),
       meta: buildDockMeta(),
       tips: idleInputTips(),
-      cursor: typeof rl.cursor === 'number' ? rl.cursor : null,
+      cursor: displayCursor,
+      fixedRows,
     });
   }
 
@@ -5232,7 +5300,7 @@ export async function startTerminalRepl() {
     readline.emitKeypressEvents(process.stdin, rl);
     process.stdin.on('keypress', (_str, key = {}) => {
       if (!inputActive) return;
-      if (_inBracketedPaste || _suppressBracketedPasteLines) return;
+      if (_inBracketedPaste || _suppressBracketedPasteLines || _suppressRawPasteLines) return;
       if (key.name === 'return' || key.name === 'enter') return;
       if (key.name === 'f2') {
         clearSlashHint();
@@ -5243,7 +5311,7 @@ export async function startTerminalRepl() {
       }
       setImmediate(() => {
         if (!inputActive) return;
-        if (_inBracketedPaste || _suppressBracketedPasteLines) return;
+        if (_inBracketedPaste || _suppressBracketedPasteLines || _suppressRawPasteLines) return;
         if (slashHintVisible && key.name === 'tab' && acceptSlashHint()) return;
         if (slashHintVisible && key.name === 'down' && moveSlashHintSelection(1)) return;
         if (slashHintVisible && key.name === 'up' && moveSlashHintSelection(-1)) return;
@@ -5305,12 +5373,16 @@ export async function startTerminalRepl() {
     if (pastedLines.length > 1 || trailing) {
       const text = [...pastedLines, trailing].join('\n');
       _promptHasInsertedPaste = true;
+      _pastedInputValue = text;
+      _pastedInputLabel = pastedTextLabel(text);
       replaceReadlineLine(text);
       renderIdleDockInput();
       return;
     }
     const line = pastedLines.join('\n');
     _promptHasInsertedPaste = false;
+    _pastedInputValue = '';
+    _pastedInputLabel = '';
     queueOrRunLine(line);
   }
 
@@ -5320,7 +5392,7 @@ export async function startTerminalRepl() {
   // or the user pressed Enter normally), the debounce falls back to old
   // behavior — a single Enter flushes almost instantly.
   rl.on('line', async (line) => {
-    if (_suppressBracketedPasteLines) {
+    if (_suppressBracketedPasteLines || _suppressRawPasteLines) {
       _pasteLines = [];
       if (_pasteFlushTimer) {
         clearTimeout(_pasteFlushTimer);
@@ -5369,6 +5441,8 @@ export async function startTerminalRepl() {
     let input = line.trim();
     const selectedSlashCommand = selectedSlashCommandFor(input);
     inputActive = false;
+    _pastedInputValue = '';
+    _pastedInputLabel = '';
     clearSlashHint();
     if (selectedSlashCommand) input = selectedSlashCommand;
     if (!input) {

package/src/tools/registry.mjs

@@ -122,6 +122,25 @@ export function createToolRegistry({
             const name = String(toolDef.name || '').trim();
             if (!name || tools.has(name)) continue;
             const pluginName = toolDef._plugin_name || toolDef.plugin_name || null;
+            if (toolDef._composed?.kind === 'pi') {
+                tools.set(name, {
+                    name,
+                    description: toolDef.description || '',
+                    inputSchema: toolDef.input_schema || toolDef.parameters || { type: 'object', properties: {} },
+                    validateInput() { return []; },
+                    async call() {
+                        return {
+                            success: false,
+                            output: `Composed pi tool '${name}' is registered but pi runtime execution is not wired yet`,
+                            _tool: name,
+                            _plugin: pluginName,
+                            _composed: toolDef._composed,
+                            _blocked: true,
+                        };
+                    },
+                });
+                continue;
+            }
             tools.set(name, {
                 name,
                 description: toolDef.description || '',

package/src/ui/input-dock.mjs

@@ -518,6 +518,21 @@ function drawInputLines(lines) {
   // No save/restore — caller parks cursor via focusDockInput.
 }
 
+function terminalCellWidthFromColumn(text, startColumn = 1) {
+  let col = Math.max(1, Math.floor(Number(startColumn) || 1));
+  const start = col;
+  for (const ch of queue.stripSequences(String(text ?? ''))) {
+    const cp = ch.codePointAt(0);
+    if (cp === 0x09) {
+      col = (Math.floor((col - 1) / 8) + 1) * 8 + 1;
+      continue;
+    }
+    if (cp === 0x0a || cp === 0x0d) continue;
+    col += queue.cellWidth(ch);
+  }
+  return Math.max(0, col - start);
+}
+
 export function isInputDockMounted() {
   return mounted;
 }
@@ -650,6 +665,20 @@ export function redrawDockFrame() {
   return true;
 }
 
+export function redrawDockInput() {
+  if (!mounted) return false;
+  contentTrackingActive = false;
+  renderFrame(lastFrame);
+  if (Array.isArray(lastFrame.overlayLines)) {
+    drawInputLines(lastFrame.overlayLines);
+  } else {
+    const layout = layoutInput(lastFrame.prefix, lastFrame.value);
+    drawInputLines(layout.lines);
+  }
+  parkCursorAtInput();
+  return true;
+}
+
 export function prepareInputPrompt({ context = '', tips = '', meta = '' } = {}) {
   if (!mounted) return false;
   contentTrackingActive = false;
@@ -672,10 +701,13 @@ export function clearInputPrompt() {
   return true;
 }
 
-export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null } = {}) {
+export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null, fixedRows = null } = {}) {
   if (!mounted) return false;
   contentTrackingActive = false;
-  setInputRowsTo(computeInputRowsForBuffer(prefix, value));
+  const requestedRows = fixedRows == null
+    ? computeInputRowsForBuffer(prefix, value)
+    : Math.max(MIN_INPUT_ROWS, Math.min(inputRowsMax, Math.floor(Number(fixedRows) || MIN_INPUT_ROWS)));
+  setInputRowsTo(requestedRows);
   renderFrame({ context, tips, meta, prefix, value, cursor, overlayLines: null });
   const layout = layoutInput(prefix, value);
   drawInputLines(layout.lines);
@@ -722,28 +754,35 @@ export function renderDockOverlay({
 export function focusDockInput(prefix, value = '', cursorInValue = null) {
   if (!mounted) return false;
   contentTrackingActive = false;
+  const target = cursorTargetForInput(prefix, value, cursorInValue);
+  if (queue.isActive()) {
+    // Record the park position — every queue op re-parks here so readline
+    // echoes always land in the input row, even mid-stream.
+    queue.park(target.row, target.col);
+    return true;
+  }
+  moveTo(target.row, target.col);
+  return true;
+}
+
+function cursorTargetForInput(prefix, value = '', cursorInValue = null) {
   const layout = layoutInput(prefix, value);
   const valueStr = String(value || '');
   const rawCursor = cursorInValue == null
     ? valueStr.length
     : Math.max(0, Math.min(valueStr.length, Math.floor(cursorInValue)));
   const cursorSlice = valueStr.slice(0, rawCursor);
-  const offset = visibleWidth(`${prefix || ''}${cursorSlice}`);
-  const pos = cursorPositionInLines(layout.wrapped, offset);
+  const inputColumn = INPUT_INDENT + 1;
+  const measureInputLine = (line) => terminalCellWidthFromColumn(line, inputColumn);
+  const offset = terminalCellWidthFromColumn(`${prefix || ''}${cursorSlice}`, inputColumn);
+  const pos = cursorPositionInLines(layout.wrapped, offset, measureInputLine);
   const visibleRowIdx = Math.max(
     0,
     Math.min(inputRows - 1, pos.row - Math.max(0, layout.wrapped.length - inputRows)),
   );
   const row = inputRowStart() + visibleRowIdx;
   const col = Math.min(cols(), INPUT_INDENT + 1 + Math.max(0, pos.col));
-  if (queue.isActive()) {
-    // Record the park position — every queue op re-parks here so readline
-    // echoes always land in the input row, even mid-stream.
-    queue.park(row, col);
-    return true;
-  }
-  moveTo(row, col);
-  return true;
+  return { row, col };
 }
 
 export function inputRowColumn() {
@@ -763,6 +802,8 @@ export function _internals() {
     drawableColumns,
     resetContentCursor,
     contentCursor: () => ({ row: contentCursorRow, col: contentCursorCol, active: contentTrackingActive }),
+    cursorTargetForInput,
+    terminalCellWidthFromColumn,
     overlayRowsForWrapped,
     FIXED_ROWS,
     MAX_INPUT_ROWS_CAP,

package/src/ui/text-layout.mjs

@@ -76,19 +76,20 @@ export function tailWithEllipsis(lines, maxRows, ellipsis = '… ') {
  *
  * Used to place the terminal cursor after rendering the input buffer.
  */
-export function cursorPositionInLines(visibleLines, offset) {
+export function cursorPositionInLines(visibleLines, offset, measure = visibleWidth) {
   const arr = Array.isArray(visibleLines) ? visibleLines : [];
+  const widthOf = typeof measure === 'function' ? measure : visibleWidth;
   let remaining = Math.max(0, Math.floor(offset));
   for (let row = 0; row < arr.length; row++) {
     const line = arr[row] || '';
-    const w = visibleWidth(line);
+    const w = widthOf(line);
     if (remaining <= w) return { row, col: remaining };
     remaining -= w;
     // Newline between wrapped lines doesn't count as a visible column,
     // but consumes zero of the remaining offset either.
   }
   const lastRow = Math.max(0, arr.length - 1);
-  return { row: lastRow, col: visibleWidth(arr[lastRow] || '') };
+  return { row: lastRow, col: widthOf(arr[lastRow] || '') };
 }
 
 // ── internals ────────────────────────────────────────────────────────────