@adecore/plan 0.0.1 → 0.17.0-beta.2

package/dist/permissions.js

@@ -0,0 +1,152 @@
+import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, refuse } from './tree.js';
+const ALLOWED = { ok: true };
+const PERSON_OPS = new Set(['set', 'note', 'unlock']);
+const AGENT_OPS = new Set(['set', 'note', 'add', 'edit', 'move', 'remove', 'meta']);
+function stepFor(plan, id, leaf) {
+    const location = locateItem(plan, id);
+    if (!location) {
+        return refuse('plan-missing-item', `The plan has no item "${id}"`);
+    }
+    if (location.item.type !== 'step') {
+        return refuse('plan-not-a-step', `"${id}" is a ${location.item.type}, not a step`);
+    }
+    if (leaf && isParentStep(location.item)) {
+        return refuse('plan-parent-state', `The step "${id}" has sub-steps, so its state follows from them`);
+    }
+    return location.item;
+}
+function mayState(plan, step, state, actor) {
+    const checks = effectiveChecks(plan, step);
+    if (actor === 'person') {
+        return checks === 'agent' ? refuse('step-locked', `Only the agent checks "${step.id}" until a person unlocks it`) : ALLOWED;
+    }
+    if (checks === 'person') {
+        return refuse('person-only', `Only a person checks "${step.id}"`);
+    }
+    if (step.by === 'person' && step.state !== undefined && step.state !== state) {
+        return refuse('set-by-person', `A person set "${step.id}" to ${step.state}; add a note or ask in the chat instead`);
+    }
+    return ALLOWED;
+}
+/* Adding under a leaf takes its state away, which may not happen to a state a person set. */
+function mayHoldChildren(plan, under) {
+    if (under === undefined) {
+        return ALLOWED;
+    }
+    const location = locateItem(plan, under);
+    if (location?.item.type === 'step' && !isParentStep(location.item) && holdsPersonState(location.item)) {
+        return refuse('set-by-person', `A person set "${under}" to ${location.item.state}; a sub-step would take that state away`);
+    }
+    return ALLOWED;
+}
+/*
+ * Whether this actor may apply the operation to the plan as it is now: who sets which step, what a
+ * person set, what a person unlocked. The shape of the result (depth, size, positions) is checked
+ * when the operation is applied.
+ */
+export function canApply(op, actor, plan) {
+    if (!(actor === 'person' ? PERSON_OPS : AGENT_OPS).has(op.op)) {
+        return refuse('op-not-allowed', actor === 'person' ? `A person cannot ${op.op} in a plan` : `An agent cannot ${op.op} a plan`);
+    }
+    switch (op.op) {
+        case 'set': {
+            if (op.next !== undefined && actor === 'person') {
+                return refuse('op-not-allowed', 'Only the agent moves on to a next step');
+            }
+            const targets = op.ids.map((id) => [id, op.state]);
+            if (op.next !== undefined) {
+                targets.push([op.next, 'active']);
+            }
+            for (const [id, state] of targets) {
+                const step = stepFor(plan, id, true);
+                if ('ok' in step) {
+                    return step;
+                }
+                const verdict = mayState(plan, step, state, actor);
+                if (!verdict.ok) {
+                    return verdict;
+                }
+            }
+            return ALLOWED;
+        }
+        case 'note': {
+            const step = stepFor(plan, op.id, false);
+            return 'ok' in step ? step : ALLOWED;
+        }
+        case 'unlock': {
+            if (op.ids === 'all') {
+                return ALLOWED;
+            }
+            for (const id of op.ids) {
+                const step = stepFor(plan, id, false);
+                if ('ok' in step) {
+                    return step;
+                }
+            }
+            return ALLOWED;
+        }
+        case 'add':
+            return mayHoldChildren(plan, op.under);
+        case 'edit': {
+            const location = locateItem(plan, op.id);
+            if (!location) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            const item = location.item;
+            if (item.type !== 'step') {
+                return ALLOWED;
+            }
+            // A new title would make a person's check or stamp stand for something they never saw.
+            if (op.title !== undefined && op.title !== item.title) {
+                if (holdsPersonState(item)) {
+                    return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so its title stays`);
+                }
+                if (effectiveChecks(plan, item) === 'person') {
+                    return refuse('person-only', `Only a person checks "${op.id}", so its title stays`);
+                }
+            }
+            if (op.checks === undefined) {
+                return ALLOWED;
+            }
+            if (item.unlocked && op.checks !== 'anyone') {
+                return refuse('unlocked-by-person', `A person unlocked "${op.id}", so anyone checks it`);
+            }
+            if (effectiveChecks(plan, item) === 'person' && op.checks !== 'person') {
+                return refuse('person-only', `Only a person checks "${op.id}", and that stays so`);
+            }
+            return ALLOWED;
+        }
+        case 'move': {
+            if (!locateItem(plan, op.id)) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            return mayHoldChildren(plan, op.under);
+        }
+        case 'remove': {
+            const location = locateItem(plan, op.id);
+            if (!location) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            if (holdsPersonState(location.item)) {
+                return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so it stays`);
+            }
+            if (allSteps([location.item]).some((step) => effectiveChecks(plan, step) === 'person')) {
+                return refuse('person-only', `Only a person checks "${op.id}" or a step under it, so it stays`);
+            }
+            return ALLOWED;
+        }
+        case 'meta': {
+            const inherits = allSteps(plan.items).some((step) => step.checks === undefined && !step.unlocked);
+            if (op.checks !== undefined && op.checks !== 'person' && plan.meta.checks === 'person' && inherits) {
+                return refuse('person-only', 'Only a person checks the steps of this plan, and that stays so');
+            }
+            return ALLOWED;
+        }
+    }
+}
+/* Deleting a plan takes every check a person made in it along, so an agent leaves one that holds any. */
+export function canDeletePlan(plan, actor) {
+    return actor === 'agent' && plan.items.some(holdsPersonState)
+        ? refuse('set-by-person', `A person checked steps of "${plan.meta.title}", so the plan stays`)
+        : ALLOWED;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,478 @@
+import { z } from 'zod';
+export declare const PLAN_LIMITS: {
+    readonly idLength: 64;
+    readonly title: 200;
+    readonly description: 1000;
+    readonly note: 500;
+    readonly status: 200;
+    readonly depth: 5;
+    readonly items: 300;
+    readonly plansPerChat: 20;
+};
+export declare const PlanItemIdSchema: z.ZodString;
+export type PlanItemId = z.infer<typeof PlanItemIdSchema>;
+export declare const PlanIdSchema: z.ZodString;
+export type PlanId = z.infer<typeof PlanIdSchema>;
+export declare const PlanStepStateSchema: z.ZodEnum<{
+    active: "active";
+    blocked: "blocked";
+    done: "done";
+    failed: "failed";
+    info: "info";
+    open: "open";
+    skipped: "skipped";
+    warning: "warning";
+}>;
+export type PlanStepState = z.infer<typeof PlanStepStateSchema>;
+export declare const PlanChecksSchema: z.ZodEnum<{
+    agent: "agent";
+    anyone: "anyone";
+    person: "person";
+}>;
+export type PlanChecks = z.infer<typeof PlanChecksSchema>;
+export declare const PlanActorSchema: z.ZodEnum<{
+    agent: "agent";
+    person: "person";
+}>;
+export type PlanActor = z.infer<typeof PlanActorSchema>;
+export declare const PlanKindSchema: z.ZodEnum<{
+    steps: "steps";
+    test: "test";
+}>;
+export type PlanKind = z.infer<typeof PlanKindSchema>;
+export declare const PlanMetaSchema: z.ZodObject<{
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        steps: "steps";
+        test: "test";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    checks: z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>;
+}, z.core.$strip>;
+export type PlanMeta = z.infer<typeof PlanMetaSchema>;
+export declare const PlanStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        done: "done";
+        failed: "failed";
+        info: "info";
+        open: "open";
+        skipped: "skipped";
+        warning: "warning";
+    }>>;
+    by: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        person: "person";
+    }>>;
+    at: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    unlocked: z.ZodOptional<z.ZodBoolean>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PlanStep = z.infer<typeof PlanStepSchema>;
+export declare const PlanTextSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanText = z.infer<typeof PlanTextSchema>;
+export declare const PlanSectionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"section">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            anyone: "anyone";
+            person: "person";
+        }>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            done: "done";
+            failed: "failed";
+            info: "info";
+            open: "open";
+            skipped: "skipped";
+            warning: "warning";
+        }>>;
+        by: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>>;
+        at: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        unlocked: z.ZodOptional<z.ZodBoolean>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type PlanSection = z.infer<typeof PlanSectionSchema>;
+export declare const PlanItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"section">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            anyone: "anyone";
+            person: "person";
+        }>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            done: "done";
+            failed: "failed";
+            info: "info";
+            open: "open";
+            skipped: "skipped";
+            warning: "warning";
+        }>>;
+        by: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>>;
+        at: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        unlocked: z.ZodOptional<z.ZodBoolean>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        done: "done";
+        failed: "failed";
+        info: "info";
+        open: "open";
+        skipped: "skipped";
+        warning: "warning";
+    }>>;
+    by: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        person: "person";
+    }>>;
+    at: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    unlocked: z.ZodOptional<z.ZodBoolean>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+}, z.core.$strip>], "type">;
+export type PlanItem = z.infer<typeof PlanItemSchema>;
+export declare const PlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    rev: z.ZodNumber;
+    createdAt: z.ZodString;
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        kind: z.ZodEnum<{
+            steps: "steps";
+            test: "test";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        checks: z.ZodEnum<{
+            agent: "agent";
+            anyone: "anyone";
+            person: "person";
+        }>;
+    }, z.core.$strip>;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"section">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            checks: z.ZodOptional<z.ZodEnum<{
+                agent: "agent";
+                anyone: "anyone";
+                person: "person";
+            }>>;
+            state: z.ZodOptional<z.ZodEnum<{
+                active: "active";
+                blocked: "blocked";
+                done: "done";
+                failed: "failed";
+                info: "info";
+                open: "open";
+                skipped: "skipped";
+                warning: "warning";
+            }>>;
+            by: z.ZodOptional<z.ZodEnum<{
+                agent: "agent";
+                person: "person";
+            }>>;
+            at: z.ZodOptional<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+            unlocked: z.ZodOptional<z.ZodBoolean>;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            anyone: "anyone";
+            person: "person";
+        }>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            done: "done";
+            failed: "failed";
+            info: "info";
+            open: "open";
+            skipped: "skipped";
+            warning: "warning";
+        }>>;
+        by: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>>;
+        at: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        unlocked: z.ZodOptional<z.ZodBoolean>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<any, z.core.$strip>>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type Plan = z.infer<typeof PlanSchema>;
+export declare const PlanSetOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    ids: z.ZodArray<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        done: "done";
+        failed: "failed";
+        info: "info";
+        open: "open";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanSetOp = z.infer<typeof PlanSetOpSchema>;
+export declare const PlanNoteOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"note">;
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type PlanNoteOp = z.infer<typeof PlanNoteOpSchema>;
+export declare const PlanUnlockOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"unlock">;
+    ids: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"all">]>;
+}, z.core.$strip>;
+export type PlanUnlockOp = z.infer<typeof PlanUnlockOpSchema>;
+export declare const PlanAddOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"add">;
+    type: z.ZodEnum<{
+        section: "section";
+        step: "step";
+        text: "text";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+    under: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanAddOp = z.infer<typeof PlanAddOpSchema>;
+export declare const PlanEditOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"edit">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+}, z.core.$strip>;
+export type PlanEditOp = z.infer<typeof PlanEditOpSchema>;
+export declare const PlanMoveOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"move">;
+    id: z.ZodString;
+    under: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanMoveOp = z.infer<typeof PlanMoveOpSchema>;
+export declare const PlanRemoveOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"remove">;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type PlanRemoveOp = z.infer<typeof PlanRemoveOpSchema>;
+export declare const PlanMetaOpSchema: z.ZodObject<{
+    op: z.ZodLiteral<"meta">;
+    title: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+}, z.core.$strip>;
+export type PlanMetaOp = z.infer<typeof PlanMetaOpSchema>;
+export declare const PlanPersonOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    ids: z.ZodArray<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        done: "done";
+        failed: "failed";
+        info: "info";
+        open: "open";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"note">;
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"unlock">;
+    ids: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"all">]>;
+}, z.core.$strip>], "op">;
+export type PlanPersonOp = z.infer<typeof PlanPersonOpSchema>;
+export declare const PlanOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    ids: z.ZodArray<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        done: "done";
+        failed: "failed";
+        info: "info";
+        open: "open";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"note">;
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"unlock">;
+    ids: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"all">]>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"add">;
+    type: z.ZodEnum<{
+        section: "section";
+        step: "step";
+        text: "text";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+    under: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"edit">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"move">;
+    id: z.ZodString;
+    under: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"remove">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"meta">;
+    title: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        anyone: "anyone";
+        person: "person";
+    }>>;
+}, z.core.$strip>], "op">;
+export type PlanOp = z.infer<typeof PlanOpSchema>;