@tea-agent/loop-agent 0.16.26 → 0.17.0

package/dist/task/contract/recover.js

@@ -0,0 +1,312 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sha256Utf8 } from "./hash.js";
+import { applyStagedToTarget, commitMarkerExists, getTransactionPaths, listTransactionIds, readTransactionIntent, readTransactionState, restoreOriginal, writeCommitMarker, writeTransactionState, } from "./journal.js";
+import { acquireTaskContractLock } from "./lock.js";
+import { appendRequestLedgerEntry, findRequestLedgerEntry, } from "./request-ledger.js";
+import { listUnfinishedTransactionDirs } from "./observe.js";
+import { observeTaskContractState } from "./observe.js";
+import { getTaskPaths } from "../runtime.js";
+import { finalizeTransaction } from "./transaction.js";
+export async function doctorTaskContract(input) {
+    const state = await observeTaskContractState(input.repoRoot, input.taskId);
+    const paths = getTaskPaths(input.repoRoot, input.taskId);
+    const unfinishedIds = await listUnfinishedTransactionDirs(paths.transactionsDir);
+    const unfinishedTransactions = unfinishedIds.map((txId) => ({
+        txId,
+        phase: "preparing",
+        path: path.join(paths.transactionsDir, txId),
+    }));
+    // Enrich phase from state.json
+    for (const item of unfinishedTransactions) {
+        const txPaths = getTransactionPaths(input.repoRoot, input.taskId, item.txId);
+        const st = await readTransactionState(txPaths);
+        if (st) {
+            item.phase = st.phase;
+        }
+    }
+    const recommendations = [];
+    if (state.effectiveStatus === "transaction-incomplete") {
+        recommendations.push("Run: loop-agent task contract recover --task <id> --json");
+    }
+    if (state.effectiveStatus === "legacy-unversioned") {
+        recommendations.push("Run apply with expectedRevision=0 or: loop-agent task contract adopt --task <id> ...");
+    }
+    if (state.effectiveStatus === "externally-modified") {
+        recommendations.push("Review out-of-band edits, then apply a new Draft or adopt current facts");
+    }
+    if (unfinishedTransactions.length > 1) {
+        recommendations.push("Multiple unfinished transactions detected — manual inspection required (no auto-select)");
+    }
+    return {
+        state,
+        unfinishedTransactions: unfinishedTransactions.map((item) => ({
+            txId: item.txId,
+            phase: item.phase,
+            path: item.path,
+        })),
+        recommendations,
+    };
+}
+export async function recoverTaskContract(input) {
+    const lock = await acquireTaskContractLock({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+        operation: "contract-recover",
+    });
+    try {
+        const paths = getTaskPaths(input.repoRoot, input.taskId);
+        const unfinished = await listUnfinishedTransactionDirs(paths.transactionsDir);
+        if (unfinished.length === 0) {
+            return {
+                action: "none",
+                message: "no unfinished transactions",
+            };
+        }
+        if (unfinished.length > 1 && !input.txId) {
+            return {
+                action: "manual-required",
+                message: `multiple unfinished transactions (${unfinished.join(", ")}); pass --tx-id`,
+            };
+        }
+        const txId = input.txId ?? unfinished[0];
+        if (!unfinished.includes(txId)) {
+            return {
+                action: "manual-required",
+                message: `transaction ${txId} is not in unfinished set`,
+                txId,
+            };
+        }
+        const txPaths = getTransactionPaths(input.repoRoot, input.taskId, txId);
+        const intent = await readTransactionIntent(txPaths);
+        const state = await readTransactionState(txPaths);
+        const committed = await commitMarkerExists(txPaths);
+        if (!intent) {
+            await writeTransactionState(txPaths, "recovery-required", {
+                code: "MISSING_INTENT",
+                message: "intent.json missing",
+            });
+            return {
+                action: "manual-required",
+                txId,
+                message: "intent.json missing; manual recovery required",
+            };
+        }
+        const beforeHashes = {};
+        const afterHashes = {};
+        const taskDir = paths.taskDir;
+        for (const target of intent.targets) {
+            const abs = path.join(taskDir, ...target.relativePath.split("/"));
+            try {
+                const bytes = await readFile(abs);
+                beforeHashes[target.relativePath] = sha256Utf8(bytes);
+            }
+            catch {
+                beforeHashes[target.relativePath] = null;
+            }
+        }
+        // Case A: commit marker exists (or all targets already match) → finalize only
+        if (committed || state?.phase === "committed") {
+            // Ensure ledger entry
+            const existingLedger = await findRequestLedgerEntry({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                requestId: intent.requestId,
+            });
+            if (!existingLedger) {
+                await appendRequestLedgerEntry({
+                    repoRoot: input.repoRoot,
+                    taskId: input.taskId,
+                    entry: {
+                        schemaVersion: 1,
+                        requestId: intent.requestId,
+                        requestPayloadSha256: intent.requestPayloadSha256,
+                        txId,
+                        revision: intent.nextRevision,
+                        canonicalHash: intent.nextRef.canonicalHash,
+                        recordedAt: new Date().toISOString(),
+                        resultSummary: { ok: true, operation: intent.operation },
+                    },
+                });
+            }
+            await finalizeTransaction({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                txId,
+            });
+            for (const target of intent.targets) {
+                const abs = path.join(taskDir, ...target.relativePath.split("/"));
+                try {
+                    const bytes = await readFile(abs);
+                    afterHashes[target.relativePath] = sha256Utf8(bytes);
+                }
+                catch {
+                    afterHashes[target.relativePath] = null;
+                }
+            }
+            return {
+                action: "finalize",
+                txId,
+                beforeHashes,
+                afterHashes,
+                message: "commit marker present; ledger/finalize completed",
+            };
+        }
+        // Case B: all targets already match staged hashes → write commit + finalize
+        let allMatch = true;
+        for (const target of intent.targets) {
+            const abs = path.join(taskDir, ...target.relativePath.split("/"));
+            try {
+                const bytes = await readFile(abs);
+                if (sha256Utf8(bytes) !== target.finalSha256) {
+                    allMatch = false;
+                    break;
+                }
+            }
+            catch {
+                allMatch = false;
+                break;
+            }
+        }
+        if (allMatch) {
+            await writeCommitMarker(txPaths, {
+                txId,
+                revision: intent.nextRevision,
+                canonicalHash: intent.nextRef.canonicalHash,
+                committedAt: new Date().toISOString(),
+            });
+            await writeTransactionState(txPaths, "committed");
+            const existingLedger = await findRequestLedgerEntry({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                requestId: intent.requestId,
+            });
+            if (!existingLedger) {
+                await appendRequestLedgerEntry({
+                    repoRoot: input.repoRoot,
+                    taskId: input.taskId,
+                    entry: {
+                        schemaVersion: 1,
+                        requestId: intent.requestId,
+                        requestPayloadSha256: intent.requestPayloadSha256,
+                        txId,
+                        revision: intent.nextRevision,
+                        canonicalHash: intent.nextRef.canonicalHash,
+                        recordedAt: new Date().toISOString(),
+                        resultSummary: { ok: true, operation: intent.operation },
+                    },
+                });
+            }
+            await finalizeTransaction({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                txId,
+            });
+            for (const target of intent.targets) {
+                afterHashes[target.relativePath] = target.finalSha256;
+            }
+            return {
+                action: "finalize",
+                txId,
+                beforeHashes,
+                afterHashes,
+                message: "targets already matched intent; commit+finalize completed",
+            };
+        }
+        // Case C: partial apply — re-apply staged if prepared/applying and staged exists, else rollback
+        if (state?.phase === "prepared" || state?.phase === "applying") {
+            try {
+                for (const target of intent.targets) {
+                    const abs = path.join(taskDir, ...target.relativePath.split("/"));
+                    await applyStagedToTarget(txPaths, target.relativePath, abs);
+                }
+                // verify
+                for (const target of intent.targets) {
+                    const abs = path.join(taskDir, ...target.relativePath.split("/"));
+                    const bytes = await readFile(abs);
+                    if (sha256Utf8(bytes) !== target.finalSha256) {
+                        throw new Error(`hash mismatch after re-apply: ${target.relativePath}`);
+                    }
+                }
+                await writeCommitMarker(txPaths, {
+                    txId,
+                    revision: intent.nextRevision,
+                    canonicalHash: intent.nextRef.canonicalHash,
+                    committedAt: new Date().toISOString(),
+                });
+                await writeTransactionState(txPaths, "committed");
+                const existingLedger = await findRequestLedgerEntry({
+                    repoRoot: input.repoRoot,
+                    taskId: input.taskId,
+                    requestId: intent.requestId,
+                });
+                if (!existingLedger) {
+                    await appendRequestLedgerEntry({
+                        repoRoot: input.repoRoot,
+                        taskId: input.taskId,
+                        entry: {
+                            schemaVersion: 1,
+                            requestId: intent.requestId,
+                            requestPayloadSha256: intent.requestPayloadSha256,
+                            txId,
+                            revision: intent.nextRevision,
+                            canonicalHash: intent.nextRef.canonicalHash,
+                            recordedAt: new Date().toISOString(),
+                            resultSummary: { ok: true, operation: intent.operation },
+                        },
+                    });
+                }
+                await finalizeTransaction({
+                    repoRoot: input.repoRoot,
+                    taskId: input.taskId,
+                    txId,
+                });
+                for (const target of intent.targets) {
+                    afterHashes[target.relativePath] = target.finalSha256;
+                }
+                return {
+                    action: "finalize",
+                    txId,
+                    beforeHashes,
+                    afterHashes,
+                    message: "re-applied staged files and finalized",
+                };
+            }
+            catch {
+                // fall through to rollback
+            }
+        }
+        // Rollback from originals
+        for (const target of intent.targets) {
+            const abs = path.join(taskDir, ...target.relativePath.split("/"));
+            await restoreOriginal(txPaths, target.relativePath, abs, target.existedBefore);
+        }
+        await writeTransactionState(txPaths, "finalized", {
+            code: "ROLLED_BACK",
+            message: "recovered by rollback to originals",
+        });
+        for (const target of intent.targets) {
+            const abs = path.join(taskDir, ...target.relativePath.split("/"));
+            try {
+                const bytes = await readFile(abs);
+                afterHashes[target.relativePath] = sha256Utf8(bytes);
+            }
+            catch {
+                afterHashes[target.relativePath] = null;
+            }
+        }
+        return {
+            action: "rollback",
+            txId,
+            beforeHashes,
+            afterHashes,
+            message: "rolled back incomplete transaction to originals",
+        };
+    }
+    finally {
+        await lock.release();
+    }
+}
+export async function listAllTransactions(repoRoot, taskId) {
+    return listTransactionIds(repoRoot, taskId);
+}

