@openrig/cli 0.5.0 → 0.5.2

package/node_modules/@openrig/daemon/dist/domain/scope/plan-lock-artifacts.js

@@ -0,0 +1,97 @@
+// OPR.0.4.7 slice-04 Stage-3 Lever A — plan-lock snapshot derivation.
+//
+// PURE derivation of a slice's `locked-artifacts` plan set from its README +
+// IMPLEMENTATION-PRD content strings — NO fs here; the scope-approve read shell
+// supplies both (readme = the approve originalBytes, prd = tryReadPRD or null).
+// Reuses the EXPORTED Review helpers directly (D1 — no shared extraction) so the
+// derived plan has source-selection/extraction parity with Review (no byte-equality
+// claim). Determinism: stable order (PRD -> selected proof-contract plannedRefs ->
+// intent visuals), normalized-path dedup, first source wins.
+import { extractProofContractSelected, extractSection, extractMediaRefs, sliceRelativeMediaPath, } from "../review/compose.js";
+import { isScaffoldPlaceholderText } from "./scaffold-placeholder.js";
+/**
+ * Derive the ordered, deduped `locked-artifacts` set for a slice plan-lock.
+ * @param readme slice README content (the approve read shell's originalBytes); null if absent.
+ * @param prd slice IMPLEMENTATION-PRD content; null when missing/unreadable (fail-open).
+ */
+export function derivePlanLockArtifacts(readme, prd) {
+    const out = [];
+    const seen = new Set(); // dedup by NORMALIZED path; first source wins
+    // Slice-relative + posix-normalize: reject absolute `/…` and `../`-escape, and
+    // collapse `mockups/./d.png` and `mockups/d.png` to one entry (first wins).
+    // nameFromPath: D4 — an intent-visual entry's name is its EMITTED (normalized)
+    // path, so the name never carries a pre-normalization raw ref (e.g. `mockups/./x.png`).
+    const add = (name, ref, kind, nameFromPath = false) => {
+        // Reject any URI-scheme ref (http/https/data/...) BEFORE normalization: every
+        // locked-artifact path is slice-relative. Intent refs are http-filtered by
+        // extractMediaRefs, but proof-contract plannedRefs are not — enforce it here.
+        if (/^[a-z][a-z0-9+.-]*:/i.test(ref))
+            return; // RFC-3986 scheme syntax
+        const norm = sliceRelativeMediaPath(ref, "");
+        if (norm === null)
+            return; // absolute / escape — never a locked artifact
+        if (seen.has(norm))
+            return; // first source wins
+        seen.add(norm);
+        out.push({ name: nameFromPath ? norm : name, path: norm, kind });
+    };
+    // 1. PRD — always pinned first: the EXPECTED spec path, even when the PRD file
+    //    is missing/unreadable (Guard #4). A missing PRD simply adds no plannedRefs.
+    add("Implementation PRD", "IMPLEMENTATION-PRD.md", "spec");
+    // 2. Selected proof-contract plannedRefs — an authored README section wins over
+    //    a pristine-scaffold PRD section (extractProofContractSelected, README-wins).
+    for (const item of extractProofContractSelected(prd, readme).items) {
+        if (!item.plannedRef)
+            continue;
+        add(item.text || item.plannedRef, item.plannedRef, "mockup"); // name = item text, path fallback
+    }
+    // 3. Intent visuals — README `## Intent visual` media refs, UNLESS the section
+    //    is N/A (the section-suppression semantics the scope audit uses).
+    const visual = extractSection(readme, "Intent visual");
+    if (visual !== null && !/\bN\/A\b/i.test(visual)) {
+        for (const ref of extractMediaRefs(visual)) {
+            add(ref, ref, "mockup", true); // deterministic name = the emitted (normalized) path (D4)
+        }
+    }
+    return out;
+}
+/**
+ * True when a DERIVED plan-lock set would freeze nothing anybody authored: the set is only the
+ * unconditional PRD pin, and the PRD file is missing or still shipped-template scaffold (no authored
+ * intent prose, no authored mini-req, no authored proof-contract row — the ONE scaffold grammar).
+ *
+ * A plan-lock's entire meaning is "THIS artifact set is what gets built"; letting the default pin a
+ * placeholder writes the strongest structural claim in the SDLC with content nobody chose. Two live
+ * locks did exactly that before this check existed. Approve refuses on this predicate unless the
+ * stamper names the set explicitly.
+ */
+export function isContentlessPlanLockSet(prd, artifacts) {
+    if (artifacts.length > 1)
+        return false; // plannedRefs / intent visuals = chosen content beyond the pin
+    if (prd === null)
+        return true; // the pin names a file that does not exist / cannot be read
+    return !prdHasAuthoredContent(prd);
+}
+/** Any line that survives stripping frontmatter, HTML comments, headings, and list/checkbox markers,
+ *  and is not the shipped bracket-placeholder grammar, is authored content — free-prose PRDs count,
+ *  only the untouched scaffold (and emptiness) does not. */
+function prdHasAuthoredContent(prd) {
+    const body = prd
+        .replace(/^---\n[\s\S]*?\n---\n?/, "") // frontmatter
+        .replace(/<!--[\s\S]*?-->/g, ""); // scaffold guidance comments
+    for (const rawLine of body.split("\n")) {
+        let line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (/^#{1,6}\s/.test(line))
+            continue; // headings are template structure
+        line = line.replace(/^(?:[-*]\s+(?:\[[ xX]\]\s+)?|\d+[.)]\s+)/, ""); // list / checkbox markers
+        if (line.length === 0)
+            continue;
+        if (isScaffoldPlaceholderText(line))
+            continue;
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=plan-lock-artifacts.js.map

package/node_modules/@openrig/daemon/dist/domain/scope/plan-lock-artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-lock-artifacts.js","sourceRoot":"","sources":["../../../src/domain/scope/plan-lock-artifacts.ts"],"names":[],"mappings":"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"}

package/node_modules/@openrig/daemon/dist/domain/scope/scaffold-placeholder.d.ts

@@ -0,0 +1,38 @@
+/** True when `text`, trimmed, is fully bracket-wrapped (`[...]`) — the
+ *  shipped scaffold-template placeholder marker, i.e. NOT authored content. */
+export declare function isScaffoldPlaceholderText(text: string): boolean;
+/** release-0.4.7 placeholder-suppression completeness — true when `body`
+ *  carries at least one numbered item (`1.` OR `1)` form) whose text is NOT a
+ *  scaffold placeholder: the ONE authored-numbered-item grammar. Consumers:
+ *  review compose `hasAuthoredMiniReqs` + BOTH scope-audit mini-reqs arms —
+ *  one predicate heals the IF-3 dot/paren grammar divergence and the audit
+ *  arm's placeholder-blindness together (arch MB-AR-1 primary shape).
+ *  Prose-only or bullet-only bodies are deliberately NOT authored — the
+ *  numbered tier is where approval starts (reviewer-L1 ruling 2026-07-11,
+ *  intent-stage gate). `null` → false. */
+export declare function hasAuthoredNumberedItem(body: string | null): boolean;
+/** release-0.4.7 placeholder-suppression completeness — true when EVERY
+ *  non-blank line of `block` is a scaffold placeholder: the section-level
+ *  "nothing authored here" test. Per-LINE deliberately, not a whole-string
+ *  trim — a two-line `[a]\n[b]` body is placeholder-only per line but would
+ *  fail the single-line regex (the multi-line honest case, arch MB-AR-2).
+ *  `null`/empty/blank-only → false: absence is its own state; callers keep
+ *  their existing null handling. */
+export declare function isPlaceholderOnlyBlock(block: string | null): boolean;
+/** PM dogfood #1 (qitem-20260720015700-630eef64) — true when `body` is a
+ *  PRESENT section whose EVERY non-blank line is scaffold-placeholder
+ *  content: either a bare placeholder line, or a structural list row
+ *  (numbered `1.`/`1)`, checkbox `- [ ]`, or bullet `-`/`*`) whose text is a
+ *  placeholder — i.e. exactly what the shipped templates scaffold, nothing
+ *  authored. This is the SECTION-level pristine test behind per-section
+ *  source selection: only a pristine PRD section may yield to an authored
+ *  README section; authored/prose/mixed content is NOT pristine and stays
+ *  canonical wherever it lives. `null`/blank-only → false (absence is its
+ *  own state; a missing section never triggers fallback). */
+export declare function isPristineScaffoldSection(body: string | null): boolean;
+/** The generic acceptance triple scaffolded by
+ *  `packages/cli/src/lib/scope-templates/slice-progress.md` — exact trimmed
+ *  literals, sync-tested against the shipped template so constant/template
+ *  drift fails CI instead of silently reviving the bogus pristine count. */
+export declare const GENERIC_SCAFFOLD_ACCEPTANCE: readonly string[];
+//# sourceMappingURL=scaffold-placeholder.d.ts.map

package/node_modules/@openrig/daemon/dist/domain/scope/scaffold-placeholder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold-placeholder.d.ts","sourceRoot":"","sources":["../../../src/domain/scope/scaffold-placeholder.ts"],"names":[],"mappings":"AAuBA;+EAC+E;AAC/E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;0CAQ0C;AAC1C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAOpE;AAED;;;;;;oCAMoC;AACpC,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAQpE;AAED;;;;;;;;;6DAS6D;AAC7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAWtE;AAED;;;4EAG4E;AAC5E,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAIxD,CAAC"}

package/node_modules/@openrig/daemon/dist/domain/scope/scaffold-placeholder.js

@@ -0,0 +1,98 @@
+// release-0.4.7 intent-stage/scaffold-projection — the ONE scaffold-recognition
+// grammar: "this text is shipped-template placeholder, not authored content."
+//
+// PARITY CONTRACT (arch ruling 2026-07-11, intent-stage plan AR-1 + P1 pin):
+// this file is a BYTE-EQUIVALENT TWIN — it exists identically at
+//   packages/cli/src/lib/scope/scaffold-placeholder.ts
+//   packages/daemon/src/domain/scope/scaffold-placeholder.ts
+// and byte-equivalence is CI-enforced by scope-audit-parity CLASSIFIER_FILES.
+// Do NOT diverge the copies, and do NOT "deduplicate" them into one file in a
+// cleanup pass — a true shared module importable by both packages does not
+// exist in this layout, so the twin-plus-parity arrangement IS the
+// single-grammar guarantee (one grammar, three consumers: review compose,
+// slice-detail-projector, and both scope-audit twins). If the layout ever
+// gains a real shared package, the twins collapse into it then — not before.
+//
+// Grammar (arch-stated): trimmed text fully bracket-wrapped = a scaffold
+// placeholder — the shipped-template marker, verified template-by-template
+// across scope-templates/*.md. Honest edge (test-pinned, not gated): ANY
+// character outside the brackets makes it real; a fully-bracket-wrapped REAL
+// deliverable is written in template grammar. `[a] and [b]` starts with `[`
+// and ends with `]`, so it classifies placeholder — arch-grammar-faithful,
+// deliberately not special-cased (no private grammar).
+/** True when `text`, trimmed, is fully bracket-wrapped (`[...]`) — the
+ *  shipped scaffold-template placeholder marker, i.e. NOT authored content. */
+export function isScaffoldPlaceholderText(text) {
+    return /^\[.*\]$/.test(text.trim());
+}
+/** release-0.4.7 placeholder-suppression completeness — true when `body`
+ *  carries at least one numbered item (`1.` OR `1)` form) whose text is NOT a
+ *  scaffold placeholder: the ONE authored-numbered-item grammar. Consumers:
+ *  review compose `hasAuthoredMiniReqs` + BOTH scope-audit mini-reqs arms —
+ *  one predicate heals the IF-3 dot/paren grammar divergence and the audit
+ *  arm's placeholder-blindness together (arch MB-AR-1 primary shape).
+ *  Prose-only or bullet-only bodies are deliberately NOT authored — the
+ *  numbered tier is where approval starts (reviewer-L1 ruling 2026-07-11,
+ *  intent-stage gate). `null` → false. */
+export function hasAuthoredNumberedItem(body) {
+    if (body === null)
+        return false;
+    for (const line of body.split("\n")) {
+        const m = line.match(/^\s*\d+[.)]\s+(.+)$/);
+        if (m && !isScaffoldPlaceholderText(m[1].trim()))
+            return true;
+    }
+    return false;
+}
+/** release-0.4.7 placeholder-suppression completeness — true when EVERY
+ *  non-blank line of `block` is a scaffold placeholder: the section-level
+ *  "nothing authored here" test. Per-LINE deliberately, not a whole-string
+ *  trim — a two-line `[a]\n[b]` body is placeholder-only per line but would
+ *  fail the single-line regex (the multi-line honest case, arch MB-AR-2).
+ *  `null`/empty/blank-only → false: absence is its own state; callers keep
+ *  their existing null handling. */
+export function isPlaceholderOnlyBlock(block) {
+    if (block === null)
+        return false;
+    const lines = block
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (lines.length === 0)
+        return false;
+    return lines.every((l) => isScaffoldPlaceholderText(l));
+}
+/** PM dogfood #1 (qitem-20260720015700-630eef64) — true when `body` is a
+ *  PRESENT section whose EVERY non-blank line is scaffold-placeholder
+ *  content: either a bare placeholder line, or a structural list row
+ *  (numbered `1.`/`1)`, checkbox `- [ ]`, or bullet `-`/`*`) whose text is a
+ *  placeholder — i.e. exactly what the shipped templates scaffold, nothing
+ *  authored. This is the SECTION-level pristine test behind per-section
+ *  source selection: only a pristine PRD section may yield to an authored
+ *  README section; authored/prose/mixed content is NOT pristine and stays
+ *  canonical wherever it lives. `null`/blank-only → false (absence is its
+ *  own state; a missing section never triggers fallback). */
+export function isPristineScaffoldSection(body) {
+    if (body === null)
+        return false;
+    const lines = body
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (lines.length === 0)
+        return false;
+    return lines.every((l) => {
+        const stripped = l.replace(/^(?:\d+[.)]\s+|-\s*\[[ xX]\]\s*|[-*]\s+)/, "");
+        return isScaffoldPlaceholderText(stripped);
+    });
+}
+/** The generic acceptance triple scaffolded by
+ *  `packages/cli/src/lib/scope-templates/slice-progress.md` — exact trimmed
+ *  literals, sync-tested against the shipped template so constant/template
+ *  drift fails CI instead of silently reviving the bogus pristine count. */
+export const GENERIC_SCAFFOLD_ACCEPTANCE = [
+    "Implementation complete",
+    "Tests passing",
+    "Review approved",
+];
+//# sourceMappingURL=scaffold-placeholder.js.map

