@forloop-cc/forloop-cli 0.2.2 → 0.2.4

package/dist/forloop

@@ -28,7 +28,7 @@ function buildSchema(options) {
 }
 function scanCommandPath(argv, globalOptions = []) {
   const globalSchema = buildSchema(globalOptions);
-  const path3 = [];
+  const path6 = [];
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -48,10 +48,10 @@ function scanCommandPath(argv, globalOptions = []) {
       i++;
       continue;
     }
-    path3.push(arg);
+    path6.push(arg);
     i++;
   }
-  return path3;
+  return path6;
 }
 function parseFlags(argv, options) {
   const schema = buildSchema(options);
@@ -142,8 +142,727 @@ var GLOBAL_OPTIONS = [
   { flag: "--version", description: "Print version" }
 ];
 
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/token-storage.ts
+import { promises as fs } from "fs";
+import path from "path";
+var getTokenPath = () => {
+  return path.join(
+    process.env.HOME || process.env.USERPROFILE || ".",
+    ".config",
+    "forloop",
+    "tokens.json"
+  );
+};
+async function loadTokens() {
+  const tokenPath = getTokenPath();
+  try {
+    const content = await fs.readFile(tokenPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        version: "1.0",
+        note: "ForLoop API tokens - do not share",
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    throw error;
+  }
+}
+async function saveTokens(tokens) {
+  const tokenPath = getTokenPath();
+  const configDir = path.dirname(tokenPath);
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(
+    tokenPath,
+    JSON.stringify(tokens, null, 2),
+    { mode: 384 }
+  );
+}
+async function getToken(profile) {
+  const tokens = await loadTokens();
+  if (profile && tokens.profiles?.[profile]) {
+    return tokens.profiles[profile];
+  }
+  if (tokens.default) return tokens.default;
+  if (tokens.profiles?.["default"]) return tokens.profiles["default"];
+  return null;
+}
+async function setToken(token, profile) {
+  const tokens = await loadTokens();
+  tokens.version = "1.0";
+  tokens.note = "ForLoop API tokens - do not share";
+  if (profile) {
+    if (!tokens.profiles) {
+      tokens.profiles = {};
+    }
+    tokens.profiles[profile] = token;
+  } else {
+    tokens.default = token;
+  }
+  tokens.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTokens(tokens);
+}
+async function clearToken(profile) {
+  const tokens = await loadTokens();
+  if (profile) {
+    if (tokens.profiles) {
+      delete tokens.profiles[profile];
+    }
+  } else {
+    delete tokens.default;
+  }
+  tokens.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTokens(tokens);
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/config.ts
+import fs2 from "fs";
+import path2 from "path";
+var PROD_API_URL = "https://api.forloop.cc";
+var DEV_API_URL = "https://api.dev.forloop.cc";
+var PROD_TOKENS_URL = "https://forloop.cc/profile?tab=api-tokens";
+var DEV_TOKENS_URL = "https://dev.forloop.cc/profile?tab=api-tokens";
+var readJsonFileIfExists = (filePath) => {
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var getHomeDir = () => {
+  return process.env.HOME || process.env.USERPROFILE || "";
+};
+var getProjectConfig = () => {
+  return readJsonFileIfExists(path2.join(process.cwd(), "opencode.json"));
+};
+var getGlobalConfig = () => {
+  const home = getHomeDir();
+  if (!home) return null;
+  return readJsonFileIfExists(path2.join(home, ".config", "opencode", "config.json"));
+};
+var getNested = (obj, keys) => {
+  let cur = obj;
+  for (const key of keys) {
+    if (!cur || typeof cur !== "object") return void 0;
+    cur = cur[key];
+  }
+  return cur;
+};
+var isTruthy = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true" || value === "1";
+  return false;
+};
+var normalizeUrl = (value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed;
+};
+var isDevUrl = (apiUrl) => {
+  return apiUrl.includes("api.dev.forloop.cc") || apiUrl.includes("dev.forloop.cc");
+};
+var resolveAllowDev = (projectConfig, globalConfig) => {
+  return isTruthy(process.env.FORLOOP_ALLOW_DEV) || isTruthy(getNested(projectConfig, ["forloop", "allowDev"])) || isTruthy(getNested(globalConfig, ["forloop", "allowDev"]));
+};
+var resolveApiUrl = (projectConfig, globalConfig, allowDev) => {
+  const envApiUrl = normalizeUrl(process.env.FORLOOP_API_URL || process.env.FORLOOP_API_BASE);
+  if (envApiUrl) {
+    if (isDevUrl(envApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Dev API URL ignored (set FORLOOP_ALLOW_DEV=true to enable)");
+      return PROD_API_URL;
+    }
+    return envApiUrl;
+  }
+  const envName = normalizeUrl(process.env.FORLOOP_ENV);
+  if (envName) {
+    if (envName === "production") return PROD_API_URL;
+    if (envName === "development") {
+      if (!allowDev) {
+        console.warn("[ForLoop Config] FORLOOP_ENV=development ignored (set FORLOOP_ALLOW_DEV=true to enable)");
+        return PROD_API_URL;
+      }
+      return DEV_API_URL;
+    }
+  }
+  const projectApiUrl = normalizeUrl(getNested(projectConfig, ["forloop", "apiUrl"]));
+  if (projectApiUrl) {
+    if (isDevUrl(projectApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Project dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)");
+      return PROD_API_URL;
+    }
+    return projectApiUrl;
+  }
+  const globalApiUrl = normalizeUrl(getNested(globalConfig, ["forloop", "apiUrl"]));
+  if (globalApiUrl) {
+    if (isDevUrl(globalApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Global dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)");
+      return PROD_API_URL;
+    }
+    return globalApiUrl;
+  }
+  return PROD_API_URL;
+};
+var detectEnvironment = (apiUrl) => {
+  if (apiUrl.includes("dev.forloop.cc")) {
+    return "development";
+  }
+  if (apiUrl.includes("api.forloop.cc")) {
+    return "production";
+  }
+  return "custom";
+};
+var getConfig = () => {
+  const projectConfig = getProjectConfig();
+  const globalConfig = getGlobalConfig();
+  const allowDev = resolveAllowDev(projectConfig, globalConfig);
+  const apiUrl = resolveApiUrl(projectConfig, globalConfig, allowDev);
+  return {
+    apiUrl,
+    environment: detectEnvironment(apiUrl),
+    tokenStorage: "global",
+    debug: process.env.FORLOOP_DEBUG === "true",
+    allowDev
+  };
+};
+var getTokensUrl = () => {
+  const config = getConfig();
+  if (config.environment === "development") return DEV_TOKENS_URL;
+  return PROD_TOKENS_URL;
+};
+var isLambdaExecution = () => {
+  const forced = (process.env.FORLOOP_EXECUTION_CONTEXT || "").toLowerCase();
+  if (forced === "lambda" || forced === "aws_lambda" || forced === "aws-lambda") return true;
+  return !!(process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.AWS_EXECUTION_ENV || process.env.LAMBDA_TASK_ROOT);
+};
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/auth.ts
+function detectTokenType(token) {
+  if (!token) return null;
+  if (token.startsWith("floop_")) {
+    return "api_key";
+  }
+  const parts = token.split(".");
+  if (parts.length === 3 && parts.every((p) => p.length > 0)) {
+    const base64urlRegex = /^[A-Za-z0-9_-]+$/;
+    if (parts.every((p) => base64urlRegex.test(p))) {
+      return "jwt";
+    }
+  }
+  return null;
+}
+async function validateToken(providedToken) {
+  const token = providedToken || await getToken();
+  if (!token) {
+    return {
+      valid: false,
+      error: "No API token configured. Please create a token at " + getTokensUrl()
+    };
+  }
+  const tokenType = detectTokenType(token);
+  if (!tokenType) {
+    return {
+      valid: false,
+      error: "Unrecognized token format. Use either a ForLoop API key (floop_*) or a valid JWT token."
+    };
+  }
+  if (tokenType === "jwt") {
+    const isLambda = isLambdaExecution();
+    if (!isLambda) {
+      return {
+        valid: false,
+        error: "JWT tokens are only supported in Lambda execution. Please use a ForLoop API key (floop_*) for local execution."
+      };
+    }
+    return {
+      valid: true,
+      token,
+      tokenType: "jwt"
+    };
+  }
+  return {
+    valid: true,
+    token,
+    tokenType: "api_key"
+  };
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/api-client.ts
+var APIError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "APIError";
+  }
+};
+var ForLoopAPIClient = class {
+  config;
+  defaultHeaders;
+  tokenType;
+  jwtExchangePromise;
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      retryCount: 3,
+      ...config
+    };
+    this.defaultHeaders = {
+      "Content-Type": "application/json"
+    };
+    this.tokenType = detectTokenType(config.token);
+    this.jwtExchangePromise = null;
+  }
+  setToken(token) {
+    this.config.token = token;
+    this.tokenType = detectTokenType(token);
+  }
+  async ensureOpencodeApiToken(endpoint) {
+    if (this.tokenType !== "jwt") return;
+    if (!endpoint.startsWith("/api/opencode/")) return;
+    if (endpoint.startsWith("/api/opencode/auth/tokens")) return;
+    if (!this.jwtExchangePromise) {
+      this.jwtExchangePromise = this.exchangeJwtForApiToken();
+    }
+    const token = await this.jwtExchangePromise;
+    this.setToken(token);
+  }
+  async exchangeJwtForApiToken() {
+    const url = `${this.config.baseUrl}/api/opencode/auth/tokens`;
+    const jwt = this.config.token;
+    const scopes = [
+      "sprint:read",
+      "sprint:write",
+      "story:read",
+      "story:write",
+      "story:delete",
+      "agent:read",
+      "agent:query",
+      "profile:read",
+      "organization:read",
+      "organization:write",
+      "organization:delete"
+    ];
+    const name = `lambda-planner-${Date.now()}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.defaultHeaders,
+        Authorization: `Bearer ${jwt}`
+      },
+      body: JSON.stringify({
+        name,
+        expiresIn: "7d",
+        scopes
+      }),
+      signal: AbortSignal.timeout(this.config.timeout)
+    });
+    if (!response.ok) {
+      throw await this.parseError(response);
+    }
+    const payload = await response.json();
+    const token = typeof payload?.token === "string" ? payload.token.trim() : "";
+    if (!token) {
+      throw new APIError("invalid_token_exchange", "Token exchange returned empty token", 500);
+    }
+    await setToken(token);
+    return token;
+  }
+  /**
+   * Get auth headers based on token type
+   * - JWT tokens: Authorization: Bearer <token>
+   * - API keys: X-API-Token: <token>
+   */
+  getAuthHeaders() {
+    const headers = {};
+    if (this.tokenType === "jwt") {
+      headers["Authorization"] = `Bearer ${this.config.token}`;
+    } else {
+      headers["X-API-Token"] = this.config.token;
+    }
+    return headers;
+  }
+  async request(endpoint, options = {}) {
+    await this.ensureOpencodeApiToken(endpoint);
+    const url = `${this.config.baseUrl}${endpoint}`;
+    let lastError = null;
+    for (let attempt = 1; attempt <= this.config.retryCount; attempt++) {
+      try {
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            ...this.defaultHeaders,
+            ...this.getAuthHeaders(),
+            // Dynamic auth headers based on token type
+            ...options.headers || {}
+          },
+          signal: AbortSignal.timeout(this.config.timeout)
+        });
+        if (!response.ok) {
+          const error = await this.parseError(response);
+          throw error;
+        }
+        return response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof APIError && error.status >= 400 && error.status < 500) {
+          throw error;
+        }
+        if (attempt < this.config.retryCount) {
+          await this.sleep(Math.pow(2, attempt) * 100);
+        }
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+  async parseError(response) {
+    try {
+      const body = await response.json();
+      return new APIError(body.error || "UnknownError", body.message || response.statusText, response.status);
+    } catch {
+      return new APIError("UnknownError", response.statusText, response.status);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async listSprints(params) {
+    const query = new URLSearchParams(params);
+    const response = await this.request(`/api/opencode/sprints?${query}`);
+    return Array.isArray(response) ? response : response.data || [];
+  }
+  async getSprint(id, options) {
+    const query = new URLSearchParams({
+      includeStories: options?.includeStories !== false ? "true" : "false",
+      includeFiles: options?.includeFiles !== false ? "true" : "false"
+    });
+    return this.request(`/api/opencode/sprints/${id}?${query}`);
+  }
+  async createSprint(data) {
+    return this.request("/api/opencode/sprints", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateSprint(id, data) {
+    return this.request(`/api/opencode/sprints/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteSprint(id) {
+    await this.request(`/api/opencode/sprints/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async createStory(data) {
+    return this.request("/api/opencode/stories", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getStory(id, options) {
+    const params = new URLSearchParams();
+    if (options?.includeComments) params.set("includeComments", "true");
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.request(`/api/opencode/stories/${id}${query}`);
+  }
+  async updateStory(id, data) {
+    return this.request(`/api/opencode/stories/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteStory(id) {
+    await this.request(`/api/opencode/stories/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async listTemplates() {
+    return this.request("/api/opencode/templates");
+  }
+  async getUserProfile() {
+    return this.request("/api/opencode/user/profile");
+  }
+  async getUserQuotas() {
+    return this.request("/api/opencode/user/quotas");
+  }
+  async getOrganizationQuotas(orgId) {
+    return this.request(`/api/opencode/organization/${orgId}/quotas`);
+  }
+  async listOrganizations() {
+    return this.request("/api/opencode/organizations");
+  }
+  async getOwnedOrganizations() {
+    return this.request("/api/opencode/organizations/owned");
+  }
+  async getOrganization(id) {
+    return this.request(`/api/opencode/organizations/${id}`);
+  }
+  async createOrganization(data) {
+    return this.request("/api/opencode/organizations", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateOrganization(id, data) {
+    return this.request(`/api/opencode/organizations/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteOrganization(id) {
+    await this.request(`/api/opencode/organizations/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async chatWithAI(request) {
+    return this.request("/api/opencode/agents/chat", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getDeveloperStatus(sprintId) {
+    return this.request(`/api/opencode/sprints/${sprintId}/developer-status`);
+  }
+  async getStorySuggestions(sprintId, storyId) {
+    return this.request("/api/opencode/agents/suggestions", {
+      method: "POST",
+      body: JSON.stringify({ sprintId, storyId })
+    });
+  }
+  async getAITasks(sprintId) {
+    const query = sprintId ? new URLSearchParams({ sprintId: String(sprintId) }) : new URLSearchParams();
+    return this.request(`/api/opencode/agents/tasks?${query}`);
+  }
+  async getSprintSummaries(sprintId) {
+    return this.request(`/api/opencode/agents/summary?sprintId=${sprintId}`);
+  }
+  async getAgentSuggestions(request) {
+    return this.request("/api/agents/suggestions", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getStoryBreakdown(storyId) {
+    return this.request(`/api/agents/stories/${storyId}/breakdown`);
+  }
+  async getStoryEstimate(storyId) {
+    return this.request(`/api/agents/stories/${storyId}/estimate`);
+  }
+  async getConversationHistory(params) {
+    const query = new URLSearchParams();
+    if (params?.sprintId) query.append("sprintId", String(params.sprintId));
+    if (params?.limit) query.append("limit", String(params.limit));
+    return this.request(`/api/opencode/messages?${query}`);
+  }
+  async clearConversationHistory(params) {
+    const query = new URLSearchParams();
+    if (params?.sprintId) query.append("sprintId", String(params.sprintId));
+    query.append("confirm", "true");
+    return this.request(`/api/opencode/messages?${query}`, {
+      method: "DELETE"
+    });
+  }
+  async createPresignedUpload(data) {
+    return this.request("/api/opencode/files/presign", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async completeUpload(data) {
+    return this.request("/api/opencode/files/complete", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getSprintFiles(sprintId) {
+    return this.request(`/api/opencode/files/sprint/${sprintId}`);
+  }
+  async deleteFile(fileId) {
+    await this.request(`/api/opencode/files/${fileId}`, {
+      method: "DELETE"
+    });
+  }
+  async logFileRead(fileId) {
+    await this.request(`/api/opencode/files/${fileId}/read`, {
+      method: "POST"
+    });
+  }
+  async getFileDownloadUrl(fileId) {
+    return this.request(`/api/opencode/files/download/${fileId}`);
+  }
+  async getFileOpenUrl(fileId) {
+    return this.request(`/api/opencode/files/open-url/${fileId}`);
+  }
+  async updateFilePosition(fileId, data) {
+    return this.request(`/api/opencode/files/${fileId}/position`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async listAiAgents() {
+    const response = await this.request("/api/opencode/ai/agents");
+    return response.agents || [];
+  }
+  async updateSprintAiAgents(sprintId, enabledAgentKeys) {
+    const response = await this.request(`/api/opencode/sprints/${sprintId}/ai-agents`, {
+      method: "PUT",
+      body: JSON.stringify({ enabledAgentKeys })
+    });
+    return response.sprintAiAgents || [];
+  }
+  async updateSchedule(storyId, data) {
+    return this.updateStory(storyId, {
+      title: data.title,
+      description: data.description,
+      metadata: data
+    });
+  }
+  async recordMessage(data) {
+    return this.request("/api/opencode/messages", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async removeMessage(messageId, sprintId, sessionId) {
+    await this.request(`/api/opencode/messages/${encodeURIComponent(messageId)}`, {
+      method: "DELETE",
+      body: JSON.stringify({ sprintId, sessionId })
+    });
+  }
+};
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/sprint-tools.ts
+import { tool } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/context-resolver.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs3 from "fs";
+import * as path3 from "path";
+var execAsync = promisify(exec);
+async function getCurrentBranch(directory) {
+  try {
+    const result = await execAsync("git rev-parse --abbrev-ref HEAD", {
+      cwd: directory
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    throw new Error("Git not available or not in a repository");
+  }
+}
+async function resolveSprintFromBranch(branch) {
+  const match = branch.match(/sprint-(\d+)/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+async function resolveSprintId(providedId, directory) {
+  if (providedId) {
+    return { sprintId: providedId, source: "provided" };
+  }
+  const envSprintId = process.env.FORLOOP_SPRINT_ID;
+  if (envSprintId) {
+    return { sprintId: parseInt(envSprintId, 10), source: "env" };
+  }
+  const manifestSprintId = getActiveSprintIdFromManifest(directory);
+  if (manifestSprintId) {
+    return { sprintId: manifestSprintId, source: "manifest" };
+  }
+  try {
+    const branch = await getCurrentBranch(directory);
+    const sprintId = await resolveSprintFromBranch(branch);
+    if (sprintId) {
+      return { sprintId, branch, source: "branch" };
+    }
+  } catch (error) {
+  }
+  return { source: "config" };
+}
+function getActiveSprintIdFromManifest(directory) {
+  const candidates = [];
+  if (directory) {
+    candidates.push(path3.join(directory, ".forloop", "manifest.json"));
+  }
+  const home = process.env.HOME;
+  if (home) {
+    candidates.push(path3.join(home, ".forloop", "manifest.json"));
+  }
+  for (const filePath of candidates) {
+    try {
+      if (!fs3.existsSync(filePath)) continue;
+      const raw = fs3.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const id = parsed?.activeSprintId;
+      if (Number.isFinite(id)) return Number(id);
+    } catch {
+    }
+  }
+  return null;
+}
+var DEFAULT_HOME = "/tmp/home";
+function getSprintDir(sprintId) {
+  return `sprint-${sprintId}`;
+}
+function getForloopRoot(sprintId) {
+  const home = process.env.HOME || DEFAULT_HOME;
+  const root = path3.join(home, ".forloop");
+  if (sprintId !== void 0) {
+    return path3.join(root, getSprintDir(sprintId));
+  }
+  return root;
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/story-tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/template-tools.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/user-tools.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/organization-tools.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/file-tools.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/schedule-tools.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/folder-tools.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/sync-tools.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-tools.ts
+import { tool as tool10 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-suggestion-tools.ts
+import { tool as tool11 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-sprint-tools.ts
+import { tool as tool12 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/ai-trigger-tools.ts
+import { tool as tool13 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/developer-status-tool.ts
+import { tool as tool14 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/hooks/shell-env.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+
 // src/commands/auth/index.ts
-import { getToken, setToken, clearToken, validateToken } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createAuthCommands() {
   return {
     "auth login": createAuthLoginCommand(),
@@ -193,7 +912,6 @@ function createAuthStatusCommand() {
       } else {
         console.log("Not authenticated");
         console.log("Run: forloop auth login --api-key <token>");
-        process.exit(1);
       }
     }
   });
@@ -210,8 +928,26 @@ function createAuthLogoutCommand() {
   });
 }
 
+// src/output/formatter.ts
+function print(config, data, label) {
+  if (config.output === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    if (label && !config.quiet) console.log(label);
+    console.log(data);
+  } else {
+    if (label && !config.quiet) console.log(label);
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function formatError(message, format) {
+  if (format === "json") {
+    return JSON.stringify({ error: { message } }, null, 2);
+  }
+  return `Error: ${message}`;
+}
+
 // src/commands/story.ts
-import { ForLoopAPIClient, getToken as getToken2, getConfig } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createStoryCommands() {
   return {
     "story create": createStoryCreateCommand(),
@@ -222,12 +958,12 @@ function createStoryCommands() {
 }
 async function getClient() {
   const config = getConfig();
-  const token = await getToken2();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
     process.exit(1);
   }
-  const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
+  const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 });
   return { client };
 }
 function createStoryCreateCommand() {
@@ -249,7 +985,7 @@ function createStoryCreateCommand() {
       'forloop story create --title "Meeting notes" --sprint 1 --type basic-note',
       'forloop story create --title "Design Docs" --sprint 1'
     ],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient();
       if (!resolved) return;
       const { client } = resolved;
@@ -289,7 +1025,7 @@ function createStoryCreateCommand() {
             points: flags.points
           })
         });
-        console.log(`Story created: #${story.id} - ${story.title} (${story.type})`);
+        print(config, story, `Story created: #${story.id} - ${story.title} (${story.type})`);
       } else {
         const story = await client.createStory({
           title: flags.title,
@@ -299,7 +1035,7 @@ function createStoryCreateCommand() {
           priority: flags.priority || "medium",
           status: "todo"
         });
-        console.log(`Doc folder created: #${story.id} - ${story.title}`);
+        print(config, story, `Doc folder created: #${story.id} - ${story.title}`);
       }
     }
   });
@@ -314,7 +1050,7 @@ function createStoryGetCommand() {
       { flag: "--no-comments", description: "Exclude comments" }
     ],
     examples: ["forloop story get --id 123"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient();
       if (!resolved) return;
       const { client } = resolved;
@@ -324,28 +1060,7 @@ function createStoryGetCommand() {
         process.exit(1);
       }
       const story = await client.getStory(storyId, { includeComments: !flags.noComments });
-      const lines = [
-        `Story #${story.id}: ${story.title}`,
-        `Sprint: #${story.sprint?.id || "N/A"} ${story.sprint?.title || ""}`,
-        `Status: ${story.status}`,
-        `Priority: ${story.priority}`,
-        `Type: ${story.type}`
-      ];
-      if (story.points) lines.push(`Points: ${story.points}`);
-      if (story.assignee) lines.push(`Assignee: ${story.assignee.name || story.assignee.email || "Unknown"}`);
-      if (story.assigneeAgentKey) lines.push(`Agent: ${story.assigneeAgentKey}`);
-      if (story.description) {
-        lines.push("", "Description:", story.description);
-      }
-      if (!flags.noComments && story.comments?.length) {
-        lines.push("", `--- Comments (${story.comments.length}) ---`);
-        for (const comment of story.comments) {
-          const author = comment.authorAgentKey || comment.user?.name || "Unknown";
-          lines.push(`  ${author}: ${comment.content || comment.body || ""}`);
-          if (comment.artifacts?.length) lines.push(`  Artifacts: ${comment.artifacts.join(", ")}`);
-        }
-      }
-      console.log(lines.join("\n"));
+      print(config, story);
     }
   });
 }
@@ -363,7 +1078,7 @@ function createStoryUpdateCommand() {
       { flag: "--points <n>", description: "Story points (0-10)", type: "number" }
     ],
     examples: ["forloop story update --id 123 --status in_progress"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient();
       if (!resolved) return;
       const { client } = resolved;
@@ -383,7 +1098,7 @@ function createStoryUpdateCommand() {
         process.exit(1);
       }
       const story = await client.updateStory(storyId, data);
-      console.log(`Story #${story.id} updated successfully.`);
+      print(config, story, `Story #${story.id} updated successfully.`);
     }
   });
 }
