@spekn/cli 1.0.3 → 1.0.5

package/dist/tui/chunk-755CADEG.mjs

@@ -1,3401 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/store/use-session-store.ts
-import { create as create6 } from "zustand";
-import { subscribeWithSelector as subscribeWithSelector6 } from "zustand/middleware";
-
-// src/utils/project-context.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-var LOCAL_CONTEXT_FILE = ".spekn";
-var GLOBAL_CONTEXT_PATH = path.join(os.homedir(), ".spekn", "context.json");
-var GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".spekn", "config.json");
-var GLOBAL_ERROR_LOG_PATH = "~/.spekn/error.log";
-var DEFAULT_GLOBAL_CONFIG = {
-  logging: {
-    enabled: false,
-    path: GLOBAL_ERROR_LOG_PATH,
-    level: "info"
-  }
-};
-var LOG_LEVEL_RANK = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40
-};
-function loadContextFile(filePath) {
-  try {
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-__name(loadContextFile, "loadContextFile");
-function loadGlobalContextData() {
-  try {
-    const raw = fs.readFileSync(GLOBAL_CONTEXT_PATH, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-__name(loadGlobalContextData, "loadGlobalContextData");
-function getGlobalProjects(global) {
-  if (!global) return [];
-  return Array.isArray(global.projects) ? global.projects : [];
-}
-__name(getGlobalProjects, "getGlobalProjects");
-function isRoot(dirPath) {
-  return path.dirname(dirPath) === dirPath;
-}
-__name(isRoot, "isRoot");
-function findNearestLocalContextFile(startDir = process.cwd()) {
-  let current = path.resolve(startDir);
-  while (true) {
-    const candidate = path.join(current, LOCAL_CONTEXT_FILE);
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-      return candidate;
-    }
-    if (isRoot(current)) return null;
-    current = path.dirname(current);
-  }
-}
-__name(findNearestLocalContextFile, "findNearestLocalContextFile");
-function resolveContextWorkspaceRoot(input) {
-  const fallback = path.resolve(input?.fallbackDir ?? process.cwd());
-  try {
-    const raw = fs.readFileSync(GLOBAL_CONTEXT_PATH, "utf-8");
-    const global = JSON.parse(raw);
-    const projects = getGlobalProjects(global);
-    const selectedProjectId = input?.projectId ?? global.lastUsedProjectId;
-    const selected = projects.find((entry) => entry?.id === selectedProjectId) ?? projects.find((entry) => Array.isArray(entry?.repoPaths) && entry.repoPaths.length > 0);
-    const repoPaths = Array.isArray(selected?.repoPaths) ? selected.repoPaths : [];
-    const existingPath = repoPaths.find((repoPath) => {
-      try {
-        return fs.existsSync(repoPath);
-      } catch {
-        return false;
-      }
-    });
-    const resolvedPath = existingPath ?? repoPaths[0];
-    if (typeof resolvedPath === "string" && resolvedPath.trim().length > 0) {
-      return path.resolve(resolvedPath);
-    }
-  } catch {
-  }
-  return fallback;
-}
-__name(resolveContextWorkspaceRoot, "resolveContextWorkspaceRoot");
-function resolveDeclaredContext(input) {
-  const localPath = input.repoPath ? path.join(path.resolve(input.repoPath), LOCAL_CONTEXT_FILE) : findNearestLocalContextFile();
-  const local = localPath ? loadContextFile(localPath) : null;
-  const global = loadGlobalContextData();
-  const globalProjectId = global?.lastUsedProjectId;
-  const globalProjectOrganizationId = (globalProjectId ? getGlobalProjects(global).find((project) => project.id === globalProjectId)?.organizationId : void 0) ?? global?.defaultOrganizationId;
-  const projectId = input.explicitProjectId ?? local?.projectId ?? globalProjectId;
-  const organizationId = input.explicitOrganizationId ?? local?.organizationId ?? (projectId ? getGlobalProjects(global).find((project) => project.id === projectId)?.organizationId : void 0) ?? globalProjectOrganizationId ?? input.credentialsOrganizationId;
-  return {
-    projectId,
-    organizationId
-  };
-}
-__name(resolveDeclaredContext, "resolveDeclaredContext");
-function saveLocalContext(repoPath, context) {
-  const filePath = path.join(path.resolve(repoPath), LOCAL_CONTEXT_FILE);
-  const content = {
-    projectId: context.projectId,
-    organizationId: context.organizationId,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n", "utf-8");
-}
-__name(saveLocalContext, "saveLocalContext");
-function saveGlobalContext(repoPathInput, context) {
-  const dirPath = path.dirname(GLOBAL_CONTEXT_PATH);
-  fs.mkdirSync(dirPath, {
-    recursive: true,
-    mode: 448
-  });
-  const existing = loadGlobalContextData();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const repoPath = path.resolve(repoPathInput);
-  const organizationId = context.organizationId ?? existing?.defaultOrganizationId ?? "";
-  const previousProjects = getGlobalProjects(existing);
-  const updatedProjects = previousProjects.map((project) => project.id === context.projectId ? {
-    ...project,
-    organizationId: organizationId || project.organizationId,
-    lastUsed: now,
-    repoPaths: Array.from(/* @__PURE__ */ new Set([
-      ...project.repoPaths ?? [],
-      repoPath
-    ]))
-  } : project);
-  if (!updatedProjects.some((project) => project.id === context.projectId) && organizationId) {
-    updatedProjects.unshift({
-      id: context.projectId,
-      organizationId,
-      lastUsed: now,
-      repoPaths: [
-        repoPath
-      ]
-    });
-  }
-  const content = {
-    defaultOrganizationId: organizationId || existing?.defaultOrganizationId,
-    projects: updatedProjects.slice(0, 10),
-    lastUsedProjectId: context.projectId,
-    preferences: existing?.preferences,
-    repoSync: existing?.repoSync,
-    updatedAt: now
-  };
-  fs.writeFileSync(GLOBAL_CONTEXT_PATH, JSON.stringify(content, null, 2) + "\n", {
-    encoding: "utf-8",
-    mode: 384
-  });
-}
-__name(saveGlobalContext, "saveGlobalContext");
-function saveGlobalContextSelectionOnly(context) {
-  const dirPath = path.dirname(GLOBAL_CONTEXT_PATH);
-  fs.mkdirSync(dirPath, {
-    recursive: true,
-    mode: 448
-  });
-  const existing = loadGlobalContextData();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const organizationId = context.organizationId ?? existing?.defaultOrganizationId ?? "";
-  const previousProjects = getGlobalProjects(existing);
-  const updatedProjects = previousProjects.map((project) => project.id === context.projectId ? {
-    ...project,
-    organizationId: organizationId || project.organizationId,
-    lastUsed: now
-  } : project);
-  if (!updatedProjects.some((project) => project.id === context.projectId) && organizationId) {
-    updatedProjects.unshift({
-      id: context.projectId,
-      organizationId,
-      lastUsed: now,
-      repoPaths: []
-    });
-  }
-  const content = {
-    defaultOrganizationId: organizationId || existing?.defaultOrganizationId,
-    projects: updatedProjects.slice(0, 10),
-    lastUsedProjectId: context.projectId,
-    preferences: existing?.preferences,
-    repoSync: existing?.repoSync,
-    updatedAt: now
-  };
-  fs.writeFileSync(GLOBAL_CONTEXT_PATH, JSON.stringify(content, null, 2) + "\n", {
-    encoding: "utf-8",
-    mode: 384
-  });
-}
-__name(saveGlobalContextSelectionOnly, "saveGlobalContextSelectionOnly");
-function ensureGitignoreHasSpekn(repoPath) {
-  const gitignorePath = path.join(path.resolve(repoPath), ".gitignore");
-  const entry = ".spekn";
-  if (!fs.existsSync(gitignorePath)) {
-    fs.writeFileSync(gitignorePath, `${entry}
-`, "utf-8");
-    return;
-  }
-  const content = fs.readFileSync(gitignorePath, "utf-8");
-  const lines = content.split(/\r?\n/);
-  if (lines.some((line) => line.trim() === entry)) return;
-  const needsNewline = content.length > 0 && !content.endsWith("\n");
-  const toAppend = `${needsNewline ? "\n" : ""}${entry}
-`;
-  fs.appendFileSync(gitignorePath, toAppend, "utf-8");
-}
-__name(ensureGitignoreHasSpekn, "ensureGitignoreHasSpekn");
-function hasLocalContext(repoPath) {
-  const startDir = repoPath ? path.resolve(repoPath) : process.cwd();
-  return findNearestLocalContextFile(startDir) !== null;
-}
-__name(hasLocalContext, "hasLocalContext");
-function persistProjectContext(repoPath, context) {
-  saveLocalContext(repoPath, context);
-  saveGlobalContext(repoPath, context);
-  ensureGitignoreHasSpekn(repoPath);
-}
-__name(persistProjectContext, "persistProjectContext");
-function persistSelectedProjectContext(context) {
-  saveGlobalContextSelectionOnly(context);
-}
-__name(persistSelectedProjectContext, "persistSelectedProjectContext");
-function persistProjectContextWithoutRepoPath(repoPath, context) {
-  saveLocalContext(repoPath, context);
-  saveGlobalContextSelectionOnly(context);
-  ensureGitignoreHasSpekn(repoPath);
-}
-__name(persistProjectContextWithoutRepoPath, "persistProjectContextWithoutRepoPath");
-function loadGlobalContextConfig() {
-  try {
-    const raw = fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
-    const parsed = JSON.parse(raw);
-    const levelCandidate = parsed?.logging?.level;
-    const level = levelCandidate === "debug" || levelCandidate === "info" || levelCandidate === "warn" || levelCandidate === "error" ? levelCandidate : DEFAULT_GLOBAL_CONFIG.logging.level;
-    return {
-      logging: {
-        enabled: typeof parsed?.logging?.enabled === "boolean" ? parsed.logging.enabled : DEFAULT_GLOBAL_CONFIG.logging.enabled,
-        path: typeof parsed?.logging?.path === "string" && parsed.logging.path.trim().length > 0 ? parsed.logging.path : DEFAULT_GLOBAL_CONFIG.logging.path,
-        level
-      }
-    };
-  } catch {
-    return DEFAULT_GLOBAL_CONFIG;
-  }
-}
-__name(loadGlobalContextConfig, "loadGlobalContextConfig");
-function saveGlobalContextConfig(config) {
-  const dirPath = path.dirname(GLOBAL_CONFIG_PATH);
-  fs.mkdirSync(dirPath, {
-    recursive: true,
-    mode: 448
-  });
-  fs.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
-    encoding: "utf-8",
-    mode: 384
-  });
-}
-__name(saveGlobalContextConfig, "saveGlobalContextConfig");
-function ensureGlobalContextConfig() {
-  const config = loadGlobalContextConfig();
-  if (!fs.existsSync(GLOBAL_CONFIG_PATH)) {
-    saveGlobalContextConfig(config);
-  }
-  return config;
-}
-__name(ensureGlobalContextConfig, "ensureGlobalContextConfig");
-function expandHomePath(filePath) {
-  if (filePath === "~") return os.homedir();
-  if (filePath.startsWith("~/")) {
-    return path.join(os.homedir(), filePath.slice(2));
-  }
-  return filePath;
-}
-__name(expandHomePath, "expandHomePath");
-function appendGlobalStructuredLog(input) {
-  try {
-    const config = ensureGlobalContextConfig();
-    if (!config.logging.enabled) return;
-    if (LOG_LEVEL_RANK[input.level] < LOG_LEVEL_RANK[config.logging.level]) return;
-    const logPath = path.resolve(expandHomePath(config.logging.path));
-    const dirPath = path.dirname(logPath);
-    fs.mkdirSync(dirPath, {
-      recursive: true,
-      mode: 448
-    });
-    const payload = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      source: input.source,
-      level: input.level,
-      message: input.message,
-      details: input.details ?? {}
-    };
-    fs.appendFileSync(logPath, `${JSON.stringify(payload)}
-`, {
-      encoding: "utf-8",
-      mode: 384
-    });
-  } catch {
-  }
-}
-__name(appendGlobalStructuredLog, "appendGlobalStructuredLog");
-function appendGlobalErrorLog(input) {
-  appendGlobalStructuredLog({
-    source: input.source,
-    level: "error",
-    message: input.message,
-    details: input.details
-  });
-}
-__name(appendGlobalErrorLog, "appendGlobalErrorLog");
-
-// src/auth/credentials-store.ts
-import * as fs2 from "fs";
-import * as os2 from "os";
-import * as path2 from "path";
-import { z } from "zod";
-var CliCredentialsSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string(),
-  expiresAt: z.number(),
-  keycloakUrl: z.string(),
-  realm: z.string(),
-  organizationId: z.string().optional(),
-  user: z.object({
-    sub: z.string(),
-    email: z.string(),
-    name: z.string().optional()
-  }).optional()
-});
-var TokenResponseSchema = z.object({
-  access_token: z.string(),
-  refresh_token: z.string(),
-  expires_in: z.number()
-});
-var CredentialsStore = class {
-  static {
-    __name(this, "CredentialsStore");
-  }
-  configDir;
-  credentialsPath;
-  constructor(configDir) {
-    this.configDir = configDir ?? path2.join(os2.homedir(), ".spekn");
-    this.credentialsPath = path2.join(this.configDir, "credentials.json");
-  }
-  load() {
-    try {
-      const raw = fs2.readFileSync(this.credentialsPath, "utf-8");
-      return CliCredentialsSchema.parse(JSON.parse(raw));
-    } catch {
-      return null;
-    }
-  }
-  save(creds) {
-    fs2.mkdirSync(this.configDir, {
-      recursive: true,
-      mode: 448
-    });
-    const json = JSON.stringify(creds, null, 2);
-    fs2.writeFileSync(this.credentialsPath, json, {
-      encoding: "utf-8",
-      mode: 384
-    });
-  }
-  clear() {
-    try {
-      fs2.rmSync(this.credentialsPath);
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  async getValidToken() {
-    const creds = this.load();
-    if (creds === null) {
-      return null;
-    }
-    const bufferMs = 3e4;
-    if (Date.now() + bufferMs < creds.expiresAt) {
-      return creds.accessToken;
-    }
-    try {
-      const tokenUrl = `${creds.keycloakUrl}/realms/${creds.realm}/protocol/openid-connect/token`;
-      const body = new URLSearchParams({
-        grant_type: "refresh_token",
-        client_id: "spekn-cli",
-        refresh_token: creds.refreshToken
-      });
-      const res = await fetch(tokenUrl, {
-        method: "POST",
-        body,
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        }
-      });
-      if (!res.ok) {
-        return null;
-      }
-      const data = TokenResponseSchema.parse(await res.json());
-      const updated = {
-        ...creds,
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token,
-        expiresAt: Date.now() + data.expires_in * 1e3
-      };
-      this.save(updated);
-      return updated.accessToken;
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/auth/jwt.ts
-function decodeJwtPayload(token) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-      return null;
-    }
-    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-    const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
-    const json = Buffer.from(padded, "base64").toString("utf-8");
-    return JSON.parse(json);
-  } catch {
-    return null;
-  }
-}
-__name(decodeJwtPayload, "decodeJwtPayload");
-
-// src/services/cli-runner.ts
-import { spawn } from "child_process";
-var CliRunner = class {
-  static {
-    __name(this, "CliRunner");
-  }
-  apiUrl;
-  credentialsStore = new CredentialsStore();
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-  }
-  resolveCliEntry() {
-    const cliEntry = process.argv[1];
-    return typeof cliEntry === "string" && cliEntry.length > 0 ? cliEntry : null;
-  }
-  buildCliEnv(options) {
-    const env = {
-      ...process.env
-    };
-    delete env.SPEKN_ORGANIZATION_ID;
-    if (options?.organizationId) {
-      env.SPEKN_ORGANIZATION_ID = options.organizationId;
-    }
-    if (options?.interactionEnabled) {
-      env.SPEKN_INTERACTION_MODE = "json-stdio";
-    } else {
-      delete env.SPEKN_INTERACTION_MODE;
-    }
-    return env;
-  }
-  async respondToInteraction(child, request, onProgress, requestInteraction) {
-    const requestPromise = requestInteraction?.(request);
-    const value = await Promise.race([
-      requestPromise,
-      new Promise((resolve) => setTimeout(() => resolve(void 0), 12e4))
-    ]);
-    if (!child.stdin || child.stdin.destroyed) return;
-    if (value === "skip") {
-      child.stdin.write(`${JSON.stringify({
-        id: request.id,
-        skip: true
-      })}
-`);
-      return;
-    }
-    const allowed = new Set(request.options.map((option) => option?.value).filter((optionValue) => typeof optionValue === "string"));
-    if (typeof value === "string" && allowed.has(value)) {
-      child.stdin.write(`${JSON.stringify({
-        id: request.id,
-        value
-      })}
-`);
-      return;
-    }
-    const fallbackValue = request.options[0]?.value;
-    if (typeof fallbackValue === "string") {
-      onProgress?.(`[interaction] Auto-selecting default: ${fallbackValue}`);
-      child.stdin.write(`${JSON.stringify({
-        id: request.id,
-        value: fallbackValue
-      })}
-`);
-      return;
-    }
-    child.stdin.write(`${JSON.stringify({
-      id: request.id
-    })}
-`);
-  }
-  async runCliCommand(args, options) {
-    const cliEntry = this.resolveCliEntry();
-    if (!cliEntry) {
-      return {
-        success: false,
-        exitCode: 1,
-        stdoutLines: [],
-        stderrLines: [],
-        outputLines: [],
-        output: "Could not resolve CLI entrypoint.",
-        error: "Could not resolve CLI entrypoint."
-      };
-    }
-    const includeAuthToken = options?.includeAuthToken !== false;
-    const token = includeAuthToken ? await this.credentialsStore.getValidToken().catch(() => null) : null;
-    const env = this.buildCliEnv({
-      organizationId: options?.organizationId,
-      interactionEnabled: Boolean(options?.requestInteraction)
-    });
-    if (includeAuthToken && token) {
-      env.SPEKN_AUTH_TOKEN = token;
-    } else if (!includeAuthToken) {
-      delete env.SPEKN_AUTH_TOKEN;
-    }
-    const finalArgs = [
-      cliEntry,
-      ...args
-    ];
-    const stdoutLines = [];
-    const stderrLines = [];
-    const outputLines = [];
-    const maxLines = options?.maxOutputLines ?? 250;
-    let stdoutBuffer = "";
-    let stderrBuffer = "";
-    const pushLine = /* @__PURE__ */ __name((line, stream) => {
-      const target = stream === "stdout" ? stdoutLines : stderrLines;
-      target.push(line);
-      outputLines.push(line);
-      if (target.length > maxLines) target.shift();
-      if (outputLines.length > maxLines) outputLines.shift();
-      options?.onProgress?.(line);
-    }, "pushLine");
-    const processLine = /* @__PURE__ */ __name((line, stream, child) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      const activityMarker = "[spekn-activity] ";
-      const activityIdx = trimmed.indexOf(activityMarker);
-      if (activityIdx >= 0) {
-        try {
-          const parsed = JSON.parse(trimmed.slice(activityIdx + activityMarker.length));
-          if (parsed.type === "spekn.activity") {
-            options?.onActivity?.(parsed);
-            return;
-          }
-        } catch {
-        }
-      }
-      const marker = "[spekn-interaction] ";
-      const markerIndex = trimmed.indexOf(marker);
-      if (options?.requestInteraction && markerIndex >= 0) {
-        const payloadRaw = trimmed.slice(markerIndex + marker.length);
-        let payload = null;
-        try {
-          payload = JSON.parse(payloadRaw);
-        } catch {
-          payload = null;
-        }
-        if (payload?.type === "spekn.interaction.request" && typeof payload.id === "string" && Array.isArray(payload.options)) {
-          options.onProgress?.(`[interaction] ${payload.title ?? "Selection required"}`);
-          const request = {
-            id: payload.id,
-            title: payload.title ?? "Selection required",
-            message: payload.message ?? "Choose an option",
-            options: payload.options,
-            allowSkip: payload.allowSkip === true
-          };
-          void this.respondToInteraction(child, request, options.onProgress, options.requestInteraction).catch(() => {
-            if (!child.stdin || child.stdin.destroyed) return;
-            child.stdin.write(`${JSON.stringify({
-              id: request.id
-            })}
-`);
-          });
-          return;
-        }
-      }
-      pushLine(trimmed, stream);
-    }, "processLine");
-    try {
-      const child = spawn(process.execPath, finalArgs, {
-        cwd: options?.cwd ?? process.cwd(),
-        env,
-        stdio: [
-          "pipe",
-          "pipe",
-          "pipe"
-        ]
-      });
-      const onData = /* @__PURE__ */ __name((stream, data) => {
-        const chunk = String(data);
-        if (stream === "stdout") {
-          stdoutBuffer += chunk;
-        } else {
-          stderrBuffer += chunk;
-        }
-        const buffer = stream === "stdout" ? stdoutBuffer : stderrBuffer;
-        const lines = buffer.split(/\r?\n|\r/);
-        const remainder = lines.pop() ?? "";
-        if (stream === "stdout") {
-          stdoutBuffer = remainder;
-        } else {
-          stderrBuffer = remainder;
-        }
-        for (const line of lines) {
-          processLine(line, stream, child);
-        }
-      }, "onData");
-      child.stdout?.on("data", (data) => onData("stdout", data));
-      child.stderr?.on("data", (data) => onData("stderr", data));
-      const exitCode = await new Promise((resolve, reject) => {
-        child.on("error", reject);
-        child.on("close", (code) => resolve(code ?? 1));
-      });
-      if (stdoutBuffer.trim().length > 0) {
-        processLine(stdoutBuffer, "stdout", child);
-      }
-      if (stderrBuffer.trim().length > 0) {
-        processLine(stderrBuffer, "stderr", child);
-      }
-      return {
-        success: exitCode === 0,
-        exitCode,
-        stdoutLines,
-        stderrLines,
-        outputLines,
-        output: outputLines.join("\n")
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        exitCode: 1,
-        stdoutLines,
-        stderrLines,
-        outputLines,
-        output: message,
-        error: message
-      };
-    }
-  }
-  async runCliJson(args, cwd, organizationId) {
-    const result = await this.runCliCommand(args, {
-      cwd,
-      organizationId,
-      includeAuthToken: true
-    });
-    if (!result.success && result.output.trim().length === 0) {
-      return {
-        ok: false,
-        error: result.error ?? "CLI command failed."
-      };
-    }
-    const output = result.stdoutLines.join("\n").trim() || result.output.trim();
-    const jsonStart = output.indexOf("{");
-    if (jsonStart === -1) {
-      return {
-        ok: false,
-        error: output || "Command produced no JSON output."
-      };
-    }
-    try {
-      const parsed = JSON.parse(output.slice(jsonStart));
-      return {
-        ok: true,
-        value: parsed
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        ok: false,
-        error: message
-      };
-    }
-  }
-};
-
-// src/services/auth-service.ts
-var AuthService = class {
-  static {
-    __name(this, "AuthService");
-  }
-  credentialsStore = new CredentialsStore();
-  cliRunner;
-  constructor(apiUrl) {
-    this.cliRunner = new CliRunner(apiUrl);
-  }
-  async checkAuthentication() {
-    try {
-      const token = await this.credentialsStore.getValidToken();
-      return token || null;
-    } catch {
-      return null;
-    }
-  }
-  async authenticateViaCli(onProgress) {
-    const result = await this.cliRunner.runCliCommand([
-      "auth",
-      "login"
-    ], {
-      cwd: process.cwd(),
-      includeAuthToken: false,
-      onProgress
-    });
-    return result.success;
-  }
-  extractUserEmail(token) {
-    try {
-      const claims = decodeJwtPayload(token);
-      return typeof claims?.["email"] === "string" ? claims["email"] : void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  extractTokenExpiry(token) {
-    try {
-      const claims = decodeJwtPayload(token);
-      if (typeof claims?.["exp"] === "number") {
-        return claims["exp"] * 1e3;
-      }
-      return void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  extractPermissions(token) {
-    const claims = decodeJwtPayload(token);
-    return Array.isArray(claims?.permissions) ? claims.permissions.filter((item) => typeof item === "string") : [];
-  }
-};
-
-// src/shared-enums.ts
-var OrganizationPlan = {
-  FREE: "free",
-  PRO: "pro",
-  TEAM: "team",
-  ENTERPRISE: "enterprise"
-};
-var WorkflowPhase = {
-  SPECIFY: "specify",
-  CLARIFY: "clarify",
-  PLAN: "plan",
-  IMPLEMENT: "implement",
-  VERIFY: "verify",
-  COMPLETE: "complete"
-};
-
-// src/services/client.ts
-import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
-
-// src/utils/trpc-url.ts
-function normalizeTrpcUrl(apiUrl) {
-  if (apiUrl.endsWith("/trpc")) {
-    return apiUrl;
-  }
-  if (apiUrl.endsWith("/")) {
-    return `${apiUrl}trpc`;
-  }
-  return `${apiUrl}/trpc`;
-}
-__name(normalizeTrpcUrl, "normalizeTrpcUrl");
-
-// src/services/client.ts
-function createApiClient(apiUrl, token, organizationId) {
-  return createTRPCProxyClient({
-    links: [
-      httpBatchLink({
-        url: normalizeTrpcUrl(apiUrl),
-        headers: {
-          authorization: token ? `Bearer ${token}` : "",
-          "x-organization-id": organizationId
-        }
-      })
-    ]
-  });
-}
-__name(createApiClient, "createApiClient");
-
-// src/services/bootstrap-service.ts
-function normalizePlan(raw) {
-  if (raw === OrganizationPlan.PRO) return OrganizationPlan.PRO;
-  if (raw === OrganizationPlan.TEAM) return OrganizationPlan.TEAM;
-  if (raw === OrganizationPlan.ENTERPRISE) return OrganizationPlan.ENTERPRISE;
-  return OrganizationPlan.FREE;
-}
-__name(normalizePlan, "normalizePlan");
-function normalizeRole(raw) {
-  if (raw === "owner" || raw === "admin" || raw === "member" || raw === "viewer") {
-    return raw;
-  }
-  return "member";
-}
-__name(normalizeRole, "normalizeRole");
-var BootstrapService = class {
-  static {
-    __name(this, "BootstrapService");
-  }
-  apiUrl;
-  credentialsStore = new CredentialsStore();
-  authService;
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-    this.authService = new AuthService(apiUrl);
-  }
-  async bootstrap(projectIdArg) {
-    const token = await this.credentialsStore.getValidToken();
-    if (!token) {
-      throw new Error("No valid credentials. Run `spekn auth login` first.");
-    }
-    const permissions = this.authService.extractPermissions(token);
-    const stored = this.credentialsStore.load();
-    const declared = resolveDeclaredContext({
-      explicitProjectId: projectIdArg,
-      repoPath: process.cwd(),
-      credentialsOrganizationId: stored?.organizationId,
-      envOrganizationId: process.env.SPEKN_ORGANIZATION_ID
-    });
-    if (!declared.projectId) {
-      throw new Error("PROJECT_CONTEXT_REQUIRED");
-    }
-    const fallbackOrg = declared.organizationId ?? "";
-    const bootstrapClient = createApiClient(this.apiUrl, token, fallbackOrg);
-    const orgs = await bootstrapClient.organization.list.query();
-    if (orgs.length === 0) {
-      throw new Error("No organization membership found for this account.");
-    }
-    const org = orgs.find((candidate) => candidate.id === fallbackOrg) ?? orgs[0];
-    const organizationId = org.id;
-    const client2 = createApiClient(this.apiUrl, token, organizationId);
-    const projects = await client2.project.list.query({
-      limit: 20,
-      offset: 0
-    });
-    if (projects.length === 0) {
-      throw new Error("ONBOARDING_REQUIRED");
-    }
-    const project = projects.find((candidate) => candidate.id === declared.projectId);
-    if (!project) {
-      throw new Error("ONBOARDING_REQUIRED");
-    }
-    const repoPath = resolveContextWorkspaceRoot({
-      projectId: project.id,
-      fallbackDir: process.cwd()
-    });
-    return {
-      boot: {
-        apiUrl: this.apiUrl,
-        organizationId,
-        organizationName: org.name,
-        role: normalizeRole(org.role),
-        plan: normalizePlan(org.plan),
-        projectId: project.id,
-        projectName: project.name,
-        repoPath,
-        permissions
-      },
-      client: client2
-    };
-  }
-  hasDeclaredProjectContext(projectIdArg) {
-    const stored = this.credentialsStore.load();
-    const declared = resolveDeclaredContext({
-      explicitProjectId: projectIdArg,
-      repoPath: process.cwd(),
-      credentialsOrganizationId: stored?.organizationId,
-      envOrganizationId: process.env.SPEKN_ORGANIZATION_ID
-    });
-    return Boolean(declared.projectId);
-  }
-  async loadWorkflowSummary(client2, projectId) {
-    const states = await client2.workflowState.listByProject.query({
-      projectId
-    });
-    const first = Array.isArray(states) && states.length > 0 ? states[0] : null;
-    const currentPhase = first?.currentPhase ?? null;
-    const blockedCount = Array.isArray(states) ? states.filter((state) => state.specificationLockStatus === "locked").length : 0;
-    return {
-      currentPhase,
-      blockedCount,
-      hasVerificationEvidence: Boolean(first?.hasVerificationEvidence),
-      hasPlanningArtifacts: Boolean(first?.hasPlanningArtifacts)
-    };
-  }
-  hasLocalProjectContext(repoPath) {
-    return hasLocalContext(repoPath);
-  }
-  persistContext(organizationId, projectId) {
-    persistSelectedProjectContext({
-      organizationId,
-      projectId
-    });
-  }
-};
-
-// src/services/bridge-service.ts
-import fs3 from "fs";
-import os3 from "os";
-import path3 from "path";
-import { spawn as spawn2 } from "child_process";
-var DEFAULT_BRIDGE_CONFIG = {
-  port: 19550,
-  pairing: null
-};
-function loadLocalBridgeConfig() {
-  const configPath = path3.join(os3.homedir(), ".spekn", "bridge", "config.json");
-  try {
-    const raw = fs3.readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return {
-      port: typeof parsed.port === "number" ? parsed.port : DEFAULT_BRIDGE_CONFIG.port,
-      pairing: parsed.pairing ?? DEFAULT_BRIDGE_CONFIG.pairing
-    };
-  } catch {
-    return DEFAULT_BRIDGE_CONFIG;
-  }
-}
-__name(loadLocalBridgeConfig, "loadLocalBridgeConfig");
-var BridgeService = class {
-  static {
-    __name(this, "BridgeService");
-  }
-  cliRunner;
-  constructor(apiUrl) {
-    this.cliRunner = new CliRunner(apiUrl);
-  }
-  async loadBridgeSummary(client2) {
-    const [flag, devices, metrics] = await Promise.all([
-      client2.bridge.getFeatureFlag.query().catch(() => ({
-        enabled: false
-      })),
-      client2.bridge.listDevices.query().catch(() => []),
-      client2.bridge.getMetrics.query().catch(() => ({
-        connectedDevices: 0,
-        authFailures: 0
-      }))
-    ]);
-    return {
-      featureEnabled: Boolean(flag.enabled),
-      devices: Array.isArray(devices) ? devices.map((device) => ({
-        id: device.id,
-        name: device.name,
-        status: device.status,
-        isDefault: Boolean(device.isDefault),
-        lastSeenAt: device.lastSeenAt
-      })) : [],
-      connectedDevices: Number(metrics.connectedDevices ?? 0),
-      authFailures: Number(metrics.authFailures ?? 0)
-    };
-  }
-  async loadLocalBridgeSummary() {
-    const config = loadLocalBridgeConfig();
-    let running = false;
-    let uptimeSec;
-    try {
-      const response = await fetch(`http://127.0.0.1:${config.port}/health`);
-      if (response.ok) {
-        const payload = await response.json();
-        running = true;
-        uptimeSec = Number(payload.uptime ?? 0);
-      }
-    } catch {
-      running = false;
-    }
-    return {
-      paired: config.pairing !== null,
-      deviceId: config.pairing?.deviceId,
-      deviceName: config.pairing?.deviceName,
-      port: config.port,
-      running,
-      uptimeSec
-    };
-  }
-  startLocalBridgeDetached() {
-    const cliEntry = this.cliRunner.resolveCliEntry();
-    if (!cliEntry) return;
-    const args = [
-      cliEntry,
-      "bridge",
-      "start"
-    ];
-    const child = spawn2(process.execPath, args, {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.unref();
-  }
-  async stopLocalBridge(configPort) {
-    const port = configPort ?? loadLocalBridgeConfig().port;
-    try {
-      await fetch(`http://127.0.0.1:${port}/shutdown`, {
-        method: "POST"
-      });
-    } catch {
-    }
-  }
-  async loadBridgeLogs(port, since) {
-    const p = port ?? loadLocalBridgeConfig().port;
-    try {
-      const url = since ? `http://127.0.0.1:${p}/logs?since=${since}` : `http://127.0.0.1:${p}/logs`;
-      const res = await fetch(url);
-      if (!res.ok) return [];
-      const data = await res.json();
-      return data.logs;
-    } catch {
-      return [];
-    }
-  }
-};
-
-// src/services/decision-service.ts
-var DecisionService = class {
-  static {
-    __name(this, "DecisionService");
-  }
-  async loadDecisions(client2, projectId) {
-    const result = await client2.decision.getAll.query({
-      projectId,
-      limit: 50,
-      offset: 0
-    });
-    const decisions = Array.isArray(result?.decisions) ? result.decisions : [];
-    return decisions.map((decision) => ({
-      id: decision.id,
-      title: decision.title,
-      status: decision.status,
-      decisionType: decision.decisionType,
-      specAnchor: decision.specAnchor,
-      createdAt: decision.createdAt
-    }));
-  }
-  async resolveDecision(client2, projectId, decisionId, status, reason, existingRationale) {
-    await client2.decision.update.mutate({
-      projectId,
-      id: decisionId,
-      data: {
-        status,
-        rationale: reason || existingRationale
-      }
-    });
-  }
-  async deleteDecision(client2, projectId, decisionId, mode = "archive") {
-    const deleteMutation = client2?.decision?.delete?.mutate;
-    if (typeof deleteMutation !== "function") {
-      throw new Error("Decision delete route is unavailable.");
-    }
-    await deleteMutation({
-      projectId,
-      id: decisionId,
-      mode
-    });
-  }
-};
-
-// src/services/export-service.ts
-var ExportService = class {
-  static {
-    __name(this, "ExportService");
-  }
-  apiUrl;
-  cliRunner;
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-    this.cliRunner = new CliRunner(apiUrl);
-  }
-  async previewExport(client2, projectId, format) {
-    const result = await client2.export.preview.query({
-      projectId,
-      formatId: format
-    });
-    return {
-      content: String(result.content ?? ""),
-      anchorCount: Number(result.anchorCount ?? 0),
-      specVersion: typeof result.specVersion === "string" ? result.specVersion : void 0,
-      warnings: Array.isArray(result.warnings) ? result.warnings.filter((warning) => typeof warning === "string") : void 0
-    };
-  }
-  async generateExport(client2, projectId, format) {
-    const result = await client2.export.generate.mutate({
-      projectId,
-      formatId: format
-    });
-    return {
-      content: String(result.content ?? ""),
-      anchorCount: Number(result.anchorCount ?? 0),
-      specVersion: typeof result.specVersion === "string" ? result.specVersion : void 0,
-      warnings: Array.isArray(result.warnings) ? result.warnings.filter((warning) => typeof warning === "string") : void 0
-    };
-  }
-  async discoverExportCapabilities(projectId, organizationId) {
-    const fallback = {
-      plan: "free",
-      modes: [
-        "global"
-      ],
-      formats: [
-        {
-          id: "agents-md"
-        },
-        {
-          id: "claude-md"
-        },
-        {
-          id: "cursorrules"
-        },
-        {
-          id: "gemini-md"
-        }
-      ]
-    };
-    const cliResult = await this.cliRunner.runCliJson([
-      "export",
-      "discover",
-      "--project",
-      projectId,
-      "--api-url",
-      this.apiUrl,
-      "--json"
-    ], void 0, organizationId);
-    if (!cliResult.ok) {
-      return fallback;
-    }
-    const result = cliResult.value;
-    const modes = Array.isArray(result?.modes) ? result.modes.filter((mode) => mode === "global" || mode === "scoped") : fallback.modes;
-    const formats = Array.isArray(result?.formats) ? result.formats.map((format) => {
-      if (format?.id !== "agents-md" && format?.id !== "claude-md" && format?.id !== "cursorrules" && format?.id !== "gemini-md") {
-        return null;
-      }
-      const formatModes = Array.isArray(format?.modes) ? format.modes.filter((mode) => mode === "global" || mode === "scoped") : void 0;
-      return {
-        id: format.id,
-        name: typeof format?.name === "string" ? format.name : void 0,
-        filename: typeof format?.filename === "string" ? format.filename : void 0,
-        modes: formatModes
-      };
-    }).filter((format) => format !== null) : fallback.formats;
-    return {
-      plan: result?.plan === "pro" || result?.plan === "team" || result?.plan === "enterprise" ? result.plan : "free",
-      modes: modes.length > 0 ? modes : fallback.modes,
-      formats: formats.length > 0 ? formats : fallback.formats
-    };
-  }
-  async exportStatus(projectId, format, options) {
-    const args = [
-      "export",
-      "status",
-      "--project",
-      projectId,
-      "--format",
-      format,
-      "--api-url",
-      this.apiUrl,
-      "--json"
-    ];
-    if (options?.mode) args.push("--mode", options.mode);
-    if (options?.scopePath) args.push("--scope", options.scopePath);
-    const cliResult = await this.cliRunner.runCliJson(args, void 0, options?.organizationId);
-    if (!cliResult.ok) {
-      return {
-        overall: "missing",
-        targets: []
-      };
-    }
-    const result = cliResult.value;
-    const overall = result?.overall === "diverged" || result?.overall === "outdated" || result?.overall === "up-to-date" ? result.overall : "missing";
-    const targets = Array.isArray(result?.targets) ? result.targets.map((target) => {
-      const status = target?.status === "diverged" || target?.status === "outdated" || target?.status === "up-to-date" ? target.status : "missing";
-      const kind = target?.kind === "canonical" ? "canonical" : "entrypoint";
-      if (typeof target?.path !== "string") return null;
-      return {
-        path: target.path,
-        kind,
-        status
-      };
-    }).filter((target) => target !== null) : [];
-    return {
-      overall,
-      targets
-    };
-  }
-  async deliverExport(projectId, format, delivery, options) {
-    const args = [
-      "export",
-      "--project",
-      projectId,
-      "--format",
-      format,
-      "--delivery",
-      delivery,
-      "--api-url",
-      this.apiUrl,
-      "--json"
-    ];
-    if (options?.mode) args.push("--mode", options.mode);
-    if (options?.scopePath) args.push("--scope", options.scopePath);
-    const exportCwd = delivery === "download" ? resolveContextWorkspaceRoot({
-      projectId,
-      fallbackDir: process.cwd()
-    }) : process.cwd();
-    const cliResult = await this.cliRunner.runCliJson(args, exportCwd, options?.organizationId);
-    if (!cliResult.ok) {
-      throw new Error(cliResult.error);
-    }
-    const result = cliResult.value;
-    if (delivery === "commit") {
-      return {
-        message: typeof result?.commitSha === "string" ? `Committed to ${result.branch ?? "branch"}: ${result.commitSha}` : "Export commit completed."
-      };
-    }
-    if (delivery === "pr") {
-      return {
-        message: typeof result?.prUrl === "string" ? `PR #${result.prNumber ?? "?"}: ${result.prUrl}` : "Export PR created."
-      };
-    }
-    if (delivery === "download") {
-      const targets = Array.isArray(result?.targets) ? result.targets.map((target) => {
-        if (typeof target?.path !== "string") return null;
-        return {
-          path: target.path,
-          kind: target?.kind === "canonical" ? "canonical" : "entrypoint",
-          status: "up-to-date"
-        };
-      }).filter((target) => target !== null) : [];
-      const count = targets.length;
-      return {
-        message: `Wrote ${count} export file(s) to ${exportCwd}.`,
-        localStatus: {
-          overall: "up-to-date",
-          targets
-        }
-      };
-    }
-    return {
-      message: "Export copy payload generated."
-    };
-  }
-};
-
-// src/services/organization-service.ts
-var OrganizationService = class {
-  static {
-    __name(this, "OrganizationService");
-  }
-  apiUrl;
-  credentialsStore = new CredentialsStore();
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-  }
-  async listOrganizations() {
-    const token = await this.credentialsStore.getValidToken();
-    if (!token) {
-      throw new Error("No valid credentials. Run `spekn auth login` first.");
-    }
-    const stored = this.credentialsStore.load();
-    const fallbackOrg = stored?.organizationId ?? process.env.SPEKN_ORGANIZATION_ID ?? "";
-    const bootstrapClient = createApiClient(this.apiUrl, token, fallbackOrg);
-    const orgs = await bootstrapClient.organization.list.query();
-    return orgs.map((org) => ({
-      id: org.id,
-      name: org.name,
-      plan: org.plan,
-      role: org.role
-    }));
-  }
-  async createOrganization(input) {
-    const token = await this.credentialsStore.getValidToken();
-    if (!token) {
-      throw new Error("No valid credentials. Run `spekn auth login` first.");
-    }
-    const stored = this.credentialsStore.load();
-    const fallbackOrg = stored?.organizationId ?? process.env.SPEKN_ORGANIZATION_ID ?? "";
-    const bootstrapClient = createApiClient(this.apiUrl, token, fallbackOrg);
-    const createdOrg = await bootstrapClient.organization.create.mutate(input);
-    return {
-      id: createdOrg.id,
-      name: createdOrg.name,
-      plan: createdOrg.plan,
-      role: "owner"
-    };
-  }
-  async listProjects(organizationId) {
-    const token = await this.credentialsStore.getValidToken();
-    if (!token) {
-      throw new Error("No valid credentials. Run `spekn auth login` first.");
-    }
-    const client2 = createApiClient(this.apiUrl, token, organizationId);
-    const projects = await client2.project.list.query({
-      limit: 100,
-      offset: 0
-    });
-    return projects.map((project) => ({
-      id: project.id,
-      name: project.name
-    }));
-  }
-  async createProject(organizationId, name) {
-    try {
-      const token = await this.credentialsStore.getValidToken();
-      if (!token) {
-        throw new Error("No valid credentials. Run `spekn auth login` first.");
-      }
-      const client2 = createApiClient(this.apiUrl, token, organizationId);
-      const created = await client2.project.create.mutate({
-        name: name.trim()
-      });
-      return {
-        id: created.id,
-        name: String(created.name ?? name.trim())
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      appendGlobalErrorLog({
-        source: "wizard.createProject",
-        message,
-        details: {
-          apiUrl: this.apiUrl,
-          organizationId,
-          projectName: name.trim(),
-          cwd: process.cwd()
-        }
-      });
-      throw error;
-    }
-  }
-  canCreateProject(org) {
-    const role = String(org?.role ?? "").toLowerCase();
-    return role === "owner" || role === "admin";
-  }
-};
-
-// src/services/repo-service.ts
-import { execFileSync } from "child_process";
-import path4 from "path";
-var RepoService = class {
-  static {
-    __name(this, "RepoService");
-  }
-  apiUrl;
-  credentialsStore = new CredentialsStore();
-  cliRunner;
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-    this.cliRunner = new CliRunner(apiUrl);
-  }
-  attachOrSyncCurrentRepository = /* @__PURE__ */ __name(async (organizationId, projectId, onProgress, _agentType, requestInteraction, onActivity) => {
-    const repoPath = process.cwd();
-    let args = [];
-    let lastOutputLines = [];
-    try {
-      const remoteUrl = this.execGit(repoPath, [
-        "remote",
-        "get-url",
-        "origin"
-      ]);
-      const token = await this.credentialsStore.getValidToken();
-      if (!token) {
-        throw new Error("No valid credentials. Run `spekn auth login` first.");
-      }
-      const client2 = createApiClient(this.apiUrl, token, organizationId);
-      const repos = await client2.gitRepository.list.query({
-        projectId,
-        limit: 100,
-        offset: 0
-      });
-      const isAlreadyAttached = repos.some((repo) => repo.repositoryUrl === remoteUrl);
-      const cliEntry = this.cliRunner.resolveCliEntry();
-      if (!cliEntry) {
-        throw new Error("Could not resolve CLI entrypoint for repo register.");
-      }
-      const runAnalyze = !isAlreadyAttached;
-      args = isAlreadyAttached ? [
-        cliEntry,
-        "repo",
-        "sync",
-        "--project-id",
-        projectId,
-        "--path",
-        repoPath,
-        "--api-url",
-        this.apiUrl,
-        "--no-analyze"
-      ] : [
-        cliEntry,
-        "repo",
-        "register",
-        "--project-id",
-        projectId,
-        "--path",
-        repoPath,
-        "--api-url",
-        this.apiUrl,
-        "--analyze"
-      ];
-      if (isAlreadyAttached) {
-        onProgress?.("Repository already attached to this project. Syncing metadata only (no analysis)...");
-      } else {
-        onProgress?.("Repository not attached yet. Registering and running analysis...");
-      }
-      const runResult = await this.cliRunner.runCliCommand(args.slice(1), {
-        cwd: repoPath,
-        organizationId,
-        onProgress,
-        requestInteraction,
-        onActivity
-      });
-      lastOutputLines = runResult.outputLines;
-      const exitCode = runResult.exitCode;
-      if (exitCode !== 0) {
-        appendGlobalErrorLog({
-          source: "wizard.registerCurrentRepository",
-          message: `Repository registration/analysis failed (exit ${exitCode}).`,
-          details: {
-            apiUrl: this.apiUrl,
-            organizationId,
-            projectId,
-            repoPath,
-            command: process.execPath,
-            args,
-            lastOutputLines: lastOutputLines.slice(-80)
-          }
-        });
-        throw new Error(`Repository registration/analysis failed (exit ${exitCode}).`);
-      }
-      if (runAnalyze) {
-        persistProjectContext(repoPath, {
-          projectId,
-          organizationId
-        });
-      } else {
-        persistProjectContextWithoutRepoPath(repoPath, {
-          projectId,
-          organizationId
-        });
-      }
-      return {
-        success: true,
-        analyzed: runAnalyze
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      appendGlobalErrorLog({
-        source: "wizard.registerCurrentRepository",
-        message,
-        details: {
-          apiUrl: this.apiUrl,
-          organizationId,
-          projectId,
-          repoPath,
-          command: process.execPath,
-          args,
-          lastOutputLines: lastOutputLines.slice(-80)
-        }
-      });
-      throw error;
-    }
-  }, "attachOrSyncCurrentRepository");
-  async syncRepositoryViaCli(organizationId, projectId, repoPathInput, options) {
-    const repoPath = path4.resolve(repoPathInput || process.cwd());
-    if (!this.cliRunner.resolveCliEntry()) {
-      return {
-        success: false,
-        output: "Could not resolve CLI entrypoint.",
-        exitCode: 1
-      };
-    }
-    const token = await this.credentialsStore.getValidToken();
-    if (!token) {
-      return {
-        success: false,
-        output: "No valid credentials. Run `spekn auth login` first.",
-        exitCode: 1
-      };
-    }
-    const args = [
-      "repo",
-      "sync",
-      "--project-id",
-      projectId,
-      "--path",
-      repoPath,
-      "--api-url",
-      this.apiUrl
-    ];
-    if (options?.analyze === false) {
-      args.push("--no-analyze");
-    }
-    if (options?.importToProject) {
-      args.push("--import-to-project");
-    }
-    if (typeof options?.maxFiles === "number" && Number.isFinite(options.maxFiles)) {
-      args.push("--max-files", String(Math.max(1, Math.floor(options.maxFiles))));
-    }
-    if (options?.analysisEngine) {
-      args.push("--analysis-engine", options.analysisEngine);
-    }
-    if (options?.agent && options.agent.trim().length > 0) {
-      args.push("--agent", options.agent.trim());
-    }
-    try {
-      const runResult = await this.cliRunner.runCliCommand(args, {
-        cwd: repoPath,
-        organizationId,
-        onProgress: options?.onProgress,
-        requestInteraction: options?.requestInteraction,
-        onActivity: options?.onActivity
-      });
-      return {
-        success: runResult.success,
-        output: runResult.output,
-        exitCode: runResult.exitCode
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        output: message,
-        exitCode: 1
-      };
-    }
-  }
-  async detachContextViaCli(_projectId, repoPath = process.cwd()) {
-    const result = await this.cliRunner.runCliCommand([
-      "repo",
-      "detach",
-      "--path",
-      repoPath
-    ], {
-      cwd: repoPath,
-      includeAuthToken: false
-    });
-    return {
-      success: result.success,
-      output: result.output || result.error || "Unknown detach error"
-    };
-  }
-  execGit(repoPath, args) {
-    try {
-      return execFileSync("git", [
-        "-C",
-        repoPath,
-        ...args
-      ], {
-        encoding: "utf-8",
-        stdio: [
-          "pipe",
-          "pipe",
-          "pipe"
-        ]
-      }).trim();
-    } catch {
-      throw new Error("Could not read git metadata. Run TUI from a git repository with an 'origin' remote.");
-    }
-  }
-};
-
-// src/services/spec-service.ts
-var SpecService = class {
-  static {
-    __name(this, "SpecService");
-  }
-  async loadSpecs(client2, projectId) {
-    const specs = await client2.specification.list.query({
-      projectId,
-      limit: 50,
-      offset: 0
-    });
-    return (Array.isArray(specs) ? specs : []).map((spec) => {
-      const frontmatter = spec.frontmatter ?? {};
-      const hints = frontmatter.hints ?? {};
-      const aiContext = frontmatter.aiContext ?? {};
-      const acp = frontmatter.acp ?? {};
-      const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags.filter((tag) => typeof tag === "string") : [];
-      const aiFocusAreas = Array.isArray(aiContext.focusAreas) ? aiContext.focusAreas.filter((area) => typeof area === "string") : [];
-      const acpAllowedAgents = Array.isArray(acp.allowedAgents) ? acp.allowedAgents.filter((agent) => typeof agent === "string") : [];
-      const countArray = /* @__PURE__ */ __name((value) => Array.isArray(value) ? value.length : 0, "countArray");
-      return {
-        id: spec.id,
-        specRef: typeof frontmatter.specRef === "string" ? frontmatter.specRef : typeof spec.specRef === "string" ? spec.specRef : void 0,
-        frontmatter,
-        title: spec.title,
-        status: spec.status,
-        version: spec.version,
-        updatedAt: spec.updatedAt,
-        type: typeof frontmatter.type === "string" ? frontmatter.type : void 0,
-        content: typeof spec.content === "string" ? spec.content : void 0,
-        tags: tags.length > 0 ? tags : void 0,
-        author: typeof frontmatter.author === "string" ? frontmatter.author : void 0,
-        hintCounts: {
-          constraints: countArray(hints.constraints),
-          requirements: countArray(hints.requirements),
-          technical: countArray(hints.technical),
-          guidance: countArray(hints.guidance)
-        },
-        relationCounts: {
-          dependsOn: countArray(frontmatter.dependsOn),
-          conflictsWith: countArray(frontmatter.conflictsWith),
-          compatibleWith: countArray(frontmatter.compatibleWith)
-        },
-        acpPolicyMode: typeof acp.policyMode === "string" ? acp.policyMode : void 0,
-        acpAllowedAgents: acpAllowedAgents.length > 0 ? acpAllowedAgents : void 0,
-        aiTokenBudget: typeof aiContext.tokenBudget === "number" ? aiContext.tokenBudget : void 0,
-        aiFocusAreas: aiFocusAreas.length > 0 ? aiFocusAreas : void 0
-      };
-    });
-  }
-  async updateSpecificationContent(client2, projectId, specificationId, content) {
-    await client2.specification.update.mutate({
-      projectId,
-      id: specificationId,
-      data: {
-        content,
-        changeType: "patch",
-        changeDescription: "Edited from TUI editor"
-      }
-    });
-  }
-  async updateSpecificationStatus(client2, projectId, specificationId, status) {
-    await client2.specification.update.mutate({
-      projectId,
-      id: specificationId,
-      data: {
-        status,
-        changeType: "metadata",
-        changeDescription: `Status changed to ${status} from TUI`
-      }
-    });
-  }
-  async deleteSpecification(client2, projectId, specificationId, mode = "archive") {
-    const deleteMutation = client2?.specification?.delete?.mutate;
-    if (typeof deleteMutation !== "function") {
-      throw new Error("Specification delete route is unavailable.");
-    }
-    await deleteMutation({
-      projectId,
-      id: specificationId,
-      mode
-    });
-  }
-  async refineSpecificationWithAi(client2, input) {
-    const refineMutation = client2?.specification?.refine?.mutate;
-    if (typeof refineMutation !== "function") {
-      throw new Error("Specification refine route is unavailable.");
-    }
-    const result = await refineMutation({
-      projectId: input.projectId,
-      specificationContent: input.specContent,
-      userMessage: input.userMessage,
-      agentType: input.agentType
-    });
-    if (typeof result?.content !== "string") {
-      throw new Error("AI refinement response was missing content.");
-    }
-    return result.content;
-  }
-};
-
-// src/services/context-service.ts
-var TuiContextService = class {
-  static {
-    __name(this, "TuiContextService");
-  }
-  apiUrl;
-  authService;
-  bootstrapService;
-  bridgeService;
-  decisionService;
-  exportService;
-  organizationService;
-  repoService;
-  specService;
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-    this.authService = new AuthService(apiUrl);
-    this.bootstrapService = new BootstrapService(apiUrl);
-    this.bridgeService = new BridgeService(apiUrl);
-    this.decisionService = new DecisionService();
-    this.exportService = new ExportService(apiUrl);
-    this.organizationService = new OrganizationService(apiUrl);
-    this.repoService = new RepoService(apiUrl);
-    this.specService = new SpecService();
-  }
-  // ── Bootstrap ──────────────────────────────────────────────────────
-  async bootstrap(projectIdArg) {
-    return this.bootstrapService.bootstrap(projectIdArg);
-  }
-  hasDeclaredProjectContext(projectIdArg) {
-    return this.bootstrapService.hasDeclaredProjectContext(projectIdArg);
-  }
-  hasLocalProjectContext(repoPath) {
-    return this.bootstrapService.hasLocalProjectContext(repoPath);
-  }
-  async loadWorkflowSummary(client2, projectId) {
-    return this.bootstrapService.loadWorkflowSummary(client2, projectId);
-  }
-  persistContext(organizationId, projectId) {
-    this.bootstrapService.persistContext(organizationId, projectId);
-  }
-  // ── Auth ───────────────────────────────────────────────────────────
-  async checkAuthentication() {
-    return this.authService.checkAuthentication();
-  }
-  async authenticateViaCli(onProgress) {
-    return this.authService.authenticateViaCli(onProgress);
-  }
-  extractUserEmail(token) {
-    return this.authService.extractUserEmail(token);
-  }
-  extractTokenExpiry(token) {
-    return this.authService.extractTokenExpiry(token);
-  }
-  // ── Organization & Project ─────────────────────────────────────────
-  async listOrganizations() {
-    return this.organizationService.listOrganizations();
-  }
-  async createOrganization(input) {
-    return this.organizationService.createOrganization(input);
-  }
-  async listProjects(organizationId) {
-    return this.organizationService.listProjects(organizationId);
-  }
-  async createProject(organizationId, name) {
-    return this.organizationService.createProject(organizationId, name);
-  }
-  canCreateProject(org) {
-    return this.organizationService.canCreateProject(org);
-  }
-  // ── Specs ──────────────────────────────────────────────────────────
-  async loadSpecs(client2, projectId) {
-    return this.specService.loadSpecs(client2, projectId);
-  }
-  async updateSpecificationContent(client2, projectId, specificationId, content) {
-    return this.specService.updateSpecificationContent(client2, projectId, specificationId, content);
-  }
-  async updateSpecificationStatus(client2, projectId, specificationId, status) {
-    return this.specService.updateSpecificationStatus(client2, projectId, specificationId, status);
-  }
-  async deleteSpecification(client2, projectId, specificationId, mode = "archive") {
-    return this.specService.deleteSpecification(client2, projectId, specificationId, mode);
-  }
-  async refineSpecificationWithAi(client2, input) {
-    return this.specService.refineSpecificationWithAi(client2, input);
-  }
-  // ── Decisions ──────────────────────────────────────────────────────
-  async loadDecisions(client2, projectId) {
-    return this.decisionService.loadDecisions(client2, projectId);
-  }
-  async resolveDecision(client2, projectId, decisionId, status, reason, existingRationale) {
-    return this.decisionService.resolveDecision(client2, projectId, decisionId, status, reason, existingRationale);
-  }
-  async deleteDecision(client2, projectId, decisionId, mode = "archive") {
-    return this.decisionService.deleteDecision(client2, projectId, decisionId, mode);
-  }
-  // ── Export ─────────────────────────────────────────────────────────
-  async previewExport(client2, projectId, format) {
-    return this.exportService.previewExport(client2, projectId, format);
-  }
-  async generateExport(client2, projectId, format) {
-    return this.exportService.generateExport(client2, projectId, format);
-  }
-  async discoverExportCapabilities(projectId, organizationId) {
-    return this.exportService.discoverExportCapabilities(projectId, organizationId);
-  }
-  async exportStatus(projectId, format, options) {
-    return this.exportService.exportStatus(projectId, format, options);
-  }
-  async deliverExport(projectId, format, delivery, options) {
-    return this.exportService.deliverExport(projectId, format, delivery, options);
-  }
-  // ── Bridge ─────────────────────────────────────────────────────────
-  async loadBridgeSummary(client2) {
-    return this.bridgeService.loadBridgeSummary(client2);
-  }
-  async loadLocalBridgeSummary() {
-    return this.bridgeService.loadLocalBridgeSummary();
-  }
-  startLocalBridgeDetached() {
-    this.bridgeService.startLocalBridgeDetached();
-  }
-  async stopLocalBridge(configPort) {
-    return this.bridgeService.stopLocalBridge(configPort);
-  }
-  async loadBridgeLogs(port, since) {
-    return this.bridgeService.loadBridgeLogs(port, since);
-  }
-  // ── Repository ─────────────────────────────────────────────────────
-  attachOrSyncCurrentRepository = /* @__PURE__ */ __name(async (organizationId, projectId, onProgress, _agentType, requestInteraction, onActivity) => {
-    return this.repoService.attachOrSyncCurrentRepository(organizationId, projectId, onProgress, _agentType, requestInteraction, onActivity);
-  }, "attachOrSyncCurrentRepository");
-  async syncRepositoryViaCli(organizationId, projectId, repoPathInput, options) {
-    return this.repoService.syncRepositoryViaCli(organizationId, projectId, repoPathInput, options);
-  }
-  async detachContextViaCli(_projectId, repoPath = process.cwd()) {
-    return this.repoService.detachContextViaCli(_projectId, repoPath);
-  }
-};
-
-// src/store/service-bridge.ts
-var service = null;
-var client = null;
-function initServiceBridge(apiUrl) {
-  if (!service) {
-    service = new TuiContextService(apiUrl);
-  }
-  return service;
-}
-__name(initServiceBridge, "initServiceBridge");
-function getService() {
-  if (!service) {
-    throw new Error("Service bridge not initialized. Call initServiceBridge() first.");
-  }
-  return service;
-}
-__name(getService, "getService");
-function getClient() {
-  return client;
-}
-__name(getClient, "getClient");
-function setClient(c) {
-  client = c;
-}
-__name(setClient, "setClient");
-
-// 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,
-  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
-  }), "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"),
-  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",
-  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"),
-  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",
-    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: [],
-  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: []
-  }), "clearProjectData"),
-  updateSpecificationContent: /* @__PURE__ */ __name(async (specificationId, content) => {
-    const client2 = getClient();
-    const boot = getBootContext();
-    if (!client2 || !boot) return;
-    await withSessionFeedback({
-      statusLine: "Saving specification...",
-      action: /* @__PURE__ */ __name(() => getService().updateSpecificationContent(client2, 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 client2 = getClient();
-    const boot = getBootContext();
-    if (!client2 || !boot) return;
-    setSessionStatusLine(`Updating status to ${status}...`);
-    try {
-      await getService().updateSpecificationStatus(client2, boot.projectId, specificationId, status);
-      appendSessionLog(`[specs] status updated to ${status}`);
-      if (options?.refresh !== false) {
-        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-KS4DPNDY.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 client2 = getClient();
-    const boot = getBootContext();
-    if (!client2 || !boot) return;
-    setSessionStatusLine(mode === "delete" ? "Deleting specification permanently..." : "Archiving specification...");
-    try {
-      await getService().deleteSpecification(client2, 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-KS4DPNDY.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 client2 = getClient();
-    const boot = getBootContext();
-    const { specs } = get();
-    if (!client2 || !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 service2 = getService();
-    try {
-      const refinedContent = await service2.refineSpecificationWithAi(client2, {
-        projectId: boot.projectId,
-        specContent,
-        userMessage,
-        agentType: "codex"
-      });
-      await service2.updateSpecificationContent(client2, boot.projectId, specificationId, refinedContent);
-      appendSessionLog("[specs] AI refinement applied and saved");
-      const { useSessionStore: useSessionStore2 } = await import("./use-session-store-KS4DPNDY.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 client2 = getClient();
-    const boot = getBootContext();
-    if (!client2 || !boot) {
-      throw new Error("Decision update unavailable: project context is not initialized.");
-    }
-    setSessionStatusLine(`Resolving decision as ${status}...`);
-    try {
-      await getService().resolveDecision(client2, boot.projectId, decisionId, status, reason, existingRationale);
-      appendSessionLog(`[decisions] ${decisionId} -> ${status}`);
-      if (options?.refresh !== false) {
-        const { useSessionStore: useSessionStore2 } = await import("./use-session-store-KS4DPNDY.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 client2 = getClient();
-    const boot = getBootContext();
-    if (!client2 || !boot) {
-      throw new Error("Decision delete unavailable: project context is not initialized.");
-    }
-    setSessionStatusLine(mode === "delete" ? "Deleting decision permanently..." : "Archiving decision...");
-    try {
-      await getService().deleteDecision(client2, 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-KS4DPNDY.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")
-})));
-
-// 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 service2 = getService();
-  const client2 = getClient();
-  try {
-    if (action === "status") {
-      const status = await service2.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 service2.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 service2.previewExport(client2, boot.projectId, format) : await service2.generateExport(client2, 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 service2 = getService();
-    try {
-      const result = await service2.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,
-  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"),
-  bridgeStart: /* @__PURE__ */ __name(() => {
-    const service2 = getService();
-    service2.startLocalBridgeDetached();
-    set({
-      startedByTui: true
-    });
-    appendSessionLog("[bridge] Started local bridge process (detached)");
-    setSessionStatusLine("Bridge start triggered (detached)");
-  }, "bridgeStart"),
-  bridgeStop: /* @__PURE__ */ __name(async () => {
-    const service2 = getService();
-    const { localBridge } = get();
-    await service2.stopLocalBridge(localBridge?.port);
-    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 service2 = getService();
-  const boot = useSessionStore.getState().boot;
-  const organizations = await service2.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 service2.listProjects(selectedOrganization.id);
-  return {
-    mode,
-    step: organizations.length === 1 ? "project" : "organization",
-    attachCurrentFolder: mode === "initial-setup",
-    organizations,
-    projects,
-    availableAgents: [],
-    canCreateProject: service2.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 service2 = getService();
-    set({
-      loading: false,
-      auth: {
-        status: "authenticating"
-      },
-      statusLine: "Starting browser login flow..."
-    });
-    appendLog("[auth] starting login flow");
-    const ok = await service2.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 service2 = getService();
-    set((prev) => ({
-      loading: prev.boot ? false : true,
-      statusLine: "Loading context..."
-    }));
-    try {
-      const token = await service2.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: service2.extractUserEmail(token),
-          tokenExpiresAt: service2.extractTokenExpiry(token)
-        }
-      });
-      if (!projectId && !service2.hasLocalProjectContext()) {
-        const onboarding = await buildOnboardingState("initial-setup");
-        set({
-          loading: false,
-          error: null,
-          onboarding,
-          statusLine: "Project setup required"
-        });
-        return;
-      }
-      let bootstrapResult;
-      try {
-        bootstrapResult = await service2.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: client2 } = bootstrapResult;
-      setClient(client2);
-      const [specs, decisions, workflow, bridge, localBridge, exportCapabilities] = await Promise.all([
-        service2.loadSpecs(client2, boot.projectId),
-        service2.loadDecisions(client2, boot.projectId),
-        service2.loadWorkflowSummary(client2, boot.projectId),
-        service2.loadBridgeSummary(client2),
-        service2.loadLocalBridgeSummary(),
-        service2.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 service2 = getService();
-    const result = await service2.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 service2 = 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 service2.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) => {
-        if (event.event === "agent_chunk" && event.text) {
-          appendLog(`[agent] ${event.text}`);
-          options?.onProgress?.(event.text);
-        }
-        options?.onActivity?.(event);
-      }, "onActivity")
-    });
-    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"),
-  // Onboarding actions
-  selectOnboardingOrganization: /* @__PURE__ */ __name(async (index) => {
-    const { onboarding, appendLog } = get();
-    const service2 = 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 service2.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: service2.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 service2 = 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 {
-        service2.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 service2 = 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 service2.createProject(onboarding.selectedOrganizationId, trimmed);
-      appendLog(`[setup] Created project "${created.name}"`);
-      if (onboarding.mode === "switch-context" || !onboarding.attachCurrentFolder) {
-        service2.persistContext(onboarding.selectedOrganizationId, created.id);
-        appendLog(`[context] switched to ${created.name}`);
-        await refresh();
-        return;
-      }
-      set((prev) => ({
-        loading: true,
-        statusLine: "Registering repository...",
-        onboarding: prev.onboarding ? {
-          ...prev.onboarding,
-          step: "registering",
-          availableAgents: prev.onboarding?.availableAgents ?? [],
-          selectedProjectId: created.id,
-          runLines: [],
-          runStatus: "running",
-          interaction: void 0,
-          error: void 0
-        } : prev.onboarding
-      }));
-      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 service2 = getService();
-  const { appendLog } = useSessionStore.getState();
-  const result = await service2.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) => ({
-        onboarding: prev.onboarding ? {
-          ...prev.onboarding,
-          runLines: [
-            ...prev.onboarding.runLines ?? [],
-            event.text
-          ].slice(-400)
-        } : prev.onboarding
-      }));
-    }
-  });
-  useSessionStore.setState((prev) => ({
-    onboarding: prev.onboarding ? {
-      ...prev.onboarding,
-      runStatus: result.warning ? "error" : "success"
-    } : prev.onboarding
-  }));
-  logOnboardingAttachResult(appendLog, result);
-}
-__name(attachRepositoryFromOnboardingZustand, "attachRepositoryFromOnboardingZustand");
-
-export {
-  __name,
-  appendGlobalStructuredLog,
-  initServiceBridge,
-  getService,
-  getClient,
-  setInitialScreen,
-  useTuiUiStore,
-  resolveNavPolicy,
-  useOnboardingWindow,
-  buildOnboardingState,
-  useSessionStore,
-  useProjectDataStore,
-  useExportStore,
-  useBridgeStore
-};