package/node_modules/@openrig/daemon/dist/domain/scope/scaffold-placeholder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold-placeholder.js","sourceRoot":"","sources":["../../../src/domain/scope/scaffold-placeholder.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,8EAA8E;AAC9E,EAAE;AACF,6EAA6E;AAC7E,iEAAiE;AACjE,uDAAuD;AACvD,6DAA6D;AAC7D,8EAA8E;AAC9E,8EAA8E;AAC9E,2EAA2E;AAC3E,mEAAmE;AACnE,0EAA0E;AAC1E,0EAA0E;AAC1E,6EAA6E;AAC7E,EAAE;AACF,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,6EAA6E;AAC7E,4EAA4E;AAC5E,2EAA2E;AAC3E,uDAAuD;AAEvD;+EAC+E;AAC/E,MAAM,UAAU,yBAAyB,CAAC,IAAY;IACpD,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;0CAQ0C;AAC1C,MAAM,UAAU,uBAAuB,CAAC,IAAmB;IACzD,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IACjE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;oCAMoC;AACpC,MAAM,UAAU,sBAAsB,CAAC,KAAoB;IACzD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACjC,MAAM,KAAK,GAAG,KAAK;SAChB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;6DAS6D;AAC7D,MAAM,UAAU,yBAAyB,CAAC,IAAmB;IAC3D,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAChC,MAAM,KAAK,GAAG,IAAI;SACf,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,CAAC,CAAC,OAAO,CAAC,0CAA0C,EAAE,EAAE,CAAC,CAAC;QAC3E,OAAO,yBAAyB,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;4EAG4E;AAC5E,MAAM,CAAC,MAAM,2BAA2B,GAAsB;IAC5D,yBAAyB;IACzB,eAAe;IACf,iBAAiB;CAClB,CAAC"}