@@ -397,7 +1112,7 @@ function createStoryDeleteCommand() {
       { flag: "--confirm", description: "Confirm deletion" }
     ],
     examples: ["forloop story delete --id 123 --confirm"],
-    async run(_config, flags) {
+    async run(config, flags) {
       if (!flags.confirm) {
         console.error("Error: --confirm is required to permanently delete a story.");
         process.exit(1);
@@ -406,13 +1121,12 @@ function createStoryDeleteCommand() {
       if (!resolved) return;
       const { client } = resolved;
       await client.deleteStory(flags.id);
-      console.log(`Story #${flags.id} deleted successfully.`);
+      print(config, { deleted: flags.id }, `Story #${flags.id} deleted successfully.`);
     }
   });
 }
 
 // src/commands/sprint.ts
-import { ForLoopAPIClient as ForLoopAPIClient2, getToken as getToken3, resolveSprintId as resolveSprintId2, getConfig as getConfig2 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createSprintCommands() {
   return {
     "sprint get": createSprintGetCommand(),
@@ -423,18 +1137,15 @@ function createSprintCommands() {
   };
 }
 async function getClient2() {
-  const config = getConfig2();
-  const token = await getToken3();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
     process.exit(1);
   }
-  const client = new ForLoopAPIClient2({ token, baseUrl: config.apiUrl });
+  const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 });
   return { client };
 }
