felenova-backlog 0.1.0

package/dist/plugin/commands/report.md

@@ -0,0 +1,26 @@
+---
+description: Record an Evaluate-Loop transition for a track in the register.
+argument-hint: "<slug> <PLAN|EVALUATE_PLAN|EXECUTE|EVALUATE_EXECUTION|COMPLETE> <IN_PROGRESS|PASS|FAIL|COMPLETE> [--note <text>]"
+allowed-tools: Bash(backlog report:*)
+---
+
+# /backlog:report
+
+**Role required: Engineer, Product or Owner.** QA and Viewer are refused (PRODUCT-SPEC §3.1,
+"Report track progress").
+
+Run exactly this, from the repo root, and show the output:
+
+```bash
+backlog report $ARGUMENTS
+```
+
+It calls `report_progress` and mirrors the conductor's `loop_state`. The first `EXECUTE`
+report flips the track's promoted items to `in-progress`. Report the transition that actually
+happened — never a step ahead of the work.
+
+## Refusals
+
+`invalid_transition` (that step/status is not legal from where the track is now — read
+`backlog status` first), `forbidden` (role is short), `not_found` (no such track, or no role
+on the project), `invalid_request` (an unknown step or status name), `conflict`, `unreachable`.

package/dist/plugin/commands/ship.md