package/node_modules/@openrig/daemon/dist/domain/scope/scope-approve.d.ts

@@ -0,0 +1,85 @@
+import type { MissionControlActionLog } from "../mission-control/mission-control-action-log.js";
+export type ScopeTier = "slice" | "mission";
+export type ApprovalScope = "spec" | "delivery";
+export interface ScopeApproveInput {
+    scopeTier: ScopeTier;
+    /** Canonical missions-root-relative path (e.g.
+     *  "release-0.4.4/slices/19-living-notes-signal-layer" or "release-0.4.4"). */
+    scopePath: string;
+    /** STAGED APPROVAL (founder un-deferred): `spec` = "the PRD matches my
+     *  intent" (the first accept-point); `delivery` = the terminal sign-off
+     *  (the freeze trigger). Omitted upstream ⇒ delivery (back-compat). */
+    approvalScope: ApprovalScope;
+    /** The REAL invoking session (honest provenance — never overwritten by
+     *  delegation). */
+    actorSession: string;
+    /** P21 era-stamp: how actorSession was established. The route passes `transport:v1` when it derived
+     *  the actor from the authenticated transport chokepoint; omitted (null) ⇒ claimed-era (a direct
+     *  caller / pre-P21 row), rendered "recorded (pre-verification era)", never re-labeled. */
+    identityProvenance?: string | null;
+    /** DELEGATED APPROVAL: whose decision this stamp records when an agent
+     *  invokes on the founder's behalf. Recorded in the audit notes only. */
+    onBehalfOf?: string | null;
+    /** OPR.0.5.0.18 — AMEND/RE-STAMP: re-approve an already-approved scope as a
+     *  new reasoned attestation superseding the prior (both preserved in the
+     *  append-only audit log; ARCH-SHAPING 9d64ceb6 v2). Atomic: same
+     *  frontmatter-first → audit-second → byte-restore ordering; no unapprove
+     *  window ever exists. */
+    reApprove?: boolean;
+    /** REQUIRED with reApprove (a reasoned deliberate act, never an accident). */
+    reason?: string | null;
+    /** PLAN-LOCK ONLY — the stamper's EXPLICIT locked-artifact set (slice-relative paths). When
+     *  present it REPLACES the derived default entirely: the set is chosen, not inherited. Each path
+     *  must exist in the slice directory. Ignored for delivery/mission approvals. */
+    lockedArtifacts?: string[] | null;
+}
+export interface ScopeApproveResult {
+    scopeTier: ScopeTier;
+    scopeId: string;
+    scopePath: string;
+    approvalScope: ApprovalScope;
+    approvedBy: string;
+    approvedAt: string;
+    onBehalfOf: string | null;
+    actionId: string;
+    /** Packet-2 interface cell: only the DELIVERY stamp fires the freeze; the
+     *  compose-and-freeze endpoint ships in Packet 2, so P1 always reports
+     *  false. The stamp + audit row stand regardless of any render outcome. */
+    freezeFired: false;
+    /** OPR.0.5.0.18 — true when this result is an amendment (a re-stamp). */
+    reApproved: boolean;
+    /** The superseded attestation (present only on a re-stamp). */
+    priorApprovedBy?: string;
+    priorApprovedAt?: string | null;
+}
+export declare class ScopeApproveError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+/** The pinned audit_notes_json shape (spec-guard blocker 2): a stable,
+ *  queryable scope-target identity + the approval scope + delegation
+ *  provenance. The audit-browse read path filters on these keys — the pair
+ *  is what makes Packet 2's one-query UNVERIFIED-stamp cross-check real. */
+export interface ScopeApprovalAuditNotes extends Record<string, unknown> {
+    kind: "scope-approval";
+    scope_tier: ScopeTier;
+    scope_id: string;
+    scope_path: string;
+    approval_scope: ApprovalScope;
+    on_behalf_of: string | null;
+}
+interface ScopeApproveDeps {
+    /** Resolves the live missions root (SliceIndexer.slicesRoot), or null when
+     *  the workspace is not configured. */
+    missionsRoot: () => string | null;
+    actionLog: MissionControlActionLog;
+    now?: () => Date;
+}
+export declare class ScopeApproveService {
+    private readonly deps;
+    constructor(deps: ScopeApproveDeps);
+    approve(input: ScopeApproveInput): ScopeApproveResult;
+}
+export {};
+//# sourceMappingURL=scope-approve.d.ts.map