-function formatDate(dateString) {
-  return new Date(dateString).toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
-}
 function createSprintGetCommand() {
   return defineCommand({
     name: "sprint get",
@@ -446,11 +1157,11 @@ function createSprintGetCommand() {
       { flag: "--no-files", description: "Exclude files from response" }
     ],
     examples: ["forloop sprint get --id 456", "forloop sprint get --id 456 --no-files"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId2(flags.id);
+      const resolution = await resolveSprintId(flags.id);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved. Use --id, set FORLOOP_SPRINT_ID, or use a sprint-XXX branch.");
         process.exit(1);
@@ -459,20 +1170,7 @@ function createSprintGetCommand() {
         includeStories: !flags.noStories,
         includeFiles: !flags.noFiles
       });
-      const lines = [
-        `Sprint #${sprint.id}: ${sprint.title}`,
-        `Status: ${sprint.status}`,
-        `Period: ${formatDate(sprint.startDate)} - ${formatDate(sprint.endDate)}`,
-        `Stories: ${sprint.stories?.length || 0}`
-      ];
-      if (sprint.stories?.length) {
-        lines.push("", "Stories:", "");
-        for (const story of sprint.stories) {
-          const icons = { todo: "[ ]", in_progress: "[>]", done: "[x]", blocked: "[!]" };
-          lines.push(`  ${icons[story.status] || "[?]"} #${story.id} ${story.title} (${story.status})`);
-        }
-      }
-      console.log(lines.join("\n"));
+      print(config, sprint);
     }
   });
 }
