@popoverai/dotrequirements 0.25.0 → 0.26.0

package/dist/schema/run-marker.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CTS run markers: per-run identifiers stamped into the frontmatter of every
+ * document a codebase-to-spec run produces. At push time a valid, team-unseen
+ * marker grants `imported` authorship to the rows it creates (IMPORT-1, IMPORT-2).
+ *
+ * Format: 32 hex chars rendered in UUID layout (8-4-4-4-12).
+ *   [0..23]  random component (96 bits)
+ *   [24]     scheme version nibble
+ *   [25..31] integrity checksum: first 7 hex chars of
+ *            sha256(`${SALT}:${random}:${version}`)
+ *
+ * The checksum is an intentionality gate, not security: the salt ships in
+ * published source, so a determined forger can reproduce it. Its job is to make
+ * casual tampering ("what if I tweak this value?") fail validation, so that
+ * successful forgery requires mining the source — documented intent (see
+ * docs/working/cts-onboarding-funnel.md, abuse posture).
+ *
+ * Pure-JS SHA-256 is used (rather than node:crypto or crypto.subtle) so the
+ * same module runs identically in Node and the Convex isolate, synchronously.
+ */
+export type RunMarkerValidation = {
+    valid: true;
+    version: string;
+} | {
+    valid: false;
+    reason: "malformed" | "unsupported_version" | "checksum_mismatch";
+};
+/**
+ * Generate a new run marker (IMPORT-1.2, IMPORT-1.3).
+ */
+export declare function generateRunMarker(): string;
+/**
+ * Validate a run marker's shape and integrity (IMPORT-2.0, IMPORT-3.0).
+ * Does NOT consult the import ledger — replay checking is the caller's job.
+ */
+export declare function validateRunMarker(marker: string): RunMarkerValidation;
+export declare function sha256Hex(input: string): string;
+//# sourceMappingURL=run-marker.d.ts.map

package/dist/schema/run-marker.js

@@ -0,0 +1,138 @@
+/**
+ * CTS run markers: per-run identifiers stamped into the frontmatter of every
+ * document a codebase-to-spec run produces. At push time a valid, team-unseen
+ * marker grants `imported` authorship to the rows it creates (IMPORT-1, IMPORT-2).
+ *
+ * Format: 32 hex chars rendered in UUID layout (8-4-4-4-12).
+ *   [0..23]  random component (96 bits)
+ *   [24]     scheme version nibble
+ *   [25..31] integrity checksum: first 7 hex chars of
+ *            sha256(`${SALT}:${random}:${version}`)
+ *
+ * The checksum is an intentionality gate, not security: the salt ships in
+ * published source, so a determined forger can reproduce it. Its job is to make
+ * casual tampering ("what if I tweak this value?") fail validation, so that
+ * successful forgery requires mining the source — documented intent (see
+ * docs/working/cts-onboarding-funnel.md, abuse posture).
+ *
+ * Pure-JS SHA-256 is used (rather than node:crypto or crypto.subtle) so the
+ * same module runs identically in Node and the Convex isolate, synchronously.
+ */
+const RUN_MARKER_SALT = "dotrequirements-cts-run-marker";
+/** Current marker scheme version (single hex nibble). */
+const SCHEME_VERSION = "1";
+const HEX_32 = /^[0-9a-f]{32}$/;
+const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/**
+ * Generate a new run marker (IMPORT-1.2, IMPORT-1.3).
+ */
+export function generateRunMarker() {
+    const bytes = new Uint8Array(12); // 96 bits → 24 hex chars
+    globalThis.crypto.getRandomValues(bytes);
+    const random = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    const checksum = computeChecksum(random, SCHEME_VERSION);
+    return toUuidLayout(`${random}${SCHEME_VERSION}${checksum}`);
+}
+/**
+ * Validate a run marker's shape and integrity (IMPORT-2.0, IMPORT-3.0).
+ * Does NOT consult the import ledger — replay checking is the caller's job.
+ */
+export function validateRunMarker(marker) {
+    if (typeof marker !== "string" || !UUID_SHAPE.test(marker)) {
+        return { valid: false, reason: "malformed" };
+    }
+    const hex = marker.replaceAll("-", "");
+    if (!HEX_32.test(hex)) {
+        return { valid: false, reason: "malformed" };
+    }
+    const random = hex.slice(0, 24);
+    const version = hex.slice(24, 25);
+    const checksum = hex.slice(25);
+    if (version !== SCHEME_VERSION) {
+        // IMPORT-1.4: future schemes validate their own versions; anything we
+        // don't know is unsupported, not malformed.
+        return { valid: false, reason: "unsupported_version" };
+    }
+    if (computeChecksum(random, version) !== checksum) {
+        return { valid: false, reason: "checksum_mismatch" };
+    }
+    return { valid: true, version };
+}
+function computeChecksum(randomHex, version) {
+    return sha256Hex(`${RUN_MARKER_SALT}:${randomHex}:${version}`).slice(0, 7);
+}
+function toUuidLayout(hex32) {
+    return `${hex32.slice(0, 8)}-${hex32.slice(8, 12)}-${hex32.slice(12, 16)}-${hex32.slice(16, 20)}-${hex32.slice(20)}`;
+}
+// =============================================================================
+// Pure-JS SHA-256 (FIPS 180-4). Synchronous and runtime-independent.
+// =============================================================================
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function rotr(x, n) {
+    return (x >>> n) | (x << (32 - n));
+}
+export function sha256Hex(input) {
+    const data = new TextEncoder().encode(input);
+    const bitLen = data.length * 8;
+    // Padding: 0x80, zeros, 64-bit big-endian length
+    const padded = new Uint8Array((((data.length + 8) >> 6) << 6) + 64);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 4, bitLen >>> 0, false);
+    view.setUint32(padded.length - 8, Math.floor(bitLen / 0x100000000), false);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+        0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}
+//# sourceMappingURL=run-marker.js.map

