@openrig/cli 0.4.7 → 0.4.8

package/daemon/dist/domain/rigspec-instantiator.js

@@ -1,6 +1,7 @@
 import nodePath from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { assembleBundle } from "./context-packs/bundle-assembler.js";
+import { resolvePermissionPolicyAttachment, resolvePermissionPolicyRefValue, } from "./permission-policy/policy-ref.js";
 import { deriveCanonicalSessionName, validateSessionComponents } from "./session-name.js";
 import { LegacyRigSpecSchema as RigSpecSchema } from "./rigspec-schema.js"; // TODO: AS-T08b — migrate to pod-aware RigSpec
 import { LegacyRigSpecCodec as RigSpecCodec } from "./rigspec-codec.js"; // TODO: AS-T08b — migrate to pod-aware RigSpec
@@ -277,6 +278,20 @@ export class PodRigInstantiator {
         this.db = deps.db;
         this.deps = deps;
     }
+    inheritedPermissionPolicy(targetRigId) {
+        if (!targetRigId)
+            return undefined;
+        const provenance = this.deps.rigRepo.getRigPolicyProvenance(targetRigId);
+        if (!provenance?.rigRef)
+            return undefined;
+        return {
+            ref: provenance.rigRef,
+            origin: provenance.origin,
+            launchPosture: provenance.launchPosture,
+            ...(provenance.resolvedTarget ? { resolvedTarget: provenance.resolvedTarget } : {}),
+            ...(provenance.declaringDir ? { declaringDir: provenance.declaringDir } : {}),
+        };
+    }
     async materialize(rigSpecYaml, rigRoot, opts) {
         let raw;
         try {
@@ -303,6 +318,7 @@ export class PodRigInstantiator {
             fsOps: this.deps.fsOps,
             rigNameOverride: targetRig?.rig.name,
             externalQualifiedIds: targetRig?.nodes.map((node) => node.logicalId),
+            inheritedPermissionPolicy: this.inheritedPermissionPolicy(opts?.targetRigId),
             exec: this.deps.exec,
         });
         if (!preflight.ready) {
@@ -312,7 +328,7 @@ export class PodRigInstantiator {
         // persistence CORE (createPod + create-node + edges + events, in one tx)
         // takes the already-parsed+validated spec so `expand` and the `add_member`
         // converge op compose it WITHOUT fabricating a synthetic rig spec.
-        return this.materializeValidatedSpec(rigSpec, rigRoot, opts);
+        return this.materializeValidatedSpec(rigSpec, rigRoot, preflight.warnings, opts);
     }
     /**
      * materialize with a STRUCTURED front (OPR.0.3.3.24): the YAML-free sibling of
@@ -342,12 +358,13 @@ export class PodRigInstantiator {
             cwdOverride: opts?.cwdOverride,
             fsOps: this.deps.fsOps,
             rigNameOverride: targetRig?.rig.name,
+            inheritedPermissionPolicy: this.inheritedPermissionPolicy(opts?.targetRigId),
             exec: this.deps.exec,
         });
         if (!preflight.ready) {
             return { ok: false, code: "preflight_failed", errors: preflight.errors, warnings: preflight.warnings };
         }
-        return this.materializeValidatedSpec(rigSpec, rigRoot, opts);
+        return this.materializeValidatedSpec(rigSpec, rigRoot, preflight.warnings, opts);
     }
     /**
      * materialize CORE (OPR.0.3.3.24): the persistence body of materialize, taking
@@ -359,7 +376,7 @@ export class PodRigInstantiator {
      * `add_member` reuse the exact create path — create+launch only, no identity
      * migration.
      */
-    async materializeValidatedSpec(rigSpec, rigRoot, opts) {
+    async materializeValidatedSpec(rigSpec, rigRoot, preflightWarnings, opts) {
         const persistedEvents = [];
         const nodeResults = [];
         try {
@@ -374,6 +391,24 @@ export class PodRigInstantiator {
                 if (rigSpec.workspace) {
                     this.deps.rigRepo.setRigWorkspace(materializedRigId, rigSpec.workspace);
                 }
+                // OPR.0.4.8.3 Seam B: persist the rig-level permission_policy REF (raw, like role) —
+                // this is ONE of TWO rig-persist sites (materializeValidatedSpec + instantiate); missing
+                // either drops the rig ref on that path (map correction, independently verified).
+                // Guard-F1: the RESOLVED rig attachment persists too (declaringDir = THIS rigRoot,
+                // the original declaring RigSpec dir) — restart-complete for organic seats,
+                // add-member under a different root, and successor continuity. STRICT (load-bearing).
+                if (rigSpec.permissionPolicy) {
+                    this.deps.rigRepo.setRigPermissionPolicy(materializedRigId, rigSpec.permissionPolicy);
+                    const rigAttachment = resolvePermissionPolicyAttachment(rigSpec.permissionPolicy, rigRoot, {
+                        readFile: (p) => this.deps.fsOps.readFile(p),
+                    });
+                    this.deps.rigRepo.setRigPolicyProvenance(materializedRigId, {
+                        origin: rigAttachment.origin,
+                        resolvedTarget: rigAttachment.resolvedTarget ?? null,
+                        declaringDir: rigAttachment.origin === "custom" ? rigRoot : null,
+                        launchPosture: rigAttachment.launchPosture,
+                    });
+                }
                 const currentRig = this.deps.rigRepo.getRig(materializedRigId);
                 const logicalIdToNodeId = new Map(currentRig.nodes.map((node) => [node.logicalId, node.id]));
                 const existingPodIds = new Set(currentRig.nodes
@@ -415,6 +450,26 @@ export class PodRigInstantiator {
                             cwdOverride: opts?.cwdOverride,
                         });
                         logicalIdToNodeId.set(qualifiedId, node.id);
+                        // Seam B R2: restart-stable provenance persists AT MATERIALIZE (a
+                        // materialized-but-never-launched seat must still restore its posture).
+                        // R2 HIGH-1: expansion into an EXISTING rig materializes through a SYNTHETIC
+                        // fragment with no rig-level ref — a ref-less member must inherit the
+                        // PERSISTED target-rig attachment (original declaring dir), never lose it.
+                        const materializeAttachment = this.resolveMemberPolicyAttachment(member.permissionPolicy, rigSpec.permissionPolicy, rigRoot);
+                        if (materializeAttachment) {
+                            this.persistNodePolicyProvenanceStrict(node.id, materializeAttachment);
+                        }
+                        else if (opts?.targetRigId) {
+                            const rigProv = this.deps.rigRepo.getRigPolicyProvenance(materializedRigId);
+                            if (rigProv) {
+                                this.deps.rigRepo.setNodePolicyProvenance(node.id, {
+                                    origin: rigProv.origin,
+                                    resolvedTarget: rigProv.resolvedTarget,
+                                    declaringDir: rigProv.declaringDir,
+                                    launchPosture: rigProv.launchPosture,
+                                });
+                            }
+                        }
                         nodeResults.push({ logicalId: qualifiedId, status: "materialized" });
                         persistedEvents.push(event);
                     }
@@ -457,6 +512,7 @@ export class PodRigInstantiator {
                     specName: rigSpec.name,
                     specVersion: rigSpec.version,
                     nodes: nodeResults,
+                    warnings: preflightWarnings,
                 },
             };
         }
@@ -632,6 +688,7 @@ export class PodRigInstantiator {
             cwdOverride: opts?.cwdOverride,
             fsOps: this.deps.fsOps,
             rigNameOverride: rig.rig.name,
+            inheritedPermissionPolicy: this.inheritedPermissionPolicy(rigId),
             exec: this.deps.exec,
         });
         if (!preflight.ready) {
@@ -692,6 +749,28 @@ export class PodRigInstantiator {
             });
             createdNodeId = node.id;
             createdEvent = event;
+            // Seam B Guard-F1: add_member runs under the CURRENT operation's root, which may
+            // differ from the ORIGINAL declaring RigSpec dir. A member OVERRIDE resolves against
+            // this operation's root (it is declared HERE); an INHERITED rig policy must reuse the
+            // PERSISTED rig attachment (original declaring root) — never re-resolve the raw rig
+            // ref against an unrelated root. STRICT persistence (load-bearing).
+            if (member.permissionPolicy) {
+                const memberAttachment = resolvePermissionPolicyAttachment(member.permissionPolicy, rigRoot, {
+                    readFile: (p) => this.deps.fsOps.readFile(p),
+                });
+                this.persistNodePolicyProvenanceStrict(node.id, memberAttachment);
+            }
+            else {
+                const rigProv = this.deps.rigRepo.getRigPolicyProvenance(rigId);
+                if (rigProv) {
+                    this.deps.rigRepo.setNodePolicyProvenance(node.id, {
+                        origin: rigProv.origin,
+                        resolvedTarget: rigProv.resolvedTarget,
+                        declaringDir: rigProv.declaringDir,
+                        launchPosture: rigProv.launchPosture,
+                    });
+                }
+            }
             if (resolvedEdges.length > 0) {
                 const logicalIdToNodeId = new Map(rig.nodes.map((n) => [n.logicalId, n.id]));
                 logicalIdToNodeId.set(qualifiedId, node.id);
@@ -730,7 +809,7 @@ export class PodRigInstantiator {
                     sessionName: launched.sessionName,
                 },
                 edges: resolvedEdges,
-                warnings: launched.warnings,
+                warnings: [...preflight.warnings, ...(launched.warnings ?? [])],
             },
         };
     }
