agentera 3.0.0-dev.79 → 3.0.0-dev.80

package/bundle/references/artifacts/state-storage-authority.yaml

@@ -2915,51 +2915,58 @@ mutation_grammar:
       verb: create
       class: record_payload
       selectors: []
-      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, full_typed_record_is_valid, readiness_is_complete_or_needs_triage, dependency_graph_is_valid]
+      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, singleton_or_versioned_batch_shape_is_valid, full_typed_records_are_valid, duplicate_local_references_are_absent, all_ids_are_allocated_before_local_reference_resolution, dependency_graph_is_valid, batch_effect_is_previewed_and_confirmed]
       owned_fields: [id, artifact, status, public_order, lifecycle]
       input:
         mode: structured
-        root: full typed TODO record
+        root: full typed TODO record or agentera.todoCreateBatch.v1 envelope
         sources: [file, stdin]
         structured_sources: [file, stdin]
         cli_owned_fields: [id, artifact, status, public_order, lifecycle]
-      recovery: Run npx -y agentera@next state todo explain --verb create --format json, remove CLI-owned fields, provide the full typed TODO record, and retry.
+      recovery: For one item, preserve the existing full-record form. For a batch, supply agentera.todoCreateBatch.v1, preview with --dry-run, then repeat the same input with its effect SHA-256 and --yes.
       examples: ['npx -y agentera@next state todo create --input todo.yaml --format json']
-      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 100 }
-      fields: []
+      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 256 }
+      fields:
+        - { flag: --effect-sha256, field: effect_sha256, kind: string }
+        - { flag: --yes, field: confirmed, kind: boolean }
 
     - artifact: todo
       verb: update
       class: record_payload
       selectors: [--id]
-      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, target_id_is_bare_ten_letters, typed_patch_is_valid, dependency_graph_is_valid]
+      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, singleton_or_versioned_batch_shape_is_valid, target_ids_are_bare_ten_letters, duplicate_targets_are_absent, typed_patches_are_valid, dependency_graph_is_valid, batch_effect_is_previewed_and_confirmed]
       owned_fields: [id, artifact, status, public_order, lifecycle]
       input:
         mode: structured
-        root: TODO record patch
+        root: TODO record patch or agentera.todoUpdateBatch.v1 envelope
         sources: [file, stdin]
         structured_sources: [file, stdin]
         cli_owned_fields: [id, artifact, status, public_order, lifecycle]
-      recovery: Reread the TODO item, use its bare ID, supply only typed patch fields, and use null or an empty list only for declared clearable fields.
+      recovery: For one item, preserve the existing --id and patch form. For a batch, supply agentera.todoUpdateBatch.v1, preview with --dry-run, then repeat the same input with its effect SHA-256 and --yes.
       examples: ['npx -y agentera@next state todo update --id qjtrmnpvka --input todo-patch.yaml --format json']
-      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 1 }
-      fields: [{ flag: --id, field: id, kind: string, required: true }]
+      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 256 }
+      fields:
+        - { flag: --id, field: id, kind: string, required: true }
+        - { flag: --effect-sha256, field: effect_sha256, kind: string }
+        - { flag: --yes, field: confirmed, kind: boolean }
 
     - artifact: todo
       verb: set-severity
       class: simple_transition
       selectors: [--id]
-      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, target_id_is_bare_ten_letters, severity_is_valid, reason_and_date_are_present]
+      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, singleton_or_agentera_todoSetSeverityBatch_v1_shape_is_valid, target_ids_are_bare_ten_letters, duplicate_targets_are_absent, severity_is_valid, reason_and_date_are_present, batch_effect_is_previewed_and_confirmed]
       owned_fields: [id, artifact, severity, lifecycle]
-      input: { mode: none, sources: [], cli_owned_fields: [] }
-      recovery: Use the bare TODO ID, one immediate-impact severity, a reason, and a YYYY-MM-DD date; no record input is accepted.
+      input: { mode: structured, root: agentera.todoSetSeverityBatch.v1 envelope, optional: true, sources: [file, stdin], structured_sources: [file, stdin], cli_owned_fields: [] }
+      recovery: Use singleton flags unchanged, or supply agentera.todoSetSeverityBatch.v1 through --input, preview it, then exact-apply it with the effect SHA-256 and --yes.
       examples: ['npx -y agentera@next state todo set-severity --id qjtrmnpvka --severity degraded --reason "Impact changed" --date 2026-07-31 --format json']
