@kisev/agentomatic 11.0.0-dev.54.g26e86b0b9fcd → 11.0.0-dev.55.g6d90f51aeff6

package/dist/lifecycle.d.ts

@@ -1,4 +1,3 @@
-export declare const RECEIPT_TTL_MS: number;
 export { LifecycleError, assertSafePath, readRegular, writeAtomic } from "@kisev/safe-fs";
 export type Scope = "global" | "project";
 export type FileExpectation = {
@@ -30,12 +29,6 @@ export type FileMutation = {
     operation: "external-remove";
     expected: FileExpectation;
 };
-export type SupersededPlan = {
-    kind: string;
-    confirmation_digest: string;
-    created_at: string;
-    expires_at: string;
-};
 export declare function stable(value: unknown): string;
 export declare function sha256(value: Buffer | string): string;
 export declare function digest(value: unknown): string;
@@ -47,20 +40,6 @@ export declare function migrateLegacyDeploymentNamespace(root: string): Promise<
 export declare function migrateLegacyNamespaces(home?: string): Promise<string[]>;
 export declare function archiveRoot(scope: Scope, cwd?: string, home?: string): string;
 export declare function withLifecycleLock<T>(stateRoot: string, callback: () => Promise<T>): Promise<T>;
-export declare function saveReceipt(stateRoot: string, kind: string, scope: Scope, root: string, payload: unknown, now?: number, planDigest?: string): Promise<{
-    digest: string;
-    plan_digest: string;
-    expires_at: string;
-    superseded_plan?: SupersededPlan;
-}>;
-export declare function consumeReceipt(stateRoot: string, expected: {
-    digest: string;
-    kind: string;
-    scope: Scope;
-    root: string;
-}, now?: number): Promise<unknown>;
-/** Invalidate an active receipt when a preview is blocked before a replacement exists. */
-export declare function supersedeReceipt(stateRoot: string, now?: number): Promise<void>;
 export declare function recoverTransaction(root: string, stateRoot: string, allowedRoots?: readonly string[]): Promise<boolean>;
 export type TransactionOptions = {
     beforePublish?: (index: number) => void;

package/dist/lifecycle.js

@@ -1,9 +1,8 @@
-import { createHash, randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-export const RECEIPT_TTL_MS = 10 * 60 * 1000;
 export { LifecycleError, assertSafePath, readRegular, writeAtomic } from "@kisev/safe-fs";
 import { LifecycleError, assertSafePath, ensureDirectory, lstatSafe, readRegular, writeAtomic, } from "@kisev/safe-fs";
 export function stable(value) {
@@ -179,200 +178,6 @@ export async function withLifecycleLock(stateRoot, callback) {
     }
     throw new LifecycleError("lifecycle_locked", "Cannot acquire lifecycle lock");
 }
-function receiptPath(stateRoot) {
-    return join(stateRoot, "receipt.json");
-}
-export async function saveReceipt(stateRoot, kind, scope, root, payload, now = Date.now(), planDigest = digest(payload)) {
-    const existingRaw = await readRegular(receiptPath(stateRoot));
-    let superseded;
-    if (existingRaw) {
-        const existing = parseReceipt(existingRaw);
-        if (!existing.consumed && Date.parse(existing.expires_at) >= now) {
-            superseded = existing;
-        }
-    }
-    const confirmationDigest = sha256(randomBytes(32));
-    const receipt = {
-        schema_version: 1,
-        digest: confirmationDigest,
-        plan_digest: planDigest,
-        nonce: randomBytes(32).toString("base64url"),
-        created_at: new Date(now).toISOString(),
-        expires_at: new Date(now + RECEIPT_TTL_MS).toISOString(),
-        consumed: false,
-        kind,
-        scope,
-        root,
-        payload,
-        ...(superseded
-            ? {
-                superseded_digests: [superseded.digest, ...(superseded.superseded_digests ?? [])],
-            }
-            : {}),
-        integrity: "",
-    };
-    receipt.integrity = receiptIntegrity(receipt);
-    await writeAtomic(receiptPath(stateRoot), Buffer.from(`${stable(receipt)}\n`), 0o600);
-    return {
-        digest: receipt.digest,
-        plan_digest: receipt.plan_digest,
-        expires_at: receipt.expires_at,
-        ...(superseded
-            ? {
-                superseded_plan: {
-                    kind: superseded.kind,
-                    confirmation_digest: superseded.digest.slice(0, 12),
-                    created_at: superseded.created_at,
-                    expires_at: superseded.expires_at,
-                },
-            }
-            : {}),
-    };
-}
-function parseReceipt(raw) {
-    let value;
-    try {
-        value = JSON.parse(raw.toString("utf8"));
-    }
-    catch {
-        throw new LifecycleError("invalid_receipt", "Receipt is not valid JSON");
-    }
-    const receipt = value;
-    if (receipt &&
-        receipt.schema_version === 1 &&
-        typeof receipt.digest === "string" &&
-        /^[a-f0-9]{64}$/.test(receipt.digest) &&
-        typeof receipt.nonce === "string" &&
-        typeof receipt.expires_at === "string" &&
-        typeof receipt.consumed === "boolean" &&
-        typeof receipt.kind === "string" &&
-        (receipt.scope === "global" || receipt.scope === "project") &&
-        typeof receipt.root === "string" &&
-        typeof receipt.integrity === "string" &&
-        receipt.plan_digest === undefined) {
-        const legacyDocument = {
-            schema_version: 1,
-            digest: receipt.digest,
-            nonce: receipt.nonce,
-            expires_at: receipt.expires_at,
-            consumed: receipt.consumed,
-            kind: receipt.kind,
-            scope: receipt.scope,
-            root: receipt.root,
-            payload: receipt.payload,
-            integrity: receipt.integrity,
-        };
-        if (receipt.digest !==
-            digest({
-                schema_version: 1,
-                kind: receipt.kind,
-                scope: receipt.scope,
-                root: receipt.root,
-                payload: receipt.payload,
-            }) ||
-            receipt.integrity !==
-                digest({
-                    schema_version: 1,
-                    digest: receipt.digest,
-                    nonce: receipt.nonce,
-                    expires_at: receipt.expires_at,
-                    consumed: receipt.consumed,
-                    kind: receipt.kind,
-                    scope: receipt.scope,
-                    root: receipt.root,
-                    payload: receipt.payload,
-                })) {
-            throw new LifecycleError("invalid_receipt", "Receipt integrity check failed");
-        }
-        const payloadRecord = receipt.payload;
-        const planDigest = payloadRecord &&
-            typeof payloadRecord === "object" &&
-            typeof payloadRecord.digest === "string" &&
-            /^[a-f0-9]{64}$/.test(payloadRecord.digest)
-            ? payloadRecord.digest
-            : digest(receipt.payload);
-        return {
-            ...legacyDocument,
-            plan_digest: planDigest,
-            created_at: new Date(Date.parse(receipt.expires_at) - RECEIPT_TTL_MS).toISOString(),
-        };
-    }
-    if (!receipt ||
-        receipt.schema_version !== 1 ||
-        typeof receipt.digest !== "string" ||
-        !/^[a-f0-9]{64}$/.test(receipt.digest) ||
-        typeof receipt.plan_digest !== "string" ||
-        !/^[a-f0-9]{64}$/.test(receipt.plan_digest) ||
-        typeof receipt.nonce !== "string" ||
-        typeof receipt.created_at !== "string" ||
-        typeof receipt.expires_at !== "string" ||
-        typeof receipt.consumed !== "boolean" ||
-        (receipt.superseded !== undefined && typeof receipt.superseded !== "boolean") ||
-        typeof receipt.kind !== "string" ||
-        (receipt.scope !== "global" && receipt.scope !== "project") ||
-        typeof receipt.root !== "string" ||
-        (receipt.superseded_digests !== undefined &&
-            (!Array.isArray(receipt.superseded_digests) ||
-                !receipt.superseded_digests.every((value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value)))) ||
-        typeof receipt.integrity !== "string") {
-        throw new LifecycleError("invalid_receipt", "Receipt has an unsupported schema");
-    }
-    const payloadRecord = receipt.payload;
-    const payloadPlanDigest = payloadRecord &&
-        typeof payloadRecord === "object" &&
-        typeof payloadRecord.plan_digest === "string"
-        ? payloadRecord.plan_digest
-        : digest(receipt.payload);
-    if (receipt.plan_digest !== payloadPlanDigest) {
-        throw new LifecycleError("invalid_receipt", "Receipt digest does not match its payload");
-    }
-    if (receipt.integrity !== receiptIntegrity(receipt))
-        throw new LifecycleError("invalid_receipt", "Receipt integrity check failed");
-    return receipt;
-}
-function receiptIntegrity(receipt) {
-    const { integrity: _integrity, ...document } = receipt;
-    return digest(document);
-}
-export async function consumeReceipt(stateRoot, expected, now = Date.now()) {
-    if (!/^[a-f0-9]{64}$/.test(expected.digest))
-        throw new LifecycleError("invalid_digest", "Confirmation digest must be a SHA-256 value");
-    const raw = await readRegular(receiptPath(stateRoot));
-    if (!raw)
-        throw new LifecycleError("confirmation_unknown", "Confirmation receipt is missing");
-    const receipt = parseReceipt(raw);
-    if (receipt.digest !== expected.digest ||
-        receipt.kind !== expected.kind ||
-        receipt.scope !== expected.scope ||
-        receipt.root !== expected.root) {
-        if (receipt.superseded_digests?.includes(expected.digest))
-            throw new LifecycleError("superseded_plan", "Confirmation receipt was superseded by a newer plan");
-        throw new LifecycleError("confirmation_unknown", "Confirmation does not match the saved plan");
-    }
-    if (receipt.superseded)
-        throw new LifecycleError("superseded_plan", "Confirmation receipt was superseded by a newer plan");
-    if (receipt.consumed)
-        throw new LifecycleError("confirmation_consumed", "Confirmation receipt was already consumed");
-    if (Date.parse(receipt.expires_at) < now)
-        throw new LifecycleError("confirmation_expired", "Confirmation receipt expired; request a fresh plan");
-    const consumed = { ...receipt, consumed: true, integrity: "" };
-    consumed.integrity = receiptIntegrity(consumed);
-    await writeAtomic(receiptPath(stateRoot), Buffer.from(`${stable(consumed)}\n`), 0o600);
-    return receipt.payload;
-}
-/** Invalidate an active receipt when a preview is blocked before a replacement exists. */
-export async function supersedeReceipt(stateRoot, now = Date.now()) {
-    const path = receiptPath(stateRoot);
-    const raw = await readRegular(path);
-    if (!raw)
-        return;
-    const receipt = parseReceipt(raw);
-    if (receipt.consumed || receipt.superseded || Date.parse(receipt.expires_at) < now)
-        return;
-    const superseded = { ...receipt, consumed: true, superseded: true, integrity: "" };
-    superseded.integrity = receiptIntegrity(superseded);
-    await writeAtomic(path, Buffer.from(`${stable(superseded)}\n`), 0o600);
-}
 function journalPath(stateRoot) {
     return join(stateRoot, "transaction-journal.json");
 }

package/dist/reconcile.d.ts

@@ -1,4 +1,4 @@
-import { LifecycleError, type SupersededPlan, type Scope, type TransactionOptions } from "./lifecycle.js";
+import { LifecycleError, type Scope, type TransactionOptions } from "./lifecycle.js";
 export type ReconcileStatus = "current" | "retired" | "renamed" | "modified-managed" | "user-owned" | "unknown" | "conflict" | "diagnostic-state-only";
 export type ReconcileItem = {
     path: string;
@@ -26,12 +26,7 @@ export type ReconcilePlan = {
         operation: "archive" | "remove" | "write";
         sha256?: string;
     }>;
-    plan_digest: string;
-    confirmation_digest?: string;
-    superseded_plan?: SupersededPlan;
     confirmable: boolean;
-    digest?: string;
-    receipt_expires_at?: string;
 };
 export type ReconcileResult = {
     status: "ok";
@@ -44,4 +39,4 @@ export declare class ReconcileError extends LifecycleError {
 export declare function previewReconcile(scope: Scope, cwd?: string, home?: string): Promise<ReconcilePlan>;
 /** Build the ownership classification without receipts, locks, or recovery. */
 export declare function inspectReconcile(scope: Scope, cwd?: string, home?: string): Promise<ReconcilePlan>;
-export declare function applyReconcile(scope: Scope, confirmationDigest: string, cwd?: string, home?: string, options?: ReconcileOptions): Promise<ReconcileResult>;
+export declare function applyReconcile(scope: Scope, cwd?: string, home?: string, options?: ReconcileOptions): Promise<ReconcileResult>;

package/dist/reconcile.js

@@ -3,7 +3,7 @@ import { lstat, readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { applyTransaction, archiveRoot, assertSafePath, consumeReceipt, destination, digest, LifecycleError, lifecycleRoot, recoverTransaction, saveReceipt, supersedeReceipt, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
+import { applyTransaction, archiveRoot, assertSafePath, destination, LifecycleError, lifecycleRoot, recoverTransaction, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
 import { archiveMutations } from "./installer.js";
 const PACKAGE_NAME = "@kisev/agentomatic";
 const GENERIC_MANIFEST = ".agentomatic-manifest.json";
@@ -394,12 +394,11 @@ async function build(scope, cwd = process.cwd(), home = homedir()) {
         diagnostic_state_only: await diagnostic(home),
         operations: operations.sort((left, right) => left.path.localeCompare(right.path)),
     };
-    const planDigest = digest(base);
     const confirmable = operations.length > 0 &&
         groups["modified-managed"].length === 0 &&
         groups.conflict.length === 0;
     return {
-        plan: { ...base, plan_digest: planDigest, confirmable, digest: planDigest },
+        plan: { ...base, confirmable },
         mutations,
     };
 }
@@ -413,23 +412,7 @@ export async function previewReconcile(scope, cwd = process.cwd(), home = homedi
             const built = await build(scope, cwd, home);
             const blocked = built.plan.modified_managed.length > 0 || built.plan.conflicts.length > 0;
             const actionable = built.plan.operations.length > 0;
-            if (blocked || !actionable) {
-                await supersedeReceipt(stateRoot);
-                const { digest: _digest, ...withoutReceipt } = built.plan;
-                return { ...withoutReceipt, confirmable: false };
-            }
-            const receipt = await saveReceipt(stateRoot, "reconcile", scope, root, {
-                plan_digest: built.plan.plan_digest,
-            }, Date.now(), built.plan.plan_digest);
-            return {
-                ...built.plan,
-                plan_digest: built.plan.plan_digest,
-                confirmation_digest: receipt.digest,
-                digest: receipt.digest,
-                confirmable: true,
-                receipt_expires_at: receipt.expires_at,
-                ...(receipt.superseded_plan ? { superseded_plan: receipt.superseded_plan } : {}),
-            };
+            return { ...built.plan, confirmable: !blocked && actionable };
         });
     }
     catch (error) {
@@ -444,22 +427,14 @@ export async function previewReconcile(scope, cwd = process.cwd(), home = homedi
 export async function inspectReconcile(scope, cwd = process.cwd(), home = homedir()) {
     return (await build(scope, cwd, home)).plan;
 }
-export async function applyReconcile(scope, confirmationDigest, cwd = process.cwd(), home = homedir(), options = {}) {
+export async function applyReconcile(scope, cwd = process.cwd(), home = homedir(), options = {}) {
     const stateRoot = lifecycleRoot(scope, cwd, home);
     const root = scopeRoot(scope, cwd, home);
     try {
         return await withLifecycleLock(stateRoot, async () => {
             if (await recoverTransaction(root, stateRoot, reconcileAllowedRoots(scope, cwd, home)))
                 throw new ReconcileError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
-            const payload = (await consumeReceipt(stateRoot, {
-                digest: confirmationDigest,
-                kind: "reconcile",
-                scope,
-                root,
-            }));
             const built = await build(scope, cwd, home);
-            if (built.plan.plan_digest !== (payload.plan_digest ?? payload.digest))
-                throw new ReconcileError("stale_plan", "Reconcile inventory changed after preview");
             if (built.plan.conflicts.length || built.plan.modified_managed.length)
                 throw new ReconcileError("conflict", "Reconcile contains unsafe ownership conflicts");
             await applyTransaction(root, stateRoot, built.mutations, {
@@ -476,7 +451,7 @@ export async function applyReconcile(scope, confirmationDigest, cwd = process.cw
             return {
                 status: "ok",
                 applied: true,
-                plan: { ...built.plan, digest: confirmationDigest },
+                plan: built.plan,
             };
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.0-dev.54.g26e86b0b9fcd",
+  "version": "11.0.0-dev.55.g6d90f51aeff6",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -49,8 +49,8 @@
     "pack:check": "node test/pack-allowlist.mjs"
   },
   "dependencies": {
-    "@kisev/memomatic": "1.0.0-dev.54.g26e86b0b9fcd",
-    "@kisev/safe-fs": "1.0.0-dev.54.g26e86b0b9fcd"
+    "@kisev/memomatic": "1.0.0-dev.55.g6d90f51aeff6",
+    "@kisev/safe-fs": "1.0.0-dev.55.g6d90f51aeff6"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.29",