@spekn/cli 1.0.0 → 1.0.2

package/dist/tui/chunk-WCTSFKTA.mjs

@@ -0,0 +1,3459 @@
+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));
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          child.kill("SIGTERM");
+        } else {
+          const onAbort = /* @__PURE__ */ __name(() => {
+            child.kill("SIGTERM");
+          }, "onAbort");
+          options.signal.addEventListener("abort", onAbort, {
+            once: true
+          });
+          child.on("close", () => options.signal?.removeEventListener("abort", onAbort));
+        }
+      }
+      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");
+async function loadWebMcpChannels(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/webmcp/channels`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.channels ?? [];
+  } catch {
+    return [];
+  }
+}
+__name(loadWebMcpChannels, "loadWebMcpChannels");
+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),
+      specGeneration: typeof result.specGeneration === "number" ? result.specGeneration : 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),
+      specGeneration: typeof result.specGeneration === "number" ? result.specGeneration : 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,
+        signal: options?.signal
+      });
+      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,
+        generationNumber: typeof spec.generationNumber === "number" ? spec.generationNumber : 1,
+        generationStatus: typeof spec.generationStatus === "string" ? spec.generationStatus : spec.status,
+        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",
+  startedAt: null,
+  availableAgents: [],
+  canCreateProject: false,
+  toolCalls: {},
+  setMode: /* @__PURE__ */ __name((mode) => set({
+    mode
+  }), "setMode"),
+  setStep: /* @__PURE__ */ __name((step) => set({
+    step
+  }), "setStep"),
+  setSelectedOrganizationIndex: /* @__PURE__ */ __name((index) => set({
+    selectedOrganizationIndex: index
+  }), "setSelectedOrganizationIndex"),
+  setSelectedProjectIndex: /* @__PURE__ */ __name((index) => set({
+    selectedProjectIndex: index
+  }), "setSelectedProjectIndex"),
+  setNewProjectName: /* @__PURE__ */ __name((name) => set({
+    newProjectName: name
+  }), "setNewProjectName"),
+  setAttachCurrentFolder: /* @__PURE__ */ __name((attach) => set({
+    attachCurrentFolder: attach
+  }), "setAttachCurrentFolder"),
+  setRunLines: /* @__PURE__ */ __name((lines) => set({
+    runLines: lines
+  }), "setRunLines"),
+  addRunLine: /* @__PURE__ */ __name((line) => set((state) => ({
+    runLines: [
+      ...state.runLines,
+      line
+    ].slice(-400)
+  })), "addRunLine"),
+  setRunStatus: /* @__PURE__ */ __name((status) => set({
+    runStatus: status
+  }), "setRunStatus"),
+  setStartedAt: /* @__PURE__ */ __name((ts) => set({
+    startedAt: ts
+  }), "setStartedAt"),
+  setInteraction: /* @__PURE__ */ __name((interaction) => set({
+    interaction
+  }), "setInteraction"),
+  setError: /* @__PURE__ */ __name((error) => set({
+    error
+  }), "setError"),
+  setSelectedOrganizationId: /* @__PURE__ */ __name((id) => set({
+    selectedOrganizationId: id
+  }), "setSelectedOrganizationId"),
+  setSelectedProjectId: /* @__PURE__ */ __name((id) => set({
+    selectedProjectId: id
+  }), "setSelectedProjectId"),
+  setAvailableAgents: /* @__PURE__ */ __name((agents) => set({
+    availableAgents: agents
+  }), "setAvailableAgents"),
+  setCanCreateProject: /* @__PURE__ */ __name((canCreate) => set({
+    canCreateProject: canCreate
+  }), "setCanCreateProject"),
+  upsertToolCall: /* @__PURE__ */ __name((event) => set((state) => {
+    const id = event.toolCallId ?? `tc-${Date.now()}`;
+    const existing = state.toolCalls[id];
+    const updated = existing ? {
+      ...existing,
+      status: event.status ?? existing.status,
+      title: event.title ?? existing.title,
+      locations: event.locations ?? existing.locations,
+      completedAt: event.status === "completed" || event.status === "failed" ? Date.now() : existing.completedAt
+    } : {
+      toolCallId: id,
+      title: event.title ?? event.toolName ?? "Tool call",
+      toolName: event.toolName,
+      kind: event.kind ?? "other",
+      status: event.status ?? "in_progress",
+      locations: event.locations ?? [],
+      startedAt: Date.now()
+    };
+    return {
+      toolCalls: {
+        ...state.toolCalls,
+        [id]: updated
+      }
+    };
+  }), "upsertToolCall"),
+  setActiveThought: /* @__PURE__ */ __name((text) => set({
+    activeThought: text
+  }), "setActiveThought"),
+  reset: /* @__PURE__ */ __name(() => set({
+    mode: "initial-setup",
+    step: "organization",
+    selectedOrganizationIndex: void 0,
+    selectedProjectIndex: void 0,
+    newProjectName: void 0,
+    attachCurrentFolder: true,
+    runLines: [],
+    runStatus: "running",
+    startedAt: null,
+    interaction: void 0,
+    error: void 0,
+    selectedOrganizationId: void 0,
+    selectedProjectId: void 0,
+    availableAgents: [],
+    canCreateProject: false,
+    toolCalls: {},
+    activeThought: void 0
+  }), "reset")
+})));
+
+// src/store/auth-utils.ts
+function isAuthenticationError(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("authentication required") || normalized.includes("no valid credentials") || normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("invalid token") || normalized.includes("token expired") || normalized.includes("auth");
+}
+__name(isAuthenticationError, "isAuthenticationError");
+
+// src/store/use-project-data-store.ts
+import { create as create3 } from "zustand";
+import { subscribeWithSelector as subscribeWithSelector3 } from "zustand/middleware";
+var EMPTY_WORKFLOW = {
+  currentPhase: null,
+  blockedCount: 0,
+  hasPlanningArtifacts: false,
+  hasVerificationEvidence: false
+};
+var useProjectDataStore = create3()(subscribeWithSelector3((set, get) => ({
+  specs: [],
+  decisions: [],
+  workflow: EMPTY_WORKFLOW,
+  navPolicy: [],
+  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-PTMWISNJ.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-PTMWISNJ.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-PTMWISNJ.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-PTMWISNJ.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-PTMWISNJ.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,
+  webmcpChannels: [],
+  setBridgeData: /* @__PURE__ */ __name((bridge, localBridge) => set({
+    bridge,
+    localBridge
+  }), "setBridgeData"),
+  setLocalBridge: /* @__PURE__ */ __name((localBridge) => set({
+    localBridge
+  }), "setLocalBridge"),
+  setBridgeLogs: /* @__PURE__ */ __name((logs) => {
+    if (logs.length === 0) return;
+    const lastTimestamp = logs[logs.length - 1].timestamp;
+    set((prev) => ({
+      bridgeLogs: [
+        ...prev.bridgeLogs,
+        ...logs
+      ].slice(-200),
+      bridgeLogsSince: lastTimestamp
+    }));
+  }, "setBridgeLogs"),
+  clearBridgeLogs: /* @__PURE__ */ __name(() => set({
+    bridgeLogs: []
+  }), "clearBridgeLogs"),
+  setWebMcpChannels: /* @__PURE__ */ __name((channels) => set({
+    webmcpChannels: channels
+  }), "setWebMcpChannels"),
+  bridgeStart: /* @__PURE__ */ __name(() => {
+    const 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);
+    if (localBridge) {
+      set({
+        localBridge: {
+          ...localBridge,
+          running: false,
+          uptimeSec: 0
+        },
+        webmcpChannels: []
+      });
+    }
+    appendSessionLog("[bridge] Stop signal sent");
+    setSessionStatusLine("Bridge stop signal sent");
+  }, "bridgeStop")
+})));
+
+// src/store/store-effects.ts
+function dispatchRefreshComplete(data) {
+  useProjectDataStore.getState().setProjectData(data.specs, data.decisions, data.workflow, data.navPolicy);
+  useExportStore.getState().setCapabilities(data.exportCapabilities);
+  useBridgeStore.getState().setBridgeData(data.bridge, data.localBridge);
+}
+__name(dispatchRefreshComplete, "dispatchRefreshComplete");
+function dispatchClearProjectData() {
+  useProjectDataStore.getState().clearProjectData();
+}
+__name(dispatchClearProjectData, "dispatchClearProjectData");
+function refreshOnAuthenticationError(message) {
+  if (!isAuthenticationError(message)) return;
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: "Authentication required. Refreshing context..."
+  });
+  appendLog("[auth] action requires authentication, refreshing context");
+  void refresh();
+}
+__name(refreshOnAuthenticationError, "refreshOnAuthenticationError");
+async function withSessionFeedback(opts) {
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: opts.statusLine
+  });
+  try {
+    const result = await opts.action();
+    appendLog(opts.successLog);
+    if (opts.refresh !== false) {
+      await refresh();
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    appendLog(`${opts.failureLog}: ${message}`);
+    useSessionStore.setState({
+      statusLine: opts.failureStatusLine
+    });
+    refreshOnAuthenticationError(message);
+    throw error;
+  }
+}
+__name(withSessionFeedback, "withSessionFeedback");
+function getBootContext() {
+  return useSessionStore.getState().boot;
+}
+__name(getBootContext, "getBootContext");
+function setSessionStatusLine(line) {
+  useSessionStore.setState({
+    statusLine: line
+  });
+}
+__name(setSessionStatusLine, "setSessionStatusLine");
+function appendSessionLog(entry) {
+  useSessionStore.getState().appendLog(entry);
+}
+__name(appendSessionLog, "appendSessionLog");
+
+// src/store/use-session-store.ts
+var onboardingInteractionResolver = null;
+function requestOnboardingInteraction(request) {
+  return new Promise((resolve) => {
+    onboardingInteractionResolver = resolve;
+    useSessionStore.setState((prev) => ({
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        interaction: request
+      } : prev.onboarding
+    }));
+  });
+}
+__name(requestOnboardingInteraction, "requestOnboardingInteraction");
+function refreshOnAuthenticationError2(message) {
+  if (!isAuthenticationError(message)) return;
+  const { appendLog, refresh } = useSessionStore.getState();
+  useSessionStore.setState({
+    statusLine: "Authentication required. Refreshing context..."
+  });
+  appendLog("[auth] action requires authentication, refreshing context");
+  void refresh();
+}
+__name(refreshOnAuthenticationError2, "refreshOnAuthenticationError");
+async function buildOnboardingState(mode) {
+  const 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) => {
+        options?.onActivity?.(event);
+      }, "onActivity"),
+      signal: options?.signal
+    });
+    if (!result.success) {
+      appendLog(`[error] repository sync failed (exit ${result.exitCode})`);
+      set({
+        statusLine: "Repository sync failed"
+      });
+      refreshOnAuthenticationError2(result.output);
+      return false;
+    }
+    appendLog("[repo] sync completed");
+    set({
+      statusLine: "Repository sync completed"
+    });
+    await refresh();
+    return true;
+  }, "syncRepository"),
+  // 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;
+      }
+      const registerStartedAt = Date.now();
+      set((prev) => ({
+        loading: true,
+        statusLine: "Registering repository...",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          step: "registering",
+          availableAgents: prev.onboarding?.availableAgents ?? [],
+          selectedProjectId: created.id,
+          runLines: [],
+          runStatus: "running",
+          startedAt: registerStartedAt,
+          interaction: void 0,
+          error: void 0
+        } : prev.onboarding
+      }));
+      useOnboardingWindow.getState().setStartedAt(registerStartedAt);
+      await attachRepositoryFromOnboardingZustand({
+        organizationId: onboarding.selectedOrganizationId,
+        projectId: created.id
+      });
+      await refresh();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      set((prev) => ({
+        loading: false,
+        statusLine: "Setup error",
+        onboarding: prev.onboarding ? {
+          ...prev.onboarding,
+          error: message
+        } : prev.onboarding
+      }));
+    }
+  }, "createOnboardingProject"),
+  resolveOnboardingInteraction: /* @__PURE__ */ __name((value) => {
+    const resolver = onboardingInteractionResolver;
+    onboardingInteractionResolver = null;
+    set((prev) => ({
+      onboarding: prev.onboarding ? {
+        ...prev.onboarding,
+        interaction: void 0
+      } : prev.onboarding
+    }));
+    if (resolver) resolver(value);
+  }, "resolveOnboardingInteraction"),
+  setOnboardingAttachCurrentFolder: /* @__PURE__ */ __name((attach) => {
+    set((prev) => ({
+      onboarding: prev.onboarding ? prev.onboarding.attachCurrentFolder === attach ? prev.onboarding : {
+        ...prev.onboarding,
+        attachCurrentFolder: attach
+      } : prev.onboarding
+    }));
+  }, "setOnboardingAttachCurrentFolder")
+})));
+async function attachRepositoryFromOnboardingZustand(input) {
+  const 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) => {
+        if (!prev.onboarding) return prev;
+        const lines = [
+          ...prev.onboarding.runLines ?? []
+        ];
+        const parts = event.text.split("\n");
+        if (lines.length === 0) {
+          lines.push(parts[0]);
+        } else {
+          lines[lines.length - 1] += parts[0];
+        }
+        for (let i = 1; i < parts.length; i++) {
+          lines.push(parts[i]);
+        }
+        return {
+          onboarding: {
+            ...prev.onboarding,
+            runLines: lines.slice(-400)
+          }
+        };
+      });
+    }
+  });
+  useSessionStore.setState((prev) => ({
+    onboarding: prev.onboarding ? {
+      ...prev.onboarding,
+      runStatus: result.warning ? "error" : "success"
+    } : prev.onboarding
+  }));
+  logOnboardingAttachResult(appendLog, result);
+}
+__name(attachRepositoryFromOnboardingZustand, "attachRepositoryFromOnboardingZustand");
+
+export {
+  __name,
+  appendGlobalStructuredLog,
+  loadWebMcpChannels,
+  initServiceBridge,
+  getService,
+  getClient,
+  setInitialScreen,
+  useTuiUiStore,
+  resolveNavPolicy,
+  useOnboardingWindow,
+  buildOnboardingState,
+  useSessionStore,
+  useProjectDataStore,
+  useExportStore,
+  useBridgeStore
+};