-      bounds: { max_input_utf8_bytes: 0, max_collection_items: 1, max_reason_code_points: 500 }
+      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 256, max_reason_code_points: 500 }
       fields:
         - { flag: --id, field: id, kind: string, required: true }
         - { flag: --severity, field: severity, kind: string, required: true, valid_values: [critical, degraded, normal, annoying] }
         - { flag: --reason, field: lifecycle.reason, kind: string, required: true }
         - { flag: --date, field: lifecycle.date, kind: date, required: true }
+        - { flag: --effect-sha256, field: effect_sha256, kind: string }
+        - { flag: --yes, field: confirmed, kind: boolean }
 
     - artifact: todo
       verb: supersede
@@ -2981,16 +2988,18 @@ mutation_grammar:
       verb: resolve
       class: simple_transition
       selectors: [--id]
-      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, target_id_is_bare_ten_letters, item_is_open, reason_and_date_are_present]
+      preconditions: [entity_mode_marker_is_valid, todo_reconciliation_is_valid, singleton_or_agentera_todoResolveBatch_v1_shape_is_valid, target_ids_are_bare_ten_letters, duplicate_targets_are_absent, every_item_is_open, reason_and_date_are_present, batch_effect_is_previewed_and_confirmed]
       owned_fields: [id, artifact, status, lifecycle]
-      input: { mode: none, sources: [], cli_owned_fields: [] }
-      recovery: Use the bare TODO ID, a reason, and a YYYY-MM-DD date; no record input is accepted.
+      input: { mode: structured, root: agentera.todoResolveBatch.v1 envelope, optional: true, sources: [file, stdin], structured_sources: [file, stdin], cli_owned_fields: [] }
+      recovery: Use singleton flags unchanged, or supply agentera.todoResolveBatch.v1 through --input, preview it, then exact-apply it with the effect SHA-256 and --yes.
       examples: ['npx -y agentera@next state todo resolve --id qjtrmnpvka --reason "Shipped" --date 2026-07-31 --format json']
-      bounds: { max_input_utf8_bytes: 0, max_collection_items: 1, max_reason_code_points: 500 }
+      bounds: { max_input_utf8_bytes: 32768, max_collection_items: 256, max_reason_code_points: 500 }
       fields:
         - { flag: --id, field: id, kind: string, required: true }
         - { flag: --reason, field: lifecycle.reason, kind: string, required: true }
         - { flag: --date, field: lifecycle.date, kind: date, required: true }
+        - { flag: --effect-sha256, field: effect_sha256, kind: string }
+        - { flag: --yes, field: confirmed, kind: boolean }
 
     - artifact: todo
       verb: reopen

package/bundle/skills/agentera/schemas/artifacts/todo.yaml

@@ -134,10 +134,13 @@ LIFECYCLE:
   description: >-
     activate is a flag-only reconciliation transition that requires the
     preview effect SHA-256 and explicit confirmation. Item lifecycle transitions
-    set-severity, supersede, resolve, and reopen require a reason and date;
+    Singleton set-severity, supersede, resolve, and reopen require flag-only
+    reason and date values. Set-severity and resolve also accept strict
+    agentera.todoSetSeverityBatch.v1 and agentera.todoResolveBatch.v1 envelopes;
+    batches require dry-run preview and exact effect-confirmed apply.
     supersede additionally requires a distinct existing replacement ID. These
-    operations never accept structured record content or use Markdown
-    strikethrough.
+    These operations never accept unversioned structured record content or use
+    Markdown strikethrough.
   clearable_patch_fields: [target_version, requirements, acceptance, readiness]
   cli_owned_fields: [id, artifact, status, public_order, lifecycle]
   transition_fields: [reason, date, replacement]

package/dist/.agentera-build-source.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "agentera.generatedBuildSource.v1",
-  "commit": "b22922ec963df96099033595c72d26aa0ef45a0b",
-  "tree": "9711c04dcf28117032a46f83f628a3e8abe00ce0",
-  "files": 6835,
-  "workingTreeSha256": "09d0c5b86327910ad828a654ea6eb6679dda41a085ed03a452187d1d0c3265d7",
-  "identitySha256": "32f7d71e8664b15a675406df2cfb669a2d3dac0ffdfefaa026d25debbc590347"
+  "commit": "296cb7e29c2521b95985f933b08f1a5d7724b4f0",
+  "tree": "732d6174b4bbf04834ff7fde86172e24ad69689c",
+  "files": 6856,
+  "workingTreeSha256": "0c148b6e30d19f0945267efa03f12d71e92587c80f8744b1cc1e0541de2ab9bd",
+  "identitySha256": "aec00264c492a72d7501ee6e58d69fa6fd1f10e0b3d5d75b0feff257e5874914"
 }