@@ -486,23 +1184,15 @@ function createSprintListCommand() {
       { flag: "--include-system-org", description: "Include system organization sprints" }
     ],
     examples: ["forloop sprint list", "forloop sprint list --org-id 1"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
       const params = {};
       if (flags.orgId) params.organizationId = String(flags.orgId);
+      if (flags.includeSystemOrg) params.includeSystemOrg = "true";
       const sprints = await client.listSprints(params);
-      if (!sprints.length) {
-        console.log("No sprints found.");
-        return;
-      }
-      const lines = ["Sprints:", ""];
-      for (const sprint of sprints) {
-        const orgInfo = sprint.organizationName ? ` (${sprint.organizationName})` : "";
-        lines.push(`  #${sprint.id} ${sprint.title}${orgInfo} - ${sprint.status}`);
-      }
-      console.log(lines.join("\n"));
+      print(config, sprints);
     }
   });
 }
@@ -520,7 +1210,7 @@ function createSprintCreateCommand() {
       { flag: "--org-id <id>", description: "Organization ID", type: "number" }
     ],
     examples: ['forloop sprint create --title "Sprint 15" --start-date 2026-06-09 --end-date 2026-06-23'],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
@@ -536,8 +1226,7 @@ function createSprintCreateCommand() {
         isPrivate: flags.private === true,
         organizationId: flags.orgId
       });
