sparta_worlds 0.6.0

package/dist/cli/tasks.js

@@ -0,0 +1,1246 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { parseDocument } from "yaml";
+import { z } from "zod";
+import { canonicalJson, createLayeredSeedLibrary, parseSeed, resolveLibraryDirs, seedHash } from "#server";
+import { parseExpect } from "./expect.js";
+import { readDoc } from "./load.js";
+import { parseRubric } from "./rubric.js";
+const TICKET_STATUSES = ["new", "open", "pending", "hold", "solved", "closed"];
+const PRIORITIES = ["low", "normal", "high", "urgent"];
+export const TaskSchema = z
+    .object({
+    id: z.string().min(1).optional(),
+    requester: z.string().email(),
+    requester_name: z.string().min(1).optional(),
+    subject: z.string().min(1),
+    body: z.string().min(1),
+    priority: z.enum(PRIORITIES).optional(),
+    tags: z.array(z.string()).optional(),
+    expected: z.string().min(1).optional(),
+    decoys: z.array(z.string().email()).min(1).optional(),
+    trap_class: z.string().optional(),
+    terminal_status: z.array(z.enum(TICKET_STATUSES)).min(1).optional(),
+    metadata: z.record(z.string()).optional(),
+})
+    .strict();
+export const TasksSchema = z
+    .object({
+    version: z.literal(1),
+    seed: z.string().min(1),
+    policy: z.string().min(1).optional(),
+    identity_map: z.string().min(1).optional(),
+    scenario: z.string().min(1).nullable().optional(),
+    runs: z.number().int().min(1).default(3),
+    mode: z.enum(["isolated", "shift"]).default("isolated"),
+    currency: z
+        .string()
+        .regex(/^[A-Za-z]{3}$/, "currency is a three-letter ISO code")
+        .transform((c) => c.toLowerCase())
+        .default("usd"),
+    budget: z
+        .object({
+        credits_total_max: z.number().int().min(0).optional(),
+        credits_count_max: z.number().int().min(0).optional(),
+    })
+        .strict()
+        .optional(),
+    invariants: z.array(z.string().min(1)).default([]),
+    plan_names: z.array(z.string().min(1)).optional(),
+    tasks: z.array(TaskSchema).min(1),
+})
+    .strict();
+export const taskLabel = (task, position) => task.id ?? String(position);
+export class TaskError extends Error {
+    label;
+    field;
+    constructor(label, field, detail) {
+        super(`task ${label}: ${field} ${detail}`);
+        this.label = label;
+        this.field = field;
+    }
+}
+export class TaskErrors extends Error {
+    errors;
+    constructor(errors) {
+        super(errors.map((e) => e.message).join("\n"));
+        this.errors = errors;
+    }
+}
+export function parseTasks(doc, source = "tasks file") {
+    const parsed = TasksSchema.safeParse(doc);
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `  ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+        throw new Error(`invalid ${source}:\n${issues}`);
+    }
+    const tasks = parsed.data;
+    if (tasks.invariants.length === 0 && tasks.tasks.every((t) => t.expected === undefined))
+        throw new Error(`${source}: no task has an expected: line and there is no invariant — add expected: to at least one task, or an invariant: a run with only advisory grading is not a gate`);
+    return tasks;
+}
+export function loadTasks(file) {
+    const path = resolve(file);
+    const text = readFileSync(path, "utf8");
+    return { doc: parseTasks(readDoc(path), path), dir: dirname(path), text };
+}
+export function parseAmount(text) {
+    if (/^\d+$/.test(text))
+        return Number(text);
+    const m = /^\$?(\d{1,3}(?:,\d{3})+|\d+)\.(\d{2})$/.exec(text);
+    if (!m)
+        return undefined;
+    return Number(m[1].replaceAll(",", "")) * 100 + Number(m[2]);
+}
+export function formatAmount(cents, currency) {
+    if (currency !== "usd")
+        return String(cents);
+    const whole = Math.floor(cents / 100);
+    const frac = String(cents % 100).padStart(2, "0");
+    return `$${whole.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")}.${frac}`;
+}
+export const EXPECTED_FORMS = "refund <amount> [on any | on duplicate | on <charge id>], credit <amount>, credit up to <amount>, void [<invoice id>], cancel [<subscription id> | duplicate], cancel at period end [<subscription id>], plan change to <price id> [<subscription id>], none, escalate";
+const EXPECTED_KINDS = "refund, credit, void, cancel, cancel at period end, plan change, none, escalate";
+export function parseExpected(line, label) {
+    const text = line.trim().replace(/\s+/g, " ");
+    const bad = (detail) => new TaskError(label, "expected", detail);
+    const amount = (raw) => {
+        const cents = parseAmount(raw);
+        if (cents === undefined || cents <= 0)
+            throw bad(`amount '${raw}' must be cents (24300) or a two-decimal figure ($243.00), above zero`);
+        return cents;
+    };
+    const subscriptionId = (id) => {
+        if (!/^sub_\S+$/.test(id))
+            throw bad(`'${id}' is not a subscription id (sub_…)`);
+        return id;
+    };
+    if (text === "none")
+        return { claim: "none", expect: { no_changes: true }, needs: { kind: "none" } };
+    if (text === "escalate")
+        return { claim: "escalate", expect: { escalate: true }, needs: { kind: "none" } };
+    const refund = /^refund (\S+)(?: on (.+))?$/.exec(text);
+    if (refund) {
+        const cents = amount(refund[1]);
+        const on = refund[2];
+        if (on === undefined || on === "any")
+            return { claim: "refund", expect: { refunds: [{ amount: cents }] }, needs: { kind: "none" } };
+        if (on === "duplicate")
+            return { claim: "refund", expect: {}, needs: { kind: "refund_duplicate", amount: cents } };
+        if (/^ch_\S+$/.test(on))
+            return { claim: "refund", expect: {}, needs: { kind: "refund_charge", amount: cents, charge: on } };
+        throw bad(`'on ${on}' must be 'on any', 'on duplicate' or 'on <charge id>' (ch_…)`);
+    }
+    const creditUpTo = /^credit up to (\S+)$/.exec(text);
+    if (creditUpTo) {
+        const cents = amount(creditUpTo[1]);
+        return {
+            claim: "credit",
+            expect: { credits: { count_any_of: [0, 1], min: 1, max: cents } },
+            needs: { kind: "none" },
+        };
+    }
+    const credit = /^credit (\S+)$/.exec(text);
+    if (credit) {
+        const cents = amount(credit[1]);
+        return { claim: "credit", expect: { credits: { count: 1, min: cents, max: cents } }, needs: { kind: "none" } };
+    }
+    const voided = /^void(?: (\S+))?$/.exec(text);
+    if (voided) {
+        if (voided[1] === undefined)
+            return { claim: "void", expect: {}, needs: { kind: "void_any" } };
+        if (!/^in_\S+$/.test(voided[1]))
+            throw bad(`'${voided[1]}' is not an invoice id (in_…)`);
+        return { claim: "void", expect: {}, needs: { kind: "void_invoice", invoice: voided[1] } };
+    }
+    const periodEnd = /^cancel at period end(?: (\S+))?$/.exec(text);
+    if (periodEnd) {
+        if (periodEnd[1] === undefined)
+            return { claim: "cancel_at_period_end", expect: {}, needs: { kind: "cancel_any", periodEnd: true } };
+        return {
+            claim: "cancel_at_period_end",
+            expect: {},
+            needs: { kind: "cancel_subscription", subscription: subscriptionId(periodEnd[1]), periodEnd: true },
+        };
+    }
+    if (text === "cancel duplicate")
+        return { claim: "cancel", expect: {}, needs: { kind: "cancel_duplicate" } };
+    const cancel = /^cancel(?: (\S+))?$/.exec(text);
+    if (cancel) {
+        if (cancel[1] === undefined)
+            return { claim: "cancel", expect: {}, needs: { kind: "cancel_any", periodEnd: false } };
+        return {
+            claim: "cancel",
+            expect: {},
+            needs: { kind: "cancel_subscription", subscription: subscriptionId(cancel[1]), periodEnd: false },
+        };
+    }
+    const plan = /^plan change to (\S+)(?: (\S+))?$/.exec(text);
+    if (plan) {
+        if (!/^price_\S+$/.test(plan[1]))
+            throw bad(`'${plan[1]}' is not a price id (price_…)`);
+        return {
+            claim: "plan_change",
+            expect: {},
+            needs: {
+                kind: "plan_change",
+                price: plan[1],
+                ...(plan[2] !== undefined ? { subscription: subscriptionId(plan[2]) } : {}),
+            },
+        };
+    }
+    throw bad(`must be one of ${EXPECTED_KINDS} (the forms: ${EXPECTED_FORMS})`);
+}
+export const IdentityMapSchema = z
+    .object({
+    version: z.literal(1),
+    seed: z.string().min(1),
+    seed_hash: z.string().min(1),
+    customers: z.array(z
+        .object({
+        id: z.string().min(1),
+        email: z.string().nullable(),
+        name: z.string().nullable(),
+        pseudonym: z.object({ id: z.string().min(1), email: z.string(), name: z.string() }).strict(),
+    })
+        .strict()),
+})
+    .strict();
+export function readIdentityMap(file) {
+    const path = resolve(file);
+    if (!existsSync(path))
+        throw new Error(`identity map ${path} does not exist (seed import --identity-map writes it)`);
+    if (process.platform !== "win32") {
+        const mode = statSync(path).mode & 0o777;
+        if ((mode & 0o077) !== 0)
+            throw new Error(`identity map ${path} is readable by others (mode ${mode.toString(8).padStart(3, "0")}): chmod 600 it — it holds real identities`);
+    }
+    const parsed = IdentityMapSchema.safeParse(JSON.parse(readFileSync(path, "utf8")));
+    if (!parsed.success)
+        throw new Error(`invalid identity map ${path}:\n${parsed.error.issues.map((i) => `  ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n")}`);
+    return parsed.data;
+}
+export function resolveSeedRef(ref, baseDir, seedsDir) {
+    if (ref.endsWith(".json")) {
+        const path = isAbsolute(ref) ? ref : resolve(baseDir, ref);
+        if (!existsSync(path))
+            throw new Error(`seed file ${path} does not exist`);
+        const seed = parseSeed(JSON.parse(readFileSync(path, "utf8")));
+        return { seed, hash: seedHash(seed), source: path };
+    }
+    const lib = createLayeredSeedLibrary(resolveLibraryDirs("seeds", seedsDir));
+    const found = lib.get(ref);
+    if (!found)
+        throw new Error(`seed '${ref}' is neither a .json file nor a library seed (looked in: ${lib.dirs.join(", ")})`);
+    return { seed: found.seed, hash: found.hash, source: lib.dirs.join(", ") };
+}
+const invoiceTotal = (inv) => inv.lines.reduce((n, l) => n + l.amount, 0);
+const chargeAmount = (inv, ch) => ch.amount ?? invoiceTotal(inv);
+function customersFor(email, seed, map) {
+    const wanted = email.toLowerCase();
+    const direct = seed.data.customers.filter((c) => (c.email ?? "").toLowerCase() === wanted);
+    if (direct.length > 0 || map === undefined)
+        return direct;
+    const byId = new Map(seed.data.customers.map((c) => [c.id, c]));
+    return map.customers
+        .filter((c) => (c.email ?? "").toLowerCase() === wanted)
+        .map((c) => byId.get(c.pseudonym.id))
+        .filter((c) => c !== undefined);
+}
+function ownerOf(needs, seed) {
+    const invoices = seed.data.invoices;
+    switch (needs.kind) {
+        case "refund_charge": {
+            const inv = invoices.find((i) => i.charges.some((c) => c.id === needs.charge));
+            return { id: needs.charge, owner: inv?.customer };
+        }
+        case "void_invoice":
+            return { id: needs.invoice, owner: invoices.find((i) => i.id === needs.invoice)?.customer };
+        case "cancel_subscription":
+            return {
+                id: needs.subscription,
+                owner: seed.data.subscriptions.find((s) => s.id === needs.subscription)?.customer,
+            };
+        case "plan_change":
+            return needs.subscription === undefined
+                ? undefined
+                : { id: needs.subscription, owner: seed.data.subscriptions.find((s) => s.id === needs.subscription)?.customer };
+        default:
+            return undefined;
+    }
+}
+export function resolveTask(task, label, parsed, seed, map) {
+    const matches = customersFor(task.requester, seed, map);
+    const err = (field, detail) => new TaskError(label, field, detail);
+    if (matches.length === 0)
+        throw err("requester", `${task.requester} matches no customer in seed ${seed.name}${map === undefined ? " (a real email needs identity_map:)" : " or in the identity map"}`);
+    const ids = matches.map((c) => c.id);
+    const needs = parsed?.needs ?? { kind: "none" };
+    const claim = parsed?.claim ?? "policy";
+    let customer;
+    let decoys = [];
+    let candidates = [];
+    if (matches.length === 1)
+        customer = matches[0];
+    else if (claim === "escalate") {
+        candidates = ids;
+        customer = matches[0];
+    }
+    else {
+        const named = ownerOf(needs, seed);
+        if (named === undefined)
+            throw err("requester", `${task.requester} is shared by ${ids.join(", ")}: name the charge, invoice or subscription in expected:, or use escalate`);
+        const owner = matches.find((c) => c.id === named.owner);
+        if (owner === undefined)
+            throw err("expected", `${named.id} belongs to none of the customers sharing ${task.requester} (${ids.join(", ")})`);
+        customer = owner;
+        decoys = ids.filter((id) => id !== owner.id);
+    }
+    const named = [];
+    for (const email of task.decoys ?? []) {
+        const found = customersFor(email, seed, map);
+        if (found.length === 0)
+            throw err("decoys", `${email} matches no customer in seed ${seed.name}${map === undefined ? " (a real email needs identity_map:)" : " or in the identity map"}`);
+        for (const c of found) {
+            if (c.id === customer.id || candidates.includes(c.id))
+                throw err("decoys", `${email} is the requester's own account (${c.id}), not a decoy`);
+            if (!decoys.includes(c.id) && !named.includes(c.id))
+                named.push(c.id);
+        }
+    }
+    decoys = [...decoys, ...named];
+    const requester = { name: task.requester_name ?? customer.name, email: customer.email ?? task.requester };
+    const mine = seed.data.invoices.filter((i) => i.customer === customer.id);
+    const subs = seed.data.subscriptions.filter((s) => s.customer === customer.id);
+    const expect = { ...(parsed?.expect ?? {}) };
+    let note = claim === "policy" ? "policy-only (no key)" : (task.expected ?? "").trim();
+    const chargeIds = (inv) => inv.charges.map((c) => c.id);
+    switch (needs.kind) {
+        case "none":
+            break;
+        case "refund_duplicate": {
+            const pairs = mine.filter((i) => i.status === "paid" &&
+                i.charges.length === 2 &&
+                i.charges.every((c) => chargeAmount(i, c) === needs.amount && (c.amount_refunded ?? 0) === 0));
+            if (pairs.length === 0)
+                throw err("expected", `on duplicate: no paid invoice of ${customer.id} carries two charges of ${needs.amount} (${mine.map((i) => `${i.id} ${i.status} [${i.charges.map((c) => `${c.id}:${chargeAmount(i, c)}`).join(", ")}]`).join("; ") || "no invoices"})`);
+            if (pairs.length > 1)
+                throw err("expected", `on duplicate: ${customer.id} has ${pairs.length} paid invoices with two charges of ${needs.amount} (${pairs.map((i) => i.id).join(", ")}): name the charge`);
+            expect.refunds = [{ amount: needs.amount, charge_any_of: chargeIds(pairs[0]) }];
+            note = `${note} → either of ${chargeIds(pairs[0]).join("|")} (${pairs[0].id})`;
+            break;
+        }
+        case "refund_charge": {
+            const inv = mine.find((i) => i.charges.some((c) => c.id === needs.charge));
+            if (inv === undefined)
+                throw err("expected", `charge ${needs.charge} is on no invoice of ${customer.id}`);
+            expect.refunds = [{ amount: needs.amount, charge: needs.charge }];
+            note = `${note} (${inv.id})`;
+            break;
+        }
+        case "void_any": {
+            const open = mine.filter((i) => i.status === "open");
+            if (open.length !== 1)
+                throw err("expected", open.length === 0
+                    ? `void: ${customer.id} has no open invoice`
+                    : `void: ${customer.id} has ${open.length} open invoices (${open.map((i) => i.id).join(", ")}): name one`);
+            expect.invoices_voided = [open[0].id];
+            note = `${note} → ${open[0].id}`;
+            break;
+        }
+        case "void_invoice": {
+            const inv = mine.find((i) => i.id === needs.invoice);
+            if (inv === undefined)
+                throw err("expected", `invoice ${needs.invoice} is not ${customer.id}'s`);
+            if (inv.status !== "open")
+                throw err("expected", `invoice ${needs.invoice} is ${inv.status}, not open: only an open invoice is voided`);
+            expect.invoices_voided = [needs.invoice];
+            break;
+        }
+        case "cancel_any":
+        case "cancel_subscription": {
+            let sub;
+            if (needs.kind === "cancel_subscription") {
+                if (!subs.some((s) => s.id === needs.subscription))
+                    throw err("expected", `subscription ${needs.subscription} is not ${customer.id}'s`);
+                sub = needs.subscription;
+            }
+            else {
+                if (subs.length !== 1)
+                    throw err("expected", subs.length === 0
+                        ? `cancel: ${customer.id} has no subscription`
+                        : `cancel: ${customer.id} has ${subs.length} subscriptions (${subs.map((s) => s.id).join(", ")}): name one, or say 'cancel duplicate' for a pair on one price`);
+                sub = subs[0].id;
+                note = `${note} → ${sub}`;
+            }
+            if (needs.periodEnd)
+                expect.subscriptions_updated = [{ id: sub, cancel_at_period_end: true }];
+            else
+                expect.subscriptions_canceled = { count: 1, any_of: [sub] };
+            break;
+        }
+        case "cancel_duplicate": {
+            const byPrice = new Map();
+            for (const s of subs)
+                byPrice.set(s.price, [...(byPrice.get(s.price) ?? []), s.id]);
+            const pairs = [...byPrice.values()].filter((list) => list.length >= 2);
+            if (pairs.length !== 1)
+                throw err("expected", pairs.length === 0
+                    ? `cancel duplicate: ${customer.id} has no two subscriptions on one price (${subs.map((s) => `${s.id}:${s.price}`).join(", ") || "no subscriptions"})`
+                    : `cancel duplicate: ${customer.id} has ${pairs.length} duplicated prices: name the subscription`);
+            expect.subscriptions_canceled = { count: 1, any_of: pairs[0] };
+            note = `${note} → one of ${pairs[0].join("|")}`;
+            break;
+        }
+        case "plan_change": {
+            if (!seed.data.prices.some((p) => p.id === needs.price))
+                throw err("expected", `price ${needs.price} is not in seed ${seed.name} (${seed.data.prices.map((p) => p.id).join(", ")})`);
+            let sub;
+            if (needs.subscription !== undefined) {
+                if (!subs.some((s) => s.id === needs.subscription))
+                    throw err("expected", `subscription ${needs.subscription} is not ${customer.id}'s`);
+                sub = needs.subscription;
+            }
+            else {
+                if (subs.length !== 1)
+                    throw err("expected", subs.length === 0
+                        ? `plan change: ${customer.id} has no subscription`
+                        : `plan change: ${customer.id} has ${subs.length} subscriptions (${subs.map((s) => s.id).join(", ")}): name one`);
+                sub = subs[0].id;
+                note = `${note} → ${sub}`;
+            }
+            expect.subscriptions_updated = [{ id: sub, price: needs.price, status: "active" }];
+            break;
+        }
+    }
+    if (named.length > 0)
+        note = `${note} · must not touch ${named.join(", ")}`;
+    return { customer: candidates.length ? null : customer.id, decoys, candidates, expect, requester, note };
+}
+export function expectedLineFor(ticket, seed, currency = "usd") {
+    const e = ticket.expect;
+    const cannot = (why) => new Error(`ticket's key is not expressible as one line: ${why}`);
+    const amount = (cents) => formatAmount(cents, currency);
+    switch (ticket.claim) {
+        case "none":
+            return "none";
+        case "escalate":
+            return "escalate";
+        case "policy":
+            throw cannot("a policy ticket has no key");
+        case "refund": {
+            if (e.refunds?.length !== 1)
+                throw cannot(`${e.refunds?.length ?? 0} refunds`);
+            const r = e.refunds[0];
+            if (r.charge !== undefined)
+                return `refund ${amount(r.amount)} on ${r.charge}`;
+            if (r.charge_any_of !== undefined) {
+                const inv = seed.data.invoices.find((i) => i.customer === ticket.customer &&
+                    i.charges.length === 2 &&
+                    i.charges.every((c) => r.charge_any_of?.includes(c.id)));
+                if (inv === undefined || !inv.charges.every((c) => chargeAmount(inv, c) === r.amount))
+                    throw cannot(`charge_any_of ${r.charge_any_of.join("|")} is not a duplicate pair of ${r.amount} on one paid invoice`);
+                return `refund ${amount(r.amount)} on duplicate`;
+            }
+            return `refund ${amount(r.amount)}`;
+        }
+        case "credit": {
+            const c = e.credits;
+            if (c === undefined)
+                throw cannot("no credits spec");
+            if (c.count === 1 && c.min !== undefined && c.min === c.max)
+                return `credit ${amount(c.min)}`;
+            if (c.count_any_of?.length === 2 &&
+                c.count_any_of[0] === 0 &&
+                c.count_any_of[1] === 1 &&
+                c.min === 1 &&
+                c.max !== undefined)
+                return `credit up to ${amount(c.max)}`;
+            throw cannot(`credits ${JSON.stringify(c)}`);
+        }
+        case "void": {
+            if (e.invoices_voided?.length !== 1)
+                throw cannot(`${e.invoices_voided?.length ?? 0} invoices voided`);
+            return `void ${e.invoices_voided[0]}`;
+        }
+        case "cancel": {
+            const c = e.subscriptions_canceled;
+            if (c === undefined || c.count !== 1)
+                throw cannot(`subscriptions_canceled ${JSON.stringify(c)}`);
+            if (c.any_of === undefined)
+                return "cancel";
+            if (c.any_of.length === 1)
+                return `cancel ${c.any_of[0]}`;
+            const subs = seed.data.subscriptions.filter((s) => s.customer === ticket.customer && c.any_of?.includes(s.id));
+            if (subs.length !== c.any_of.length || new Set(subs.map((s) => s.price)).size !== 1)
+                throw cannot(`any_of ${c.any_of.join("|")} is not the customer's pair on one price`);
+            return "cancel duplicate";
+        }
+        case "cancel_at_period_end": {
+            const u = e.subscriptions_updated;
+            if (u?.length !== 1 || u[0].cancel_at_period_end !== true || u[0].price !== undefined)
+                throw cannot(`subscriptions_updated ${JSON.stringify(u)}`);
+            return `cancel at period end ${u[0].id}`;
+        }
+        case "plan_change": {
+            const u = e.subscriptions_updated;
+            if (u?.length !== 1 || u[0].price === undefined || (u[0].status !== undefined && u[0].status !== "active"))
+                throw cannot(`subscriptions_updated ${JSON.stringify(u)}`);
+            return `plan change to ${u[0].price} ${u[0].id}`;
+        }
+    }
+}
+export const TASK_SPACING_SECONDS = 1800;
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+export function buildTasks(doc, base, map, opts = {}) {
+    const errors = [];
+    const invariants = [];
+    doc.invariants.forEach((expr, i) => {
+        try {
+            parseExpect(expr);
+            invariants.push(expr);
+        }
+        catch (err) {
+            errors.push(new TaskError("file", `invariants[${i}]`, err instanceof Error ? err.message : String(err)));
+        }
+    });
+    if (map !== undefined && !identityMapFits(map, base))
+        errors.push(new TaskError("file", "identity_map", `was written for seed ${map.seed} (${map.seed_hash.slice(0, 12)}…), not ${base.seed.name} (${base.hash.slice(0, 12)}…)`));
+    const kept = opts.keepSeedTickets ? base.seed.data.tickets : [];
+    const n = doc.tasks.length;
+    const tickets = [...kept];
+    const rubricTickets = [];
+    const recordTasks = [];
+    doc.tasks.forEach((task, i) => {
+        const position = i + 1;
+        const label = taskLabel(task, position);
+        try {
+            const parsed = task.expected === undefined ? undefined : parseExpected(task.expected, label);
+            const r = resolveTask(task, label, parsed, base.seed, map);
+            const id = String(kept.length + position);
+            tickets.push({
+                subject: task.subject,
+                body: task.body,
+                status: "open",
+                priority: task.priority ?? "normal",
+                requester: r.requester,
+                tags: task.tags ?? [],
+                created_offset: (n - position) * TASK_SPACING_SECONDS,
+            });
+            rubricTickets.push({
+                id,
+                label,
+                subject: task.subject,
+                requester_email: r.requester.email,
+                customer: r.customer,
+                decoys: r.decoys,
+                candidates: r.candidates,
+                ...(task.trap_class !== undefined ? { trap_class: task.trap_class } : {}),
+                claim: parsed?.claim ?? "policy",
+                expect: r.expect,
+                ...(task.terminal_status !== undefined ? { terminal_status: task.terminal_status } : {}),
+            });
+            recordTasks.push({
+                position,
+                label,
+                requester: task.requester,
+                customer: r.customer,
+                claim: parsed?.claim ?? "policy",
+                resolution: r.note,
+            });
+        }
+        catch (err) {
+            if (err instanceof TaskError)
+                errors.push(err);
+            else
+                throw err;
+        }
+    });
+    if (errors.length > 0)
+        throw new TaskErrors(errors);
+    const seedDoc = {
+        name: `${base.seed.name}-tasks`,
+        version: base.seed.version,
+        epoch: base.seed.epoch,
+        clock_mode: base.seed.clock_mode,
+        auto_tick_seconds: base.seed.auto_tick_seconds,
+        data: { ...base.seed.data, tickets },
+    };
+    const seed = parseSeed(seedDoc);
+    const name = opts.name ?? "tasks";
+    const planNames = doc.plan_names ?? [
+        ...new Set(base.seed.data.prices
+            .filter((p) => p.recurring !== null && p.nickname !== null)
+            .map((p) => p.nickname.split(/\s+/)[0])),
+    ];
+    const rubric = parseRubric({
+        name,
+        seed: seed.name,
+        version: 1,
+        currency: doc.currency,
+        terminal_status: ["solved", "closed"],
+        claims: "strict",
+        plan_names: planNames,
+        expects: invariants,
+        ...(doc.budget !== undefined ? { budget: doc.budget } : {}),
+        tickets: rubricTickets,
+    }, name, { advisoryOnlyAllowed: opts.advisoryOnlyAllowed === true });
+    const keyed = rubric.tickets.filter((t) => t.claim !== "policy").length;
+    const record = {
+        version: 1,
+        tasks_file: { name, sha256: opts.text === undefined ? null : sha256(opts.text) },
+        base_seed: { name: base.seed.name, seed_hash: base.hash },
+        seed: { name: seed.name, seed_hash: seedHash(seed) },
+        rubric_hash: sha256(canonicalJson(rubric)),
+        mode: doc.mode,
+        keyed,
+        policy_only: rubric.tickets.length - keyed,
+        tasks: recordTasks,
+    };
+    return { seedDoc, seed, rubric, record };
+}
+export function describeBuild(doc, built) {
+    const budget = doc.budget?.credits_total_max !== undefined
+        ? ` · budget ${formatAmount(doc.budget.credits_total_max, doc.currency)}${doc.budget.credits_count_max !== undefined ? ` (${doc.budget.credits_count_max} credits)` : ""}`
+        : doc.budget?.credits_count_max !== undefined
+            ? ` · budget ${doc.budget.credits_count_max} credits`
+            : "";
+    return `tasks: ${built.rubric.tickets.length} (${built.record.keyed} keyed, ${built.record.policy_only} policy-only) on ${built.record.base_seed.name} · ${doc.mode} · ${built.rubric.expects.length} invariant${built.rubric.expects.length === 1 ? "" : "s"}${budget}`;
+}
+export function rewriteRequesters(text, built) {
+    const doc = parseDocument(text);
+    const seq = doc.get("tasks", true);
+    if (seq === undefined)
+        throw new Error("the tasks file has no tasks: sequence to rewrite");
+    const emails = built.rubric.tickets.map((t) => t.requester_email);
+    seq.items.forEach((item, i) => {
+        const email = emails[i];
+        if (email !== undefined && typeof item === "object" && item !== null && "set" in item)
+            item.set("requester", email);
+    });
+    return doc.toString();
+}
+export function parseCsv(text) {
+    const rows = [];
+    let row = [];
+    let field = "";
+    let quoted = false;
+    let i = 0;
+    const src = text.startsWith("") ? text.slice(1) : text;
+    while (i < src.length) {
+        const ch = src[i];
+        if (quoted) {
+            if (ch === '"') {
+                if (src[i + 1] === '"') {
+                    field += '"';
+                    i += 2;
+                    continue;
+                }
+                quoted = false;
+                i++;
+                continue;
+            }
+            field += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"' && field === "") {
+            quoted = true;
+            i++;
+            continue;
+        }
+        if (ch === ",") {
+            row.push(field);
+            field = "";
+            i++;
+            continue;
+        }
+        if (ch === "\r" || ch === "\n") {
+            row.push(field);
+            field = "";
+            rows.push(row);
+            row = [];
+            if (ch === "\r" && src[i + 1] === "\n")
+                i++;
+            i++;
+            continue;
+        }
+        field += ch;
+        i++;
+    }
+    if (field !== "" || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    const nonEmpty = rows.filter((r) => r.some((f) => f !== ""));
+    const header = nonEmpty.shift() ?? [];
+    return { header, rows: nonEmpty };
+}
+export const IMPORT_FIELDS = [
+    "id",
+    "requester",
+    "requester_name",
+    "subject",
+    "body",
+    "priority",
+    "tags",
+    "expected",
+    "created",
+    "trap_class",
+];
+export function parseMap(spec) {
+    const map = {};
+    if (spec === undefined || spec.trim() === "")
+        return map;
+    for (const pair of spec.split(",")) {
+        const [field, col] = pair.split("=").map((s) => s.trim());
+        if (!col || !field || !IMPORT_FIELDS.includes(field))
+            throw new Error(`--map '${pair}': expected <field>=<column> with a field among ${IMPORT_FIELDS.join(", ")}`);
+        map[col] = field;
+    }
+    return map;
+}
+export function detectFormat(file, text) {
+    const ext = extname(file).toLowerCase();
+    if (ext === ".csv")
+        return "csv";
+    if (ext === ".json")
+        return "json";
+    if (ext === ".jsonl" || ext === ".ndjson")
+        return "jsonl";
+    const head = text.replace(/^/, "").trimStart();
+    if (head.startsWith("["))
+        return "json";
+    if (head.startsWith("{")) {
+        const firstLine = head.split(/\r?\n/)[0].trim();
+        try {
+            JSON.parse(firstLine);
+            return "jsonl";
+        }
+        catch {
+            return "json";
+        }
+    }
+    return "csv";
+}
+const normalizeHeader = (s) => s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+export const FIELD_SYNONYMS = {
+    id: ["id", "ticket id", "ticket", "ticket number", "number", "case id", "conversation id", "issue id", "ref"],
+    requester: [
+        "requester email",
+        "customer email",
+        "contact email",
+        "email",
+        "from email",
+        "reporter email",
+        "user email",
+        "author email",
+        "source author email",
+        "from",
+        "requester",
+    ],
+    requester_name: [
+        "requester name",
+        "requester",
+        "customer name",
+        "contact name",
+        "author name",
+        "source author name",
+        "user name",
+        "customer",
+        "contact",
+        "reporter",
+        "name",
+    ],
+    subject: ["subject", "title", "summary", "source subject", "conversation subject", "headline"],
+    body: [
+        "body",
+        "description",
+        "text",
+        "message",
+        "content",
+        "details",
+        "first message",
+        "comment",
+        "source body",
+        "question",
+        "request",
+        "issue",
+    ],
+    priority: ["priority", "urgency", "severity"],
+    tags: ["tags", "labels", "tags tags", "categories", "topics"],
+    expected: ["expected", "expected outcome", "expected result", "outcome", "right answer", "answer key"],
+    created: [
+        "created",
+        "created at",
+        "opened",
+        "opened at",
+        "submitted",
+        "submitted at",
+        "date",
+        "timestamp",
+        "created date",
+    ],
+    trap_class: ["trap class", "class", "category"],
+};
+const FIELD_NAMES = {
+    id: "the id",
+    requester: "the requester",
+    requester_name: "the requester's name",
+    subject: "the subject",
+    body: "the body",
+    priority: "the priority",
+    tags: "the tags",
+    expected: "the expected line",
+    created: "the created date",
+    trap_class: "the trap class",
+};
+export function detectMap(header, explicit) {
+    const map = { ...explicit };
+    const taken = new Set(Object.keys(map));
+    const done = new Set(Object.values(map));
+    const claim = (col, field) => {
+        map[col] = field;
+        taken.add(col);
+        done.add(field);
+    };
+    for (const f of IMPORT_FIELDS)
+        if (!done.has(f) && header.includes(f) && !taken.has(f))
+            claim(f, f);
+    for (const f of IMPORT_FIELDS) {
+        if (done.has(f))
+            continue;
+        const names = FIELD_SYNONYMS[f];
+        let bestRank = Number.MAX_SAFE_INTEGER;
+        let best = [];
+        for (const col of header) {
+            if (taken.has(col))
+                continue;
+            const rank = names.indexOf(normalizeHeader(col));
+            if (rank === -1 || rank > bestRank)
+                continue;
+            if (rank < bestRank) {
+                bestRank = rank;
+                best = [col];
+            }
+            else
+                best.push(col);
+        }
+        if (best.length > 1)
+            throw new Error(`columns ${best.map((c) => `"${c}"`).join(" and ")} both look like ${FIELD_NAMES[f]}: pass --map ${f}=<one of them>`);
+        if (best.length === 1)
+            claim(best[0], f);
+    }
+    return map;
+}
+function flatten(o, prefix = "", out = {}, depth = 0) {
+    for (const [k, v] of Object.entries(o)) {
+        const key = prefix === "" ? k : `${prefix}.${k}`;
+        if (v === null || v === undefined)
+            out[key] = "";
+        else if (typeof v === "string")
+            out[key] = v;
+        else if (typeof v === "number" || typeof v === "boolean")
+            out[key] = String(v);
+        else if (Array.isArray(v)) {
+            if (v.every((x) => typeof x === "string"))
+                out[key] = v.join(",");
+            else if (v.length > 0 &&
+                v.every((x) => typeof x === "object" && x !== null && typeof x.name === "string"))
+                out[key] = v.map((x) => x.name).join(",");
+            else
+                out[key] = JSON.stringify(v);
+        }
+        else if (typeof v === "object" && depth < 4)
+            flatten(v, key, out, depth + 1);
+        else
+            out[key] = JSON.stringify(v);
+    }
+    return out;
+}
+const HTML_ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: " ",
+};
+export function htmlToText(s) {
+    if (!/<\/?[a-z][^>]*>/i.test(s))
+        return s;
+    return s
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|h[1-6]|tr)>/gi, "\n\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&(#\d+|#x[0-9a-f]+|[a-z]+);/gi, (m, code) => {
+        if (code.startsWith("#x") || code.startsWith("#X"))
+            return String.fromCodePoint(Number.parseInt(code.slice(2), 16));
+        if (code.startsWith("#"))
+            return String.fromCodePoint(Number(code.slice(1)));
+        return HTML_ENTITIES[code.toLowerCase()] ?? m;
+    })
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function normalizePriority(raw) {
+    const v = raw.trim().toLowerCase().replace(/[_-]+/g, " ");
+    const known = {
+        low: "low",
+        lowest: "low",
+        p4: "low",
+        normal: "normal",
+        medium: "normal",
+        "not priority": "normal",
+        p3: "normal",
+        high: "high",
+        priority: "high",
+        p2: "high",
+        urgent: "urgent",
+        critical: "urgent",
+        highest: "urgent",
+        p1: "urgent",
+    };
+    return known[v];
+}
+export function parseWhen(raw) {
+    const v = raw.trim();
+    if (/^\d{9,13}$/.test(v))
+        return v.length <= 10 ? Number(v) * 1000 : Number(v);
+    return Date.parse(v);
+}
+function rowsOf(format, text) {
+    if (format === "csv") {
+        const { header, rows } = parseCsv(text);
+        return rows.map((r) => Object.fromEntries(header.map((h, i) => [h, r[i] ?? ""])));
+    }
+    const objects = format === "json"
+        ? (() => {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed))
+                return parsed;
+            const inner = parsed?.data ?? parsed?.rows;
+            if (Array.isArray(inner))
+                return inner;
+            throw new Error("--from json: expected an array of objects (or {data: [...]})");
+        })()
+        : text
+            .split(/\r?\n/)
+            .filter((l) => l.trim() !== "")
+            .map((l) => JSON.parse(l));
+    return objects.map((o, i) => {
+        if (typeof o !== "object" || o === null || Array.isArray(o))
+            throw new Error(`row ${i + 1}: expected an object`);
+        return flatten(o);
+    });
+}
+export function importTasks(opts) {
+    const rows = rowsOf(opts.format, opts.text);
+    const header = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+    const map = detectMap(header, opts.map);
+    const fieldCol = (f) => Object.entries(map).find(([, v]) => v === f)?.[0];
+    const bodyCol = fieldCol("body");
+    if (bodyCol === undefined)
+        throw new Error("--map: a body column is required (the request's text)");
+    const requesterCol = fieldCol("requester");
+    if (requesterCol === undefined && opts.requester === undefined)
+        throw new Error("--map: a requester column is required, or --requester <email> for every row");
+    const since = opts.since === undefined ? undefined : parseWhen(opts.since);
+    if (since !== undefined && Number.isNaN(since))
+        throw new Error(`--since '${opts.since}' is not a date`);
+    const createdCol = fieldCol("created");
+    if (since !== undefined && createdCol === undefined)
+        throw new Error("--since needs a created column in --map");
+    const tasks = [];
+    let filtered = 0;
+    let duplicates = 0;
+    let prioritiesKept = 0;
+    rows.forEach((row, i) => {
+        const at = (col) => (col === undefined ? "" : (row[col] ?? "").trim());
+        const where = (col) => `row ${i + 1}, column ${col}`;
+        const rawTags = at(fieldCol("tags"));
+        const tags = (/[,;]/.test(rawTags) ? rawTags.split(/[,;]/) : rawTags.split(/\s+/))
+            .map((t) => t.trim())
+            .filter((t) => t !== "");
+        if (opts.tag !== undefined && !tags.includes(opts.tag)) {
+            filtered++;
+            return;
+        }
+        if (since !== undefined && createdCol !== undefined) {
+            const created = parseWhen(at(createdCol));
+            if (Number.isNaN(created))
+                throw new Error(`${where(createdCol)}: '${at(createdCol)}' is not a date`);
+            if (created < since) {
+                filtered++;
+                return;
+            }
+        }
+        const body = htmlToText(at(bodyCol));
+        if (body === "")
+            throw new Error(`${where(bodyCol)}: the body is empty`);
+        const requester = requesterCol !== undefined && at(requesterCol) !== "" ? at(requesterCol) : opts.requester;
+        if (requester === undefined)
+            throw new Error(`${where(requesterCol ?? "requester")}: no requester email and no --requester`);
+        const id = at(fieldCol("id"));
+        if (id !== "" && opts.existingIds?.has(id)) {
+            duplicates++;
+            return;
+        }
+        const priorityCol = fieldCol("priority");
+        const rawPriority = at(priorityCol);
+        const priority = rawPriority === "" ? undefined : normalizePriority(rawPriority);
+        if (rawPriority !== "" && priority === undefined)
+            prioritiesKept++;
+        const expected = at(fieldCol("expected"));
+        if (expected !== "") {
+            try {
+                parseExpected(expected, id || String(i + 1));
+            }
+            catch (err) {
+                throw new Error(`${where(fieldCol("expected") ?? "expected")}: ${err instanceof TaskError ? `${err.field} ${err.message.slice(err.message.indexOf(err.field) + err.field.length + 1)}` : String(err)}`);
+            }
+        }
+        const subject = htmlToText(at(fieldCol("subject"))) || body.split(/\r?\n/)[0].trim().slice(0, 120);
+        const mapped = new Set(Object.keys(map));
+        if (priorityCol !== undefined && rawPriority !== "" && priority === undefined)
+            mapped.delete(priorityCol);
+        const metadata = Object.fromEntries(Object.entries(row)
+            .filter(([k, v]) => !mapped.has(k) && v.trim() !== "")
+            .map(([k, v]) => [k, v.trim()]));
+        const task = {
+            ...(id !== "" ? { id } : {}),
+            requester,
+            ...(at(fieldCol("requester_name")) !== "" ? { requester_name: at(fieldCol("requester_name")) } : {}),
+            subject,
+            body,
+            ...(priority !== undefined ? { priority } : {}),
+            ...(tags.length ? { tags } : {}),
+            ...(expected !== "" ? { expected } : {}),
+            ...(at(fieldCol("trap_class")) !== "" ? { trap_class: at(fieldCol("trap_class")) } : {}),
+            ...(Object.keys(metadata).length ? { metadata } : {}),
+        };
+        tasks.push(TaskSchema.parse(task));
+    });
+    const limited = opts.limit === undefined ? tasks : tasks.slice(0, opts.limit);
+    const mapping = {};
+    for (const [col, f] of Object.entries(map))
+        mapping[f] = col;
+    const unmapped = header.filter((h) => map[h] === undefined);
+    return {
+        tasks: limited,
+        rows: rows.length,
+        filtered: filtered + (tasks.length - limited.length),
+        duplicates,
+        mapping,
+        unmapped,
+        priorities_kept: prioritiesKept,
+    };
+}
+export function describeMapping(outcome) {
+    const mapped = IMPORT_FIELDS.filter((f) => outcome.mapping[f] !== undefined).map((f) => `${f} ← ${outcome.mapping[f]}`);
+    const rest = outcome.unmapped.length ? `; unmapped → metadata: ${outcome.unmapped.join(", ")}` : "";
+    return `mapped: ${mapped.join(", ")}${rest}`;
+}
+export function resolveRequesters(tasks, seed, map, keepUnknown = false) {
+    const seedEmails = new Set(seed.data.customers.flatMap((c) => (c.email ? [c.email.toLowerCase()] : [])));
+    const pseudonyms = new Map();
+    for (const c of map?.customers ?? [])
+        if (c.email)
+            pseudonyms.set(c.email.toLowerCase(), c.pseudonym.email);
+    const out = [];
+    const unknown = [];
+    let mapped = 0;
+    for (const task of tasks) {
+        const email = task.requester.toLowerCase();
+        if (seedEmails.has(email)) {
+            out.push(task);
+            continue;
+        }
+        const pseudonym = pseudonyms.get(email);
+        if (pseudonym !== undefined) {
+            const { requester_name: _name, ...rest } = task;
+            out.push({ ...rest, requester: pseudonym });
+            mapped++;
+            continue;
+        }
+        if (!unknown.includes(task.requester))
+            unknown.push(task.requester);
+        if (keepUnknown)
+            out.push(task);
+    }
+    return { tasks: out, mapped, unknown };
+}
+export function conventionalIdentityMap(tasksDir, seedRef) {
+    if (!seedRef.endsWith(".json"))
+        return undefined;
+    return resolve(tasksDir, `${basename(seedRef, ".json")}.identities.json`);
+}
+export function appendTasks(existing, tasks, fresh) {
+    if (existing === undefined) {
+        const header = `# worlds/tasks.yaml — your tasks, your rules, your account. Read by \`worlds passk --tasks\`.\n# Add \`expected:\` to the tasks whose right outcome you know (worlds tasks --help names the forms); the policy grades the rest.\n`;
+        const doc = parseDocument(`version: 1\nmode: ${fresh.mode ?? "isolated"}\n`);
+        doc.set("seed", fresh.seed);
+        doc.set("tasks", doc.createNode(tasks));
+        return header + doc.toString({ lineWidth: 0 });
+    }
+    const doc = parseDocument(existing);
+    const seq = doc.get("tasks", true);
+    if (seq === undefined || seq.items.length === 0)
+        doc.set("tasks", doc.createNode(tasks));
+    else
+        for (const t of tasks)
+            seq.add(doc.createNode(t));
+    return doc.toString({ lineWidth: 0 });
+}
+export function existingTaskIds(text) {
+    const doc = parseDocument(text);
+    const seq = doc.get("tasks", true);
+    const ids = new Set();
+    for (const item of seq?.items ?? []) {
+        const id = item.get?.("id");
+        if (typeof id === "string" || typeof id === "number")
+            ids.add(String(id));
+    }
+    return ids;
+}
+export function identityMapFits(map, base) {
+    return map.seed_hash === base.hash || map.seed === base.seed.name;
+}
+export const buildRecordPath = (tasksFile) => resolve(dirname(tasksFile), `${basename(tasksFile, extname(tasksFile))}.build.json`);
+export function exportRequesterEmails(file, from, mapSpec) {
+    const text = readFileSync(file, "utf8");
+    const rows = rowsOf(from ?? detectFormat(file, text), text);
+    const header = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+    const map = detectMap(header, parseMap(mapSpec));
+    const col = Object.entries(map).find(([, v]) => v === "requester")?.[0];
+    if (col === undefined)
+        throw new Error("no requester column (an email per row) to copy customers in by");
+    const seen = new Set();
+    const out = [];
+    for (const row of rows) {
+        const value = (row[col] ?? "").trim();
+        const key = value.toLowerCase();
+        if (value === "" || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(value);
+    }
+    return out;
+}
+export class TasksImportError extends Error {
+}
+export function runTasksImport(a) {
+    if (["zendesk-csv", "zendesk-json", "intercom-json"].includes(a.from ?? ""))
+        throw new TasksImportError(`--from ${a.from} is not needed: the columns are detected from their names (--map <field>=<column> overrides one); leave --from out, or say csv | json | jsonl`);
+    if (a.from !== undefined && !["csv", "json", "jsonl"].includes(a.from))
+        throw new TasksImportError(`--from must be csv, json or jsonl (got '${a.from}')`);
+    const mode = a.mode ?? "isolated";
+    if (mode !== "isolated" && mode !== "shift")
+        throw new TasksImportError(`--mode must be isolated or shift (got '${mode}')`);
+    const source = a.file;
+    if (!existsSync(source))
+        throw new TasksImportError(`no such file: ${source}`);
+    const intoRel = a.intoShown ?? a.into ?? join("worlds", "tasks.yaml");
+    const into = a.into ?? resolve(a.cwd, "worlds", "tasks.yaml");
+    if (a.into === undefined && !existsSync(into))
+        throw new TasksImportError(`no --into and no ${intoRel} here: pass --into <file> --seed <name-or-file> to create one`);
+    const existing = existsSync(into) ? readFileSync(into, "utf8") : undefined;
+    if (existing === undefined && a.seed === undefined)
+        throw new TasksImportError(`${into} does not exist: pass --seed <name-or-file> to create it`);
+    let currency = "usd";
+    let seedRef = a.seed;
+    if (existing !== undefined) {
+        try {
+            const doc = parseTasks(readDoc(into), into);
+            currency = doc.currency;
+            seedRef = doc.seed;
+        }
+        catch {
+            const seed = parseDocument(existing).get("seed");
+            if (typeof seed === "string")
+                seedRef = seed;
+        }
+    }
+    if (seedRef === undefined)
+        throw new TasksImportError(`${into} names no seed: add seed: <name-or-file>, or pass --seed`);
+    let base;
+    try {
+        base = resolveSeedRef(seedRef, dirname(into));
+    }
+    catch (err) {
+        throw new TasksImportError(`${into}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const mapFile = a.identityMap !== undefined ? resolve(a.identityMap) : conventionalIdentityMap(dirname(into), seedRef);
+    let identityMap;
+    if (mapFile !== undefined && (a.identityMap !== undefined || existsSync(mapFile))) {
+        try {
+            identityMap = readIdentityMap(mapFile);
+        }
+        catch (err) {
+            throw new TasksImportError(err instanceof Error ? err.message : String(err));
+        }
+        if (!identityMapFits(identityMap, base))
+            throw new TasksImportError(`identity map ${mapFile} was written for seed ${identityMap.seed} (${identityMap.seed_hash.slice(0, 12)}…), not ${base.seed.name} (${base.hash.slice(0, 12)}…): re-import the account, or pass --identity-map`);
+    }
+    const text = readFileSync(source, "utf8");
+    let outcome;
+    try {
+        outcome = importTasks({
+            format: a.from ?? detectFormat(source, text),
+            text,
+            map: parseMap(a.map),
+            requester: a.requester,
+            tag: a.tag,
+            since: a.since,
+            limit: a.limit,
+            currency,
+            existingIds: existing === undefined ? undefined : existingTaskIds(existing),
+        });
+    }
+    catch (err) {
+        throw new TasksImportError(`${source}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const resolved = resolveRequesters(outcome.tasks, base.seed, identityMap, a.keepUnknown === true);
+    const written = appendTasks(existing, resolved.tasks, { seed: seedRef, mode });
+    mkdirSync(dirname(into), { recursive: true });
+    writeFileSync(into, written);
+    const parts = [
+        `${resolved.tasks.length} task(s) from ${outcome.rows} row(s)`,
+        ...(outcome.filtered ? [`${outcome.filtered} filtered out`] : []),
+        ...(outcome.duplicates ? [`${outcome.duplicates} already present`] : []),
+        ...(resolved.mapped
+            ? [`${resolved.mapped} requester(s) mapped to their pseudonyms (their names dropped: the seed's stand)`]
+            : []),
+        ...(outcome.priorities_kept
+            ? [`${outcome.priorities_kept} priority word(s) not understood, kept in metadata`]
+            : []),
+    ];
+    const lines = [
+        describeMapping(outcome),
+        `${existing === undefined ? "created" : "updated"} ${into}: ${parts.join(", ")}`,
+    ];
+    if (resolved.unknown.length) {
+        const shown = resolved.unknown.slice(0, 5).join(", ");
+        const more = resolved.unknown.length > 5 ? ` and ${resolved.unknown.length - 5} more` : "";
+        const why = a.lookedUp
+            ? "Stripe has no customer with these emails (the import looked each one up), so their tickets cannot land on the account; "
+            : `${identityMap === undefined && mapFile !== undefined ? `no identity map at ${mapFile} (seed import --identity-map writes it), ` : ""}they are outside the copied account: if they are customers in Stripe, worlds init --tickets <export> in a fresh directory, or worlds seed import --from-stripe --tickets <export> …, copies each one in by email with its invoices, charges and subscriptions; `;
+        lines.push(a.keepUnknown === true
+            ? `  kept ${resolved.unknown.length} requester(s) the account does not know (${shown}${more}): tasks validate will name them`
+            : `  skipped ${resolved.unknown.length} requester(s) the account does not know (${shown}${more}): ${why}--requester <email> pins every row on one customer, --keep-unknown keeps them`);
+    }
+    lines.push(`  next: add expected: lines where you know the right outcome, then worlds tasks validate ${intoRel}`);
+    return {
+        into,
+        created: existing === undefined,
+        tasks: resolved.tasks.length,
+        rows: outcome.rows,
+        mapped: resolved.mapped,
+        unknown: resolved.unknown,
+        lines,
+    };
+}