package/node_modules/@openrig/daemon/dist/domain/scope/scope-approve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-approve.d.ts","sourceRoot":"","sources":["../../../src/domain/scope/scope-approve.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAKhG,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAC5C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,UAAU,CAAC;AAEhD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,SAAS,CAAC;IACrB;mFAC+E;IAC/E,SAAS,EAAE,MAAM,CAAC;IAClB;;2EAEuE;IACvE,aAAa,EAAE,aAAa,CAAC;IAC7B;uBACmB;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB;;+FAE2F;IAC3F,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;6EACyE;IACzE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;8BAI0B;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;;qFAEiF;IACjF,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB;;+EAE2E;IAC3E,WAAW,EAAE,KAAK,CAAC;IACnB,yEAAyE;IACzE,UAAU,EAAE,OAAO,CAAC;IACpB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,qBAAa,iBAAkB,SAAQ,KAAK;aAExB,IAAI,EAAE,MAAM;aAEZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjC,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAKpD;AAED;;;4EAG4E;AAC5E,MAAM,WAAW,uBAAwB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtE,IAAI,EAAE,gBAAgB,CAAC;IACvB,UAAU,EAAE,SAAS,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,aAAa,CAAC;IAC9B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAOD,UAAU,gBAAgB;IACxB;2CACuC;IACvC,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,uBAAuB,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;gBAE5B,IAAI,EAAE,gBAAgB;IAIlC,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB;CA6MtD"}

