@crouton-kit/crouter 0.3.32 → 0.3.33

package/dist/builtin-views/settings/web.jsx

@@ -0,0 +1,167 @@
+// @ts-check
+/**
+ * Model ladders settings — web presenter for the `settings` view.
+ *
+ * Mouse-first: enum fields (default provider, persona strength) are click-to-pick
+ * chips that save immediately; free-text fields (matrix model ids, new persona)
+ * open an inline editor prefilled with the current value, with Save/Cancel.
+ *
+ * @module settings/web
+ */
+
+import { Loading, NotReady, ErrorState } from '@crouton-kit/crouter/web';
+
+/** @typedef {import('./core.mjs').SettingsState} SettingsState */
+
+const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
+const PROVIDERS = ['anthropic', 'openai'];
+
+/** Inline editor for a free-text field (matrix model id, new persona pair). */
+/** @param {{ state: SettingsState, dispatch: (intent:string, payload?:unknown)=>void }} props */
+function Editor({ state, dispatch }) {
+  if (!state.edit) return null;
+  return (
+    <div className="rounded border border-cyan-300 bg-cyan-50 p-3">
+      <div className="mb-2 text-sm text-slate-600">Editing <span className="font-semibold text-slate-900">{state.edit.label}</span></div>
+      <div className="flex items-center gap-2">
+        <input
+          autoFocus
+          value={state.edit.draft}
+          placeholder={state.edit.kind === 'personaNew' ? 'kind strength' : 'model id'}
+          onChange={(e) => dispatch('setDraft', e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter') { e.preventDefault(); dispatch('submitEdit'); }
+            else if (e.key === 'Escape') { e.preventDefault(); dispatch('cancelEdit'); }
+          }}
+          className="flex-1 rounded border border-slate-300 bg-white px-3 py-2 font-mono text-sm outline-none focus:border-cyan-500"
+        />
+        <button type="button" onClick={() => dispatch('submitEdit')} className="rounded bg-cyan-600 px-3 py-2 text-sm font-semibold text-white hover:bg-cyan-700">Save</button>
+        <button type="button" onClick={() => dispatch('cancelEdit')} className="rounded border border-slate-300 bg-white px-3 py-2 text-sm text-slate-600 hover:bg-slate-100">Cancel</button>
+      </div>
+      {state.edit.kind === 'personaNew' ? <div className="mt-2 text-xs text-slate-500">Format: <code>kind strength</code> or <code>kind=strength</code> (strength = ultra·strong·medium·light).</div> : null}
+    </div>
+  );
+}
+
+/** A small segmented control of fixed choices that saves on click. */
+/** @param {{ choices: string[], value: string, onPick: (c:string)=>void }} props */
+function Segmented({ choices, value, onPick }) {
+  return (
+    <div className="inline-flex overflow-hidden rounded border border-slate-300">
+      {choices.map((c) => (
+        <button
+          key={c}
+          type="button"
+          onClick={() => onPick(c)}
+          className={`px-2.5 py-1 text-sm capitalize ${c === value ? 'bg-cyan-600 text-white' : 'bg-white text-slate-600 hover:bg-slate-100'} ${c !== choices[0] ? 'border-l border-slate-300' : ''}`}
+        >
+          {c}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+/** True when the editor is currently targeting this matrix cell. */
+/** @param {SettingsState} state @param {string} strength @param {string} provider */
+function isEditingCell(state, strength, provider) {
+  return !!state.edit && state.edit.kind === 'matrixCell' && state.edit.strength === strength && state.edit.provider === provider;
+}
+
+/** @param {import('../../core/view/contract.js').ViewProps<SettingsState>} props */
+export default function Settings({ state, dispatch }) {
+  if (state.sourceError && state.modelLadders === null) {
+    const d = state.sourceError.display;
+    const Comp = d.level === 'error' ? ErrorState : NotReady;
+    return <Comp headline={d.headline} explanation={d.explanation} nextStep={d.nextStep || undefined} onRetry={() => dispatch('refresh')} />;
+  }
+  if (state.modelLadders === null) {
+    return <Loading label="Loading model ladders…" />;
+  }
+
+  const ladders = state.modelLadders;
+  const personas = Object.keys(state.personaStrengths).sort((a, b) => a.localeCompare(b));
+  const editingPersonaNew = !!state.edit && state.edit.kind === 'personaNew';
+
+  return (
+    <div className="h-full overflow-auto text-sm">
+      <div className="space-y-5 p-4">
+        <div>
+          <h1 className="text-base font-semibold">Model ladders</h1>
+          <p className="text-xs text-slate-500">Click a model id to edit it; click a provider or strength to switch it. Changes save immediately.</p>
+        </div>
+
+        {/* Default provider — enum, click to pick. */}
+        <div className="flex items-center gap-3">
+          <span className="font-semibold">Default provider</span>
+          <Segmented choices={PROVIDERS} value={ladders.defaultProvider ?? 'anthropic'} onPick={(p) => dispatch('applyValue', { kind: 'defaultProvider', value: p })} />
+        </div>
+
+        {/* Provider × strength matrix — each model id click-to-edit. */}
+        <div className="space-y-3">
+          {STRENGTHS.map((strength) => (
+            <div key={strength}>
+              <div className="mb-1 font-semibold capitalize">{strength}</div>
+              <div className="grid grid-cols-1 gap-2 md:grid-cols-2">
+                {PROVIDERS.map((provider) => {
+                  const editing = isEditingCell(state, strength, provider);
+                  if (editing) {
+                    return (
+                      <div key={provider} className="rounded border border-cyan-300 bg-cyan-50 p-2">
+                        <div className="mb-1 text-xs uppercase tracking-wide text-slate-400">{provider}</div>
+                        <div className="flex items-center gap-2">
+                          <input
+                            autoFocus
+                            value={state.edit.draft}
+                            onChange={(e) => dispatch('setDraft', e.target.value)}
+                            onKeyDown={(e) => {
+                              if (e.key === 'Enter') { e.preventDefault(); dispatch('submitEdit'); }
+                              else if (e.key === 'Escape') { e.preventDefault(); dispatch('cancelEdit'); }
+                            }}
+                            className="flex-1 rounded border border-slate-300 bg-white px-2 py-1 font-mono text-sm outline-none focus:border-cyan-500"
+                          />
+                          <button type="button" onClick={() => dispatch('submitEdit')} className="rounded bg-cyan-600 px-2 py-1 text-xs font-semibold text-white hover:bg-cyan-700">Save</button>
+                          <button type="button" onClick={() => dispatch('cancelEdit')} className="rounded border border-slate-300 bg-white px-2 py-1 text-xs text-slate-600 hover:bg-slate-100">Cancel</button>
+                        </div>
+                      </div>
+                    );
+                  }
+                  const v = ladders[provider]?.[strength] ?? '—';
+                  return (
+                    <button
+                      key={provider}
+                      type="button"
+                      title="Click to edit"
+                      onClick={() => dispatch('beginEditFor', { kind: 'matrix', strength, provider })}
+                      className="rounded border border-slate-200 bg-white px-2 py-1 text-left hover:border-cyan-400 hover:bg-cyan-50"
+                    >
+                      <div className="text-xs uppercase tracking-wide text-slate-400">{provider}</div>
+                      <div className="truncate font-mono text-sm text-slate-800">{v}</div>
+                    </button>
+                  );
+                })}
+              </div>
+            </div>
+          ))}
+        </div>
+
+        {/* Persona strengths — enum per persona, click to pick. */}
+        <div className="space-y-2">
+          <div className="font-semibold">Persona strengths</div>
+          {personas.length === 0 ? <div className="text-xs text-slate-400">None set yet.</div> : null}
+          {personas.map((persona) => (
+            <div key={persona} className="flex items-center gap-3">
+              <span className="w-40 truncate font-mono text-slate-800">{persona}</span>
+              <Segmented choices={STRENGTHS} value={state.personaStrengths[persona] ?? 'strong'} onPick={(s) => dispatch('applyValue', { kind: 'personaStrength', persona, value: s })} />
+            </div>
+          ))}
+          {editingPersonaNew ? (
+            <Editor state={state} dispatch={dispatch} />
+          ) : (
+            <button type="button" onClick={() => dispatch('beginEditFor', { kind: 'addPersona' })} className="rounded border border-dashed border-emerald-400 px-3 py-1.5 text-sm font-semibold text-emerald-700 hover:bg-emerald-50">+ add persona strength</button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

package/dist/cli.js

@@ -1,10 +1,21 @@
 #!/usr/bin/env node
+import { enableCompileCache } from 'node:module';
 import { runCli } from './core/command.js';
 import { resolveRoot } from './build-root.js';
 import { maybeBootRoot } from './core/runtime/front-door.js';
 import { maybeAutoUpdate } from './core/auto-update.js';
 import { ensureOfficialMarketplace, ensureProjectScope } from './core/bootstrap.js';
-import { provisionExports } from './core/skill-sync/export.js';
+import { provisionExports } from './core/host-exports/export.js';
+// V8 compile-cache (Node 22+): persist compiled bytecode across runs so a cold
+// `crtr` re-spawn skips recompiling its module graph. Biggest payoff is the
+// heavy attach-viewer bundle that main() dynamic-imports via resolveRoot — this
+// runs first, so the cache is active before that import() compiles. Measured
+// neutral on the tiny leaf path (feed/node), a clear win on attach. Best-effort:
+// older Node lacks the API.
+try {
+    enableCompileCache();
+}
+catch { /* pre-22 Node: no compile cache */ }
 async function main() {
     // Lazy command tree: load only the subtree this invocation dispatches into.
     // resolveRoot returns the full tree only for help/version/bare/unknown, where
@@ -12,14 +23,16 @@ async function main() {
     // hot leaf-dispatch path loads one subtree, keeping the other 11 (and their
     // heavy deps — the attach TUI, web/vite) off cold-start.
     const root = await resolveRoot(process.argv[2]);
+    // Prune legacy generated host artifacts before the front door can boot pi,
+    // otherwise stale Agent Skills can leak into the prompt for bare `crtr`.
+    provisionExports(root, process.argv);
     // The front door: bare `crtr` (or `crtr [dir] ["prompt"]`) boots a resident
     // root node and execs pi in this terminal. Recognized subcommands fall through
     // to the normal dispatcher. Must run before anything that assumes a subcommand.
-    if (maybeBootRoot(root, process.argv)) {
+    if (await maybeBootRoot(root, process.argv)) {
         // bootRoot exec'd pi inline and exited; unreachable.
     }
     ensureOfficialMarketplace(process.argv);
-    provisionExports(root);
     ensureProjectScope(process.argv);
     maybeAutoUpdate(process.argv);
     await runCli(root, process.argv);

package/dist/clients/attach/__tests__/autocomplete-and-bash-mode.test.js

@@ -0,0 +1,96 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
+import { buildAttachAutocompleteProvider, deriveBashMode, resolveEditorFrameStyles } from '../attach-cmd.js';
+function writeFakeFd(binDir) {
+    const fdBin = join(binDir, 'fd');
+    writeFileSync(fdBin, `#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+if (process.argv.includes('--version')) {
+  process.stdout.write('fd 0.0.0\\n');
+  process.exit(0);
+}
+const args = process.argv.slice(2);
+const baseDirIndex = args.indexOf('--base-directory');
+const baseDir = baseDirIndex >= 0 ? args[baseDirIndex + 1] : process.cwd();
+const maxResultsIndex = args.indexOf('--max-results');
+const maxResults = maxResultsIndex >= 0 ? Number(args[maxResultsIndex + 1]) : Infinity;
+const fullPath = args.includes('--full-path');
+let query = '';
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i];
+  if (arg === '--base-directory' || arg === '--max-results' || arg === '--type' || arg === '--exclude') {
+    i += 1;
+    continue;
+  }
+  if (arg === '--follow' || arg === '--hidden' || arg === '--full-path') continue;
+  if (!arg.startsWith('--')) query = arg;
+}
+const results = [];
+function walk(dir, rel = '') {
+  const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.name === '.git') continue;
+    const nextRel = rel ? rel + '/' + entry.name : entry.name;
+    const full = path.join(dir, entry.name);
+    if (!query || nextRel.includes(query) || entry.name.includes(query)) {
+      results.push((fullPath ? nextRel : nextRel) + (entry.isDirectory() ? '/' : ''));
+      if (results.length >= maxResults) return true;
+    }
+    if (entry.isDirectory() && walk(full, nextRel)) return true;
+  }
+  return false;
+}
+walk(baseDir);
+process.stdout.write(results.join('\\n'));
+`, 'utf8');
+    chmodSync(fdBin, 0o755);
+    return fdBin;
+}
+test('#6 attach threads the resolved fd path into @-mention file completion', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'crtr-at-'));
+    const binDir = mkdtempSync(join(tmpdir(), 'crtr-fd-'));
+    mkdirSync(join(base, 'nested'));
+    writeFileSync(join(base, 'alpha.txt'), 'a');
+    writeFileSync(join(base, 'nested', 'beta.md'), 'b');
+    const fdPath = writeFakeFd(binDir);
+    let seen;
+    const provider = buildAttachAutocompleteProvider(base, fdPath, [], (items, cwd, passedFdPath) => {
+        seen = { cwd, fdPath: passedFdPath, items };
+        return new CombinedAutocompleteProvider(items, cwd, passedFdPath);
+    });
+    assert.equal(seen?.cwd, base);
+    assert.equal(seen?.fdPath, fdPath);
+    assert.ok((seen?.items.length ?? 0) > 0);
+    const result = await provider.getSuggestions(['@'], 0, 1, {
+        force: false,
+        signal: new AbortController().signal,
+    });
+    assert.ok(result, 'expected @ suggestions from the file picker');
+    assert.equal(result?.prefix, '@');
+    assert.ok(result?.items.some((item) => item.label === 'alpha.txt' || item.label === 'nested/'));
+});
+test('attach-cmd derives bash mode from the leading cue and switches frame colors', () => {
+    assert.equal(deriveBashMode('plain text'), 0);
+    assert.equal(deriveBashMode('  ! echo hi'), 1);
+    assert.equal(deriveBashMode('\t!! echo hi'), 2);
+    const pal = {
+        bashMode: (s) => `green:${s}`,
+        bashModeAlt: (s) => `bright:${s}`,
+        border: (s) => `border:${s}`,
+    };
+    const off = resolveEditorFrameStyles(0, undefined, pal);
+    assert.equal(off.titleStyle('x'), '\x1b[7m x \x1b[27m');
+    assert.notEqual(off.borderColor, pal.bashMode);
+    assert.notEqual(off.borderColor, pal.bashModeAlt);
+    const single = resolveEditorFrameStyles(1, undefined, pal);
+    assert.equal(single.borderColor, pal.bashMode);
+    assert.equal(single.titleStyle('x'), '\x1b[42m\x1b[97m\x1b[1m x \x1b[0m');
+    const double = resolveEditorFrameStyles(2, undefined, pal);
+    assert.equal(double.borderColor, pal.bashModeAlt);
+    assert.equal(double.titleStyle('x'), '\x1b[102m\x1b[30m\x1b[1m x \x1b[0m');
+});

package/dist/clients/attach/__tests__/bash-bang-routing.test.js

@@ -0,0 +1,58 @@
+// Regression: typing `!cmd` in the attach viewer was sent to the engine as a
+// normal PROMPT (the LLM saw the literal `!cmd` and took a turn) instead of
+// running bash and injecting the output into context with no agent turn — pi's
+// native `!`/`!!` semantics. The fix routes a leading `!` in InputController to a
+// `bash` drive frame (and `!!` to one with excludeFromContext). These tests lock
+// the routing decision (the user-visible crux) so it can't silently revert.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { TUI, ProcessTerminal } from '@earendil-works/pi-tui';
+import { TitledEditor } from '../titled-editor.js';
+import { InputController } from '../input-controller.js';
+import { createKeybindingsManager } from '../config-load.js';
+const ENTER = '\r';
+function build() {
+    const agentDir = mkdtempSync(join(tmpdir(), 'crtr-bang-'));
+    const km = createKeybindingsManager(agentDir);
+    const tui = new TUI(new ProcessTerminal());
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const editor = new TitledEditor(tui, { borderColor: (s) => s, selectList: {} }, km, {
+        paddingX: 1,
+    });
+    const frames = [];
+    const hooks = {
+        onCommand: (f) => frames.push(f),
+        onDialogResponse: () => { },
+    };
+    // eslint-disable-next-line no-new -- wiring the editor.onSubmit handler is the point
+    new InputController(tui, editor, km, hooks);
+    return { editor, frames };
+}
+test('`!cmd` routes to a bash frame, not a prompt', () => {
+    const { editor, frames } = build();
+    editor.setText('!ls -la');
+    editor.handleInput(ENTER);
+    assert.deepEqual(frames, [{ type: 'bash', command: 'ls -la', excludeFromContext: false }]);
+    assert.equal(editor.getText(), '', 'editor clears after a bash submit');
+});
+test('`!!cmd` routes to a bash frame with excludeFromContext', () => {
+    const { editor, frames } = build();
+    editor.setText('!!echo secret');
+    editor.handleInput(ENTER);
+    assert.deepEqual(frames, [{ type: 'bash', command: 'echo secret', excludeFromContext: true }]);
+});
+test('a bare `!` with no command is ignored (no frame, text kept)', () => {
+    const { editor, frames } = build();
+    editor.setText('!   ');
+    editor.handleInput(ENTER);
+    assert.equal(frames.length, 0, 'a bare `!` must not emit a bash frame');
+});
+test('ordinary text still routes to a prompt frame (no regression)', () => {
+    const { editor, frames } = build();
+    editor.setText('hello world');
+    editor.handleInput(ENTER);
+    assert.deepEqual(frames, [{ type: 'prompt', text: 'hello world' }]);
+});

package/dist/clients/attach/__tests__/bundle-pi-tui-dedup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/bundle-pi-tui-dedup.test.js

@@ -0,0 +1,56 @@
+// Regression: after the attach viewer was re-bundled (commit d72c0de), Alt+Enter
+// silently stopped inserting a newline. Root cause was NOT in the editor logic —
+// editor-newline.test.ts still passed because it runs UNBUNDLED (tsx), where
+// config-load and pi-coding-agent's CustomEditor each load their own pi-tui from
+// disk and `mirrorKeybindingsToEditor` reaches the editor's disk copy.
+//
+// In the BUNDLE, esbuild inlined TWO distinct pi-tui module instances — the
+// top-level `node_modules/@earendil-works/pi-tui` (imported by config-load) and
+// pi-coding-agent's nested `.../pi-coding-agent/node_modules/@earendil-works/pi-tui`
+// (imported by CustomEditor). `setKeybindings` ran against the first global; the
+// editor read `getKeybindings` from the second. The Alt+Enter newLine binding was
+// invisible to the editor and the key fell through — swallowed. The runtime disk
+// mirror can't help: it targets a third (on-disk) instance, not either bundled one.
+//
+// Fix: the build:attach script aliases @earendil-works/pi-tui to one absolute
+// path so esbuild collapses both imports to a SINGLE bundled instance, and
+// setKeybindings reaches the editor directly. This test bundles attach-cmd.ts
+// the way the build script does and asserts exactly one pi-tui copy is inlined.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { build } from 'esbuild';
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(here, '..', '..', '..', '..'); // src/clients/attach/__tests__ → package root
+const entry = join(repoRoot, 'src/clients/attach/attach-cmd.ts');
+const piTui = join(repoRoot, 'node_modules/@earendil-works/pi-tui');
+/** Count distinct pi-tui package directories esbuild inlines into the bundle.
+ *  Unminified output keeps each module's source path as a `// <path>` comment. */
+function piTuiCopies(code) {
+    const copies = new Set();
+    for (const m of code.matchAll(/node_modules\/(?:\.pnpm\/)?@earendil-works\/(?:pi-coding-agent\/node_modules\/@earendil-works\/)?pi-tui/g)) {
+        copies.add(m[0]);
+    }
+    return copies;
+}
+test('build:attach aliases pi-tui to one path (sanity: package.json carries the alias)', () => {
+    const pkg = JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8'));
+    assert.match(pkg.scripts['build:attach'], /--alias:@earendil-works\/pi-tui=/, 'build:attach must alias pi-tui so the bundle inlines a single instance');
+});
+test('attach bundle inlines exactly ONE pi-tui instance (editor + config-load share the keybindings global)', async () => {
+    const result = await build({
+        entryPoints: [entry],
+        bundle: true,
+        write: false,
+        format: 'esm',
+        platform: 'node',
+        target: 'node22',
+        alias: { '@earendil-works/pi-tui': piTui },
+        logLevel: 'silent',
+    });
+    const code = result.outputFiles[0].text;
+    const copies = piTuiCopies(code);
+    assert.equal(copies.size, 1, `bundle must inline exactly one pi-tui (two = the Alt+Enter regression). Found: ${[...copies].join(', ')}`);
+});

package/dist/clients/attach/__tests__/titled-editor.test.js

@@ -10,7 +10,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { visibleWidth } from '@earendil-works/pi-tui';
-import { composeTopBorder } from '../titled-editor.js';
+import { composeTopBorder, thinkingBorderColor, thinkingTitleStyle } from '../titled-editor.js';
 const titleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
 const borderColor = (s) => `\x1b[38;2;128;128;128m${s}\x1b[39m`;
 const compose = (width, title, info) => composeTopBorder(width, title, info, titleStyle, borderColor);
@@ -37,3 +37,24 @@ test('info chip survives intact when there is room for it', () => {
     assert.ok(line.includes(info), 'fitting info must not be truncated or dropped');
     assert.equal(visibleWidth(line), 80);
 });
+test('thinking levels use an evenly spaced blue→orange scale', () => {
+    const cases = [
+        ['minimal', '38;2;68;120;228', '48;2;68;120;228'],
+        ['low', '38;2;108;128;188', '48;2;108;128;188'],
+        ['medium', '38;2;148;136;148', '48;2;148;136;148'],
+        ['high', '38;2;188;144;108', '48;2;188;144;108'],
+        ['xhigh', '38;2;228;152;68', '48;2;228;152;68'],
+    ];
+    const borderRgb = new Set();
+    const titleRgb = new Set();
+    for (const [level, border, title] of cases) {
+        const borderColor = thinkingBorderColor(level, (s) => s);
+        const titleStyle = thinkingTitleStyle(level, (s) => s);
+        assert.match(composeTopBorder(24, 'sess', '', (s) => s, borderColor), new RegExp(`\\x1b\\[${border}m`), `${level} border should use ${border}`);
+        assert.match(titleStyle('sess'), new RegExp(`\\x1b\\[${title}m`), `${level} title should use ${title}`);
+        borderRgb.add(border);
+        titleRgb.add(title);
+    }
+    assert.equal(borderRgb.size, cases.length, 'every thinking level needs its own border step');
+    assert.equal(titleRgb.size, cases.length, 'every thinking level needs its own title step');
+});

package/dist/clients/attach/attach-cmd.d.ts

@@ -1,2 +1,20 @@
+import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
 import type { BranchDef } from '../../core/command.js';
+import type { BrokerSnapshot } from '../../core/runtime/broker-protocol.js';
+import { type AttachPalette } from './config-load.js';
+/** Derive the shell-mode cue from the editor contents. Leading whitespace is
+ *  ignored so pasted commands and indented text still toggle correctly. */
+export declare function deriveBashMode(text: string): 0 | 1 | 2;
+/** Resolve the editor border + title-chip styles for the current shell cue. */
+export declare function resolveEditorFrameStyles(bashMode: 0 | 1 | 2, thinkingLevel: BrokerSnapshot['state']['thinkingLevel'] | undefined, pal: Pick<AttachPalette, 'bashMode' | 'bashModeAlt' | 'border'>): {
+    borderColor: (s: string) => string;
+    titleStyle: (s: string) => string;
+};
+export declare function buildAttachAutocompleteProvider(cwd: string, fdPath: string | null, commands?: ReadonlyArray<{
+    name: string;
+    description?: string;
+}>, createProvider?: (items: ReadonlyArray<{
+    name: string;
+    description?: string;
+}>, cwd: string, fdPath: string | null) => CombinedAutocompleteProvider): CombinedAutocompleteProvider;
 export declare function registerAttach(): BranchDef;