worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/protocol/index.js

@@ -0,0 +1,215 @@
+import { Schema as S } from "effect";
+const text = S.String.check(S.isMinLength(1));
+const optional = S.optionalKey;
+export const Actor = S.Struct({
+    id: text,
+    kind: S.Literals(["human", "agent", "service", "connector"]),
+    groups: optional(S.Array(text)),
+});
+export const Scalar = S.Union([S.String, S.Number, S.Boolean]);
+export const Facts = S.Record(S.String, S.Union([Scalar, S.Null]));
+const Values = S.Record(S.String, Scalar);
+export const SignatureInput = S.Struct({
+    consent: S.Boolean,
+    intent: S.Boolean,
+    method: text,
+    device: text,
+});
+export const Draft = S.Union([
+    S.Struct({ kind: S.Literal("assert"), values: Facts, factKind: optional(text) }),
+    S.Struct({
+        kind: S.Literal("evidence"),
+        operation: text,
+        values: Values,
+        instance: optional(text),
+    }),
+]);
+export const Proposal = S.Struct({
+    id: text,
+    type: text,
+    subject: text,
+    by: Actor,
+    at: text,
+    rationale: text,
+    draft: Draft,
+    state: S.Literals(["pending", "accepted", "rejected"]),
+    resolution: optional(S.Struct({ by: Actor, at: text, command: text, reason: optional(text) })),
+});
+const address = { type: text, subject: text };
+const read = { ...address, at: optional(text) };
+const command = { ...address, id: text };
+export const requests = {
+    status: S.Struct(read),
+    facts: S.Struct(read),
+    work: S.Struct(read),
+    operations: S.Struct(read),
+    explain: S.Struct({ ...read, requirement: optional(text) }),
+    subjects: S.Struct({ type: text }),
+    assert: S.Struct({ ...command, values: Facts, kind: optional(text) }),
+    perform: S.Struct({
+        ...command,
+        operation: text,
+        values: optional(Values),
+        instance: optional(text),
+        reason: optional(S.Union([Scalar, S.Null])),
+        signature: optional(SignatureInput),
+        unsigned: optional(S.Boolean),
+        amend: optional(S.Struct({ previous: text, reason: text })),
+        revoke: optional(text),
+    }),
+    signal: S.Struct({ ...command, machine: text, state: text, instance: optional(text) }),
+    propose: S.Struct({ ...command, draft: Draft, rationale: text }),
+    proposals: S.Struct({
+        type: optional(text),
+        subject: optional(text),
+        state: optional(S.Literals(["pending", "accepted", "rejected"])),
+    }),
+    "accept-proposal": S.Struct({ ...command, proposal: text, signature: optional(SignatureInput) }),
+    "reject-proposal": S.Struct({ ...command, proposal: text, reason: text }),
+    changes: S.Record(S.String, S.Never),
+};
+export const verbs = Object.keys(requests);
+export const mutations = [
+    "assert",
+    "perform",
+    "signal",
+    "propose",
+    "accept-proposal",
+    "reject-proposal",
+];
+export const errorCodes = [
+    "invalid-request",
+    "unauthenticated",
+    "human-required",
+    "forbidden",
+    "not-found",
+    "command-duplicate",
+    "proposal-resolved",
+    "write-refused",
+    "internal",
+];
+export const ProtocolError = S.Struct({
+    code: S.Literals(errorCodes),
+    message: S.String,
+    details: optional(S.Array(S.String)),
+});
+const Status = S.Literals(["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]);
+const nullableText = S.Union([S.String, S.Null]);
+export const SubjectStatus = S.Struct({
+    subject: S.String,
+    at: S.String,
+    release: S.String,
+    revision: S.Number,
+    wakeAt: nullableText,
+    wakeReason: S.String,
+    machines: S.Array(S.Struct({ instance: S.String, machine: S.String, state: nullableText, since: nullableText })),
+    instances: S.Array(S.Struct({
+        instance: S.String,
+        component: S.String,
+        digest: S.String,
+        outputs: S.Record(S.String, Status),
+        requirements: S.Array(S.Struct({
+            name: S.String,
+            label: S.String,
+            status: Status,
+            due: nullableText,
+            blocked: nullableText,
+        })),
+    })),
+});
+export const Missing = S.Struct({
+    text: S.String,
+    kind: S.Literals(["requirement", "evidence", "fact", "machine", "other"]),
+    requirement: optional(S.String),
+    instance: optional(S.String),
+    evidence: optional(S.String),
+    producedBy: optional(S.Array(S.Struct({ requirement: S.String, instance: S.String }))),
+    fact: optional(S.String),
+    machine: optional(S.String),
+    states: optional(S.Array(S.String)),
+});
+export const Fact = S.Struct({
+    fact: S.String,
+    value: S.Union([Scalar, S.Null]),
+    by: S.String,
+    at: S.String,
+    command: nullableText,
+});
+export const WorkItem = S.Struct({
+    id: S.String,
+    instance: S.String,
+    operation: S.String,
+    label: S.String,
+    kind: S.Literals(["interaction", "connector", "decision", "proposal"]),
+    state: S.Literals(["eligible", "waiting", "dispatched", "held"]),
+    advances: S.Array(S.String),
+    assignee: S.Struct({ id: nullableText, kind: S.Literals(["entity", "group", "connector"]) }),
+    missing: S.Array(Missing),
+    fields: S.Array(S.Struct({
+        field: S.String,
+        mode: S.Literals(["ask", "confirm", "read-only"]),
+        value: S.Union([Scalar, S.Null]),
+    })),
+    proposal: optional(S.String),
+});
+export const Change = S.Struct({
+    subject: S.String,
+    revision: S.Number,
+    at: S.String,
+    transitions: S.Array(S.Struct({
+        instance: S.String,
+        kind: S.Literals(["requirement", "output"]),
+        name: S.String,
+        from: S.Union([Status, S.Null]),
+        to: S.Union([Status, S.Null]),
+    })),
+    opened: S.Array(WorkItem),
+    closed: S.Array(WorkItem),
+});
+export const Outcome = S.Struct({
+    accepted: S.Boolean,
+    codes: S.Array(S.String),
+    status: SubjectStatus,
+    change: Change,
+});
+const Json = S.suspend(() => S.Union([S.Null, S.Boolean, S.Number, S.String, S.Array(Json), S.Record(S.String, Json)]));
+export const responses = {
+    status: SubjectStatus,
+    facts: S.Array(Fact),
+    work: S.Array(WorkItem),
+    operations: S.Array(S.Struct({
+        instance: S.String,
+        name: S.String,
+        kind: S.Literals(["action", "decision"]),
+        state: S.Literals([
+            "eligible",
+            "waiting",
+            "dispatched",
+            "held",
+            "complete",
+            "not-applicable",
+            "decision",
+        ]),
+    })),
+    explain: S.Array(Json),
+    subjects: S.Array(S.String),
+    assert: Outcome,
+    perform: Outcome,
+    signal: Outcome,
+    propose: Outcome,
+    proposals: S.Array(Proposal),
+    "accept-proposal": Outcome,
+    "reject-proposal": Outcome,
+    changes: S.Struct({ revision: S.Number, nextWake: nullableText }),
+};
+export const requestJsonSchema = (verb) => S.toJsonSchemaDocument(requests[verb]).schema;
+export const responseJsonSchema = (verb) => S.toJsonSchemaDocument(responses[verb]);
+export const decodeRequest = (verb, value) => S.decodeUnknownSync(requests[verb])(value, { onExcessProperty: "error" });
+export const decodeActor = (value) => S.decodeUnknownSync(Actor)(value, { onExcessProperty: "error" });
+export const decodeResponse = (verb, value) => S.decodeUnknownSync(responses[verb])(value, {
+    onExcessProperty: "error",
+});
+export const resultJsonSchema = (verb) => S.toJsonSchemaDocument(S.Union([
+    S.Struct({ ok: S.Literal(true), value: responses[verb] }),
+    S.Struct({ ok: S.Literal(false), error: ProtocolError }),
+]));

package/dist/_internal/reconciler/action-intents.d.ts

@@ -0,0 +1,17 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { ActionResult, Cx, Instance, RequirementResult, Value, WorkIntent } from "./model.js";
+export declare const assignment: (cx: Cx, value: Value, requested?: Pick<IR.Action, "dispatch" | "onIneligible">, kind?: ActionResult["assigneeKind"]) => {
+    assignee: string;
+    assigneeId: string | null;
+    assigneeKind: "entity" | "group" | "connector";
+    dispatch: "auto" | "claim" | "manual";
+    onIneligible: "withdraw" | "keep" | "review";
+};
+export declare const openIntent: (inst: Instance, target: RequirementResult, action: ActionResult) => WorkIntent | null;
+export interface ActionProjection {
+    readonly action: ActionResult | null;
+    readonly intent: WorkIntent | null;
+}
+export declare const projectAction: (cx: Cx, inst: Instance, a: IR.Action, requirements: readonly RequirementResult[], amending?: boolean) => ActionProjection;
+/** Waiting display details can change harmlessly; dispatched ineligibility is consequential. */
+export declare const projectionSignature: ({ action, intent }: ActionProjection) => string;

package/dist/_internal/reconciler/action-intents.js

@@ -0,0 +1,161 @@
+import { missingCondition } from "./missing.js";
+import { workKey } from "./work.js";
+import { resourceGeneration } from "./resource-generation.js";
+import { advanceTargets } from "../ir-checks/index.js";
+import { policyAssignments } from "./policies.js";
+import { projectInteractionFields } from "./interaction-fields.js";
+import { readRenewal } from "./evidence-validity.js";
+import { and, evaluateIn, isUnknown, keyText, truth } from "./evaluation.js";
+import { semanticJson } from "./result-digest.js";
+export const assignment = (cx, value, requested, kind) => {
+    const id = typeof value === "string" && value.length ? value : null;
+    const namespace = id ? cx.b.nsOf(id) : undefined;
+    const assigneeKind = kind ?? (namespace ? "entity" : "group");
+    const entity = namespace ? cx.p.entities.get(namespace) : undefined;
+    const shown = id && entity?.display ? cx.b.fact(id, `${entity.ns}/${entity.display}`)?.v : undefined;
+    return {
+        assignee: isUnknown(value) ? "Unassigned" : value === null ? "" : String(shown ?? value),
+        assigneeId: id,
+        assigneeKind,
+        dispatch: requested?.dispatch ?? (assigneeKind === "group" ? "claim" : "auto"),
+        onIneligible: requested?.onIneligible ?? "withdraw",
+    };
+};
+export const openIntent = (inst, target, action) => action.state === "eligible" && action.assigneeId
+    ? {
+        instance: inst.id,
+        action: action.action,
+        occurrence: target.occurrence,
+        idempotencyKey: action.idempotencyKey,
+        at: action.at,
+        kind: "open",
+        ...(action.advancesAll
+            ? { occurrences: action.advancesAll.map((name) => `${inst.id}/${name}`) }
+            : {}),
+        ...(action.authorityConstraints
+            ? { authorityConstraints: action.authorityConstraints }
+            : {}),
+        dispatch: action.dispatch ?? (action.assigneeKind === "group" ? "claim" : "auto"),
+        onIneligible: action.onIneligible ?? "withdraw",
+        assignee: { id: action.assigneeId, kind: action.assigneeKind },
+    }
+    : null;
+export const projectAction = (cx, inst, a, requirements, amending = false) => {
+    const names = advanceTargets(a);
+    const targets = names.map((name) => {
+        const target = requirements.find((r) => r.name === name);
+        return { target, status: cx.statusRead?.(inst, name) ?? target.status };
+    });
+    const chosen = targets.find((t) => t.status === "Open" || t.status === "Overdue") ?? targets[0];
+    const { target, status } = chosen;
+    const definition = cx.p.components
+        .get(inst.component)
+        .requirements.find((r) => r.name === target.name);
+    const renewal = definition.renewWithin
+        ? readRenewal({ ...cx, ...(target.recurrence ? { proofPeriod: target.recurrence } : {}) }, definition, target.occurrence)
+        : null;
+    const baseKey = a.idempotency
+        ? names.length > 1
+            ? JSON.stringify([
+                "worldvm/action@1",
+                inst.component,
+                a.name,
+                inst.cycle,
+                a.idempotency.map((e) => evaluateIn(cx, e)),
+            ])
+            : `${a.name}[${a.idempotency.map((e) => keyText(evaluateIn(cx, e))).join(", ")}]`
+        : target.recurrence
+            ? `${target.occurrence}/${a.name}`
+            : `${inst.id}/${a.name}`;
+    const resource = cx.p.components
+        .get(inst.component)
+        .resources?.find((r) => a.via.kind === "connector" &&
+        r.acquire.connector === a.via.connector &&
+        r.acquire.capability === a.via.capability);
+    const generationKey = resource
+        ? JSON.stringify([
+            "worldvm/resource@1",
+            baseKey,
+            resource.name,
+            resourceGeneration(cx.p, cx.b, inst),
+        ])
+        : baseKey;
+    const key = !a.idempotency && renewal?.expiresAt
+        ? JSON.stringify(["worldvm/renewal@1", generationKey, renewal.expiresAt])
+        : generationKey;
+    if (!amending &&
+        names.length > 1 &&
+        a.via.kind === "interaction" &&
+        cx.b
+            .evidenceOf(inst.id)
+            .some((e) => e.workKey === workKey(inst.account, key) && e.status === "attested"))
+        return { action: null, intent: null };
+    const dispatched = cx.b.dispatched(key);
+    const ineligible = dispatched
+        ? {
+            instance: inst.id,
+            action: a.name,
+            occurrence: target.occurrence,
+            idempotencyKey: key,
+            at: a.at,
+            kind: a.onIneligible ?? "withdraw",
+        }
+        : null;
+    if (!amending &&
+        status !== "Open" &&
+        status !== "Overdue" &&
+        !(status === "Satisfied" && renewal?.state === "ready"))
+        return { action: null, intent: status === "Satisfied" ? null : ineligible };
+    const needs = a.needs.map((n) => ({
+        text: n.text,
+        expr: n.expr,
+        truth: truth(evaluateIn(cx, n.expr)),
+    }));
+    const connector = a.via.kind === "connector" ? a.via.connector : null;
+    const who = assignment(cx, connector ? `connector:${connector}` : a.assignee ? evaluateIn(cx, a.assignee) : null, a, connector ? "connector" : a.assigneeKind);
+    const constraints = policyAssignments(cx, a);
+    const entities = constraints.filter((c) => c.kind === "entity").map((c) => c.id);
+    const allowed = constraints.every((c) => c.id !== null) && new Set(entities).size <= 1;
+    const assigned = names.length === 1 || who.assigneeId !== null;
+    const eligible = and(needs.map((n) => n.truth)) === true && who.assigneeId !== null && allowed;
+    const interaction = a.via.kind === "interaction" ? cx.p.interactions.get(a.via.name) : undefined;
+    const action = {
+        ...(interaction
+            ? {
+                fields: projectInteractionFields(cx.p, interaction, (expr) => evaluateIn(cx, expr), {
+                    basis: cx.b,
+                    ...(cx.temporal ? { temporal: cx.temporal } : {}),
+                }),
+            }
+            : {}),
+        ...who,
+        ...(constraints.length ? { authorityConstraints: constraints } : {}),
+        action: a.name,
+        label: a.label ?? a.name,
+        advances: target.name,
+        ...(names.length > 1 ? { advancesAll: names } : {}),
+        via: a.via.kind === "interaction" ? a.via.name : `${a.via.connector}/${a.via.capability}`,
+        kind: a.via.kind,
+        interaction: a.via.kind === "interaction" ? a.via.name : null,
+        idempotencyKey: key,
+        state: dispatched
+            ? "dispatched"
+            : allowed && assigned && and(needs.map((n) => n.truth)) === true
+                ? "eligible"
+                : "waiting",
+        missing: [
+            ...needs.filter((n) => n.truth !== true).map((n) => missingCondition(cx, n.text, n.expr)),
+            ...(!allowed
+                ? [{ text: "Policy assignment intersection is unknown or empty", kind: "other" }]
+                : []),
+            ...(!assigned ? [{ text: "Assignee is Unknown", kind: "other" }] : []),
+        ],
+        at: a.at,
+    };
+    return {
+        action,
+        intent: dispatched ? (eligible ? null : ineligible) : openIntent(inst, target, action),
+    };
+};
+/** Waiting display details can change harmlessly; dispatched ineligibility is consequential. */
+export const projectionSignature = ({ action, intent }) => semanticJson([action?.state === "eligible" ? action : (action?.state ?? null), intent]);

package/dist/_internal/reconciler/actions.d.ts

@@ -0,0 +1,7 @@
+import { type EvaluationContext } from "./context.js";
+import type * as IR from "../world-ir/types.generated.js";
+import { type ActionResult, type Cx, type Instance, type HoldResult, type RequirementResult, type WorkIntent } from "./model.js";
+export declare const evaluateActions: (ctx: EvaluationContext, inst: Instance, cx: Cx, component: IR.Component, requirements: readonly RequirementResult[], holds?: readonly HoldResult[]) => {
+    readonly actions: ActionResult[];
+    readonly workIntents: WorkIntent[];
+};

package/dist/_internal/reconciler/actions.js

@@ -0,0 +1,134 @@
+import { evidenceSuperseded } from "./evidence-history.js";
+import { reusableProof, reuseDecisionName } from "./reuse.js";
+import { advanceTargets, priorCycleOperationName } from "../ir-checks/index.js";
+import {} from "./context.js";
+import { activeHolds } from "./holds.js";
+import { nextTime, isPastDeadline } from "./instants.js";
+import { evaluateIn, isDuration, legacyAcceptance, plus, selectedDecision } from "./evaluation.js";
+import { Unknown, } from "./model.js";
+import { assignment, openIntent, projectAction, projectionSignature } from "./action-intents.js";
+import { timed } from "./scheduling.js";
+export const evaluateActions = (ctx, inst, cx, component, requirements, holds = []) => {
+    const p = cx.p;
+    const b = cx.b;
+    // Eligibility is a pure derivation (P7): the requirement is Open/Overdue and every need holds.
+    const actions = [];
+    const workIntents = [];
+    for (const r of component.requirements) {
+        const target = requirements.find((q) => q.name === r.name);
+        const open = target.status === "Open" || target.status === "Overdue";
+        const accepts = r.accepts;
+        if (open && r.reuse?.confirm && selectedDecision(cx, r.name)?.definition.effect !== "reject") {
+            const offer = timed(ctx, { ...cx, occurrence: target.occurrence }, ["requirement", r.name, "reuse"], `${r.label ?? r.name}: reuse window changes`, (c) => {
+                const candidate = reusableProof(c, r);
+                if (!candidate || candidate instanceof Unknown)
+                    return null;
+                const who = assignment(c, evaluateIn(c, r.reuse.confirm), undefined, r.reuse.confirmKind);
+                return {
+                    action: `accept-reuse:${r.name}`,
+                    label: `Accept existing evidence for ${r.label ?? r.name}`,
+                    advances: r.name,
+                    ...who,
+                    via: "decision",
+                    kind: "decision",
+                    interaction: null,
+                    idempotencyKey: JSON.stringify([
+                        inst.id,
+                        reuseDecisionName(inst.component, r.name, "accepted"),
+                        candidate.record.id,
+                    ]),
+                    state: who.assigneeId ? "eligible" : "waiting",
+                    missing: who.assigneeId
+                        ? []
+                        : [{ text: "Confirmation principal is Unknown", kind: "other" }],
+                    at: r.at,
+                };
+            });
+            if (offer) {
+                actions.push(offer);
+                const intent = openIntent(inst, target, offer);
+                if (intent)
+                    workIntents.push(intent);
+            }
+        }
+        // An acceptance the law leaves to the employer is offered as a decision, never automatic.
+        if (open &&
+            accepts?.from &&
+            inst.prior &&
+            !legacyAcceptance(cx, r) &&
+            selectedDecision(cx, r.name)?.definition.effect !== "reject") {
+            const prior = b
+                .evidence(`${inst.prior}/${accepts.from}`)
+                .filter((e) => e.status === "attested" && !evidenceSuperseded(b, e))
+                .at(-1);
+            const offer = timed(ctx, cx, ["requirement", r.name, "reuse"], `${r.label ?? r.name}: prior evidence window changes`, (c) => {
+                const within = accepts.within ? evaluateIn(c, accepts.within) : null;
+                const expires = prior && within && isDuration(within) ? plus(prior.at, within) : null;
+                if (expires) {
+                    const next = nextTime(expires);
+                    if (next)
+                        c.temporal?.add(next);
+                }
+                if (!prior || (expires && isPastDeadline(c.b.now, expires)))
+                    return null;
+                const contract = p.ir.decisions?.find((d) => d.of === inst.component &&
+                    d.name ===
+                        priorCycleOperationName(p.ir.decisions ?? [], inst.component, r.name, "accepted"));
+                const principal = contract
+                    ? evaluateIn(c, contract.by)
+                    : accepts.confirm
+                        ? evaluateIn(c, accepts.confirm)
+                        : null;
+                return {
+                    action: `accept-prior:${r.name}`,
+                    label: accepts.label ?? `Accept the prior cycle's ${r.name}`,
+                    advances: r.name,
+                    ...assignment(c, principal, undefined, contract?.byKind === "individual" ? "entity" : contract?.byKind),
+                    via: "decision",
+                    kind: "decision",
+                    interaction: null,
+                    idempotencyKey: `${inst.id}/accept-prior:${r.name}`,
+                    state: "eligible",
+                    missing: [],
+                    at: r.at,
+                };
+            });
+            if (offer) {
+                actions.push(offer);
+                const intent = openIntent(inst, target, offer);
+                if (intent)
+                    workIntents.push(intent);
+            }
+        }
+    }
+    for (const a of component.actions) {
+        const target = requirements.find((q) => q.name === advanceTargets(a)[0]);
+        if (!target)
+            continue;
+        const projection = timed(ctx, cx, ["action", a.name], `${a.label ?? a.name}: eligibility changes`, (c) => projectAction(c, inst, a, requirements), projectionSignature);
+        if (projection.action)
+            actions.push(projection.action);
+        if (projection.intent)
+            workIntents.push(projection.intent);
+    }
+    const paused = activeHolds(holds, "dispatch");
+    if (!paused.length)
+        return { actions, workIntents };
+    return {
+        actions: actions.map((action) => action.state === "eligible"
+            ? {
+                ...action,
+                state: "held",
+                heldBy: paused.map((h) => h.name),
+                missing: [
+                    ...action.missing,
+                    ...paused.map((h) => ({
+                        text: `Hold: ${h.label}${h.condition === "unknown" ? " (condition Unknown)" : ""}`,
+                        kind: "other",
+                    })),
+                ],
+            }
+            : action),
+        workIntents: workIntents.filter((intent) => intent.kind !== "open"),
+    };
+};

package/dist/_internal/reconciler/amendments.d.ts

@@ -0,0 +1,12 @@
+import type { EvidenceRecord } from "./basis.js";
+import type { World } from "./memory.js";
+import type { TimePoint } from "./instants.js";
+import type { WorldReconciliation, ActionResult } from "./model.js";
+export declare const amendmentAction: (recon: WorldReconciliation, world: World, now: TimePoint, instance: string, name: string, previous: string) => {
+    readonly action: ActionResult;
+    readonly record: EvidenceRecord;
+    readonly code?: never;
+} | {
+    readonly code: string;
+    readonly action?: never;
+};

package/dist/_internal/reconciler/amendments.js

@@ -0,0 +1,52 @@
+import { basis } from "./memory.js";
+import { instanceContext } from "./evaluation.js";
+import { programFor } from "./reconcile.js";
+import { projectAction } from "./action-intents.js";
+import { activeHolds } from "./holds.js";
+import { advanceTargets, componentOperationNames } from "../ir-checks/index.js";
+import { signatureValid } from "./signatures.js";
+import { evidenceOccurrences, supersededEvidence } from "./evidence-history.js";
+export const amendmentAction = (recon, world, now, instance, name, previous) => {
+    const inst = recon.instances.get(instance), p = programFor(recon, instance), result = recon.results.get(instance);
+    const definition = inst && p?.components.get(inst.component)?.actions.find((a) => a.name === name), via = definition?.via;
+    const evidence = via?.kind === "interaction" && p?.evidence.get(p.interactions.get(via.name).produces);
+    if (!inst ||
+        !p ||
+        !result ||
+        !definition ||
+        !evidence ||
+        !evidence.amend ||
+        evidence.of !== inst.component)
+        return { code: "amendment-target" };
+    if (!componentOperationNames(p.ir, p.components.get(inst.component)).includes(name))
+        return { code: "amendment-target" };
+    const targets = advanceTargets(definition).map((n) => result.requirements.find((r) => r.name === n));
+    if (targets.some((r) => !r || !["Open", "Overdue", "Satisfied"].includes(r.status)))
+        return { code: "amendment-target" };
+    const scopes = targets.map((r) => r.occurrence).sort(), snapshot = basis(world, now), records = snapshot.evidence(scopes[0]), superseded = supersededEvidence(records);
+    const originals = records.filter((r) => r.id === previous);
+    if (originals.length !== 1 ||
+        originals[0].type !== evidence.name ||
+        originals[0].status !== "attested" ||
+        !signatureValid(originals[0]) ||
+        JSON.stringify(evidenceOccurrences(originals[0])) !== JSON.stringify(scopes))
+        return { code: "amendment-target" };
+    if (superseded.has(previous) ||
+        scopes.some((scope) => snapshot
+            .evidence(scope)
+            .filter((r) => r.type === evidence.name &&
+            r.status === "attested" &&
+            signatureValid(r) &&
+            !superseded.has(r.id))
+            .at(-1)?.id !== previous))
+        return { code: "amendment-stale" };
+    const action = projectAction(instanceContext(recon, snapshot, inst), inst, definition, result.requirements, true).action;
+    if (!action)
+        return { code: "operation-not-eligible" };
+    return {
+        record: originals[0],
+        action: activeHolds(result.holds ?? [], "dispatch").length
+            ? { ...action, state: "held" }
+            : action,
+    };
+};