oh-my-super-agent 0.1.0

package/dist/src/goals/authority.js

@@ -0,0 +1,621 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { assertActorId, assertOpaqueId, assertRecordId, assertTransitionNonce, recordFileName, } from "../domain/records.js";
+import { findPackageRoot } from "../package-root.js";
+import { acquireDirectoryLock } from "../runtime/lock.js";
+import { createRecordStore } from "../runtime/record-store.js";
+import { assertSchema, loadJsonSchema } from "../runtime/schema.js";
+import { createStableId } from "../runtime/stable-id.js";
+import { assertTeamCheckpointProjection, projectReadOnlyTeamState } from "../team/projection.js";
+import { validateExistingDirectory } from "../utils/fs.js";
+import { assertGoalArtifactStore, } from "./artifact-store.js";
+import { assertNativeGoalSnapshot, parseNativeGoalSnapshot } from "./native-snapshot.js";
+const GOAL_AUTHORITIES = new WeakMap();
+const GOAL_PLAN_GATES = new WeakMap();
+export function createGoalAuthority(options) {
+    const artifactStore = options.artifactStore;
+    assertGoalArtifactStore(artifactStore);
+    const packageRoot = options.packageRoot ?? findPackageRoot();
+    const recordsRoot = validateExistingDirectory(options.recordsRoot, "goal records root");
+    const locksRoot = validateExistingDirectory(options.locksRoot, "goal locks root");
+    const payloadSchema = loadJsonSchema(join(packageRoot, "schemas", "goal-payload.schema.json"));
+    const store = createRecordStore({
+        recordsRoot,
+        locksRoot,
+        recordValidator: (record) => validateGoalRecord(record, payloadSchema, artifactStore),
+        transitionValidator: validateGoalTransition,
+    });
+    const facade = Object.freeze({
+        read(goalId) {
+            return freezeGoal(store.read(assertRecordId(goalId, "goal id")));
+        },
+    });
+    GOAL_AUTHORITIES.set(facade, { store, artifacts: artifactStore, packageRoot, recordsRoot, locksRoot });
+    return facade;
+}
+export function assertGoalAuthority(value) {
+    if (typeof value !== "object" || value === null || !GOAL_AUTHORITIES.has(value)) {
+        throw new Error("goal operation requires a real branded OMS GoalAuthority");
+    }
+}
+export function createGoal(authority, input) {
+    return createGoalWithReplay(authority, input).goal;
+}
+export function createGoalWithReplay(authority, input) {
+    const internals = internalsFor(authority);
+    const objective = assertText(input.objective, "goal objective");
+    const stoppingCondition = assertText(input.stoppingCondition, "goal stopping condition");
+    const repositoryScope = assertText(input.repositoryScope, "goal repository scope");
+    const queueScope = assertText(input.queueScope ?? "default", "goal queue scope");
+    const runtimeHorizon = assertRuntimeHorizon(input.runtimeHorizon ?? "until-empty");
+    const budgetProfile = assertBudgetProfile(input.budgetProfile ?? "subscription-only");
+    const policyProfile = assertPolicyProfile(input.policyProfile ?? "default");
+    const leader = assertActorId(input.leaderId, "goal leader id");
+    timestampEpoch(input.createdAt, "goal created_at");
+    const creationNonce = assertTransitionNonce(input.creationNonce ?? createStableId("goal-create", objective, repositoryScope, queueScope, stoppingCondition, runtimeHorizon, budgetProfile, policyProfile));
+    const goalId = goalIdentity({
+        objective,
+        repositoryScope,
+        queueScope,
+        stoppingCondition,
+        runtimeHorizon,
+        budgetProfile,
+        policyProfile,
+        creationNonce,
+    });
+    const nonce = creationNonce;
+    const record = {
+        schema_version: 1,
+        record_id: assertRecordId(goalId),
+        record_kind: assertOpaqueId("oms-goal", "goal record kind"),
+        version: 0,
+        state: "active",
+        attempt: 1,
+        max_attempts: 1,
+        actor: leader,
+        lease_token: null,
+        transition_nonce: nonce,
+        payload: {
+            goal_id: goalId,
+            objective,
+            repository_scope: repositoryScope,
+            queue_scope: queueScope,
+            stopping_condition: stoppingCondition,
+            runtime_horizon: runtimeHorizon,
+            budget_profile: budgetProfile,
+            policy_profile: policyProfile,
+            creation_nonce: creationNonce,
+            created_at: input.createdAt,
+            updated_at: input.createdAt,
+            native_snapshot: null,
+            team_checkpoint: null,
+            ultragoal_checkpoint: null,
+            regression_request: null,
+            park_reason: null,
+        },
+        transition_outcomes: [{
+                nonce,
+                version: 0,
+                state: "active",
+                attempt: 1,
+                actor: leader,
+                lease_token: null,
+            }],
+    };
+    const lock = acquireDirectoryLock({
+        locksRoot: internals.locksRoot,
+        lockId: "goal-authority-create",
+        ownerId: leader,
+        note: `create:${creationNonce}`,
+    });
+    try {
+        const existing = internals.store.list();
+        const nonceMatch = existing.find((candidate) => candidate.payload.creation_nonce === creationNonce);
+        if (nonceMatch) {
+            if (nonceMatch.actor !== leader || !sameGoalCreationPayload(nonceMatch.payload, record.payload)) {
+                throw new Error("goal creation nonce already exists with different authority or payload");
+            }
+            return Object.freeze({ status: "replayed", goal: freezeGoal(nonceMatch) });
+        }
+        const active = existing.filter((candidate) => candidate.state === "active");
+        if (active.length > 1)
+            throw new Error("goal authority contains multiple active goals");
+        if (active.length === 1)
+            throw new Error("goal authority already has an active goal with a different creation nonce");
+        return Object.freeze({ status: "created", goal: freezeGoal(internals.store.create(record)) });
+    }
+    finally {
+        lock.release();
+    }
+}
+export function readGoal(authority, goalId) {
+    assertGoalAuthority(authority);
+    return authority.read(goalId);
+}
+export function issueActiveGoalPlanGate(authority, goalId) {
+    const internals = internalsFor(authority);
+    const current = readMutableGoal(internals, goalId);
+    if (current.state !== "active")
+        throw new Error(`GoalPlanGate requires an active goal: ${current.record_id}`);
+    const gate = Object.freeze(goalPlanBinding(internals, current));
+    GOAL_PLAN_GATES.set(gate, Object.freeze({ authority, binding: gate }));
+    return gate;
+}
+export function assertGoalPlanGate(value) {
+    if (typeof value !== "object" || value === null || !GOAL_PLAN_GATES.has(value)) {
+        throw new Error("Team planning requires a real GoalAuthority-issued GoalPlanGate");
+    }
+    if (!Object.isFrozen(value))
+        throw new Error("GoalPlanGate lost its frozen authority boundary");
+}
+export function assertFreshGoalPlanGate(gate) {
+    assertGoalPlanGate(gate);
+    const metadata = GOAL_PLAN_GATES.get(gate);
+    if (!metadata)
+        throw new Error("GoalPlanGate metadata is unavailable");
+    if (!sameGoalPlanBinding(gate, metadata.binding))
+        throw new Error("GoalPlanGate binding changed after issuance");
+    const internals = internalsFor(metadata.authority);
+    const current = readMutableGoal(internals, metadata.binding.goal_id);
+    if (current.state !== "active")
+        throw new Error(`stale GoalPlanGate: canonical goal is ${current.state}`);
+    if (!sameGoalPlanBinding(goalPlanBinding(internals, current), metadata.binding)) {
+        throw new Error("stale GoalPlanGate: canonical goal version or identity changed");
+    }
+}
+export function recordNativeGoalSnapshot(options) {
+    const internals = internalsFor(options.authority);
+    const current = readMutableGoal(internals, options.goalId);
+    if (current.state !== "active")
+        throw new Error(`native snapshot cannot attach while goal is ${current.state}`);
+    const observedAt = timestampEpoch(options.observedAt, "native snapshot observed_at");
+    const snapshot = parseNativeGoalSnapshot(options.snapshot, internals.packageRoot);
+    assertNativeGoalSnapshot(snapshot);
+    const capturedAt = timestampEpoch(snapshot.captured_at, "native snapshot captured_at");
+    if (observedAt < capturedAt)
+        throw new Error("native snapshot observation predates capture");
+    const artifact = writeNativeSnapshot(internals.artifacts, current, snapshot);
+    const identityMismatch = snapshot.native_goal_id !== current.record_id
+        || snapshot.objective !== current.payload.objective
+        || snapshot.stopping_condition !== current.payload.stopping_condition;
+    if (identityMismatch) {
+        return parkWithRegression(internals, current, {
+            reason: "native-goal-mismatch",
+            requestedAt: options.observedAt,
+            sources: [artifact.ref],
+            predicate: null,
+        });
+    }
+    let stale = capturedAt <= timestampEpoch(current.payload.updated_at, "goal updated_at");
+    if (current.payload.native_snapshot) {
+        const previous = internals.artifacts.read(current.payload.native_snapshot);
+        stale ||= Number(snapshot.snapshot_version) <= Number(previous.payload.snapshot_version);
+    }
+    if (stale) {
+        return parkWithRegression(internals, current, {
+            reason: "stale-native-snapshot",
+            requestedAt: options.observedAt,
+            sources: [artifact.ref],
+            predicate: null,
+        });
+    }
+    const result = transitionGoal(internals, current, "active", createStableId("native-attach", current.record_id, artifact.ref.artifact_id), {
+        ...current.payload,
+        updated_at: options.observedAt,
+        native_snapshot: artifact.ref,
+    });
+    return Object.freeze({ status: "attached", goal: freezeGoal(result), artifact: artifact.ref });
+}
+export function recordTeamCheckpoint(options) {
+    const internals = internalsFor(options.authority);
+    const current = readMutableGoal(internals, options.goalId);
+    if (current.state !== "active")
+        throw new Error(`Team checkpoint cannot attach while goal is ${current.state}`);
+    const projection = projectReadOnlyTeamState(options.teamState, internals.packageRoot);
+    assertTeamCheckpointProjection(projection);
+    if (projection.goal_id !== current.record_id)
+        throw new Error("Team checkpoint belongs to a different goal");
+    const completedAt = timestampEpoch(projection.delivery_wave.completed_at, "Team delivery completed_at");
+    const goalUpdatedAt = timestampEpoch(current.payload.updated_at, "goal updated_at");
+    if (completedAt <= goalUpdatedAt) {
+        throw new Error("stale Team checkpoint");
+    }
+    if (current.payload.team_checkpoint)
+        throw new Error("goal already has a different Team checkpoint");
+    const artifact = writeTeamArtifact(internals.artifacts, current.record_id, projection);
+    const result = transitionGoal(internals, current, "active", createStableId("team-attach", current.record_id, artifact.ref.artifact_id), {
+        ...current.payload,
+        updated_at: projection.delivery_wave.completed_at,
+        team_checkpoint: artifact.ref,
+    });
+    return Object.freeze({ status: "attached", goal: freezeGoal(result), artifact: artifact.ref });
+}
+export function recordBrokenGoalPredicate(options) {
+    const internals = internalsFor(options.authority);
+    const current = readMutableGoal(internals, options.goalId);
+    if (current.state !== "active" && current.state !== "completed") {
+        throw new Error(`predicate failure cannot park goal while ${current.state}`);
+    }
+    assertRecordId(options.predicateId, "predicate id");
+    assertSha256(options.expectedSha256, "predicate expected digest");
+    assertSha256(options.actualSha256, "predicate actual digest");
+    if (options.expectedSha256 === options.actualSha256)
+        throw new Error("predicate result did not fail");
+    requireNewerTimestamp(options.observedAt, current.payload.updated_at, "predicate observed_at");
+    return parkWithRegression(internals, current, {
+        reason: "predicate-failed",
+        requestedAt: options.observedAt,
+        sources: [],
+        predicate: {
+            predicate_id: options.predicateId,
+            expected_sha256: options.expectedSha256,
+            actual_sha256: options.actualSha256,
+        },
+    });
+}
+export function checkpointUltragoal(options) {
+    const internals = internalsFor(options.authority);
+    const current = readMutableGoal(internals, options.goalId);
+    const leader = assertActorId(options.leaderId, "Ultragoal leader id");
+    if (leader !== current.actor)
+        throw new Error("only the canonical goal leader may checkpoint Ultragoal");
+    if (current.state !== "active")
+        throw new Error(`Ultragoal cannot checkpoint while goal is ${current.state}`);
+    requireNewerTimestamp(options.checkpointedAt, current.payload.updated_at, "Ultragoal checkpointed_at");
+    if (!current.payload.native_snapshot
+        || !current.payload.team_checkpoint
+        || !sameReference(options.nativeSnapshot, current.payload.native_snapshot)
+        || !sameReference(options.teamCheckpoint, current.payload.team_checkpoint)) {
+        const sources = [];
+        if (current.payload.native_snapshot)
+            sources.push(current.payload.native_snapshot);
+        if (current.payload.team_checkpoint)
+            sources.push(current.payload.team_checkpoint);
+        return parkWithRegression(internals, current, {
+            reason: "ultragoal-mismatch",
+            requestedAt: options.checkpointedAt,
+            sources,
+            predicate: null,
+        });
+    }
+    const native = internals.artifacts.read(current.payload.native_snapshot);
+    const team = internals.artifacts.read(current.payload.team_checkpoint);
+    const nativeCapturedAt = timestampEpoch(String(native.payload.captured_at), "native snapshot captured_at");
+    const deliveryCompletedAt = timestampEpoch(String(team.payload.delivery_wave.completed_at), "Team delivery completed_at");
+    const invalid = native.artifact_kind !== "native-goal-snapshot"
+        || team.artifact_kind !== "team-checkpoint"
+        || native.payload.status !== "complete"
+        || native.payload.terminal !== true
+        || native.payload.native_goal_id !== current.record_id
+        || native.payload.objective !== current.payload.objective
+        || native.payload.stopping_condition !== current.payload.stopping_condition
+        || nativeCapturedAt <= deliveryCompletedAt;
+    if (invalid) {
+        return parkWithRegression(internals, current, {
+            reason: "ultragoal-mismatch",
+            requestedAt: options.checkpointedAt,
+            sources: [current.payload.native_snapshot, current.payload.team_checkpoint],
+            predicate: null,
+        });
+    }
+    const artifact = writeUltragoalArtifact(internals.artifacts, current, options);
+    const result = transitionGoal(internals, current, "completed", createStableId("goal-complete", current.record_id, artifact.ref.artifact_id), {
+        ...current.payload,
+        updated_at: options.checkpointedAt,
+        ultragoal_checkpoint: artifact.ref,
+        regression_request: null,
+        park_reason: null,
+    });
+    return Object.freeze({ status: "completed", goal: freezeGoal(result), artifact: artifact.ref });
+}
+function writeNativeSnapshot(artifacts, goal, snapshot) {
+    const artifactId = createStableId("native-goal", goal.record_id, String(snapshot.snapshot_version), snapshot.captured_at);
+    return artifacts.write({
+        schema_version: 1,
+        artifact_id: artifactId,
+        artifact_kind: "native-goal-snapshot",
+        goal_id: goal.record_id,
+        producer: "codex-get-goal",
+        created_at: snapshot.captured_at,
+        payload: snapshot,
+    });
+}
+function writeTeamArtifact(artifacts, goalId, projection) {
+    const artifactId = createStableId("team-check", goalId, projection.delivery_wave.wave_id, projection.test_sha256);
+    return artifacts.write({
+        schema_version: 1,
+        artifact_id: artifactId,
+        artifact_kind: "team-checkpoint",
+        goal_id: goalId,
+        producer: "oms-team-projection",
+        created_at: projection.delivery_wave.completed_at,
+        payload: projection,
+    });
+}
+function writeUltragoalArtifact(artifacts, goal, options) {
+    const artifactId = createStableId("ultragoal", goal.record_id, options.nativeSnapshot.sha256, options.teamCheckpoint.sha256);
+    return artifacts.write({
+        schema_version: 1,
+        artifact_id: artifactId,
+        artifact_kind: "ultragoal-checkpoint",
+        goal_id: goal.record_id,
+        producer: "oms-ultragoal-leader",
+        created_at: options.checkpointedAt,
+        payload: {
+            schema_version: 1,
+            goal_id: goal.record_id,
+            leader_id: options.leaderId,
+            checkpointed_at: options.checkpointedAt,
+            native_snapshot: options.nativeSnapshot,
+            team_checkpoint: options.teamCheckpoint,
+            objective_sha256: sha256(goal.payload.objective),
+            stopping_condition_sha256: sha256(goal.payload.stopping_condition),
+            terminal: true,
+        },
+    });
+}
+function parkWithRegression(internals, current, input) {
+    requireNewerTimestamp(input.requestedAt, current.payload.updated_at, "regression requested_at");
+    const sourceArtifacts = [...input.sources].sort(compareReferences);
+    const artifactId = createStableId("regression", current.record_id, input.reason, input.requestedAt, JSON.stringify(sourceArtifacts), JSON.stringify(input.predicate));
+    const regression = internals.artifacts.write({
+        schema_version: 1,
+        artifact_id: artifactId,
+        artifact_kind: "regression-request",
+        goal_id: current.record_id,
+        producer: "oms-goal-authority",
+        created_at: input.requestedAt,
+        payload: {
+            schema_version: 1,
+            goal_id: current.record_id,
+            reason: input.reason,
+            objective: current.payload.objective,
+            stopping_condition: current.payload.stopping_condition,
+            requested_at: input.requestedAt,
+            source_artifacts: sourceArtifacts,
+            predicate: input.predicate,
+            disposition: "queue-request-only",
+        },
+    });
+    const goal = transitionGoal(internals, current, "parked", createStableId("goal-park", current.record_id, regression.ref.artifact_id), {
+        ...current.payload,
+        updated_at: input.requestedAt,
+        regression_request: regression.ref,
+        park_reason: input.reason,
+    });
+    return Object.freeze({ status: "parked", goal: freezeGoal(goal), regression: regression.ref });
+}
+function transitionGoal(internals, current, toState, nonce, payload) {
+    return internals.store.transition({
+        recordId: current.record_id,
+        ownerId: current.actor,
+        expectedVersion: current.version,
+        nonce,
+        expectedActor: current.actor,
+        expectedAttempt: 1,
+        expectedLeaseToken: null,
+        fromStates: [current.state],
+        toState,
+        updatePayload: () => payload,
+    }).record;
+}
+function validateGoalRecord(raw, payloadSchema, artifacts) {
+    if (raw.record_kind !== "oms-goal")
+        throw new Error("goal authority accepts only oms-goal records");
+    if (raw.attempt !== 1 || raw.max_attempts !== 1 || raw.lease_token !== null) {
+        throw new Error("goal lifecycle does not use ticket attempts or leases");
+    }
+    assertSchema(raw.payload, payloadSchema, "canonical goal payload");
+    const record = raw;
+    if (record.payload.goal_id !== record.record_id)
+        throw new Error("goal payload id mismatch");
+    assertText(record.payload.objective, "goal objective");
+    assertText(record.payload.repository_scope, "goal repository scope");
+    assertText(record.payload.queue_scope, "goal queue scope");
+    assertText(record.payload.stopping_condition, "goal stopping condition");
+    assertRuntimeHorizon(record.payload.runtime_horizon);
+    assertBudgetProfile(record.payload.budget_profile);
+    assertPolicyProfile(record.payload.policy_profile);
+    assertTransitionNonce(record.payload.creation_nonce, "goal creation nonce");
+    if (record.record_id !== goalIdentity({
+        objective: record.payload.objective,
+        repositoryScope: record.payload.repository_scope,
+        queueScope: record.payload.queue_scope,
+        stoppingCondition: record.payload.stopping_condition,
+        runtimeHorizon: record.payload.runtime_horizon,
+        budgetProfile: record.payload.budget_profile,
+        policyProfile: record.payload.policy_profile,
+        creationNonce: record.payload.creation_nonce,
+    })) {
+        throw new Error("canonical goal objective and stopping condition, scope, profiles, and nonce do not match goal identity");
+    }
+    const createdAt = timestampEpoch(record.payload.created_at, "goal created_at");
+    const updatedAt = timestampEpoch(record.payload.updated_at, "goal updated_at");
+    if (updatedAt < createdAt)
+        throw new Error("goal updated_at predates creation");
+    if (!["active", "parked", "completed"].includes(record.state))
+        throw new Error("invalid goal state");
+    const native = validateGoalArtifact(record.payload.native_snapshot, "native-goal-snapshot", record.record_id, artifacts);
+    const team = validateGoalArtifact(record.payload.team_checkpoint, "team-checkpoint", record.record_id, artifacts);
+    const ultragoal = validateGoalArtifact(record.payload.ultragoal_checkpoint, "ultragoal-checkpoint", record.record_id, artifacts);
+    const regression = validateGoalArtifact(record.payload.regression_request, "regression-request", record.record_id, artifacts);
+    if (record.state !== "parked" && native && (native.payload.native_goal_id !== record.record_id
+        || native.payload.objective !== record.payload.objective
+        || native.payload.stopping_condition !== record.payload.stopping_condition)) {
+        throw new Error("active goal native snapshot does not match canonical identity");
+    }
+    if (team && team.payload.goal_id !== record.record_id)
+        throw new Error("goal Team checkpoint identity mismatch");
+    if (regression && (regression.payload.objective !== record.payload.objective
+        || regression.payload.stopping_condition !== record.payload.stopping_condition)) {
+        throw new Error("goal regression request changed canonical objective");
+    }
+    if (record.state === "active" && (record.payload.park_reason !== null || regression !== undefined || record.payload.ultragoal_checkpoint !== null)) {
+        throw new Error("active goal contains terminal or regression authority");
+    }
+    if (record.state === "parked") {
+        if (!record.payload.park_reason || !regression)
+            throw new Error("parked goal requires a typed regression request");
+        if (regression.payload.reason !== record.payload.park_reason)
+            throw new Error("parked goal reason does not match regression request");
+    }
+    if (record.state === "completed") {
+        if (!record.payload.ultragoal_checkpoint || !ultragoal || !record.payload.native_snapshot || !record.payload.team_checkpoint
+            || record.payload.park_reason !== null || regression !== undefined) {
+            throw new Error("completed goal requires only terminal Ultragoal authority");
+        }
+        if (!sameReference(ultragoal.payload.native_snapshot, record.payload.native_snapshot)
+            || !sameReference(ultragoal.payload.team_checkpoint, record.payload.team_checkpoint)
+            || ultragoal.payload.leader_id !== record.actor
+            || ultragoal.payload.objective_sha256 !== sha256(record.payload.objective)
+            || ultragoal.payload.stopping_condition_sha256 !== sha256(record.payload.stopping_condition)) {
+            throw new Error("completed goal Ultragoal checkpoint does not bind canonical authority");
+        }
+    }
+}
+function validateGoalTransition(currentRaw, nextRaw) {
+    const current = currentRaw;
+    const next = nextRaw;
+    if (next.record_id !== current.record_id
+        || next.record_kind !== current.record_kind
+        || next.actor !== current.actor
+        || next.payload.goal_id !== current.payload.goal_id
+        || next.payload.objective !== current.payload.objective
+        || next.payload.repository_scope !== current.payload.repository_scope
+        || next.payload.queue_scope !== current.payload.queue_scope
+        || next.payload.stopping_condition !== current.payload.stopping_condition
+        || next.payload.runtime_horizon !== current.payload.runtime_horizon
+        || next.payload.budget_profile !== current.payload.budget_profile
+        || next.payload.policy_profile !== current.payload.policy_profile
+        || next.payload.creation_nonce !== current.payload.creation_nonce
+        || next.payload.created_at !== current.payload.created_at) {
+        throw new Error("canonical goal identity, objective, and stopping condition are immutable");
+    }
+    if (timestampEpoch(next.payload.updated_at, "next goal updated_at") < timestampEpoch(current.payload.updated_at, "goal updated_at")) {
+        throw new Error("goal updated_at cannot move backwards");
+    }
+    const allowed = {
+        active: ["active", "parked", "completed"],
+        parked: ["parked"],
+        completed: ["completed", "parked"],
+    };
+    if (!allowed[current.state].includes(next.state))
+        throw new Error(`illegal goal transition ${current.state} -> ${next.state}`);
+}
+function validateGoalArtifact(reference, kind, goalId, artifacts) {
+    if (reference === null)
+        return undefined;
+    if (reference.kind !== kind)
+        throw new Error(`goal artifact must be ${kind}`);
+    const artifact = artifacts.read(reference);
+    if (artifact.goal_id !== goalId || artifact.artifact_kind !== kind)
+        throw new Error("goal artifact authority mismatch");
+    return artifact;
+}
+function readMutableGoal(internals, goalId) {
+    return internals.store.read(assertRecordId(goalId, "goal id"));
+}
+function goalPlanBinding(internals, goal) {
+    return {
+        goal_id: goal.record_id,
+        goal_version: goal.version,
+        goal_state: "active",
+        objective_sha256: sha256(goal.payload.objective),
+        stopping_condition_sha256: sha256(goal.payload.stopping_condition),
+        goal_record_path: join(internals.recordsRoot, recordFileName(goal.record_id)),
+    };
+}
+function sameGoalPlanBinding(left, right) {
+    return left.goal_id === right.goal_id
+        && left.goal_version === right.goal_version
+        && left.goal_state === right.goal_state
+        && left.objective_sha256 === right.objective_sha256
+        && left.stopping_condition_sha256 === right.stopping_condition_sha256
+        && left.goal_record_path === right.goal_record_path;
+}
+function internalsFor(authority) {
+    assertGoalAuthority(authority);
+    const internals = GOAL_AUTHORITIES.get(authority);
+    if (!internals)
+        throw new Error("goal authority internals are unavailable");
+    return internals;
+}
+function freezeGoal(record) {
+    return deepFreeze(structuredClone(record));
+}
+function sameReference(left, right) {
+    return left.kind === right.kind
+        && left.artifact_id === right.artifact_id
+        && left.sha256 === right.sha256
+        && left.file_name === right.file_name;
+}
+function compareReferences(left, right) {
+    return compareText(left.artifact_id, right.artifact_id)
+        || compareText(left.sha256, right.sha256)
+        || compareText(left.file_name, right.file_name);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function requireNewerTimestamp(next, current, label) {
+    const nextEpoch = timestampEpoch(next, label);
+    if (nextEpoch <= timestampEpoch(current, "goal updated_at"))
+        throw new Error(`${label} is stale`);
+    return nextEpoch;
+}
+function timestampEpoch(value, label) {
+    const epoch = Date.parse(value);
+    const normalized = value.includes(".") ? value : value.replace("Z", ".000Z");
+    if (!Number.isFinite(epoch) || new Date(epoch).toISOString() !== normalized)
+        throw new Error(`${label} is invalid`);
+    return epoch;
+}
+function assertText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`${label} must not be blank`);
+    return value;
+}
+function assertRuntimeHorizon(value) {
+    if (value !== "until-empty" && value !== "12h" && value !== "24h")
+        throw new Error("goal runtime horizon is invalid");
+    return value;
+}
+function assertBudgetProfile(value) {
+    if (value !== "subscription-only")
+        throw new Error("goal budget profile is invalid");
+    return value;
+}
+function assertPolicyProfile(value) {
+    if (value !== "default")
+        throw new Error("goal policy profile is invalid");
+    return value;
+}
+function goalIdentity(input) {
+    return createStableId("goal", input.objective, input.repositoryScope, input.queueScope, input.stoppingCondition, input.runtimeHorizon, input.budgetProfile, input.policyProfile, input.creationNonce);
+}
+function sameGoalCreationPayload(left, right) {
+    return left.objective === right.objective
+        && left.repository_scope === right.repository_scope
+        && left.queue_scope === right.queue_scope
+        && left.stopping_condition === right.stopping_condition
+        && left.runtime_horizon === right.runtime_horizon
+        && left.budget_profile === right.budget_profile
+        && left.policy_profile === right.policy_profile
+        && left.creation_nonce === right.creation_nonce;
+}
+function assertSha256(value, label) {
+    if (!/^[a-f0-9]{64}$/.test(value))
+        throw new Error(`${label} is invalid`);
+    return value;
+}
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}
+//# sourceMappingURL=authority.js.map