@agfpd/iapeer 0.3.0 → 0.4.1

package/src/index.ts

@@ -23,6 +23,8 @@ export * from './init/index.ts'
 export * from './install/index.ts'
 // Update — the cloud-only deploy path (`iapeer update`: npm latest → rebuild → restart).
 export * from './update/index.ts'
+// Uninstall — symmetric foundation removal (namespace-safe; refuses on a foreign fleet).
+export * from './uninstall/index.ts'
 // Onboard — the host-phase (idempotent marketplace registration in claude + codex).
 export * from './onboard/index.ts'
 // Memory slot — the declarative provider slot (контракт «Слот памяти»): status read + onboard step.

package/src/init/index.ts

@@ -21,6 +21,7 @@ import { IapError } from '../core/errors.ts'
 import {
   ensureLocalIapScaffold,
   pluginStateDir,
+  resolveGlobalRoot,
   writeFileAtomic,
   type StorageOptions,
 } from '../storage/index.ts'
@@ -245,6 +246,36 @@ export function ensureDoctrineTemplate(cwd: string): { path: string; created: bo
   return { path, created: true }
 }
 
+/**
+ * Create the GLOBAL host-doctrine template `~/.iapeer/IAPEER.md` if absent — the
+ * host-wide owner doctrine (Layer-2 GLOBAL in composeSystemPrompt, shared by EVERY
+ * peer; the general layer ABOVE each peer's own `.iapeer/IAPEER.md`). It is consumed at
+ * launch but was never scaffolded, so a fresh install left no host-doctrine file for the
+ * owner to find — asymmetric with the per-peer stub (ensureDoctrineTemplate). This
+ * mirrors that stub at host scope (discoverability + consistency). NEVER overwrites an
+ * existing host doctrine. Returns {path, created}.
+ */
+export function ensureGlobalDoctrineTemplate(env: NodeJS.ProcessEnv = process.env): { path: string; created: boolean } {
+  const root = resolveGlobalRoot(env)
+  const path = join(root, IAPEER_DOCTRINE_FILE)
+  if (existsSync(path)) return { path, created: false }
+  mkdirSync(root, { recursive: true })
+  writeFileSync(
+    path,
+    [
+      '# Host doctrine',
+      '',
+      '<!-- Host-wide rules shared by EVERY peer on this machine — the general layer,',
+      "     merged into every peer's system prompt at launch ABOVE that peer's own",
+      '     .iapeer/IAPEER.md. Replace this with your host-wide conventions. An empty',
+      '     file contributes nothing. -->',
+      '',
+    ].join('\n'),
+    { mode: 0o644 },
+  )
+  return { path, created: true }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // initPeer — orchestrate: provision (identity + registry + infra plist) + per-peer
 // ecosystem wiring (MCP transport per agentic runtime + doctrine template)

package/src/install/index.ts

@@ -13,10 +13,11 @@
 // signInstalledBinary (signing.ts) re-signs each install with the
 // stable local identity so the designated requirement — and the grants — survive.
 
-import { copyFileSync, existsSync, mkdirSync, renameSync, statSync } from 'fs'
+import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from 'fs'
 import { homedir } from 'os'
-import { join } from 'path'
+import { basename, join, relative, sep } from 'path'
 import { spawnSync } from 'child_process'
+import { resolveGlobalRoot } from '../storage/index.ts'
 import { signInstalledBinary, type SigningOutcome } from './signing.ts'
 
 /** The stable host-wide install path of the `iapeer` binary. Standard user-bin (no
@@ -95,6 +96,64 @@ export function installIapeer(cliEntrypoint: string, env: NodeJS.ProcessEnv = pr
   return { binPath, prevPath, size, signing }
 }
 
+/**
+ * Scaffold an ecosystem package's docs to the STABLE, versioned, per-package host
+ * path `~/.iapeer/docs/<pkg>/` so an agent can read the contract OFFLINE (a compiled
+ * binary embeds no docs; the npm tarball's docs/ is discarded after install — proven:
+ * `iapeer update` extracts to a temp dir it rm's in a `finally`, and the bunx cache
+ * does not retain the package findably). This is the FOUNDATION-OWNED CONVENTION every
+ * ecosystem package follows: each copies its OWN docs on its OWN install/update, so a
+ * package's on-host docs always match its installed version.
+ *
+ * Mechanics: copy <docsSource> → ~/.iapeer/docs/<pkg> EXCLUDING internals/ (mirroring
+ * the npm `files` exclusion), via an atomic temp-dir swap so a reader never sees a
+ * half-copied tree. BEST-EFFORT — a missing source or copy hiccup NEVER fails the
+ * install (the binary works without on-host docs); the caller logs the outcome.
+ */
+export function scaffoldHostDocs(
+  pkg: string,
+  docsSource: string,
+  env: NodeJS.ProcessEnv = process.env,
+): { copied: boolean; dest: string; reason?: string } {
+  const root = resolveGlobalRoot(env)
+  const dest = join(root, 'docs', pkg)
+  // Fail-closed sandbox guard (in spirit with assertInstallSandboxIsolated): never write
+  // the REAL machine ~/.iapeer under a sandboxed test that forgot to set IAPEER_ROOT.
+  // Compared against the ACTUAL OS home (homedir()), not env.HOME — the root IS the docs
+  // isolation, so an env.HOME-based check would false-trip when a test legitimately
+  // points IAPEER_ROOT at <tmp>/.iapeer (with env.HOME also <tmp>).
+  if (env.IAPEER_TEST_SANDBOX === '1' && root === join(homedir(), '.iapeer')) {
+    throw new Error(`refusing to scaffold docs into the REAL ${join(root, 'docs')} under IAPEER_TEST_SANDBOX=1 — set IAPEER_ROOT`)
+  }
+  if (!existsSync(docsSource)) return { copied: false, dest, reason: `docs source not found: ${docsSource}` }
+  const tmp = `${dest}.tmp-${process.pid}`
+  try {
+    rmSync(tmp, { recursive: true, force: true })
+    mkdirSync(join(dest, '..'), { recursive: true })
+    cpSync(docsSource, tmp, {
+      recursive: true,
+      // Skip the internals/ subtree (matches package.json files: "!docs/internals";
+      // returning false for a directory skips its whole subtree) and macOS .DS_Store
+      // cruft (the foundation is macOS-targeted, so every dev/host tree carries it).
+      filter: src => {
+        if (basename(src) === '.DS_Store') return false
+        const rel = relative(docsSource, src)
+        return rel !== 'internals' && !rel.startsWith(`internals${sep}`)
+      },
+    })
+    rmSync(dest, { recursive: true, force: true })
+    renameSync(tmp, dest)
+    return { copied: true, dest }
+  } catch (e) {
+    try {
+      rmSync(tmp, { recursive: true, force: true })
+    } catch {
+      /* best-effort cleanup */
+    }
+    return { copied: false, dest, reason: e instanceof Error ? e.message : String(e) }
+  }
+}
+
 /** The previous-binary path kept by the last install for one-step rollback. */
 export function iapeerPrevBinPath(env: NodeJS.ProcessEnv = process.env): string {
   return `${iapeerBinPath(env)}.prev`

package/src/launch/composeSystemPrompt.ts

@@ -103,6 +103,14 @@ export function composeSystemPrompt(input: ComposePromptInput): string {
   // The YAML identity block is the only Layer-1 section (synthesized, no marker).
   const sections: string[] = [yaml]
 
+  // Host-context pointer to the on-host ecosystem docs (FU6). Each package's install
+  // scaffolds its own contract docs to the stable, versioned, per-package path
+  // ~/.iapeer/docs/<package>/, so an agent can read "how does iapeer do X" offline
+  // instead of guessing. Synthesized Layer-1 fact (no marker). Wording: owner-approved.
+  sections.push(
+    'iapeer reference docs are on this host at ~/.iapeer/docs/ — one folder per package (start at iapeer/README.md). Consult them for how iapeer works instead of guessing.',
+  )
+
   // Layer 2 — IAPEER.md doctrine, GLOBAL then LOCAL (general → specific), each its
   // OWN marked file-section. The bash existence-gate (present-but-empty global → a
   // bare "\n") is dropped deliberately: an empty doctrine file now contributes no

package/src/onboard/memory.ts

@@ -25,11 +25,26 @@ export interface MemoryOnboardOptions {
   skip?: boolean
   /** --memory <pkg>: override the provider package (default @agfpd/iapeer-memory). */
   package?: string
+  /** Host agentic runtime to thread to the provider init (`--runtime <rt>`) — the
+   *  onboard↔init contract: the provider provisions its role-peers (index/watcher/
+   *  timer) on THIS runtime instead of guessing. Omitted on a no-runtime host →
+   *  the provider degrades (base+BM25, role-peers skipped). */
+  runtime?: string
   dryRun?: boolean
   env?: NodeJS.ProcessEnv
+  /** Wall-clock backstop (ms) for the provider-init subprocess — a hung provider
+   *  (e.g. a stalled native build) must NEVER wedge onboard (memory is optional).
+   *  The interactive wizard passes a generous value; the linear path leaves it
+   *  unset (no timeout). */
+  timeoutMs?: number
   /** Injectable runner (tests). Default: availability probe + `npx -y <pkg> init …`
    *  with inherited stdio. */
-  runInit?: (pkg: string, args: string[], env: NodeJS.ProcessEnv) => { status: number | null; unavailable: boolean }
+  runInit?: (
+    pkg: string,
+    args: string[],
+    env: NodeJS.ProcessEnv,
+    timeoutMs?: number,
+  ) => { status: number | null; unavailable: boolean }
 }
 
 export interface MemoryOnboardResult {
@@ -49,17 +64,24 @@ function defaultRunInit(
   pkg: string,
   args: string[],
   env: NodeJS.ProcessEnv,
+  timeoutMs?: number,
 ): { status: number | null; unavailable: boolean } {
   // Availability probe FIRST (cheap, side-effect-free): an unpublished package /
   // no network → soft-skip per the contract (the provider's release order must
-  // never block the core's onboard).
-  const probe = spawnSync('npm', ['view', `${pkg}@latest`, 'version'], { encoding: 'utf8', env })
+  // never block the core's onboard). Bounded so the probe itself cannot hang.
+  const probe = spawnSync('npm', ['view', `${pkg}@latest`, 'version'], { encoding: 'utf8', env, timeout: 60_000 })
   if (probe.status !== 0) return { status: probe.status, unavailable: true }
   // INHERITED stdio — the provider owns its install questions (tty interactive
   // happens here, once). npx bin-name nuance (cf. the 0.2.9 update pitfall): with
   // the provider bin already on PATH npx runs the INSTALLED one — acceptable for
   // an idempotent init (unlike the self-update case where it was a structural bug).
-  const r = spawnSync('npx', ['-y', pkg, ...args], { stdio: 'inherit', env })
+  // timeout: a generous wall-clock backstop so a hung provider can't wedge onboard
+  // (the caller also makes Ctrl-C skip just this step).
+  const r = spawnSync('npx', ['-y', pkg, ...args], {
+    stdio: 'inherit',
+    env,
+    ...(timeoutMs ? { timeout: timeoutMs } : {}),
+  })
   return { status: r.status, unavailable: false }
 }
 
@@ -91,12 +113,12 @@ export async function onboardMemoryProvider(opts: MemoryOnboardOptions = {}): Pr
       detail: `slot is occupied by "${existing.provider}" (${existing.package}) — uninstall it first`,
     }
   }
-  const args = ['init', ...coreKnownInitArgs(env)]
+  const args = ['init', ...coreKnownInitArgs(env), ...(opts.runtime ? ['--runtime', opts.runtime] : [])]
   if (opts.dryRun) {
     return { state: 'dry-run', provider: null, detail: `would run: npx -y ${pkg} ${args.join(' ')}` }
   }
   const run = opts.runInit ?? defaultRunInit
-  const r = run(pkg, args, env)
+  const r = run(pkg, args, env, opts.timeoutMs)
   if (r.unavailable) {
     return {
       state: 'skipped-unavailable',

package/src/tui/ansi.ts

@@ -0,0 +1,71 @@
+// ANSI palette for plain-text CLI output that runs OUTSIDE Ink — chiefly the
+// post-Ink onboard summary (run.tsx), which prints after the wizard unmounts and
+// would otherwise read as a flat, colorless tail to a styled flow.
+//
+// It mirrors the Ink wizard's palette one-for-one (see app.tsx color()/glyph()):
+//   ok → green ✓ · warn → yellow ! · fail → red ✗ · pending → gray · ·
+//   headers → bold (cyan for emphasis) · secondary detail/paths → dim
+// so the seam between the React-rendered part and the printed part is invisible.
+//
+// Color is GATED (colorEnabled): on by default only on a real TTY, force-on with
+// FORCE_COLOR (covers inherited-pipe passthrough by a child process), and hard-off
+// with NO_COLOR (https://no-color.org — presence disables, any value) so piped /
+// redirected / CI captures stay byte-clean. This is the team-wide convention we
+// hand to peer providers (e.g. iapeer-memory) whose stdout we surface verbatim.
+
+const ESC = '\x1b['
+const RESET = `${ESC}0m`
+
+const CODE = {
+  bold: '1',
+  dim: '2',
+  red: '31',
+  green: '32',
+  yellow: '33',
+  cyan: '36',
+  gray: '90',
+} as const
+
+export type AnsiPaint = (s: string) => string
+
+export interface Ansi {
+  bold: AnsiPaint
+  dim: AnsiPaint
+  red: AnsiPaint
+  green: AnsiPaint
+  yellow: AnsiPaint
+  cyan: AnsiPaint
+  gray: AnsiPaint
+}
+
+/** Whether to emit ANSI color for `stream`. NO_COLOR (any value) hard-disables;
+ *  FORCE_COLOR (truthy, not "0"/"false") forces on; otherwise gated on a real TTY. */
+export function colorEnabled(
+  env: NodeJS.ProcessEnv = process.env,
+  stream: { isTTY?: boolean } = process.stdout,
+): boolean {
+  if (env.NO_COLOR != null) return false
+  const fc = env.FORCE_COLOR
+  if (fc != null && fc !== '0' && fc !== 'false' && fc !== '') return true
+  return stream.isTTY === true
+}
+
+/** Build a palette. When `enabled` is false every paint fn is identity (no codes),
+ *  so the same call sites produce clean text for pipes/CI. Codes compose: an inner
+ *  paint applies before the outer, both before the run resets — `a.bold(a.cyan(s))`
+ *  renders bold+cyan. */
+export function makeAnsi(enabled: boolean): Ansi {
+  const wrap =
+    (code: string): AnsiPaint =>
+    (s: string) =>
+      enabled ? `${ESC}${code}m${s}${RESET}` : s
+  return {
+    bold: wrap(CODE.bold),
+    dim: wrap(CODE.dim),
+    red: wrap(CODE.red),
+    green: wrap(CODE.green),
+    yellow: wrap(CODE.yellow),
+    cyan: wrap(CODE.cyan),
+    gray: wrap(CODE.gray),
+  }
+}

package/src/tui/onboard/app.tsx

@@ -20,15 +20,24 @@ export interface WizardResult {
   memoryConsent: boolean
   advisories: string[]
   summary: string[]
+  telegramConsent: boolean
+  /** Host agentic runtime detected during the run (claude if installed, else
+   *  codex, else undefined on a no-runtime host) — threaded to the memory
+   *  provider init as `--runtime` per the onboard↔init contract. */
+  hostRuntime?: OnboardRuntime
 }
 
-type Phase = 'gate' | 'running' | 'memory' | 'declined' | 'finishing'
+type Phase = 'gate' | 'running' | 'telegram' | 'memory' | 'declined' | 'finishing'
 type StepStatus = 'pending' | 'running' | 'ok' | 'warn' | 'fail'
 interface Step {
   key: string
   label: string
   status: StepStatus
   detail?: string
+  /** Honest "this can take a moment" note shown while the step is running (the
+   *  spinner can't animate during a blocking spawnSync, so the label carries the
+   *  expectation). */
+  hint?: string
 }
 
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
@@ -85,6 +94,8 @@ export function OnboardApp({
   const [phase, setPhase] = useState<Phase>('gate')
   const [steps, setSteps] = useState<Step[]>([])
   const [advisories, setAdvisories] = useState<string[]>([])
+  const [hostRuntime, setHostRuntime] = useState<OnboardRuntime | undefined>(undefined)
+  const [telegramConsent, setTelegramConsent] = useState(false)
   const spin = useSpinnerFrame(phase === 'running')
 
   const finish = (memoryConsent: boolean): void => {
@@ -94,7 +105,7 @@ export function OnboardApp({
       return `  ${mark} ${s.label}${s.detail ? ` — ${s.detail}` : ''}`
     })
     summary.unshift(failed ? 'Onboard finished with errors:' : 'Onboard complete:')
-    onResult({ code: failed ? 1 : 0, memoryConsent, advisories, summary })
+    onResult({ code: failed ? 1 : 0, memoryConsent, telegramConsent, advisories, summary, hostRuntime })
     setPhase('finishing')
     setTimeout(() => exit(), 30)
   }
@@ -108,6 +119,22 @@ export function OnboardApp({
     { isActive: phase === 'gate' },
   )
 
+  // Telegram consent — DEFAULT-YES ([Y/n]). Records the decision; the actual setup
+  // (install + ask name/user_id) runs post-Ink (its readline needs a cooked
+  // terminal). Then → memory consent.
+  useInput(
+    (input, key) => {
+      if (input === 'n' || input === 'N') {
+        setTelegramConsent(false)
+        setPhase('memory')
+      } else if (input === 'y' || input === 'Y' || key.return) {
+        setTelegramConsent(true)
+        setPhase('memory')
+      }
+    },
+    { isActive: phase === 'telegram' },
+  )
+
   // Memory consent — DEFAULT-YES ([Y/n]: Enter or y → install).
   useInput(
     (input, key) => {
@@ -120,7 +147,7 @@ export function OnboardApp({
   // Declined → exit 1 (no host mutation).
   useEffect(() => {
     if (phase !== 'declined') return
-    onResult({ code: 1, memoryConsent: false, advisories: [], summary: ['onboard aborted — risk not accepted.'] })
+    onResult({ code: 1, memoryConsent: false, telegramConsent: false, advisories: [], summary: ['onboard aborted — risk not accepted.'] })
     const t = setTimeout(() => exit(), 30)
     return () => clearTimeout(t)
   }, [phase, onResult, exit])
@@ -132,10 +159,16 @@ export function OnboardApp({
     const set = (k: string, patch: Partial<Step>) =>
       setSteps(prev => prev.map(s => (s.key === k ? { ...s, ...patch } : s)))
     setSteps([
-      { key: 'daemon', label: 'Start router daemon', status: 'pending' },
+      { key: 'daemon', label: 'Start router daemon', status: 'pending', hint: 'a few seconds' },
       { key: 'market', label: 'Register marketplace (claude, codex)', status: 'pending' },
       { key: 'auth', label: 'Check runtime sign-in', status: 'pending' },
       { key: 'fda', label: 'Check macOS Full Disk Access', status: 'pending' },
+      {
+        key: 'notifier',
+        label: 'Install scheduler (timer · watcher)',
+        status: 'pending',
+        hint: 'first run can take up to a minute',
+      },
     ])
 
     // Backend steps use synchronous spawnSync (launchctl, runtime plugin list) —
@@ -164,10 +197,19 @@ export function OnboardApp({
       const r = onboardHost({ env })
       const installed: OnboardRuntime[] = []
       for (const m of r.marketplaces) if (m.state !== 'runtime-missing') installed.push(m.runtime)
+      // host-runtime for the memory init contract: claude if present (covers
+      // both-installed → claude default), else codex, else undefined (no runtime).
+      setHostRuntime(installed.includes('claude') ? 'claude' : installed[0])
       const mFail = r.marketplaces.some(m => m.state === 'failed')
+      const allMissing = r.marketplaces.length > 0 && r.marketplaces.every(m => m.state === 'runtime-missing')
       set('market', {
-        status: mFail ? 'fail' : 'ok',
-        detail: r.marketplaces.map(m => `${m.runtime}:${m.state}`).join(' '),
+        // runtime-missing is NOT success — show '!' (warn), never a contradictory ✓.
+        status: mFail ? 'fail' : allMissing ? 'warn' : 'ok',
+        detail: allMissing
+          ? 'no agent runtime installed — skipped'
+          : r.marketplaces
+              .map(m => `${m.runtime}: ${m.state === 'runtime-missing' ? 'not installed' : m.state}`)
+              .join(', '),
       })
       if (cancelled) return
       await tick()
@@ -177,8 +219,11 @@ export function OnboardApp({
       if (installed.length === 0) {
         set('auth', { status: 'warn', detail: 'no runtime installed' })
         adv.push(
-          '⚠ SETUP INCOMPLETE — no agent runtime found. iapeer needs Claude Code or Codex CLI\n' +
-            '  to run peers. Install one, sign in, then re-run `iapeer onboard`.',
+          '⚠ SETUP INCOMPLETE — no agent runtime found. iapeer needs an agent runtime: Claude Code OR Codex (either works).\n' +
+            '  Install EITHER (commands verified against the official docs), sign in, then re-run `iapeer onboard`:\n' +
+            '    Claude Code:  curl -fsSL https://claude.ai/install.sh | bash   (or: brew install --cask claude-code)\n' +
+            '    Codex:        npm install -g @openai/codex                     (or: brew install --cask codex)\n' +
+            '  If a download is blocked in your region, try the brew form or the other runtime.',
         )
       } else {
         const notes = installed.map(rt => runtimeAuthNote(rt, env)).filter((n): n is string => n != null)
@@ -188,6 +233,7 @@ export function OnboardApp({
         })
         adv.push(...notes)
       }
+      setAdvisories([...adv]) // surface SETUP-INCOMPLETE / auth advisories IN the wizard now
       if (cancelled) return
 
       set('fda', { status: 'running' })
@@ -197,9 +243,32 @@ export function OnboardApp({
       set('fda', { status: tcc ? 'warn' : 'ok', detail: fda === true ? 'granted' : tcc ? 'not granted' : 'n/a' })
       if (tcc) adv.push(tcc)
       if (cancelled) return
+      await tick()
+
+      // notifier — the scheduler (timer · watcher) that memory's index upkeep
+      // rides on; a silent default. Its npx install captures stdio (no terminal
+      // contention), so it runs in-wizard like the other steps. Idempotent: a
+      // present package/peers → no-op. A failure must NOT fail onboard (degrade).
+      set('notifier', { status: 'running' })
+      await tick()
+      try {
+        // canonical backbone step (same as the linear onboard path): zero-question,
+        // captured-stdio, idempotent, soft-skip on unavailable.
+        const { onboardNotifierStep } = await import('../../onboard/steps.ts')
+        const ns = await onboardNotifierStep({ env, warn: () => {} })
+        set('notifier', {
+          status: ns.state === 'deployed' ? 'ok' : 'warn',
+          detail: ns.state === 'deployed' ? `${ns.peers.length} peer(s)` : (ns.detail ?? ns.state),
+        })
+        if (ns.state !== 'deployed') adv.push(`Scheduler (notifier): ${ns.detail ?? ns.state}`)
+      } catch (e) {
+        set('notifier', { status: 'warn', detail: (e instanceof Error ? e.message : 'failed').slice(0, 60) })
+      }
+      if (cancelled) return
+      await tick()
 
-      setAdvisories(adv)
-      setPhase('memory')
+      setAdvisories([...adv])
+      setPhase('telegram')
     })()
 
     return () => {
@@ -236,23 +305,51 @@ export function OnboardApp({
     return <Text color="red">onboard aborted — risk not accepted.</Text>
   }
 
-  // running | memory | finishing
+  // running | telegram | memory | finishing
   return (
     <Box flexDirection="column">
-      <Text bold>Setting up the host…</Text>
-      <Box flexDirection="column" marginTop={1}>
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          iapeer
+        </Text>
+        <Text bold> · setting up the host</Text>
+      </Box>
+      <Box flexDirection="column">
         {steps.map(s => (
           <Box key={s.key}>
             <Text color={color(s.status)}>{glyph(s.status, spin)} </Text>
             <Text>{s.label}</Text>
-            {s.detail ? <Text dimColor> — {s.detail}</Text> : null}
+            {s.detail ? (
+              <Text dimColor> — {s.detail}</Text>
+            ) : s.status === 'running' && s.hint ? (
+              <Text dimColor> — {s.hint}…</Text>
+            ) : null}
           </Box>
         ))}
       </Box>
+      {advisories.length > 0 ? (
+        <Box marginTop={1} flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1}>
+          {advisories.map((a, i) => (
+            <Text key={i} color="yellow">
+              {a}
+            </Text>
+          ))}
+        </Box>
+      ) : null}
+      {phase === 'telegram' ? (
+        <Box marginTop={1} flexDirection="column">
+          <Text bold color="cyan">
+            ? Set up Telegram — talk to your agents from your phone?
+          </Text>
+          <Text dimColor> It will ask your name + Telegram user_id next. (bot token comes later) [Y/n]</Text>
+        </Box>
+      ) : null}
       {phase === 'memory' ? (
         <Box marginTop={1} flexDirection="column">
-          <Text>Install the shared-memory provider (@agfpd/iapeer-memory)?</Text>
-          <Text dimColor>It gives your agents a shared knowledge vault. [Y/n] </Text>
+          <Text bold color="cyan">
+            ? Install the shared-memory provider (@agfpd/iapeer-memory)?
+          </Text>
+          <Text dimColor> Gives your agents a shared knowledge vault. [Y/n]</Text>
         </Box>
       ) : null}
     </Box>