-      console.log(`Sprint created: #${sprint.id} - ${sprint.title}`);
-      console.log(`Period: ${formatDate(sprint.startDate)} - ${formatDate(sprint.endDate)}`);
+      print(config, sprint, `Sprint created: #${sprint.id} - ${sprint.title}`);
     }
   });
 }
@@ -555,7 +1244,7 @@ function createSprintUpdateCommand() {
       { flag: "--private", description: "Set visibility to private" }
     ],
     examples: ['forloop sprint update --id 456 --title "Updated Sprint"'],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
@@ -570,7 +1259,7 @@ function createSprintUpdateCommand() {
         process.exit(1);
       }
       const sprint = await client.updateSprint(flags.id, updateData);
-      console.log(`Sprint #${sprint.id} updated successfully.`);
+      print(config, sprint, `Sprint #${sprint.id} updated successfully.`);
     }
   });
 }
@@ -584,7 +1273,7 @@ function createSprintDeleteCommand() {
       { flag: "--confirm", description: "Confirm deletion" }
     ],
     examples: ["forloop sprint delete --id 456 --confirm"],
-    async run(_config, flags) {
+    async run(config, flags) {
       if (!flags.confirm) {
         console.error("Error: --confirm is required to permanently delete a sprint.");
         process.exit(1);
@@ -592,14 +1281,22 @@ function createSprintDeleteCommand() {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
-      await client.deleteSprint(flags.id);
-      console.log(`Sprint #${flags.id} deleted successfully.`);
+      const result = await client.deleteSprint(flags.id);
+      print(config, result, `Sprint #${flags.id} deleted successfully.`);
     }
   });
 }
 
 // src/commands/org.ts
