exponential-cli 1.6.0 → 1.8.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/commands/auth.ts
 import { Command } from "commander";
@@ -1176,6 +1176,127 @@ Pipeline Stages (${stages.length})`));
   }
   console.log();
 }
+function outputPageJson(page) {
+  console.log(JSON.stringify(page, null, 2));
+}
+function outputPagePretty(page) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3.bold(page.title)}`);
+  console.log(chalk3.gray(`  ID: ${page.id}`));
+  if (page.project) {
+    console.log(`  ${chalk3.gray("Project:")} ${page.project.name}`);
+  }
+  if (page.body) {
+    console.log(`
+${page.body}
+`);
+  }
+}
+function outputPagesJson(pages) {
+  console.log(JSON.stringify({ pages, total: pages.length }, null, 2));
+}
+function outputPagesPretty(pages) {
+  if (pages.length === 0) {
+    console.log(chalk3.gray("No pages found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Pages (${pages.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const p of pages) {
+    console.log(`  ${chalk3.bold(p.title)}`);
+    console.log(chalk3.gray(`    ID: ${p.id}`));
+  }
+  console.log();
+}
+function outputRequirementJson(requirement) {
+  console.log(JSON.stringify(requirement, null, 2));
+}
+function outputRequirementPretty(requirement) {
+  const met = requirement.checkedAt ? chalk3.green("[met]") : chalk3.gray("[unmet]");
+  const kind = requirement.kind ? chalk3.gray(` (${requirement.kind})`) : "";
+  console.log(`  ${met} ${requirement.statement}${kind}`);
+  console.log(chalk3.gray(`    ID: ${requirement.id}`));
+}
+function outputRequirementsJson(requirements) {
+  console.log(JSON.stringify({ requirements, total: requirements.length }, null, 2));
+}
+function outputRequirementsPretty(requirements) {
+  if (requirements.length === 0) {
+    console.log(chalk3.gray("No requirements found."));
+    return;
+  }
+  const metCount = requirements.filter((r) => r.checkedAt).length;
+  console.log(chalk3.bold(`
+Requirements (${metCount}/${requirements.length} met)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const r of requirements) {
+    outputRequirementPretty(r);
+  }
+  console.log();
+}
+function outputRequirementBatchJson(results) {
+  console.log(JSON.stringify({
+    results,
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length
+  }, null, 2));
+}
+function outputRequirementBatchPretty(results) {
+  for (const r of results) {
+    if (r.success) {
+      console.log(`  ${chalk3.green("\u2713")} #${r.index}: ${r.requirement?.statement ?? ""}`);
+    } else {
+      console.log(`  ${chalk3.red("\u2717")} #${r.index}: ${r.error ?? "failed"}`);
+    }
+  }
+  const ok = results.filter((r) => r.success).length;
+  console.log(chalk3.bold(`
+${ok}/${results.length} requirements added`));
+}
+function getScopeStatusColor(status) {
+  switch (status) {
+    case "PLANNED":
+      return "blue";
+    case "IN_PROGRESS":
+      return "yellow";
+    case "SHIPPED":
+      return "green";
+    case "DEPRECATED":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+function outputScopeJson(scope) {
+  console.log(JSON.stringify(scope, null, 2));
+}
+function outputScopePretty(scope) {
+  const badge = chalk3[getScopeStatusColor(scope.status)](`[${scope.status}]`);
+  console.log(`  ${badge} ${chalk3.bold(scope.version)}`);
+  console.log(chalk3.gray(`    ID: ${scope.id}`));
+  if (scope.description) {
+    console.log(`    ${scope.description.substring(0, 120)}${scope.description.length > 120 ? "..." : ""}`);
+  }
+}
+function outputScopesJson(scopes) {
+  console.log(JSON.stringify({ scopes, total: scopes.length }, null, 2));
+}
+function outputScopesPretty(scopes) {
+  if (scopes.length === 0) {
+    console.log(chalk3.gray("No scopes found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Scopes (${scopes.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const s of scopes) {
+    outputScopePretty(s);
+  }
+  console.log();
+}
 
 // src/commands/actions.ts
 var VALID_PRIORITIES = [
@@ -1949,7 +2070,7 @@ function createEpicsCommand() {
 }
 
 // src/commands/features.ts
-import { Command as Command7 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/commands/stories.ts
 import { Command as Command6 } from "commander";
@@ -2058,12 +2179,325 @@ function createStoriesCommand() {
   return stories;
 }
 
+// src/commands/scopes.ts
+import { Command as Command7 } from "commander";
+var SCOPE_STATUSES = [
+  "PLANNED",
+  "IN_PROGRESS",
+  "SHIPPED",
+  "DEPRECATED"
+];
+function validateScopeStatus(value) {
+  if (!value) return void 0;
+  if (!SCOPE_STATUSES.includes(value)) {
+    throw new Error(
+      `Invalid status "${value}". Valid: ${SCOPE_STATUSES.join(", ")}`
+    );
+  }
+  return value;
+}
+function createScopesCommand() {
+  const scopes = new Command7("scopes").description(
+    `Manage a feature's scopes: shippable increments ("V1", "V2"), each with its own lifecycle.`
+  );
+  scopes.command("list").description("List a feature's scopes").requiredOption("--feature <id>", "Feature CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const list = await client.scopes.list({ featureId: options.feature });
+        if (useJson) outputScopesJson(list);
+        else outputScopesPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  scopes.command("add").description("Add a scope to a feature").requiredOption("--feature <id>", "Feature CUID").requiredOption("--version <label>", 'Short label for the increment, e.g. "V1"').requiredOption("-d, --description <text>", "What this scope delivers (markdown supported)").option("--status <status>", `Status: ${SCOPE_STATUSES.join(", ")} (default PLANNED)`).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateScopeStatus(options.status);
+        const client = getClient();
+        const scope = await client.scopes.create({
+          featureId: options.feature,
+          version: options.version,
+          description: options.description,
+          status
+        });
+        if (useJson) outputScopeJson(scope);
+        else {
+          console.log("\n\u2713 Scope added");
+          outputScopePretty(scope);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  scopes.command("update").description("Update a scope (setting SHIPPED stamps shippedAt and rolls the feature status up)").requiredOption("--id <id>", "Scope CUID").option("--version <label>", "New version label").option("-d, --description <text>", "New description").option("--status <status>", `Status: ${SCOPE_STATUSES.join(", ")}`).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateScopeStatus(options.status);
+        const client = getClient();
+        const scope = await client.scopes.update({
+          id: options.id,
+          version: options.version,
+          description: options.description,
+          status
+        });
+        if (useJson) outputScopeJson(scope);
+        else {
+          console.log("\n\u2713 Scope updated");
+          outputScopePretty(scope);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  scopes.command("rm").description("Delete a scope").requiredOption("--id <id>", "Scope CUID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const result = await client.scopes.delete(options.id);
+      if (useJson) console.log(JSON.stringify(result, null, 2));
+      else console.log("\n\u2713 Scope deleted");
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return scopes;
+}
+
+// src/commands/requirements.ts
+import { Command as Command8 } from "commander";
+var REQUIREMENT_KINDS = [
+  "FUNCTIONAL",
+  "NON_FUNCTIONAL",
+  "CONSTRAINT"
+];
+function validateKind(value) {
+  if (!value) return void 0;
+  if (!REQUIREMENT_KINDS.includes(value)) {
+    throw new Error(
+      `Invalid kind "${value}". Valid: ${REQUIREMENT_KINDS.join(", ")}`
+    );
+  }
+  return value;
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function createRequirementsCommand() {
+  const requirements = new Command8("requirements").description(
+    `Manage a feature's requirements: atomic, testable EARS-style "shall" statements, checkable met/unmet.`
+  );
+  requirements.command("add").description(
+    [
+      "Add requirements to a feature.",
+      "",
+      "Flag mode: pass -s/--statement (plus optional --kind/--scope) to add one requirement.",
+      "Batch mode: pipe a JSON array of { statement, kind?, scopeId? } on stdin",
+      "            to add many at once (per-item success/failure is reported)."
+    ].join("\n")
+  ).requiredOption("--feature <id>", "Feature CUID").option("-s, --statement <text>", 'One EARS-style "shall" statement').option("--kind <kind>", `Kind: ${REQUIREMENT_KINDS.join(", ")}`).option("--scope <id>", "Feature scope CUID to pin the requirement to").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        if (options.statement) {
+          const requirement = await client.requirements.create({
+            featureId: options.feature,
+            statement: options.statement,
+            kind: validateKind(options.kind),
+            scopeId: options.scope
+          });
+          if (useJson) outputRequirementJson(requirement);
+          else {
+            console.log("\n\u2713 Requirement added");
+            outputRequirementPretty(requirement);
+          }
+          return;
+        }
+        if (process.stdin.isTTY) {
+          throw new Error(
+            "Pass -s/--statement, or pipe a JSON array of requirements on stdin."
+          );
+        }
+        const raw = await readStdin2();
+        let batch;
+        try {
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed)) throw new Error("not an array");
+          batch = parsed;
+        } catch {
+          throw new Error(
+            "stdin must be a JSON array of { statement, kind?, scopeId? } objects."
+          );
+        }
+        const results = [];
+        for (const [index, item] of batch.entries()) {
+          try {
+            if (!item.statement || typeof item.statement !== "string") {
+              throw new Error('missing "statement"');
+            }
+            const input = {
+              featureId: options.feature,
+              statement: item.statement,
+              kind: validateKind(item.kind),
+              scopeId: item.scopeId
+            };
+            const requirement = await client.requirements.create(input);
+            results.push({ index, success: true, requirement });
+          } catch (error) {
+            results.push({
+              index,
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+        if (useJson) outputRequirementBatchJson(results);
+        else outputRequirementBatchPretty(results);
+        if (results.some((r) => !r.success)) process.exitCode = 1;
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  requirements.command("list").description("List a feature's requirements").requiredOption("--feature <id>", "Feature CUID").option("--scope <id>", "Only requirements pinned to this scope").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const list = await client.requirements.list({
+          featureId: options.feature,
+          scopeId: options.scope
+        });
+        if (useJson) outputRequirementsJson(list);
+        else outputRequirementsPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  requirements.command("check").description("Mark a requirement met (or unmet with --unmet)").requiredOption("--id <id>", "Requirement CUID").option("--unmet", "Mark unmet instead of met").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const requirement = await client.requirements.setChecked(
+          options.id,
+          !options.unmet
+        );
+        if (useJson) outputRequirementJson(requirement);
+        else {
+          console.log(`
+\u2713 Requirement marked ${options.unmet ? "unmet" : "met"}`);
+          outputRequirementPretty(requirement);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  requirements.command("rm").description("Delete a requirement").requiredOption("--id <id>", "Requirement CUID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const result = await client.requirements.delete(options.id);
+      if (useJson) console.log(JSON.stringify(result, null, 2));
+      else console.log("\n\u2713 Requirement deleted");
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return requirements;
+}
+
+// src/commands/areas.ts
+import { Command as Command9 } from "commander";
+import chalk4 from "chalk";
+function outputAreasPretty(areas) {
+  if (areas.length === 0) {
+    console.log(chalk4.gray("No areas found."));
+    return;
+  }
+  console.log(chalk4.bold(`
+Areas (${areas.length} total)`));
+  console.log(chalk4.gray("\u2500".repeat(50)));
+  for (const a of areas) {
+    const count = a._count?.features != null ? chalk4.gray(` (${a._count.features} features)`) : "";
+    console.log(`  ${chalk4.bold(a.name)}${count}`);
+    console.log(chalk4.gray(`    ID: ${a.id}`));
+  }
+  console.log();
+}
+function createAreasCommand() {
+  const areas = new Command9("areas").description(
+    "Manage a product's areas: the buckets features are filed under (a feature has exactly one or none)."
+  );
+  areas.command("list").description("List a product's areas").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(client, workspaceId, options.product);
+        const list = await client.areas.list({ productId });
+        if (useJson) console.log(JSON.stringify({ areas: list, total: list.length }, null, 2));
+        else outputAreasPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  areas.command("create").description("Create an area in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-n, --name <name>", "Area name (unique per product)").option("-d, --description <text>", "What belongs in this area").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(client, workspaceId, options.product);
+        const area = await client.areas.create({
+          productId,
+          name: options.name,
+          description: options.description
+        });
+        if (useJson) console.log(JSON.stringify(area, null, 2));
+        else console.log(`
+\u2713 Area created: ${area.name} (${area.id})`);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return areas;
+}
+
 // src/commands/features.ts
 var FEATURE_STATUSES = [
   "IDEA",
   "DEFINED",
   "IN_PROGRESS",
   "SHIPPED",
+  "DEPRECATED",
   "ARCHIVED"
 ];
 function validateFeatureStatus(value) {
@@ -2076,7 +2510,7 @@ function validateFeatureStatus(value) {
   return value;
 }
 function createFeaturesCommand() {
-  const features = new Command7("features").description(
+  const features = new Command10("features").description(
     "Manage features. A feature lives under a product and groups user stories, scopes, and tickets."
   );
   features.command("list").description("List features in a product").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option("--status <status>", `Filter by status: ${FEATURE_STATUSES.join(", ")}`).action(
@@ -2112,7 +2546,7 @@ function createFeaturesCommand() {
       handleError(error, useJson);
     }
   });
-  features.command("create").description("Create a new feature in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-n, --name <name>", "Feature name").option("-d, --description <text>", "Description (markdown supported)").option("--vision <text>", "Vision / target outcome").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--effort <n>", "Effort estimate", parseFloat).option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
+  features.command("create").description("Create a new feature in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-n, --name <name>", "Feature name").option("-d, --description <text>", "Description (markdown supported)").option("--vision <text>", "Vision / target outcome").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--effort <n>", "Effort estimate", parseFloat).option("--area <id>", "Area CUID (per-product bucket) to file the feature under").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
     async (options, cmd) => {
       const globalOpts = cmd.optsWithGlobals();
       const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2132,7 +2566,8 @@ function createFeaturesCommand() {
           vision: options.vision,
           status,
           priority: options.priority,
-          effort: options.effort
+          effort: options.effort,
+          areaId: options.area
         });
         if (useJson) outputFeatureJson(feature);
         else {
@@ -2144,7 +2579,7 @@ function createFeaturesCommand() {
       }
     }
   );
-  features.command("update").description("Update an existing feature").requiredOption("--id <id>", "Feature CUID").option("-n, --name <name>", "New name").option("-d, --description <text>", "New description").option("--vision <text>", "New vision text").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4", parseInt).option("--effort <n>", "Effort estimate", parseFloat).action(
+  features.command("update").description("Update an existing feature").requiredOption("--id <id>", "Feature CUID").option("-n, --name <name>", "New name").option("-d, --description <text>", "New description").option("--vision <text>", "New vision text").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4", parseInt).option("--effort <n>", "Effort estimate", parseFloat).option("--area <id>", 'Area CUID ("none" to clear)').action(
     async (options, cmd) => {
       const globalOpts = cmd.optsWithGlobals();
       const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2158,7 +2593,8 @@ function createFeaturesCommand() {
           vision: options.vision,
           status,
           priority: options.priority,
-          effort: options.effort
+          effort: options.effort,
+          areaId: options.area === "none" ? null : options.area
         });
         if (useJson) outputFeatureJson(feature);
         else {
@@ -2170,13 +2606,51 @@ function createFeaturesCommand() {
       }
     }
   );
+  features.command("link-page").description("Link a Knowledge page (PRD, spec, research) to a feature").requiredOption("--feature <id>", "Feature CUID").requiredOption("--page <id>", "Page CUID").option("--scope <id>", "Feature scope CUID to pin the page to").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const link = await client.features.linkPage({
+          featureId: options.feature,
+          pageId: options.page,
+          scopeId: options.scope
+        });
+        if (useJson) console.log(JSON.stringify(link, null, 2));
+        else console.log("\n\u2713 Page linked");
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  features.command("unlink-page").description("Unlink a Knowledge page from a feature").requiredOption("--feature <id>", "Feature CUID").requiredOption("--page <id>", "Page CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const result = await client.features.unlinkPage(
+          options.feature,
+          options.page
+        );
+        if (useJson) console.log(JSON.stringify(result, null, 2));
+        else console.log("\n\u2713 Page unlinked");
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
   features.addCommand(createStoriesCommand());
+  features.addCommand(createScopesCommand());
+  features.addCommand(createRequirementsCommand());
+  features.addCommand(createAreasCommand());
   return features;
 }
 
 // src/commands/labels.ts
-import { Command as Command8 } from "commander";
-import chalk4 from "chalk";
+import { Command as Command11 } from "commander";
+import chalk5 from "chalk";
 var TRIAGE_LABELS = [
   { slug: "needs-triage", name: "needs-triage", color: "avatar-orange" },
   { slug: "needs-info", name: "needs-info", color: "avatar-yellow" },
@@ -2190,22 +2664,22 @@ function looksLikeCuid(value) {
 }
 function outputTagsPretty(tags) {
   if (tags.length === 0) {
-    console.log(chalk4.dim("No labels found."));
+    console.log(chalk5.dim("No labels found."));
     return;
   }
   console.log();
   for (const tag of tags) {
-    const scope = tag.workspaceId === null ? chalk4.cyan("global") : chalk4.magenta("workspace");
-    const category = tag.category === null ? chalk4.dim("(label)") : chalk4.dim(`(${tag.category})`);
+    const scope = tag.workspaceId === null ? chalk5.cyan("global") : chalk5.magenta("workspace");
+    const category = tag.category === null ? chalk5.dim("(label)") : chalk5.dim(`(${tag.category})`);
     console.log(
-      `  ${chalk4.bold(tag.slug)}  ${tag.name}  ${chalk4.gray(tag.color)}  ${scope}  ${category}`
+      `  ${chalk5.bold(tag.slug)}  ${tag.name}  ${chalk5.gray(tag.color)}  ${scope}  ${category}`
     );
   }
   console.log();
 }
 function outputTagPretty(tag, prefix) {
   if (prefix) console.log(prefix);
-  console.log(`  ${chalk4.bold(tag.slug)}  ${tag.name}  ${chalk4.gray(tag.color)}`);
+  console.log(`  ${chalk5.bold(tag.slug)}  ${tag.name}  ${chalk5.gray(tag.color)}`);
 }
 async function resolveLabelIds(client, workspaceId, values) {
   if (values.length === 0) return [];
@@ -2229,7 +2703,7 @@ async function resolveLabelIds(client, workspaceId, values) {
   return [...byId, ...resolvedFromSlugs];
 }
 function createLabelsCommand() {
-  const labels = new Command8("labels").description(
+  const labels = new Command11("labels").description(
     "Manage labels (orthogonal tags applied to actions, tickets, features, and epics)."
   );
   labels.command("list").description("List labels visible in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID").option(
@@ -2277,7 +2751,7 @@ function createLabelsCommand() {
         if (useJson) {
           console.log(JSON.stringify(tag, null, 2));
         } else {
-          outputTagPretty(tag, chalk4.green("\n\u2713 Label created"));
+          outputTagPretty(tag, chalk5.green("\n\u2713 Label created"));
         }
       } catch (error) {
         handleError(error, useJson);
@@ -2315,10 +2789,10 @@ function createLabelsCommand() {
           console.log(JSON.stringify(results, null, 2));
         } else {
           console.log();
-          console.log(chalk4.bold("Triage labels:"));
+          console.log(chalk5.bold("Triage labels:"));
           for (const r of results) {
-            const tag = chalk4.bold(r.slug);
-            const status = r.status === "created" ? chalk4.green("created") : chalk4.dim("existed");
+            const tag = chalk5.bold(r.slug);
+            const status = r.status === "created" ? chalk5.green("created") : chalk5.dim("existed");
             console.log(`  ${tag}  ${status}`);
           }
           console.log();
@@ -2332,7 +2806,7 @@ function createLabelsCommand() {
 }
 
 // src/commands/organizations.ts
-import { Command as Command9 } from "commander";
+import { Command as Command12 } from "commander";
 var VALID_SIZES = [
   "1-10",
   "11-50",
@@ -2342,7 +2816,7 @@ var VALID_SIZES = [
   "1000+"
 ];
 function createOrganizationsCommand() {
-  const organizations = new Command9("organizations").alias("orgs").description("Manage CRM organizations");
+  const organizations = new Command12("organizations").alias("orgs").description("Manage CRM organizations");
   organizations.command("list").description("List organizations").requiredOption("--workspace <id>", "Workspace ID").option("--search <query>", "Search by name or description").option("--industry <industry>", "Filter by industry").option("--limit <n>", "Max results to return", parseInt).option("--cursor <cursor>", "Pagination cursor").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2409,10 +2883,101 @@ function createOrganizationsCommand() {
   return organizations;
 }
 
+// src/commands/pages.ts
+import { readFileSync } from "fs";
+import { Command as Command13 } from "commander";
+function readBody(body, bodyFile) {
+  if (body !== void 0) return body;
+  if (bodyFile === void 0) return void 0;
+  if (bodyFile === "-") return readFileSync(0, "utf-8");
+  return readFileSync(bodyFile, "utf-8");
+}
+function createPagesCommand() {
+  const pages = new Command13("pages").description(
+    'Manage Knowledge pages (PRDs, research, technical specs). Link one to a feature with "features link-page".'
+  );
+  pages.command("list").description("List pages in a workspace").option("--workspace <slug|id>", "Workspace (defaults to the configured default)").option("--search <text>", "Filter by title/content").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const list = await client.pages.list({
+          workspaceId,
+          search: options.search
+        });
+        if (useJson) outputPagesJson(list);
+        else outputPagesPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  pages.command("get <id>").description("Get a page by CUID (body is Markdown)").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const page = await client.pages.get(id);
+      if (useJson) outputPageJson(page);
+      else outputPagePretty(page);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  pages.command("create").description("Create a page. Body: -b text, --body-file <path>, or --body-file - for stdin.").option("--workspace <slug|id>", "Workspace (defaults to the configured default)").requiredOption("-t, --title <title>", "Page title").option("-b, --body <markdown>", "Markdown body").option("--body-file <path>", 'Read the Markdown body from a file ("-" = stdin)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const page = await client.pages.create({
+          workspaceId,
+          title: options.title,
+          body: readBody(options.body, options.bodyFile)
+        });
+        if (useJson) outputPageJson(page);
+        else {
+          console.log("\n\u2713 Page created");
+          outputPagePretty(page);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  pages.command("update").description(
+    "Update a page. Sending a body is a Markdown-source write: the Markdown becomes canonical."
+  ).requiredOption("--id <id>", "Page CUID").option("-t, --title <title>", "New title").option("-b, --body <markdown>", "New Markdown body (replaces the whole body)").option("--body-file <path>", 'Read the new Markdown body from a file ("-" = stdin)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const page = await client.pages.update({
+          id: options.id,
+          title: options.title,
+          body: readBody(options.body, options.bodyFile)
+        });
+        if (useJson) outputPageJson(page);
+        else {
+          console.log("\n\u2713 Page updated");
+          outputPagePretty(page);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return pages;
+}
+
 // src/commands/products.ts
-import { Command as Command10 } from "commander";
+import { Command as Command14 } from "commander";
 function createProductsCommand() {
-  const products = new Command10("products").description(
+  const products = new Command14("products").description(
     "Manage products. A workspace contains products; a product holds features and tickets."
   );
   products.command("list").description("List products in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID (defaults to configured workspace)").action(async (options, cmd) => {
@@ -2475,9 +3040,9 @@ function createProductsCommand() {
 }
 
 // src/commands/projects.ts
-import { Command as Command11 } from "commander";
+import { Command as Command15 } from "commander";
 function createProjectsCommand() {
-  const projects = new Command11("projects").description("Manage projects");
+  const projects = new Command15("projects").description("Manage projects");
   projects.command("list").description("List all projects").option("--workspace <id>", "Filter by workspace ID").option("--include-actions", "Include actions in output").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2499,8 +3064,86 @@ function createProjectsCommand() {
   return projects;
 }
 
+// src/commands/search.ts
+import { Command as Command16 } from "commander";
+import chalk6 from "chalk";
+var TYPE_LABELS = {
+  workspace: "Workspaces",
+  project: "Projects",
+  action: "Actions",
+  goal: "Goals",
+  keyResult: "Key Results",
+  outcome: "Outcomes",
+  ticket: "Tickets",
+  feature: "Features",
+  epic: "Epics",
+  page: "Pages",
+  meeting: "Meetings",
+  contact: "Contacts",
+  organization: "Organizations",
+  product: "Products"
+};
+function createSearchCommand() {
+  const search = new Command16("search").description(
+    "Global search across projects, actions, goals, workspaces and more \u2014 same coverage as the app's Cmd+K palette"
+  ).argument("<query>", "Text to search for").option("-w, --workspace <slug>", "Restrict results to one workspace (slug or ID)").option("-l, --limit <n>", "Max results per entity type (1-25, default 10)").action(async (query, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      let workspaceId;
+      if (options.workspace) {
+        const workspaces = await client.workspaces.list();
+        const match = workspaces.find(
+          (w) => w.slug === options.workspace || w.id === options.workspace
+        );
+        if (!match) {
+          console.error(chalk6.red(`Workspace "${options.workspace}" not found.`));
+          console.log(chalk6.gray("Available workspaces:"));
+          workspaces.forEach((w) => {
+            console.log(chalk6.gray(`  - ${w.slug} (${w.name})`));
+          });
+          process.exit(1);
+        }
+        workspaceId = match.id;
+      }
+      const limit = options.limit ? Number(options.limit) : void 0;
+      const result = await client.search.global({ query, workspaceId, limit });
+      if (useJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.results.length === 0) {
+        console.log(chalk6.gray(`No matches for "${result.query}".`));
+        return;
+      }
+      const byType = /* @__PURE__ */ new Map();
+      for (const r of result.results) {
+        const bucket = byType.get(r.type) ?? [];
+        bucket.push(r);
+        byType.set(r.type, bucket);
+      }
+      for (const [type, rows] of byType) {
+        console.log(chalk6.bold(`
+${TYPE_LABELS[type] ?? type}`));
+        for (const row of rows) {
+          const parts = [chalk6.white(row.title)];
+          if (row.subtitle) parts.push(chalk6.gray(row.subtitle));
+          if (row.workspace) parts.push(chalk6.cyan(`@${row.workspace.slug}`));
+          console.log(`  ${parts.join(chalk6.gray(" \xB7 "))}`);
+          console.log(chalk6.gray(`    ${row.id}${row.url ? `  ${row.url}` : ""}`));
+        }
+      }
+      console.log();
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return search;
+}
+
 // src/commands/tickets.ts
-import { Command as Command12 } from "commander";
+import { Command as Command17 } from "commander";
 function collectRepeatable(value, previous) {
   return [...previous, value];
 }
@@ -2543,7 +3186,7 @@ function validateTicketType(value) {
   return value;
 }
 function createTicketsCommand() {
-  const tickets = new Command12("tickets").description(
+  const tickets = new Command17("tickets").description(
     "Manage product backlog tickets. Tickets live under a product, link to features/epics, depend on each other, and can be implemented via actions."
   );
   tickets.command("list").description(
@@ -2646,7 +3289,7 @@ function createTicketsCommand() {
       handleError(error, useJson);
     }
   });
-  tickets.command("create").description("Create a new ticket in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-t, --title <title>", "Ticket title").option("-b, --body <text>", "Body (markdown supported)").option("--type <type>", `Ticket type: ${TICKET_TYPES.join(", ")}`).option("--status <status>", `Initial status: ${TICKET_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--points <n>", "Story points", parseFloat).option("--feature <id>", "Feature CUID to attach to").option("--epic <id>", "Epic CUID to attach to").option("--assignee <id>", "Assignee user ID").option("--branch <name>", "Branch name").option("--pr <url>", "Pull request URL").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option(
+  tickets.command("create").description("Create a new ticket in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-t, --title <title>", "Ticket title").option("-b, --body <text>", "Body (markdown supported)").option("--type <type>", `Ticket type: ${TICKET_TYPES.join(", ")}`).option("--status <status>", `Initial status: ${TICKET_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--points <n>", "Story points", parseFloat).option("--feature <id>", "Feature CUID to attach to").option("--scope <id>", "Feature scope CUID to attach to (requires --feature)").option("--epic <id>", "Epic CUID to attach to").option("--assignee <id>", "Assignee user ID").option("--branch <name>", "Branch name").option("--pr <url>", "Pull request URL").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option(
     "--label <slug-or-id>",
     "Label to attach (repeatable)",
     collectRepeatable,
@@ -2674,6 +3317,7 @@ function createTicketsCommand() {
           priority: options.priority,
           points: options.points,
           featureId: options.feature,
+          scopeId: options.scope,
           epicId: options.epic,
           assigneeId: options.assignee,
           branchName: options.branch,
@@ -2856,7 +3500,7 @@ function createTicketsCommand() {
       handleError(error, useJson);
     }
   });
-  const comment = new Command12("comment").description("Manage comments on a ticket");
+  const comment = new Command17("comment").description("Manage comments on a ticket");
   comment.command("add").description("Add a comment to a ticket").requiredOption("--id <id>", "Ticket CUID").requiredOption("-m, --message <text>", "Comment content (markdown supported)").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2895,10 +3539,10 @@ function createTicketsCommand() {
 }
 
 // src/commands/workspaces.ts
-import { Command as Command13 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command18 } from "commander";
+import chalk7 from "chalk";
 function createWorkspacesCommand() {
-  const workspaces = new Command13("workspaces").description("Manage workspaces");
+  const workspaces = new Command18("workspaces").description("Manage workspaces");
   workspaces.command("list").description("List all workspaces").action(async (_options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2911,7 +3555,7 @@ function createWorkspacesCommand() {
         const config = getConfig();
         outputWorkspacesPretty(workspaces2);
         if (config.defaultWorkspaceSlug) {
-          console.log(chalk5.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
+          console.log(chalk7.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
         }
       }
     } catch (error) {
@@ -2924,10 +3568,10 @@ function createWorkspacesCommand() {
       const workspaces2 = await client.workspaces.list();
       const workspace = workspaces2.find((w) => w.slug === slug);
       if (!workspace) {
-        console.error(chalk5.red(`Workspace with slug "${slug}" not found.`));
-        console.log(chalk5.gray("Available workspaces:"));
+        console.error(chalk7.red(`Workspace with slug "${slug}" not found.`));
+        console.log(chalk7.gray("Available workspaces:"));
         workspaces2.forEach((w) => {
-          console.log(chalk5.gray(`  - ${w.slug} (${w.name})`));
+          console.log(chalk7.gray(`  - ${w.slug} (${w.name})`));
         });
         process.exit(1);
       }
@@ -2935,7 +3579,7 @@ function createWorkspacesCommand() {
         defaultWorkspaceId: workspace.id,
         defaultWorkspaceSlug: workspace.slug
       });
-      console.log(chalk5.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
+      console.log(chalk7.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
     } catch (error) {
       handleError(error);
     }
@@ -2944,7 +3588,7 @@ function createWorkspacesCommand() {
 }
 
 // src/index.ts
-var program = new Command14();
+var program = new Command19();
 program.name("exponential").description(
   [
     "CLI to interact with Exponential productivity app.",
@@ -2962,8 +3606,10 @@ program.addCommand(createEpicsCommand());
 program.addCommand(createFeaturesCommand());
 program.addCommand(createLabelsCommand());
 program.addCommand(createOrganizationsCommand());
+program.addCommand(createPagesCommand());
 program.addCommand(createProductsCommand());
 program.addCommand(createProjectsCommand());
+program.addCommand(createSearchCommand());
 program.addCommand(createTicketsCommand());
 program.addCommand(createWorkspacesCommand());
 program.parse();