package/dist/schema/schemas.d.ts

@@ -60,6 +60,7 @@ export declare function buildRequirementKey(prefix: string, number: number): str
 export declare const MetadataSchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
     pulledAt: z.ZodOptional<z.ZodString>;
+    ctsRun: z.ZodOptional<z.ZodString>;
     document: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         title: z.ZodString;
@@ -76,6 +77,7 @@ export declare const MetadataSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     version?: number | undefined;
     pulledAt?: string | undefined;
+    ctsRun?: string | undefined;
     document?: {
         title: string;
         id?: string | undefined;
@@ -84,6 +86,7 @@ export declare const MetadataSchema: z.ZodObject<{
 }, {
     version?: number | undefined;
     pulledAt?: string | undefined;
+    ctsRun?: string | undefined;
     document?: {
         title: string;
         id?: string | undefined;
@@ -146,6 +149,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     _meta: z.ZodObject<{
         version: z.ZodOptional<z.ZodNumber>;
         pulledAt: z.ZodOptional<z.ZodString>;
+        ctsRun: z.ZodOptional<z.ZodString>;
         document: z.ZodOptional<z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
@@ -162,6 +166,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;
@@ -170,6 +175,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;
@@ -180,6 +186,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     _meta: z.ZodObject<{
         version: z.ZodOptional<z.ZodNumber>;
         pulledAt: z.ZodOptional<z.ZodString>;
+        ctsRun: z.ZodOptional<z.ZodString>;
         document: z.ZodOptional<z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
@@ -196,6 +203,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;
@@ -204,6 +212,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;
@@ -214,6 +223,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     _meta: z.ZodObject<{
         version: z.ZodOptional<z.ZodNumber>;
         pulledAt: z.ZodOptional<z.ZodString>;
+        ctsRun: z.ZodOptional<z.ZodString>;
         document: z.ZodOptional<z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
@@ -230,6 +240,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;
@@ -238,6 +249,7 @@ export declare const RequirementsFileSchema: z.ZodObject<{
     }, {
         version?: number | undefined;
         pulledAt?: string | undefined;
+        ctsRun?: string | undefined;
         document?: {
             title: string;
             id?: string | undefined;

package/dist/schema/schemas.js

@@ -112,6 +112,7 @@ export function buildRequirementKey(prefix, number) {
 export const MetadataSchema = z.object({
     version: z.number().optional(), // Informational - incremented on push
     pulledAt: z.string().optional(), // ISO 8601 timestamp - used for conflict detection
+    ctsRun: z.string().optional(), // Run marker stamped by codebase-to-spec (IMPORT-1); grants imported authorship at document creation (IMPORT-2)
     document: z
         .object({
         id: z.string().optional(), // Cloud document link - filled by push when creating

package/dist/templates/agents/cts-worker.md

@@ -4,6 +4,6 @@ description: Generic worker subagent for the codebase-to-spec workflow. Handles
 tools: Bash, Read, Edit, Write, Glob, Grep
 ---
 
-You are a codebase-to-spec worker. The prompt you receive tells you which CLI dispatch to fetch: it will instruct you to run `dotrequirements cts dispatch-context <dispatch-id>` (the exact invocation is given in your prompt), read the `"prompt"` field of the JSON it prints, and follow those instructions exactly.
+You are a codebase-to-spec worker. The prompt you receive tells you which CLI dispatch to fetch: it will instruct you to run `{{DOTREQ_CLI}} cts dispatch-context <dispatch-id>` (the exact invocation is given in your prompt), read the `"prompt"` field of the JSON it prints, and follow those instructions exactly.
 
 Those fetched instructions are your real task — which files to read, what to write and where, and how to validate and style-check your output via Bash. Follow them exactly and do not improvise beyond what they ask. When your prompt also asks you to return a structured result, return exactly that shape.

package/dist/templates/skills/codebase-to-spec/SKILL.md

@@ -19,7 +19,7 @@ Do **not** use for new-feature design (use the `dotreq-requirements` skill), bug
 
 This skill runs its pipeline as a dynamic Workflow. If the `Workflow` tool is not available in this environment, **stop** and tell the user:
 
-> "codebase-to-spec runs as a dynamic workflow, which this Claude Code version/configuration doesn't support. For CI or headless use, run `dotrequirements cts run --scope <path>` instead."
+> "codebase-to-spec runs as a dynamic workflow, which this Claude Code version/configuration doesn't support. For CI or headless use, run `{{DOTREQ_CLI}} cts run --scope <path>` instead."
 
 Do not attempt a non-workflow fallback.
 
@@ -35,7 +35,14 @@ For large codebases, encourage scoping to a single area — the pack has a conte
 
 ### 2. Pack (deterministic)
 
-Run `dotrequirements cts pack --scope <PATH>` via Bash. Deterministic, no LLM. It emits `[CTS] pack/done` then `pack/budget-ok`, or exits **10 (BudgetExceeded)** if the compressed pack is too large. On BudgetExceeded, surface the limit and offer a narrower scope (back to step 1).
+Run `{{DOTREQ_CLI}} cts pack --scope <PATH>` via Bash. Deterministic, no LLM. It emits `[CTS] pack/done` then `pack/budget-ok`, or exits **10 (BudgetExceeded)** if the compressed pack is too large. On BudgetExceeded, surface the limit and offer a narrower scope (back to step 1).
+
+**Stale install gate.** If pack also emits a `pack/stale-version` line, this install of codebase-to-spec is out of date. Before launching the workflow, tell the user (naming both versions from the line) and offer to refresh:
+
+- **Refresh:** run `npx -y @popoverai/dotrequirements@<latest> cts skill-install` via Bash, substituting the `latest` version from the stale-version line. If it refuses because a file was hand-edited, surface that and let the user decide (`--overwrite` only on their say-so). Then re-run pack with that same refreshed invocation and continue from its output — the refreshed skill bundle and CLI now run as one matching version.
+- **Decline:** continue with the installed version unchanged.
+
+If pack emits no stale-version line, say nothing about versions.
 
 ### 3. Run the workflow
 
@@ -45,7 +52,7 @@ Launch the bundled workflow:
 Workflow({ name: "specify-codebase" })
 ```
 
-You normally pass no `args` — `cli` defaults to `dotrequirements` on PATH, and the iteration caps default to `roundsCap: 5` / `outlineRoundsCap: 4`. Override only if needed, passing `args` as a real object (not a JSON string). *(Only in the dotrequirements dev repo, pass `args: { cli: "node <repo>/packages/cli/dist/cli.js" }`.)*
+You normally pass no `args` — `cli` defaults to the same CLI invocation this skill uses, and the iteration caps default to `roundsCap: 5` / `outlineRoundsCap: 4`. Override only if needed, passing `args` as a real object (not a JSON string). *(Only in the dotrequirements dev repo, pass `args: { cli: "node <repo>/packages/cli/dist/cli.js" }`.)*
 
 The workflow plans the outline (planner + an independent reviewer, looping to convergence), enumerates the areas, fans out one specifier per area, converges each area (specify → review → edit), then composes the partials into one spec and runs a document-level cross-area review/edit pass (dedup, terminology, seam gaps). It runs in the background — watch progress in `/workflows`. Do not narrate every step; only surface the gates below.
 
@@ -59,18 +66,33 @@ The workflow returns one of:
 ### 5. Present (deterministic)
 
 On `status: "done"`, the workflow has already composed the spec and run the cross-area pass. Write the final file(s):
-- `dotrequirements cts present-orchestrator` — writes the composed spec to file(s) under `.requirements/`.
+- `{{DOTREQ_CLI}} cts present-orchestrator` — writes the composed spec to file(s) under `.requirements/`.
 
 `present-orchestrator` errors on existing-file conflicts unless given `--overwrite` or `--skip-existing`. When a conflict is reported, ask the user which they want, then re-run with that flag.
 
 When `cross_area_converged` is `false`, the cross-area pass hit `crossAreaRoundsCap` without a clean approval — present the spec, but surface that in the summary so the user gives the composed spec an extra look.
 
-### 6. Summarize and offer follow-ups
+### 6. Orient and consult
+
+The spec is written; this step is about what the user does with it. End the run as a consultation, not a menu.
+
+**Summarize.** How many areas and requirements, the file path(s) written, and — importantly — any `unconverged` areas (they hit the round cap; surface the reviewer's outstanding findings for those areas so the user can verify them) and any `failed` areas (no draft was produced; they are absent from the spec).
+
+**Orient.** Briefly say what this spec is designed for — it's not a one-off artifact. It lives alongside the code (PR it into the repo), drives AI-first development (an assistant working from the spec via MCP), is inherently testable (the test harness binds tests to requirements), and is meant to be reviewed and refined with the team (the web platform).
+
+**Lead with one offer, phrased as its outcome.** Pick the one that fits this user's context — e.g. they mentioned a PM who needs to see this, or they're about to refactor and want tests, or they asked for the spec to guide an assistant. Mention the other outcomes in passing, not as a list of options. Any of the four can be taken up regardless of which one led. Mechanical steps (logging in, syncing, configuration) are never themselves the offer — they run only in service of an outcome the user accepted. Each offer must describe what accepting will do **before** the user accepts; acceptance then authorizes those described steps without re-confirming each one. Anything beyond what was described still requires confirmation.
+
+**Team review (one yes puts the spec in front of their team).** The offer describes what accepting will do: connect this project to dotrequirements cloud (a browser login is the only action left to them), sync the spec, and land on its web location where their team reviews it. On acceptance:
+
+1. If no cloud credentials exist, run `{{DOTREQ_CLI}} link --yes --json` via Bash. The user completes login in the browser; everything else is yours.
+2. If link exits with code 2, its JSON is a `decision_needed` — multiple teams, existing projects, or a plan at its project limit. Relay the options conversationally (they are the user's choice, not yours), then retry link with the chosen option's `retryFlag` appended.
+3. Once linked, run `{{DOTREQ_CLI}} push --yes`. Present each document's web URL from the output as the place the user's team reviews it.
+4. Hand over the share mechanics from link's JSON, matched to the teammate's surface: the `inviteUrl` for a teammate who will review in the web platform, and the `sharePullCommand` for a teammate working in their IDE. If link omitted one (e.g. the user isn't a team admin), hand over what's there without apology.
+5. With the spec in the cloud, offer to set up the assistant you are running as to work from the spec going forward — framed as that outcome ("I can work from this spec in future sessions"), not as configuration. On acceptance, run `{{DOTREQ_CLI}} ai-setup --assistant <id>` with the identifier for this assistant (e.g. `claude-code`).
+
+If the user declines the team-review offer, note that it stands for later and don't repeat the pitch.
 
-Present a readable summary: how many areas and requirements, the file path(s) written, and — importantly — any `unconverged` areas (they hit the round cap; their latest draft was kept and is worth a look) and any `failed` areas (no draft was produced; they are absent from the spec). Then offer, **without auto-running any of them**:
-- **Push to cloud** — `dotrequirements push` (only if cloud is configured; it's a destructive sync).
-- **Refine an area** — re-run on a narrower scope.
-- **Re-run on a different scope.**
+**Always available:** refining a specific area (re-run on a narrower scope) and re-running on a different scope.
 
 ## What you must NOT do
 
@@ -78,8 +100,8 @@ Present a readable summary: how many areas and requirements, the file path(s) wr
 - Don't dispatch workers via the Task tool — the workflow owns all agent work.
 - Don't claim convergence when `unconverged` or `failed` is non-empty — surface those areas honestly.
 - Don't present when `status` is `outline-unconverged` or `enumerate-failed`.
-- Don't push to cloud without asking.
+- Don't run connect/sync/setup steps the user hasn't accepted an outcome for. Once they accept an offer, the steps it described are authorized — don't re-confirm each one, and don't go beyond them.
 
 ## Host portability
 
-This skill requires Claude Code with dynamic-workflow support (it launches the `specify-codebase` workflow). On hosts without it, or for CI/headless use, the legacy `dotrequirements cts run` CLI runs the same pipeline non-interactively.
+This skill requires Claude Code with dynamic-workflow support (it launches the `specify-codebase` workflow). On hosts without it, or for CI/headless use, the legacy `{{DOTREQ_CLI}} cts run` CLI runs the same pipeline non-interactively.

package/dist/templates/workflows/specify-codebase.js

@@ -27,10 +27,12 @@ export const meta = {
 //
 // args may arrive as a JSON string depending on how the caller passes it; normalize.
 const input = typeof args === 'string' ? JSON.parse(args) : args || {}
-// `cli` defaults to the PATH binary for installed users; the dev repo passes a
+// `cli` defaults to the invocation stamped at install time (a version-pinned
+// `npx` form for installed users, so no PATH binary is needed and every
+// shell-out in a run resolves the same version); the dev repo passes a
 // `node <repo>/dist/cli.js` invocation explicitly.
 const {
-  cli = 'dotrequirements',
+  cli = '{{DOTREQ_CLI}}',
   roundsCap = 5,
   outlineRoundsCap = 4,
   crossAreaRoundsCap = 5,

package/dist/utils/own-package.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read this package's own package.json (name + version). Works from both
+ * src/ (vitest) and dist/ (compiled) since the two trees sit at the same
+ * depth under packages/cli.
+ */
+export declare function getOwnPackage(): {
+    name: string;
+    version: string;
+};
+//# sourceMappingURL=own-package.d.ts.map

package/dist/utils/own-package.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Read this package's own package.json (name + version). Works from both
+ * src/ (vitest) and dist/ (compiled) since the two trees sit at the same
+ * depth under packages/cli.
+ */
+export function getOwnPackage() {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync(pkgPath, "utf-8"));
+}
+//# sourceMappingURL=own-package.js.map

package/dist/utils/project-selector.d.ts

@@ -7,6 +7,11 @@ export interface SelectedProject {
 export interface SelectedTeam {
     teamId: string;
     tier: string;
+    /** Display name; present when selected via the shared selectTeam */
+    name?: string;
+    tierName?: string;
+    projectCount?: number;
+    projectLimit?: number;
 }
 /**
  * Prompt user to select a team from their available teams.

package/dist/utils/project-selector.js

@@ -31,6 +31,10 @@ export async function selectTeam(client) {
     return {
         teamId: selectedTeamId,
         tier: selectedTeam?.tier ?? "free",
+        name: selectedTeam?.name,
+        tierName: selectedTeam?.tierName,
+        projectCount: selectedTeam?.projectCount,
+        projectLimit: selectedTeam?.projectLimit,
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popoverai/dotrequirements",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Requirements tracking CLI, test harness, and MCP server",
   "type": "module",
   "bin": {
@@ -44,7 +44,7 @@
     "email": "support@dotrequirements.io"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
     "@babel/parser": "^7.28.5",