-import { ForLoopAPIClient as ForLoopAPIClient3, getToken as getToken4, getConfig as getConfig3 } from "@forloop-cc/forloop-opencode-plugin-planner";
+async function getClient3() {
+  const config = getConfig();
+  const token = await getToken();
+  if (!token) {
+    console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
+    process.exit(1);
+  }
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 }) };
+}
 function createOrgCommands() {
   return {
     "org list": createOrgListCommand(),
@@ -608,15 +1305,6 @@ function createOrgCommands() {
     "org update": createOrgUpdateCommand()
   };
 }
-async function getClient3() {
-  const config = getConfig3();
-  const token = await getToken4();
-  if (!token) {
-    console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
-    process.exit(1);
-  }
-  return { client: new ForLoopAPIClient3({ token, baseUrl: config.apiUrl }) };
-}
 function createOrgListCommand() {
   return defineCommand({
     name: "org list",
@@ -625,12 +1313,16 @@ function createOrgListCommand() {
     options: [
       { flag: "--owned-only", description: "List only organizations you own" }
     ],
-    examples: ["forloop org list", "forloop org list --owned-only"],
-    async run(_config, flags) {
+    examples: ["forloop org list", "forloop org list --owned-only", "forloop org list --output json"],
+    async run(config, flags) {
       const resolved = await getClient3();
       if (!resolved) return;
       const { client } = resolved;
       const orgs = flags.ownedOnly ? await client.getOwnedOrganizations() : await client.listOrganizations();
+      if (config.output === "json") {
+        print(config, orgs);
+        return;
+      }
       if (!orgs.length) {
         console.log("No organizations found.");
         return;
@@ -652,19 +1344,16 @@ function createOrgGetCommand() {
     options: [
       { flag: "--id <number>", description: "Organization ID", required: true, type: "number" }
     ],
-    examples: ["forloop org get --id 1"],
-    async run(_config, flags) {
+    examples: ["forloop org get --id 1", "forloop org get --id 1 --output json"],
+    async run(config, flags) {
       if (!flags.id) {
         console.error("Error: --id is required");
         process.exit(1);
       }
       const resolved = await getClient3();
       if (!resolved) return;
-      const { client } = resolved;
-      const org = await client.getOrganization(flags.id);
-      console.log(`Organization #${org.id}: ${org.name}`);
-      console.log(`Type: ${org.type || "user"}`);
-      if (org.description) console.log(`Description: ${org.description}`);
+      const org = await resolved.client.getOrganization(flags.id);
+      print(config, org);
     }
   });
 }
@@ -678,19 +1367,18 @@ function createOrgCreateCommand() {
       { flag: "--description <text>", description: "Organization description" }
     ],
     examples: ['forloop org create --name "My Team" --description "Engineering team"'],
-    async run(_config, flags) {
+    async run(config, flags) {
       if (!flags.name) {
         console.error("Error: --name is required");
         process.exit(1);
       }
       const resolved = await getClient3();
       if (!resolved) return;
-      const { client } = resolved;
-      const org = await client.createOrganization({
+      const org = await resolved.client.createOrganization({
         name: flags.name,
         description: flags.description
       });
-      console.log(`Organization created: #${org.id} - ${org.name}`);
+      print(config, org, `Organization created: #${org.id} - ${org.name}`);
     }
   });
 }
@@ -705,25 +1393,23 @@ function createOrgUpdateCommand() {
       { flag: "--description <text>", description: "New description" }
     ],
     examples: ['forloop org update --id 1 --name "New Name"'],
-    async run(_config, flags) {
+    async run(config, flags) {
       if (!flags.id) {
         console.error("Error: --id is required");
         process.exit(1);
       }
       const resolved = await getClient3();
       if (!resolved) return;
-      const { client } = resolved;
-      const org = await client.updateOrganization(flags.id, {
+      const org = await resolved.client.updateOrganization(flags.id, {
         name: flags.name,
         description: flags.description
       });
-      console.log(`Organization #${org.id} updated successfully.`);
+      print(config, org, `Organization #${org.id} updated successfully.`);
     }
   });
 }
 
 // src/commands/template.ts
-import { ForLoopAPIClient as ForLoopAPIClient4, getToken as getToken5, getConfig as getConfig4 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createTemplateCommands() {
   return {
     "template list": createTemplateListCommand()
@@ -732,30 +1418,41 @@ function createTemplateCommands() {
 function createTemplateListCommand() {
   return defineCommand({
     name: "template list",
-    description: "List available story templates",
+    description: "List available story templates (basic-task, basic-note, schedule-meeting, doc-folder)",
     usage: "forloop template list",
-    examples: ["forloop template list"],
-    async run(_config) {
-      const config = getConfig4();
-      const token = await getToken5();
+    examples: ["forloop template list", "forloop template list --output json"],
+    async run(config) {
+      const apiConfig = getConfig();
+      const token = await getToken();
       if (!token) {
         console.error("Error: No API token configured.");
         process.exit(1);
       }
-      const client = new ForLoopAPIClient4({ token, baseUrl: config.apiUrl });
+      const client = new ForLoopAPIClient({ token, baseUrl: apiConfig.apiUrl, timeout: 3e4 });
       const templates = await client.listTemplates();
       const active = templates.filter((t) => !t.deletedAt);
+      if (config.output === "json") {
+        print(config, active);
+        return;
+      }
       if (!active.length) {
         console.log("No templates found.");
         return;
       }
+      const builtIn = [
+        { name: "Basic Task", slug: "basic-task", description: "Standard task with title, description, priority, and story points", fields: [] },
+        { name: "Basic Note", slug: "basic-note", description: "Simple note with title and description", fields: [] }
+      ];
+      const allTemplates = [...builtIn, ...active];
       const lines = ["Available Templates:", ""];
-      for (const t of active) {
-        const fields = JSON.parse(t.fields);
-        const fieldNames = fields.map((f) => f.label).join(", ");
-        lines.push(`  ${t.name} (slug: ${t.slug})`);
+      for (const t of allTemplates) {
+        const fields = t.fields && typeof t.fields === "string" ? JSON.parse(t.fields) : Array.isArray(t.fields) ? t.fields : [];
+        const fieldNames = Array.isArray(fields) ? fields.map((f) => f.label || f).join(", ") : "";
+        const isBuiltIn = builtIn.some((b) => b.slug === t.slug);
+        const badge = isBuiltIn ? " (built-in)" : "";
+        lines.push(`  ${t.name} (slug: ${t.slug})${badge}`);
         lines.push(`    ${t.description}`);
-        lines.push(`    Fields: ${fieldNames}`);
+        if (fieldNames) lines.push(`    Fields: ${fieldNames}`);
         lines.push("");
       }
       console.log(lines.join("\n"));
@@ -764,7 +1461,6 @@ function createTemplateListCommand() {
 }
 
 // src/commands/agent.ts
-import { ForLoopAPIClient as ForLoopAPIClient5, getToken as getToken6, resolveSprintId as resolveSprintId3, getConfig as getConfig5 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createAgentCommands() {
   return {
     "agent history": createAgentHistoryCommand(),
@@ -773,13 +1469,13 @@ function createAgentCommands() {
   };
 }
 async function getClient4() {
-  const config = getConfig5();
-  const token = await getToken6();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient5({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 }) };
 }
 function createAgentHistoryCommand() {
   return defineCommand({
@@ -791,31 +1487,17 @@ function createAgentHistoryCommand() {
       { flag: "--limit <n>", description: "Number of messages (max 200, default 50)", type: "number" }
     ],
     examples: ["forloop agent history --sprint 1 --limit 20"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient4();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId3(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       const sprintId = resolution.sprintId || flags.sprint;
       const history = await client.getConversationHistory({
         sprintId,
         limit: flags.limit || 50
       });
-      const messages = history.messages || [];
-      if (!messages.length) {
-        console.log("No conversation history found.");
-        return;
-      }
-      console.log(`Conversation History (${history.total || messages.length} total):`);
-      for (const msg of messages) {
-        const preview = (msg.userMessage || "").substring(0, 80);
-        console.log(`  ${preview}${preview.length >= 80 ? "..." : ""}`);
-        if (msg.agentResponse) {
-          const resp = msg.agentResponse.substring(0, 100);
-          console.log(`    -> ${resp}${msg.agentResponse.length > 100 ? "..." : ""}`);
-        }
-        console.log("");
-      }
+      print(config, history);
     }
   });
 }
@@ -866,7 +1548,7 @@ function createDeveloperStatusCommand() {
       const resolved = await getClient4();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId3(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -878,11 +1560,11 @@ function createDeveloperStatusCommand() {
         console.log(`Sprint #${resolution.sprintId}: ${sprint.storiesDone || 0}/${sprint.storiesTotal || 0} stories done.`);
         return;
       }
-      const exec = status.execution || {};
+      const exec3 = status.execution || {};
       const task = status.task || {};
-      console.log(`Developer Task: ${exec.status}`);
+      console.log(`Developer Task: ${exec3.status}`);
       console.log(`Sprint: #${resolution.sprintId}`);
-      if (exec.startedAt) console.log(`Started: ${new Date(exec.startedAt).toLocaleString()}`);
+      if (exec3.startedAt) console.log(`Started: ${new Date(exec3.startedAt).toLocaleString()}`);
       if (task.branchName) console.log(`Branch: ${task.branchName}`);
       if (task.errorMessage) console.log(`Error: ${task.errorMessage}`);
       console.log(`Progress: ${sprint.storiesDone || 0}/${sprint.storiesTotal || 0} done, ${sprint.storiesInProgress || 0} in progress.`);
@@ -891,7 +1573,15 @@ function createDeveloperStatusCommand() {
 }
 
 // src/commands/user.ts
-import { ForLoopAPIClient as ForLoopAPIClient6, getToken as getToken7, getConfig as getConfig6 } from "@forloop-cc/forloop-opencode-plugin-planner";
+async function getClient5() {
+  const config = getConfig();
+  const token = await getToken();
+  if (!token) {
+    console.error("Error: No API token configured.");
+    process.exit(1);
+  }
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 }) };
+}
 function createUserCommands() {
   return {
     "user profile": createUserProfileCommand(),
@@ -899,29 +1589,17 @@ function createUserCommands() {
     "org quotas": createOrgQuotasCommand()
   };
 }
-async function getClient5() {
-  const config = getConfig6();
-  const token = await getToken7();
-  if (!token) {
-    console.error("Error: No API token configured.");
-    process.exit(1);
-  }
-  return { client: new ForLoopAPIClient6({ token, baseUrl: config.apiUrl }) };
-}
 function createUserProfileCommand() {
   return defineCommand({
     name: "user profile",
     description: "Get current user profile",
     usage: "forloop user profile",
-    examples: ["forloop user profile"],
-    async run(_config) {
+    examples: ["forloop user profile", "forloop user profile --output json"],
+    async run(config) {
       const resolved = await getClient5();
       if (!resolved) return;
-      const { client } = resolved;
-      const profile = await client.getUserProfile();
-      console.log(`User: ${profile.name || profile.email || "Unknown"}`);
-      console.log(`Email: ${profile.email}`);
-      if (profile.tier) console.log(`Tier: ${profile.tier}`);
+      const profile = await resolved.client.getUserProfile();
+      print(config, profile, "User Profile:");
     }
   });
 }
@@ -930,14 +1608,12 @@ function createUserQuotasCommand() {
     name: "user quotas",
     description: "Check user quota limits",
     usage: "forloop user quotas",
-    examples: ["forloop user quotas"],
-    async run(_config) {
+    examples: ["forloop user quotas", "forloop user quotas --output json"],
+    async run(config) {
       const resolved = await getClient5();
       if (!resolved) return;
-      const { client } = resolved;
-      const quotas = await client.getUserQuotas();
-      console.log("User Quotas:");
-      console.log(JSON.stringify(quotas, null, 2));
+      const quotas = await resolved.client.getUserQuotas();
+      print(config, quotas, "User Quotas:");
     }
   });
 }
@@ -949,26 +1625,23 @@ function createOrgQuotasCommand() {
     options: [
       { flag: "--org-id <id>", description: "Organization ID", required: true, type: "number" }
     ],
-    examples: ["forloop org quotas --org-id 1"],
-    async run(_config, flags) {
+    examples: ["forloop org quotas --org-id 1", "forloop org quotas --org-id 1 --output json"],
+    async run(config, flags) {
       if (!flags.orgId) {
         console.error("Error: --org-id is required");
         process.exit(1);
       }
       const resolved = await getClient5();
       if (!resolved) return;
-      const { client } = resolved;
-      const quotas = await client.getOrganizationQuotas(flags.orgId);
-      console.log("Organization Quotas:");
-      console.log(JSON.stringify(quotas, null, 2));
+      const quotas = await resolved.client.getOrganizationQuotas(flags.orgId);
+      print(config, quotas, "Organization Quotas:");
     }
   });
 }
 
 // src/commands/file.ts
-import { ForLoopAPIClient as ForLoopAPIClient7, getToken as getToken8, getConfig as getConfig7 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 function createFileCommands() {
   return {
     "file upload": createFileUploadCommand(),
@@ -978,13 +1651,13 @@ function createFileCommands() {
   };
 }
 async function getClient6() {
-  const config = getConfig7();
-  const token = await getToken8();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient7({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 }) };
 }
 var mimeTypes = {
   ".png": "image/png",
@@ -1018,18 +1691,18 @@ function createFileUploadCommand() {
       { flag: "--folder <text>", description: "S3 folder within sprint" }
     ],
     examples: ["forloop file upload --path ./report.pdf --sprint 1 --folder docs"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient6();
       if (!resolved) return;
       const { client } = resolved;
       const filePath = flags.path;
-      if (!fs.existsSync(filePath)) {
+      if (!fs4.existsSync(filePath)) {
         console.error(`Error: File not found: ${filePath}`);
         process.exit(1);
       }
-      const fileContent = fs.readFileSync(filePath);
-      const fileName = path.basename(filePath);
-      const ext = path.extname(fileName);
+      const fileContent = fs4.readFileSync(filePath);
+      const fileName = path4.basename(filePath);
+      const ext = path4.extname(fileName);
       const contentType = mimeTypes[ext] || "application/octet-stream";
       const presign = await client.createPresignedUpload({
         sprintId: flags.sprint,
@@ -1054,8 +1727,7 @@ function createFileUploadCommand() {
         size: fileContent.length,
         folder: flags.folder
       });
-      console.log(`File uploaded: ${fileName} (${formatSize(fileContent.length)})`);
-      console.log(`URL: ${complete.url}`);
+      print(config, { fileName, size: fileContent.length, url: complete.url, fileId: complete.id }, `File uploaded: ${fileName} (${formatSize(fileContent.length)})`);
     }
   });
 }
@@ -1068,23 +1740,12 @@ function createFileListCommand() {
       { flag: "--sprint <id>", description: "Sprint ID", required: true, type: "number" }
     ],
     examples: ["forloop file list --sprint 1"],
-    async run(_config, flags) {
+    async run(config, flags) {
       const resolved = await getClient6();
       if (!resolved) return;
       const { client } = resolved;
       const files = await client.getSprintFiles(flags.sprint);
-      if (!files.length) {
-        console.log("No files found.");
-        return;
-      }
-      const lines = [`Files in Sprint #${flags.sprint}:`, ""];
-      for (const file of files) {
-        lines.push(`  ${file.originalName || file.filename}`);
-        lines.push(`    Size: ${formatSize(file.size)} | Type: ${file.fileType}`);
-        lines.push(`    URL: ${file.url}`);
-        lines.push("");
-      }
-      console.log(lines.join("\n"));
+      print(config, files, `Files in Sprint #${flags.sprint}:`);
     }
   });
 }
@@ -1132,7 +1793,6 @@ function createFileDownloadCommand() {
 }
 
 // src/commands/folder.ts
-import { ForLoopAPIClient as ForLoopAPIClient8, getToken as getToken9, getConfig as getConfig8 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createFolderCommands() {
   return {
     "folder create": createFolderCreateCommand()
@@ -1151,13 +1811,13 @@ function createFolderCreateCommand() {
     ],
     examples: ['forloop folder create --title "Project Docs" --sprint 1 --permissions team'],
     async run(_config, flags) {
-      const config = getConfig8();
-      const token = await getToken9();
+      const config = getConfig();
+      const token = await getToken();
       if (!token) {
         console.error("Error: No API token configured.");
         process.exit(1);
       }
-      const client = new ForLoopAPIClient8({ token, baseUrl: config.apiUrl });
+      const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 });
       const story = await client.createStory({
         title: flags.title,
         description: flags.description,
@@ -1172,9 +1832,8 @@ function createFolderCreateCommand() {
 }
 
 // src/commands/sync.ts
-import { ForLoopAPIClient as ForLoopAPIClient9, getToken as getToken10, resolveSprintId as resolveSprintId4, getConfig as getConfig9, getForloopRoot } from "@forloop-cc/forloop-opencode-plugin-planner";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function createSyncCommands() {
   return {
     "sync aivy-folder": createSyncAivyFolderCommand(),
@@ -1184,13 +1843,13 @@ function createSyncCommands() {
   };
 }
 async function getClient7() {
-  const config = getConfig9();
-  const token = await getToken10();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient9({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl, timeout: 3e4 }) };
 }
 function createSyncAivyFolderCommand() {
   return defineCommand({
@@ -1206,7 +1865,7 @@ function createSyncAivyFolderCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -1243,7 +1902,7 @@ function createAivyDocGetCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -1277,14 +1936,14 @@ function createS3ToLocalCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
       }
       const files = await client.getSprintFiles(resolution.sprintId);
       const localRoot = getForloopRoot(resolution.sprintId);
-      fs2.mkdirSync(localRoot, { recursive: true });
+      fs5.mkdirSync(localRoot, { recursive: true });
       let downloaded = 0;
       let skipped = 0;
       for (const file of files) {
@@ -1299,9 +1958,9 @@ function createS3ToLocalCommand() {
         if (res.ok) {
           const buf = Buffer.from(await res.arrayBuffer());
           const kind = name.startsWith("knowledge-") ? "knowledge" : name.startsWith("plan-") ? "plan" : name.startsWith("task-") ? "task" : "other";
-          const dir = path2.join(localRoot, kind);
-          fs2.mkdirSync(dir, { recursive: true });
-          fs2.writeFileSync(path2.join(dir, name), buf);
+          const dir = path5.join(localRoot, kind);
+          fs5.mkdirSync(dir, { recursive: true });
+          fs5.writeFileSync(path5.join(dir, name), buf);
           downloaded++;
         }
       }
@@ -1325,18 +1984,18 @@ function createLocalToS3Command() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
       }
       const filePath = flags.path;
-      if (!fs2.existsSync(filePath)) {
+      if (!fs5.existsSync(filePath)) {
         console.error(`Error: File not found: ${filePath}`);
         process.exit(1);
       }
-      const fileBuf = fs2.readFileSync(filePath);
-      const fileName = path2.basename(filePath);
+      const fileBuf = fs5.readFileSync(filePath);
+      const fileName = path5.basename(filePath);
       const contentType = "text/markdown";
       const folder = flags.folder || "project";
       const presign = await client.createPresignedUpload({
@@ -1367,12 +2026,12 @@ function createLocalToS3Command() {
 var CommandRegistry = class {
   root = { children: /* @__PURE__ */ new Map() };
   constructor(commands) {
-    for (const [path3, cmd] of Object.entries(commands)) {
-      this.register(path3, cmd);
+    for (const [path6, cmd] of Object.entries(commands)) {
+      this.register(path6, cmd);
     }
   }
-  register(path3, command) {
-    const parts = path3.split(" ");
+  register(path6, command) {
+    const parts = path6.split(" ");
     let node = this.root;
     for (const part of parts) {
       if (!node.children.has(part)) {
@@ -1622,14 +2281,6 @@ var registry = new CommandRegistry({
   "agent sprint": agentDeveloperSprintCmd
 });
 
-// src/output/formatter.ts
-function formatError(message, format) {
-  if (format === "json") {
-    return JSON.stringify({ error: { message } }, null, 2);
-  }
-  return `\u274C ${message}`;
-}
-
 // src/errors/handler.ts
 function handleError(error) {
   const isJson = process.argv.includes("--output=json");
@@ -1652,10 +2303,7 @@ Tip: ${suggestion}
 }
 
 // src/main.ts
-import { getConfig as getConfig10 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import { getToken as getToken11 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import { detectTokenType } from "@forloop-cc/forloop-opencode-plugin-planner";
-var CLI_VERSION = "0.2.2";
+var CLI_VERSION = "0.2.4";
 process.on("SIGINT", () => {
   process.stderr.write("\nInterrupted. Exiting.\n");
   process.exit(130);
@@ -1682,7 +2330,7 @@ async function main() {
   if (commandPath.length === 0) {
     registry.printHelp([], process.stderr);
     try {
-      const token2 = await getToken11();
+      const token2 = await getToken();
       if (token2) {
         const tokenType = detectTokenType(token2);
         const masked = token2.slice(0, 8) + "..." + token2.slice(-4);
@@ -1703,8 +2351,8 @@ async function main() {
   const { command, extra } = registry.resolve(commandPath);
   const flags = parseFlags(argv, [...GLOBAL_OPTIONS, ...command.options ?? []]);
   if (extra.length > 0) flags._positional = extra;
-  const pluginConfig = getConfig10();
-  const token = await getToken11();
+  const pluginConfig = getConfig();
+  const token = await getToken();
   const isNoAuth = NO_AUTH_COMMANDS.some(
     (cmd) => cmd.every((c, i) => commandPath[i] === c)
   );
@@ -1715,7 +2363,7 @@ async function main() {
     process.exit(3);
   }
   const cliConfig = {
-    region: pluginConfig.apiUrl.includes("dev.forloop.cc") ? "dev" : "global",
+    region: "global",
     apiUrl: pluginConfig.apiUrl,
     serverLambdaUrl: "",
     environment: pluginConfig.environment,