@@ -0,0 +1,30 @@
+---
+description: Close a track — write the shipped commit and production date back to the register, subject to the QA matrix gate.
+argument-hint: "<slug> --auto | --commit <sha> --date <YYYY-MM-DD>"
+allowed-tools: Bash(backlog ship:*)
+---
+
+# /backlog:ship
+
+**Role required: Product or Owner only.** Engineers and QA are refused by the service
+(PRODUCT-SPEC §3.1, "Ship"). If that is the caller, report the matrix state and hand the ship
+to a Product role rather than retrying.
+
+**A human must approve the ship first** (feature-kickoff's second checkpoint). Do not run this
+to "finish the task".
+
+Run exactly this, from the repo root, and show the output:
+
+```bash
+backlog ship $ARGUMENTS
+```
+
+It calls `ship_track`, surfaces the QA matrix gate result (strict or permissive per track) and
+appends the track to `conductor/index.md` Recent Completions.
+
+## Refusals
+
+`forbidden` (Engineer or QA cannot ship — name the role and stop), `conflict` (the matrix gate
+is unmet under strict enforcement, or the track is not complete — print the coverage summary),
+`invalid_request` (neither `--auto` nor both `--commit` and `--date`), `not_found` (no such
+track, or no role on the project), `superseded`, `unreachable`.

package/dist/plugin/skills/backlog-management/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: backlog-management
+description: Change the product register — file a new item as a draft, co-author a draft's spec fields, review criteria with a critique, comment on an item, or suggest a change to criteria that are already locked. Use when someone says "file an item for X", "add this to the backlog", "write acceptance criteria for TMN-004", "review these criteria", "leave a note on ACC-012", or "the criteria for X are wrong". Writes through MCP tools only; it never edits docs/backlog/.
+---
+
+# backlog-management — writing to the register
+
+Every write goes through the `backlog` MCP server. `docs/backlog/**` is an export: editing it
+changes nothing and will be overwritten by the next `backlog export`.
+
+## Role required
+
+Read the row before you call the tool (PRODUCT-SPEC §3.1):
+
+| What you want to do | Tool | Role required |
+|---|---|---|
+| file an item (always lands as `draft`) | `create_item` | **Engineer or QA and above** |
+| edit spec fields of a `draft` | `update_item` | **Engineer or QA and above** |
+| edit spec fields of a `reviewed` item | `update_item` | **Product or Owner** |
+| `draft → reviewed` (needs a non-empty critique) | `review_criteria` | **Engineer or QA and above** |
+| `reviewed → locked` (needs ≥1 criterion) | `lock_criteria` | **Product or Owner** |
+| unlock (`locked → reviewed`, reason required) | `unlock_criteria` | **Product or Owner** |
+| schedule / deschedule, set priority | `schedule_item`, `deschedule_item`, `set_priority` | **Product or Owner** |
+| reject (reason required) | `reject_item` | **Product or Owner** |
+| suggest a change on a **locked** item | `suggest_change` | **Engineer or QA and above** |
+| accept / decline a suggestion (note required) | `resolve_suggestion` | **Product or Owner** |
+| comment on any item | `add_comment` | **Engineer or QA and above** |
+| open a follow-up from a track | `add_follow_up` | **Engineer or QA and above** |
+
+Viewers cannot write anything. If the caller's role is short, **say which role is needed and
+stop** — do not try a different tool to get around it.
+
+## What the caller may not do
+
+- **Locked means immutable.** Never call `update_item` on a locked item, and never edit the
+  copy of the criteria in `conductor/tracks/<slug>/spec.md`. File a `suggest_change` against
+  the item and let a Product role resolve it; `backlog sync <slug>` re-renders `spec.md` when
+  the register says the criteria moved.
+- Never lock your own draft to unblock yourself if you are an Engineer or QA. That is the
+  review gate, not a formality.
+- Never invent a criterion the human did not ask for, and never reword one that is already
+  `reviewed` to make it pass.
+- Never write a status, a ship date or a commit SHA here — that is **feature-kickoff**.
+- Never put a token, a PAT, or any credential into an item, a comment, or a suggestion.
+
+## Refusals you can hit, and what each means
+
+| Code | What it means here |
+|---|---|
+| `forbidden` | the caller's role does not allow this write — name the role the table above requires and stop |
+| `locked` | the criteria are locked; use `suggest_change` instead of an edit |
+| `not_locked` | the item is not locked yet, and this call needs it to be |
+| `invalid_transition` | the state machine refused the move — re-read the item's current status first |
+| `reason_required` | unlock, reject and decline all need a written reason; ask the human for one |
+| `superseded` | a newer revision exists — re-read the item and file it again against the current version |
+| `conflict` | a precondition failed (e.g. a review with an empty critique) — read the item and act on what it says now |
+| `invalid_request` | the arguments are malformed; check the tool's argument names |
+| `read_only_token` | the PAT is read-only and this writes — a writable PAT must be minted in the web UI (`/me`) |
+| `not_found` | no such ref, or no role on that project |
+| `unreachable` | the service is down — nothing was written; say so and try again later |
+
+Every refusal is one sentence from the service. Repeat it to the human rather than retrying
+the same call.

package/dist/plugin/skills/backlog-query/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: backlog-query
+description: Read the product register for this repo — what is in the backlog, what is ready to work on, what one item actually says. Use whenever someone asks "what's in the backlog", "what should I work on", "what's the status of TMN-004", "is ACC-012 locked yet", "which tracks are open", "what's blocked", or names a backlog ID and wants to know about it rather than change it. Read-only: it never writes to the register and never edits docs/backlog/.
+---
+
+# backlog-query — the read-only front door
+
+The product register (what / why / on what conditions) lives in the backlog service, not in
+this repo. `docs/backlog/` is at most an exported snapshot: **never read it as the truth and
+never edit it.** Ask the register.
+
+## Role required
+
+**Viewer or above** on the project — every role can read (PRODUCT-SPEC §3.1, first row).
+Nothing in this skill can be refused for being too small a role except by a token that has
+no membership at all.
+
+## How to ask
+
+Prefer the MCP tools on the `backlog` server, which `backlog init` wrote into `.mcp.json`:
+
+| Question | Tool | Args |
+|---|---|---|
+| what is in the backlog | `list_items` | `project`, and any of `status`, `criteria_status`, `priority`, `domain`, `q` |
+| what should I work on | `next_ready` | `project` — locked, unblocked, unpromoted, ranked by priority |
+| what does TMN-004 say | `get_item` | `ref` — `TMN-004` or `tammeni/TMN-004` |
+| which tracks are open | `list_tracks` | `project`, `active_only?` |
+| what is track X doing | `get_track` | `track` |
+| what decisions are owed | `list_decisions` | `project` |
+| what changed lately | `get_activity` | `project`, `since?` |
+
+The project slug is in `backlog.config.json` at the repo root. If the MCP server is not
+connected, the same three answers are available from the CLI — `backlog status`,
+`backlog next`, `backlog doctor` — and `backlog status` falls back to the last cached
+result when the service is unreachable.
+
+## What you may not do here
+
+- No writes. Filing, editing, reviewing, locking, commenting and suggesting belong to
+  **backlog-management**; promotion and ship belong to **feature-kickoff**.
+- No editing `docs/backlog/**` to "fix" something you read. That directory is an export.
+- No inventing an item's criteria from memory. If `get_item` did not say it, it is not in
+  the contract.
+
+## Refusals you can hit, and what each means
+
+| Code | What it means here |
+|---|---|
+| `no_session` | no credential reached the service — the PAT comes from `$BACKLOG_TOKEN` or `~/.config/backlog/token`; run `backlog doctor` |
+| `token_unknown` / `token_revoked` / `token_expired` | the PAT is no longer good — mint a new one in the web UI (`/me`) and re-run `backlog init` |
+| `no_member` | the service has no org membership for this caller |
+| `not_found` | the ref does not exist **or** the caller has no role on that project — a project's existence is privileged, so the two look the same on purpose |
+| `rate_limited` | 120 requests per minute per token; wait and retry |
+| `unreachable` | the service is down — say so, and use `backlog status` for the cached view |
+
+Never paste a token value into a file, a command line, a commit or an answer. The register's
+credential is referenced as `${BACKLOG_TOKEN}` and nowhere else.

package/dist/plugin/skills/feature-kickoff/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: feature-kickoff
+description: Run a feature end to end against the register and the conductor — promote locked items into a track, write the plan, scaffold the QA matrix, report each Evaluate-Loop transition, and ship. Use when someone says "let's work on TMN-004", "start a track for ACC-012 and ACC-013", "kick off the next feature", "what's next — let's do it", "report the plan passed", or "ship the verification track". Keeps both human checkpoints.
+---
+
+# feature-kickoff — promotion to ship
+
+The register owns *what* and *why*; `conductor/` owns *how* and *now*. The only coupling is
+the tool surface below. **"let's work on TMN-004" starts here.**
+
+## Role required
+
+Each step has its own row in PRODUCT-SPEC §3.1, and they are not the same:
+
+| Step | Role required |
+|---|---|
+| read what is ready (`backlog next`) | **Viewer or above** |
+| promote (`backlog promote`) | **Engineer, Product or Owner** — QA and Viewer refused |
+| matrix init (`backlog matrix init`) | **QA, Engineer, Product or Owner** |
+| report progress (`backlog report`) | **Engineer, Product or Owner** |
+| ship (`backlog ship`) | **Product or Owner only** |
+
+If the caller's role is short for a step, say which role that step needs and stop there.
+
+## The loop
+
+```
+next  →  PROMOTE  →  plan  →  [HUMAN CHECKPOINT 1]  →  matrix init  →  EXECUTE
+          ↑                                                              │
+          └──────────────── report each transition ──────────────────────┘
+                                                                          ↓
+                                          [HUMAN CHECKPOINT 2]  →  SHIP
+```
+
+### 1. Find the work — role: **Viewer+**
+
+`backlog next` (or `next_ready`) lists locked, unblocked, unpromoted items ranked by
+priority. Nothing may be promoted until its criteria are **locked** in the register.
+
+### 2. Promote — role: **Engineer, Product or Owner**
+
+```
+backlog promote <ID…> [--slug <slug>] [--type feature|fix|chore]
+```
+Calls `promote_items`, then writes `conductor/tracks/<slug>/{spec.md,plan.md,metadata.json}`
+from the payload the service returned and updates `conductor/tracks.md`. `spec.md` is
+**generated** — hand-edit `plan.md`, never `spec.md`.
+
+### 3. Plan — no register call
+
+Write the plan with `superpowers:writing-plans` into
+`docs/superpowers/plans/<date>-<track>.md`. `plan.md` in the track points at it.
+
+### 4. **Human Checkpoint 1 — the human approves the plan.** Stop and ask.
+
+Do not promote further, scaffold the matrix, or write code before a human has said yes to the
+plan. This checkpoint is not yours to skip, delegate or infer from silence.
+
+### 5. Matrix init — role: **QA, Engineer, Product or Owner**
+
+Immediately after the plan is approved:
+```
+backlog matrix init <slug>
+```
+Calls `matrix_init`: one `☐` row per criterion of every promoted item, IDs `{ID}-AC{n}.M1`.
+It refuses if a matrix already exists.
+
+### 6. Execute and report — role: **Engineer, Product or Owner**
+
+At every Evaluate-Loop transition:
+```
+backlog report <slug> <PLAN|EVALUATE_PLAN|EXECUTE|EVALUATE_EXECUTION|COMPLETE> <IN_PROGRESS|PASS|FAIL|COMPLETE> [--note …]
+```
+Calls `report_progress`; the first `EXECUTE` flips the promoted items to `in-progress`. If the
+criteria moved under you (`spec_drift`), run `backlog sync <slug>` — it re-renders `spec.md`
+and marks superseded matrix rows `⏭️`. Never patch `spec.md` by hand to make it agree.
+
+### 7. **Human Checkpoint 2 — the human approves the ship.** Stop and ask.
+
+Ship writes a commit SHA and a production date into the register. Never ship on your own
+judgement, and never to "finish the task".
+
+### 8. Ship — role: **Product or Owner only**
+
+```
+backlog ship <slug> --auto | --commit <sha> --date <YYYY-MM-DD>
+```
+Calls `ship_track`. The QA matrix gate applies (strict or permissive per track). **Engineers
+and QA are refused here** — if that is the caller, report the matrix state and hand the ship
+to a Product role.
+
+## What you may not do
+
+- Promote an item whose criteria are not locked; ask for a lock instead.
+- Edit `docs/backlog/**` or a track's `spec.md`.
+- Change a criterion to match what was built — `suggest_change` (see **backlog-management**).
+- Skip either human checkpoint.
+- Put a token value into `.mcp.json`, a track file, a commit or a comment. The PAT lives in
+  `$BACKLOG_TOKEN` or `~/.config/backlog/token`; `.mcp.json` references `${BACKLOG_TOKEN}`.
+
+## Refusals you can hit, and what each means
+
+| Code | What it means here |
+|---|---|
+| `not_locked` | an item in the promote list is not locked — stop and ask a Product role to lock it |
+| `forbidden` | the role is short for this step (promote needs Engineer+, ship needs Product+) — name the role and stop |
+| `conflict` | a precondition failed: a matrix already exists, the ship gate is unmet, or the track is not in that step — read `backlog status` and say what it says |
+| `invalid_transition` | that loop step/status move is not legal from where the track is now |
+| `superseded` | the criteria version moved — run `backlog sync <slug>` and re-read `spec.md` |
+| `not_found` | no such track or ref, or no role on the project |
+| `invalid_request` | bad arguments — e.g. a ship without both a commit and a date |
+| `unreachable` | the service is down. Execution is local and continues; promotion, matrix edits and ship wait |

package/dist/snapshot.d.ts

@@ -0,0 +1,24 @@
+import type { Item, ItemSource, MatrixDoc, MatrixRow, Track } from './_core/index.js';
+export interface ProjectSnapshot {
+    version: 1;
+    project: string;
+    root: string;
+    items: Array<{
+        item: Item;
+        source: ItemSource;
+    }>;
+    tracks: Array<{
+        track: Track;
+        metadataPath: string;
+        raw: string;
+    }>;
+    matrices: Array<{
+        doc: MatrixDoc;
+        rows: MatrixRow[];
+    }>;
+    docs: Record<'README.md' | 'decisions-owed.md' | '_schema.md', {
+        path: string;
+        raw: string;
+    } | null>;
+    warnings: string[];
+}

package/dist/snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot.js.map

package/dist/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../src/snapshot.ts"],"names":[],"mappings":""}

package/dist/token.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A refusal about the token *store* — never about the token value. Nothing in this module
+ * puts a token in a message, a log line or an error: the value only ever moves between the
+ * file and the caller.
+ */
+export declare class TokenError extends Error {
+    constructor(message: string);
+}
+/** `~/.config/backlog/token` — the one place a PAT lives on disk (PRODUCT-SPEC §6.4). */
+export declare function tokenPath(home: string): string;
+/**
+ * Reads `~/.config/backlog/token`, trimmed. Null when the file is absent or empty.
+ * On a POSIX platform a file any other user could read is refused outright rather than
+ * used — a leaked PAT is worse than a failed command.
+ */
+export declare function readToken(home: string): string | null;
+/**
+ * `$BACKLOG_TOKEN` wins (CI, a one-off shell), else the file. Null when neither has one —
+ * the caller turns that into `token_required`, which `errors.ts` renders.
+ */
+export declare function resolveToken(env: NodeJS.ProcessEnv, home: string): string | null;
+/**
+ * Writes the PAT with mode 0600 into a 0700 directory, and `chmod`s both explicitly because
+ * a permissive umask widens the create mode. Refuses a home that is inside a git work tree:
+ * a token must never land somewhere `git add -A` can pick it up.
+ */
+export declare function saveToken(home: string, plaintext: string): string;
+/** The plan's argument order (`writeToken(value, home)`); same behaviour as `saveToken`. */
+export declare function writeToken(value: string, home: string): string;

package/dist/token.js

@@ -0,0 +1,99 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/**
+ * A refusal about the token *store* — never about the token value. Nothing in this module
+ * puts a token in a message, a log line or an error: the value only ever moves between the
+ * file and the caller.
+ */
+export class TokenError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TokenError';
+    }
+}
+const POSIX = process.platform !== 'win32';
+/** `~/.config/backlog/token` — the one place a PAT lives on disk (PRODUCT-SPEC §6.4). */
+export function tokenPath(home) {
+    return join(home, '.config', 'backlog', 'token');
+}
+function tokenDir(home) {
+    return join(home, '.config', 'backlog');
+}
+/**
+ * Reads `~/.config/backlog/token`, trimmed. Null when the file is absent or empty.
+ * On a POSIX platform a file any other user could read is refused outright rather than
+ * used — a leaked PAT is worse than a failed command.
+ */
+export function readToken(home) {
+    const path = tokenPath(home);
+    let stat;
+    try {
+        stat = statSync(path);
+    }
+    catch {
+        return null;
+    }
+    if (POSIX) {
+        const mode = stat.mode & 0o777;
+        if ((mode & 0o077) !== 0) {
+            throw new TokenError(`${path} is mode ${mode.toString(8)} — group- or world-readable; run: chmod 600 ${path}`);
+        }
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        throw new TokenError(`cannot read ${path}`);
+    }
+    const value = raw.trim();
+    return value === '' ? null : value;
+}
+/**
+ * `$BACKLOG_TOKEN` wins (CI, a one-off shell), else the file. Null when neither has one —
+ * the caller turns that into `token_required`, which `errors.ts` renders.
+ */
+export function resolveToken(env, home) {
+    const fromEnv = env.BACKLOG_TOKEN?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return readToken(home);
+}
+function insideGitWorkTree(dir) {
+    let current = resolve(dir);
+    for (;;) {
+        if (existsSync(join(current, '.git')))
+            return true;
+        const parent = dirname(current);
+        if (parent === current)
+            return false;
+        current = parent;
+    }
+}
+/**
+ * Writes the PAT with mode 0600 into a 0700 directory, and `chmod`s both explicitly because
+ * a permissive umask widens the create mode. Refuses a home that is inside a git work tree:
+ * a token must never land somewhere `git add -A` can pick it up.
+ */
+export function saveToken(home, plaintext) {
+    const value = plaintext.trim();
+    if (value === '')
+        throw new TokenError('refusing to write an empty token');
+    const dir = tokenDir(home);
+    if (insideGitWorkTree(home)) {
+        throw new TokenError(`${home} is inside a git work tree — refusing to write a token there; a PAT belongs outside any repository`);
+    }
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const path = tokenPath(home);
+    writeFileSync(path, `${value}\n`, { mode: 0o600 });
+    if (POSIX) {
+        chmodSync(dir, 0o700);
+        chmodSync(path, 0o600);
+    }
+    return path;
+}
+/** The plan's argument order (`writeToken(value, home)`); same behaviour as `saveToken`. */
+export function writeToken(value, home) {
+    return saveToken(home, value);
+}
+//# sourceMappingURL=token.js.map

