@spekn/cli 1.0.1 → 1.0.3

package/dist/tui/chunk-SHJNIAAJ.mjs

@@ -0,0 +1,1697 @@
+import {
+  OrganizationPlan,
+  WorkflowPhase,
+  __name,
+  appendGlobalStructuredLog,
+  getClient,
+  getService,
+  persistProjectContext,
+  setClient
+} from "./chunk-YUYJ7VBG.mjs";
+
+// src/store/use-session-store.ts
+import { create as create6 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector6 } from "zustand/middleware";
+
+// src/store/use-tui-ui-store.ts
+import { create } from "zustand";
+import { subscribeWithSelector } from "zustand/middleware";
+var _initialScreen = "home";
+function setInitialScreen(screen) {
+  _initialScreen = screen;
+}
+__name(setInitialScreen, "setInitialScreen");
+var initialState = {
+  screen: _initialScreen,
+  showHelp: false,
+  commandMode: false,
+  searchQuery: "",
+  navMode: "content",
+  cursorSpec: null,
+  cursorDecision: null,
+  openedSpecId: void 0,
+  editorMenuOpen: false,
+  statusMenuOpen: false,
+  aiRefineMenuOpen: false,
+  editorLaunching: false,
+  selectedEditor: "",
+  selectedOrganizationIndex: void 0,
+  selectedProjectIndex: void 0,
+  newProjectName: void 0,
+  generationPanelOpen: false,
+  generationPanelSpecId: void 0,
+  selectedAnalysisAgent: "auto"
+};
+var useTuiUiStore = create()(subscribeWithSelector((set) => ({
+  ...initialState,
+  screen: _initialScreen,
+  setScreen: /* @__PURE__ */ __name((screen) => set({
+    screen
+  }), "setScreen"),
+  toggleHelp: /* @__PURE__ */ __name(() => set((prev) => ({
+    showHelp: !prev.showHelp
+  })), "toggleHelp"),
+  setShowHelp: /* @__PURE__ */ __name((show) => set({
+    showHelp: show
+  }), "setShowHelp"),
+  setCommandMode: /* @__PURE__ */ __name((enabled) => set({
+    commandMode: enabled
+  }), "setCommandMode"),
+  setSearchQuery: /* @__PURE__ */ __name((query) => set({
+    searchQuery: query
+  }), "setSearchQuery"),
+  setNavMode: /* @__PURE__ */ __name((mode) => set({
+    navMode: mode
+  }), "setNavMode"),
+  setCursorSpec: /* @__PURE__ */ __name((spec) => set({
+    cursorSpec: spec
+  }), "setCursorSpec"),
+  setCursorDecision: /* @__PURE__ */ __name((decision) => set({
+    cursorDecision: decision
+  }), "setCursorDecision"),
+  setOpenedSpecId: /* @__PURE__ */ __name((specId) => set({
+    openedSpecId: specId
+  }), "setOpenedSpecId"),
+  setSelectedEditor: /* @__PURE__ */ __name((editor) => set({
+    selectedEditor: editor
+  }), "setSelectedEditor"),
+  setEditorMenuOpen: /* @__PURE__ */ __name((open) => set({
+    editorMenuOpen: open
+  }), "setEditorMenuOpen"),
+  setStatusMenuOpen: /* @__PURE__ */ __name((open) => set({
+    statusMenuOpen: open
+  }), "setStatusMenuOpen"),
+  setAiRefineMenuOpen: /* @__PURE__ */ __name((open) => set({
+    aiRefineMenuOpen: open
+  }), "setAiRefineMenuOpen"),
+  setEditorLaunching: /* @__PURE__ */ __name((launching) => set({
+    editorLaunching: launching
+  }), "setEditorLaunching"),
+  openEditorMenuForSpec: /* @__PURE__ */ __name((specId, editor) => set({
+    openedSpecId: specId,
+    selectedEditor: editor,
+    editorMenuOpen: true
+  }), "openEditorMenuForSpec"),
+  resetSpecsUi: /* @__PURE__ */ __name(() => set({
+    openedSpecId: void 0,
+    cursorSpec: null,
+    editorMenuOpen: false,
+    statusMenuOpen: false,
+    aiRefineMenuOpen: false,
+    editorLaunching: false,
+    generationPanelOpen: false,
+    generationPanelSpecId: void 0
+  }), "resetSpecsUi"),
+  setSelectedOrganizationIndex: /* @__PURE__ */ __name((index) => set({
+    selectedOrganizationIndex: index
+  }), "setSelectedOrganizationIndex"),
+  setSelectedProjectIndex: /* @__PURE__ */ __name((index) => set({
+    selectedProjectIndex: index
+  }), "setSelectedProjectIndex"),
+  setNewProjectName: /* @__PURE__ */ __name((name) => set({
+    newProjectName: name
+  }), "setNewProjectName"),
+  setSelectedAnalysisAgent: /* @__PURE__ */ __name((agent) => set({
+    selectedAnalysisAgent: agent
+  }), "setSelectedAnalysisAgent"),
+  resetOnboardingUi: /* @__PURE__ */ __name(() => set({
+    selectedOrganizationIndex: void 0,
+    selectedProjectIndex: void 0,
+    newProjectName: void 0,
+    selectedAnalysisAgent: "auto"
+  }), "resetOnboardingUi"),
+  setGenerationPanelOpen: /* @__PURE__ */ __name((open, specId) => set({
+    generationPanelOpen: open,
+    generationPanelSpecId: specId
+  }), "setGenerationPanelOpen"),
+  showTooltip: /* @__PURE__ */ __name((message, duration = 3e3) => set((state) => {
+    if (state.tooltipTimeout) {
+      clearTimeout(state.tooltipTimeout);
+    }
+    const timeout = setTimeout(() => {
+      useTuiUiStore.getState().clearTooltip();
+    }, duration);
+    return {
+      tooltip: message,
+      tooltipTimeout: timeout
+    };
+  }), "showTooltip"),
+  clearTooltip: /* @__PURE__ */ __name(() => set((state) => {
+    if (state.tooltipTimeout) {
+      clearTimeout(state.tooltipTimeout);
+    }
+    return {
+      tooltip: void 0,
+      tooltipTimeout: void 0
+    };
+  }), "clearTooltip")
+})));
+
+// src/capabilities/policy.ts
+var TIER_ORDER = {
+  [OrganizationPlan.FREE]: 0,
+  [OrganizationPlan.PRO]: 1,
+  [OrganizationPlan.TEAM]: 2,
+  [OrganizationPlan.ENTERPRISE]: 3
+};
+var NAV_DEFINITIONS = [
+  {
+    id: "home",
+    label: "Home",
+    description: "Next actions and workflow pulse",
+    requiredPlan: OrganizationPlan.FREE
+  },
+  {
+    id: "specs",
+    label: "Specs",
+    description: "Manage governed specifications",
+    requiredPlan: OrganizationPlan.FREE
+  },
+  {
+    id: "decisions",
+    label: "Decision Log",
+    description: "Review decisions and rationale",
+    requiredPlan: OrganizationPlan.FREE
+  },
+  {
+    id: "export",
+    label: "Export",
+    description: "Generate AGENTS.md / CLAUDE.md / .cursorrules",
+    requiredPlan: OrganizationPlan.FREE
+  },
+  {
+    id: "bridge",
+    label: "Local Bridge",
+    description: "Bridge status and controls",
+    requiredPlan: OrganizationPlan.FREE
+  },
+  {
+    id: "active-runs",
+    label: "Active Runs",
+    description: "Realtime orchestration dashboard",
+    requiredPlan: OrganizationPlan.TEAM
+  },
+  {
+    id: "phase-gates",
+    label: "Phase Gates",
+    description: "Approve and unblock workflow phases",
+    requiredPlan: OrganizationPlan.TEAM
+  },
+  {
+    id: "skills-marketplace",
+    label: "Skills Marketplace",
+    description: "Manage shared managed skills",
+    requiredPlan: OrganizationPlan.TEAM
+  },
+  {
+    id: "org-governance",
+    label: "Org Governance",
+    description: "Compliance, policy, deployment gates",
+    requiredPlan: OrganizationPlan.ENTERPRISE
+  }
+];
+var GATE_DISABLED_PHASES = [
+  WorkflowPhase.SPECIFY,
+  WorkflowPhase.CLARIFY
+];
+function meetsMinimumTier(current, required) {
+  return TIER_ORDER[current] >= TIER_ORDER[required];
+}
+__name(meetsMinimumTier, "meetsMinimumTier");
+function resolveNavPolicy(ctx) {
+  return NAV_DEFINITIONS.map((item) => {
+    if (!meetsMinimumTier(ctx.plan, item.requiredPlan)) {
+      return {
+        ...item,
+        state: "locked",
+        reason: `Requires ${item.requiredPlan.toUpperCase()} tier`
+      };
+    }
+    if (item.id === "phase-gates" && ctx.role === "viewer") {
+      return {
+        ...item,
+        state: "disabled",
+        reason: "Viewer role cannot approve gates"
+      };
+    }
+    if (item.id === "phase-gates" && ctx.workflowPhase && GATE_DISABLED_PHASES.includes(ctx.workflowPhase)) {
+      return {
+        ...item,
+        state: "disabled",
+        reason: `Gate approvals are unavailable in ${ctx.workflowPhase} phase`
+      };
+    }
+    return {
+      ...item,
+      state: "enabled"
+    };
+  });
+}
+__name(resolveNavPolicy, "resolveNavPolicy");
+
+// src/state/onboarding-utils.ts
+function logOnboardingAttachResult(appendLog, result) {
+  if (result.warning) {
+    appendLog(`[warn] ${result.warning}`);
+  }
+  if (result.analyzed) {
+    appendLog("[setup] Repository attached and analysis complete.");
+  } else if (result.warning) {
+    appendLog("[setup] Repository attached; analysis did not fully complete.");
+  } else {
+    appendLog("[setup] Repository already attached. Metadata sync complete (analysis skipped).");
+  }
+}
+__name(logOnboardingAttachResult, "logOnboardingAttachResult");
+
+// src/store/windows/use-onboarding-window.ts
+import { create as create2 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector2 } from "zustand/middleware";
+var useOnboardingWindow = create2()(subscribeWithSelector2((set) => ({
+  mode: "initial-setup",
+  step: "organization",
+  attachCurrentFolder: true,
+  runLines: [],
+  runStatus: "running",
+  startedAt: null,
+  availableAgents: [],
+  canCreateProject: false,
+  toolCalls: {},
+  setMode: /* @__PURE__ */ __name((mode) => set({
+    mode
+  }), "setMode"),
+  setStep: /* @__PURE__ */ __name((step) => set({
+    step
+  }), "setStep"),
+  setSelectedOrganizationIndex: /* @__PURE__ */ __name((index) => set({
+    selectedOrganizationIndex: index
+  }), "setSelectedOrganizationIndex"),
+  setSelectedProjectIndex: /* @__PURE__ */ __name((index) => set({
+    selectedProjectIndex: index
+  }), "setSelectedProjectIndex"),
+  setNewProjectName: /* @__PURE__ */ __name((name) => set({
+    newProjectName: name
+  }), "setNewProjectName"),
+  setAttachCurrentFolder: /* @__PURE__ */ __name((attach) => set({
+    attachCurrentFolder: attach
+  }), "setAttachCurrentFolder"),
+  setRunLines: /* @__PURE__ */ __name((lines) => set({
+    runLines: lines
+  }), "setRunLines"),
+  addRunLine: /* @__PURE__ */ __name((line) => set((state) => ({
+    runLines: [
+      ...state.runLines,
+      line
+    ].slice(-400)
+  })), "addRunLine"),
+  setRunStatus: /* @__PURE__ */ __name((status) => set({
+    runStatus: status
+  }), "setRunStatus"),
+  setStartedAt: /* @__PURE__ */ __name((ts) => set({
+    startedAt: ts
+  }), "setStartedAt"),
+  setInteraction: /* @__PURE__ */ __name((interaction) => set({
+    interaction
+  }), "setInteraction"),
+  setError: /* @__PURE__ */ __name((error) => set({
+    error
+  }), "setError"),
+  setSelectedOrganizationId: /* @__PURE__ */ __name((id) => set({
+    selectedOrganizationId: id
+  }), "setSelectedOrganizationId"),
+  setSelectedProjectId: /* @__PURE__ */ __name((id) => set({
+    selectedProjectId: id
+  }), "setSelectedProjectId"),
+  setAvailableAgents: /* @__PURE__ */ __name((agents) => set({
+    availableAgents: agents
+  }), "setAvailableAgents"),
+  setCanCreateProject: /* @__PURE__ */ __name((canCreate) => set({
+    canCreateProject: canCreate
+  }), "setCanCreateProject"),
+  upsertToolCall: /* @__PURE__ */ __name((event) => set((state) => {
+    const id = event.toolCallId ?? `tc-${Date.now()}`;
+    const existing = state.toolCalls[id];
+    const updated = existing ? {
+      ...existing,
+      status: event.status ?? existing.status,
+      title: event.title ?? existing.title,
+      locations: event.locations ?? existing.locations,
+      completedAt: event.status === "completed" || event.status === "failed" ? Date.now() : existing.completedAt
+    } : {
+      toolCallId: id,
+      title: event.title ?? event.toolName ?? "Tool call",
+      toolName: event.toolName,
+      kind: event.kind ?? "other",
+      status: event.status ?? "in_progress",
+      locations: event.locations ?? [],
+      startedAt: Date.now()
+    };
+    return {
+      toolCalls: {
+        ...state.toolCalls,
+        [id]: updated
+      }
+    };
+  }), "upsertToolCall"),
+  setActiveThought: /* @__PURE__ */ __name((text) => set({
+    activeThought: text
+  }), "setActiveThought"),
+  reset: /* @__PURE__ */ __name(() => set({
+    mode: "initial-setup",
+    step: "organization",
+    selectedOrganizationIndex: void 0,
+    selectedProjectIndex: void 0,
+    newProjectName: void 0,
+    attachCurrentFolder: true,
+    runLines: [],
+    runStatus: "running",
+    startedAt: null,
+    interaction: void 0,
+    error: void 0,
+    selectedOrganizationId: void 0,
+    selectedProjectId: void 0,
+    availableAgents: [],
+    canCreateProject: false,
+    toolCalls: {},
+    activeThought: void 0
+  }), "reset")
+})));
+
+// src/store/auth-utils.ts
+function isAuthenticationError(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("authentication required") || normalized.includes("no valid credentials") || normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("invalid token") || normalized.includes("token expired") || normalized.includes("auth");
+}
+__name(isAuthenticationError, "isAuthenticationError");
+
+// src/store/use-project-data-store.ts
+import { create as create3 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector3 } from "zustand/middleware";
+var EMPTY_WORKFLOW = {
+  currentPhase: null,
+  blockedCount: 0,
+  hasPlanningArtifacts: false,
+  hasVerificationEvidence: false
+};
+var useProjectDataStore = create3()(subscribeWithSelector3((set, get) => ({
+  specs: [],
+  decisions: [],
+  workflow: EMPTY_WORKFLOW,
+  navPolicy: [],
+  specGenerations: {},
+  activeGenerationId: null,
+  setProjectData: /* @__PURE__ */ __name((specs, decisions, workflow, navPolicy) => set({
+    specs,
+    decisions,
+    workflow,
+    navPolicy
+  }), "setProjectData"),
+  setPollingData: /* @__PURE__ */ __name((workflow, navPolicy) => set({
+    workflow,
+    navPolicy
+  }), "setPollingData"),
+  clearProjectData: /* @__PURE__ */ __name(() => set({
+    specs: [],
+    decisions: [],
+    workflow: EMPTY_WORKFLOW,
+    navPolicy: [],
+    specGenerations: {},
+    activeGenerationId: null
+  }), "clearProjectData"),
+  updateSpecificationContent: /* @__PURE__ */ __name(async (specificationId, content) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) return;
+    await withSessionFeedback({
+      statusLine: "Saving specification...",
+      action: /* @__PURE__ */ __name(() => getService().updateSpecificationContent(client, boot.projectId, specificationId, content), "action"),
+      successLog: "[specs] saved specification changes",
+      failureLog: "[error] save failed",
+      failureStatusLine: "Save failed"
+    });
+  }, "updateSpecificationContent"),
+  updateSpecificationStatus: /* @__PURE__ */ __name(async (specificationId, status, options) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) return;
+    setSessionStatusLine(`Updating status to ${status}...`);
+    try {
+      await getService().updateSpecificationStatus(client, boot.projectId, specificationId, status);
+      appendSessionLog(`[specs] status updated to ${status}`);
+      if (options?.refresh !== false) {
+        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-VOK5ML5J.mjs");
+        await useSessionStore2.getState().refresh();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[error] status update failed: ${message}`);
+      setSessionStatusLine("Status update failed");
+      refreshOnAuthenticationError(message);
+    }
+  }, "updateSpecificationStatus"),
+  deleteSpecification: /* @__PURE__ */ __name(async (specificationId, mode = "archive", options) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) return;
+    setSessionStatusLine(mode === "delete" ? "Deleting specification permanently..." : "Archiving specification...");
+    try {
+      await getService().deleteSpecification(client, boot.projectId, specificationId, mode);
+      appendSessionLog(mode === "delete" ? "[specs] specification deleted permanently" : "[specs] specification archived");
+      if (options?.refresh !== false) {
+        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-VOK5ML5J.mjs");
+        await useSessionStore2.getState().refresh();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[error] specification ${mode === "delete" ? "delete" : "archive"} failed: ${message}`);
+      setSessionStatusLine(mode === "delete" ? "Permanent delete failed" : "Archive failed");
+      refreshOnAuthenticationError(message);
+    }
+  }, "deleteSpecification"),
+  refineSpecificationWithAi: /* @__PURE__ */ __name(async (specificationId, userMessage) => {
+    const client = getClient();
+    const boot = getBootContext();
+    const { specs } = get();
+    if (!client || !boot) return;
+    const spec = specs.find((item) => item.id === specificationId);
+    if (!spec) {
+      appendSessionLog("[error] refine failed: specification not found in current list");
+      setSessionStatusLine("Refinement failed");
+      return;
+    }
+    const specContent = (spec.content ?? "").trim();
+    if (!specContent) {
+      appendSessionLog("[error] refine failed: selected specification has no content");
+      setSessionStatusLine("Refinement failed");
+      return;
+    }
+    setSessionStatusLine("Refining specification with AI...");
+    const service = getService();
+    try {
+      const refinedContent = await service.refineSpecificationWithAi(client, {
+        projectId: boot.projectId,
+        specContent,
+        userMessage,
+        agentType: "codex"
+      });
+      await service.updateSpecificationContent(client, boot.projectId, specificationId, refinedContent);
+      appendSessionLog("[specs] AI refinement applied and saved");
+      const { useSessionStore: useSessionStore2 } = await import("./use-session-store-VOK5ML5J.mjs");
+      await useSessionStore2.getState().refresh();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[error] AI refinement failed: ${message}`);
+      setSessionStatusLine("AI refinement failed");
+      refreshOnAuthenticationError(message);
+    }
+  }, "refineSpecificationWithAi"),
+  resolveDecision: /* @__PURE__ */ __name(async (decisionId, status, reason, existingRationale, options) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) {
+      throw new Error("Decision update unavailable: project context is not initialized.");
+    }
+    setSessionStatusLine(`Resolving decision as ${status}...`);
+    try {
+      await getService().resolveDecision(client, boot.projectId, decisionId, status, reason, existingRationale);
+      appendSessionLog(`[decisions] ${decisionId} -> ${status}`);
+      if (options?.refresh !== false) {
+        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-VOK5ML5J.mjs");
+        await useSessionStore2.getState().refresh();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[error] decision resolution failed: ${message}`);
+      setSessionStatusLine("Decision resolution failed");
+      refreshOnAuthenticationError(message);
+      throw error;
+    }
+  }, "resolveDecision"),
+  deleteDecision: /* @__PURE__ */ __name(async (decisionId, mode = "archive", options) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) {
+      throw new Error("Decision delete unavailable: project context is not initialized.");
+    }
+    setSessionStatusLine(mode === "delete" ? "Deleting decision permanently..." : "Archiving decision...");
+    try {
+      await getService().deleteDecision(client, boot.projectId, decisionId, mode);
+      appendSessionLog(mode === "delete" ? `[decisions] ${decisionId} deleted permanently` : `[decisions] ${decisionId} archived`);
+      if (options?.refresh !== false) {
+        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-VOK5ML5J.mjs");
+        await useSessionStore2.getState().refresh();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[error] decision ${mode === "delete" ? "delete" : "archive"} failed: ${message}`);
+      setSessionStatusLine(mode === "delete" ? "Permanent delete failed" : "Archive failed");
+      refreshOnAuthenticationError(message);
+      throw error;
+    }
+  }, "deleteDecision"),
+  loadGenerations: /* @__PURE__ */ __name(async (specId) => {
+    const client = getClient();
+    const boot = getBootContext();
+    if (!client || !boot) return;
+    try {
+      const gens = await getService().listGenerations(client, boot.projectId, specId);
+      set((state) => ({
+        specGenerations: {
+          ...state.specGenerations,
+          [specId]: gens.map((g) => ({
+            id: g.id,
+            generationNumber: g.generationNumber,
+            status: g.status,
+            createdBy: g.createdBy ?? "",
+            createdAt: g.createdAt ?? "",
+            lockedBy: g.lockedBy,
+            lockedAt: g.lockedAt,
+            qualityScore: g.qualityScore,
+            qualityGrade: g.qualityGrade,
+            content: g.content
+          }))
+        }
+      }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendSessionLog(`[specs] failed to load generations: ${message}`);
+      refreshOnAuthenticationError(message);
+    }
+  }, "loadGenerations"),
+  setActiveGenerationId: /* @__PURE__ */ __name((genId) => set({
+    activeGenerationId: genId
+  }), "setActiveGenerationId")
+})));
+
+// src/store/use-export-store.ts
+import { create as create4 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector4 } from "zustand/middleware";
+
+// src/utils/clipboard.ts
+import { spawnSync } from "child_process";
+function clipboardAttempts() {
+  if (process.platform === "darwin") {
+    return [
+      {
+        cmd: "pbcopy",
+        args: []
+      }
+    ];
+  }
+  if (process.platform === "win32") {
+    return [
+      {
+        cmd: "clip",
+        args: []
+      }
+    ];
+  }
+  return [
+    {
+      cmd: "wl-copy",
+      args: []
+    },
+    {
+      cmd: "xclip",
+      args: [
+        "-selection",
+        "clipboard"
+      ]
+    },
+    {
+      cmd: "xsel",
+      args: [
+        "--clipboard",
+        "--input"
+      ]
+    }
+  ];
+}
+__name(clipboardAttempts, "clipboardAttempts");
+function copyTextToClipboard(text) {
+  const attempts = clipboardAttempts();
+  let lastError = "No clipboard command available.";
+  for (const attempt of attempts) {
+    const result = spawnSync(attempt.cmd, attempt.args, {
+      input: text,
+      encoding: "utf8",
+      stdio: [
+        "pipe",
+        "ignore",
+        "pipe"
+      ]
+    });
+    if (!result.error && result.status === 0) {
+      return {
+        ok: true
+      };
+    }
+    lastError = (result.error?.message ?? result.stderr?.trim()) || `${attempt.cmd} exited with status ${result.status}`;
+  }
+  return {
+    ok: false,
+    error: lastError
+  };
+}
+__name(copyTextToClipboard, "copyTextToClipboard");
+
+// src/store/use-export-store.ts
+var EMPTY_EXPORT_JOB = {
+  action: null,
+  status: "idle"
+};
+async function runExport(action) {
+  const state = useExportStore.getState();
+  const boot = getBootContext();
+  if (!boot) return;
+  if (state.exportInFlight) {
+    appendSessionLog("[warn] Export already in progress");
+    return;
+  }
+  const format = state.exportFormat;
+  useExportStore.setState({
+    exportInFlight: true,
+    exportJob: {
+      action,
+      status: "running",
+      format
+    }
+  });
+  setSessionStatusLine(action === "preview" ? "Previewing export..." : "Generating export...");
+  const service = getService();
+  const client = getClient();
+  try {
+    if (action === "status") {
+      const status = await service.exportStatus(boot.projectId, format, {
+        mode: state.exportMode,
+        scopePath: state.exportScopePath || void 0,
+        organizationId: boot.organizationId
+      });
+      useExportStore.setState({
+        exportStatus: status,
+        exportJob: {
+          action,
+          status: "success",
+          format
+        }
+      });
+      setSessionStatusLine(`Export status: ${status.overall}`);
+      appendSessionLog(`[export] Status ${format}: ${status.overall}`);
+      return;
+    }
+    if (action === "commit" || action === "pr") {
+      const delivery = action === "commit" ? "commit" : "pr";
+      const result = await service.deliverExport(boot.projectId, format, delivery, {
+        mode: state.exportMode,
+        scopePath: state.exportScopePath || void 0,
+        organizationId: boot.organizationId
+      });
+      useExportStore.setState({
+        exportJob: {
+          action,
+          status: "success",
+          format
+        }
+      });
+      setSessionStatusLine(result.message);
+      appendSessionLog(`[export] ${result.message}`);
+      return;
+    }
+    const output = action === "preview" ? await service.previewExport(client, boot.projectId, format) : await service.generateExport(client, boot.projectId, format);
+    useExportStore.setState({
+      exportPreview: output,
+      exportJob: {
+        action,
+        status: "success",
+        format
+      }
+    });
+    setSessionStatusLine(action === "preview" ? "Export preview ready" : "Export generated");
+    const verb = action === "preview" ? "Previewed" : "Generated";
+    appendSessionLog(`[export] ${verb} ${format} (${output.anchorCount} anchors)`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    useExportStore.setState({
+      exportJob: {
+        action,
+        status: "error",
+        format,
+        error: message
+      }
+    });
+    setSessionStatusLine(action === "preview" ? "Export preview failed" : "Export generation failed");
+    appendSessionLog(`[error] Export ${action} failed: ${message}`);
+    refreshOnAuthenticationError(message);
+  } finally {
+    useExportStore.setState({
+      exportInFlight: false
+    });
+  }
+}
+__name(runExport, "runExport");
+var useExportStore = create4()(subscribeWithSelector4((set, get) => ({
+  exportFormat: "agents-md",
+  exportMode: "global",
+  exportScopePath: "",
+  exportDelivery: "download",
+  exportCapabilities: null,
+  exportPreview: null,
+  exportStatus: null,
+  exportValidation: {
+    open: false
+  },
+  exportJob: EMPTY_EXPORT_JOB,
+  exportInFlight: false,
+  setCapabilities: /* @__PURE__ */ __name((capabilities) => {
+    set((prev) => {
+      const discoveredFormats = capabilities?.formats?.map((f) => f.id) ?? [];
+      const discoveredModes = capabilities?.modes ?? [];
+      const resolvedFormat = discoveredFormats.length > 0 ? discoveredFormats.includes(prev.exportFormat) ? prev.exportFormat : discoveredFormats[0] : prev.exportFormat;
+      const resolvedMode = discoveredModes.length > 0 ? discoveredModes.includes(prev.exportMode) ? prev.exportMode : discoveredModes[0] : prev.exportMode;
+      return {
+        exportCapabilities: capabilities,
+        exportFormat: resolvedFormat,
+        exportMode: resolvedMode
+      };
+    });
+  }, "setCapabilities"),
+  setExportFormat: /* @__PURE__ */ __name((format) => {
+    set((prev) => {
+      const allowedFormats = prev.exportCapabilities?.formats.map((f) => f.id) ?? [];
+      if (allowedFormats.length > 0 && !allowedFormats.includes(format)) {
+        setSessionStatusLine(`Export format unavailable: ${format}`);
+        return prev;
+      }
+      if (prev.exportFormat === format) return prev;
+      setSessionStatusLine(`Export format set to ${format}`);
+      return {
+        exportFormat: format,
+        exportPreview: null,
+        exportStatus: null,
+        exportValidation: {
+          open: false
+        },
+        exportJob: EMPTY_EXPORT_JOB
+      };
+    });
+  }, "setExportFormat"),
+  setExportMode: /* @__PURE__ */ __name((mode) => {
+    set((prev) => {
+      const allowedModes = prev.exportCapabilities?.modes ?? [];
+      if (allowedModes.length > 0 && !allowedModes.includes(mode)) {
+        setSessionStatusLine(`Export mode unavailable: ${mode}`);
+        return prev;
+      }
+      setSessionStatusLine(`Export mode set to ${mode}`);
+      return {
+        exportMode: mode
+      };
+    });
+  }, "setExportMode"),
+  setExportScopePath: /* @__PURE__ */ __name((scopePath) => {
+    setSessionStatusLine("Updated export scope path");
+    set({
+      exportScopePath: scopePath
+    });
+  }, "setExportScopePath"),
+  setExportDelivery: /* @__PURE__ */ __name((delivery) => {
+    setSessionStatusLine(`Export delivery set to ${delivery}`);
+    set({
+      exportDelivery: delivery
+    });
+  }, "setExportDelivery"),
+  previewExport: /* @__PURE__ */ __name(async () => {
+    await runExport("preview");
+  }, "previewExport"),
+  generateExport: /* @__PURE__ */ __name(async () => {
+    setSessionStatusLine("Confirm export validation to write files to disk");
+    set({
+      exportValidation: {
+        open: true
+      }
+    });
+  }, "generateExport"),
+  validateAndWriteExport: /* @__PURE__ */ __name(async () => {
+    const state = get();
+    const boot = getBootContext();
+    if (!boot) return;
+    if (state.exportInFlight) {
+      appendSessionLog("[warn] Export already in progress");
+      return;
+    }
+    const format = state.exportFormat;
+    set({
+      exportInFlight: true,
+      exportValidation: {
+        open: false
+      },
+      exportJob: {
+        action: "generate",
+        status: "running",
+        format
+      }
+    });
+    setSessionStatusLine("Validating export and writing files...");
+    const service = getService();
+    try {
+      const result = await service.deliverExport(boot.projectId, format, "download", {
+        mode: state.exportMode,
+        scopePath: state.exportScopePath || void 0,
+        organizationId: boot.organizationId
+      });
+      set((prev) => ({
+        exportStatus: result.localStatus ?? prev.exportStatus,
+        exportJob: {
+          action: "generate",
+          status: "success",
+          format
+        }
+      }));
+      setSessionStatusLine(result.message);
+      appendSessionLog(`[export] ${result.message}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set({
+        exportJob: {
+          action: "generate",
+          status: "error",
+          format,
+          error: message
+        }
+      });
+      setSessionStatusLine("Export validation/write failed");
+      appendSessionLog(`[error] Export validate/write failed: ${message}`);
+      refreshOnAuthenticationError(message);
+    } finally {
+      set({
+        exportInFlight: false
+      });
+    }
+  }, "validateAndWriteExport"),
+  cancelExportValidation: /* @__PURE__ */ __name(() => {
+    setSessionStatusLine("Export validation cancelled");
+    set({
+      exportValidation: {
+        open: false
+      }
+    });
+  }, "cancelExportValidation"),
+  statusExport: /* @__PURE__ */ __name(async () => {
+    await runExport("status");
+  }, "statusExport"),
+  commitExport: /* @__PURE__ */ __name(async () => {
+    await runExport("commit");
+  }, "commitExport"),
+  createPrExport: /* @__PURE__ */ __name(async () => {
+    await runExport("pr");
+  }, "createPrExport"),
+  copyExportPreview: /* @__PURE__ */ __name(() => {
+    const { exportPreview, exportJob } = get();
+    const hasGeneratedPreview = exportJob.status === "success" && (exportJob.action === "preview" || exportJob.action === "generate");
+    if (!exportPreview?.content || !hasGeneratedPreview) {
+      setSessionStatusLine("No generated preview to copy. Run p or g first.");
+      appendSessionLog("[warn] export copy requested before preview/generate completed");
+      return;
+    }
+    const copied = copyTextToClipboard(exportPreview.content);
+    if (copied.ok) {
+      setSessionStatusLine("Copied preview to clipboard");
+      appendSessionLog("[export] copied preview to clipboard");
+      return;
+    }
+    setSessionStatusLine("Clipboard copy failed");
+    appendSessionLog(`[error] clipboard copy failed: ${copied.error}`);
+  }, "copyExportPreview")
+})));
+
+// src/store/use-bridge-store.ts
+import { create as create5 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector5 } from "zustand/middleware";
+var useBridgeStore = create5()(subscribeWithSelector5((set, get) => ({
+  bridge: null,
+  localBridge: null,
+  bridgeLogs: [],
+  bridgeLogsSince: 0,
+  startedByTui: false,
+  webmcpChannels: [],
+  setBridgeData: /* @__PURE__ */ __name((bridge, localBridge) => set({
+    bridge,
+    localBridge
+  }), "setBridgeData"),
+  setLocalBridge: /* @__PURE__ */ __name((localBridge) => set({
+    localBridge
+  }), "setLocalBridge"),
+  setBridgeLogs: /* @__PURE__ */ __name((logs) => {
+    if (logs.length === 0) return;
+    const lastTimestamp = logs[logs.length - 1].timestamp;
+    set((prev) => ({
+      bridgeLogs: [
+        ...prev.bridgeLogs,
+        ...logs
+      ].slice(-200),
+      bridgeLogsSince: lastTimestamp
+    }));
+  }, "setBridgeLogs"),
+  clearBridgeLogs: /* @__PURE__ */ __name(() => set({
+    bridgeLogs: []
+  }), "clearBridgeLogs"),
+  setWebMcpChannels: /* @__PURE__ */ __name((channels) => set({
+    webmcpChannels: channels
+  }), "setWebMcpChannels"),
+  bridgeStart: /* @__PURE__ */ __name(() => {
+    const service = getService();
+    service.startLocalBridgeDetached();
+    set({
+      startedByTui: true
+    });
+    appendSessionLog("[bridge] Started local bridge process (detached)");
+    setSessionStatusLine("Bridge start triggered (detached)");
+  }, "bridgeStart"),
+  bridgeStop: /* @__PURE__ */ __name(async () => {
+    const service = getService();
+    const { localBridge } = get();
+    await service.stopLocalBridge(localBridge?.port);
+    if (localBridge) {
+      set({
+        localBridge: {
+          ...localBridge,
+          running: false,
+          uptimeSec: 0
+        },
+        webmcpChannels: []
+      });
+    }
+    appendSessionLog("[bridge] Stop signal sent");
+    setSessionStatusLine("Bridge stop signal sent");
+  }, "bridgeStop")
+})));
+
+// src/store/store-effects.ts
+function dispatchRefreshComplete(data) {
+  useProjectDataStore.getState().setProjectData(data.specs, data.decisions, data.workflow, data.navPolicy);
+  useExportStore.getState().setCapabilities(data.exportCapabilities);
+  useBridgeStore.getState().setBridgeData(data.bridge, data.localBridge);
+}
+__name(dispatchRefreshComplete, "dispatchRefreshComplete");
+function dispatchClearProjectData() {
+  useProjectDataStore.getState().clearProjectData();
+}
+__name(dispatchClearProjectData, "dispatchClearProjectData");
+function refreshOnAuthenticationError(message) {
+  if (!isAuthenticationError(message)) return;
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: "Authentication required. Refreshing context..."
+  });
+  appendLog("[auth] action requires authentication, refreshing context");
+  void refresh();
+}
+__name(refreshOnAuthenticationError, "refreshOnAuthenticationError");
+async function withSessionFeedback(opts) {
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: opts.statusLine
+  });
+  try {
+    const result = await opts.action();
+    appendLog(opts.successLog);
+    if (opts.refresh !== false) {
+      await refresh();
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    appendLog(`${opts.failureLog}: ${message}`);
+    useSessionStore.setState({
+      statusLine: opts.failureStatusLine
+    });
+    refreshOnAuthenticationError(message);
+    throw error;
+  }
+}
+__name(withSessionFeedback, "withSessionFeedback");
+function getBootContext() {
+  return useSessionStore.getState().boot;
+}
+__name(getBootContext, "getBootContext");
+function setSessionStatusLine(line) {
+  useSessionStore.setState({
+    statusLine: line
+  });
+}
+__name(setSessionStatusLine, "setSessionStatusLine");
+function appendSessionLog(entry) {
+  useSessionStore.getState().appendLog(entry);
+}
+__name(appendSessionLog, "appendSessionLog");
+
+// src/store/use-session-store.ts
+var onboardingInteractionResolver = null;
+function requestOnboardingInteraction(request) {
+  return new Promise((resolve) => {
+    onboardingInteractionResolver = resolve;
+    useSessionStore.setState((prev) => ({
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        interaction: request
+      } : prev.onboarding
+    }));
+  });
+}
+__name(requestOnboardingInteraction, "requestOnboardingInteraction");
+function refreshOnAuthenticationError2(message) {
+  if (!isAuthenticationError(message)) return;
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: "Authentication required. Refreshing context..."
+  });
+  appendLog("[auth] action requires authentication, refreshing context");
+  void refresh();
+}
+__name(refreshOnAuthenticationError2, "refreshOnAuthenticationError");
+async function buildOnboardingState(mode) {
+  const service = getService();
+  const boot = useSessionStore.getState().boot;
+  const organizations = await service.listOrganizations();
+  if (organizations.length === 0) {
+    return {
+      mode,
+      step: "create-organization",
+      attachCurrentFolder: mode === "initial-setup",
+      organizations: [],
+      projects: [],
+      availableAgents: [],
+      canCreateProject: false,
+      error: void 0
+    };
+  }
+  const preferredOrganizationId = boot?.organizationId;
+  const selectedOrganization = organizations.find((org) => org.id === preferredOrganizationId) ?? organizations[0];
+  const projects = await service.listProjects(selectedOrganization.id);
+  return {
+    mode,
+    step: organizations.length === 1 ? "project" : "organization",
+    attachCurrentFolder: mode === "initial-setup",
+    organizations,
+    projects,
+    availableAgents: [],
+    canCreateProject: service.canCreateProject(selectedOrganization),
+    selectedOrganizationId: selectedOrganization.id,
+    interaction: void 0,
+    error: void 0
+  };
+}
+__name(buildOnboardingState, "buildOnboardingState");
+var useSessionStore = create6()(subscribeWithSelector6((set, get) => ({
+  boot: null,
+  auth: null,
+  onboarding: null,
+  loading: true,
+  error: null,
+  statusLine: "Bootstrapping...",
+  logs: [],
+  appendLog: /* @__PURE__ */ __name((entry) => {
+    const screen = useTuiUiStore.getState().screen;
+    const level = entry.startsWith("[error]") ? "error" : entry.startsWith("[warn]") ? "warn" : "info";
+    appendGlobalStructuredLog({
+      source: "tui.event-log",
+      level,
+      message: entry,
+      details: {
+        screen
+      }
+    });
+    set((prev) => ({
+      logs: [
+        entry,
+        ...prev.logs
+      ].slice(0, 40)
+    }));
+  }, "appendLog"),
+  setStatusLine: /* @__PURE__ */ __name((line) => set({
+    statusLine: line
+  }), "setStatusLine"),
+  setLoading: /* @__PURE__ */ __name((loading) => set({
+    loading
+  }), "setLoading"),
+  setError: /* @__PURE__ */ __name((error) => set({
+    error
+  }), "setError"),
+  authenticate: /* @__PURE__ */ __name(async () => {
+    const { appendLog } = get();
+    const service = getService();
+    set({
+      loading: false,
+      auth: {
+        status: "authenticating"
+      },
+      statusLine: "Starting browser login flow..."
+    });
+    appendLog("[auth] starting login flow");
+    const ok = await service.authenticateViaCli((line) => {
+      appendLog(`[auth] ${line}`);
+    });
+    if (!ok) {
+      set({
+        auth: {
+          status: "auth_failed",
+          error: "Authentication failed. Check logs and try again."
+        },
+        statusLine: "Authentication failed"
+      });
+      appendLog("[auth] login flow failed");
+      return;
+    }
+    appendLog("[auth] login flow completed");
+    await get().refresh();
+  }, "authenticate"),
+  refresh: /* @__PURE__ */ __name(async (projectId) => {
+    const service = getService();
+    set((prev) => ({
+      loading: prev.boot ? false : true,
+      statusLine: "Loading context..."
+    }));
+    try {
+      const token = await service.checkAuthentication();
+      if (!token) {
+        set({
+          loading: false,
+          error: null,
+          auth: {
+            status: "unauthenticated",
+            error: "No valid credentials. Please run `spekn auth login` to authenticate."
+          },
+          statusLine: "Authentication required"
+        });
+        return;
+      }
+      set({
+        auth: {
+          status: "authenticated",
+          userEmail: service.extractUserEmail(token),
+          tokenExpiresAt: service.extractTokenExpiry(token)
+        }
+      });
+      if (!projectId && !service.hasLocalProjectContext()) {
+        const onboarding = await buildOnboardingState("initial-setup");
+        set({
+          loading: false,
+          error: null,
+          onboarding,
+          statusLine: "Project setup required"
+        });
+        return;
+      }
+      let bootstrapResult;
+      try {
+        bootstrapResult = await service.bootstrap(projectId);
+      } catch (bootstrapError) {
+        if (bootstrapError instanceof Error && bootstrapError.message === "ONBOARDING_REQUIRED") {
+          const onboarding = await buildOnboardingState("initial-setup");
+          set({
+            loading: false,
+            error: null,
+            onboarding,
+            statusLine: "Project setup required"
+          });
+          return;
+        }
+        throw bootstrapError;
+      }
+      const { boot, client } = bootstrapResult;
+      setClient(client);
+      const [specs, decisions, workflow, bridge, localBridge, exportCapabilities] = await Promise.all([
+        service.loadSpecs(client, boot.projectId),
+        service.loadDecisions(client, boot.projectId),
+        service.loadWorkflowSummary(client, boot.projectId),
+        service.loadBridgeSummary(client),
+        service.loadLocalBridgeSummary(),
+        service.discoverExportCapabilities(boot.projectId, boot.organizationId).catch(() => null)
+      ]);
+      const capabilityContext = {
+        plan: boot.plan,
+        role: boot.role,
+        workflowPhase: workflow.currentPhase,
+        permissions: boot.permissions
+      };
+      const navPolicy = resolveNavPolicy(capabilityContext);
+      dispatchRefreshComplete({
+        specs,
+        decisions,
+        workflow,
+        navPolicy,
+        exportCapabilities,
+        bridge,
+        localBridge
+      });
+      set({
+        boot,
+        loading: false,
+        error: null,
+        onboarding: null,
+        statusLine: "Ready"
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      let authStatus = null;
+      if (message.includes("credentials") || message.includes("auth") || message.includes("token")) {
+        authStatus = {
+          status: "auth_failed",
+          error: message
+        };
+      }
+      set((prev) => ({
+        loading: false,
+        error: message,
+        auth: authStatus || prev.auth,
+        statusLine: "Error"
+      }));
+      get().appendLog(`[error] ${message}`);
+    }
+  }, "refresh"),
+  switchContext: /* @__PURE__ */ __name(async () => {
+    const { appendLog } = get();
+    set({
+      loading: true,
+      error: null,
+      statusLine: "Loading organizations..."
+    });
+    try {
+      const onboarding = await buildOnboardingState("switch-context");
+      set({
+        loading: false,
+        onboarding,
+        statusLine: "Switch organization/project"
+      });
+      appendLog("[context] switch mode opened");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set({
+        loading: false,
+        statusLine: "Context switch failed",
+        error: message
+      });
+      appendLog(`[error] context switch failed: ${message}`);
+      refreshOnAuthenticationError2(message);
+    }
+  }, "switchContext"),
+  detachRepoContext: /* @__PURE__ */ __name(async () => {
+    const { boot, appendLog, refresh } = get();
+    const service = getService();
+    const result = await service.detachContextViaCli(boot?.projectId, process.cwd());
+    if (!result.success) {
+      appendLog(`[error] Failed to detach context: ${result.output}`);
+      set({
+        statusLine: "Context detach failed"
+      });
+      return;
+    }
+    if (result.output) {
+      appendLog(`[context] ${result.output}`);
+    }
+    appendLog("[context] Detached repository from local project context");
+    set({
+      boot: null,
+      statusLine: "Repository detached. Select a project to attach."
+    });
+    dispatchClearProjectData();
+    await refresh();
+  }, "detachRepoContext"),
+  syncRepository: /* @__PURE__ */ __name(async (options) => {
+    const { boot, appendLog, refresh } = get();
+    const service = getService();
+    if (!boot) {
+      appendLog("[error] repository sync unavailable: no active project context");
+      set({
+        statusLine: "Repository sync unavailable"
+      });
+      return false;
+    }
+    appendLog("[repo] running sync (metadata + drift analysis)");
+    set({
+      statusLine: "Syncing repository..."
+    });
+    const result = await service.syncRepositoryViaCli(boot.organizationId, boot.projectId, boot.repoPath, {
+      analyze: options?.analyze ?? true,
+      importToProject: options?.importToProject,
+      maxFiles: options?.maxFiles,
+      analysisEngine: options?.analysisEngine,
+      agent: options?.agent,
+      requestInteraction: options?.requestInteraction,
+      onProgress: /* @__PURE__ */ __name((line) => {
+        appendLog(`[repo] ${line}`);
+        options?.onProgress?.(line);
+      }, "onProgress"),
+      onActivity: /* @__PURE__ */ __name((event) => {
+        options?.onActivity?.(event);
+      }, "onActivity"),
+      signal: options?.signal
+    });
+    if (!result.success) {
+      appendLog(`[error] repository sync failed (exit ${result.exitCode})`);
+      set({
+        statusLine: "Repository sync failed"
+      });
+      refreshOnAuthenticationError2(result.output);
+      return false;
+    }
+    appendLog("[repo] sync completed");
+    set({
+      statusLine: "Repository sync completed"
+    });
+    await refresh();
+    return true;
+  }, "syncRepository"),
+  registerRepository: /* @__PURE__ */ __name(async (options) => {
+    const { boot, appendLog, refresh } = get();
+    const service = getService();
+    if (!boot) {
+      appendLog("[error] repository register unavailable: no active project context");
+      set({
+        statusLine: "Repository register unavailable"
+      });
+      return false;
+    }
+    appendLog("[repo] running register");
+    set({
+      statusLine: "Registering repository..."
+    });
+    const repoPath = options?.path ?? boot.repoPath;
+    const result = await service.registerRepositoryViaCli(boot.organizationId, boot.projectId, repoPath, {
+      primary: options?.primary,
+      analyze: options?.analyze,
+      agent: options?.agent,
+      requestInteraction: options?.requestInteraction,
+      onProgress: /* @__PURE__ */ __name((line) => {
+        appendLog(`[repo] ${line}`);
+        options?.onProgress?.(line);
+      }, "onProgress"),
+      onActivity: /* @__PURE__ */ __name((event) => {
+        options?.onActivity?.(event);
+      }, "onActivity"),
+      signal: options?.signal
+    });
+    if (!result.success) {
+      appendLog(`[error] repository register failed (exit ${result.exitCode})`);
+      set({
+        statusLine: "Repository register failed"
+      });
+      refreshOnAuthenticationError2(result.output);
+      return false;
+    }
+    appendLog("[repo] register completed");
+    set({
+      statusLine: "Repository register completed"
+    });
+    await refresh();
+    return true;
+  }, "registerRepository"),
+  // Onboarding actions
+  selectOnboardingOrganization: /* @__PURE__ */ __name(async (index) => {
+    const { onboarding, appendLog } = get();
+    const service = getService();
+    if (!onboarding) return;
+    if (index < 0 || index >= onboarding.organizations.length) {
+      set((prev) => ({
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: `Invalid organization index: ${index + 1}`
+        } : prev.onboarding
+      }));
+      return;
+    }
+    const selectedOrganization = onboarding.organizations[index];
+    set((prev) => ({
+      loading: true,
+      statusLine: "Loading projects...",
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        selectedOrganizationId: selectedOrganization.id,
+        error: void 0
+      } : prev.onboarding
+    }));
+    try {
+      const projects = await service.listProjects(selectedOrganization.id);
+      set((prev) => ({
+        loading: false,
+        statusLine: "Select a project",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          step: "project",
+          attachCurrentFolder: prev.onboarding.attachCurrentFolder,
+          projects,
+          availableAgents: prev.onboarding?.availableAgents ?? [],
+          canCreateProject: service.canCreateProject(selectedOrganization),
+          selectedOrganizationId: selectedOrganization.id,
+          interaction: void 0,
+          error: projects.length === 0 ? "No projects found in selected organization." : void 0
+        } : prev.onboarding
+      }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set((prev) => ({
+        loading: false,
+        statusLine: "Setup error",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: message
+        } : prev.onboarding
+      }));
+    }
+  }, "selectOnboardingOrganization"),
+  registerOnboardingProject: /* @__PURE__ */ __name(async (index) => {
+    const { onboarding, appendLog, refresh } = get();
+    const service = getService();
+    if (!onboarding || !onboarding.selectedOrganizationId) return;
+    if (index < 0 || index >= onboarding.projects.length) {
+      set((prev) => ({
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: `Invalid project index: ${index + 1}`
+        } : prev.onboarding
+      }));
+      return;
+    }
+    const selectedProject = onboarding.projects[index];
+    if (onboarding.mode === "switch-context" || !onboarding.attachCurrentFolder) {
+      set((prev) => ({
+        loading: true,
+        statusLine: "Switching context...",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: void 0
+        } : prev.onboarding
+      }));
+      try {
+        service.persistContext(onboarding.selectedOrganizationId, selectedProject.id);
+        appendLog(`[context] switched to ${selectedProject.name}`);
+        await refresh();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        set((prev) => ({
+          loading: false,
+          statusLine: "Context switch failed",
+          onboarding: prev.onboarding ? {
+            ...prev.onboarding,
+            step: "project",
+            error: message
+          } : prev.onboarding
+        }));
+      }
+      return;
+    }
+    set((prev) => ({
+      loading: true,
+      statusLine: "Linking repository...",
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        error: void 0
+      } : prev.onboarding
+    }));
+    try {
+      persistProjectContext(process.cwd(), {
+        projectId: selectedProject.id,
+        organizationId: onboarding.selectedOrganizationId
+      });
+      appendLog(`[context] linked to ${selectedProject.name}`);
+      await refresh();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set((prev) => ({
+        loading: false,
+        statusLine: "Setup error",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          step: "project",
+          error: message
+        } : prev.onboarding
+      }));
+    }
+  }, "registerOnboardingProject"),
+  createOnboardingProject: /* @__PURE__ */ __name(async (name) => {
+    const { onboarding, appendLog, refresh } = get();
+    const service = getService();
+    if (!onboarding || !onboarding.selectedOrganizationId) return;
+    const trimmed = name.trim();
+    if (!onboarding.canCreateProject) {
+      set((prev) => ({
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: "You are not authorized to create projects in this organization."
+        } : prev.onboarding
+      }));
+      return;
+    }
+    if (trimmed.length < 2) {
+      set((prev) => ({
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: "Project name must be at least 2 characters."
+        } : prev.onboarding
+      }));
+      return;
+    }
+    set((prev) => ({
+      loading: true,
+      statusLine: "Creating project...",
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        error: void 0
+      } : prev.onboarding
+    }));
+    try {
+      const created = await service.createProject(onboarding.selectedOrganizationId, trimmed);
+      appendLog(`[setup] Created project "${created.name}"`);
+      if (onboarding.mode === "switch-context" || !onboarding.attachCurrentFolder) {
+        service.persistContext(onboarding.selectedOrganizationId, created.id);
+        appendLog(`[context] switched to ${created.name}`);
+        await refresh();
+        return;
+      }
+      const registerStartedAt = Date.now();
+      set((prev) => ({
+        loading: true,
+        statusLine: "Registering repository...",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          step: "registering",
+          availableAgents: prev.onboarding?.availableAgents ?? [],
+          selectedProjectId: created.id,
+          runLines: [],
+          runStatus: "running",
+          startedAt: registerStartedAt,
+          interaction: void 0,
+          error: void 0
+        } : prev.onboarding
+      }));
+      useOnboardingWindow.getState().setStartedAt(registerStartedAt);
+      await attachRepositoryFromOnboardingZustand({
+        organizationId: onboarding.selectedOrganizationId,
+        projectId: created.id
+      });
+      await refresh();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set((prev) => ({
+        loading: false,
+        statusLine: "Setup error",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: message
+        } : prev.onboarding
+      }));
+    }
+  }, "createOnboardingProject"),
+  resolveOnboardingInteraction: /* @__PURE__ */ __name((value) => {
+    const resolver = onboardingInteractionResolver;
+    onboardingInteractionResolver = null;
+    set((prev) => ({
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        interaction: void 0
+      } : prev.onboarding
+    }));
+    if (resolver) resolver(value);
+  }, "resolveOnboardingInteraction"),
+  setOnboardingAttachCurrentFolder: /* @__PURE__ */ __name((attach) => {
+    set((prev) => ({
+      onboarding: prev.onboarding ? prev.onboarding.attachCurrentFolder === attach ? prev.onboarding : {
+        ...prev.onboarding,
+        attachCurrentFolder: attach
+      } : prev.onboarding
+    }));
+  }, "setOnboardingAttachCurrentFolder")
+})));
+async function attachRepositoryFromOnboardingZustand(input) {
+  const service = getService();
+  const { appendLog } = useSessionStore.getState();
+  const result = await service.attachOrSyncCurrentRepository(input.organizationId, input.projectId, (line) => {
+    appendLog(`[setup] ${line}`);
+    useSessionStore.setState((prev) => ({
+      statusLine: line.slice(0, 100),
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        runLines: [
+          ...prev.onboarding.runLines ?? [],
+          line
+        ].slice(-400)
+      } : prev.onboarding
+    }));
+  }, void 0, requestOnboardingInteraction, (event) => {
+    const { upsertToolCall, setActiveThought } = useOnboardingWindow.getState();
+    if (event.event === "tool_call" || event.event === "tool_call_update") {
+      upsertToolCall(event);
+    } else if (event.event === "agent_thought") {
+      setActiveThought(event.text);
+    } else if (event.event === "agent_chunk" && event.text) {
+      useSessionStore.setState((prev) => {
+        if (!prev.onboarding) return prev;
+        const lines = [
+          ...prev.onboarding.runLines ?? []
+        ];
+        const parts = event.text.split("\n");
+        if (lines.length === 0) {
+          lines.push(parts[0]);
+        } else {
+          lines[lines.length - 1] += parts[0];
+        }
+        for (let i = 1; i < parts.length; i++) {
+          lines.push(parts[i]);
+        }
+        return {
+          onboarding: {
+            ...prev.onboarding,
+            runLines: lines.slice(-400)
+          }
+        };
+      });
+    }
+  });
+  useSessionStore.setState((prev) => ({
+    onboarding: prev.onboarding ? {
+      ...prev.onboarding,
+      runStatus: result.warning ? "error" : "success"
+    } : prev.onboarding
+  }));
+  logOnboardingAttachResult(appendLog, result);
+}
+__name(attachRepositoryFromOnboardingZustand, "attachRepositoryFromOnboardingZustand");
+
+export {
+  setInitialScreen,
+  useTuiUiStore,
+  resolveNavPolicy,
+  useOnboardingWindow,
+  buildOnboardingState,
+  useSessionStore,
+  useProjectDataStore,
+  useExportStore,
+  dispatchRefreshComplete,
+  dispatchClearProjectData,
+  refreshOnAuthenticationError,
+  withSessionFeedback,
+  getBootContext,
+  setSessionStatusLine,
+  appendSessionLog,
+  useBridgeStore
+};