package/dist/task/contract/request-ledger.js

@@ -0,0 +1,37 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { getTaskContractPaths } from "./paths.js";
+export async function readRequestLedger(input) {
+    const paths = getTaskContractPaths(input.repoRoot, input.taskId);
+    try {
+        const raw = await readFile(paths.requestLedgerPath, "utf-8");
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function findRequestLedgerEntry(input) {
+    const entries = await readRequestLedger(input);
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry?.requestId === input.requestId)
+            return entry;
+    }
+    return undefined;
+}
+export async function appendRequestLedgerEntry(input) {
+    const paths = getTaskContractPaths(input.repoRoot, input.taskId);
+    await mkdir(path.dirname(paths.requestLedgerPath), { recursive: true });
+    await appendFile(paths.requestLedgerPath, `${JSON.stringify(input.entry)}\n`, "utf-8");
+}

package/dist/task/contract/schema.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+import { taskKindSchema, taskVerifyCommandSchema } from "../config-types.js";
+import { TASK_CONFIG_SCHEMA_VERSION, TASK_CONTRACT_CANONICALIZER_VERSION, TASK_CONTRACT_DRAFT_SCHEMA_VERSION, TASK_CONTRACT_PROJECTION_VERSION, TASK_CONTRACT_REF_SCHEMA_VERSION, } from "./constants.js";
+const sha256Schema = z
+    .string()
+    .regex(/^[a-f0-9]{64}$/, "sha256 must be lowercase hex");
+export const taskContractDraftRequirementSchema = z
+    .object({
+    objective: z.string().min(1),
+    scope: z.array(z.string()),
+    nonGoals: z.array(z.string()),
+    acceptanceCriteria: z
+        .array(z
+        .object({
+        id: z.string().min(1),
+        text: z.string().min(1),
+    })
+        .strict())
+        .min(1),
+})
+    .strict();
+export const taskContractDraftConstraintsSchema = z
+    .object({
+    invariants: z.array(z.string()),
+    allowedPaths: z.array(z.string()),
+    forbiddenPaths: z.array(z.string()),
+    protectedUserChanges: z.array(z.string()).optional(),
+    expectedVerification: z.array(z.string()).optional(),
+    failureConditions: z.array(z.string()).optional(),
+    knownRisks: z.array(z.string()).optional(),
+})
+    .strict();
+export const taskContractDraftVerificationSchema = z
+    .object({
+    commands: z.array(taskVerifyCommandSchema),
+})
+    .strict();
+export const taskContractDraftReferenceSchema = z
+    .object({
+    role: z.string().min(1),
+    ref: z.string().min(1),
+})
+    .strict();
+export const taskContractDraftSourceResolutionSchema = z
+    .object({
+    sourceRef: z.string().min(1),
+    conflict: z.string().min(1),
+    decision: z.string().min(1),
+    reason: z.string().min(1),
+    decidedBy: z.enum(["human"]),
+})
+    .strict();
+export const taskContractDraftSchema = z
+    .object({
+    schemaVersion: z.literal(TASK_CONTRACT_DRAFT_SCHEMA_VERSION),
+    taskId: z.string().min(1),
+    title: z.string().min(1),
+    taskKind: taskKindSchema,
+    featureId: z.string().min(1).optional(),
+    requirement: taskContractDraftRequirementSchema,
+    constraints: taskContractDraftConstraintsSchema,
+    verification: taskContractDraftVerificationSchema,
+    references: z.array(taskContractDraftReferenceSchema).optional(),
+    sourceResolutions: z
+        .array(taskContractDraftSourceResolutionSchema)
+        .optional(),
+    openQuestions: z.array(z.string()).optional(),
+    assumptions: z.array(z.string()).optional(),
+    hardConstraints: z.array(z.string()).optional(),
+    interviewAssessmentRef: z
+        .object({
+        draftSha256: z.string().min(1),
+        assessmentId: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .superRefine((draft, ctx) => {
+    if (draft.taskKind === "knowledge-sync" && !draft.featureId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "featureId is required when taskKind is knowledge-sync",
+            path: ["featureId"],
+        });
+    }
+    const allowed = new Set(draft.constraints.allowedPaths);
+    for (const forbidden of draft.constraints.forbiddenPaths) {
+        if (allowed.has(forbidden)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `forbiddenPaths entry overlaps allowedPaths: ${forbidden}`,
+                path: ["constraints", "forbiddenPaths"],
+            });
+        }
+    }
+});
+export const taskContractSourceHashesSchema = z
+    .object({
+    requirementSha256: sha256Schema,
+    constraintsSha256: sha256Schema,
+    referenceManifestSha256: sha256Schema.optional(),
+})
+    .strict();
+export const taskContractRefSchema = z
+    .object({
+    schemaVersion: z.literal(TASK_CONTRACT_REF_SCHEMA_VERSION),
+    taskId: z.string().min(1),
+    revision: z.number().int().nonnegative(),
+    projectionVersion: z.literal(TASK_CONTRACT_PROJECTION_VERSION),
+    canonicalizerVersion: z.literal(TASK_CONTRACT_CANONICALIZER_VERSION),
+    taskConfigSchemaVersion: z.literal(TASK_CONFIG_SCHEMA_VERSION),
+    sourceHashes: taskContractSourceHashesSchema,
+    taskConfigSha256: sha256Schema,
+    canonicalHash: sha256Schema,
+    updatedAt: z.string().min(1),
+    lastRequestId: z.string().min(1).optional(),
+})
+    .strict();
+export function parseTaskContractDraft(raw) {
+    return taskContractDraftSchema.parse(raw);
+}
+export function safeParseTaskContractDraft(raw) {
+    return taskContractDraftSchema.safeParse(raw);
+}
+export function parseTaskContractRef(raw) {
+    return taskContractRefSchema.parse(raw);
+}
+export function safeParseTaskContractRef(raw) {
+    return taskContractRefSchema.safeParse(raw);
+}
+/** Additional business rules beyond zod schema. */
+export function validateDraftBusinessRules(draft) {
+    const errors = [];
+    if (draft.taskKind === "knowledge-sync" && !draft.featureId) {
+        errors.push("featureId is required when taskKind is knowledge-sync");
+    }
+    if (!draft.requirement.objective.trim()) {
+        errors.push("requirement.objective must be non-empty");
+    }
+    if (draft.requirement.acceptanceCriteria.length === 0) {
+        errors.push("at least one acceptance criterion is required");
+    }
+    const allowed = new Set(draft.constraints.allowedPaths);
+    for (const forbidden of draft.constraints.forbiddenPaths) {
+        if (allowed.has(forbidden)) {
+            errors.push(`forbiddenPaths entry overlaps allowedPaths: ${forbidden}`);
+        }
+    }
+    return errors;
+}

