@productbrain/cli 0.1.0-beta.9 → 0.1.0-beta.9000

package/dist/lib/startup-signals.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-signals.test.js","sourceRoot":"","sources":["../../src/lib/startup-signals.test.ts"],"names":[],"mappings":"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"}

package/dist/lib/state.d.ts

@@ -0,0 +1,60 @@
+/**
+ * CLI setup state resolution — determines where the user is in the setup journey
+ * and what render tier to use for output.
+ *
+ * WP-325 S1: Foundation utilities consumed by S2 (index.ts) and S3 (connect.ts).
+ * No callers wired in this slice — this is the shared substrate.
+ *
+ * Stage model:
+ *   unconfigured     → no API key found anywhere
+ *   authenticated    → API key present, but workspace unreachable (offline or not yet connected)
+ *   workspace-bound  → key + workspace reachable, but no active session
+ *   active           → key + workspace + active session
+ */
+import { type ConfigFailureKind } from './config.js';
+/** Four-stage setup journey from cold start to active use. */
+export type SetupStage = 'unconfigured' | 'authenticated' | 'workspace-bound' | 'active';
+export interface SetupState {
+    stage: SetupStage;
+    /** Human-readable list of what is still missing. Empty when stage === 'active'. */
+    missingSteps: string[];
+    /** Single most important next command to run. */
+    nextAction: string;
+    /** Workspace name — populated when workspace probe succeeds. */
+    workspaceName?: string;
+    /** Total entry count from the workspace — populated when workspace probe succeeds. */
+    entryCount?: number;
+    /** Whether a write session is currently active. */
+    sessionActive?: boolean;
+    /** Exact local-binding failure, when this is more specific than ordinary first-time setup. */
+    configurationIssue?: {
+        kind: ConfigFailureKind;
+        reason: string;
+        guidance: string;
+    };
+}
+/** Output render tier for the current runtime context. */
+export type RenderTier = 'json' | 'plain' | 'ink';
+/**
+ * Determine the user's current setup stage and surface what's missing.
+ *
+ * Resolution order mirrors the config cascade (getConfigSafe → probeWorkspace → readSession).
+ * Each step is attempted only if the previous one succeeded, matching how the system
+ * actually behaves when a command runs.
+ *
+ * Network calls: probeWorkspace() makes one lightweight orient call. If the caller is in a
+ * context where network is unavailable, this returns 'authenticated' rather than throwing.
+ */
+export declare function resolveSetupState(): Promise<SetupState>;
+/**
+ * Determine the appropriate output rendering tier for the current process context.
+ *
+ * Priority:
+ *   json  → isJsonMode() is true (explicit --json flag or PB_JSON=1 env var — piping alone does
+ *           NOT switch modes, WP-744 / 1e-B; formerly `!process.stdout.isTTY` alone)
+ *   plain → stdout is not a TTY (but isJsonMode() was false — e.g. piped output with no --json/
+ *           PB_JSON=1, or --pretty on a pipe)
+ *   ink   → interactive TTY, Ink React rendering is safe
+ */
+export declare function detectRenderTier(): RenderTier;
+//# sourceMappingURL=state.d.ts.map

package/dist/lib/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/lib/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AASpE,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,eAAe,GAAG,iBAAiB,GAAG,QAAQ,CAAC;AAEzF,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,mFAAmF;IACnF,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8FAA8F;IAC9F,kBAAkB,CAAC,EAAE;QACnB,IAAI,EAAE,iBAAiB,CAAC;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAMlD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CAgD7D;AAMD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAI7C"}

package/dist/lib/state.js