package/dist/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAClG,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC;AAE3C,yFAAyF;AACzF,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC;AAED,SAAS,QAAQ,CAAC,IAAY;IAC5B,OAAO,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,IAAiC,CAAC;IACtC,IAAI,CAAC;QACH,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,UAAU,CAClB,GAAG,IAAI,YAAY,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,+CAA+C,IAAI,EAAE,CACzF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,UAAU,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;IAC9C,CAAC;IACD,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IACzB,OAAO,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,GAAsB,EAAE,IAAY;IAC/D,MAAM,OAAO,GAAG,GAAG,CAAC,aAAa,EAAE,IAAI,EAAE,CAAC;IAC1C,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,SAAS,iBAAiB,CAAC,GAAW;IACpC,IAAI,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,SAAS,CAAC;QACR,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QACnD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,OAAO;YAAE,OAAO,KAAK,CAAC;QACrC,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,SAAiB;IACvD,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,KAAK,KAAK,EAAE;QAAE,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAE3E,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC3B,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,UAAU,CAClB,GAAG,IAAI,oGAAoG,CAC5G,CAAC;IACJ,CAAC;IAED,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7B,aAAa,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACnD,IAAI,KAAK,EAAE,CAAC;QACV,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtB,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,IAAY;IACpD,OAAO,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAChC,CAAC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "felenova-backlog",
+  "version": "0.1.0",
+  "description": "Felenova's backlog CLI: the repo-side bridge to the hosted product register, plus the backlog-execution plugin for Claude Code.",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/felenova/backlog.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/felenova/backlog#readme",
+  "keywords": [
+    "backlog",
+    "conductor",
+    "mcp",
+    "claude-code",
+    "felenova"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "bin": {
+    "backlog": "./bin/backlog.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/vendor-core.mjs && node scripts/copy-plugin-payload.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm run test"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "yaml": "^2.9.0",
+    "zod": "^4.6.2"
+  },
+  "devDependencies": {
+    "@felenova/backlog-core": "workspace:*",
+    "@types/node": "^22.20.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11"
+  }
+}