@bahulam/code 0.1.13 → 0.1.14

package/src/plugins/pi-compat/scaffold.mjs

@@ -24,20 +24,24 @@ import * as path from 'node:path';
 import { COMPOSED_TOOL_SEPARATOR } from '../pi-compose.mjs';
 
 /**
- * Derive a pack slug from a pi package name.
- *   pi-web-access → web-access-studio
- *   pi-redmine    → redmine-studio
- *   @ffmpeg/transitions → transitions-studio
- *   plain-name    → plain-name-studio
+ * Derive a pack slug from a source package name. No forced suffix — a
+ * pack can be anything (studio, analyzer, connector, worker, …), and
+ * pinning a semantic to the slug guesses wrong most of the time. The
+ * default is the source name, sanitized. Author overrides with --slug.
+ *
+ *   pi-web-access        → pi-web-access
+ *   pi-redmine           → pi-redmine
+ *   @ffmpeg/transitions  → transitions        (scope stripped)
+ *   filesystem-mcp       → filesystem-mcp
+ *   plain-name           → plain-name
  */
 export function deriveSlug(packageName) {
   let base = String(packageName || '').trim();
   const scoped = base.match(/^@[^/]+\/(.+)$/);
   if (scoped) base = scoped[1];
-  base = base.replace(/^pi-/, '');
   base = base.replace(/[^a-z0-9-]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase();
-  if (!base) base = 'pi-pack';
-  return `${base}-studio`;
+  if (!base) base = 'pack';
+  return base;
 }
 
 /**
@@ -77,13 +81,75 @@ function truncate(s, n) {
   return str.slice(0, n - 1) + '…';
 }
 
+/**
+ * Compose the "Requirements & constraints" block from the analyzer's
+ * findings. Injected into the generated agent's system prompt so the
+ * sub-agent knows what its composed tools need — no user teaching
+ * required. Falls back to an empty list if requirements is absent (fresh
+ * install where the analyzer didn't run, etc.).
+ */
+function requirementsPromptLines(requirements, namespace) {
+  if (!requirements) return [];
+  const lines = ['', 'Requirements & constraints (from ingredient analysis):'];
+  const bins = requirements.system_binaries || [];
+  if (bins.length) {
+    const names = bins.map(b => b.name).join(', ');
+    lines.push(
+      `- System binaries required: ${names}. If a tool errors with "ENOENT" or "spawn ${bins[0].name}", tell the user to install them (macOS: \`${bins[0].install_hints?.darwin || 'via brew'}\`; Linux: \`${bins[0].install_hints?.linux || 'via package manager'}\`).`,
+    );
+  }
+  const creds = (requirements.env_vars || []).filter(v => v.credential);
+  if (creds.length) {
+    lines.push(
+      `- API keys / credentials expected: ${creds.map(v => v.name).join(', ')}. If a tool fails with an auth error, ask the user to set the missing env var.`,
+    );
+  }
+  if (requirements.workspace_scoped_paths) {
+    lines.push(
+      '- Paths passed to composed tools MUST be workspace-relative (relative to the current working directory). Absolute paths outside cwd are rejected with "Path is outside the workspace". If the user references an absolute path, ask them to `cd` closer to it or copy the file into the workspace.',
+    );
+  }
+  // Per-tool schema constraints the agent must respect. Emit BOTH required
+  // fields AND regex/range constraints — the underlying pi tools throw
+  // opaque path/type errors when a required param is missing, and the
+  // agent's default reasoning tends to skip params whose descriptions
+  // sound "optional" even when the schema marks them required.
+  const tc = requirements.tool_constraints || {};
+  const toolsWithConstraints = Object.keys(tc).filter(t => Object.keys(tc[t]).length);
+  if (toolsWithConstraints.length) {
+    lines.push('- Strict input schemas — supply EVERY required field and respect all constraints. Missing a required field usually throws an opaque error like `paths[1] argument must be of type string`:');
+    for (const t of toolsWithConstraints) {
+      const params = tc[t];
+      const required = Object.keys(params).filter(p => params[p].required);
+      const regexed = Object.entries(params).filter(([, c]) => c.regex);
+      const ranged = Object.entries(params).filter(([, c]) => c.min != null || c.max != null || c.enum);
+      if (required.length) {
+        lines.push(`    - \`${namespace}${COMPOSED_TOOL_SEPARATOR}${t}\` requires: ${required.map(p => `\`${p}\``).join(', ')}`);
+      }
+      for (const [param, c] of regexed) {
+        lines.push(`        · \`${param}\` must match \`${c.regex}\``);
+      }
+      for (const [param, c] of ranged) {
+        const parts = [];
+        if (c.min != null) parts.push(`min ${c.min}`);
+        if (c.max != null) parts.push(`max ${c.max}`);
+        if (c.enum) parts.push(`one of ${JSON.stringify(c.enum)}`);
+        lines.push(`        · \`${param}\` ${parts.join(', ')}`);
+      }
+    }
+  }
+  // If we detected no external requirements at all, keep the block out so
+  // the prompt stays clean.
+  return lines.length > 1 ? lines : [];
+}
+
 /**
  * Compose an agent system prompt from the pi package + its tools.
  * Focused on WHAT the agent should do, not step-by-step recipes — the
  * generic template can't know the pack's domain. Users are expected to
  * edit the prompt after generation.
  */
