@spekn/cli 1.0.1 → 1.0.2

package/dist/tui/chunk-JKFOY4IF.mjs

@@ -0,0 +1,2003 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auth/credentials-store.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path 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 ?? path.join(os.homedir(), ".spekn");
+    this.credentialsPath = path.join(this.configDir, "credentials.json");
+  }
+  load() {
+    try {
+      const raw = fs.readFileSync(this.credentialsPath, "utf-8");
+      return CliCredentialsSchema.parse(JSON.parse(raw));
+    } catch {
+      return null;
+    }
+  }
+  save(creds) {
+    fs.mkdirSync(this.configDir, {
+      recursive: true,
+      mode: 448
+    });
+    const json = JSON.stringify(creds, null, 2);
+    fs.writeFileSync(this.credentialsPath, json, {
+      encoding: "utf-8",
+      mode: 384
+    });
+  }
+  clear() {
+    try {
+      fs.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/utils/project-context.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+var LOCAL_CONTEXT_FILE = ".spekn";
+var GLOBAL_CONTEXT_PATH = path2.join(os2.homedir(), ".spekn", "context.json");
+var GLOBAL_CONFIG_PATH = path2.join(os2.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 = fs2.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 = fs2.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 path2.dirname(dirPath) === dirPath;
+}
+__name(isRoot, "isRoot");
+function findNearestLocalContextFile(startDir = process.cwd()) {
+  let current = path2.resolve(startDir);
+  while (true) {
+    const candidate = path2.join(current, LOCAL_CONTEXT_FILE);
+    if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+      return candidate;
+    }
+    if (isRoot(current)) return null;
+    current = path2.dirname(current);
+  }
+}
+__name(findNearestLocalContextFile, "findNearestLocalContextFile");
+function resolveContextWorkspaceRoot(input) {
+  const fallback = path2.resolve(input?.fallbackDir ?? process.cwd());
+  try {
+    const raw = fs2.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 fs2.existsSync(repoPath);
+      } catch {
+        return false;
+      }
+    });
+    const resolvedPath = existingPath ?? repoPaths[0];
+    if (typeof resolvedPath === "string" && resolvedPath.trim().length > 0) {
+      return path2.resolve(resolvedPath);
+    }
+  } catch {
+  }
+  return fallback;
+}
+__name(resolveContextWorkspaceRoot, "resolveContextWorkspaceRoot");
+function resolveDeclaredContext(input) {
+  const localPath = input.repoPath ? path2.join(path2.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 = path2.join(path2.resolve(repoPath), LOCAL_CONTEXT_FILE);
+  const content = {
+    projectId: context.projectId,
+    organizationId: context.organizationId,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs2.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n", "utf-8");
+}
+__name(saveLocalContext, "saveLocalContext");
+function saveGlobalContext(repoPathInput, context) {
+  const dirPath = path2.dirname(GLOBAL_CONTEXT_PATH);
+  fs2.mkdirSync(dirPath, {
+    recursive: true,
+    mode: 448
+  });
+  const existing = loadGlobalContextData();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const repoPath = path2.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
+  };
+  fs2.writeFileSync(GLOBAL_CONTEXT_PATH, JSON.stringify(content, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+__name(saveGlobalContext, "saveGlobalContext");
+function saveGlobalContextSelectionOnly(context) {
+  const dirPath = path2.dirname(GLOBAL_CONTEXT_PATH);
+  fs2.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
+  };
+  fs2.writeFileSync(GLOBAL_CONTEXT_PATH, JSON.stringify(content, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+__name(saveGlobalContextSelectionOnly, "saveGlobalContextSelectionOnly");
+function ensureGitignoreHasSpekn(repoPath) {
+  const gitignorePath = path2.join(path2.resolve(repoPath), ".gitignore");
+  const entry = ".spekn";
+  if (!fs2.existsSync(gitignorePath)) {
+    fs2.writeFileSync(gitignorePath, `${entry}
+`, "utf-8");
+    return;
+  }
+  const content = fs2.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}
+`;
+  fs2.appendFileSync(gitignorePath, toAppend, "utf-8");
+}
+__name(ensureGitignoreHasSpekn, "ensureGitignoreHasSpekn");
+function hasLocalContext(repoPath) {
+  const startDir = repoPath ? path2.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 = fs2.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 = path2.dirname(GLOBAL_CONFIG_PATH);
+  fs2.mkdirSync(dirPath, {
+    recursive: true,
+    mode: 448
+  });
+  fs2.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+__name(saveGlobalContextConfig, "saveGlobalContextConfig");
+function ensureGlobalContextConfig() {
+  const config = loadGlobalContextConfig();
+  if (!fs2.existsSync(GLOBAL_CONFIG_PATH)) {
+    saveGlobalContextConfig(config);
+  }
+  return config;
+}
+__name(ensureGlobalContextConfig, "ensureGlobalContextConfig");
+function expandHomePath(filePath) {
+  if (filePath === "~") return os2.homedir();
+  if (filePath.startsWith("~/")) {
+    return path2.join(os2.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 = path2.resolve(expandHomePath(config.logging.path));
+    const dirPath = path2.dirname(logPath);
+    fs2.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 ?? {}
+    };
+    fs2.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/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;
+  }
+  async createSpecification(client2, projectId, title, content, status = "draft") {
+    const createMutation = client2?.specification?.create?.mutate;
+    if (typeof createMutation !== "function") {
+      throw new Error("Specification create route is unavailable.");
+    }
+    const result = await createMutation({
+      projectId,
+      title,
+      content,
+      status
+    });
+    return {
+      id: result.id
+    };
+  }
+  async listGenerations(client2, projectId, specId) {
+    const query = client2?.specification?.listGenerations?.query;
+    if (typeof query !== "function") {
+      throw new Error("Specification listGenerations route is unavailable.");
+    }
+    const result = await query({
+      projectId,
+      specificationId: specId
+    });
+    return Array.isArray(result) ? result : [];
+  }
+  async startNewGeneration(client2, projectId, specId, fromGenerationId) {
+    const mutation = client2?.specification?.startNewGeneration?.mutate;
+    if (typeof mutation !== "function") {
+      throw new Error("Specification startNewGeneration route is unavailable.");
+    }
+    return await mutation({
+      projectId,
+      specificationId: specId,
+      fromGenerationId
+    });
+  }
+  async lockGeneration(client2, projectId, specId) {
+    const mutation = client2?.specification?.lock?.mutate;
+    if (typeof mutation !== "function") {
+      throw new Error("Specification lock route is unavailable.");
+    }
+    await mutation({
+      projectId,
+      specificationId: specId
+    });
+  }
+  async unlockGeneration(client2, projectId, specId) {
+    const mutation = client2?.specification?.unlock?.mutate;
+    if (typeof mutation !== "function") {
+      throw new Error("Specification unlock route is unavailable.");
+    }
+    await mutation({
+      projectId,
+      specificationId: specId
+    });
+  }
+  async deleteGeneration(client2, projectId, generationId) {
+    const mutation = client2?.specification?.deleteGeneration?.mutate;
+    if (typeof mutation !== "function") {
+      throw new Error("Specification deleteGeneration route is unavailable.");
+    }
+    await mutation({
+      projectId,
+      generationId
+    });
+  }
+};
+
+// 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);
+  }
+  async createSpecification(client2, projectId, title, content, status = "draft") {
+    return this.specService.createSpecification(client2, projectId, title, content, status);
+  }
+  async listGenerations(client2, projectId, specId) {
+    return this.specService.listGenerations(client2, projectId, specId);
+  }
+  async startNewGeneration(client2, projectId, specId, fromGenerationId) {
+    return this.specService.startNewGeneration(client2, projectId, specId, fromGenerationId);
+  }
+  async lockGeneration(client2, projectId, specId) {
+    return this.specService.lockGeneration(client2, projectId, specId);
+  }
+  async unlockGeneration(client2, projectId, specId) {
+    return this.specService.unlockGeneration(client2, projectId, specId);
+  }
+  async deleteGeneration(client2, projectId, generationId) {
+    return this.specService.deleteGeneration(client2, projectId, generationId);
+  }
+  // ── 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");
+
+export {
+  __name,
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  OrganizationPlan,
+  WorkflowPhase,
+  persistProjectContext,
+  appendGlobalStructuredLog,
+  loadWebMcpChannels,
+  initServiceBridge,
+  getService,
+  getClient,
+  setClient
+};