@forloop-cc/forloop-cli 0.2.1

package/dist/forloop.mjs

@@ -0,0 +1,2440 @@
+#!/usr/bin/env node
+
+// src/args.ts
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function flagKey(def) {
+  const m = def.flag.match(/^--([a-z][a-z0-9-]*)/i);
+  return m ? kebabToCamel(m[1]) : null;
+}
+function isBooleanDef(def) {
+  if (def.type === "boolean") return true;
+  if (def.type === "string" || def.type === "number" || def.type === "array") return false;
+  return !def.flag.includes("<") && !def.flag.includes("[");
+}
+function buildSchema(options) {
+  const booleans = /* @__PURE__ */ new Set();
+  const numbers = /* @__PURE__ */ new Set();
+  const arrays = /* @__PURE__ */ new Set();
+  for (const opt of options) {
+    const key = flagKey(opt);
+    if (!key) continue;
+    if (isBooleanDef(opt)) booleans.add(key);
+    else if (opt.type === "number") numbers.add(key);
+    else if (opt.type === "array") arrays.add(key);
+  }
+  return { booleans, numbers, arrays };
+}
+function scanCommandPath(argv, globalOptions = []) {
+  const globalSchema = buildSchema(globalOptions);
+  const path6 = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--") break;
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      const key = eqIdx !== -1 ? arg.slice(2, eqIdx) : arg.slice(2);
+      const camelKey = kebabToCamel(key);
+      if (!globalSchema.booleans.has(camelKey) && eqIdx === -1) {
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      i++;
+      continue;
+    }
+    path6.push(arg);
+    i++;
+  }
+  return path6;
+}
+function parseFlags(argv, options) {
+  const schema = buildSchema(options);
+  const flags = {
+    quiet: false,
+    verbose: false,
+    noColor: false,
+    dryRun: false,
+    help: false,
+    nonInteractive: false
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      flags.help = true;
+      i++;
+      continue;
+    }
+    if (arg === "--") {
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      let key;
+      let value;
+      if (eqIdx !== -1) {
+        key = arg.slice(2, eqIdx);
+        value = arg.slice(eqIdx + 1);
+      } else {
+        key = arg.slice(2);
+      }
+      const camelKey = kebabToCamel(key);
+      if (schema.booleans.has(camelKey)) {
+        flags[camelKey] = true;
+        i++;
+        continue;
+      }
+      if (value === void 0) {
+        i++;
+        value = argv[i];
+      }
+      if (value === void 0) throw new Error(`Flag --${key} requires a value.`);
+      if (schema.arrays.has(camelKey)) {
+        const arr = flags[camelKey];
+        if (arr) arr.push(value);
+        else flags[camelKey] = [value];
+      } else if (schema.numbers.has(camelKey)) {
+        flags[camelKey] = Number(value);
+      } else {
+        flags[camelKey] = value;
+      }
+    }
+    i++;
+  }
+  return flags;
+}
+
+// src/errors/base.ts
+var CLIError = class extends Error {
+  constructor(message, exitCode = 1, suggestion) {
+    super(message);
+    this.exitCode = exitCode;
+    this.suggestion = suggestion;
+    this.name = "CLIError";
+  }
+};
+
+// src/command.ts
+function defineCommand(spec) {
+  return {
+    ...spec,
+    execute: spec.run
+  };
+}
+var GLOBAL_OPTIONS = [
+  { flag: "--api-key <key>", description: "ForLoop API key" },
+  { flag: "--api-url <url>", description: "API base URL (overrides config)" },
+  { flag: "--base-url <url>", description: "Alias for --api-url" },
+  { flag: "--output <format>", description: "Output format: text (default), json" },
+  { flag: "--timeout <seconds>", description: "Request timeout (default: 60)", type: "number" },
+  { flag: "--quiet", description: "Suppress non-essential output" },
+  { flag: "--verbose", description: "Print HTTP request/response details" },
+  { flag: "--no-color", description: "Disable ANSI colors" },
+  { flag: "--dry-run", description: "Show what would happen without executing" },
+  { flag: "--non-interactive", description: "Disable interactive prompts (CI mode)" },
+  { flag: "--help", description: "Show help" },
+  { flag: "--version", description: "Print version" }
+];
+
+// ../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);
+}
+
+// ../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);
+};
+
+// ../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"
+  };
+}
+
+// ../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 })
+    });
+  }
+};
+
+// ../forloop-opencode-plugin-planner/plugins/tools/sprint-tools.ts
+import { tool } from "@opencode-ai/plugin";
+
+// ../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;
+}
+
+// ../forloop-opencode-plugin-planner/plugins/tools/story-tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/template-tools.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/user-tools.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/organization-tools.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/file-tools.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/schedule-tools.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/folder-tools.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/sync-tools.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/agent-tools.ts
+import { tool as tool10 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/agent-suggestion-tools.ts
+import { tool as tool11 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/agent-sprint-tools.ts
+import { tool as tool12 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/ai-trigger-tools.ts
+import { tool as tool13 } from "@opencode-ai/plugin";
+
+// ../forloop-opencode-plugin-planner/plugins/tools/developer-status-tool.ts
+import { tool as tool14 } from "@opencode-ai/plugin";
+
+// ../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
+function createAuthCommands() {
+  return {
+    "auth login": createAuthLoginCommand(),
+    "auth status": createAuthStatusCommand(),
+    "auth logout": createAuthLogoutCommand()
+  };
+}
+function createAuthLoginCommand() {
+  return defineCommand({
+    name: "auth login",
+    description: "Authenticate with ForLoop API key",
+    usage: "forloop auth login --api-key <token>",
+    options: [
+      { flag: "--api-key <token>", description: "ForLoop API token (starts with floop_)", required: true }
+    ],
+    examples: [
+      "forloop auth login --api-key floop_xxxx"
+    ],
+    async run(_config, flags) {
+      const apiKey = flags.apiKey;
+      if (!apiKey || !apiKey.startsWith("floop_")) {
+        console.error('Error: --api-key is required and must start with "floop_"');
+        process.exit(1);
+      }
+      const validation = await validateToken(apiKey);
+      if (!validation.valid) {
+        console.error(`Invalid token: ${validation.error}`);
+        process.exit(1);
+      }
+      await setToken(apiKey);
+      console.log("Authenticated successfully. Token saved to ~/.config/forloop/tokens.json");
+    }
+  });
+}
+function createAuthStatusCommand() {
+  return defineCommand({
+    name: "auth status",
+    description: "Check current authentication status",
+    usage: "forloop auth status",
+    async run(_config) {
+      const token = await getToken();
+      if (token) {
+        const masked = token.slice(0, 8) + "..." + token.slice(-4);
+        const validation = await validateToken(token);
+        console.log(`Token: ${masked}`);
+        console.log(`Format: ${validation.valid ? "valid" : "invalid"}`);
+      } else {
+        console.log("Not authenticated");
+        console.log("Run: forloop auth login --api-key <token>");
+        process.exit(1);
+      }
+    }
+  });
+}
+function createAuthLogoutCommand() {
+  return defineCommand({
+    name: "auth logout",
+    description: "Clear saved authentication token",
+    usage: "forloop auth logout",
+    async run(_config) {
+      await clearToken();
+      console.log("Logged out. Token cleared.");
+    }
+  });
+}
+
+// src/commands/story.ts
+function createStoryCommands() {
+  return {
+    "story create": createStoryCreateCommand(),
+    "story get": createStoryGetCommand(),
+    "story update": createStoryUpdateCommand(),
+    "story delete": createStoryDeleteCommand()
+  };
+}
+async function getClient() {
+  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 ForLoopAPIClient({ token, baseUrl: config.apiUrl });
+  return { client };
+}
+function createStoryCreateCommand() {
+  return defineCommand({
+    name: "story create",
+    description: "Create a story. Use --type basic-task|basic-note for template-based stories, or omit for doc_folder.",
+    usage: "forloop story create --title <text> --sprint <id> [--type basic-task|basic-note] [flags]",
+    options: [
+      { flag: "--title <text>", description: "Story title", required: true },
+      { flag: "--sprint <id>", description: "Target sprint ID", required: true, type: "number" },
+      { flag: "--type <type>", description: "basic-task or basic-note. Omit for doc_folder." },
+      { flag: "--description <text>", description: "Story description" },
+      { flag: "--priority <priority>", description: "low, medium, high, critical (default: medium)" },
+      { flag: "--points <n>", description: "Story points (0-10)", type: "number" },
+      { flag: "--assignee-agent <key>", description: "AI agent key to assign to" }
+    ],
+    examples: [
+      'forloop story create --title "Implement login" --sprint 1 --type basic-task --priority high --points 3',
+      'forloop story create --title "Meeting notes" --sprint 1 --type basic-note',
+      'forloop story create --title "Design Docs" --sprint 1'
+    ],
+    async run(_config, flags) {
+      const resolved = await getClient();
+      if (!resolved) return;
+      const { client } = resolved;
+      const sprintId = flags.sprint;
+      if (!sprintId || !flags.title) {
+        console.error("Error: --title and --sprint are required");
+        process.exit(1);
+      }
+      const templateSlug = flags.type;
+      if (templateSlug) {
+        if (templateSlug !== "basic-task" && templateSlug !== "basic-note") {
+          console.error('Error: --type must be "basic-task" or "basic-note"');
+          process.exit(1);
+        }
+        const templates = await client.listTemplates();
+        const template = templates.find((t) => t.slug === templateSlug && !t.deletedAt);
+        if (!template) {
+          console.error(`Error: Template "${templateSlug}" not found`);
+          process.exit(1);
+        }
+        const story = await client.createStory({
+          title: flags.title,
+          description: flags.description,
+          sprintId,
+          type: template.storyType || "task",
+          templateId: template.id,
+          priority: flags.priority || "medium",
+          points: flags.points,
+          assigneeAgentKey: flags.assigneeAgent,
+          assigneeType: flags.assigneeAgent ? "agent" : void 0,
+          status: "todo",
+          metadata: JSON.stringify({
+            taskTitle: flags.title,
+            description: flags.description,
+            status: "not-started",
+            priority: flags.priority || "medium",
+            points: flags.points
+          })
+        });
+        console.log(`Story created: #${story.id} - ${story.title} (${story.type})`);
+      } else {
+        const story = await client.createStory({
+          title: flags.title,
+          description: flags.description,
+          sprintId,
+          type: "doc_folder",
+          priority: flags.priority || "medium",
+          status: "todo"
+        });
+        console.log(`Doc folder created: #${story.id} - ${story.title}`);
+      }
+    }
+  });
+}
+function createStoryGetCommand() {
+  return defineCommand({
+    name: "story get",
+    description: "Get story details including sprint info, assignee, and comments",
+    usage: "forloop story get --id <number>",
+    options: [
+      { flag: "--id <number>", description: "Story ID", required: true, type: "number" },
+      { flag: "--no-comments", description: "Exclude comments" }
+    ],
+    examples: ["forloop story get --id 123"],
+    async run(_config, flags) {
+      const resolved = await getClient();
+      if (!resolved) return;
+      const { client } = resolved;
+      const storyId = flags.id;
+      if (!storyId) {
+        console.error("Error: --id is required");
+        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"));
+    }
+  });
+}
+function createStoryUpdateCommand() {
+  return defineCommand({
+    name: "story update",
+    description: "Update story fields",
+    usage: "forloop story update --id <number> [flags]",
+    options: [
+      { flag: "--id <number>", description: "Story ID", required: true, type: "number" },
+      { flag: "--title <text>", description: "New title" },
+      { flag: "--description <text>", description: "New description" },
+      { flag: "--status <status>", description: "todo, in_progress, done, blocked" },
+      { flag: "--priority <priority>", description: "low, medium, high, critical" },
+      { flag: "--points <n>", description: "Story points (0-10)", type: "number" }
+    ],
+    examples: ["forloop story update --id 123 --status in_progress"],
+    async run(_config, flags) {
+      const resolved = await getClient();
+      if (!resolved) return;
+      const { client } = resolved;
+      const storyId = flags.id;
+      if (!storyId) {
+        console.error("Error: --id is required");
+        process.exit(1);
+      }
+      const data = {};
+      if (flags.title !== void 0) data.title = flags.title;
+      if (flags.description !== void 0) data.description = flags.description;
+      if (flags.status !== void 0) data.status = flags.status;
+      if (flags.priority !== void 0) data.priority = flags.priority;
+      if (flags.points !== void 0) data.points = flags.points;
+      if (Object.keys(data).length === 0) {
+        console.error("Error: at least one field to update is required");
+        process.exit(1);
+      }
+      const story = await client.updateStory(storyId, data);
+      console.log(`Story #${story.id} updated successfully.`);
+    }
+  });
+}
+function createStoryDeleteCommand() {
+  return defineCommand({
+    name: "story delete",
+    description: "Delete a story",
+    usage: "forloop story delete --id <number> --confirm",
+    options: [
+      { flag: "--id <number>", description: "Story ID", required: true, type: "number" },
+      { flag: "--confirm", description: "Confirm deletion" }
+    ],
+    examples: ["forloop story delete --id 123 --confirm"],
+    async run(_config, flags) {
+      if (!flags.confirm) {
+        console.error("Error: --confirm is required to permanently delete a story.");
+        process.exit(1);
+      }
+      const resolved = await getClient();
+      if (!resolved) return;
+      const { client } = resolved;
+      await client.deleteStory(flags.id);
+      console.log(`Story #${flags.id} deleted successfully.`);
+    }
+  });
+}
+
+// src/commands/sprint.ts
+function createSprintCommands() {
+  return {
+    "sprint get": createSprintGetCommand(),
+    "sprint list": createSprintListCommand(),
+    "sprint create": createSprintCreateCommand(),
+    "sprint update": createSprintUpdateCommand(),
+    "sprint delete": createSprintDeleteCommand()
+  };
+}
+async function getClient2() {
+  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 ForLoopAPIClient({ token, baseUrl: config.apiUrl });
+  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",
+    description: "Get sprint details including stories and files",
+    usage: "forloop sprint get --id <number>",
+    options: [
+      { flag: "--id <number>", description: "Sprint ID (auto-detected if not provided)", type: "number" },
+      { flag: "--no-stories", description: "Exclude stories from response" },
+      { 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) {
+      const resolved = await getClient2();
+      if (!resolved) return;
+      const { client } = resolved;
+      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);
+      }
+      const sprint = await client.getSprint(resolution.sprintId, {
+        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"));
+    }
+  });
+}
+function createSprintListCommand() {
+  return defineCommand({
+    name: "sprint list",
+    description: "List all accessible sprints",
+    usage: "forloop sprint list [--org-id <id>] [--include-system-org]",
+    options: [
+      { flag: "--org-id <id>", description: "Filter by organization ID", type: "number" },
+      { flag: "--include-system-org", description: "Include system organization sprints" }
+    ],
+    examples: ["forloop sprint list", "forloop sprint list --org-id 1"],
+    async run(_config, flags) {
+      const resolved = await getClient2();
+      if (!resolved) return;
+      const { client } = resolved;
+      const params = {};
+      if (flags.orgId) params.organizationId = String(flags.orgId);
+      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"));
+    }
+  });
+}
+function createSprintCreateCommand() {
+  return defineCommand({
+    name: "sprint create",
+    description: "Create a new sprint",
+    usage: "forloop sprint create --title <text> --start-date <YYYY-MM-DD> --end-date <YYYY-MM-DD> [flags]",
+    options: [
+      { flag: "--title <text>", description: "Sprint title", required: true },
+      { flag: "--start-date <date>", description: "Start date (YYYY-MM-DD)", required: true },
+      { flag: "--end-date <date>", description: "End date (YYYY-MM-DD)", required: true },
+      { flag: "--description <text>", description: "Sprint description" },
+      { flag: "--private", description: "Make sprint private" },
+      { 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) {
+      const resolved = await getClient2();
+      if (!resolved) return;
+      const { client } = resolved;
+      if (!flags.title || !flags.startDate || !flags.endDate) {
+        console.error("Error: --title, --start-date, and --end-date are required");
+        process.exit(1);
+      }
+      const sprint = await client.createSprint({
+        title: flags.title,
+        description: flags.description,
+        startDate: flags.startDate,
+        endDate: flags.endDate,
+        isPrivate: flags.private === true,
+        organizationId: flags.orgId
+      });
+      console.log(`Sprint created: #${sprint.id} - ${sprint.title}`);
+      console.log(`Period: ${formatDate(sprint.startDate)} - ${formatDate(sprint.endDate)}`);
+    }
+  });
+}
+function createSprintUpdateCommand() {
+  return defineCommand({
+    name: "sprint update",
+    description: "Update sprint details",
+    usage: "forloop sprint update --id <number> [flags]",
+    options: [
+      { flag: "--id <number>", description: "Sprint ID", required: true, type: "number" },
+      { flag: "--title <text>", description: "New title" },
+      { flag: "--description <text>", description: "New description" },
+      { flag: "--start-date <date>", description: "New start date" },
+      { flag: "--end-date <date>", description: "New end date" },
+      { flag: "--private", description: "Set visibility to private" }
+    ],
+    examples: ['forloop sprint update --id 456 --title "Updated Sprint"'],
+    async run(_config, flags) {
+      const resolved = await getClient2();
+      if (!resolved) return;
+      const { client } = resolved;
+      const updateData = {};
+      if (flags.title !== void 0) updateData.title = flags.title;
+      if (flags.description !== void 0) updateData.description = flags.description;
+      if (flags.startDate !== void 0) updateData.startDate = flags.startDate;
+      if (flags.endDate !== void 0) updateData.endDate = flags.endDate;
+      if (flags.private !== void 0) updateData.isPrivate = true;
+      if (Object.keys(updateData).length === 0) {
+        console.error("Error: at least one field to update is required");
+        process.exit(1);
+      }
+      const sprint = await client.updateSprint(flags.id, updateData);
+      console.log(`Sprint #${sprint.id} updated successfully.`);
+    }
+  });
+}
+function createSprintDeleteCommand() {
+  return defineCommand({
+    name: "sprint delete",
+    description: "Delete a sprint permanently",
+    usage: "forloop sprint delete --id <number> --confirm",
+    options: [
+      { flag: "--id <number>", description: "Sprint ID", required: true, type: "number" },
+      { flag: "--confirm", description: "Confirm deletion" }
+    ],
+    examples: ["forloop sprint delete --id 456 --confirm"],
+    async run(_config, flags) {
+      if (!flags.confirm) {
+        console.error("Error: --confirm is required to permanently delete a sprint.");
+        process.exit(1);
+      }
+      const resolved = await getClient2();
+      if (!resolved) return;
+      const { client } = resolved;
+      await client.deleteSprint(flags.id);
+      console.log(`Sprint #${flags.id} deleted successfully.`);
+    }
+  });
+}
+
+// src/commands/org.ts
+function createOrgCommands() {
+  return {
+    "org list": createOrgListCommand(),
+    "org get": createOrgGetCommand(),
+    "org create": createOrgCreateCommand(),
+    "org update": createOrgUpdateCommand()
+  };
+}
+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 }) };
+}
+function createOrgListCommand() {
+  return defineCommand({
+    name: "org list",
+    description: "List organizations you belong to",
+    usage: "forloop org list [--owned-only]",
+    options: [
+      { flag: "--owned-only", description: "List only organizations you own" }
+    ],
+    examples: ["forloop org list", "forloop org list --owned-only"],
+    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 (!orgs.length) {
+        console.log("No organizations found.");
+        return;
+      }
+      const lines = ["Organizations:", ""];
+      for (const org of orgs) {
+        const role = org.members?.[0]?.role || "member";
+        lines.push(`  #${org.id} ${org.name} (${role})`);
+      }
+      console.log(lines.join("\n"));
+    }
+  });
+}
+function createOrgGetCommand() {
+  return defineCommand({
+    name: "org get",
+    description: "Get organization details",
+    usage: "forloop org get --id <number>",
+    options: [
+      { flag: "--id <number>", description: "Organization ID", required: true, type: "number" }
+    ],
+    examples: ["forloop org get --id 1"],
+    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}`);
+    }
+  });
+}
+function createOrgCreateCommand() {
+  return defineCommand({
+    name: "org create",
+    description: "Create a new organization (requires Team/Enterprise tier)",
+    usage: "forloop org create --name <text> [--description <text>]",
+    options: [
+      { flag: "--name <text>", description: "Organization name", required: true },
+      { flag: "--description <text>", description: "Organization description" }
+    ],
+    examples: ['forloop org create --name "My Team" --description "Engineering team"'],
+    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({
+        name: flags.name,
+        description: flags.description
+      });
+      console.log(`Organization created: #${org.id} - ${org.name}`);
+    }
+  });
+}
+function createOrgUpdateCommand() {
+  return defineCommand({
+    name: "org update",
+    description: "Update organization details",
+    usage: "forloop org update --id <number> [--name <text>] [--description <text>]",
+    options: [
+      { flag: "--id <number>", description: "Organization ID", required: true, type: "number" },
+      { flag: "--name <text>", description: "New name" },
+      { flag: "--description <text>", description: "New description" }
+    ],
+    examples: ['forloop org update --id 1 --name "New Name"'],
+    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, {
+        name: flags.name,
+        description: flags.description
+      });
+      console.log(`Organization #${org.id} updated successfully.`);
+    }
+  });
+}
+
+// src/commands/template.ts
+function createTemplateCommands() {
+  return {
+    "template list": createTemplateListCommand()
+  };
+}
+function createTemplateListCommand() {
+  return defineCommand({
+    name: "template list",
+    description: "List available story templates",
+    usage: "forloop template list",
+    examples: ["forloop template list"],
+    async run(_config) {
+      const config = getConfig();
+      const token = await getToken();
+      if (!token) {
+        console.error("Error: No API token configured.");
+        process.exit(1);
+      }
+      const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
+      const templates = await client.listTemplates();
+      const active = templates.filter((t) => !t.deletedAt);
+      if (!active.length) {
+        console.log("No templates found.");
+        return;
+      }
+      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})`);
+        lines.push(`    ${t.description}`);
+        lines.push(`    Fields: ${fieldNames}`);
+        lines.push("");
+      }
+      console.log(lines.join("\n"));
+    }
+  });
+}
+
+// src/commands/agent.ts
+function createAgentCommands() {
+  return {
+    "agent history": createAgentHistoryCommand(),
+    "agent developer-sprint": createDeveloperSprintCommand(),
+    "agent developer-status": createDeveloperStatusCommand()
+  };
+}
+async function getClient4() {
+  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 }) };
+}
+function createAgentHistoryCommand() {
+  return defineCommand({
+    name: "agent history",
+    description: "View conversation history with AI agents from opencode sessions",
+    usage: "forloop agent history [--sprint <id>] [--limit <n>]",
+    options: [
+      { flag: "--sprint <id>", description: "Sprint ID", type: "number" },
+      { 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) {
+      const resolved = await getClient4();
+      if (!resolved) return;
+      const { client } = resolved;
+      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("");
+      }
+    }
+  });
+}
+function createDeveloperSprintCommand() {
+  return defineCommand({
+    name: "agent developer-sprint",
+    description: "Trigger the developer agent to implement sprint stories",
+    usage: "forloop agent developer-sprint --sprint <id> [--message <text>]",
+    options: [
+      { flag: "--sprint <id>", description: "Sprint ID", required: true, type: "number" },
+      { flag: "--message <text>", description: "Instructions for the developer agent" }
+    ],
+    examples: ['forloop agent developer-sprint --sprint 1 --message "Implement all planned tasks"'],
+    async run(_config, flags) {
+      if (!flags.sprint) {
+        console.error("Error: --sprint is required");
+        process.exit(1);
+      }
+      const resolved = await getClient4();
+      if (!resolved) return;
+      const { client } = resolved;
+      const response = await client.chatWithAI({
+        sprintId: flags.sprint,
+        message: flags.message || "Start implementing the sprint stories assigned to the developer agent",
+        selectedAgentKey: "forLoopTaskSupervisor",
+        type: "developer.sprint",
+        metadata: { channel: "developer_sprint" }
+      });
+      const taskId = response.taskId || response.id || "unknown";
+      console.log(`Developer sprint triggered:`);
+      console.log(`  Task ID: ${taskId}`);
+      console.log(`  Sprint: #${flags.sprint}`);
+      console.log(`  Agent: forLoopTaskSupervisor`);
+      console.log(`Check dashboard for story progress.`);
+    }
+  });
+}
+function createDeveloperStatusCommand() {
+  return defineCommand({
+    name: "agent developer-status",
+    description: "Check status of a running developer task",
+    usage: "forloop agent developer-status [--sprint <id>]",
+    options: [
+      { flag: "--sprint <id>", description: "Sprint ID", type: "number" }
+    ],
+    examples: ["forloop agent developer-status --sprint 1"],
+    async run(_config, flags) {
+      const resolved = await getClient4();
+      if (!resolved) return;
+      const { client } = resolved;
+      const resolution = await resolveSprintId(flags.sprint);
+      if (!resolution.sprintId) {
+        console.error("Error: No sprint ID resolved.");
+        process.exit(1);
+      }
+      const status = await client.getDeveloperStatus(resolution.sprintId);
+      const sprint = status.sprint || {};
+      if (!status.hasActiveTask) {
+        console.log(`No active developer task.`);
+        console.log(`Sprint #${resolution.sprintId}: ${sprint.storiesDone || 0}/${sprint.storiesTotal || 0} stories done.`);
+        return;
+      }
+      const exec3 = status.execution || {};
+      const task = status.task || {};
+      console.log(`Developer Task: ${exec3.status}`);
+      console.log(`Sprint: #${resolution.sprintId}`);
+      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.`);
+    }
+  });
+}
+
+// src/commands/user.ts
+function createUserCommands() {
+  return {
+    "user profile": createUserProfileCommand(),
+    "user quotas": createUserQuotasCommand(),
+    "org quotas": createOrgQuotasCommand()
+  };
+}
+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 }) };
+}
+function createUserProfileCommand() {
+  return defineCommand({
+    name: "user profile",
+    description: "Get current user profile",
+    usage: "forloop user profile",
+    examples: ["forloop user profile"],
+    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}`);
+    }
+  });
+}
+function createUserQuotasCommand() {
+  return defineCommand({
+    name: "user quotas",
+    description: "Check user quota limits",
+    usage: "forloop user quotas",
+    examples: ["forloop user quotas"],
+    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));
+    }
+  });
+}
+function createOrgQuotasCommand() {
+  return defineCommand({
+    name: "org quotas",
+    description: "Get organization quota usage",
+    usage: "forloop org quotas --org-id <id>",
+    options: [
+      { flag: "--org-id <id>", description: "Organization ID", required: true, type: "number" }
+    ],
+    examples: ["forloop org quotas --org-id 1"],
+    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));
+    }
+  });
+}
+
+// src/commands/file.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function createFileCommands() {
+  return {
+    "file upload": createFileUploadCommand(),
+    "file list": createFileListCommand(),
+    "file delete": createFileDeleteCommand(),
+    "file download": createFileDownloadCommand()
+  };
+}
+async function getClient6() {
+  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 }) };
+}
+var mimeTypes = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".mp4": "video/mp4",
+  ".mp3": "audio/mpeg"
+};
+function formatSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function createFileUploadCommand() {
+  return defineCommand({
+    name: "file upload",
+    description: "Upload a file to a sprint via presigned S3 URL",
+    usage: "forloop file upload --path <path> --sprint <id> [--description <text>] [--folder <text>]",
+    options: [
+      { flag: "--path <path>", description: "Local file path", required: true },
+      { flag: "--sprint <id>", description: "Target sprint ID", required: true, type: "number" },
+      { flag: "--description <text>", description: "File description" },
+      { flag: "--folder <text>", description: "S3 folder within sprint" }
+    ],
+    examples: ["forloop file upload --path ./report.pdf --sprint 1 --folder docs"],
+    async run(_config, flags) {
+      const resolved = await getClient6();
+      if (!resolved) return;
+      const { client } = resolved;
+      const filePath = flags.path;
+      if (!fs4.existsSync(filePath)) {
+        console.error(`Error: File not found: ${filePath}`);
+        process.exit(1);
+      }
+      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,
+        contentType,
+        originalName: fileName,
+        folder: flags.folder
+      });
+      const uploadResponse = await fetch(presign.uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": contentType, "Content-Length": String(fileContent.length) },
+        body: fileContent
+      });
+      if (!uploadResponse.ok) {
+        console.error(`Error: Upload failed (${uploadResponse.status})`);
+        process.exit(1);
+      }
+      const complete = await client.completeUpload({
+        sprintId: flags.sprint,
+        fileName: presign.fileName,
+        originalName: fileName,
+        fileType: contentType,
+        size: fileContent.length,
+        folder: flags.folder
+      });
+      console.log(`File uploaded: ${fileName} (${formatSize(fileContent.length)})`);
+      console.log(`URL: ${complete.url}`);
+    }
+  });
+}
+function createFileListCommand() {
+  return defineCommand({
+    name: "file list",
+    description: "List files attached to a sprint",
+    usage: "forloop file list --sprint <id>",
+    options: [
+      { flag: "--sprint <id>", description: "Sprint ID", required: true, type: "number" }
+    ],
+    examples: ["forloop file list --sprint 1"],
+    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"));
+    }
+  });
+}
+function createFileDeleteCommand() {
+  return defineCommand({
+    name: "file delete",
+    description: "Delete a file from a sprint permanently",
+    usage: "forloop file delete --id <number> --confirm",
+    options: [
+      { flag: "--id <number>", description: "File ID", required: true, type: "number" },
+      { flag: "--confirm", description: "Confirm deletion" }
+    ],
+    examples: ["forloop file delete --id 1 --confirm"],
+    async run(_config, flags) {
+      if (!flags.confirm) {
+        console.error("Error: --confirm is required.");
+        process.exit(1);
+      }
+      const resolved = await getClient6();
+      if (!resolved) return;
+      const { client } = resolved;
+      await client.deleteFile(flags.id);
+      console.log(`File #${flags.id} deleted.`);
+    }
+  });
+}
+function createFileDownloadCommand() {
+  return defineCommand({
+    name: "file download",
+    description: "Get a download URL for a file",
+    usage: "forloop file download --id <number>",
+    options: [
+      { flag: "--id <number>", description: "File ID", required: true, type: "number" }
+    ],
+    examples: ["forloop file download --id 1"],
+    async run(_config, flags) {
+      const resolved = await getClient6();
+      if (!resolved) return;
+      const { client } = resolved;
+      await client.logFileRead(flags.id);
+      const download = await client.getFileDownloadUrl(flags.id);
+      console.log(`Download URL: ${download.url}`);
+    }
+  });
+}
+
+// src/commands/folder.ts
+function createFolderCommands() {
+  return {
+    "folder create": createFolderCreateCommand()
+  };
+}
+function createFolderCreateCommand() {
+  return defineCommand({
+    name: "folder create",
+    description: "Create a document folder for storing files",
+    usage: "forloop folder create --title <text> --sprint <id> [--description <text>] [--permissions <type>]",
+    options: [
+      { flag: "--title <text>", description: "Folder name", required: true },
+      { flag: "--sprint <id>", description: "Target sprint ID", required: true, type: "number" },
+      { flag: "--description <text>", description: "Folder description" },
+      { flag: "--permissions <type>", description: "public, team, private (default: team)" }
+    ],
+    examples: ['forloop folder create --title "Project Docs" --sprint 1 --permissions team'],
+    async run(_config, flags) {
+      const config = getConfig();
+      const token = await getToken();
+      if (!token) {
+        console.error("Error: No API token configured.");
+        process.exit(1);
+      }
+      const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
+      const story = await client.createStory({
+        title: flags.title,
+        description: flags.description,
+        sprintId: flags.sprint,
+        type: "doc_folder",
+        status: "todo",
+        metadata: JSON.stringify({ permissions: flags.permissions || "team" })
+      });
+      console.log(`Document folder created: #${story.id} - ${story.title}`);
+    }
+  });
+}
+
+// src/commands/sync.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function createSyncCommands() {
+  return {
+    "sync aivy-folder": createSyncAivyFolderCommand(),
+    "sync aivy-doc-get": createAivyDocGetCommand(),
+    "sync s3-to-local": createS3ToLocalCommand(),
+    "sync local-to-s3": createLocalToS3Command()
+  };
+}
+async function getClient7() {
+  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 }) };
+}
+function createSyncAivyFolderCommand() {
+  return defineCommand({
+    name: "sync aivy-folder",
+    description: "Ensure a doc_folder exists for file sync in the working sprint",
+    usage: "forloop sync aivy-folder [--sprint <id>] [--title <text>]",
+    options: [
+      { flag: "--sprint <id>", description: "Target sprint ID", type: "number" },
+      { flag: "--title <text>", description: 'Doc folder title (default: "forloop Aivy doc")' }
+    ],
+    examples: ["forloop sync aivy-folder --sprint 1"],
+    async run(_config, flags) {
+      const resolved = await getClient7();
+      if (!resolved) return;
+      const { client } = resolved;
+      const resolution = await resolveSprintId(flags.sprint);
+      if (!resolution.sprintId) {
+        console.error("Error: No sprint ID resolved.");
+        process.exit(1);
+      }
+      const title = flags.title || "forloop Aivy doc";
+      const sprint = await client.getSprint(resolution.sprintId, { includeStories: true, includeFiles: false });
+      const stories = Array.isArray(sprint?.stories) ? sprint.stories : [];
+      const existing = stories.find((s) => s.type === "doc_folder" && s.title?.toLowerCase() === title.toLowerCase());
+      if (existing?.id) {
+        console.log(`Doc folder already exists: #${existing.id} "${existing.title}"`);
+        return;
+      }
+      const created = await client.createStory({
+        sprintId: resolution.sprintId,
+        type: "doc_folder",
+        title,
+        status: "todo"
+      });
+      console.log(`Doc folder created: #${created.id} "${created.title}"`);
+    }
+  });
+}
+function createAivyDocGetCommand() {
+  return defineCommand({
+    name: "sync aivy-doc-get",
+    description: "Get the doc_folder story ID for linking files",
+    usage: "forloop sync aivy-doc-get [--sprint <id>] [--title <text>]",
+    options: [
+      { flag: "--sprint <id>", description: "Target sprint ID", type: "number" },
+      { flag: "--title <text>", description: 'Doc folder title (default: "forloop Aivy doc")' }
+    ],
+    examples: ["forloop sync aivy-doc-get --sprint 1"],
+    async run(_config, flags) {
+      const resolved = await getClient7();
+      if (!resolved) return;
+      const { client } = resolved;
+      const resolution = await resolveSprintId(flags.sprint);
+      if (!resolution.sprintId) {
+        console.error("Error: No sprint ID resolved.");
+        process.exit(1);
+      }
+      const title = flags.title || "forloop Aivy doc";
+      const sprint = await client.getSprint(resolution.sprintId, { includeStories: true, includeFiles: false });
+      const stories = Array.isArray(sprint?.stories) ? sprint.stories : [];
+      const existing = stories.find((s) => s.type === "doc_folder" && s.title?.toLowerCase() === title.toLowerCase());
+      if (existing?.id) {
+        console.log(`Doc folder: #${existing.id} "${existing.title}" (Sprint #${resolution.sprintId})`);
+      } else {
+        console.log(`Doc folder not found. Run: forloop sync aivy-folder --sprint ${resolution.sprintId}`);
+      }
+    }
+  });
+}
+function createS3ToLocalCommand() {
+  return defineCommand({
+    name: "sync s3-to-local",
+    description: "Download sprint files from S3 to local ~/.forloop/ directory",
+    usage: "forloop sync s3-to-local [--sprint <id>] [--no-knowledge] [--no-plans] [--no-tasks] [--overwrite]",
+    options: [
+      { flag: "--sprint <id>", description: "Target sprint ID", type: "number" },
+      { flag: "--no-knowledge", description: "Skip knowledge files" },
+      { flag: "--no-plans", description: "Skip plan files" },
+      { flag: "--no-tasks", description: "Skip task files" },
+      { flag: "--overwrite", description: "Overwrite existing local files" }
+    ],
+    examples: ["forloop sync s3-to-local --sprint 1"],
+    async run(_config, flags) {
+      const resolved = await getClient7();
+      if (!resolved) return;
+      const { client } = resolved;
+      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);
+      fs5.mkdirSync(localRoot, { recursive: true });
+      let downloaded = 0;
+      let skipped = 0;
+      for (const file of files) {
+        const name = (file.originalName || file.filename || "").toLowerCase();
+        const skip = flags.noKnowledge && name.startsWith("knowledge-") || flags.noPlans && name.startsWith("plan-") || flags.noTasks && name.startsWith("task-");
+        if (skip) {
+          skipped++;
+          continue;
+        }
+        const open = await client.getFileOpenUrl(file.id);
+        const res = await fetch(open.url);
+        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 = path5.join(localRoot, kind);
+          fs5.mkdirSync(dir, { recursive: true });
+          fs5.writeFileSync(path5.join(dir, name), buf);
+          downloaded++;
+        }
+      }
+      console.log(`Sync complete: ${downloaded} downloaded, ${skipped} skipped.`);
+    }
+  });
+}
+function createLocalToS3Command() {
+  return defineCommand({
+    name: "sync local-to-s3",
+    description: "Upload a local file to sprint S3",
+    usage: "forloop sync local-to-s3 --path <path> [--sprint <id>] [--folder <text>] [--delete]",
+    options: [
+      { flag: "--path <path>", description: "Local file path", required: true },
+      { flag: "--sprint <id>", description: "Target sprint ID", type: "number" },
+      { flag: "--folder <text>", description: "Remote folder (e.g., project/plans)" },
+      { flag: "--delete", description: "Delete remote file instead of uploading" }
+    ],
+    examples: ["forloop sync local-to-s3 --path ~/.forloop/sprint-1/plan/plan.md --sprint 1"],
+    async run(_config, flags) {
+      const resolved = await getClient7();
+      if (!resolved) return;
+      const { client } = resolved;
+      const resolution = await resolveSprintId(flags.sprint);
+      if (!resolution.sprintId) {
+        console.error("Error: No sprint ID resolved.");
+        process.exit(1);
+      }
+      const filePath = flags.path;
+      if (!fs5.existsSync(filePath)) {
+        console.error(`Error: File not found: ${filePath}`);
+        process.exit(1);
+      }
+      const fileBuf = fs5.readFileSync(filePath);
+      const fileName = path5.basename(filePath);
+      const contentType = "text/markdown";
+      const folder = flags.folder || "project";
+      const presign = await client.createPresignedUpload({
+        sprintId: resolution.sprintId,
+        contentType,
+        originalName: fileName,
+        folder
+      });
+      await fetch(presign.uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": contentType },
+        body: fileBuf
+      });
+      await client.completeUpload({
+        sprintId: resolution.sprintId,
+        fileName: presign.fileName,
+        originalName: fileName,
+        fileType: contentType,
+        size: fileBuf.length,
+        folder
+      });
+      console.log(`Synced: ${fileName} -> Sprint #${resolution.sprintId}`);
+    }
+  });
+}
+
+// src/registry.ts
+var CommandRegistry = class {
+  root = { children: /* @__PURE__ */ new Map() };
+  constructor(commands) {
+    for (const [path6, cmd] of Object.entries(commands)) {
+      this.register(path6, cmd);
+    }
+  }
+  register(path6, command) {
+    const parts = path6.split(" ");
+    let node = this.root;
+    for (const part of parts) {
+      if (!node.children.has(part)) {
+        node.children.set(part, { children: /* @__PURE__ */ new Map() });
+      }
+      node = node.children.get(part);
+    }
+    node.command = command;
+  }
+  getAllCommands() {
+    const commands = [];
+    const seen = /* @__PURE__ */ new Set();
+    const traverse = (node) => {
+      if (node.command && !seen.has(node.command)) {
+        seen.add(node.command);
+        commands.push(node.command);
+      }
+      for (const child of node.children.values()) {
+        traverse(child);
+      }
+    };
+    traverse(this.root);
+    return commands;
+  }
+  resolve(commandPath) {
+    let node = this.root;
+    const matched = [];
+    for (const part of commandPath) {
+      const child = node.children.get(part);
+      if (!child) break;
+      node = child;
+      matched.push(part);
+    }
+    if (node.command) {
+      return { command: node.command, extra: commandPath.slice(matched.length) };
+    }
+    if (matched.length > 0 && node.children.size === 1) {
+      const [, child] = node.children.entries().next().value;
+      if (child.command) {
+        return { command: child.command, extra: commandPath.slice(matched.length) };
+      }
+    }
+    if (matched.length > 0 && node.children.size > 1) {
+      const children = Array.from(node.children.values());
+      const commands = children.map((c) => c.command);
+      const first = commands[0];
+      if (first && commands.every((c) => c === first)) {
+        return { command: first, extra: commandPath.slice(matched.length) };
+      }
+    }
+    if (matched.length > 0 && node.children.size > 0) {
+      const subcommands = Array.from(node.children.entries()).map(([name, n]) => {
+        if (n.command) return `  ${matched.join(" ")} ${name}    ${n.command.description}`;
+        const subs = Array.from(n.children.keys()).join(", ");
+        return `  ${matched.join(" ")} ${name} [${subs}]`;
+      }).join("\n");
+      throw new CLIError(
+        `Unknown command: forloop ${commandPath.join(" ")}
+
+Available commands:
+${subcommands}`,
+        2 /* USAGE */,
+        `forloop ${matched.join(" ")} --help`
+      );
+    }
+    throw new CLIError(
+      `Unknown command: forloop ${commandPath.join(" ")}`,
+      2 /* USAGE */,
+      "forloop --help"
+    );
+  }
+  // Color helpers
+  bold = (s, out) => out.isTTY ? `\x1B[1m${s}\x1B[0m` : s;
+  accent = (s, out) => out.isTTY ? `\x1B[38;2;59;130;246m${s}\x1B[0m` : s;
+  dim = (s, out) => out.isTTY ? `\x1B[2m${s}\x1B[0m` : s;
+  printHelp(commandPath, out = process.stdout) {
+    if (commandPath.length === 0) {
+      this.printRootHelp(out);
+      return;
+    }
+    let node = this.root;
+    for (const part of commandPath) {
+      const child = node.children.get(part);
+      if (!child) {
+        this.printRootHelp(out);
+        return;
+      }
+      node = child;
+    }
+    if (node.command) {
+      this.printCommandHelp(node.command, out);
+      return;
+    }
+    const prefix = commandPath.join(" ");
+    out.write(`
+${this.bold("Usage:", out)} forloop ${prefix} <command> [flags]
+
+`);
+    out.write(`${this.bold("Commands:", out)}
+`);
+    this.printChildren(node, prefix, out);
+    out.write("\n");
+  }
+  printRootHelp(out) {
+    const LOGO = [
+      " \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+      " \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+      " \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+      " \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D ",
+      " \u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2551\u2588\u2588\u2551     ",
+      " \u255A\u2550\u255D      \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u255D     "
+    ];
+    const BLUE = [59, 130, 246];
+    out.write("\n");
+    for (const line of LOGO) {
+      if (out.isTTY) {
+        out.write(`\x1B[1;38;2;${BLUE[0]};${BLUE[1]};${BLUE[2]}m${line}\x1B[0m
+`);
+      } else {
+        out.write(line + "\n");
+      }
+    }
+    const b = (s) => this.bold(s, out);
+    const a = (s) => this.accent(s, out);
+    const d = (s) => this.dim(s, out);
+    out.write(`
+${b("Usage:")} forloop <resource> <command> [flags]
+
+${b("Resources:")}
+  ${a("auth")}       ${d("Authentication (login, status, logout)")}
+  ${a("sprint")}     ${d("Sprint operations (list, get, create, update, delete)")}
+  ${a("story")}      ${d("Story operations (create, get, update, delete)")}
+  ${a("template")}   ${d("Template operations (list)")}
+  ${a("agent")}      ${d("Agent operations (history, developer-sprint, developer-status)")}
+  ${a("org")}        ${d("Organization operations (list, get, create, update)")}
+  ${a("user")}       ${d("User operations (profile, quotas)")}
+  ${a("file")}       ${d("File operations (upload, list, delete, download)")}
+  ${a("folder")}     ${d("Folder operations (create)")}
+  ${a("sync")}       ${d("Sync operations (aivy-folder, aivy-doc-get, s3-to-local, local-to-s3)")}
+
+${b("Global Flags:")}
+  ${a("--api-key <key>")}        ${d("ForLoop API key")}
+  ${a("--api-url <url>")}        ${d("API base URL (overrides config)")}
+  ${a("--output <format>")}      ${d("Output format: text, json")}
+  ${a("--quiet")}                ${d("Suppress non-essential output")}
+  ${a("--verbose")}              ${d("Print HTTP request/response details")}
+  ${a("--timeout <seconds>")}    ${d("Request timeout (default: 60)")}
+  ${a("--no-color")}             ${d("Disable ANSI colors")}
+  ${a("--dry-run")}              ${d("Show what would happen without executing")}
+  ${a("--non-interactive")}      ${d("Disable interactive prompts (CI mode)")}
+  ${a("--version")}              ${d("Print version and exit")}
+  ${a("--help")}                 ${d("Show help")}
+
+${b("Getting Help:")}
+  ${d("Add --help after any command to see options and examples.")}
+  ${d("For example:")} forloop story get --help
+`);
+  }
+  printCommandHelp(cmd, out) {
+    const b = (s) => this.bold(s, out);
+    const a = (s) => this.accent(s, out);
+    const d = (s) => this.dim(s, out);
+    out.write(`
+${cmd.description}
+`);
+    if (cmd.usage) out.write(`${b("Usage:")} ${cmd.usage}
+`);
+    if (cmd.options && cmd.options.length > 0) {
+      const maxLen = Math.max(...cmd.options.map((o) => o.flag.length));
+      out.write(`
+${b("Options:")}
+`);
+      for (const opt of cmd.options) {
+        out.write(`  ${a(opt.flag.padEnd(maxLen + 2))} ${d(opt.description)}
+`);
+      }
+    }
+    if (cmd.examples && cmd.examples.length > 0) {
+      out.write(`
+${b("Examples:")}
+`);
+      for (const ex of cmd.examples) {
+        out.write(`  ${d(ex)}
+`);
+      }
+    }
+    out.write(`
+${d("Global flags (--api-key, --output, --quiet, etc.) are always available.")}
+`);
+    out.write(`${d("Run")} forloop --help ${d("for the full list.")}
+`);
+  }
+  printChildren(node, prefix, out) {
+    const entries = [];
+    const seen = /* @__PURE__ */ new Map();
+    const collect = (n, p) => {
+      for (const [name, child] of n.children) {
+        if (child.command) {
+          const existing = seen.get(child.command);
+          if (existing) continue;
+          seen.set(child.command, name);
+          entries.push({ fullName: `${p} ${name}`, description: child.command.description });
+        }
+        if (child.children.size > 0) collect(child, `${p} ${name}`);
+      }
+    };
+    collect(node, prefix);
+    if (entries.length === 0) return;
+    const maxLen = Math.max(...entries.map((e) => e.fullName.length));
+    for (const { fullName, description } of entries) {
+      out.write(`  ${this.accent(fullName.padEnd(maxLen), out)}  ${this.dim(description, out)}
+`);
+    }
+  }
+};
+var sprintGetCmd = createSprintCommands()["sprint get"];
+var sprintListCmd = createSprintCommands()["sprint list"];
+var sprintCreateCmd = createSprintCommands()["sprint create"];
+var sprintUpdateCmd = createSprintCommands()["sprint update"];
+var sprintDeleteCmd = createSprintCommands()["sprint delete"];
+var storyCreateCmd = createStoryCommands()["story create"];
+var storyGetCmd = createStoryCommands()["story get"];
+var storyUpdateCmd = createStoryCommands()["story update"];
+var storyDeleteCmd = createStoryCommands()["story delete"];
+var agentHistoryCmd = createAgentCommands()["agent history"];
+var agentDeveloperSprintCmd = createAgentCommands()["agent developer-sprint"];
+var agentDeveloperStatusCmd = createAgentCommands()["agent developer-status"];
+var fileUploadCmd = createFileCommands()["file upload"];
+var fileListCmd = createFileCommands()["file list"];
+var fileDeleteCmd = createFileCommands()["file delete"];
+var fileDownloadCmd = createFileCommands()["file download"];
+var registry = new CommandRegistry({
+  ...createAuthCommands(),
+  ...createStoryCommands(),
+  ...createSprintCommands(),
+  ...createOrgCommands(),
+  ...createTemplateCommands(),
+  ...createAgentCommands(),
+  ...createUserCommands(),
+  ...createFileCommands(),
+  ...createFolderCommands(),
+  ...createSyncCommands(),
+  // Aliases
+  "sprint show": sprintGetCmd,
+  "sprint info": sprintGetCmd,
+  "agent status": agentDeveloperStatusCmd,
+  "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");
+  const message = error instanceof Error ? error.message : String(error);
+  const exitCode = error instanceof CLIError ? error.exitCode : 1 /* GENERAL */;
+  if (isJson) {
+    console.error(formatError(message, "json"));
+  } else {
+    process.stderr.write(`
+Error: ${message}
+`);
+  }
+  const suggestion = error instanceof CLIError ? error.suggestion : void 0;
+  if (suggestion && !isJson) {
+    process.stderr.write(`
+Tip: ${suggestion}
+`);
+  }
+  process.exit(exitCode);
+}
+
+// src/main.ts
+var CLI_VERSION = "0.2.0";
+process.on("SIGINT", () => {
+  process.stderr.write("\nInterrupted. Exiting.\n");
+  process.exit(130);
+});
+process.stdout.on("error", (e) => {
+  if (e.code === "EPIPE") process.exit(0);
+});
+var NO_AUTH_COMMANDS = [
+  ["auth", "login"],
+  ["auth", "logout"],
+  ["auth", "status"]
+];
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(`forloop ${CLI_VERSION}`);
+    process.exit(0);
+  }
+  const commandPath = scanCommandPath(argv, GLOBAL_OPTIONS);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    registry.printHelp(commandPath, process.stderr);
+    process.exit(0);
+  }
+  if (commandPath.length === 0) {
+    registry.printHelp([], process.stderr);
+    try {
+      const token2 = await getToken();
+      if (token2) {
+        const tokenType = detectTokenType(token2);
+        const masked = token2.slice(0, 8) + "..." + token2.slice(-4);
+        process.stderr.write(`
+  Token: ${masked}  Type: ${tokenType || "unknown"}
+`);
+        process.stderr.write("  Use forloop --help for all available commands.\n\n");
+      } else {
+        process.stderr.write("\n  Not authenticated.\n");
+        process.stderr.write("  forloop auth login --api-key floop_xxxxx\n\n");
+      }
+    } catch {
+      process.stderr.write("\n  Not authenticated.\n");
+      process.stderr.write("  forloop auth login --api-key floop_xxxxx\n\n");
+    }
+    process.exit(0);
+  }
+  const { command, extra } = registry.resolve(commandPath);
+  const flags = parseFlags(argv, [...GLOBAL_OPTIONS, ...command.options ?? []]);
+  if (extra.length > 0) flags._positional = extra;
+  const pluginConfig = getConfig();
+  const token = await getToken();
+  const isNoAuth = NO_AUTH_COMMANDS.some(
+    (cmd) => cmd.every((c, i) => commandPath[i] === c)
+  );
+  if (!isNoAuth && !token) {
+    process.stderr.write("\nError: No ForLoop API token configured.\n");
+    process.stderr.write("  Run: forloop auth login --api-key floop_xxxxx\n");
+    process.stderr.write("  Or set: FORLOOP_API_KEY environment variable\n\n");
+    process.exit(3);
+  }
+  const cliConfig = {
+    region: pluginConfig.apiUrl.includes("dev.forloop.cc") ? "dev" : "global",
+    apiUrl: pluginConfig.apiUrl,
+    serverLambdaUrl: "",
+    environment: pluginConfig.environment,
+    output: flags.output === "json" ? "json" : "text",
+    timeout: flags.timeout ?? 60,
+    verbose: flags.verbose === true,
+    quiet: flags.quiet === true,
+    noColor: flags.noColor === true || !process.stdout.isTTY,
+    dryRun: flags.dryRun === true,
+    nonInteractive: flags.nonInteractive === true,
+    apiKey: flags.apiKey || token
+  };
+  await command.execute(cliConfig, flags);
+}
+main().catch(handleError);