-function generatePrompt(packageName, namespace, toolNames, hasState) {
+function generatePrompt(packageName, namespace, toolNames, hasState, requirements = null) {
   const composed = toolNames.map(t => `${namespace}${COMPOSED_TOOL_SEPARATOR}${t}`);
   const stateLines = hasState
     ? [
@@ -103,6 +169,7 @@ function generatePrompt(packageName, namespace, toolNames, hasState) {
     'Available composed tools:',
     ...composed.map(t => `- \`${t}\``),
     ...stateLines,
+    ...requirementsPromptLines(requirements, namespace),
     '',
     'Rules:',
     '- Use the composed tools directly — do not describe what you would do, DO it.',
@@ -453,7 +520,16 @@ export function scaffoldPiPack({
     `Specialist agent for ${packageName}. Composes ${toolNames.length} tool${toolNames.length === 1 ? '' : 's'} exposed as ${namespace}${COMPOSED_TOOL_SEPARATOR}*.`,
     240,
   );
-  const systemPrompt = generatePrompt(packageName, namespace, toolNames, state);
+
+  // Pull the requirements sidecar the analyzer wrote at install time
+  // (may be absent if user is scaffolding manually with an older ingredient).
+  let requirements = null;
+  const reqSidecar = path.join(piDir, '.bahulam-requirements.json');
+  if (fs.existsSync(reqSidecar)) {
+    try { requirements = JSON.parse(fs.readFileSync(reqSidecar, 'utf-8')); } catch { /* skip */ }
+  }
+
+  const systemPrompt = generatePrompt(packageName, namespace, toolNames, state, requirements);
 
   const manifest = renderManifest({
     slug,

package/src/plugins/pi-compat/shim.mjs

@@ -130,5 +130,33 @@ export function createPiShim({ pluginName = 'pi', captured }) {
     },
   };
 
-  return pi;
+  // Pi's ExtensionAPI is a moving target — packages call methods we haven't
+  // stubbed yet (registerMessageRenderer, registerRoute, registerHandler,
+  // …). Any unstubbed method call throws, aborting activation before
+  // registerTool ever runs, and the probe reports 0 tools.
+  //
+  // Fall back to a no-op returner for every unknown property so activation
+  // reaches its full extent. A tool's runtime call may still fail if it
+  // needed that surface — that's an accurate signal at execution time,
+  // not a silent black hole at load time.
+  return new Proxy(pi, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver);
+      if (typeof prop === 'symbol') return undefined;
+      if (process.env.DEBUG) {
+        process.stderr.write(`[pi:${pluginName}] shim: pi.${String(prop)} stubbed (no-op)\n`);
+      }
+      // Return a callable that also has method access (e.g. pi.foo.bar).
+      // Property access on the stub returns another stub, so chains never
+      // throw. Result is undefined so anything that reads a return value
+      // treats it as "not present" (typeof result === 'undefined').
+      const stub = function stub() { return undefined; };
+      return new Proxy(stub, {
+        get(t, p) {
+          if (typeof p === 'symbol') return t[p];
+          return stub;
+        },
+      });
+    },
+  });
 }

package/src/plugins/preflight.mjs

@@ -39,6 +39,8 @@ export const RESERVED_TOOL_NAMES = new Set([
   // write
   'write_file', 'write_project', 'edit_file', 'delete_file', 'shell',
   'analyze_image', 'generate_image',
+  // background jobs (PRD-102 §6.2.3) — long-running renders, builds, etc.
+  'job_output', 'job_kill', 'job_status', 'job_list',
   // agent/skill/workflow admin
   'ask_user', 'agent_create', 'agent_sync', 'agents_list',
   'skill_install', 'skill_update', 'skill_remove', 'skill_view', 'skills_list',

package/src/terminal/main.mjs

@@ -27,6 +27,7 @@ const PLUGIN_MANAGEMENT_COMMANDS = new Set([
   'validate', 'check', 'lint',
   'list', 'ls', 'remove', 'rm', 'uninstall',
   'enable', 'disable', 'info', 'update', 'upgrade',
+  'doctor',
 ]);
 
 function parsePluginArgs(argv) {
@@ -69,7 +70,7 @@ function parsePluginArgs(argv) {
       if (arg && (arg.includes('/') || fs.existsSync?.(arg))) parsed.source = arg;
       else parsed.pluginName = arg;
     }
-    else if (['info', 'remove', 'rm', 'uninstall', 'enable', 'disable', 'update', 'upgrade'].includes(parsed.action)) {
+    else if (['info', 'remove', 'rm', 'uninstall', 'enable', 'disable', 'update', 'upgrade', 'doctor'].includes(parsed.action)) {
       parsed.pluginName = positional.shift() || null;
     }
   } else {

package/src/terminal/repl.mjs

@@ -184,6 +184,7 @@ import {
   moveToContent,
   prepareInputPrompt,
   redrawDockFrame,
+  redrawDockInput,
   renderDockInput,
   unmountInputDock,
 } from '../ui/input-dock.mjs';
@@ -1559,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;
@@ -1591,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,
@@ -1604,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;
@@ -1614,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;
@@ -1631,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()) {
@@ -2322,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();
@@ -2331,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');
@@ -2342,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.
@@ -2367,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
@@ -2433,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
@@ -2733,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;
@@ -4298,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;
   };
 

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;
@@ -725,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() {
@@ -766,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 ────────────────────────────────────────────────────────────