package/dist/cli/capabilityContext/progress.js

@@ -20,10 +20,11 @@ export function progressVerificationSummary(progress) {
     }
     const latest = progress.latest && typeof progress.latest === "object" && !Array.isArray(progress.latest) ? progress.latest : {};
     const verified = latest.verified;
-    const latestVerification = progress.latest_verification && typeof progress.latest_verification === "object" && !Array.isArray(progress.latest_verification)
-        ? progress.latest_verification
-        : {};
-    const projectedVerifiedPresent = latest.verified_present === true || latestVerification.present === true;
+    const latestVerification = progress.latest_verification;
+    const projectedVerifiedPresent = latest.verified_present === true ||
+        (latestVerification && typeof latestVerification === "object" && !Array.isArray(latestVerification)
+            ? latestVerification.present === true
+            : hasRecordedValue(latestVerification));
     const verifiedPresent = hasRecordedValue(verified) || projectedVerifiedPresent;
     const cycle = {};
     for (const key of ["number", "timestamp", "type", "phase"]) {
@@ -40,8 +41,8 @@ export function progressVerificationSummary(progress) {
         verified_present: verifiedPresent,
         non_empty_evidence_present: verifiedPresent,
         non_empty_evidence_fields: evidenceFields,
-        verified: hasRecordedValue(verified) ? verified : null,
-        verification_summary: hasRecordedValue(verified) ? verified : projectedVerifiedPresent ? { present: true } : null,
+        verified: hasRecordedValue(verified) ? verified : projectedVerifiedPresent ? latestVerification : null,
+        verification_summary: hasRecordedValue(verified) ? verified : projectedVerifiedPresent ? latestVerification : null,
         latest_progress_verification_pointer: pointer,
         caveats,
     };

package/dist/cli/commands/prime.js

@@ -59,6 +59,19 @@ export function cmdPrime(args, io = {}) {
         err("Error: prime --dashboard/--orientation and prime --guidance are mutually exclusive\n");
         return 2;
     }
+    if (dashboard && args.fields !== undefined) {
+        const migrationCommand = preCutoverCommand("prime --context status --format json");
+        return rejectInput({
+            class: "mutually_exclusive",
+            message: "Deprecated prime --dashboard --fields selectors are not supported during status-capsule migration",
+            example: migrationCommand,
+            diagnosis: {
+                migration_command: migrationCommand,
+                consumer_path: "capability_context.context.status_context",
+            },
+            recovery: `Run '${migrationCommand}' and read capability_context.context.status_context; no state was changed.`,
+        });
+    }
     const retiredFieldRejection = rejectRetiredPrimeFields(command, format, args.fields, out, err);
     if (retiredFieldRejection !== null)
         return retiredFieldRejection;

package/dist/cli/commands/state/write.js

@@ -5,6 +5,8 @@ import { emitStructured } from "../../structured.js";
 import { StateRetrievalFailure } from "../../../state/directRetrieval.js";
 import { normalizeArtifactProtocolId, VALIDATE_ARTIFACT_PROTOCOL_IDS, } from "../../../registries/artifactProtocolIds.js";
 import { buildExplain, buildExplainAll, assertMutationGrammarParity, exampleFor, executeStateWrite, isWritableArtifact, loadStructuredInput, operationSpec, projectedFields, renderExplainText, StateWriteInputError, verbsForArtifact, WRITABLE_ARTIFACTS, } from "../../../state/write/index.js";
+import { inspectTodoUpdateBatch } from "../../../state/todoUpdateBatch.js";
+import { inspectTodoCreateBatch } from "../../../state/todoCreateBatch.js";
 function formatFromArgv(argv) {
     for (let i = 0; i < argv.length; i++) {
         if (argv[i] === "--format" && argv[i + 1] === "json")
@@ -17,6 +19,14 @@ function formatFromArgv(argv) {
 function invalid(body) {
     throw new StateWriteInputError(body);
 }
+function missingTodoUpdateId() {
+    invalid({
+        class: "missing_argument",
+        message: "--id is required for todo update",
+        syntax: "--id VALUE",
+        example: exampleFor("todo", "update"),
+    });
+}
 function emitRetrievalFailure(error, format, io) {
     if (format === "json") {
         emitStructured(error.body, "json", io.out ?? ((text) => process.stdout.write(text)));
@@ -168,10 +178,16 @@ function parseWrite(artifactRaw, argv) {
     let dryRun = false;
     let force = false;
     let inputSource = null;
+    const transitionBatchMode = artifact === "todo"
+        && (verb === "set-severity" || verb === "resolve")
+        && argv.slice(1).some((token) => token === "--input" || token.startsWith("--input="));
     for (let i = 1; i < argv.length;) {
         const token = argv[i];
         if (!token.startsWith("--"))
             invalid({ class: "unrecognized_argument", message: `unrecognized arguments: ${token}` });
+        const tokenName = token.split("=", 1)[0];
+        if (!transitionBatchMode && artifact === "todo" && (verb === "set-severity" || verb === "resolve") && (tokenName === "--effect-sha256" || tokenName === "--yes"))
+            invalid({ class: "unrecognized_argument", message: `unrecognized arguments: ${tokenName}`, example: exampleFor(artifact, verb) });
         if (token === "--dry-run") {
             dryRun = true;
             i += 1;
@@ -280,15 +296,19 @@ function parseWrite(artifactRaw, argv) {
             example: exampleFor(artifact, verb),
         });
     const selectorFields = new Set(spec.fields.filter((field) => spec.selectors.includes(field.flag)).map((field) => field.field));
-    const correctionApplyFields = artifact === "todo" && verb === "correct-owners"
+    const correctionApplyFields = artifact === "todo" && (verb === "correct-owners" || verb === "update" || verb === "create" || verb === "set-severity" || verb === "resolve")
         ? new Set(["effect_sha256", "confirmed"])
         : new Set();
-    if (spec.inputRoot && Object.keys(values).some((field) => !selectorFields.has(field) && !correctionApplyFields.has(field)))
+    if (artifact === "todo" && ["set-severity", "resolve"].includes(verb) && inputSource && Object.keys(values).some((field) => !correctionApplyFields.has(field)))
+        invalid({ class: "mutually_exclusive", message: `${artifact} ${verb} accepts field flags, not --input`, example: exampleFor(artifact, verb) });
+    if (spec.inputRoot && inputSource && Object.keys(values).some((field) => !selectorFields.has(field) && !correctionApplyFields.has(field)))
         invalid({
             class: "mutually_exclusive",
             message: `--input cannot be combined with field flags for ${artifact} ${verb}`,
         });
     for (const field of fields.filter((candidate) => candidate.required)) {
+        if (artifact === "todo" && ["update", "set-severity", "resolve"].includes(verb) && inputSource && ["id", "severity", "lifecycle.reason", "lifecycle.date"].includes(field.field))
+            continue;
         if (mappingPath(values, field.field) === undefined) {
             invalid({
                 class: "missing_argument",
@@ -389,6 +409,8 @@ export function runStateWrite(artifactRaw, argv, io) {
                 input = loadStructuredInput(parsed.inputSource, io.stdin ?? (() => fsStdin()), parsed.spec.inputMaxBytes);
             }
             catch (error) {
+                if (parsed.artifact === "todo" && parsed.spec.verb === "update" && !parsed.values.id)
+                    missingTodoUpdateId();
                 const message = error.message;
                 invalid({
                     class: message.startsWith("input file") ? "unsupported_target" : message.includes("UTF-8 limit") ? "schema_violation" : "invalid_format",
@@ -398,7 +420,11 @@ export function runStateWrite(artifactRaw, argv, io) {
                     ...(message.includes("UTF-8 limit") ? { violations: [message] } : {}),
                 });
             }
-            for (const owned of parsed.spec.cliOwnedFields ?? []) {
+            const updateBatch = parsed.artifact === "todo" && parsed.spec.verb === "update" ? inspectTodoUpdateBatch(input) : null;
+            const createBatch = parsed.artifact === "todo" && parsed.spec.verb === "create" ? inspectTodoCreateBatch(input) : null;
+            if (parsed.artifact === "todo" && parsed.spec.verb === "update" && !parsed.values.id && !updateBatch?.strictEnvelope)
+                missingTodoUpdateId();
+            for (const owned of createBatch ? [] : parsed.spec.cliOwnedFields ?? []) {
                 if (hasNested(input, owned))
                     invalid({
                         class: "schema_violation",

package/dist/cli/help.js

@@ -216,16 +216,21 @@ export function printStateHelp(sub) {
             "       agentera state todo activate|repair --dry-run|--effect-sha256 SHA256 --yes --format json",
             "       agentera state todo correct-owners --input OWNER_MAPPING.yaml --dry-run|--effect-sha256 SHA256 --yes --format json",
             "       agentera state todo create --input TODO.yaml --format json",
+            "       agentera state todo create --input TODO-CREATE-BATCH.yaml --dry-run --format json",
+            "       agentera state todo create --input TODO-CREATE-BATCH.yaml --effect-sha256 SHA256 --yes --format json",
             "       agentera state todo update --id ID --input TODO-PATCH.yaml --format json",
             "       agentera state todo set-severity --id ID --severity LEVEL --reason TEXT --date YYYY-MM-DD --format json",
+            "       agentera state todo set-severity --input TODO-SEVERITY-BATCH.yaml --dry-run|--effect-sha256 SHA256 --yes --format json",
             "       agentera state todo supersede --id ID --replacement ID --reason TEXT --date YYYY-MM-DD --format json",
             "       agentera state todo resolve|reopen --id ID --reason TEXT --date YYYY-MM-DD --format json",
+            "       agentera state todo resolve --input TODO-RESOLVE-BATCH.yaml --dry-run|--effect-sha256 SHA256 --yes --format json",
             "",
             "Each TODO item is one independently mutable canonical entity. IDs are bare ten-letter project-wide identities.",
             "TODO views are bounded in severity/status and Markdown public order; exact get returns complete detail.",
-            "Create accepts a full typed YAML/JSON record; update is a patch, so omitted fields preserve state and null/empty-list clears apply only to declared clearable fields.",
+            "Singleton create accepts a full typed YAML/JSON record. Batch create accepts one strict agentera.todoCreateBatch.v1 envelope: preview it with --dry-run, then apply the same input with the returned --effect-sha256 and --yes.",
+            "Update is a patch, so omitted fields preserve state and null/empty-list clears apply only to declared clearable fields.",
             "Readiness is Agentera-owned operational state; public fields are owned by TODO.md and divergent public values fail before effects.",
-            "Lifecycle verbs are flag-only typed transitions and cannot be supplied as record content.",
+            "Singleton lifecycle verbs remain flag-only. Set-severity and resolve also accept strict verb-specific batch envelopes that require preview and exact confirmed apply.",
             "Marker-absent repositories must complete migration before ordinary TODO access.",
             "",
             "Discover writes: agentera state todo explain --format json",
@@ -494,10 +499,11 @@ export function printPrimeHelp() {
         "  --context CAPABILITY  Emit startup context for a capability (e.g. plan)",
         "  --input FILE|-         Transient agentera.buildExecutionRequest.v1 input; valid only with --context build",
         "  --guidance            Emit static routing guidance",
-        "  --dashboard           Emit the prime orientation dashboard",
-        "  --orientation         Emit orientation briefing sections",
+        "  --dashboard           Deprecated status-capsule alias; incompatible with --fields",
+        "  --orientation         Deprecated dashboard alias; incompatible with --fields",
         "  --fields FIELDS       Comma-separated field filter for JSON/YAML output",
         "",
+        "Dashboard consumers must use `npx -y agentera@next prime --context status --format json` and read capability_context.context.status_context.",
         "JSON output uses bounded surfaces: bare prime is at most 12000 UTF-8 bytes and status context at most 22500; startup contains one availability projection and aggregate outcome, while schema discovery owns writer detail.",
     ].join("\n");
 }

package/dist/state/todoCreateBatch.js

@@ -0,0 +1,69 @@
+import { createHash } from "node:crypto";
+import { canonicalRecordJson } from "./archiveDiscovery.js";
+import { todoInputViolations } from "./todoDocsEntityValidation.js";
+import { reject } from "./write/errors.js";
+export const TODO_CREATE_BATCH_VERSION = "agentera.todoCreateBatch.v1";
+function mapping(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
+export function inspectTodoCreateBatch(input) {
+    if (!input || input.schema_version !== TODO_CREATE_BATCH_VERSION)
+        return null;
+    const strictEnvelope = Object.keys(input).sort().join(",") === "creates,schema_version" && Array.isArray(input.creates);
+    const violations = [];
+    if (!strictEnvelope)
+        violations.push("batch envelope must contain exactly schema_version and creates");
+    if (!Array.isArray(input.creates) || input.creates.length < 1 || input.creates.length > 256)
+        violations.push("creates must contain 1 to 256 entries");
+    const creates = (Array.isArray(input.creates) ? input.creates : []).map((value, index) => {
+        if (!mapping(value) || Object.keys(value).sort().join(",") !== "local_ref,record" || typeof value.local_ref !== "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(value.local_ref) || !mapping(value.record)) {
+            violations.push(`creates[${index}] must contain exactly one valid local_ref and one record mapping`);
+            return { local_ref: "", record: {} };
+        }
+        const validationRecord = structuredClone(value.record);
+        if (mapping(validationRecord.readiness) && Array.isArray(validationRecord.readiness.dependencies))
+            validationRecord.readiness.dependencies = validationRecord.readiness.dependencies.map((dependency) => mapping(dependency) && typeof dependency.local_ref === "string" ? { artifact: "todo", id: "aaaaaaaaaa" } : dependency);
+        violations.push(...todoInputViolations(validationRecord, "create").map((item) => `creates[${index}].record: ${item}`));
+        return { local_ref: value.local_ref, record: value.record };
+    });
+    const refs = new Set();
+    for (const { local_ref } of creates) {
+        if (local_ref && refs.has(local_ref))
+            violations.push(`duplicate local reference '${local_ref}'`);
+        refs.add(local_ref);
+    }
+    for (const [index, { record }] of creates.entries()) {
+        const dependencies = mapping(record.readiness) ? record.readiness.dependencies : undefined;
+        if (!Array.isArray(dependencies))
+            continue;
+        for (const dependency of dependencies) {
+            if (mapping(dependency) && Object.keys(dependency).sort().join(",") === "artifact,id" && dependency.artifact === "todo" && typeof dependency.id === "string" && /^[a-z]{10}$/.test(dependency.id))
+                continue;
+            if (mapping(dependency) && Object.keys(dependency).join(",") === "local_ref" && typeof dependency.local_ref === "string" && refs.has(dependency.local_ref))
+                continue;
+            violations.push(`creates[${index}].record.readiness.dependencies contains a missing or invalid local reference`);
+        }
+    }
+    const edges = new Map(creates.map(({ local_ref, record }) => [local_ref, (mapping(record.readiness) && Array.isArray(record.readiness.dependencies) ? record.readiness.dependencies : []).flatMap((value) => mapping(value) && typeof value.local_ref === "string" ? [value.local_ref] : [])]));
+    const visiting = new Set();
+    const visited = new Set();
+    const cyclic = (ref) => { if (visiting.has(ref))
+        return true; if (visited.has(ref))
+        return false; visiting.add(ref); const found = (edges.get(ref) ?? []).some(cyclic); visiting.delete(ref); visited.add(ref); return found; };
+    if ([...edges.keys()].some(cyclic))
+        violations.push("request-local dependency graph contains a cycle");
+    return { strictEnvelope, creates, violations: [...new Set(violations)] };
+}
+export function parseTodoCreateBatch(input) {
+    const inspected = inspectTodoCreateBatch(input);
+    if (!inspected)
+        return null;
+    if (inspected.violations.length)
+        reject({ class: "schema_violation", message: "todo create batch input is invalid", violations: inspected.violations, recovery: "Correct the strict agentera.todoCreateBatch.v1 envelope, then preview it again; no state was changed." });
+    return inspected.creates;
+}
+export function resolveTodoCreateBatchRecords(entries, ids) {
+    return entries.map(({ local_ref, record }) => { const copy = structuredClone(record); if (mapping(copy.readiness) && Array.isArray(copy.readiness.dependencies))
+        copy.readiness.dependencies = copy.readiness.dependencies.map((value) => mapping(value) && "local_ref" in value ? { artifact: "todo", id: ids.get(String(value.local_ref)) } : value); return { local_ref, record: copy }; });
+}
+export function todoCreateBatchEffectSha256(input, mappingSha256, localRefs, targets) {
+    return createHash("sha256").update(canonicalRecordJson({ schema_version: TODO_CREATE_BATCH_VERSION, input, mapping_sha256: mappingSha256, local_refs: localRefs, targets })).digest("hex");
+}