package/node_modules/@openrig/daemon/dist/domain/scope/scope-approve.js

@@ -0,0 +1,290 @@
+// OPR.0.4.4.19 FR-9 — scope approve: frontmatter sole-writer + append-only
+// audit row (kills vibe-shuttled approval).
+//
+// Daemon-side by design (plan-review CONFIRMED; arch-lead interface-cell
+// PASS): the stamp is a workspace frontmatter write, the audit row is a
+// mission_control_actions insert, and the freeze-trigger interface cell
+// (Packet 2) invokes the compose-and-freeze endpoint AFTER the stamp+audit
+// commit — so the stamp+audit pair lives behind ONE daemon operation.
+//
+// Ordering (arch-lead PIN, 2026-07-04): frontmatter-first → audit-second →
+// on audit failure LOUD-FAIL + byte-restore the prior frontmatter. The
+// compensating-DELETE variant is REJECTED — no row is ever deleted from
+// mission_control_actions; append-only stands.
+//
+// Two-regime role clarity (BR-6, ratified): approval is the freeze/LOCKED
+// trigger and the regime-2 sign-off — it is NEVER the source of proven-green.
+// Nothing here computes or stores "green".
+import * as fs from "node:fs";
+import * as path from "node:path";
+import YAML from "yaml";
+import { derivePlanLockArtifacts, isContentlessPlanLockSet } from "./plan-lock-artifacts.js";
+import { sliceRelativeMediaPath } from "../review/compose.js";
+import { NODE_FILE_PRECEDENCE, resolveNodeFile } from "./node-file.js";
+export class ScopeApproveError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ScopeApproveError";
+    }
+}
+const STAMP_FIELDS = {
+    delivery: { by: "approved-by", at: "approved-at", priors: "approved-priors" },
+    spec: { by: "approved-spec-by", at: "approved-spec-at", priors: "approved-spec-priors" },
+};
+export class ScopeApproveService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    approve(input) {
+        const missionsRoot = this.deps.missionsRoot();
+        if (!missionsRoot) {
+            throw new ScopeApproveError("workspace_not_configured", "The daemon has no missions root configured; scope approve needs the workspace primitive.");
+        }
+        // Path containment: the scope path must resolve INSIDE the missions root
+        // (content-surfaces discipline — no ../ escapes).
+        const resolved = path.resolve(missionsRoot, input.scopePath);
+        if (resolved !== missionsRoot && !resolved.startsWith(missionsRoot + path.sep)) {
+            throw new ScopeApproveError("scope_path_escape", `scopePath '${input.scopePath}' resolves outside the missions root.`, { scopePath: input.scopePath });
+        }
+        const readmePath = resolveNodeFile(resolved);
+        if (!readmePath) {
+            throw new ScopeApproveError("scope_not_found", `No ${NODE_FILE_PRECEDENCE.join(" or ")} at ${input.scopePath} under the missions root — not a declared ${input.scopeTier}.`, { scopePath: input.scopePath, scopeTier: input.scopeTier });
+        }
+        const originalBytes = fs.readFileSync(readmePath, "utf8");
+        const frontmatter = parseFrontmatter(originalBytes);
+        const scopeId = typeof frontmatter["id"] === "string" && frontmatter["id"].trim().length > 0
+            ? frontmatter["id"]
+            : null;
+        if (!scopeId) {
+            throw new ScopeApproveError("scope_id_missing", `${input.scopePath} has no frontmatter id (dot-ID) — the audit target contract requires a stable scope_id.`, { scopePath: input.scopePath, action: "Run: rig scope " + input.scopeTier + " reconcile <path> to mint the id, then re-approve." });
+        }
+        // OPR.0.5.0.18 — the amend/re-stamp verb (ARCH-SHAPING 9d64ceb6 v2): a
+        // lock is a point-in-time ATTESTATION, not an irreversible seal. Without
+        // --re-approve, an existing stamp still refuses loudly — but the refusal
+        // TEACHES the sanctioned verb instead of dead-ending. With it, the stamp
+        // is superseded by a new reasoned attestation; both live in the
+        // append-only audit log. A spec stamp followed by a delivery stamp is
+        // still the normal staged sequence (different scopes never collide).
+        const fields = STAMP_FIELDS[input.approvalScope];
+        const existingBy = frontmatter[fields.by];
+        const hasExistingStamp = typeof existingBy === "string" && existingBy.trim().length > 0;
+        const isReApprove = input.reApprove === true;
+        if (hasExistingStamp && !isReApprove) {
+            throw new ScopeApproveError("already_approved", `${input.scopePath} already carries a ${input.approvalScope} approval stamp: ${fields.by}: ${existingBy}, ${fields.at}: ${String(frontmatter[fields.at] ?? "?")}. To amend/re-stamp it as a new reasoned attestation (prior preserved in the audit log), re-run with --re-approve --reason "<why>".`, { scopePath: input.scopePath, approvalScope: input.approvalScope, existingBy, existingAt: frontmatter[fields.at] ?? null });
+        }
+        const reason = typeof input.reason === "string" ? input.reason.trim() : "";
+        if (isReApprove && reason.length === 0) {
+            throw new ScopeApproveError("reason_required", `--re-approve is a reasoned deliberate act: pass --reason "<why>" describing what changed since the prior ${input.approvalScope} attestation.`, { scopePath: input.scopePath, approvalScope: input.approvalScope });
+        }
+        if (isReApprove && !hasExistingStamp) {
+            throw new ScopeApproveError("nothing_to_reapprove", `${input.scopePath} carries no ${input.approvalScope} approval stamp to supersede — run a plain approve (without --re-approve) for the first attestation.`, { scopePath: input.scopePath, approvalScope: input.approvalScope });
+        }
+        const priorApprovedBy = hasExistingStamp ? existingBy : null;
+        const priorApprovedAt = hasExistingStamp
+            ? (typeof frontmatter[fields.at] === "string" ? frontmatter[fields.at] : null)
+            : null;
+        const priorCount = typeof frontmatter[fields.priors] === "number" ? frontmatter[fields.priors] : 0;
+        const approvedAt = (this.deps.now?.() ?? new Date()).toISOString();
+        // Stage-3 Lever A — plan-lock snapshot: ONLY a slice SPEC approval derives +
+        // co-serializes the `locked-artifacts` set (mission/delivery NEVER create it;
+        // a delivery merge preserves an existing list). PRD read fails open to null.
+        //
+        // B14 — the set must be CHOSEN, not inherited. An explicit `lockedArtifacts`
+        // replaces derivation entirely (validated to exist, slice-relative). Without
+        // it the derived default still applies, but a set that would freeze only a
+        // missing/scaffold PRD refuses loudly: a plan-lock says "THIS artifact set
+        // is what gets built", and two live locks froze placeholder bytes before
+        // this check existed.
+        const isPlanLock = input.scopeTier === "slice" && input.approvalScope === "spec";
+        let lockedArtifacts;
+        if (isPlanLock) {
+            const explicit = Array.isArray(input.lockedArtifacts)
+                ? input.lockedArtifacts.map((p) => String(p).trim()).filter((p) => p.length > 0)
+                : [];
+            if (explicit.length > 0) {
+                lockedArtifacts = resolveExplicitPlanLockArtifacts(explicit, resolved, input.scopePath);
+            }
+            else {
+                const prd = tryReadPRD(resolved);
+                lockedArtifacts = derivePlanLockArtifacts(originalBytes, prd);
+                if (isContentlessPlanLockSet(prd, lockedArtifacts)) {
+                    throw new ScopeApproveError("plan_lock_contentless", `${input.scopePath}: the derived locked-artifacts set is only the default IMPLEMENTATION-PRD.md pin, and that file is ${prd === null ? "missing" : "still unfilled scaffold"} — the lock would freeze content nobody chose.`, {
+                        scopePath: input.scopePath,
+                        action: "Author the PRD (or its README sections) so the plan carries real content, or name the real set explicitly: rig scope slice approve <slice> --scope spec --locked-artifacts \"SPEC.md,PLAN-….md\".",
+                    });
+                }
+            }
+        }
+        // 1. Frontmatter FIRST (the arch-pinned ordering). The stamp AND the
+        // co-serialized `locked-artifacts` land in ONE writeFrontmatterFields +
+        // writeFileSync — so a later audit failure restores a clean verbatim README.
+        const updated = writeFrontmatterFields(originalBytes, {
+            [fields.by]: input.actorSession,
+            [fields.at]: approvedAt,
+            // OPR.0.5.0.18 — amendment lineage in the ONE atomic frontmatter write:
+            // prior-count rides beside the current attestation so the (filesystem-
+            // local) scope audit can show lineage; the rows hold the full history.
+            ...(isReApprove ? { [fields.priors]: priorCount + 1 } : {}),
+            ...(isPlanLock ? { "locked-artifacts": lockedArtifacts } : {}),
+            // P21 era-stamp: a `provenance:` line beside the approved-by stamp records how the approver
+            // identity was established. Present (`transport:v1`) ⇒ transport-derived; absent ⇒ claimed-era.
+            ...(input.identityProvenance ? { provenance: input.identityProvenance } : {}),
+        });
+        fs.writeFileSync(readmePath, updated, "utf8");
+        // 2. Audit SECOND. On failure: byte-restore the prior frontmatter and
+        // fail loudly — a failed audit write can never leave a trusted half-stamp
+        // (QA plan-review guardrail), and no audit row is ever deleted.
+        const scopePathCanonical = path.relative(missionsRoot, resolved).split(path.sep).join("/");
+        const auditNotes = {
+            kind: "scope-approval",
+            scope_tier: input.scopeTier,
+            scope_id: scopeId,
+            scope_path: scopePathCanonical,
+            approval_scope: input.approvalScope,
+            on_behalf_of: input.onBehalfOf ?? null,
+            // OPR.0.5.0.18 — the amendment row makes the supersession explicit
+            // (additive keys; the audit-browse scope filters are untouched). The
+            // provenance triple: authorizer = on_behalf_of, acting agent =
+            // actor_session, reason = the verbatim operator reason.
+            ...(isReApprove
+                ? {
+                    re_approval: true,
+                    reason,
+                    prior_approved_by: priorApprovedBy,
+                    prior_approved_at: priorApprovedAt,
+                    prior_count: priorCount + 1,
+                }
+                : {}),
+        };
+        let actionId;
+        try {
+            const baseReason = input.onBehalfOf
+                ? `scope-approval (${input.approvalScope}) on behalf of ${input.onBehalfOf}`
+                : `scope-approval (${input.approvalScope})`;
+            const entry = this.deps.actionLog.record({
+                actionVerb: "approve",
+                qitemId: null, // scope approvals are NOT qitem actions
+                actorSession: input.actorSession,
+                actedAt: approvedAt,
+                reason: isReApprove ? `${baseReason} re-approve: ${reason}` : baseReason,
+                auditNotes,
+                identityProvenance: input.identityProvenance ?? null,
+            });
+            actionId = entry.actionId;
+        }
+        catch (err) {
+            fs.writeFileSync(readmePath, originalBytes, "utf8");
+            throw new ScopeApproveError("audit_write_failed", `The approval audit row could not be written; the frontmatter stamp was restored to its prior state (no half-stamp). Cause: ${err instanceof Error ? err.message : String(err)}`, { scopePath: input.scopePath, approvalScope: input.approvalScope });
+        }
+        // 3. Freeze-trigger interface cell (Packet 2): the DELIVERY stamp will
+        // synchronously invoke the ONE compose-and-freeze endpoint AFTER this
+        // point. The endpoint does not exist at P1; when it lands, a failed
+        // render never un-approves and never half-stamps — the stamp + audit
+        // row above stand regardless of the render outcome.
+        return {
+            scopeTier: input.scopeTier,
+            scopeId,
+            scopePath: scopePathCanonical,
+            approvalScope: input.approvalScope,
+            approvedBy: input.actorSession,
+            approvedAt,
+            onBehalfOf: input.onBehalfOf ?? null,
+            actionId,
+            freezeFired: false,
+            reApproved: isReApprove,
+            ...(isReApprove && priorApprovedBy !== null
+                ? { priorApprovedBy, priorApprovedAt }
+                : {}),
+        };
+    }
+}
+// ——— frontmatter helpers (daemon-side mirror of the CLI scope-fs shape:
+// hand-rolled split + YAML.parse, safe-by-default per PRD §4 leg 2) ———
+function parseFrontmatter(content) {
+    if (!content.startsWith("---"))
+        return {};
+    const match = /^---\s*\n([\s\S]*?)\n---/.exec(content);
+    if (!match)
+        return {};
+    try {
+        const parsed = YAML.parse(match[1]);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Reads the slice IMPLEMENTATION-PRD.md; returns null on ANY missing/unreadable
+ *  error (never throws) — the plan-lock derivation fails open to a PRD-only set. */
+function tryReadPRD(sliceDir) {
+    try {
+        return fs.readFileSync(path.join(sliceDir, "IMPLEMENTATION-PRD.md"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** B14 — the stamper's explicit plan-lock set: slice-relative, normalized by the SAME rules as the
+ *  derived path (no scheme/absolute/escape), each file verified to EXIST — a chosen set naming a
+ *  missing file is the same defect the explicit path exists to end. Dedup, first wins. */
+function resolveExplicitPlanLockArtifacts(raw, sliceDir, scopePath) {
+    const out = [];
+    const seen = new Set();
+    for (const ref of raw) {
+        if (/^[a-z][a-z0-9+.-]*:/i.test(ref)) {
+            throw new ScopeApproveError("locked_artifact_invalid", `${scopePath}: locked artifact "${ref}" carries a URI scheme — every locked-artifact path is slice-relative.`, { scopePath, ref });
+        }
+        const norm = sliceRelativeMediaPath(ref, "");
+        if (norm === null) {
+            throw new ScopeApproveError("locked_artifact_invalid", `${scopePath}: locked artifact "${ref}" is absolute or escapes the slice directory — every locked-artifact path is slice-relative.`, { scopePath, ref });
+        }
+        if (!fs.existsSync(path.join(sliceDir, norm))) {
+            throw new ScopeApproveError("locked_artifact_missing", `${scopePath}: locked artifact "${norm}" does not exist in the slice directory — a chosen set must name real files.`, { scopePath, ref: norm });
+        }
+        if (seen.has(norm))
+            continue;
+        seen.add(norm);
+        out.push({ name: norm, path: norm, kind: "spec" });
+    }
+    return out;
+}
+/** P15 (WRITER-EXCEEDS-ITS-OWNERSHIP fix, PM-ruled 2026-08-07): the stamp is
+ *  sole-writer of its OWN keys and must byte-preserve every line it does not
+ *  own. The old implementation parsed and RE-SERIALIZED the whole block, so
+ *  stamping invalidated any seal taken over the file — seal-then-lock broke by
+ *  construction. Now: each owned key is serialized alone and spliced in by
+ *  index (replace-in-place when the key exists, append at the block end when
+ *  absent). Unowned bytes — folded scalars, quoting style, ordering — are
+ *  untouched, so stripping exactly the owned lines restores the pre-stamp
+ *  bytes. Index splicing (never String.replace with a dynamic replacement)
+ *  keeps $-metacharacters in values inert. */
+function writeFrontmatterFields(content, fields) {
+    const match = /^---\s*\n([\s\S]*?)\n---/.exec(content);
+    if (!match) {
+        const yaml = YAML.stringify(fields).trimEnd();
+        return `---\n${yaml}\n---\n\n${content}`;
+    }
+    let block = match[1];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined)
+            continue;
+        const rendered = YAML.stringify({ [key]: value }).trimEnd();
+        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // a top-level `key:` line plus its indented continuation lines (nested blocks)
+        const keyRe = new RegExp(`^${escaped}:[^\\n]*(?:\\n[ \\t]+[^\\n]*)*`, "m");
+        const existing = keyRe.exec(block);
+        if (existing) {
+            block = block.slice(0, existing.index) + rendered + block.slice(existing.index + existing[0].length);
+        }
+        else {
+            block = block.length > 0 ? `${block}\n${rendered}` : rendered;
+        }
+    }
+    return content.slice(0, match.index) + `---\n${block}\n---` + content.slice(match.index + match[0].length);
+}
+//# sourceMappingURL=scope-approve.js.map