package/dist/task/contract/transaction.js

@@ -0,0 +1,160 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { CONSTRAINTS_FILE_NAME, CONTRACT_FILE_NAME, REQUIREMENT_FILE_NAME, } from "./constants.js";
+import { applyStagedToTarget, backupOriginalIfExists, commitMarkerExists, ensureTransactionDirs, getTransactionPaths, readTransactionIntent, readTransactionState, restoreOriginal, stageJsonFile, stageTextFile, writeCommitMarker, writeTransactionIntent, writeTransactionState, } from "./journal.js";
+import { sha256Utf8 } from "./hash.js";
+import { getTaskPaths } from "../runtime.js";
+function targetAbs(taskDir, relativePath) {
+    return path.join(taskDir, ...relativePath.split("/"));
+}
+/**
+ * Run the journaled multi-file commit protocol for contract mutations.
+ * commit.json is the unique logical commit point.
+ */
+export async function runJournaledContractCommit(input) {
+    const paths = getTaskPaths(input.repoRoot, input.taskId);
+    const txId = `tx-${Date.now()}-${randomBytes(4).toString("hex")}`;
+    const txPaths = getTransactionPaths(input.repoRoot, input.taskId, txId);
+    await ensureTransactionDirs(txPaths);
+    await writeTransactionState(txPaths, "preparing");
+    const requirementRel = `source/${REQUIREMENT_FILE_NAME}`;
+    const constraintsRel = `source/${CONSTRAINTS_FILE_NAME}`;
+    const taskConfigRel = "task.json";
+    const contractRel = CONTRACT_FILE_NAME;
+    const targetSpecs = [
+        {
+            kind: "requirement",
+            relativePath: requirementRel,
+            content: input.targets.requirementContent,
+            isJson: false,
+        },
+        {
+            kind: "constraints",
+            relativePath: constraintsRel,
+            content: input.targets.constraintsContent,
+            isJson: false,
+        },
+        {
+            kind: "task-config",
+            relativePath: taskConfigRel,
+            content: input.targets.taskConfigContent,
+            isJson: false,
+        },
+        {
+            kind: "contract",
+            relativePath: contractRel,
+            content: input.targets.contractRef,
+            isJson: true,
+        },
+    ];
+    const targetRecords = [];
+    for (const spec of targetSpecs) {
+        const abs = targetAbs(paths.taskDir, spec.relativePath);
+        const backup = await backupOriginalIfExists(txPaths, abs, spec.relativePath);
+        const originalSha256 = backup.content
+            ? sha256Utf8(backup.content)
+            : null;
+        if (spec.isJson) {
+            await stageJsonFile(txPaths, spec.relativePath, spec.content, input.repoRoot);
+        }
+        else {
+            await stageTextFile(txPaths, spec.relativePath, spec.content, input.repoRoot);
+        }
+        // Read staged bytes for hash
+        const { readFile } = await import("node:fs/promises");
+        const stagedBytes = await readFile(path.join(txPaths.stagedDir, spec.relativePath));
+        const stagedSha256 = sha256Utf8(stagedBytes);
+        targetRecords.push({
+            kind: spec.kind,
+            relativePath: spec.relativePath,
+            existedBefore: backup.existed,
+            originalSha256,
+            stagedSha256,
+            finalSha256: stagedSha256,
+        });
+    }
+    const intent = {
+        schemaVersion: 1,
+        txId,
+        taskId: input.taskId,
+        operation: input.operation,
+        requestId: input.requestId,
+        requestPayloadSha256: input.requestPayloadSha256,
+        expectedRevision: input.expectedRevision,
+        expectedObservedCanonicalHash: input.expectedObservedCanonicalHash,
+        nextRevision: input.nextRevision,
+        fencingToken: input.fencingToken,
+        createdAt: new Date().toISOString(),
+        targets: targetRecords,
+        nextRef: input.targets.contractRef,
+    };
+    await writeTransactionIntent(txPaths, intent);
+    await writeTransactionState(txPaths, "prepared");
+    await writeTransactionState(txPaths, "applying");
+    try {
+        for (const record of targetRecords) {
+            const abs = targetAbs(paths.taskDir, record.relativePath);
+            await applyStagedToTarget(txPaths, record.relativePath, abs);
+        }
+        // Verify applied hashes match intent
+        const { readFile } = await import("node:fs/promises");
+        for (const record of targetRecords) {
+            const abs = targetAbs(paths.taskDir, record.relativePath);
+            const applied = await readFile(abs);
+            const appliedHash = sha256Utf8(applied);
+            if (appliedHash !== record.finalSha256) {
+                throw new Error(`post-apply hash mismatch for ${record.relativePath}: expected ${record.finalSha256}, got ${appliedHash}`);
+            }
+        }
+        // Unique logical commit point
+        await writeCommitMarker(txPaths, {
+            txId,
+            revision: input.nextRevision,
+            canonicalHash: input.targets.contractRef.canonicalHash,
+            committedAt: new Date().toISOString(),
+        });
+        await writeTransactionState(txPaths, "committed");
+    }
+    catch (error) {
+        // Only rollback if commit marker not written
+        const committed = await commitMarkerExists(txPaths);
+        if (!committed) {
+            for (const record of targetRecords) {
+                const abs = targetAbs(paths.taskDir, record.relativePath);
+                try {
+                    await restoreOriginal(txPaths, record.relativePath, abs, record.existedBefore);
+                }
+                catch {
+                    // best-effort restore
+                }
+            }
+            await writeTransactionState(txPaths, "recovery-required", {
+                code: "APPLY_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            await writeTransactionState(txPaths, "committed", {
+                code: "POST_COMMIT_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        throw error;
+    }
+    return { txId, ref: input.targets.contractRef };
+}
+export async function finalizeTransaction(input) {
+    const txPaths = getTransactionPaths(input.repoRoot, input.taskId, input.txId);
+    const state = await readTransactionState(txPaths);
+    if (!state) {
+        throw new Error(`transaction state missing: ${input.txId}`);
+    }
+    if (state.phase === "finalized")
+        return;
+    const committed = await commitMarkerExists(txPaths);
+    if (!committed && state.phase !== "committed") {
+        throw new Error(`cannot finalize non-committed transaction ${input.txId} phase=${state.phase}`);
+    }
+    await writeTransactionState(txPaths, "finalized");
+}
+export { readTransactionIntent, readTransactionState, getTransactionPaths };

package/dist/task/contract/types.js

@@ -0,0 +1 @@
+export {};