@spekn/cli 1.0.3 → 1.0.6

package/dist/tui/chunk-YUYJ7VBG.mjs

@@ -1,2029 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// 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 registerRepositoryViaCli(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",
-      "register",
-      "--project-id",
-      projectId,
-      "--path",
-      repoPath,
-      "--api-url",
-      this.apiUrl
-    ];
-    if (options?.primary) {
-      args.push("--primary");
-    }
-    if (options?.analyze === false) {
-      args.push("--no-analyze");
-    } else {
-      args.push("--analyze");
-    }
-    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
-      });
-      if (runResult.success) {
-        persistProjectContext(repoPath, {
-          projectId,
-          organizationId
-        });
-      }
-      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 registerRepositoryViaCli(organizationId, projectId, repoPathInput, options) {
-    return this.repoService.registerRepositoryViaCli(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,
-  OrganizationPlan,
-  WorkflowPhase,
-  persistProjectContext,
-  appendGlobalStructuredLog,
-  loadWebMcpChannels,
-  initServiceBridge,
-  getService,
-  getClient,
-  setClient
-};