@@ -777,6 +856,21 @@ export class PodRigInstantiator {
             if (rigSpec.workspace) {
                 this.deps.rigRepo.setRigWorkspace(rigId, rigSpec.workspace);
             }
+            // OPR.0.4.8.3 Seam B: the SECOND rig-persist site (bootstrap instantiate path) —
+            // both sites must write or the rig ref silently drops on one instantiate path.
+            // Guard-F1: resolved rig attachment persists here too (declaringDir = rigRoot).
+            if (rigSpec.permissionPolicy) {
+                this.deps.rigRepo.setRigPermissionPolicy(rigId, rigSpec.permissionPolicy);
+                const rigAttachment = resolvePermissionPolicyAttachment(rigSpec.permissionPolicy, rigRoot, {
+                    readFile: (p) => this.deps.fsOps.readFile(p),
+                });
+                this.deps.rigRepo.setRigPolicyProvenance(rigId, {
+                    origin: rigAttachment.origin,
+                    resolvedTarget: rigAttachment.resolvedTarget ?? null,
+                    declaringDir: rigAttachment.origin === "custom" ? rigRoot : null,
+                    launchPosture: rigAttachment.launchPosture,
+                });
+            }
         }
         catch (err) {
             return { ok: false, code: "instantiate_error", message: err.message };
@@ -785,7 +879,7 @@ export class PodRigInstantiator {
         const nodeResults = [];
         const nodeIdMap = {}; // "pod.member" -> node DB id
         const launchedSessionNames = []; // Track for orphan cleanup on total failure
-        const podInstantiateWarnings = [];
+        const podInstantiateWarnings = preflight.warnings;
         // Store per-member context for deferred launch
         const memberContext = new Map();
         // Phase 1: Create all pods and collect member entries
@@ -858,8 +952,7 @@ export class PodRigInstantiator {
                 continue;
             }
             // Create node
-            let nodeId;
-            try {
+            const createUnit = this.db.transaction(() => {
                 const node = this.deps.rigRepo.addNode(rigId, qualifiedId, {
                     // OPR.0.4.6.FAC1 (VM-caught): the pod-aware bootstrap
                     // instantiate-from-YAML path (`rig up <spec>`) creates agent
@@ -874,6 +967,10 @@ export class PodRigInstantiator {
                     runtime: member.runtime,
                     model: member.model,
                     codexConfigProfile: member.codexConfigProfile,
+                    // OPR.0.4.8.3 Seam B: bootstrap inline addNode is the FOURTH node-creation
+                    // site (see the role wire note above) — same member-ref persistence as
+                    // createMemberNode or `rig up <spec>` seats lose their policy ref.
+                    permissionPolicy: member.permissionPolicy,
                     cwd: configResult.config.cwd,
                     restorePolicy: configResult.config.restorePolicy,
                     podId,
@@ -884,7 +981,21 @@ export class PodRigInstantiator {
                     resolvedSpecVersion: configResult.config.resolvedSpecVersion,
                     resolvedSpecHash: configResult.config.resolvedSpecHash,
                 });
-                nodeId = node.id;
+                // Guard multi-seat correction (16e853a7): node creation + required provenance
+                // are ONE ATOMIC UNIT (SQLite savepoint). A setter fault rolls the INSERT back
+                // too — under partial-success semantics the sibling may proceed, but a failed
+                // member can never survive as a half-created node whose restore posture would
+                // widen to the rig attachment. (Previously the row survived with provenance
+                // null, and resolveRestorePosture fell through to rig full_bypass.)
+                const bootstrapAttachment = this.resolveMemberPolicyAttachment(member.permissionPolicy, rigSpec.permissionPolicy, rigRoot);
+                if (bootstrapAttachment)
+                    this.persistNodePolicyProvenanceStrict(node.id, bootstrapAttachment);
+                return node.id;
+            });
+            let nodeId;
+            try {
+                nodeId = createUnit();
+                // nodeIdMap only AFTER the atomic unit succeeds (Guard contract item 2).
                 nodeIdMap[qualifiedId] = nodeId;
             }
             catch (err) {
@@ -1158,6 +1269,9 @@ export class PodRigInstantiator {
             runtime: input.member.runtime,
             model: input.member.model,
             codexConfigProfile: input.member.codexConfigProfile,
+            // OPR.0.4.8.3 Seam B: the member's OWN raw ref persists on the node (like role);
+            // rig-level lives on the rig row; precedence applies at RESOLUTION, not storage.
+            permissionPolicy: input.member.permissionPolicy,
             cwd: effectiveCwd,
             restorePolicy: input.member.restorePolicy,
             podId: input.podId,
@@ -1187,6 +1301,40 @@ export class PodRigInstantiator {
             ? this.launchExistingTerminalMember(input)
             : this.launchExistingAgentMember(input);
     }
+    /**
+     * OPR.0.4.8.3 Seam B — the ONE precedence + resolution point for a seat's permission
+     * policy at launch: member ref > rig ref > absent (undefined = the env-driven floor).
+     * Custom refs resolve relative to the rig root (the declaring RigSpec's directory in a
+     * materialized rig). Returns undefined when no ref is attached at either level.
+     */
+    resolveMemberPolicyAttachment(memberRef, rigRef, rigRoot) {
+        const ref = resolvePermissionPolicyRefValue(memberRef, rigRef);
+        if (!ref)
+            return undefined;
+        return resolvePermissionPolicyAttachment(ref, rigRoot, {
+            readFile: (p) => this.deps.fsOps.readFile(p),
+        });
+    }
+    /** Seam B Guard-F2: the STRICT materialize/add-member persist — provenance here is
+     *  LOAD-BEARING restart state; a real write failure must fail the surrounding
+     *  transaction, never commit a node without it. (The repository setter itself still
+     *  no-ops on pre-057 legacy fixture DBs — that narrow compatibility is preserved.) */
+    persistNodePolicyProvenanceStrict(nodeId, attachment) {
+        this.deps.rigRepo.setNodePolicyProvenance(nodeId, {
+            origin: attachment.origin,
+            resolvedTarget: attachment.resolvedTarget ?? null,
+            declaringDir: attachment.declaringDir ?? null,
+            launchPosture: attachment.launchPosture,
+        });
+    }
+    /** Seam B: the LAUNCH-time refresh stays best-effort (idempotent re-write on an already-
+     *  materialized node; a transient failure must not block a launch). */
+    persistNodePolicyProvenance(nodeId, attachment) {
+        try {
+            this.persistNodePolicyProvenanceStrict(nodeId, attachment);
+        }
+        catch { /* best-effort on launch refresh only */ }
+    }
     async launchExistingAgentMember(input) {
         const resolveResult = input.resolveResult ?? resolveAgentRef(input.member.agentRef, input.rigRoot, this.deps.fsOps);
         if (!resolveResult.ok) {
@@ -1210,6 +1358,24 @@ export class PodRigInstantiator {
             return { status: "failed", error: configResult.errors.join("; ") };
         }
         this.updateNodeResolvedConfig(input.nodeId, configResult.config);
+        // OPR.0.4.8.3 Seam B: resolve the seat's permission-policy attachment once for this
+        // launch (member > rig precedence; declaring dir = the rig root, where the declaring
+        // RigSpec + its relative policy files live). Also persists restart-stable provenance.
+        // R2 HIGH-1: the LIVE binding must AGREE with persisted provenance — structured
+        // add-member/expansion launch with a SYNTHETIC minimal spec (no rig-level ref), so
+        // when the in-memory spec resolves nothing, the PERSISTED node provenance (written in
+        // the creation tx) and then the PERSISTED rig attachment are the binding's truth.
+        const policyAttachment = this.resolveMemberPolicyAttachment(input.member.permissionPolicy, input.rigSpec.permissionPolicy, input.rigRoot);
+        if (policyAttachment)
+            this.persistNodePolicyProvenance(input.nodeId, policyAttachment);
+        // R2 terminal (954d97a0): TRUE ABSENCE binds the locked MINIMUM FLOOR explicitly
+        // (README v4 "DEFAULT IF NONE ATTACHED = the minimum floor"; FINAL2) — ambient
+        // OPENRIG_YOLO must never widen a seat with no attachment. Absence stays honest
+        // (no fabricated attachment/provenance); only the lifecycle BINDING is explicit.
+        const launchPosture = policyAttachment?.launchPosture
+            ?? this.deps.rigRepo.getNodePolicyProvenance(input.nodeId)?.launchPosture
+            ?? this.deps.rigRepo.getRigPolicyProvenance(input.rigId)?.launchPosture
+            ?? "floor";
         const sessionNameErrors = validateSessionComponents(input.pod.id, input.member.id, input.rigSpec.name);
         if (sessionNameErrors.length > 0) {
             return { status: "failed", error: sessionNameErrors.join("; ") };
@@ -1256,6 +1422,9 @@ export class PodRigInstantiator {
             cwd: configResult.config.cwd,
             model: configResult.config.model,
             codexConfigProfile: input.member.codexConfigProfile,
+            // OPR.0.4.8.3 Seam B: resolved launch posture (member > rig > persisted > FLOOR)
+            // binds per-seat explicitly; adapters thread it into the yolo-mode helpers.
+            launchPosture,
         };
         // session_source dispatch: fork (native runtime fork) vs rebuild (artifact-
         // injected fresh launch) vs agent_image (PL-016 Item 4: dispatch through
@@ -1418,6 +1587,13 @@ export class PodRigInstantiator {
     }
     async launchExistingTerminalMember(input) {
         const effectiveCwd = resolveLaunchCwd(input.member.cwd, input.rigRoot, input.cwdOverride);
+        const terminalPolicyAttachment = this.resolveMemberPolicyAttachment(input.member.permissionPolicy, input.rigSpec.permissionPolicy, input.rigRoot);
+        if (terminalPolicyAttachment)
+            this.persistNodePolicyProvenance(input.nodeId, terminalPolicyAttachment);
+        const terminalLaunchPosture = terminalPolicyAttachment?.launchPosture
+            ?? this.deps.rigRepo.getNodePolicyProvenance(input.nodeId)?.launchPosture
+            ?? this.deps.rigRepo.getRigPolicyProvenance(input.rigId)?.launchPosture
+            ?? "floor"; // R2 terminal: absence = the locked floor, explicitly
         const sessionNameErrors = validateSessionComponents(input.pod.id, input.member.id, input.rigSpec.name);
         if (sessionNameErrors.length > 0) {
             return { status: "failed", error: sessionNameErrors.join("; ") };
@@ -1457,6 +1633,9 @@ export class PodRigInstantiator {
             cmuxSurface: null,
             updatedAt: "",
             cwd: effectiveCwd,
+            // Seam B: a terminal seat has no harness posture flag, but the resolved/persisted
+            // posture (floor when absent) still binds for provenance-consuming consumers.
+            launchPosture: terminalLaunchPosture,
         };
         const adapter = this.deps.adapters["terminal"];
         if (!adapter) {