@@ -0,0 +1,97 @@
+/**
+ * CLI setup state resolution — determines where the user is in the setup journey
+ * and what render tier to use for output.
+ *
+ * WP-325 S1: Foundation utilities consumed by S2 (index.ts) and S3 (connect.ts).
+ * No callers wired in this slice — this is the shared substrate.
+ *
+ * Stage model:
+ *   unconfigured     → no API key found anywhere
+ *   authenticated    → API key present, but workspace unreachable (offline or not yet connected)
+ *   workspace-bound  → key + workspace reachable, but no active session
+ *   active           → key + workspace + active session
+ */
+import { getConfigSafe } from './config.js';
+import { probeWorkspace } from './workspace-probe.js';
+import { readSession } from './session.js';
+import { isJsonMode } from './runner.js';
+// ---------------------------------------------------------------------------
+// resolveSetupState
+// ---------------------------------------------------------------------------
+/**
+ * Determine the user's current setup stage and surface what's missing.
+ *
+ * Resolution order mirrors the config cascade (getConfigSafe → probeWorkspace → readSession).
+ * Each step is attempted only if the previous one succeeded, matching how the system
+ * actually behaves when a command runs.
+ *
+ * Network calls: probeWorkspace() makes one lightweight orient call. If the caller is in a
+ * context where network is unavailable, this returns 'authenticated' rather than throwing.
+ */
+export async function resolveSetupState() {
+    // Step 1 — is an API key configured?
+    const configResult = getConfigSafe();
+    if (!configResult.ok) {
+        return {
+            stage: 'unconfigured',
+            missingSteps: [configResult.reason],
+            nextAction: configResult.nextCommand,
+            configurationIssue: {
+                kind: configResult.kind,
+                reason: configResult.reason,
+                guidance: configResult.guidance,
+            },
+        };
+    }
+    // Step 2 — can we reach the workspace?
+    const wsInfo = await probeWorkspace();
+    if (!wsInfo) {
+        return {
+            stage: 'authenticated',
+            missingSteps: ['Workspace not connected or unreachable'],
+            nextAction: 'pb connect',
+        };
+    }
+    // Step 3 — is there an active write session?
+    const session = readSession();
+    if (!session) {
+        return {
+            stage: 'workspace-bound',
+            missingSteps: ['No active write session'],
+            nextAction: 'pb session start',
+            workspaceName: wsInfo.name,
+            entryCount: wsInfo.entryCount,
+            sessionActive: false,
+        };
+    }
+    // All steps satisfied — fully active
+    return {
+        stage: 'active',
+        missingSteps: [],
+        nextAction: 'pb orient -b',
+        workspaceName: wsInfo.name,
+        entryCount: wsInfo.entryCount,
+        sessionActive: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// detectRenderTier
+// ---------------------------------------------------------------------------
+/**
+ * Determine the appropriate output rendering tier for the current process context.
+ *
+ * Priority:
+ *   json  → isJsonMode() is true (explicit --json flag or PB_JSON=1 env var — piping alone does
+ *           NOT switch modes, WP-744 / 1e-B; formerly `!process.stdout.isTTY` alone)
+ *   plain → stdout is not a TTY (but isJsonMode() was false — e.g. piped output with no --json/
+ *           PB_JSON=1, or --pretty on a pipe)
+ *   ink   → interactive TTY, Ink React rendering is safe
+ */
+export function detectRenderTier() {
+    if (isJsonMode())
+        return 'json';
+    if (!process.stdout.isTTY)
+        return 'plain';
+    return 'ink';
+}
+//# sourceMappingURL=state.js.map

package/dist/lib/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../src/lib/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAA0B,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAgCzC,8EAA8E;AAC9E,oBAAoB;AACpB,8EAA8E;AAE9E;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,qCAAqC;IACrC,MAAM,YAAY,GAAG,aAAa,EAAE,CAAC;IACrC,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;QACrB,OAAO;YACL,KAAK,EAAE,cAAc;YACrB,YAAY,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC;YACnC,UAAU,EAAE,YAAY,CAAC,WAAW;YACpC,kBAAkB,EAAE;gBAClB,IAAI,EAAE,YAAY,CAAC,IAAI;gBACvB,MAAM,EAAE,YAAY,CAAC,MAAM;gBAC3B,QAAQ,EAAE,YAAY,CAAC,QAAQ;aAChC;SACF,CAAC;IACJ,CAAC;IAED,uCAAuC;IACvC,MAAM,MAAM,GAAG,MAAM,cAAc,EAAE,CAAC;IACtC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO;YACL,KAAK,EAAE,eAAe;YACtB,YAAY,EAAE,CAAC,wCAAwC,CAAC;YACxD,UAAU,EAAE,YAAY;SACzB,CAAC;IACJ,CAAC;IAED,6CAA6C;IAC7C,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;IAC9B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;YACL,KAAK,EAAE,iBAAiB;YACxB,YAAY,EAAE,CAAC,yBAAyB,CAAC;YACzC,UAAU,EAAE,kBAAkB;YAC9B,aAAa,EAAE,MAAM,CAAC,IAAI;YAC1B,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,qCAAqC;IACrC,OAAO;QACL,KAAK,EAAE,QAAQ;QACf,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE,cAAc;QAC1B,aAAa,EAAE,MAAM,CAAC,IAAI;QAC1B,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,aAAa,EAAE,IAAI;KACpB,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAE9E;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB;IAC9B,IAAI,UAAU,EAAE;QAAE,OAAO,MAAM,CAAC;IAChC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK;QAAE,OAAO,OAAO,CAAC;IAC1C,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/lib/statusCategories.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Status category axis (T2, TASK-386, WP-779, DEC-1622 kickoff-final §5). Split out of
+ * statusStateMachine.ts (round-2 review) to keep that file under its 500-line module-health
+ * ceiling — a real split, never a comment trim; re-exported from statusStateMachine.ts so every
+ * existing import path (`kernel/entries/statusStateMachine`) keeps resolving unchanged.
+ *
+ * The kernel's four status CATEGORIES — RULE-630 step 1 adds this union beside
+ * statusStateMachine.ts's existing draft/accepted/active/deprecated/archived trust literals,
+ * removing nothing (T9a2 removes `active`/`deprecated` from the schema union only after T9a1's
+ * deploy step has emptied them fleet-wide). A category is NEVER supplied by a caller: it is
+ * looked up from the entry's collection's declared `statusList` (below) by the entry's stored
+ * `workflowStatus` LABEL. T3a (TASK-388, WP-779, DEC-1788) wired the one write door
+ * (`convex/lib/writeEntryStatus.ts`) through `resolveStatusCategory` — a writer whose
+ * destination collection declares a `statusList` now gets `current`/`past`/`discarded` written
+ * into `entries.status` alongside the label; an undeclared collection, or an unmapped label,
+ * still leaves `entries.status` holding one of the 5 legacy trust words. `entries.status` stores
+ * the category once derivable; `entries.workflowStatus` stores the label. No new column.
+ */
+export declare const STATUS_CATEGORIES: readonly ["draft", "current", "past", "discarded"];
+export type StatusCategory = (typeof STATUS_CATEGORIES)[number];
+export declare function isStatusCategory(value: string): value is StatusCategory;
+export declare function isDraftCategory(value: string): boolean;
+export declare function isCurrentCategory(value: string): boolean;
+export declare function isPastCategory(value: string): boolean;
+export declare function isDiscardedCategory(value: string): boolean;
+/**
+ * Round 1 review (P1, PR #652 threads 1 + 2): the write-compat bridge means
+ * 'accepted' and legacy 'active' are the SAME trust level, permanently — not a
+ * transitional state. Every reader that gates on "is this entry live/accepted"
+ * (orientation, authority resolution, question routing, governance-promotion
+ * gates) MUST accept both words, or a migrated/mixed workspace silently loses
+ * — or under-gates — entries depending on which literal they happen to carry.
+ * This is the ONE shared predicate; do not re-hand-roll `=== 'active'`.
+ */
+export declare const TRUST_ACCEPTED_WORDS: readonly ["accepted", "active", "current"];
+export declare function isTrustAccepted(status: string): boolean;
+/**
+ * WP-664 Lane 2 S2 reduction leaf 3 — the mirror predicate on the OTHER trust-word pair: legacy
+ * 'deprecated' is the same trust level as canonical 'archived', permanently (same DEC-1571 fold
+ * as isTrustAccepted's active/accepted pairing above, just on the retired side). Every reader
+ * that means "is this entry retired" (skip a dead reference in an enumeration, exclude from a
+ * subtree/anchor recovery pass) MUST accept both words, or a not-yet-migrated 'deprecated' row
+ * silently survives a filter written only against 'archived'. This is the shared predicate for
+ * that axis — do not re-hand-roll `=== 'archived' || === 'deprecated'` (a pattern already
+ * duplicated across a dozen-plus call sites at the time this helper was added; widening those
+ * onto it is future-leaf work, not this leaf's scope).
+ */
+export declare const TRUST_ARCHIVED_WORDS: readonly ["archived", "deprecated", "past", "discarded"];
+/** One row of a collection's declared, ORDERED status vocabulary — the catalog's `statusList`
+ *  field (`dev-system-collections.json`), synced onto both `system_collection_definitions` and
+ *  per-workspace `collections` rows. `label` is stored in `entries.workflowStatus`; `category`
+ *  is what `entries.status` resolves to for that label.
+ *
+ *  T4b (TASK-389, DEC-1813): `archiveDefault` marks the ONE Past-category label an archive (which
+ *  never knows the specific outcome an entry ended at) writes — see `archiveLabelFor` below.
+ *  Optional on the type so a category with no Past label at all stays representable;
+ *  `validateStatusList` makes it mandatory in practice by refusing a Past label set with anything
+ *  other than exactly one `archiveDefault`. */
+export interface StatusListEntry {
+    label: string;
+    category: StatusCategory;
+    archiveDefault?: boolean;
+    /** TASK-490 (TEN-4160): the ONE Past label `pb entry resolve` writes (tensions: resolved, tasks: done). Optional, and only
+     *  ever on a Past label; a collection with none resolves to its archiveDefault. */
+    resolveDefault?: boolean;
+}
+/**
+ * Validates a collection's declared `statusList` (kickoff-final §5 ruling #2, round-2 review):
+ * the FIRST label is literally "draft" AND category 'draft'; exactly ONE label is category
+ * 'draft'; exactly ONE label is category 'discarded' and that label is itself literally
+ * "discarded"; every OTHER label is category 'current' or 'past'; labels are unique (case-folded
+ * — "Draft" and "draft" collide); no label is empty or whitespace-padded; DEC-1813: among the
+ * Past-category labels (if any), exactly one is marked `archiveDefault: true` — the word an
+ * archive (which never knows the specific outcome) writes. Accepts `unknown` (this is called on
+ * raw catalog JSON before it is known to be shaped) — mirrors `validateAxisContract`
+ * (convex/lib/axisContract.ts)'s defensive-input posture, not just `validateStageLabelMap`'s
+ * already-typed one. Returns every violation found; empty = valid. Pure, never throws.
+ */
+export declare function validateStatusList(statusList: unknown): readonly string[];
+/** Looks up a label's category from a collection's declared statusList. Never throws — an
+ *  unmapped label (statusList absent, or the label isn't declared) resolves to `undefined` so
+ *  the caller (the one write door, `convex/lib/writeEntryStatus.ts`) decides whether that is a
+ *  hard failure — this module stays neutral, same posture as `resolveProgress`
+ *  (statusStateMachine.ts) does for the progress axis. */
+export declare function resolveStatusCategory(label: string, statusList: readonly StatusListEntry[] | undefined): StatusCategory | undefined;
+/** A category's trust-LEVEL equivalent — draft/current/past/discarded, projected onto the
+ *  three-level axis kernel/entries/statusStateMachine.ts's TRUST_TRANSITIONS speaks
+ *  (`'draft' | 'current' | 'archived'`). TASK-587 (WP-779, TEN-4295): the live level is `current`,
+ *  the word every accept door stores, never the retired `accepted`. */
+export type CategoryTrustLevel = 'draft' | 'current' | 'archived';
+export declare const CATEGORY_TRUST_LEVEL: Record<StatusCategory, CategoryTrustLevel>;
+/** T3b (TASK-388, WP-779, DEC-1788): the ONE derivation, shared by every writer that turns a
+ *  `workflowStatus` label into a `status` category — the patch door (`writeEntryStatus.ts`) and
+ *  a future create path both call this instead of each re-implementing the
+ *  `resolveStatusCategory` + trust-level lookup pair. Pure: no `ctx.db`, no guard, no write —
+ *  callers run their OWN guards (creation has its own; writeEntryStatus.ts's guard block is
+ *  unchanged) against the `trustWord` this returns, exactly as they would a caller-supplied
+ *  trust word. `undefined` covers two cases identically (no derivation to report): an undeclared
+ *  statusList, and a declared statusList whose label isn't listed. TASK-389/DEC-1789 governs when
+ *  the second case becomes a hard failure at the write door. */
+export declare function deriveStatusPair(collection: {
+    statusList?: readonly StatusListEntry[];
+} | null | undefined, workflowStatus: string | undefined): {
+    category: StatusCategory;
+    trustWord: CategoryTrustLevel;
+} | undefined;
+/** T3b round-2 review: the ONE reconciliation both writeEntryStatus.ts and _patchEntry run
+ *  against `deriveStatusPair`'s result — never throws (this module stays Convex-free, same
+ *  posture as `validateStatusList`); the caller turns `disagreementError` into its own
+ *  VALIDATION_FAILED. `explicitTrustWord` is the caller's OWN status, already canonicalized to
+ *  a trust word (or `null` for an unrecognized word, or `undefined` when no status was
+ *  supplied at all) — the caller resolves that BEFORE calling, since canonicalWriteTarget lives
+ *  in statusStateMachine.ts, not here (no import cycle: this file is re-exported THROUGH that
+ *  one). `derivedPair` is undefined for both cases `deriveStatusPair` already covers. */
+export declare function reconcileStatusDerivation(explicitTrustWord: CategoryTrustLevel | null | undefined, workflowStatus: string | undefined, collection: {
+    statusList?: readonly StatusListEntry[];
+} | null | undefined): {
+    derivedPair: {
+        category: StatusCategory;
+        trustWord: CategoryTrustLevel;
+    } | undefined;
+    disagreementError: string | undefined;
+};
+/**
+ * DEC-1813/DEC-1814 (T4b, TASK-389, TASK-466): `archiveLabelFor` turns an archive CATEGORY into the
+ * status WORD to write. There is no archive reason: the category is decided by the caller alone
+ * (a draft archives to Discarded, anything else to Past, or a door passes 'discarded' explicitly)
+ * and the word carries only that category. Production callers (`rg -n "archiveLabelFor\(" convex`):
+ * `convex/agentKnowledge/archiveEntry.ts` (the Rail delete door) calls it directly, and
+ * `convex/lib/archiveWorkflowStatus.ts` calls it through `resolveArchiveWorkflowStatusOrThrow`, the one
+ * resolver updateEntry's archive door, the supersede, glossary-merge and deprecate doors and the
+ * hygiene sweep all use. Both land on the identical word for the same category.
+ *
+ * Discarded always writes the literal 'discarded' (every statusList declares it,
+ * `validateStatusList`'s own rule) REGARDLESS of whether a statusList is even declared; Past writes
+ * the collection's one `archiveDefault` Past label, or `undefined` when the collection has no
+ * statusList at all, or (should `validateStatusList` ever have been skipped) no Past label is marked
+ * `archiveDefault` — the caller decides whether that `undefined` is a hard failure, this module
+ * stays neutral, same posture as `resolveStatusCategory`.
+ */
+/** DEC-1813: the ONE label a CATEGORY of archive writes.
+ *  'discarded' always writes the literal 'discarded' (every statusList declares it,
+ *  `validateStatusList`'s own rule); 'past' writes the collection's one `archiveDefault` Past
+ *  label, or `undefined` when none is marked (`validateStatusList` refuses a list without exactly
+ *  one, but an older, pre-validation row can still lack it). */
+export declare function archiveLabelFor(statusList: readonly StatusListEntry[] | undefined, category: Extract<StatusCategory, 'past' | 'discarded'>): string | undefined;
+export declare const ENTRY_STATUS_READ_WORDS: readonly ["draft", "accepted", "active", "current", "archived", "deprecated", "past", "discarded"];
+export declare const ENTRY_STATUS_WRITE_WORDS: readonly ["draft", "archived"];
+/** Display-word fold for a stored `entries.status`/lifecycle value: legacy `active` displays as
+ *  the canonical `accepted` word (DEC-1575 — the two are the same trust level), so the CLI never
+ *  shows a fresh accept and a legacy row under different labels. F2 (PR review, kickoff-final
+ *  §5): `current` is a CATEGORY, not the same thing as the `accepted` LABEL one collection's own
+ *  `statusList` happens to use for its live state — `pb get`/formatters/entry.ts shows the raw
+ *  stored word ("Status: current"), so folding `current` here would make `search` disagree with
+ *  `get` for the exact same entry. Every value besides legacy `active` (including `accepted`
+ *  itself and the category words `current`/`past`/`discarded`) displays as-is. Deliberately NOT
+ *  a `deprecated`→`archived` fold, which would collapse two genuinely distinct stored values into
+ *  one shown word, which a display column must not do. */
+export declare function displayEntryStatus(status: string): string;
+//# sourceMappingURL=statusCategories.d.ts.map

package/dist/lib/statusCategories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusCategories.d.ts","sourceRoot":"","sources":["../../src/lib/statusCategories.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,oDAAqD,CAAC;AAEpF,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAIhE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,cAAc,CAEvE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAA8B;AACrF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAgC;AACzF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAA6B;AACnF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAkC;AAU7F;;;;;;;;GAQG;AASH,eAAO,MAAM,oBAAoB,4CAA6C,CAAC;AAE/E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;GAUG;AASH,eAAO,MAAM,oBAAoB,0DAA2D,CAAC;AAE7F;;;;;;;;;+CAS+C;AAC/C,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,cAAc,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;uFACmF;IACnF,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CA+EzE;AAED;;;;0DAI0D;AAC1D,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAChD,cAAc,GAAG,SAAS,CAE5B;AAED;;;uEAGuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;AAElE,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,cAAc,EAAE,kBAAkB,CAE3E,CAAC;AAEF;;;;;;;;gEAQgE;AAChE,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE;IAAE,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAC1E,cAAc,EAAE,MAAM,GAAG,SAAS,GAChC;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,kBAAkB,CAAA;CAAE,GAAG,SAAS,CAKzE;AAED;;;;;;;yFAOyF;AACzF,wBAAgB,yBAAyB,CACxC,iBAAiB,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EACxD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE;IAAE,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GACxE;IAAE,WAAW,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,SAAS,EAAE,kBAAkB,CAAA;KAAE,GAAG,SAAS,CAAC;IAAC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAOjI;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;;;;gEAIgE;AAChE,wBAAgB,eAAe,CAC9B,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EAClD,QAAQ,EAAE,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,CAAC,GACrD,MAAM,GAAG,SAAS,CAGpB;AAyBD,eAAO,MAAM,uBAAuB,oGAAuE,CAAC;AAC5G,eAAO,MAAM,wBAAwB,gCAAiC,CAAC;AAEvE;;;;;;;;;0DAS0D;AAC1D,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/lib/statusCategories.js

@@ -0,0 +1,284 @@
+// GENERATED by scripts/generate-mcp-embedded-copies.mjs from kernel/entries/statusCategories.ts.
+// DO NOT EDIT. Run `npm run mcp:embedded-copies` to regenerate.
+// Local runtime copy for the isolated connector build.
+/**
+ * Status category axis (T2, TASK-386, WP-779, DEC-1622 kickoff-final §5). Split out of
+ * statusStateMachine.ts (round-2 review) to keep that file under its 500-line module-health
+ * ceiling — a real split, never a comment trim; re-exported from statusStateMachine.ts so every
+ * existing import path (`kernel/entries/statusStateMachine`) keeps resolving unchanged.
+ *
+ * The kernel's four status CATEGORIES — RULE-630 step 1 adds this union beside
+ * statusStateMachine.ts's existing draft/accepted/active/deprecated/archived trust literals,
+ * removing nothing (T9a2 removes `active`/`deprecated` from the schema union only after T9a1's
+ * deploy step has emptied them fleet-wide). A category is NEVER supplied by a caller: it is
+ * looked up from the entry's collection's declared `statusList` (below) by the entry's stored
+ * `workflowStatus` LABEL. T3a (TASK-388, WP-779, DEC-1788) wired the one write door
+ * (`convex/lib/writeEntryStatus.ts`) through `resolveStatusCategory` — a writer whose
+ * destination collection declares a `statusList` now gets `current`/`past`/`discarded` written
+ * into `entries.status` alongside the label; an undeclared collection, or an unmapped label,
+ * still leaves `entries.status` holding one of the 5 legacy trust words. `entries.status` stores
+ * the category once derivable; `entries.workflowStatus` stores the label. No new column.
+ */
+export const STATUS_CATEGORIES = ['draft', 'current', 'past', 'discarded'];
+const STATUS_CATEGORY_SET = new Set(STATUS_CATEGORIES);
+export function isStatusCategory(value) {
+    return STATUS_CATEGORY_SET.has(value);
+}
+export function isDraftCategory(value) { return value === 'draft'; }
+export function isCurrentCategory(value) { return value === 'current'; }
+export function isPastCategory(value) { return value === 'past'; }
+export function isDiscardedCategory(value) { return value === 'discarded'; }
+// ─── Trust-word axis (F1, PR review, TASK-393, WP-779) ─────────────────────────────────────────
+// Moved from statusStateMachine.ts, which imports both arrays + isTrustAccepted back and
+// re-exports them unchanged (`export * from './statusCategories'`) — every existing
+// `from '.../statusStateMachine'` importer keeps resolving. Moved here (not left in place)
+// because this is the connector-copy source (T2) and every existing generated-copy target is
+// dependency-free (see e.g. spineVerdictRead.ts's header) — statusStateMachine.ts imports
+// `./patchFieldPolicy` for one unrelated function, so it can't be the copy source itself.
+/**
+ * Round 1 review (P1, PR #652 threads 1 + 2): the write-compat bridge means
+ * 'accepted' and legacy 'active' are the SAME trust level, permanently — not a
+ * transitional state. Every reader that gates on "is this entry live/accepted"
+ * (orientation, authority resolution, question routing, governance-promotion
+ * gates) MUST accept both words, or a migrated/mixed workspace silently loses
+ * — or under-gates — entries depending on which literal they happen to carry.
+ * This is the ONE shared predicate; do not re-hand-roll `=== 'active'`.
+ */
+// WP-735 S5 review round (Codex P1, "Derive live-status filtering from the canonical helper"):
+// a DB-level pre-filter (Convex .filter() takes literal q.eq comparisons, never an arbitrary JS
+// predicate) needs the actual words, not just isTrustAccepted's boolean — exporting them here
+// keeps every such pre-filter derived from the SAME list this predicate reads, instead of a
+// second hand-typed literal pair that could silently drift if a future trust-word is added.
+// T3a (TASK-388, WP-779, DEC-1788): 'current' joins the pair once writeEntryStatus.ts derives it
+// into `status` for a collection with a declared statusList — the category axis's "live" word is
+// the SAME trust level as 'accepted'/'active', not a fourth thing a reader must learn separately.
+export const TRUST_ACCEPTED_WORDS = ['accepted', 'active', 'current'];
+export function isTrustAccepted(status) {
+    return TRUST_ACCEPTED_WORDS.includes(status);
+}
+/**
+ * WP-664 Lane 2 S2 reduction leaf 3 — the mirror predicate on the OTHER trust-word pair: legacy
+ * 'deprecated' is the same trust level as canonical 'archived', permanently (same DEC-1571 fold
+ * as isTrustAccepted's active/accepted pairing above, just on the retired side). Every reader
+ * that means "is this entry retired" (skip a dead reference in an enumeration, exclude from a
+ * subtree/anchor recovery pass) MUST accept both words, or a not-yet-migrated 'deprecated' row
+ * silently survives a filter written only against 'archived'. This is the shared predicate for
+ * that axis — do not re-hand-roll `=== 'archived' || === 'deprecated'` (a pattern already
+ * duplicated across a dozen-plus call sites at the time this helper was added; widening those
+ * onto it is future-leaf work, not this leaf's scope).
+ */
+// T3a (TASK-388, WP-779, DEC-1788): 'past' and 'discarded' join the pair — the category axis's
+// two retired words are the SAME trust level as 'archived'/'deprecated', same reasoning as
+// TRUST_ACCEPTED_WORDS's 'current' addition above.
+// T4a1 (TASK-387, WP-779): exported as an array too, mirroring TRUST_ACCEPTED_WORDS — a DB-level
+// pre-filter or an aggregate-bounds reader on the archived side needs the actual words, not just
+// isTrustArchived's boolean, and this is the ONE list both derive from (never a second hand-typed
+// four-word literal). `isTrustArchived` itself now reads this array instead of an inline literal
+// chain — one list, not two copies that could silently drift.
+export const TRUST_ARCHIVED_WORDS = ['archived', 'deprecated', 'past', 'discarded'];
+function isPlainStatusListEntry(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Validates a collection's declared `statusList` (kickoff-final §5 ruling #2, round-2 review):
+ * the FIRST label is literally "draft" AND category 'draft'; exactly ONE label is category
+ * 'draft'; exactly ONE label is category 'discarded' and that label is itself literally
+ * "discarded"; every OTHER label is category 'current' or 'past'; labels are unique (case-folded
+ * — "Draft" and "draft" collide); no label is empty or whitespace-padded; DEC-1813: among the
+ * Past-category labels (if any), exactly one is marked `archiveDefault: true` — the word an
+ * archive (which never knows the specific outcome) writes. Accepts `unknown` (this is called on
+ * raw catalog JSON before it is known to be shaped) — mirrors `validateAxisContract`
+ * (convex/lib/axisContract.ts)'s defensive-input posture, not just `validateStageLabelMap`'s
+ * already-typed one. Returns every violation found; empty = valid. Pure, never throws.
+ */
+export function validateStatusList(statusList) {
+    if (!Array.isArray(statusList)) {
+        return ['statusList must be an array.'];
+    }
+    if (statusList.length === 0) {
+        return ['statusList must declare at least one label.'];
+    }
+    const shapeErrors = [];
+    const entries = [];
+    for (const raw of statusList) {
+        if (!isPlainStatusListEntry(raw) || typeof raw.label !== 'string' || typeof raw.category !== 'string') {
+            shapeErrors.push(`every statusList entry must be an object with a string "label" and a string "category", got ${JSON.stringify(raw)}.`);
+            continue;
+        }
+        entries.push({ label: raw.label, category: raw.category, archiveDefault: raw.archiveDefault === true, resolveDefault: raw.resolveDefault === true });
+    }
+    if (shapeErrors.length > 0)
+        return shapeErrors; // can't meaningfully check the rules below on malformed entries
+    const errors = [];
+    for (const entry of entries) {
+        if (entry.label.length === 0 || entry.label.trim() !== entry.label) {
+            errors.push(`label "${entry.label}" is empty or whitespace-padded — labels must be non-empty and trimmed.`);
+        }
+        if (!isStatusCategory(entry.category)) {
+            errors.push(`label "${entry.label}" declares category "${entry.category}", which is not one of the four kernel categories (${STATUS_CATEGORIES.join('|')}).`);
+        }
+    }
+    if (entries[0].label !== 'draft') {
+        errors.push(`statusList[0] must be literally labeled "draft", found "${entries[0].label}".`);
+    }
+    if (entries[0].category !== 'draft') {
+        errors.push(`statusList[0] ("${entries[0].label}") must be category 'draft' — the first declared label is always the collection's draft state.`);
+    }
+    const draftCount = entries.filter((e) => e.category === 'draft').length;
+    if (draftCount !== 1) {
+        errors.push(`statusList must declare exactly one 'draft' category label, found ${draftCount}.`);
+    }
+    const discarded = entries.filter((e) => e.category === 'discarded');
+    if (discarded.length !== 1) {
+        errors.push(`statusList must declare exactly one 'discarded' category label, found ${discarded.length}.`);
+    }
+    else if (discarded[0].label !== 'discarded') {
+        errors.push(`the 'discarded' category label must itself be named "discarded", found "${discarded[0].label}".`);
+    }
+    // DEC-1813: among the Past-category labels (if this collection declares any), exactly one must
+    // be the archive default — the word `archiveLabelFor` writes for an archive, which never knows
+    // the specific outcome (done/achieved/answered/etc. are written only by the verb that knows it).
+    const pastLabels = entries.filter((e) => e.category === 'past');
+    const pastArchiveDefaults = pastLabels.filter((e) => e.archiveDefault === true);
+    if (pastLabels.length > 0 && pastArchiveDefaults.length !== 1) {
+        errors.push(`statusList must mark exactly one Past-category label archiveDefault: true, found ${pastArchiveDefaults.length} among ${pastLabels.length} Past label(s).`);
+    }
+    // archiveDefault only ever means anything on a Past-category label (archiveLabelFor never reads
+    // it on any other category) — a non-Past label marked true would advertise (and
+    // describeCollection would render) two "archive defaults" while archiveLabelFor only ever
+    // honors the Past one. Reject the non-Past marker outright rather than let the stored contract
+    // and the advertised vocabulary disagree.
+    for (const entry of entries) {
+        if (entry.category !== 'past' && entry.archiveDefault === true) {
+            errors.push(`label "${entry.label}" (category "${entry.category}") declares archiveDefault: true — archiveDefault is only meaningful on a Past-category label.`);
+        }
+    }
+    // TASK-490: resolveDefault is optional, only on a Past label, at most one, and never the archiveDefault itself.
+    const resolveDefaults = entries.filter((e) => e.resolveDefault === true);
+    if (resolveDefaults.length > 1)
+        errors.push(`statusList may mark at most one label resolveDefault: true, found ${resolveDefaults.length}.`);
+    for (const entry of resolveDefaults) {
+        if (entry.category !== 'past' || entry.archiveDefault === true)
+            errors.push(`label "${entry.label}" declares resolveDefault: true — it is only meaningful on a Past-category label that is not the archiveDefault.`);
+    }
+    const seen = new Set();
+    for (const entry of entries) {
+        const key = entry.label.toLowerCase();
+        if (seen.has(key)) {
+            errors.push(`label "${entry.label}" collides with another label after case-folding — statusList labels must be unique regardless of case.`);
+        }
+        seen.add(key);
+    }
+    return errors;
+}
+/** Looks up a label's category from a collection's declared statusList. Never throws — an
+ *  unmapped label (statusList absent, or the label isn't declared) resolves to `undefined` so
+ *  the caller (the one write door, `convex/lib/writeEntryStatus.ts`) decides whether that is a
+ *  hard failure — this module stays neutral, same posture as `resolveProgress`
+ *  (statusStateMachine.ts) does for the progress axis. */
+export function resolveStatusCategory(label, statusList) {
+    return statusList?.find((e) => e.label === label)?.category;
+}
+export const CATEGORY_TRUST_LEVEL = {
+    draft: 'draft', current: 'current', past: 'archived', discarded: 'archived',
+};
+/** T3b (TASK-388, WP-779, DEC-1788): the ONE derivation, shared by every writer that turns a
+ *  `workflowStatus` label into a `status` category — the patch door (`writeEntryStatus.ts`) and
+ *  a future create path both call this instead of each re-implementing the
+ *  `resolveStatusCategory` + trust-level lookup pair. Pure: no `ctx.db`, no guard, no write —
+ *  callers run their OWN guards (creation has its own; writeEntryStatus.ts's guard block is
+ *  unchanged) against the `trustWord` this returns, exactly as they would a caller-supplied
+ *  trust word. `undefined` covers two cases identically (no derivation to report): an undeclared
+ *  statusList, and a declared statusList whose label isn't listed. TASK-389/DEC-1789 governs when
+ *  the second case becomes a hard failure at the write door. */
+export function deriveStatusPair(collection, workflowStatus) {
+    if (typeof workflowStatus !== 'string' || collection?.statusList === undefined)
+        return undefined;
+    const category = resolveStatusCategory(workflowStatus, collection.statusList);
+    if (category === undefined)
+        return undefined;
+    return { category, trustWord: CATEGORY_TRUST_LEVEL[category] };
+}
+/** T3b round-2 review: the ONE reconciliation both writeEntryStatus.ts and _patchEntry run
+ *  against `deriveStatusPair`'s result — never throws (this module stays Convex-free, same
+ *  posture as `validateStatusList`); the caller turns `disagreementError` into its own
+ *  VALIDATION_FAILED. `explicitTrustWord` is the caller's OWN status, already canonicalized to
+ *  a trust word (or `null` for an unrecognized word, or `undefined` when no status was
+ *  supplied at all) — the caller resolves that BEFORE calling, since canonicalWriteTarget lives
+ *  in statusStateMachine.ts, not here (no import cycle: this file is re-exported THROUGH that
+ *  one). `derivedPair` is undefined for both cases `deriveStatusPair` already covers. */
+export function reconcileStatusDerivation(explicitTrustWord, workflowStatus, collection) {
+    const derivedPair = deriveStatusPair(collection, workflowStatus);
+    if (derivedPair === undefined)
+        return { derivedPair: undefined, disagreementError: undefined };
+    if (explicitTrustWord != null && explicitTrustWord !== derivedPair.trustWord) {
+        return { derivedPair, disagreementError: `expected trust level "${derivedPair.trustWord}" (category "${derivedPair.category}"), got "${explicitTrustWord}"` };
+    }
+    return { derivedPair, disagreementError: undefined };
+}
+/**
+ * DEC-1813/DEC-1814 (T4b, TASK-389, TASK-466): `archiveLabelFor` turns an archive CATEGORY into the
+ * status WORD to write. There is no archive reason: the category is decided by the caller alone
+ * (a draft archives to Discarded, anything else to Past, or a door passes 'discarded' explicitly)
+ * and the word carries only that category. Production callers (`rg -n "archiveLabelFor\(" convex`):
+ * `convex/agentKnowledge/archiveEntry.ts` (the Rail delete door) calls it directly, and
+ * `convex/lib/archiveWorkflowStatus.ts` calls it through `resolveArchiveWorkflowStatusOrThrow`, the one
+ * resolver updateEntry's archive door, the supersede, glossary-merge and deprecate doors and the
+ * hygiene sweep all use. Both land on the identical word for the same category.
+ *
+ * Discarded always writes the literal 'discarded' (every statusList declares it,
+ * `validateStatusList`'s own rule) REGARDLESS of whether a statusList is even declared; Past writes
+ * the collection's one `archiveDefault` Past label, or `undefined` when the collection has no
+ * statusList at all, or (should `validateStatusList` ever have been skipped) no Past label is marked
+ * `archiveDefault` — the caller decides whether that `undefined` is a hard failure, this module
+ * stays neutral, same posture as `resolveStatusCategory`.
+ */
+/** DEC-1813: the ONE label a CATEGORY of archive writes.
+ *  'discarded' always writes the literal 'discarded' (every statusList declares it,
+ *  `validateStatusList`'s own rule); 'past' writes the collection's one `archiveDefault` Past
+ *  label, or `undefined` when none is marked (`validateStatusList` refuses a list without exactly
+ *  one, but an older, pre-validation row can still lack it). */
+export function archiveLabelFor(statusList, category) {
+    if (category === 'discarded')
+        return 'discarded';
+    return statusList?.find((e) => e.category === 'past' && e.archiveDefault === true)?.label;
+}
+// ─── Connector-facing entries.status vocabulary (T8, TASK-393, WP-779) ────────────────────────
+//
+// The isolated CLI/MCP connector builds cannot import `kernel/` live (same Railway/standalone-
+// package isolation `scripts/generate-mcp-embedded-copies.mjs`'s header documents for
+// flags_core.ts/logo-markup.ts) — this file is their generated-copy source for the status
+// vocabulary instead of each connector hand-typing its own word list, which had already
+// drifted: `entriesContract.ts`'s filter enum, `knowledge.ts`'s `updateEntrySchema.status` enum
+// and `LifecycleStatus` type, and the CLI's `formatters/search.ts` display fold each hard-coded
+// the pre-T2 5-word trust set (`draft|active|accepted|deprecated|archived`) and would silently
+// reject or mis-render an entry once T3a/T3b (DEC-1788, already merged) start deriving
+// `current`/`past`/`discarded` onto entries whose collection declares a `statusList`.
+//
+// F1 (PR review): DERIVED from TRUST_ACCEPTED_WORDS/TRUST_ARCHIVED_WORDS above, not a third,
+// independently-typed list — a real ratchet against the exact drift this slice exists to close.
+//
+// Two lists, not one: a READ (list/search filter) must still recognize the two pre-fold legacy
+// trust words on a not-yet-migrated row (DEC-1575) — it only ever widens. A WRITE
+// (`pb update --status` / MCP `entries` action=update) must not advertise `active`/`deprecated`
+// as fresh input: `writeEntryStatus.ts`'s `canonicalWriteTarget` write-compat bridge exists for
+// pre-existing internal callers, not for a caller typing a legacy word today. `accepted` is
+// deliberately absent from the write set — unchanged pre-existing policy (`commit` is the accept
+// path, never `update`; the MCP `updateEntrySchema` comment already said so before this file
+// generated it).
+export const ENTRY_STATUS_READ_WORDS = ['draft', ...TRUST_ACCEPTED_WORDS, ...TRUST_ARCHIVED_WORDS];
+export const ENTRY_STATUS_WRITE_WORDS = ['draft', 'archived'];
+/** Display-word fold for a stored `entries.status`/lifecycle value: legacy `active` displays as
+ *  the canonical `accepted` word (DEC-1575 — the two are the same trust level), so the CLI never
+ *  shows a fresh accept and a legacy row under different labels. F2 (PR review, kickoff-final
+ *  §5): `current` is a CATEGORY, not the same thing as the `accepted` LABEL one collection's own
+ *  `statusList` happens to use for its live state — `pb get`/formatters/entry.ts shows the raw
+ *  stored word ("Status: current"), so folding `current` here would make `search` disagree with
+ *  `get` for the exact same entry. Every value besides legacy `active` (including `accepted`
+ *  itself and the category words `current`/`past`/`discarded`) displays as-is. Deliberately NOT
+ *  a `deprecated`→`archived` fold, which would collapse two genuinely distinct stored values into
+ *  one shown word, which a display column must not do. */
+export function displayEntryStatus(status) {
+    return status === 'active' ? 'accepted' : status;
+}
+//# sourceMappingURL=statusCategories.js.map