priiisk 0.1.1

package/dist/chunk-Z64QXV3O.js

@@ -0,0 +1,2547 @@
+import { createRequire as __priiiskCreateRequire } from "node:module";
+const require = __priiiskCreateRequire(import.meta.url);
+import {
+  CampAskState,
+  Cause_exports,
+  Clock_exports,
+  Context_exports,
+  Data_exports,
+  Deferred_exports,
+  Effect_exports,
+  FiberSet_exports,
+  Match_exports,
+  Stream_exports,
+  SubscriptionRef_exports
+} from "./chunk-KFSFN6L5.js";
+
+// packages/host-ui/src/backend/campUiBackend.ts
+var CampUiBackendError = class extends Data_exports.TaggedError("CampUiBackendError") {
+};
+var CampUiBackend = class extends Context_exports.Tag("priiisk/CampUiBackend")() {
+};
+
+// packages/host-ui/src/model/campUiModel.ts
+var CampUiPlacement = {
+  external: "external",
+  embedded: "embedded"
+};
+var CampUiHealthStatus = {
+  ready: "ready",
+  degraded: "degraded",
+  failed: "failed"
+};
+var CampUiScreen = {
+  camp: "camp",
+  worker: "worker"
+};
+var campUiAskBlockId = (askId) => `ask:${askId}`;
+var makeInitialCampUiState = (snapshot, presentationNow = 0) => ({
+  ...snapshot.workers[0] === void 0 ? {} : { selectedWorkerId: snapshot.workers[0].snapshot.worker.id },
+  screen: CampUiScreen.camp,
+  focusedSlotId: "roster",
+  detailVisible: false,
+  presentationNow,
+  drafts: /* @__PURE__ */ new Map(),
+  scrollOffsets: /* @__PURE__ */ new Map(),
+  expandedDetailBlockIds: /* @__PURE__ */ new Set()
+});
+var makeCampUiModel = (snapshot, presentationNow = 0) => ({
+  snapshot,
+  state: makeInitialCampUiState(snapshot, presentationNow)
+});
+var findCampUiWorker = (snapshot, workerId) => snapshot.workers.find((candidate) => candidate.snapshot.worker.id === workerId);
+
+// packages/host-ui/src/backend/campUiReconcile.ts
+var retainWorkerEntries = (entries, workerIds) => new Map([...entries].filter(([workerId]) => workerIds.has(workerId)));
+var reconcileCampUiState = (current, snapshot) => {
+  if (current.snapshot.generation !== snapshot.generation) {
+    return makeInitialCampUiState(snapshot, current.state.presentationNow);
+  }
+  const workerIds = new Set(snapshot.workers.map((worker) => worker.snapshot.worker.id));
+  const previousId = current.state.selectedWorkerId;
+  const previousIndex = current.snapshot.workers.findIndex(
+    (worker) => worker.snapshot.worker.id === previousId
+  );
+  const fallbackIndex = Math.min(Math.max(previousIndex, 0), snapshot.workers.length - 1);
+  const selectedWorkerId = previousId !== void 0 && workerIds.has(previousId) ? previousId : snapshot.workers[fallbackIndex]?.snapshot.worker.id;
+  const {
+    selectedWorkerId: _selectedWorkerId,
+    focusedDetailBlockId: previousFocusedBlockId,
+    ...stableState
+  } = current.state;
+  const askBlockIds = new Set(
+    snapshot.workers.flatMap((worker) => worker.asks.map((ask) => campUiAskBlockId(ask.askId)))
+  );
+  const expandedDetailBlockIds = new Set(
+    [...current.state.expandedDetailBlockIds].filter(
+      (blockId) => !blockId.startsWith("ask:") || askBlockIds.has(blockId)
+    )
+  );
+  const focusedDetailBlockId = previousFocusedBlockId !== void 0 && (!previousFocusedBlockId.startsWith("ask:") || askBlockIds.has(previousFocusedBlockId)) ? previousFocusedBlockId : void 0;
+  return {
+    ...stableState,
+    ...selectedWorkerId === void 0 ? {} : { selectedWorkerId },
+    ...focusedDetailBlockId === void 0 ? {} : { focusedDetailBlockId },
+    screen: selectedWorkerId === void 0 ? CampUiScreen.camp : current.state.screen,
+    focusedSlotId: selectedWorkerId === void 0 ? "roster" : current.state.focusedSlotId,
+    drafts: retainWorkerEntries(current.state.drafts, workerIds),
+    scrollOffsets: retainWorkerEntries(current.state.scrollOffsets, workerIds),
+    expandedDetailBlockIds
+  };
+};
+
+// packages/host-ui/src/backend/campUiStoreState.ts
+var updateCampUiWorkerMap = (current, workerId, value) => new Map(current).set(workerId, value);
+var updateCampUiStringSet = (current, value, included) => {
+  const next = new Set(current);
+  if (included) next.add(value);
+  else next.delete(value);
+  return next;
+};
+
+// packages/host-ui/src/backend/campUiStore.ts
+var CampUiControllerError = class extends Data_exports.TaggedError("CampUiControllerError") {
+};
+var makeCampUiStore = (initial, presentationNow = 0) => Effect_exports.gen(function* () {
+  const modelRef = yield* SubscriptionRef_exports.make(makeCampUiModel(initial, presentationNow));
+  const updateState = (mutate) => SubscriptionRef_exports.update(modelRef, (model) => ({ ...model, state: mutate(model.state) }));
+  const controller = {
+    selectWorker: (workerId) => SubscriptionRef_exports.modifyEffect(
+      modelRef,
+      (model) => findCampUiWorker(model.snapshot, workerId) === void 0 ? Effect_exports.fail(
+        new CampUiControllerError({
+          operation: "campUi.selectWorker",
+          code: "worker_not_found",
+          workerId
+        })
+      ) : Effect_exports.succeed([
+        void 0,
+        {
+          ...model,
+          state: { ...model.state, selectedWorkerId: workerId }
+        }
+      ])
+    ),
+    openWorker: (workerId) => SubscriptionRef_exports.modifyEffect(
+      modelRef,
+      (model) => findCampUiWorker(model.snapshot, workerId) === void 0 ? Effect_exports.fail(
+        new CampUiControllerError({
+          operation: "campUi.openWorker",
+          code: "worker_not_found",
+          workerId
+        })
+      ) : Effect_exports.succeed([
+        void 0,
+        {
+          ...model,
+          state: {
+            ...model.state,
+            selectedWorkerId: workerId,
+            screen: CampUiScreen.worker
+          }
+        }
+      ])
+    ),
+    activateScreen: (screen) => SubscriptionRef_exports.modifyEffect(
+      modelRef,
+      (model) => screen === CampUiScreen.worker && model.state.selectedWorkerId === void 0 ? Effect_exports.fail(
+        new CampUiControllerError({
+          operation: "campUi.activateScreen",
+          code: "worker_not_selected"
+        })
+      ) : Effect_exports.succeed([void 0, { ...model, state: { ...model.state, screen } }])
+    ),
+    focusDetailBlock: (focusedDetailBlockId) => updateState((state) => {
+      if (focusedDetailBlockId !== void 0) return { ...state, focusedDetailBlockId };
+      const { focusedDetailBlockId: _focusedDetailBlockId, ...rest } = state;
+      return rest;
+    }),
+    focusSlot: (focusedSlotId) => updateState((state) => ({ ...state, focusedSlotId })),
+    setDraft: (workerId, draft) => updateState((state) => ({
+      ...state,
+      drafts: updateCampUiWorkerMap(state.drafts, workerId, draft)
+    })),
+    setDetailVisible: (detailVisible) => updateState((state) => {
+      if (state.detailVisible === detailVisible) return state;
+      return { ...state, detailVisible };
+    }),
+    setDetailBlockExpanded: (blockId, expanded) => updateState((state) => ({
+      ...state,
+      expandedDetailBlockIds: updateCampUiStringSet(
+        state.expandedDetailBlockIds,
+        blockId,
+        expanded
+      )
+    })),
+    setPresentationNow: (now) => updateState((state) => {
+      const presentationNow2 = Math.max(0, Math.floor(now));
+      return presentationNow2 === state.presentationNow ? state : { ...state, presentationNow: presentationNow2 };
+    }),
+    setScrollOffset: (workerId, offset) => updateState((state) => ({
+      ...state,
+      scrollOffsets: updateCampUiWorkerMap(state.scrollOffsets, workerId, Math.max(0, offset))
+    })),
+    setActionError: (message) => updateState((state) => {
+      if (message !== void 0) return { ...state, lastActionError: message };
+      const { lastActionError: _lastActionError, ...rest } = state;
+      return rest;
+    })
+  };
+  return {
+    current: SubscriptionRef_exports.get(modelRef),
+    changes: modelRef.changes,
+    updateSnapshot: (snapshot) => SubscriptionRef_exports.modify(modelRef, (current) => {
+      const stale = current.snapshot.generation === snapshot.generation && snapshot.revision <= current.snapshot.revision;
+      return stale ? [false, current] : [true, { snapshot, state: reconcileCampUiState(current, snapshot) }];
+    }),
+    controller
+  };
+});
+
+// packages/host-ui/src/composition/campUiComponent.ts
+var makeCampUiComponentGroup = (components) => {
+  const inputComponents = components.some((component) => component.handleInput !== void 0);
+  const pointerComponents = components.some((component) => component.handlePointer !== void 0);
+  const invalidatingComponents = components.some((component) => component.invalidate !== void 0);
+  return {
+    render: (viewport) => components.flatMap((component) => component.render(viewport)),
+    ...components.some((component) => component.focusable === true) ? { focusable: true } : {},
+    ...inputComponents ? {
+      handleInput: (input) => [...components].reverse().some((component) => component.handleInput?.(input) === true)
+    } : {},
+    ...pointerComponents ? {
+      handlePointer: (pointer) => {
+        for (const component of [...components].reverse()) {
+          const intents = component.handlePointer?.(pointer) ?? [];
+          if (intents.length > 0) return intents;
+        }
+        return [];
+      }
+    } : {},
+    ...invalidatingComponents ? {
+      invalidate: () => {
+        for (const component of components) component.invalidate?.();
+      }
+    } : {}
+  };
+};
+var emptyCampUiComponent = {
+  render: () => []
+};
+
+// packages/host-ui/src/composition/campUiSlots.ts
+var CampUiSlot = {
+  campHeader: "camp-header",
+  seat: "seat",
+  resources: "resources",
+  roster: "roster",
+  sessionHeader: "session-header",
+  transcript: "transcript",
+  composer: "composer",
+  campFooter: "camp-footer",
+  sessionFooter: "session-footer",
+  overlay: "overlay"
+};
+var CampUiContributionStrategy = {
+  append: "append",
+  replace: "replace",
+  decorate: "decorate"
+};
+var CampUiCompositionError = class extends Data_exports.TaggedError("CampUiCompositionError") {
+};
+var orderContributions = (contributions) => [...contributions].sort(
+  (left, right) => (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id)
+);
+var registerDispose = (component) => component.dispose === void 0 ? Effect_exports.succeed(component) : Effect_exports.addFinalizer(() => component.dispose).pipe(
+  Effect_exports.as(component)
+);
+var validateContributions = (defaults, contributions) => {
+  const ids = [...defaults, ...contributions].map((contribution) => contribution.id);
+  const duplicateId = ids.find((id, index) => ids.indexOf(id) !== index);
+  if (duplicateId !== void 0) {
+    return Effect_exports.fail(
+      new CampUiCompositionError({ code: "duplicate_id", details: { id: duplicateId } })
+    );
+  }
+  const replacementSlots = contributions.filter((contribution) => contribution.strategy === CampUiContributionStrategy.replace).map((contribution) => contribution.slotId);
+  const duplicateSlot = replacementSlots.find(
+    (slotId, index) => replacementSlots.indexOf(slotId) !== index
+  );
+  return duplicateSlot === void 0 ? Effect_exports.void : Effect_exports.fail(
+    new CampUiCompositionError({
+      code: "multiple_replacements",
+      details: { slotId: duplicateSlot }
+    })
+  );
+};
+var composeCampUiSlots = (context, defaults, contributions) => Effect_exports.gen(function* () {
+  yield* validateContributions(defaults, contributions);
+  const slotIds = [...new Set([...defaults, ...contributions].map((item) => item.slotId))];
+  const entries = yield* Effect_exports.forEach(
+    slotIds,
+    (slotId) => Effect_exports.gen(function* () {
+      const replacement = contributions.find(
+        (item) => item.slotId === slotId && item.strategy === CampUiContributionStrategy.replace
+      );
+      const base = replacement === void 0 ? defaults.filter((item) => item.slotId === slotId) : [];
+      const appended = contributions.filter(
+        (item) => item.slotId === slotId && item.strategy === CampUiContributionStrategy.append
+      );
+      const contentFactories = orderContributions([
+        ...base,
+        ...replacement === void 0 ? [] : [replacement],
+        ...appended
+      ]);
+      const components = yield* Effect_exports.forEach(
+        contentFactories,
+        (item) => item.mount(context).pipe(Effect_exports.flatMap(registerDispose))
+      );
+      let content = components.length === 0 ? emptyCampUiComponent : makeCampUiComponentGroup(components);
+      const decorators = orderContributions(
+        contributions.filter(
+          (item) => item.slotId === slotId && item.strategy === CampUiContributionStrategy.decorate
+        )
+      );
+      for (const decorator of decorators) {
+        content = yield* decorator.decorate(context, content).pipe(Effect_exports.flatMap(registerDispose));
+      }
+      return [slotId, content];
+    })
+  );
+  return new Map(entries);
+});
+
+// packages/host-ui/src/composition/campUiDetailBlocks.ts
+var byOrder = (left, right) => (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id);
+var composeCampUiDetailBlocks = (defaults, contributions) => {
+  const renderers = [...defaults, ...contributions];
+  const ids = renderers.map((renderer) => renderer.id);
+  const duplicateId = ids.find((id, index) => ids.indexOf(id) !== index);
+  return duplicateId === void 0 ? Effect_exports.succeed(renderers.sort(byOrder)) : Effect_exports.fail(
+    new CampUiCompositionError({
+      code: "duplicate_id",
+      details: { area: "detail-block", id: duplicateId }
+    })
+  );
+};
+var renderCampUiDetailBlocks = (registry, context) => renderCampUiDetailBlockLayout(registry, context).lines;
+var renderCampUiDetailBlockLayout = (registry, context) => {
+  const lines = [];
+  const ranges = [];
+  for (const renderer of registry) {
+    for (const block of renderer.render(context)) {
+      const start = lines.length;
+      lines.push(...block.lines, "");
+      ranges.push({
+        id: block.id,
+        start,
+        end: start + block.lines.length,
+        toggleable: block.toggleable === true
+      });
+    }
+  }
+  return { lines, ranges };
+};
+
+// packages/host-ui/src/model/campUiAttention.ts
+var campUiPendingAskTargets = (snapshot) => snapshot.workers.flatMap(
+  (worker, workerIndex) => worker.asks.filter((ask) => ask.state === CampAskState.pending).map((ask) => ({
+    askId: ask.askId,
+    blockId: campUiAskBlockId(ask.askId),
+    openedAt: ask.openedAt,
+    workerId: worker.snapshot.worker.id,
+    workerIndex
+  }))
+).sort(
+  (left, right) => left.openedAt - right.openedAt || left.workerIndex - right.workerIndex || left.askId.localeCompare(right.askId)
+);
+var nextCampUiPendingAskTarget = (snapshot, focusedBlockId) => {
+  const targets = campUiPendingAskTargets(snapshot);
+  if (targets.length === 0) return void 0;
+  const current = targets.findIndex((target) => target.blockId === focusedBlockId);
+  return targets[current < 0 ? 0 : (current + 1) % targets.length];
+};
+
+// packages/host-ui/src/interaction/campUiIntents.ts
+var CampUiIntents = Data_exports.taggedEnum();
+var makeCampUiIntentHandler = (options) => Match_exports.type().pipe(
+  Match_exports.tagsExhaustive({
+    ActivateScreen: ({ screen }) => options.controller.activateScreen(screen),
+    FocusDetailBlock: ({ blockId }) => options.controller.focusDetailBlock(blockId),
+    FocusSlot: ({ slotId }) => options.controller.focusSlot(slotId),
+    JumpToWorkerTail: ({ workerId }) => options.controller.focusDetailBlock(void 0).pipe(Effect_exports.zipRight(options.controller.setScrollOffset(workerId, 0))),
+    NextPendingAsk: () => Effect_exports.suspend(() => {
+      const model = options.readModel();
+      const target = nextCampUiPendingAskTarget(
+        model.snapshot,
+        model.state.focusedDetailBlockId
+      );
+      return target === void 0 ? Effect_exports.void : options.controller.openWorker(target.workerId).pipe(
+        Effect_exports.zipRight(options.controller.setDetailBlockExpanded(target.blockId, true)),
+        Effect_exports.zipRight(options.controller.focusDetailBlock(target.blockId)),
+        Effect_exports.zipRight(options.controller.focusSlot(CampUiSlot.transcript))
+      );
+    }),
+    OpenWorker: ({ workerId }) => options.controller.openWorker(workerId),
+    ScrollWorker: ({ workerId, delta }) => Effect_exports.suspend(() => {
+      const offset = options.readModel().state.scrollOffsets.get(workerId) ?? 0;
+      return options.controller.focusDetailBlock(void 0).pipe(
+        Effect_exports.zipRight(
+          options.controller.setScrollOffset(workerId, Math.max(0, offset + delta))
+        )
+      );
+    }),
+    SelectRelativeWorker: ({ delta }) => Effect_exports.suspend(() => {
+      const model = options.readModel();
+      const workers = model.snapshot.workers;
+      if (workers.length === 0) return Effect_exports.void;
+      const current = workers.findIndex(
+        (worker) => worker.snapshot.worker.id === model.state.selectedWorkerId
+      );
+      const index = current < 0 ? 0 : Math.min(workers.length - 1, Math.max(0, current + delta));
+      const workerId = workers[index]?.snapshot.worker.id;
+      return workerId === void 0 ? Effect_exports.void : options.controller.selectWorker(workerId);
+    }),
+    SelectWorker: ({ workerId }) => options.controller.selectWorker(workerId),
+    SetDraft: ({ workerId, draft }) => options.controller.setDraft(workerId, draft),
+    SetScrollOffset: ({ workerId, offset }) => options.controller.setScrollOffset(workerId, offset),
+    SetTranscriptVisible: ({ visible }) => options.controller.setDetailVisible(visible),
+    Steer: ({ workerId, message }) => message.trim() === "" ? Effect_exports.void : options.backend.steer({ workerId, message }).pipe(
+      Effect_exports.tap(() => options.controller.setActionError(void 0)),
+      Effect_exports.tap(() => options.controller.setDraft(workerId, "")),
+      Effect_exports.catchAll(
+        (cause) => options.controller.setDraft(workerId, message).pipe(Effect_exports.zipRight(options.controller.setActionError(cause.message)))
+      )
+    ),
+    ToggleDetailBlock: ({ blockId }) => Effect_exports.suspend(
+      () => options.controller.setDetailBlockExpanded(
+        blockId,
+        !options.readModel().state.expandedDetailBlockIds.has(blockId)
+      )
+    )
+  })
+);
+var makeCampUiIntentRouter = (options) => {
+  const handle = makeCampUiIntentHandler(options);
+  return { emit: (intent) => options.dispatch(handle(intent)) };
+};
+
+// packages/host-ui/src/interaction/campUiSpatialFocus.ts
+var CampUiFocusDirection = {
+  down: "down",
+  left: "left",
+  right: "right",
+  up: "up"
+};
+var centerX = (region2) => region2.x + region2.width / 2;
+var centerY = (region2) => region2.y + region2.height / 2;
+var distanceToInterval = (value, start, end) => value < start ? start - value : value > end ? value - end : 0;
+var scoreCandidate = (current, candidate, direction, order) => {
+  const horizontalDelta = centerX(candidate) - centerX(current);
+  const verticalDelta = centerY(candidate) - centerY(current);
+  const horizontal = direction === CampUiFocusDirection.left || direction === CampUiFocusDirection.right;
+  const directionDelta = horizontal ? horizontalDelta : verticalDelta;
+  const expectedSign = direction === CampUiFocusDirection.right || direction === CampUiFocusDirection.down ? 1 : -1;
+  if (directionDelta * expectedSign <= 0) return void 0;
+  const primaryDistance = horizontal ? direction === CampUiFocusDirection.right ? Math.max(0, candidate.x - (current.x + current.width)) : Math.max(0, current.x - (candidate.x + candidate.width)) : direction === CampUiFocusDirection.down ? Math.max(0, candidate.y - (current.y + current.height)) : Math.max(0, current.y - (candidate.y + candidate.height));
+  const perpendicularDistance = horizontal ? distanceToInterval(centerY(current), candidate.y, candidate.y + candidate.height) : distanceToInterval(centerX(current), candidate.x, candidate.x + candidate.width);
+  return {
+    slotId: candidate.slotId,
+    primaryDistance,
+    perpendicularDistance,
+    centerDistance: Math.abs(directionDelta),
+    order
+  };
+};
+var compareCandidates = (left, right) => left.primaryDistance - right.primaryDistance || left.perpendicularDistance - right.perpendicularDistance || left.centerDistance - right.centerDistance || left.order - right.order;
+var findCampUiSpatialFocusTarget = (frame, currentSlotId, focusableSlotIds, direction) => {
+  if (!focusableSlotIds.has(currentSlotId)) return void 0;
+  const current = frame?.regions.find((region2) => region2.slotId === currentSlotId);
+  if (current === void 0) return void 0;
+  return frame?.regions.map(
+    (candidate, order) => candidate.slotId === currentSlotId || !focusableSlotIds.has(candidate.slotId) ? void 0 : scoreCandidate(current, candidate, direction, order)
+  ).filter((candidate) => candidate !== void 0).sort(compareCandidates)[0]?.slotId;
+};
+
+// packages/host-ui/src/layout/campUiLayoutPolicy.ts
+var defaultCampUiLayoutPolicy = {
+  leftMinimumWidth: 28,
+  leftMaximumWidth: 40,
+  sessionMinimumWidth: 52,
+  wideMinimumHeight: 18,
+  leftRatio: 0.3,
+  footerHeight: 3,
+  sessionHeaderHeight: 1,
+  composerHeight: 3
+};
+
+// packages/host-ui/src/layout/campUiSizing.ts
+var CampUiSectionSizeKind = {
+  fixed: "fixed",
+  grow: "grow"
+};
+var rows = (value) => Math.max(0, Math.floor(value));
+var allocateCampUiSectionRows = (availableRows, sizes) => {
+  const allocated = sizes.map(() => 0);
+  let remaining = rows(availableRows);
+  const growIndexes = [];
+  for (const [index, size] of sizes.entries()) {
+    if (size.kind === CampUiSectionSizeKind.grow) {
+      growIndexes.push(index);
+      continue;
+    }
+    const height = Math.min(remaining, rows(size.rows));
+    allocated[index] = height;
+    remaining -= height;
+  }
+  const maximumMinimum = Math.max(
+    0,
+    ...growIndexes.map((index) => {
+      const size = sizes[index];
+      return size?.kind === CampUiSectionSizeKind.grow ? rows(size.minimumRows ?? 0) : 0;
+    })
+  );
+  for (let minimumRow = 0; minimumRow < maximumMinimum && remaining > 0; minimumRow += 1) {
+    for (const index of growIndexes) {
+      const size = sizes[index];
+      if (size?.kind !== CampUiSectionSizeKind.grow || minimumRow >= rows(size.minimumRows ?? 0)) {
+        continue;
+      }
+      allocated[index] = (allocated[index] ?? 0) + 1;
+      remaining -= 1;
+      if (remaining === 0) break;
+    }
+  }
+  let remainingWeight = growIndexes.reduce((total, index) => {
+    const size = sizes[index];
+    return total + (size?.kind === CampUiSectionSizeKind.grow ? Math.max(0, size.weight) : 0);
+  }, 0);
+  for (const [position, index] of growIndexes.entries()) {
+    if (remaining === 0) break;
+    const size = sizes[index];
+    if (size?.kind !== CampUiSectionSizeKind.grow) continue;
+    const weight = Math.max(0, size.weight);
+    const last = position === growIndexes.length - 1;
+    const height = last || remainingWeight <= 0 ? remaining : Math.floor(remaining * weight / remainingWeight);
+    allocated[index] = (allocated[index] ?? 0) + height;
+    remaining -= height;
+    remainingWeight -= weight;
+  }
+  return allocated;
+};
+var defaultCampUiLeftSectionSizes = {
+  camp: { kind: CampUiSectionSizeKind.fixed, rows: 4 },
+  resources: { kind: CampUiSectionSizeKind.grow, weight: 1, minimumRows: 1 },
+  workers: { kind: CampUiSectionSizeKind.grow, weight: 1, minimumRows: 1 }
+};
+
+// packages/host-ui/src/layout/campUiLayout.ts
+var CampUiLayoutMode = {
+  wide: "wide",
+  narrow: "narrow"
+};
+var region = (slotId, x, y, width, height) => width <= 0 || height <= 0 ? void 0 : { slotId, x, y, width, height };
+var compact = (items) => items.filter((item) => item !== void 0);
+var fixedRows = (available, requested) => Math.min(Math.max(available, 0), Math.max(requested, 0));
+var leftSectionHeights = (bodyHeight, slots) => {
+  const size = (slotId, fallback) => slots?.get(slotId)?.sectionSize ?? fallback;
+  return allocateCampUiSectionRows(bodyHeight, [
+    size(CampUiSlot.campHeader, defaultCampUiLeftSectionSizes.camp),
+    size(CampUiSlot.resources, defaultCampUiLeftSectionSizes.resources),
+    size(CampUiSlot.roster, defaultCampUiLeftSectionSizes.workers)
+  ]);
+};
+var makeNarrowFrame = (viewport, state, policy, slots) => {
+  const footerHeight = fixedRows(viewport.height, policy.footerHeight);
+  const bodyHeight = Math.max(0, viewport.height - footerHeight);
+  const footerY = bodyHeight;
+  const workerScreen = state.screen === CampUiScreen.worker && state.selectedWorkerId !== void 0;
+  const [campHeight = 0, resourcesHeight = 0, rosterHeight = 0] = workerScreen ? [] : leftSectionHeights(bodyHeight, slots);
+  const sessionHeaderHeight = workerScreen ? fixedRows(bodyHeight, policy.sessionHeaderHeight) : 0;
+  const composerHeight = workerScreen ? fixedRows(bodyHeight - sessionHeaderHeight, policy.composerHeight) : 0;
+  const transcriptHeight = workerScreen ? bodyHeight - sessionHeaderHeight - composerHeight : 0;
+  return {
+    mode: CampUiLayoutMode.narrow,
+    dividers: [],
+    regions: compact([
+      region(CampUiSlot.campHeader, 0, 0, viewport.width, campHeight),
+      region(CampUiSlot.resources, 0, campHeight, viewport.width, resourcesHeight),
+      region(CampUiSlot.roster, 0, campHeight + resourcesHeight, viewport.width, rosterHeight),
+      region(CampUiSlot.sessionHeader, 0, 0, viewport.width, sessionHeaderHeight),
+      region(CampUiSlot.transcript, 0, sessionHeaderHeight, viewport.width, transcriptHeight),
+      region(
+        CampUiSlot.composer,
+        0,
+        sessionHeaderHeight + transcriptHeight,
+        viewport.width,
+        composerHeight
+      ),
+      region(
+        workerScreen ? CampUiSlot.sessionFooter : CampUiSlot.campFooter,
+        0,
+        footerY,
+        viewport.width,
+        footerHeight
+      )
+    ])
+  };
+};
+var makeWideFrame = (viewport, policy, slots) => {
+  const footerHeight = fixedRows(viewport.height, policy.footerHeight);
+  const bodyHeight = Math.max(0, viewport.height - footerHeight);
+  const leftWidth = Math.max(
+    policy.leftMinimumWidth,
+    Math.min(
+      policy.leftMaximumWidth,
+      viewport.width - policy.sessionMinimumWidth - 1,
+      Math.floor(viewport.width * policy.leftRatio)
+    )
+  );
+  const rightX = leftWidth + 1;
+  const rightWidth = viewport.width - rightX;
+  const [campHeight = 0, resourcesHeight = 0, rosterHeight = 0] = leftSectionHeights(
+    bodyHeight,
+    slots
+  );
+  const sessionHeaderHeight = fixedRows(bodyHeight, policy.sessionHeaderHeight);
+  const composerHeight = fixedRows(bodyHeight - sessionHeaderHeight, policy.composerHeight);
+  const transcriptHeight = bodyHeight - sessionHeaderHeight - composerHeight;
+  const footerY = bodyHeight;
+  return {
+    mode: CampUiLayoutMode.wide,
+    dividers: viewport.height === 0 ? [] : [{ x: leftWidth, y: 0, height: viewport.height }],
+    regions: compact([
+      region(CampUiSlot.campHeader, 0, 0, leftWidth, campHeight),
+      region(CampUiSlot.resources, 0, campHeight, leftWidth, resourcesHeight),
+      region(CampUiSlot.roster, 0, campHeight + resourcesHeight, leftWidth, rosterHeight),
+      region(CampUiSlot.sessionHeader, rightX, 0, rightWidth, sessionHeaderHeight),
+      region(CampUiSlot.transcript, rightX, sessionHeaderHeight, rightWidth, transcriptHeight),
+      region(
+        CampUiSlot.composer,
+        rightX,
+        sessionHeaderHeight + transcriptHeight,
+        rightWidth,
+        composerHeight
+      ),
+      region(CampUiSlot.campFooter, 0, footerY, leftWidth, footerHeight),
+      region(CampUiSlot.sessionFooter, rightX, footerY, rightWidth, footerHeight)
+    ])
+  };
+};
+var makeDefaultCampUiLayout = (policy = defaultCampUiLayoutPolicy) => ({
+  id: "default",
+  resolve: (viewport, state, slots) => {
+    const normalized = {
+      width: Math.max(0, viewport.width),
+      height: Math.max(0, viewport.height)
+    };
+    const wideMinimumWidth = policy.leftMinimumWidth + 1 + policy.sessionMinimumWidth;
+    return normalized.width >= wideMinimumWidth && normalized.height >= policy.wideMinimumHeight ? makeWideFrame(normalized, policy, slots) : makeNarrowFrame(normalized, state, policy, slots);
+  }
+});
+
+// packages/host-ui/src/model/campUiRuntimeHealth.ts
+var CampUiRuntimeStatus = {
+  starting: "starting",
+  ready: "ready",
+  retrying: "retrying",
+  failed: "failed",
+  stopped: "stopped"
+};
+
+// packages/host-ui/src/pi/shared/campUiVisual.ts
+import { getSelectListTheme } from "@earendil-works/pi-coding-agent";
+
+// packages/host-ui/src/pi/shared/campUiRenderText.ts
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+var piShellIntegrationMarkers = [
+  "\x1B]133;A\x07",
+  "\x1B]133;B\x07",
+  "\x1B]133;C\x07"
+];
+var stripPiShellIntegration = (line) => piShellIntegrationMarkers.reduce((current, marker) => current.replaceAll(marker, ""), line);
+var hasCampUiTextContent = (line) => {
+  let index = 0;
+  while (index < line.length) {
+    if (line.charCodeAt(index) !== 27) {
+      if ((line[index] ?? "").trim() !== "") return true;
+      index += 1;
+      continue;
+    }
+    const marker = line[index + 1];
+    if (marker === "[") {
+      index += 2;
+      while (index < line.length) {
+        const code = line.charCodeAt(index);
+        index += 1;
+        if (code >= 64 && code <= 126) break;
+      }
+      continue;
+    }
+    if (marker === "]") {
+      index += 2;
+      while (index < line.length) {
+        if (line.charCodeAt(index) === 7) {
+          index += 1;
+          break;
+        }
+        if (line.charCodeAt(index) === 27 && line[index + 1] === "\\") {
+          index += 2;
+          break;
+        }
+        index += 1;
+      }
+      continue;
+    }
+    index += Math.min(2, line.length - index);
+  }
+  return false;
+};
+var fitCampUiLine = (line, width) => {
+  if (width <= 0) return "";
+  const truncated = truncateToWidth(stripPiShellIntegration(line), width);
+  return `${truncated}${" ".repeat(Math.max(0, width - visibleWidth(truncated)))}`;
+};
+var fitCampUiLines = (lines, width, height) => Array.from(
+  { length: Math.max(0, height) },
+  (_, index) => fitCampUiLine(lines[index] ?? "", width)
+);
+var joinCampUiColumns = (left, right, width) => {
+  if (width <= 0) return "";
+  const rightWidth = visibleWidth(right);
+  if (rightWidth >= width) return fitCampUiLine(right, width);
+  const leftWidth = Math.max(0, width - rightWidth - 2);
+  const fittedLeft = truncateToWidth(left, leftWidth);
+  const gap = " ".repeat(Math.max(1, width - visibleWidth(fittedLeft) - rightWidth));
+  return fitCampUiLine(`${fittedLeft}${gap}${right}`, width);
+};
+var jsonText = (value) => {
+  try {
+    return JSON.stringify(value, void 0, 2);
+  } catch {
+    return String(value);
+  }
+};
+var compactNumber = (value) => new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+
+// packages/host-ui/src/pi/shared/campUiVisual.ts
+var CampUiTone = {
+  success: "success",
+  active: "active",
+  attention: "attention",
+  error: "error",
+  external: "external",
+  info: "info",
+  neutral: "neutral"
+};
+var CampUiGlyph = {
+  success: "\u2713",
+  active: "\u25B8",
+  attention: "\u25B8",
+  error: "\u2717",
+  external: "\u21C4",
+  neutral: "\xB7",
+  live: "\u25CF"
+};
+var ansiByTone = {
+  success: "\x1B[32m",
+  active: "\x1B[32m",
+  attention: "\x1B[33m",
+  error: "\x1B[31m",
+  external: "\x1B[34m",
+  info: "\x1B[34m",
+  neutral: "\x1B[90m"
+};
+var glyphByTone = {
+  success: CampUiGlyph.success,
+  active: CampUiGlyph.active,
+  attention: CampUiGlyph.attention,
+  error: CampUiGlyph.error,
+  external: CampUiGlyph.external,
+  info: CampUiGlyph.active,
+  neutral: CampUiGlyph.neutral
+};
+var statePresentation = /* @__PURE__ */ new Map([
+  ["pending", { tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }],
+  ["starting", { tone: CampUiTone.active, glyph: CampUiGlyph.active }],
+  ["running", { tone: CampUiTone.active, glyph: CampUiGlyph.active }],
+  ["recovering", { tone: CampUiTone.attention, glyph: CampUiGlyph.attention }],
+  ["completed", { tone: CampUiTone.success, glyph: CampUiGlyph.success }],
+  ["failed", { tone: CampUiTone.error, glyph: CampUiGlyph.error }],
+  ["closed", { tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }],
+  ["ready", { tone: CampUiTone.success, glyph: CampUiGlyph.live }],
+  ["degraded", { tone: CampUiTone.attention, glyph: CampUiGlyph.attention }],
+  ["streaming", { tone: CampUiTone.active, glyph: CampUiGlyph.active }],
+  ["idle", { tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }]
+]);
+var styleCampUiTone = (tone, text) => `${ansiByTone[tone]}${text}\x1B[39m`;
+var uniqueCampUiNames = (names) => [...new Set(names)].sort((left, right) => left.localeCompare(right));
+var renderCampUiStatus = (label, tone, glyph = glyphByTone[tone]) => styleCampUiTone(tone, `${glyph} ${label}`);
+var renderCampUiState = (state) => {
+  const presentation = statePresentation.get(state) ?? {
+    tone: CampUiTone.neutral,
+    glyph: CampUiGlyph.neutral
+  };
+  return renderCampUiStatus(state, presentation.tone, presentation.glyph);
+};
+var workerStatePresentation = /* @__PURE__ */ new Map([
+  ["queued", { label: "queued", tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }],
+  ["starting", { label: "starting", tone: CampUiTone.info, glyph: CampUiGlyph.active }],
+  ["running", { label: "working", tone: CampUiTone.active, glyph: CampUiGlyph.active }],
+  [
+    "waiting_for_orchestrator",
+    { label: "ask", tone: CampUiTone.attention, glyph: CampUiGlyph.attention }
+  ],
+  /* A bounded wait, not a failure: the session and the transcript are still there. */
+  ["retrying", { label: "retrying", tone: CampUiTone.attention, glyph: CampUiGlyph.attention }],
+  ["idle", { label: "idle", tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }],
+  ["interrupted", { label: "interrupted", tone: CampUiTone.error, glyph: CampUiGlyph.error }],
+  ["recovering", { label: "recovering", tone: CampUiTone.attention, glyph: CampUiGlyph.attention }],
+  ["completed", { label: "done", tone: CampUiTone.success, glyph: CampUiGlyph.success }],
+  ["failed", { label: "error", tone: CampUiTone.error, glyph: CampUiGlyph.error }],
+  ["closed", { label: "closed", tone: CampUiTone.neutral, glyph: CampUiGlyph.neutral }]
+]);
+var fallbackWorkerPresentation = {
+  label: "unknown",
+  tone: CampUiTone.neutral,
+  glyph: CampUiGlyph.neutral
+};
+var renderCampUiWorkerState = (state, options) => {
+  const base = workerStatePresentation.get(state) ?? fallbackWorkerPresentation;
+  const terminal = state === "completed" || state === "closed";
+  const presentation = options.failed || state === "failed" || state === "interrupted" ? workerStatePresentation.get(state === "interrupted" ? "interrupted" : "failed") : !terminal && options.pendingAsks > 0 ? {
+    label: options.pendingAsks === 1 ? "ask" : `ask ${options.pendingAsks}`,
+    tone: CampUiTone.attention,
+    glyph: CampUiGlyph.attention
+  } : !terminal && options.streaming ? workerStatePresentation.get("running") : base;
+  const resolved = presentation ?? fallbackWorkerPresentation;
+  return renderCampUiStatus(resolved.label, resolved.tone, resolved.glyph);
+};
+var renderSelectedCampUiRow = (line, width) => {
+  const selected = getSelectListTheme().selectedText(fitCampUiLine(line, width));
+  return `\x1B[7m${selected}\x1B[27m`;
+};
+
+// packages/host-ui/src/pi/blocks/campUiDirectedBlock.ts
+import { getMarkdownTheme, getSelectListTheme as getSelectListTheme2 } from "@earendil-works/pi-coding-agent";
+import { Markdown, truncateToWidth as truncateToWidth2 } from "@earendil-works/pi-tui";
+var DEFAULT_DIRECTED_BLOCK_BODY_LINES = 4;
+var formatCampUiDuration = (durationMs) => {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1e3));
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes === 0) return `${seconds}s`;
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+  if (hours === 0) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+};
+var directedLine = (content, width, tone) => {
+  if (width <= 0) return "";
+  const border = styleCampUiTone(tone, "\u2502");
+  return width === 1 ? border : fitCampUiLine(`${border} ${content}`, width);
+};
+var collapseMarkdownLines = (lines, maximum, width) => {
+  if (lines.length <= maximum) return { lines, hidden: 0 };
+  if (maximum <= 0) return { lines: [], hidden: lines.length };
+  const visible = lines.slice(0, maximum);
+  const last = visible.at(-1);
+  if (last !== void 0) {
+    const previewWidth = Math.max(1, Math.floor(width * 0.7));
+    visible[visible.length - 1] = getSelectListTheme2().description(
+      `${truncateToWidth2(last, Math.max(1, previewWidth - 1))}\u2026`
+    );
+  }
+  return { lines: visible, hidden: lines.length - maximum };
+};
+var renderCampUiDirectedBlock = (block, width) => {
+  if (width <= 0) return [];
+  const contentWidth = Math.max(1, width - 2);
+  const markdownLines = new Markdown(block.markdown, 0, 0, getMarkdownTheme()).render(contentWidth);
+  const maximum = block.collapsedBodyLines ?? DEFAULT_DIRECTED_BLOCK_BODY_LINES;
+  const collapsed = collapseMarkdownLines(markdownLines, maximum, contentWidth);
+  const body = block.expanded ? markdownLines : collapsed.lines;
+  const expandable = markdownLines.length > maximum;
+  const hint = !expandable || block.showToggleHint === false ? [] : [
+    getSelectListTheme2().description(
+      block.expanded ? "enter collapse" : `enter expand \xB7 ${collapsed.hidden} lines hidden`
+    )
+  ];
+  return [
+    directedLine(renderCampUiStatus(block.label, block.tone), width, block.tone),
+    ...body.map((line) => directedLine(line, width, block.tone)),
+    directedLine(getSelectListTheme2().description(block.summary), width, block.tone),
+    ...hint.map((line) => directedLine(line, width, block.tone))
+  ];
+};
+
+// packages/host-ui/src/pi/blocks/campUiAskBlock.ts
+var toneByState = {
+  [CampAskState.pending]: CampUiTone.attention,
+  [CampAskState.answered]: CampUiTone.success,
+  [CampAskState.expired]: CampUiTone.error,
+  [CampAskState.interrupted]: CampUiTone.error
+};
+var campUiPendingAskBlockRenderer = {
+  id: "pending-asks",
+  order: 100,
+  render: ({ model, worker, width }) => {
+    return worker.asks.map((ask) => {
+      const blockId = campUiAskBlockId(ask.askId);
+      const mode = ask.blocking ? "blocking" : "non-blocking";
+      const stateLabel = {
+        [CampAskState.pending]: `pending \xB7 ${formatCampUiDuration(
+          model.state.presentationNow - ask.openedAt
+        )}`,
+        [CampAskState.answered]: "answered",
+        [CampAskState.expired]: "expired",
+        [CampAskState.interrupted]: "interrupted"
+      }[ask.state];
+      const summary = {
+        [CampAskState.pending]: `Awaiting orchestrator reply \xB7 ${ask.askId}`,
+        [CampAskState.answered]: `${ask.answerSummary ?? "Answered"} \xB7 ${ask.askId}`,
+        [CampAskState.expired]: `Expired \xB7 ${ask.askId}`,
+        [CampAskState.interrupted]: `Interrupted by host restart \xB7 ${ask.askId}`
+      }[ask.state];
+      return {
+        id: blockId,
+        lines: renderCampUiDirectedBlock(
+          {
+            label: `Ask \xB7 to ${ask.controllerId} \xB7 ${mode} \xB7 ${stateLabel}`,
+            markdown: ask.question,
+            summary,
+            tone: toneByState[ask.state],
+            expanded: model.state.expandedDetailBlockIds.has(blockId),
+            ...ask.state === CampAskState.answered ? { collapsedBodyLines: 0, showToggleHint: false } : {}
+          },
+          width
+        ),
+        toggleable: ask.state !== CampAskState.answered
+      };
+    });
+  }
+};
+
+// packages/host-ui/src/pi/blocks/campUiAssistantMessage.ts
+import { getMarkdownTheme as getMarkdownTheme2, getSelectListTheme as getSelectListTheme3 } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown as Markdown2, Spacer, Text } from "@earendil-works/pi-tui";
+var CampUiAssistantMessage = class extends Container {
+  constructor(message) {
+    super();
+    const markdownTheme = getMarkdownTheme2();
+    const selectTheme = getSelectListTheme3();
+    const visible = message.content.filter(
+      (content) => content.kind !== "tool-call" && content.kind !== "image"
+    );
+    if (visible.length > 0) this.addChild(new Spacer(1));
+    for (const [index, content] of visible.entries()) {
+      if (content.kind === "text" && content.text.trim() !== "") {
+        this.addChild(new Markdown2(content.text.trim(), 1, 0, markdownTheme));
+      }
+      if (content.kind === "thinking" && content.text.trim() !== "") {
+        this.addChild(
+          new Markdown2(content.text.trim(), 1, 0, markdownTheme, {
+            color: selectTheme.description,
+            italic: true
+          })
+        );
+      }
+      if (content.kind === "unknown") {
+        this.addChild(
+          new Markdown2(
+            `Unknown content
+
+\`\`\`json
+${jsonText(content.value)}
+\`\`\``,
+            1,
+            0,
+            markdownTheme
+          )
+        );
+      }
+      if (index < visible.length - 1) this.addChild(new Spacer(1));
+    }
+    for (const content of message.content) {
+      if (content.kind === "image") {
+        this.addChild(new Text(selectTheme.description(`[Image: ${content.mimeType}]`), 1, 0));
+      }
+    }
+    if (message.errorMessage !== void 0) {
+      this.addChild(new Spacer(1));
+      this.addChild(new Text(selectTheme.noMatch(`Error: ${message.errorMessage}`), 1, 0));
+    }
+  }
+};
+
+// packages/host-ui/src/pi/blocks/campUiComposer.ts
+import { getMarkdownTheme as getMarkdownTheme3, getSelectListTheme as getSelectListTheme4 } from "@earendil-works/pi-coding-agent";
+import { Editor, Key, matchesKey } from "@earendil-works/pi-tui";
+var makeCampUiComposerComponent = (context, tui) => {
+  const markdownTheme = getMarkdownTheme3();
+  const selectTheme = getSelectListTheme4();
+  const editors = /* @__PURE__ */ new Map();
+  const makeEditor = (workerId) => {
+    let handlingSubmit = false;
+    let syncing = false;
+    const editor = new Editor(
+      tui,
+      { borderColor: markdownTheme.codeBlockBorder, selectList: getSelectListTheme4() },
+      { paddingX: 1 }
+    );
+    editor.onChange = (draft) => {
+      if (!syncing && !(handlingSubmit && draft === "")) {
+        context.emit(CampUiIntents.SetDraft({ workerId, draft }));
+      }
+    };
+    editor.onSubmit = (text) => {
+      if (text.trim() === "") return;
+      editor.addToHistory(text);
+      context.emit(CampUiIntents.Steer({ workerId, message: text }));
+    };
+    return {
+      editor,
+      handleInput: (input) => {
+        handlingSubmit = matchesKey(input, Key.enter);
+        editor.handleInput(input);
+        handlingSubmit = false;
+      },
+      setDraft: (draft) => {
+        if (draft === editor.getText()) return;
+        syncing = true;
+        editor.setText(draft);
+        syncing = false;
+      }
+    };
+  };
+  const selectedEditor = () => {
+    const workerId = context.readModel().state.selectedWorkerId;
+    if (workerId === void 0) return void 0;
+    const existing = editors.get(workerId);
+    if (existing !== void 0) return existing;
+    const created = makeEditor(workerId);
+    editors.set(workerId, created);
+    return created;
+  };
+  return {
+    focusable: true,
+    render: (viewport) => {
+      const model = context.readModel();
+      const workerId = model.state.selectedWorkerId;
+      const entry = selectedEditor();
+      if (workerId === void 0 || entry === void 0) {
+        return [selectTheme.description("worker not selected")];
+      }
+      const { editor } = entry;
+      editor.focused = model.state.focusedSlotId === CampUiSlot.composer;
+      editor.borderColor = editor.focused ? selectTheme.selectedPrefix : markdownTheme.codeBlockBorder;
+      entry.setDraft(model.state.drafts.get(workerId) ?? "");
+      return editor.render(viewport.width).slice(0, viewport.height);
+    },
+    handleInput: (input) => {
+      const entry = selectedEditor();
+      if (entry === void 0) return false;
+      const { editor } = entry;
+      const autocompleteVisible = editor.isShowingAutocomplete();
+      if (matchesKey(input, Key.escape) || matchesKey(input, Key.tab) || matchesKey(input, "shift+tab")) {
+        if (!autocompleteVisible) return false;
+        entry.handleInput(input);
+        return true;
+      }
+      const arrow = matchesKey(input, Key.left) || matchesKey(input, Key.right) || matchesKey(input, Key.up) || matchesKey(input, Key.down);
+      if (arrow) {
+        const beforeCursor = editor.getCursor();
+        const beforeText = editor.getText();
+        entry.handleInput(input);
+        const afterCursor = editor.getCursor();
+        return autocompleteVisible || beforeText !== editor.getText() || beforeCursor.line !== afterCursor.line || beforeCursor.col !== afterCursor.col;
+      }
+      entry.handleInput(input);
+      return true;
+    },
+    handlePointer: (pointer) => pointer.action === "press" && pointer.button === "left" ? [CampUiIntents.FocusSlot({ slotId: CampUiSlot.composer })] : [],
+    invalidate: () => {
+      for (const { editor } of editors.values()) editor.invalidate();
+    }
+  };
+};
+
+// packages/host-ui/src/pi/blocks/campUiDetail.ts
+import { getSelectListTheme as getSelectListTheme7 } from "@earendil-works/pi-coding-agent";
+import { Key as Key2, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+
+// packages/host-ui/src/pi/blocks/campUiEquipmentBlock.ts
+import { getMarkdownTheme as getMarkdownTheme4, UserMessageComponent } from "@earendil-works/pi-coding-agent";
+var escapeMarkdown = (value) => value.replaceAll(/([\\`*_[\]{}()#+.!|>])/gu, "\\$1");
+var renderNames = (names) => names.length === 0 ? "none" : names.map(escapeMarkdown).join(", ");
+var renderMcpServers = (equipment) => renderNames(
+  equipment.mcp.serverNames.map((serverName) => {
+    const toolNames = equipment.mcp.toolNamesByServer?.[serverName];
+    return toolNames === void 0 ? serverName : `${serverName} (${toolNames.join(", ")})`;
+  })
+);
+var equipmentMarkdown = (equipment) => {
+  const role = equipment.role ?? equipment.preset ?? "worker";
+  const tools = [.../* @__PURE__ */ new Set([...equipment.builtinTools, ...equipment.customToolNames])].sort();
+  const lines = [
+    `**Equipment \xB7 ${escapeMarkdown(role)}**`,
+    "",
+    `- **Tools:** ${renderNames(tools)}`,
+    `- **MCP:** ${renderMcpServers(equipment)}`,
+    `- **Skills:** ${renderNames(equipment.skillNames)}`,
+    `- **Access:** ${equipment.readOnly ? "read-only" : "read/write"}`
+  ];
+  return lines.join("\n");
+};
+var campUiEquipmentBlockRenderer = {
+  id: "role-equipment",
+  order: -100,
+  render: ({ worker, width }) => [
+    {
+      id: "role-equipment",
+      lines: new UserMessageComponent(
+        equipmentMarkdown(worker.snapshot.worker.equipment),
+        getMarkdownTheme4(),
+        0
+      ).render(width)
+    }
+  ]
+};
+
+// packages/host-ui/src/pi/blocks/campUiTranscriptBlocks.ts
+import { getMarkdownTheme as getMarkdownTheme7, UserMessageComponent as UserMessageComponent2 } from "@earendil-works/pi-coding-agent";
+import { Markdown as Markdown4 } from "@earendil-works/pi-tui";
+
+// packages/host-ui/src/pi/shared/campUiPanel.ts
+import { getMarkdownTheme as getMarkdownTheme5, getSelectListTheme as getSelectListTheme5 } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth as truncateToWidth3, visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+var rule = (start, label, width, borderColor, labelColor) => {
+  const prefix = `${borderColor(`${start}\u2500 `)}${labelColor(label)}${borderColor(" ")}`;
+  const truncated = truncateToWidth3(prefix, width);
+  return `${truncated}${borderColor("\u2500".repeat(Math.max(0, width - visibleWidth2(truncated))))}`;
+};
+var renderCampUiPanel = (label, body, width) => {
+  if (width <= 0) return [];
+  const borderColor = getMarkdownTheme5().codeBlockBorder;
+  const labelColor = getSelectListTheme5().selectedText;
+  if (width === 1) {
+    return [borderColor("\u2502"), ...body.map(() => borderColor("\u2502")), borderColor("\u2570")];
+  }
+  return [
+    rule("\u256D", label, width, borderColor, labelColor),
+    ...body.map((line) => fitCampUiLine(`${borderColor("\u2502")} ${line}`, width)),
+    borderColor(`\u2570${"\u2500".repeat(width - 1)}`)
+  ];
+};
+
+// packages/host-ui/src/pi/blocks/campUiToolResult.ts
+import {
+  getMarkdownTheme as getMarkdownTheme6,
+  getSelectListTheme as getSelectListTheme6,
+  truncateToVisualLines
+} from "@earendil-works/pi-coding-agent";
+import { Markdown as Markdown3 } from "@earendil-works/pi-tui";
+var CAMP_UI_DEFAULT_TOOL_PREVIEW_LINES = 12;
+var CAMP_UI_BASH_PREVIEW_LINES = 8;
+var previewLinesByTool = /* @__PURE__ */ new Map([["bash", CAMP_UI_BASH_PREVIEW_LINES]]);
+var toolResultContent = (result, markdown) => result.content.flatMap((content) => {
+  if (content.kind === "text" || content.kind === "thinking") return [content.text];
+  if (content.kind === "image") return [`[Image: ${content.mimeType}]`];
+  if (content.kind === "tool-call") {
+    return [
+      markdown ? `**Tool: ${content.toolName}**
+
+\`\`\`json
+${jsonText(content.arguments)}
+\`\`\`` : jsonText(content.arguments)
+    ];
+  }
+  return [
+    markdown ? `**Unknown content**
+
+\`\`\`json
+${jsonText(content.value)}
+\`\`\`` : jsonText(content.value)
+  ];
+}).join(markdown ? "\n\n" : "\n");
+var toolResultPlainText = (result) => [
+  toolResultContent(result, false),
+  ...result.errorMessage === void 0 ? [] : [`Error: ${result.errorMessage}`],
+  ...result.toolResultDetails === void 0 ? [] : [`Details
+${jsonText(result.toolResultDetails)}`]
+].filter((part) => part !== "").join("\n");
+var renderCampUiToolResult = (result, width, expanded) => {
+  const boundedWidth = Math.max(1, width);
+  const plainText = toolResultPlainText(result);
+  const preview = truncateToVisualLines(
+    getSelectListTheme6().description(plainText),
+    previewLinesByTool.get(result.toolName ?? "") ?? CAMP_UI_DEFAULT_TOOL_PREVIEW_LINES,
+    boundedWidth
+  );
+  if (!expanded) {
+    return [
+      ...preview.visualLines,
+      ...preview.skippedCount === 0 ? [] : [
+        getSelectListTheme6().description(
+          `... ${preview.skippedCount} more lines \xB7 enter expand`
+        )
+      ]
+    ];
+  }
+  const content = toolResultContent(result, true);
+  const lines = content === "" ? [] : new Markdown3(content, 0, 0, getMarkdownTheme6()).render(boundedWidth);
+  return [
+    ...lines,
+    ...result.errorMessage === void 0 ? [] : [getSelectListTheme6().noMatch(`Error: ${result.errorMessage}`)],
+    ...result.toolResultDetails === void 0 ? [] : [
+      getSelectListTheme6().description("Details"),
+      ...new Markdown3(jsonText(result.toolResultDetails), 0, 0, getMarkdownTheme6()).render(
+        boundedWidth
+      )
+    ],
+    ...preview.skippedCount === 0 ? [] : [getSelectListTheme6().description("enter collapse")]
+  ];
+};
+
+// packages/host-ui/src/pi/blocks/campUiTranscriptBlocks.ts
+var contentMarkdown = (message, includeToolCalls) => message.content.flatMap((content) => {
+  if (content.kind === "text") return [content.text];
+  if (content.kind === "thinking") {
+    return [`> Thinking
+> ${content.text.replaceAll("\n", "\n> ")}`];
+  }
+  if (content.kind === "image") return [`[Image: ${content.mimeType}]`];
+  if (content.kind === "tool-call") {
+    return includeToolCalls ? [`**Tool: ${content.toolName}**
+
+\`\`\`json
+${jsonText(content.arguments)}
+\`\`\``] : [];
+  }
+  return [`**Unknown content**
+
+\`\`\`json
+${jsonText(content.value)}
+\`\`\``];
+}).join("\n\n");
+var renderMessage = (message, width) => {
+  if (message.role === "user") {
+    const markdown2 = contentMarkdown(message, false);
+    if (markdown2 === "") return [];
+    const attribution = message.source?.kind === "controller" ? [
+      styleCampUiTone(
+        CampUiTone.external,
+        `controller ${message.source.controllerId}${message.source.actorId === void 0 ? "" : ` \xB7 ${message.source.actorId}`}`
+      )
+    ] : [];
+    return [
+      ...attribution,
+      ...new UserMessageComponent2(markdown2, getMarkdownTheme7(), 0).render(width)
+    ];
+  }
+  if (message.role === "assistant") {
+    return new CampUiAssistantMessage(message).render(width);
+  }
+  const markdown = contentMarkdown(message, false);
+  if (markdown === "") return [];
+  const prefix = message.role === "assistant" ? "" : `${message.role}
+
+`;
+  const suffix = message.errorMessage === void 0 ? "" : `
+
+Error: ${message.errorMessage}`;
+  return new Markdown4(`${prefix}${markdown}${suffix}`, 0, 0, getMarkdownTheme7()).render(width);
+};
+var renderMarkdown = (markdown, width) => new Markdown4(markdown, 0, 0, getMarkdownTheme7()).render(Math.max(1, width));
+var firstStringArgument = (parameters, names) => {
+  for (const name of names) {
+    const value = parameters[name];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return void 0;
+};
+var toolArgumentSummary = (toolName, parameters) => {
+  const namesByTool = /* @__PURE__ */ new Map([
+    ["bash", ["command"]],
+    ["edit", ["path", "file_path"]],
+    ["find", ["pattern", "path"]],
+    ["grep", ["pattern", "path"]],
+    ["ls", ["path"]],
+    ["read", ["path", "file_path"]],
+    ["write", ["path", "file_path"]]
+  ]);
+  return firstStringArgument(parameters, namesByTool.get(toolName) ?? []) ?? jsonText(parameters);
+};
+var renderToolCall = (toolCall, result, width, expanded) => {
+  const innerWidth = Math.max(1, width - 2);
+  const status = result === void 0 ? "running" : result.isError === true ? "failed" : "completed";
+  const body = [
+    ...renderMarkdown(toolArgumentSummary(toolCall.toolName, toolCall.arguments), innerWidth),
+    ...result === void 0 ? [] : renderCampUiToolResult(result, innerWidth, expanded)
+  ];
+  return renderCampUiPanel(`${toolCall.toolName} \xB7 ${status}`, body, width);
+};
+var renderUnmatchedToolResult = (message, width, expanded) => {
+  const status = message.isError === true ? "failed" : "completed";
+  const name = message.toolName ?? "unknown";
+  return renderCampUiPanel(
+    `${name} \xB7 ${status}`,
+    renderCampUiToolResult(message, Math.max(1, width - 2), expanded),
+    width
+  );
+};
+var renderTranscript = (transcript, width, expandedDetailBlockIds) => {
+  const results = /* @__PURE__ */ new Map();
+  const callIds = /* @__PURE__ */ new Set();
+  for (const message of transcript) {
+    if (message.role === "toolResult" && message.toolCallId !== void 0) {
+      results.set(message.toolCallId, message);
+    }
+    for (const content of message.content) {
+      if (content.kind === "tool-call") callIds.add(content.toolCallId);
+    }
+  }
+  return transcript.flatMap((message, index) => {
+    const messageId = message.id ?? String(index);
+    if (message.role === "toolResult") {
+      const blockId = `tool-result:${messageId}`;
+      return message.toolCallId !== void 0 && callIds.has(message.toolCallId) ? [] : [
+        {
+          id: blockId,
+          lines: renderUnmatchedToolResult(message, width, expandedDetailBlockIds.has(blockId)),
+          toggleable: true
+        }
+      ];
+    }
+    const blocks = [];
+    const messageLines = renderMessage(message, width);
+    if (messageLines.length > 0) blocks.push({ id: `message:${messageId}`, lines: messageLines });
+    for (const content of message.content) {
+      if (content.kind !== "tool-call") continue;
+      const blockId = `tool-call:${content.toolCallId}`;
+      blocks.push({
+        id: blockId,
+        lines: renderToolCall(
+          content,
+          results.get(content.toolCallId),
+          width,
+          expandedDetailBlockIds.has(blockId)
+        ),
+        toggleable: results.has(content.toolCallId)
+      });
+    }
+    return blocks;
+  });
+};
+var campUiTranscriptBlockRenderer = {
+  id: "transcript",
+  order: 0,
+  render: ({ model, worker, width }) => renderTranscript(
+    worker.snapshot.session?.transcript ?? [],
+    width,
+    model.state.expandedDetailBlockIds
+  )
+};
+
+// packages/host-ui/src/pi/blocks/campUiDetail.ts
+var defaultCampUiDetailBlockRenderers = [
+  campUiEquipmentBlockRenderer,
+  campUiTranscriptBlockRenderer,
+  campUiPendingAskBlockRenderer
+];
+var sameCampUiDetailBlockSet = (left, right) => left.size === right.size && [...left].every((blockId) => right.has(blockId));
+var makeCampUiDetailComponent = (context, registry = defaultCampUiDetailBlockRenderers) => {
+  const renderState = /* @__PURE__ */ new Map();
+  const detailCache = /* @__PURE__ */ new Map();
+  let renderedRanges = [];
+  let visibleRanges = [];
+  return {
+    focusable: true,
+    render: (viewport) => {
+      renderedRanges = [];
+      visibleRanges = [];
+      const model = context.readModel();
+      const selectTheme = getSelectListTheme7();
+      const workerId = model.state.selectedWorkerId;
+      if (workerId === void 0) return [selectTheme.description("No worker selected")];
+      const worker = findCampUiWorker(model.snapshot, workerId);
+      if (worker === void 0) return [selectTheme.noMatch("Selected worker is unavailable")];
+      if (worker.error !== void 0) {
+        return [selectTheme.noMatch(`Snapshot error: ${worker.error}`)];
+      }
+      const cached = detailCache.get(workerId);
+      const detail = cached !== void 0 && cached.worker === worker && cached.width === viewport.width && cached.expandedDetailBlockIds === model.state.expandedDetailBlockIds && cached.presentationNow === model.state.presentationNow ? cached.detail : renderCampUiDetailBlockLayout(registry, {
+        model,
+        worker,
+        width: viewport.width
+      });
+      if (detail !== cached?.detail) {
+        detailCache.set(workerId, {
+          worker,
+          width: viewport.width,
+          expandedDetailBlockIds: model.state.expandedDetailBlockIds,
+          presentationNow: model.state.presentationNow,
+          detail
+        });
+      }
+      renderedRanges = detail.ranges.filter((range) => range.toggleable);
+      const focusedRange = model.state.focusedSlotId === CampUiSlot.transcript ? renderedRanges.find((range) => range.id === model.state.focusedDetailBlockId) : void 0;
+      const focusedLine = focusedRange === void 0 ? void 0 : Array.from(
+        { length: focusedRange.end - focusedRange.start },
+        (_, index) => focusedRange.start + index
+      ).find((index) => hasCampUiTextContent(detail.lines[index] ?? "")) ?? focusedRange.start;
+      const lines = focusedRange === void 0 ? detail.lines : detail.lines.map(
+        (line, index) => index === focusedLine ? fitCampUiLine(
+          `${styleCampUiTone(CampUiTone.active, `${CampUiGlyph.active} `)}${line}`,
+          viewport.width
+        ) : line
+      );
+      const previous = renderState.get(workerId);
+      const offset = model.state.scrollOffsets.get(workerId) ?? 0;
+      const growth = previous !== void 0 && previous.width === viewport.width && sameCampUiDetailBlockSet(
+        previous.expandedDetailBlockIds,
+        model.state.expandedDetailBlockIds
+      ) ? Math.max(0, lines.length - previous.lineCount) : 0;
+      const focusedOffset = focusedRange === void 0 ? void 0 : Math.max(
+        0,
+        lines.length - Math.min(lines.length, focusedRange.start + viewport.height)
+      );
+      const maximumOffset = Math.max(0, lines.length - viewport.height);
+      const desiredOffset = focusedOffset ?? (offset > 0 ? offset + growth : 0);
+      const lockedOffset = Math.min(maximumOffset, desiredOffset);
+      if (lockedOffset !== offset) {
+        context.emit(CampUiIntents.SetScrollOffset({ workerId, offset: lockedOffset }));
+      }
+      renderState.set(workerId, {
+        width: viewport.width,
+        lineCount: lines.length,
+        expandedDetailBlockIds: model.state.expandedDetailBlockIds
+      });
+      if (lines.length === 0) return [selectTheme.description("Waiting for worker output...")];
+      const end = Math.max(0, lines.length - lockedOffset);
+      const start = Math.max(0, end - viewport.height);
+      visibleRanges = renderedRanges.filter((range) => range.end > start && range.start < end).map((range) => ({
+        blockId: range.id,
+        start: Math.max(0, range.start - start),
+        end: Math.min(end - start, range.end - start)
+      }));
+      return lines.slice(start, end);
+    },
+    handleInput: (input) => {
+      const delta = matchesKey2(input, Key2.up) ? -1 : matchesKey2(input, Key2.down) ? 1 : void 0;
+      if (delta === void 0 || renderedRanges.length === 0) return false;
+      const focusedBlockId = context.readModel().state.focusedDetailBlockId;
+      const current = renderedRanges.findIndex((range) => range.id === focusedBlockId);
+      const next = current < 0 ? delta < 0 ? renderedRanges.length - 1 : 0 : current + delta;
+      const target = renderedRanges[next];
+      if (target === void 0) return false;
+      context.emit(CampUiIntents.FocusDetailBlock({ blockId: target.id }));
+      return true;
+    },
+    handlePointer: (pointer) => {
+      const workerId = context.readModel().state.selectedWorkerId;
+      if (workerId === void 0) return [];
+      if (pointer.action === "wheel") {
+        return [
+          CampUiIntents.FocusSlot({ slotId: CampUiSlot.transcript }),
+          CampUiIntents.ScrollWorker({
+            workerId,
+            delta: pointer.direction === "up" ? 3 : -3
+          })
+        ];
+      }
+      if (pointer.action !== "press" || pointer.button !== "left") return [];
+      const target = visibleRanges.find(
+        (range) => pointer.y >= range.start && pointer.y < range.end
+      );
+      return target === void 0 ? [CampUiIntents.FocusSlot({ slotId: CampUiSlot.transcript })] : [
+        CampUiIntents.FocusSlot({ slotId: CampUiSlot.transcript }),
+        CampUiIntents.FocusDetailBlock({ blockId: target.blockId }),
+        CampUiIntents.ToggleDetailBlock({ blockId: target.blockId })
+      ];
+    }
+  };
+};
+
+// packages/host-ui/src/pi/layout/campUiChrome.ts
+import { getSelectListTheme as getSelectListTheme8 } from "@earendil-works/pi-coding-agent";
+var makeCampUiCampHeader = (context) => ({
+  render: (viewport) => {
+    const snapshot = context.readModel().snapshot;
+    const theme = getSelectListTheme8();
+    const mode = snapshot.placement === "external" ? "agentless" : "foreman";
+    return [
+      fitCampUiLine(theme.description(snapshot.displayName), viewport.width),
+      fitCampUiLine(
+        `${theme.description(mode)} ${theme.description("\xB7")} ${renderCampUiState(snapshot.health.status)}`,
+        viewport.width
+      )
+    ];
+  }
+});
+var makeCampUiSeat = (context) => ({
+  render: (viewport) => {
+    const snapshot = context.readModel().snapshot;
+    const theme = getSelectListTheme8();
+    const external = snapshot.placement === "external";
+    const controller = snapshot.controllerConnected ? renderCampUiStatus("live", CampUiTone.success, CampUiGlyph.live) : renderCampUiStatus("lost", CampUiTone.error);
+    return [
+      fitCampUiLine(
+        external ? `${renderCampUiStatus("controller", CampUiTone.external)} ${theme.description("\xB7 external \xB7")} ${controller}` : `${renderCampUiStatus("foreman", CampUiTone.neutral)} ${theme.description("\xB7 session not reported \xB7")} ${controller}`,
+        viewport.width
+      )
+    ];
+  }
+});
+var makeCampUiRoster = (context) => ({
+  focusable: true,
+  render: (viewport) => {
+    const model = context.readModel();
+    const theme = getSelectListTheme8();
+    const focused = model.state.focusedSlotId === CampUiSlot.roster;
+    if (model.snapshot.workers.length === 0) {
+      return [theme.description("No workers")];
+    }
+    const workers = model.snapshot.workers.map((entry) => {
+      const worker = entry.snapshot.worker;
+      const selected = worker.id === model.state.selectedWorkerId;
+      const name = worker.alias ?? worker.id.slice(0, 8);
+      const session = entry.snapshot.session;
+      const active = uniqueCampUiNames([
+        ...session?.activeToolNames ?? [],
+        ...session?.pendingToolNames ?? []
+      ]);
+      const pendingAsks = entry.asks.filter((ask) => ask.state === "pending").length;
+      const tool = active.length === 0 ? "" : styleCampUiTone(CampUiTone.active, `  ${active.slice(0, 2).join(", ")}`);
+      const label = selected ? theme.selectedText(name) : name;
+      const role = theme.description(`(${worker.equipment.role ?? "worker"})`);
+      const status = renderCampUiWorkerState(worker.state, {
+        failed: entry.error !== void 0,
+        pendingAsks,
+        streaming: session?.isStreaming === true
+      });
+      const line = `${status}  ${label} ${role}${tool}`;
+      return selected && focused ? renderSelectedCampUiRow(line, viewport.width) : fitCampUiLine(line, viewport.width);
+    });
+    return workers;
+  },
+  handlePointer: (pointer) => {
+    if (pointer.action !== "press" || pointer.button !== "left") return [];
+    const workerId = context.readModel().snapshot.workers[pointer.y]?.snapshot.worker.id;
+    if (workerId === void 0) return [];
+    return [
+      CampUiIntents.FocusSlot({ slotId: CampUiSlot.roster }),
+      pointer.mode === "narrow" ? CampUiIntents.OpenWorker({ workerId }) : CampUiIntents.SelectWorker({ workerId })
+    ];
+  }
+});
+var makeCampUiSessionHeader = (context) => ({
+  render: (viewport) => {
+    const model = context.readModel();
+    const theme = getSelectListTheme8();
+    const workerId = model.state.selectedWorkerId;
+    if (workerId === void 0) {
+      return [fitCampUiLine(theme.description("Select a worker"), viewport.width)];
+    }
+    const worker = findCampUiWorker(model.snapshot, workerId);
+    if (worker === void 0) return [theme.noMatch("Worker unavailable")];
+    const workerName = worker.snapshot.worker.alias ?? workerId.slice(0, 8);
+    const role = worker.snapshot.worker.equipment.role ?? "worker";
+    const line = `${theme.selectedText(`camp / ${workerName}`)} ${theme.description(`\xB7 ${role} \xB7 session ${worker.snapshot.worker.sessionState}`)}`;
+    return [fitCampUiLine(line, viewport.width)];
+  },
+  handlePointer: (pointer) => pointer.action === "press" && pointer.button === "left" && pointer.y === 0 ? [
+    CampUiIntents.ActivateScreen({ screen: CampUiScreen.camp }),
+    CampUiIntents.FocusDetailBlock({}),
+    CampUiIntents.FocusSlot({ slotId: CampUiSlot.roster })
+  ] : []
+});
+
+// packages/host-ui/src/pi/layout/campUiFooter.ts
+import { getMarkdownTheme as getMarkdownTheme8, getSelectListTheme as getSelectListTheme9 } from "@earendil-works/pi-coding-agent";
+var aggregateCampUsage = (workers) => {
+  const usages = workers.flatMap(
+    (worker) => worker.snapshot.session?.usage === void 0 ? [] : [worker.snapshot.session.usage]
+  );
+  return {
+    cost: usages.reduce((total, usage) => total + usage.cost, 0),
+    reportedWorkers: usages.length,
+    tokens: usages.reduce((total, usage) => total + usage.tokens.total, 0),
+    totalWorkers: workers.length
+  };
+};
+var aggregateUsageText = (usage) => {
+  if (usage.totalWorkers > 0 && usage.reportedWorkers === 0) {
+    return "tokens unknown \xB7 cost unknown";
+  }
+  const partial = usage.reportedWorkers < usage.totalWorkers;
+  const lowerBound = partial ? "\u2265" : "";
+  const coverage = partial ? ` \xB7 ${usage.reportedWorkers}/${usage.totalWorkers} reported` : "";
+  return `\u2193 ${lowerBound}${compactNumber(usage.tokens)} tokens \xB7 ${lowerBound}$${usage.cost.toFixed(3)}${coverage}`;
+};
+var footerDivider = (width) => fitCampUiLine(getMarkdownTheme8().codeBlockBorder("\u2500".repeat(width)), width);
+var retryText = (retryAt, now) => {
+  if (retryAt === void 0) return "";
+  return `retry in ${Math.max(0, Math.ceil((retryAt - now) / 1e3))}s`;
+};
+var diagnosticText = (value) => {
+  const normalized = value?.replaceAll(/\s+/gu, " ").trim();
+  return normalized === "" ? void 0 : normalized;
+};
+var makeCampUiCampFooter = (context) => ({
+  render: (viewport) => {
+    const model = context.readModel();
+    const theme = getSelectListTheme9();
+    const health = model.snapshot.health;
+    const usage = aggregateUsageText(aggregateCampUsage(model.snapshot.workers));
+    const actionError = diagnosticText(model.state.lastActionError);
+    const healthSummary = diagnosticText(health.message);
+    const healthMessage = health.code === void 0 ? healthSummary : healthSummary === void 0 ? health.code : `${health.code} \xB7 ${healthSummary}`;
+    const healthTone = health.status === CampUiHealthStatus.failed ? CampUiTone.error : CampUiTone.attention;
+    const diagnostic = actionError !== void 0 ? `${renderCampUiStatus("action error", CampUiTone.error)} ${theme.description(`\xB7 ${actionError}`)}` : healthMessage !== void 0 ? styleCampUiTone(healthTone, healthMessage) : health.status === CampUiHealthStatus.ready ? "" : renderCampUiStatus(health.status, healthTone);
+    const retry = retryText(health.retryAt, model.state.presentationNow);
+    return [
+      footerDivider(viewport.width),
+      joinCampUiColumns(diagnostic, theme.description(usage), viewport.width),
+      fitCampUiLine(retry === "" ? "" : theme.description(retry), viewport.width)
+    ];
+  }
+});
+var makeCampUiSessionFooter = (context) => ({
+  render: (viewport) => {
+    const model = context.readModel();
+    const theme = getSelectListTheme9();
+    const workerId = model.state.selectedWorkerId;
+    const worker = workerId === void 0 ? void 0 : findCampUiWorker(model.snapshot, workerId);
+    const usage = worker?.snapshot.session?.usage;
+    const tokenText = usage === void 0 ? "tokens unknown" : `\u2193 ${compactNumber(usage.tokens.total)} tokens`;
+    const costText = usage === void 0 ? "cost unknown" : `$${usage.cost.toFixed(3)}`;
+    const cacheText = usage?.latestCacheHitRate === void 0 ? usage === void 0 || usage.tokens.total === 0 ? "cache n/a" : "cache not reported" : `cache ${usage.latestCacheHitRate.toFixed(0)}%`;
+    const contextText = usage?.context?.percent === null || usage?.context?.percent === void 0 ? "context unknown" : `context ${usage.context.percent.toFixed(0)}%`;
+    const modelText = usage?.model ?? worker?.snapshot.worker.equipment.model ?? "model unknown";
+    const thinking = worker?.snapshot.session?.thinkingLevel ?? worker?.snapshot.worker.equipment.thinkingLevel ?? "unknown";
+    const identity = worker === void 0 ? theme.description("worker not selected") : `${theme.selectedText(worker.snapshot.worker.alias ?? worker.snapshot.worker.id.slice(0, 8))} ${theme.description(`\xB7 ${worker.snapshot.worker.cwd}`)}`;
+    const branch = worker === void 0 || model.snapshot.projectBranch === null ? "" : theme.description(`branch ${model.snapshot.projectBranch}`);
+    return [
+      footerDivider(viewport.width),
+      branch === "" ? fitCampUiLine(identity, viewport.width) : joinCampUiColumns(identity, branch, viewport.width),
+      joinCampUiColumns(
+        theme.description(`${tokenText} \xB7 ${costText} \xB7 ${cacheText} \xB7 ${contextText}`),
+        theme.description(`${modelText} \xB7 effort ${thinking}`),
+        viewport.width
+      )
+    ];
+  }
+});
+
+// packages/host-ui/src/pi/layout/campUiResources.ts
+import { getSelectListTheme as getSelectListTheme10 } from "@earendil-works/pi-coding-agent";
+var renderResourceTree = (label, value, tone, width) => {
+  const theme = getSelectListTheme10();
+  const lines = [
+    theme.description(label),
+    `${theme.description("\u2514\u2500")} ${renderCampUiStatus(value, tone)}`
+  ];
+  return lines.map((line) => fitCampUiLine(line, width));
+};
+var makeCampUiResources = (context) => ({
+  render: (viewport) => {
+    const model = context.readModel();
+    const snapshot = model.snapshot;
+    const equipment = snapshot.workers.map((worker) => worker.snapshot.worker.equipment);
+    const inventory = snapshot.resources;
+    const resourcesReported = inventory.reportedWorkers > 0;
+    const equipmentReported = equipment.length > 0;
+    const partial = !inventory.complete;
+    const resourceText = (items) => {
+      if (!resourcesReported) return "not reported";
+      const names = uniqueCampUiNames(items.map((item) => item.name));
+      const value = names.length === 0 ? "none loaded" : names.join(", ");
+      return partial ? `${value} \xB7 partial` : value;
+    };
+    const mcpNames = uniqueCampUiNames(equipment.flatMap((item) => item.mcp.serverNames));
+    const mcpHealth = snapshot.workers.flatMap((worker) => worker.snapshot.mcp);
+    const healthNames = new Set(mcpHealth.map((item) => item.serverName));
+    const failedMcp = mcpHealth.some(
+      (item) => item.status === "failed" || item.status === "closed"
+    );
+    const pendingMcp = mcpHealth.some(
+      (item) => item.status === "connecting" || item.status === "retry-wait"
+    );
+    const partialMcp = mcpHealth.some((item) => !item.catalogComplete);
+    const missingMcpHealth = mcpNames.some((name) => !healthNames.has(name));
+    const mcpTone = failedMcp ? CampUiTone.error : pendingMcp || partialMcp || missingMcpHealth ? CampUiTone.attention : mcpNames.length > 0 ? CampUiTone.success : CampUiTone.neutral;
+    const mcpNotes = [
+      ...failedMcp ? ["down"] : [],
+      ...pendingMcp ? ["connecting"] : [],
+      ...partialMcp ? ["catalog partial"] : [],
+      ...missingMcpHealth ? ["health not reported"] : []
+    ];
+    const mcpText = !equipmentReported ? "not reported" : mcpNames.length === 0 ? "none configured" : `${mcpNames.join(", ")}${mcpNotes.length === 0 ? "" : ` \xB7 ${mcpNotes.join(", ")}`}`;
+    return [
+      ...renderResourceTree(
+        "Context",
+        resourceText(inventory.contextFiles),
+        inventory.contextFiles.length > 0 ? CampUiTone.success : CampUiTone.neutral,
+        viewport.width
+      ),
+      ...renderResourceTree(
+        "Extensions",
+        resourceText(inventory.extensions),
+        inventory.extensions.length > 0 ? CampUiTone.success : CampUiTone.neutral,
+        viewport.width
+      ),
+      ...renderResourceTree(
+        "Skills",
+        resourceText(inventory.skills),
+        inventory.skills.length > 0 ? CampUiTone.success : CampUiTone.neutral,
+        viewport.width
+      ),
+      ...renderResourceTree("MCP", mcpText, mcpTone, viewport.width)
+    ];
+  }
+});
+
+// packages/host-ui/src/pi/layout/campUiDefaultSlots.ts
+var makeDefaultCampUiContributions = (tui, detailBlocks) => [
+  {
+    id: "default-camp-header",
+    slotId: CampUiSlot.campHeader,
+    mount: (context) => Effect_exports.succeed(makeCampUiCampHeader(context))
+  },
+  {
+    id: "default-seat",
+    slotId: CampUiSlot.seat,
+    mount: (context) => Effect_exports.succeed(makeCampUiSeat(context))
+  },
+  {
+    id: "default-resources",
+    slotId: CampUiSlot.resources,
+    mount: (context) => Effect_exports.succeed(makeCampUiResources(context))
+  },
+  {
+    id: "default-roster",
+    slotId: CampUiSlot.roster,
+    mount: (context) => Effect_exports.succeed(makeCampUiRoster(context))
+  },
+  {
+    id: "default-session-header",
+    slotId: CampUiSlot.sessionHeader,
+    mount: (context) => Effect_exports.succeed(makeCampUiSessionHeader(context))
+  },
+  {
+    id: "default-transcript",
+    slotId: CampUiSlot.transcript,
+    mount: (context) => Effect_exports.succeed(makeCampUiDetailComponent(context, detailBlocks))
+  },
+  {
+    id: "default-composer",
+    slotId: CampUiSlot.composer,
+    mount: (context) => Effect_exports.succeed(makeCampUiComposerComponent(context, tui))
+  },
+  {
+    id: "default-camp-footer",
+    slotId: CampUiSlot.campFooter,
+    mount: (context) => Effect_exports.succeed(makeCampUiCampFooter(context))
+  },
+  {
+    id: "default-session-footer",
+    slotId: CampUiSlot.sessionFooter,
+    mount: (context) => Effect_exports.succeed(makeCampUiSessionFooter(context))
+  }
+];
+
+// packages/host-ui/src/pi/layout/campUiSection.ts
+import { getMarkdownTheme as getMarkdownTheme9, getSelectListTheme as getSelectListTheme11 } from "@earendil-works/pi-coding-agent";
+import { visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
+var renderHeader = (header, width) => {
+  const theme = getMarkdownTheme9();
+  const selectTheme = getSelectListTheme11();
+  const rule2 = header.focused === true ? selectTheme.selectedPrefix : theme.codeBlockBorder;
+  const title = header.focused === true ? selectTheme.selectedText : theme.heading;
+  const ruleCharacter = header.focused === true ? "\u2501" : "\u2500";
+  const detail = header.detail === void 0 ? "" : `  ${selectTheme.description(header.detail)}`;
+  const label = `${rule2(ruleCharacter.repeat(2))} ${title(header.title)}${detail} `;
+  const ruleWidth = Math.max(0, width - visibleWidth3(label));
+  return fitCampUiLine(`${label}${rule2(ruleCharacter.repeat(ruleWidth))}`, width);
+};
+var makeCampUiSection = (options) => {
+  let childHeights = options.children.map(() => 0);
+  const components = options.children.map((child) => child.component);
+  const pointerComponents = components.some((component) => component.handlePointer !== void 0);
+  const inputComponents = components.some((component) => component.handleInput !== void 0);
+  const invalidatingComponents = components.some((component) => component.invalidate !== void 0);
+  const disposableComponents = components.some((component) => component.dispose !== void 0);
+  return {
+    sectionSize: options.size,
+    ...components.some((component) => component.focusable === true) ? { focusable: true } : {},
+    render: (viewport) => {
+      if (viewport.height <= 0) {
+        childHeights = options.children.map(() => 0);
+        return [];
+      }
+      childHeights = [
+        ...allocateCampUiSectionRows(
+          viewport.height - 1,
+          options.children.map((child) => child.size)
+        )
+      ];
+      return [
+        renderHeader(options.header(), viewport.width),
+        ...options.children.flatMap((child, index) => {
+          const height = childHeights[index] ?? 0;
+          const lines = child.component.render({ width: viewport.width, height }).slice(0, height);
+          return [...lines, ...Array.from({ length: height - lines.length }, () => "")];
+        })
+      ];
+    },
+    ...inputComponents ? {
+      handleInput: (input) => [...components].reverse().some((component) => component.handleInput?.(input) === true)
+    } : {},
+    ...pointerComponents ? {
+      handlePointer: (pointer) => {
+        const bodyY = pointer.y - 1;
+        if (bodyY < 0) return [];
+        let offset = 0;
+        for (const [index, child] of options.children.entries()) {
+          const height = childHeights[index] ?? 0;
+          if (bodyY >= offset && bodyY < offset + height) {
+            return child.component.handlePointer?.({ ...pointer, y: bodyY - offset }) ?? [];
+          }
+          offset += height;
+        }
+        return [];
+      }
+    } : {},
+    ...invalidatingComponents ? {
+      invalidate: () => {
+        for (const component of components) component.invalidate?.();
+      }
+    } : {},
+    ...disposableComponents ? {
+      dispose: Effect_exports.forEach(
+        [...components].reverse(),
+        (component) => component.dispose ?? Effect_exports.void,
+        { discard: true }
+      )
+    } : {}
+  };
+};
+var decorateDefaultCampUiSections = (context, slots) => {
+  const decorated = new Map(slots);
+  const component = (slotId) => slots.get(slotId) ?? emptyCampUiComponent;
+  decorated.set(
+    CampUiSlot.campHeader,
+    makeCampUiSection({
+      header: () => ({ title: "Camp" }),
+      size: defaultCampUiLeftSectionSizes.camp,
+      children: [
+        {
+          component: component(CampUiSlot.campHeader),
+          size: { kind: CampUiSectionSizeKind.fixed, rows: 2 }
+        },
+        {
+          component: component(CampUiSlot.seat),
+          size: { kind: CampUiSectionSizeKind.grow, weight: 1, minimumRows: 1 }
+        }
+      ]
+    })
+  );
+  decorated.delete(CampUiSlot.seat);
+  decorated.set(
+    CampUiSlot.resources,
+    makeCampUiSection({
+      header: () => ({ title: "Resources" }),
+      size: defaultCampUiLeftSectionSizes.resources,
+      children: [
+        {
+          component: component(CampUiSlot.resources),
+          size: { kind: CampUiSectionSizeKind.grow, weight: 1 }
+        }
+      ]
+    })
+  );
+  decorated.set(
+    CampUiSlot.roster,
+    makeCampUiSection({
+      header: () => ({
+        title: "Workers",
+        detail: String(context.readModel().snapshot.workers.length),
+        focused: context.readModel().state.focusedSlotId === CampUiSlot.roster
+      }),
+      size: defaultCampUiLeftSectionSizes.workers,
+      children: [
+        {
+          component: component(CampUiSlot.roster),
+          size: { kind: CampUiSectionSizeKind.grow, weight: 1 }
+        }
+      ]
+    })
+  );
+  return decorated;
+};
+
+// packages/host-ui/src/pi/mountPiCampUi.ts
+import { initTheme } from "@earendil-works/pi-coding-agent";
+import { ProcessTerminal, TUI } from "@earendil-works/pi-tui";
+
+// packages/host-ui/src/pi/piCampUiRoot.ts
+import { getMarkdownTheme as getMarkdownTheme10 } from "@earendil-works/pi-coding-agent";
+import { Key as Key3, matchesKey as matchesKey3 } from "@earendil-works/pi-tui";
+
+// packages/host-ui/src/pi/runtime/campUiPointerInput.ts
+var CampUiPointerAction = {
+  press: "press",
+  release: "release",
+  wheel: "wheel"
+};
+var CampUiPointerButton = {
+  left: "left",
+  middle: "middle",
+  right: "right"
+};
+var CampUiPointerDirection = {
+  up: "up",
+  down: "down"
+};
+var sgrPointerPattern = /^<(\d+);(\d+);(\d+)([Mm])$/u;
+var parseCampUiPointerInput = (input) => {
+  if (!input.startsWith("\x1B[")) return void 0;
+  const match = sgrPointerPattern.exec(input.slice(2));
+  if (match === null) return void 0;
+  const code = Number(match[1]);
+  const column = Number(match[2]);
+  const row = Number(match[3]);
+  if (!Number.isSafeInteger(code) || column < 1 || row < 1) return void 0;
+  const base = {
+    x: column - 1,
+    y: row - 1,
+    shift: (code & 4) !== 0,
+    alt: (code & 8) !== 0,
+    control: (code & 16) !== 0
+  };
+  if ((code & 64) !== 0) {
+    return {
+      ...base,
+      action: CampUiPointerAction.wheel,
+      direction: (code & 1) === 0 ? CampUiPointerDirection.up : CampUiPointerDirection.down
+    };
+  }
+  const button = [CampUiPointerButton.left, CampUiPointerButton.middle, CampUiPointerButton.right][code & 3];
+  if (button === void 0) return void 0;
+  return {
+    ...base,
+    action: match[4] === "M" ? CampUiPointerAction.press : CampUiPointerAction.release,
+    button
+  };
+};
+
+// packages/host-ui/src/pi/runtime/campUiPointerRouting.ts
+var routeCampUiPointer = (frame, pointer, slots) => {
+  if (frame === void 0) return [];
+  const hit = frame.regions.find(
+    (region2) => pointer.x >= region2.x && pointer.x < region2.x + region2.width && pointer.y >= region2.y && pointer.y < region2.y + region2.height
+  );
+  if (hit === void 0) return [];
+  return slots.get(hit.slotId)?.handlePointer?.({
+    ...pointer,
+    x: pointer.x - hit.x,
+    y: pointer.y - hit.y,
+    mode: frame.mode
+  }) ?? [];
+};
+
+// packages/host-ui/src/pi/piCampUiRoot.ts
+var focusDirectionFromInput = (input) => {
+  if (matchesKey3(input, Key3.left)) return CampUiFocusDirection.left;
+  if (matchesKey3(input, Key3.right)) return CampUiFocusDirection.right;
+  if (matchesKey3(input, Key3.up)) return CampUiFocusDirection.up;
+  return matchesKey3(input, Key3.down) ? CampUiFocusDirection.down : void 0;
+};
+var focusableSlotsInFrame = (frame, slots) => [
+  ...new Set(
+    (frame?.regions ?? []).filter((region2) => slots.get(region2.slotId)?.focusable === true).map((region2) => region2.slotId)
+  )
+];
+var PiCampUiRoot = class {
+  mode = CampUiLayoutMode.narrow;
+  frame;
+  context;
+  slots;
+  layout;
+  getHeight;
+  wheelDirectionFromInput;
+  constructor(context, slots, layout, getHeight, wheelDirectionFromInput) {
+    this.context = context;
+    this.slots = slots;
+    this.layout = layout;
+    this.getHeight = getHeight;
+    this.wheelDirectionFromInput = wheelDirectionFromInput;
+  }
+  render(width) {
+    const height = Math.max(0, this.getHeight());
+    const viewport = { width: Math.max(0, width - 1), height };
+    const frame = this.layout.resolve(viewport, this.context.readModel().state, this.slots);
+    this.frame = frame;
+    this.mode = frame.mode;
+    const state = this.context.readModel().state;
+    const focusOrder = focusableSlotsInFrame(frame, this.slots);
+    if (!focusOrder.includes(state.focusedSlotId)) {
+      const fallback = focusOrder[0];
+      if (fallback !== void 0) this.context.emit(CampUiIntents.FocusSlot({ slotId: fallback }));
+    }
+    const detailVisible = frame.regions.some((region2) => region2.slotId === CampUiSlot.transcript);
+    if (this.context.readModel().state.detailVisible !== detailVisible) {
+      this.context.emit(CampUiIntents.SetTranscriptVisible({ visible: detailVisible }));
+    }
+    const rendered = new Map(
+      frame.regions.map((region2) => [
+        region2,
+        this.slots.get(region2.slotId)?.render({ width: region2.width, height: region2.height }) ?? []
+      ])
+    );
+    return Array.from({ length: height }, (_, row) => {
+      const segments = [];
+      for (const [region2, lines] of rendered) {
+        if (row < region2.y || row >= region2.y + region2.height) continue;
+        segments.push({
+          x: region2.x,
+          width: region2.width,
+          text: lines[row - region2.y] ?? ""
+        });
+      }
+      for (const divider of frame.dividers) {
+        if (row >= divider.y && row < divider.y + divider.height) {
+          segments.push({
+            x: divider.x,
+            width: 1,
+            text: getMarkdownTheme10().codeBlockBorder("\u2502")
+          });
+        }
+      }
+      segments.sort((left, right) => left.x - right.x);
+      let cursor = 0;
+      let line = "";
+      for (const segment of segments) {
+        line += " ".repeat(Math.max(0, segment.x - cursor));
+        line += fitCampUiLine(segment.text, segment.width);
+        cursor = segment.x + segment.width;
+      }
+      return fitCampUiLine(
+        `${line}${" ".repeat(Math.max(0, viewport.width - cursor))}`,
+        viewport.width
+      );
+    });
+  }
+  handleInput(input) {
+    const pointer = parseCampUiPointerInput(input);
+    if (pointer !== void 0) {
+      for (const intent of routeCampUiPointer(this.frame, pointer, this.slots)) {
+        this.context.emit(intent);
+      }
+      return;
+    }
+    const wheelDirection = this.wheelDirectionFromInput?.(input);
+    if (wheelDirection !== void 0) {
+      const model2 = this.context.readModel();
+      const workerId2 = model2.state.selectedWorkerId;
+      const transcriptVisible = this.frame?.regions.some((region2) => region2.slotId === CampUiSlot.transcript) === true;
+      if (workerId2 !== void 0 && transcriptVisible) {
+        this.context.emit(
+          CampUiIntents.ScrollWorker({
+            workerId: workerId2,
+            delta: wheelDirection === "up" ? 3 : -3
+          })
+        );
+      }
+      return;
+    }
+    const model = this.context.readModel();
+    const focusOrder = focusableSlotsInFrame(this.frame, this.slots);
+    const focusedSlotId = focusOrder.includes(model.state.focusedSlotId) ? model.state.focusedSlotId : focusOrder[0] ?? model.state.focusedSlotId;
+    if (focusedSlotId !== model.state.focusedSlotId) {
+      this.context.emit(CampUiIntents.FocusSlot({ slotId: focusedSlotId }));
+    }
+    if (this.slots.get(focusedSlotId)?.handleInput?.(input) === true) return;
+    if (matchesKey3(input, Key3.escape)) {
+      if (focusedSlotId === CampUiSlot.composer) {
+        this.context.emit(CampUiIntents.FocusSlot({ slotId: CampUiSlot.transcript }));
+      } else if (model.state.screen === CampUiScreen.worker) {
+        this.context.emit(CampUiIntents.ActivateScreen({ screen: CampUiScreen.camp }));
+        this.context.emit(CampUiIntents.FocusDetailBlock({}));
+        this.context.emit(CampUiIntents.FocusSlot({ slotId: CampUiSlot.roster }));
+      }
+      return;
+    }
+    if (matchesKey3(input, Key3.tab) || matchesKey3(input, "shift+tab")) {
+      if (focusOrder.length === 0) return;
+      const current = focusOrder.indexOf(focusedSlotId);
+      const delta = matchesKey3(input, "shift+tab") ? -1 : 1;
+      const base = current < 0 ? delta > 0 ? -1 : 0 : current;
+      const next = focusOrder[(base + delta + focusOrder.length) % focusOrder.length];
+      if (next === void 0) return;
+      this.context.emit(CampUiIntents.FocusSlot({ slotId: next }));
+      return;
+    }
+    if (focusedSlotId !== CampUiSlot.composer && input === "n") {
+      this.context.emit(CampUiIntents.NextPendingAsk());
+      return;
+    }
+    if (focusedSlotId === CampUiSlot.transcript && model.state.focusedDetailBlockId !== void 0 && matchesKey3(input, Key3.enter)) {
+      this.context.emit(
+        CampUiIntents.ToggleDetailBlock({ blockId: model.state.focusedDetailBlockId })
+      );
+      return;
+    }
+    if (focusedSlotId === CampUiSlot.roster) {
+      const delta = matchesKey3(input, Key3.up) ? -1 : matchesKey3(input, Key3.down) ? 1 : void 0;
+      if (delta !== void 0) {
+        const current = model.snapshot.workers.findIndex(
+          (worker) => worker.snapshot.worker.id === model.state.selectedWorkerId
+        );
+        const next = current < 0 ? 0 : current + delta;
+        if (next >= 0 && next < model.snapshot.workers.length && next !== current) {
+          this.context.emit(CampUiIntents.SelectRelativeWorker({ delta }));
+          return;
+        }
+      }
+      if (matchesKey3(input, Key3.enter) && model.state.selectedWorkerId !== void 0) {
+        this.context.emit(CampUiIntents.OpenWorker({ workerId: model.state.selectedWorkerId }));
+        this.context.emit(
+          CampUiIntents.FocusSlot({
+            slotId: this.mode === CampUiLayoutMode.wide ? CampUiSlot.composer : CampUiSlot.transcript
+          })
+        );
+        return;
+      }
+    }
+    const workerId = model.state.selectedWorkerId;
+    if (focusedSlotId === CampUiSlot.transcript && workerId !== void 0 && matchesKey3(input, Key3.end)) {
+      this.context.emit(CampUiIntents.JumpToWorkerTail({ workerId }));
+      return;
+    }
+    if (focusedSlotId === CampUiSlot.transcript && workerId !== void 0 && (matchesKey3(input, Key3.pageUp) || matchesKey3(input, Key3.pageDown))) {
+      this.context.emit(
+        CampUiIntents.ScrollWorker({
+          workerId,
+          delta: (matchesKey3(input, Key3.pageUp) ? 1 : -1) * Math.max(
+            1,
+            (this.frame?.regions.find((region2) => region2.slotId === CampUiSlot.transcript)?.height ?? 10) - 2
+          )
+        })
+      );
+      return;
+    }
+    const direction = focusDirectionFromInput(input);
+    if (direction === void 0) return;
+    const target = findCampUiSpatialFocusTarget(
+      this.frame,
+      focusedSlotId,
+      new Set(focusOrder),
+      direction
+    );
+    if (target !== void 0) this.context.emit(CampUiIntents.FocusSlot({ slotId: target }));
+  }
+  invalidate() {
+    for (const component of this.slots.values()) component.invalidate?.();
+  }
+};
+
+// packages/host-ui/src/pi/runtime/campUiPresentationClock.ts
+var hasPendingCampUiAsk = (model) => model.snapshot.workers.some(
+  (worker) => worker.asks.some((ask) => ask.state === CampAskState.pending)
+);
+var runCampUiPresentationClock = (readModel, controller) => Effect_exports.forever(
+  Effect_exports.sleep("1 second").pipe(
+    Effect_exports.zipRight(
+      Effect_exports.suspend(
+        () => hasPendingCampUiAsk(readModel()) ? Clock_exports.currentTimeMillis.pipe(Effect_exports.flatMap(controller.setPresentationNow)) : Effect_exports.void
+      )
+    )
+  )
+);
+
+// packages/host-ui/src/pi/runtime/campUiSubscriptionRetry.ts
+var CAMP_UI_SUBSCRIPTION_MAX_RETRIES = 4;
+var CAMP_UI_SUBSCRIPTION_BASE_DELAY_MS = 250;
+var campUiSubscriptionRetryDelay = (attempt) => CAMP_UI_SUBSCRIPTION_BASE_DELAY_MS * 2 ** Math.max(0, attempt - 1);
+var sameCampUiRuntimeHealth = (left, right) => left.status === right.status && left.operation === right.operation && left.message === right.message && left.attempt === right.attempt && left.nextRetryAt === right.nextRetryAt;
+
+// packages/host-ui/src/pi/runtime/campUiTerminalModes.ts
+var ENTER_ALTERNATE_SCREEN = "\x1B[?1049h";
+var LEAVE_ALTERNATE_SCREEN = "\x1B[?1049l";
+var ENABLE_ALTERNATE_SCROLL = "\x1B[?1007h";
+var DISABLE_ALTERNATE_SCROLL = "\x1B[?1007l";
+var CampUiWheelDirection = {
+  down: "down",
+  up: "up"
+};
+var makeCampUiTerminalModes = (terminal) => {
+  let alternateScreenActive = false;
+  let alternateScrollActive = false;
+  return {
+    enter: () => {
+      if (alternateScreenActive) return;
+      terminal.write(ENTER_ALTERNATE_SCREEN);
+      alternateScreenActive = true;
+    },
+    exit: () => {
+      if (alternateScrollActive) {
+        terminal.write(DISABLE_ALTERNATE_SCROLL);
+        alternateScrollActive = false;
+      }
+      if (alternateScreenActive) {
+        terminal.write(LEAVE_ALTERNATE_SCREEN);
+        alternateScreenActive = false;
+      }
+    },
+    tryEnableAlternateScroll: () => {
+      if (alternateScrollActive) return true;
+      if (!alternateScreenActive || !terminal.kittyProtocolActive) return false;
+      terminal.write(ENABLE_ALTERNATE_SCROLL);
+      alternateScrollActive = true;
+      return true;
+    },
+    wheelDirection: (input) => {
+      if (!alternateScrollActive) return void 0;
+      if (input === "\x1B[A") return CampUiWheelDirection.up;
+      if (input === "\x1B[B") return CampUiWheelDirection.down;
+      return void 0;
+    }
+  };
+};
+
+// packages/host-ui/src/pi/mountPiCampUi.ts
+var mountPiCampUi = (options) => Effect_exports.gen(function* () {
+  const startedAt = yield* Clock_exports.currentTimeMillis;
+  const healthRef = yield* SubscriptionRef_exports.make({
+    status: CampUiRuntimeStatus.starting,
+    operation: "ui.mount",
+    updatedAt: startedAt
+  });
+  const setHealth = (health) => SubscriptionRef_exports.get(healthRef).pipe(
+    Effect_exports.flatMap(
+      (current2) => sameCampUiRuntimeHealth(current2, { ...health, updatedAt: current2.updatedAt }) ? Effect_exports.void : Clock_exports.currentTimeMillis.pipe(
+        Effect_exports.flatMap(
+          (updatedAt) => SubscriptionRef_exports.set(healthRef, { ...health, updatedAt })
+        )
+      )
+    )
+  );
+  yield* Effect_exports.sync(() => initTheme(void 0, false));
+  const initial = yield* options.backend.snapshot;
+  const store = yield* makeCampUiStore(initial, startedAt);
+  let current = yield* store.current;
+  const terminal = options.terminal ?? new ProcessTerminal();
+  const terminalModes = makeCampUiTerminalModes(terminal);
+  yield* Effect_exports.acquireRelease(
+    Effect_exports.sync(() => terminalModes.enter()),
+    () => Effect_exports.sync(() => terminalModes.exit())
+  );
+  const tui = new TUI(terminal, true);
+  const runEffect = yield* FiberSet_exports.makeRuntime();
+  const dispatch = (effect) => {
+    runEffect(
+      effect.pipe(
+        Effect_exports.catchAllCause((cause) => store.controller.setActionError(Cause_exports.pretty(cause)))
+      )
+    );
+  };
+  const router = makeCampUiIntentRouter({
+    backend: options.backend,
+    controller: store.controller,
+    readModel: () => current,
+    dispatch
+  });
+  const context = {
+    readModel: () => current,
+    emit: router.emit
+  };
+  const detailBlocks = yield* composeCampUiDetailBlocks(
+    defaultCampUiDetailBlockRenderers,
+    options.detailBlocks ?? []
+  );
+  const composedSlots = yield* composeCampUiSlots(
+    context,
+    makeDefaultCampUiContributions(tui, detailBlocks),
+    options.contributions ?? []
+  );
+  const slots = decorateDefaultCampUiSections(context, composedSlots);
+  const root = new PiCampUiRoot(
+    context,
+    slots,
+    options.layout ?? makeDefaultCampUiLayout(),
+    () => terminal.rows,
+    terminalModes.wheelDirection
+  );
+  tui.addChild(root);
+  tui.setFocus(root);
+  yield* Effect_exports.sync(() => {
+    terminal.setTitle(initial.displayName);
+    terminal.clearScreen();
+    tui.start();
+  });
+  yield* Effect_exports.addFinalizer(
+    () => Effect_exports.sync(() => {
+      tui.stop();
+      terminal.setProgress(false);
+    }).pipe(
+      Effect_exports.zipRight(setHealth({ status: CampUiRuntimeStatus.stopped, operation: "ui.stop" }))
+    )
+  );
+  yield* Effect_exports.forkScoped(
+    Effect_exports.gen(function* () {
+      for (let attempt = 0; attempt < 25; attempt += 1) {
+        if (yield* Effect_exports.sync(() => terminalModes.tryEnableAlternateScroll())) return;
+        yield* Effect_exports.sleep("10 millis");
+      }
+    })
+  );
+  const fibers = yield* FiberSet_exports.make();
+  yield* FiberSet_exports.run(
+    fibers,
+    store.changes.pipe(
+      Stream_exports.runForEach(
+        (model) => Effect_exports.sync(() => {
+          current = model;
+          tui.requestRender();
+        })
+      )
+    )
+  );
+  yield* FiberSet_exports.run(
+    fibers,
+    runCampUiPresentationClock(() => current, store.controller)
+  );
+  yield* setHealth({ status: CampUiRuntimeStatus.ready, operation: "ui.mount" });
+  const runSubscription = (failures) => options.backend.changes.pipe(
+    Stream_exports.runForEach(
+      (snapshot) => store.updateSnapshot(snapshot).pipe(
+        Effect_exports.zipRight(
+          setHealth({ status: CampUiRuntimeStatus.ready, operation: "ui.subscribe" })
+        ),
+        Effect_exports.zipRight(store.controller.setActionError(void 0))
+      )
+    ),
+    Effect_exports.zipRight(
+      Effect_exports.fail(
+        new Error("Camp UI backend subscription ended before the UI scope was closed")
+      )
+    ),
+    Effect_exports.catchAll((cause) => {
+      const attempt = failures + 1;
+      const message = cause instanceof Error ? cause.message : String(cause);
+      if (attempt > CAMP_UI_SUBSCRIPTION_MAX_RETRIES) {
+        return setHealth({
+          status: CampUiRuntimeStatus.failed,
+          operation: "ui.subscribe",
+          message,
+          attempt
+        }).pipe(Effect_exports.zipRight(store.controller.setActionError(message)));
+      }
+      const delay = campUiSubscriptionRetryDelay(attempt);
+      return Clock_exports.currentTimeMillis.pipe(
+        Effect_exports.flatMap(
+          (now) => setHealth({
+            status: CampUiRuntimeStatus.retrying,
+            operation: "ui.subscribe",
+            message,
+            attempt,
+            nextRetryAt: now + delay
+          })
+        ),
+        Effect_exports.zipRight(store.controller.setActionError(message)),
+        Effect_exports.zipRight(Effect_exports.sleep(delay)),
+        Effect_exports.zipRight(Effect_exports.suspend(() => runSubscription(attempt)))
+      );
+    })
+  );
+  yield* FiberSet_exports.run(fibers, runSubscription(0));
+  tui.requestRender(true);
+  return {
+    controller: store.controller,
+    tui,
+    health: { current: SubscriptionRef_exports.get(healthRef), changes: healthRef.changes }
+  };
+});
+
+// packages/host-ui/src/run-selector/campRunSelector.ts
+import { getMarkdownTheme as getMarkdownTheme11, getSelectListTheme as getSelectListTheme12, initTheme as initTheme2 } from "@earendil-works/pi-coding-agent";
+import {
+  Key as Key4,
+  matchesKey as matchesKey4,
+  ProcessTerminal as ProcessTerminal2,
+  TUI as TUI2
+} from "@earendil-works/pi-tui";
+var PiCampRunSelectorRoot = class {
+  selectedIndex = 0;
+  items;
+  getHeight;
+  select;
+  requestRender;
+  constructor(items, getHeight, select, requestRender) {
+    this.items = items;
+    this.getHeight = getHeight;
+    this.select = select;
+    this.requestRender = requestRender;
+  }
+  render(width) {
+    const height = Math.max(0, this.getHeight());
+    const viewportWidth = Math.max(0, width - 1);
+    const markdown = getMarkdownTheme11();
+    const selection = getSelectListTheme12();
+    const header = `${markdown.codeBlockBorder("\u2500\u2500")} ${markdown.heading("Resume camp")} ${markdown.codeBlockBorder("\u2500".repeat(Math.max(0, viewportWidth - 16)))}`;
+    const available = Math.max(0, height - 2);
+    const capacity = Math.max(1, Math.floor(available / 2));
+    const start = Math.min(
+      Math.max(0, this.selectedIndex - Math.floor(capacity / 2)),
+      Math.max(0, this.items.length - capacity)
+    );
+    const visibleItems = this.items.slice(start, start + capacity);
+    const rows2 = visibleItems.flatMap((item, index) => {
+      const selected = start + index === this.selectedIndex;
+      const prefix = selected ? selection.selectedPrefix("\u25CF ") : "  ";
+      const title = selected ? selection.selectedText(item.runId) : item.runId;
+      const details = selection.description(
+        `${item.lifecycle} \xB7 ${String(item.workerCount)} workers \xB7 ${item.updatedAt}`
+      );
+      return [
+        fitCampUiLine(`${prefix}${title}`, viewportWidth),
+        fitCampUiLine(`  ${details}`, viewportWidth)
+      ];
+    });
+    const content = [fitCampUiLine(header, viewportWidth), "", ...rows2].slice(0, height);
+    return [...content, ...Array.from({ length: Math.max(0, height - content.length) }, () => "")];
+  }
+  handleInput(input) {
+    if (matchesKey4(input, Key4.escape) || input === "q") {
+      this.select(void 0);
+      return;
+    }
+    if (matchesKey4(input, Key4.enter)) {
+      this.select(this.items[this.selectedIndex]?.runId);
+      return;
+    }
+    const delta = matchesKey4(input, Key4.up) ? -1 : matchesKey4(input, Key4.down) ? 1 : 0;
+    if (delta === 0 || this.items.length === 0) return;
+    this.selectedIndex = (this.selectedIndex + delta + this.items.length) % this.items.length;
+    this.requestRender();
+  }
+  invalidate() {
+  }
+};
+var selectCampRun = (options) => Effect_exports.scoped(
+  Effect_exports.gen(function* () {
+    yield* Effect_exports.sync(() => initTheme2(void 0, false));
+    const selected = yield* Deferred_exports.make();
+    const terminal = options.terminal ?? new ProcessTerminal2();
+    const modes = makeCampUiTerminalModes(terminal);
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(() => modes.enter()),
+      () => Effect_exports.sync(() => modes.exit())
+    );
+    const tui = new TUI2(terminal, true);
+    const root = new PiCampRunSelectorRoot(
+      options.items,
+      () => terminal.rows,
+      (runId) => {
+        Effect_exports.runFork(Deferred_exports.succeed(selected, runId));
+      },
+      () => tui.requestRender()
+    );
+    tui.addChild(root);
+    tui.setFocus(root);
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(() => {
+        terminal.setTitle("Resume camp");
+        terminal.clearScreen();
+        tui.start();
+        tui.requestRender(true);
+      }),
+      () => Effect_exports.sync(() => tui.stop())
+    );
+    return yield* Deferred_exports.await(selected);
+  })
+);
+
+// packages/host-ui/src/index.ts
+var PACKAGE = "@priiisk/host-ui";
+
+export {
+  CampUiBackendError,
+  CampUiBackend,
+  CampUiPlacement,
+  CampUiHealthStatus,
+  CampUiScreen,
+  campUiAskBlockId,
+  makeInitialCampUiState,
+  makeCampUiModel,
+  findCampUiWorker,
+  CampUiControllerError,
+  makeCampUiStore,
+  makeCampUiComponentGroup,
+  emptyCampUiComponent,
+  CampUiSlot,
+  CampUiContributionStrategy,
+  CampUiCompositionError,
+  composeCampUiSlots,
+  composeCampUiDetailBlocks,
+  renderCampUiDetailBlocks,
+  renderCampUiDetailBlockLayout,
+  campUiPendingAskTargets,
+  nextCampUiPendingAskTarget,
+  CampUiIntents,
+  makeCampUiIntentHandler,
+  makeCampUiIntentRouter,
+  CampUiFocusDirection,
+  findCampUiSpatialFocusTarget,
+  defaultCampUiLayoutPolicy,
+  CampUiSectionSizeKind,
+  allocateCampUiSectionRows,
+  defaultCampUiLeftSectionSizes,
+  CampUiLayoutMode,
+  makeDefaultCampUiLayout,
+  CampUiRuntimeStatus,
+  hasCampUiTextContent,
+  fitCampUiLine,
+  fitCampUiLines,
+  joinCampUiColumns,
+  jsonText,
+  compactNumber,
+  CampUiTone,
+  CampUiGlyph,
+  styleCampUiTone,
+  uniqueCampUiNames,
+  renderCampUiStatus,
+  renderCampUiState,
+  renderCampUiWorkerState,
+  renderSelectedCampUiRow,
+  DEFAULT_DIRECTED_BLOCK_BODY_LINES,
+  formatCampUiDuration,
+  renderCampUiDirectedBlock,
+  campUiPendingAskBlockRenderer,
+  CampUiAssistantMessage,
+  makeCampUiComposerComponent,
+  campUiEquipmentBlockRenderer,
+  renderCampUiPanel,
+  CAMP_UI_DEFAULT_TOOL_PREVIEW_LINES,
+  CAMP_UI_BASH_PREVIEW_LINES,
+  renderCampUiToolResult,
+  campUiTranscriptBlockRenderer,
+  defaultCampUiDetailBlockRenderers,
+  makeCampUiDetailComponent,
+  makeDefaultCampUiContributions,
+  makeCampUiSection,
+  decorateDefaultCampUiSections,
+  PiCampUiRoot,
+  hasPendingCampUiAsk,
+  runCampUiPresentationClock,
+  CAMP_UI_SUBSCRIPTION_MAX_RETRIES,
+  CAMP_UI_SUBSCRIPTION_BASE_DELAY_MS,
+  campUiSubscriptionRetryDelay,
+  sameCampUiRuntimeHealth,
+  mountPiCampUi,
+  PiCampRunSelectorRoot,
+  selectCampRun,
+  PACKAGE
+};