@skill-harness/adapters 0.11.0 → 0.13.0

package/dist/learning-journal.js

@@ -0,0 +1,256 @@
+import { constants, openSync, closeSync, readSync, writeSync, fstatSync, lstatSync, fsyncSync, mkdirSync, unlinkSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { types } from 'node:util';
+import { isAbsolute, join, dirname, parse, resolve } from 'node:path';
+import { interventionCanonicalJson } from '@skill-harness/core';
+export function learningJson(value) {
+    const limit = 2 * 1024 * 1024, cache = new WeakMap(), visiting = new WeakSet();
+    const size = (v, depth) => {
+        if (depth > 16)
+            throw Error('learning JSON depth bound');
+        if (v === null || typeof v === 'boolean' || typeof v === 'string' || typeof v === 'number' && Number.isFinite(v)) {
+            if (typeof v === 'string' && Buffer.byteLength(v) > limit)
+                throw Error('learning JSON byte bound');
+            const bytes = Buffer.byteLength(JSON.stringify(v));
+            if (bytes > limit)
+                throw Error('learning JSON byte bound');
+            return { bytes, height: 0 };
+        }
+        if (!v || typeof v !== 'object')
+            throw Error('plain learning JSON required');
+        if (types.isProxy(v))
+            throw Error('learning proxy refused');
+        const old = cache.get(v);
+        if (old) {
+            if (depth + old.height > 16)
+                throw Error('learning JSON depth bound');
+            return old;
+        }
+        if (visiting.has(v))
+            throw Error('cyclic learning JSON refused');
+        visiting.add(v);
+        const array = Array.isArray(v), prototype = Object.getPrototypeOf(v), descriptors = Object.getOwnPropertyDescriptors(v);
+        if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+            throw Error('plain learning JSON required');
+        const keys = Reflect.ownKeys(descriptors);
+        if (array && (v.length > 4096 || keys.length !== v.length + 1))
+            throw Error('dense bounded learning array required');
+        const fields = array ? Array.from({ length: v.length }, (_, i) => String(i)) : keys;
+        let bytes = 2, height = 0;
+        for (let i = 0; i < fields.length; i++) {
+            const key = fields[i];
+            if (typeof key !== 'string')
+                throw Error('plain learning property required');
+            const d = descriptors[key];
+            if (!d || !('value' in d) || !d.enumerable)
+                throw Error('plain learning property required');
+            const child = size(d.value, depth + 1);
+            bytes += child.bytes + (i ? 1 : 0) + (array ? 0 : Buffer.byteLength(JSON.stringify(key)) + 1);
+            height = Math.max(height, child.height + 1);
+            if (bytes > limit)
+                throw Error('learning JSON byte bound');
+        }
+        visiting.delete(v);
+        const result = { bytes, height };
+        cache.set(v, result);
+        return result;
+    };
+    size(value, 0);
+    return interventionCanonicalJson(value);
+}
+export const learningHash = (value) => createHash('sha256').update(learningJson(value)).digest('hex');
+export const learningCopy = (value) => JSON.parse(learningJson(value));
+const LIMIT = 4 * 1024 * 1024;
+function directory(path) {
+    if (!isAbsolute(path))
+        throw Error('absolute learning directory required');
+    for (let p = path;; p = dirname(p)) {
+        const s = lstatSync(p);
+        if (!s.isDirectory() || s.isSymbolicLink())
+            throw Error('learning directory substitution');
+        if (p === parse(p).root)
+            break;
+    }
+    const s = lstatSync(path);
+    if ((s.mode & 0o077) || (process.getuid && s.uid !== process.getuid()))
+        throw Error('private owned learning directory required');
+}
+function sync(path) { const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW); try {
+    fsyncSync(fd);
+}
+finally {
+    closeSync(fd);
+} }
+export function learningFile(path, limit = 1024 * 1024) {
+    if (!constants.O_NOFOLLOW || !constants.O_NONBLOCK)
+        throw Error('required safe file flags unavailable');
+    if (!isAbsolute(path))
+        throw Error('absolute learning file required');
+    // Reject every symlink ancestor, but do not require public parent directories to be private.
+    for (let p = dirname(path);; p = dirname(p)) {
+        const s = lstatSync(p);
+        if (!s.isDirectory() || s.isSymbolicLink())
+            throw Error('learning file ancestor substitution');
+        if (p === parse(p).root)
+            break;
+    }
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const s = fstatSync(fd);
+        if (!s.isFile() || s.nlink !== 1 || s.size > limit)
+            throw Error('bounded regular learning file required');
+        const out = Buffer.alloc(limit + 1);
+        let n = 0;
+        while (n < out.length) {
+            const k = readSync(fd, out, n, out.length - n, n);
+            if (!k)
+                break;
+            n += k;
+        }
+        if (n > limit)
+            throw Error('learning file bound exceeded');
+        return out.subarray(0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Shared durable CAS for the weekly supervisor and trust lifecycle. Trusted cooperative filesystem,
+ * not hostile same-UID rollback protection. A stranded claim is never automatically recovered. */
+export function learningJournal(path, initial) {
+    if (!constants.O_NOFOLLOW || !constants.O_NONBLOCK || !constants.O_DIRECTORY)
+        throw Error('required safe journal flags unavailable');
+    if (initial !== undefined) {
+        directory(dirname(path));
+        mkdirSync(path, { mode: 0o700 });
+        directory(path);
+        const value = learningCopy(initial), body = { prior: null, value }, record = { ...body, id: learningHash(body) };
+        const fd = openSync(join(path, 'events.jsonl'), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            writeAll(fd, Buffer.from(learningJson(record) + '\n'));
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        sync(path);
+        sync(dirname(path));
+    }
+    directory(path);
+    const identity = lstatSync(path), file = join(path, 'events.jsonl');
+    const check = () => { directory(path); const s = lstatSync(path); if (s.dev !== identity.dev || s.ino !== identity.ino)
+        throw Error('learning directory identity changed'); };
+    const read = () => {
+        check();
+        const stat = lstatSync(file);
+        if ((stat.mode & 0o077) || (process.getuid && stat.uid !== process.getuid()))
+            throw Error('private learning journal required');
+        const text = learningFile(file, LIMIT).toString('utf8');
+        if (!text.endsWith('\n'))
+            throw Error('learning history incomplete');
+        const lines = text.slice(0, -1).split('\n');
+        if (!lines.length || lines.length > 4096)
+            throw Error('learning history bound');
+        let prior = null;
+        return lines.map(line => { const r = JSON.parse(line); if (learningJson(r) !== line || Object.keys(r).sort().join() !== 'id,prior,value' || r.prior !== prior || r.id !== learningHash({ prior, value: r.value }))
+            throw Error('learning history identity mismatch'); prior = r.id; return r; });
+    };
+    read();
+    return { read, append(prior, value) {
+            check();
+            const lock = join(path, 'writer.lock'), token = randomUUID();
+            const fd = openSync(lock, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600), owned = fstatSync(fd);
+            let error, result;
+            try {
+                writeAll(fd, Buffer.from(token));
+                fsyncSync(fd);
+                const history = read();
+                if (history.at(-1).id !== prior)
+                    throw Error('stale learning CAS');
+                if (history.length >= 4096)
+                    throw Error('learning history bound');
+                const body = { prior, value: learningCopy(value) }, event = { ...body, id: learningHash(body) }, line = Buffer.from(learningJson(event) + '\n');
+                const out = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+                try {
+                    const s = fstatSync(out);
+                    if (!s.isFile() || s.nlink !== 1 || (s.mode & 0o077) || s.size + line.length > LIMIT)
+                        throw Error('learning append refused');
+                    writeAll(out, line);
+                    fsyncSync(out);
+                }
+                finally {
+                    closeSync(out);
+                }
+                sync(path);
+                result = event;
+            }
+            catch (e) {
+                error = e;
+            }
+            finally {
+                try {
+                    const s = lstatSync(lock);
+                    if (s.dev !== owned.dev || s.ino !== owned.ino || learningFile(lock, 128).toString() !== token)
+                        throw Error('learning lock ownership lost');
+                    unlinkSync(lock);
+                    sync(path);
+                }
+                catch (e) {
+                    error ??= e;
+                }
+                finally {
+                    try {
+                        closeSync(fd);
+                    }
+                    catch (e) {
+                        error ??= e;
+                    }
+                }
+            }
+            if (error)
+                throw error;
+            return result;
+        } };
+}
+/** One authoritative store per weekly key/policy in this archive; a renamed directory cannot refill it. */
+export function registerLearningStore(root, kind, key, target, binding) {
+    if (!/^[a-f0-9]{64}$/.test(key) || !isAbsolute(target) || !['weekly', 'trust', 'intervention', 'access'].includes(kind))
+        throw Error('invalid learning registration');
+    directory(root);
+    directory(dirname(target));
+    const parent = join(root, 'learning-stores');
+    try {
+        mkdirSync(parent, { mode: 0o700 });
+        sync(root);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+    }
+    directory(parent);
+    const path = join(parent, `${kind}-${key}`), initial = { type: 'learning-registration-v1', target: resolve(target), binding };
+    try {
+        learningJournal(path, initial);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const records = learningJournal(path).read();
+        if (records.length !== 1 || learningHash(records[0].value) !== learningHash(initial))
+            throw Error('learning key already bound to another store or input');
+    }
+}
+export function verifyLearningStore(root, kind, key, target, binding) {
+    if (!/^[a-f0-9]{64}$/.test(key) || !isAbsolute(target))
+        throw Error('invalid learning registration');
+    const records = learningJournal(join(root, 'learning-stores', `${kind}-${key}`)).read();
+    if (records.length !== 1 || learningHash(records[0].value) !== learningHash({ type: 'learning-registration-v1', target: resolve(target), binding }))
+        throw Error('learning store registration mismatch');
+}
+function writeAll(fd, bytes) { let n = 0; while (n < bytes.length) {
+    const k = writeSync(fd, bytes, n, bytes.length - n);
+    if (!k)
+        throw Error('learning write stalled');
+    n += k;
+} }
+//# sourceMappingURL=learning-journal.js.map

package/dist/pi-daddy-ledger-v2.d.ts

@@ -1,7 +1,7 @@
-/** pi-daddy commit whose contract artifact this schema was taken from. */
-export declare const PI_DADDY_CONTRACT_COMMIT = "1948b9406c13c9730f2fc103e68023d6e58c5e85";
+/** pi-daddy commit whose contract artifacts this schema was taken from. */
+export declare const PI_DADDY_CONTRACT_COMMIT = "c364a6717e3d5e369ecd3298b9cbb595eb94d9b2";
 /** SHA-256 of the byte-exact producer schema file this object was generated from. */
-export declare const PI_DADDY_LEDGER_V2_SCHEMA_SHA256 = "69c3a6856481b9250587c5785a8aadda87baba6cb03c79b209cff4f55f70a81c";
+export declare const PI_DADDY_LEDGER_V2_SCHEMA_SHA256 = "3862bc451c25393dd40b198c62a8f94a3f58784e31da6dff05e3f06be71a3f86";
 /** pi-daddy's canonical, closed ledgerVersion 2 event schema (JSON Schema draft 2020-12). */
 export declare const PI_DADDY_LEDGER_V2_SCHEMA: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
@@ -109,7 +109,7 @@ export declare const PI_DADDY_LEDGER_V2_SCHEMA: {
         };
         readonly refusalCode: {
             readonly type: "string";
-            readonly enum: readonly ["CAPABILITY_ESCALATION", "GRANT_ID_MALFORMED", "DEFINITION_NOT_AUTHORIZED", "UNDECLARED_TOOLS", "UNKNOWN_TOOL", "GATED_UNAPPROVED", "APPROVAL_EXPIRED", "APPROVAL_SCOPE_MISMATCH", "APPROVAL_FLOW_FAILED", "DEPTH_EXCEEDED", "FANOUT_EXCEEDED", "EXECUTOR_UNAVAILABLE", "CHILD_TIMED_OUT", "CHILD_CANCELLED", "CHILD_EXIT_NONZERO", "TASK_MISSING", "UNKNOWN_DEFINITION", "CEILING_PATTERNS_UNRESOLVED", "NARROWING_VIOLATED", "DEFINITION_UNREADABLE", "CORRELATION_TOO_LARGE", "CORRELATION_INVALID", "LEDGER_WRITE_FAILED", "FANOUT_FAILED", "WORKSPACE_NOT_REGISTERED", "WORKSPACE_WRITE_CONFLICT", "WORKSPACE_LEASE_STALE", "CHECK_NOT_CONFIGURED", "CHECK_CONFIGURATION_INVALID", "CHECK_IDENTITY_UNAVAILABLE", "CHECK_IDENTITY_MISMATCH"];
+            readonly enum: readonly ["CAPABILITY_ESCALATION", "GRANT_ID_MALFORMED", "DEFINITION_NOT_AUTHORIZED", "UNDECLARED_TOOLS", "UNKNOWN_TOOL", "GATED_UNAPPROVED", "APPROVAL_EXPIRED", "APPROVAL_SCOPE_MISMATCH", "APPROVAL_FLOW_FAILED", "DEPTH_EXCEEDED", "FANOUT_EXCEEDED", "EXECUTOR_UNAVAILABLE", "CHILD_TIMED_OUT", "CHILD_CANCELLED", "CHILD_EXIT_NONZERO", "TASK_MISSING", "UNKNOWN_DEFINITION", "CEILING_PATTERNS_UNRESOLVED", "NARROWING_VIOLATED", "DEFINITION_UNREADABLE", "CORRELATION_TOO_LARGE", "CORRELATION_INVALID", "LEDGER_WRITE_FAILED", "FANOUT_FAILED", "WORKSPACE_NOT_REGISTERED", "WORKSPACE_NOT_AUTHORIZED", "WORKSPACE_WRITE_CONFLICT", "WORKSPACE_LEASE_STALE", "CHECK_NOT_CONFIGURED", "CHECK_CONFIGURATION_INVALID", "CHECK_IDENTITY_UNAVAILABLE", "CHECK_IDENTITY_MISMATCH"];
         };
         readonly refusal: {
             readonly type: "object";

package/dist/pi-daddy-ledger-v2.js

@@ -1,18 +1,19 @@
 // GENERATED by scripts/vendor-pi-daddy-contract.mjs — do not edit by hand.
 //
 // The runtime copy of pi-daddy's canonical `ledgerVersion: 2` JSON Schema, pinned to
-// producer commit 1948b9406c13c9730f2fc103e68023d6e58c5e85.
+// producer commit c364a6717e3d5e369ecd3298b9cbb595eb94d9b2.
 // It is a module rather than a file read so it survives bundling (the pi extension is a
 // committed esbuild bundle) and so the published package needs no data asset.
 //
-// contracts/pi-daddy/ledger/v2/ holds the byte-exact producer artifact and its recorded
-// SHA-256 digests; packages/adapters/test/pi-daddy-contract.test.ts asserts those digests
-// and that this object still deep-equals the vendored bytes. Re-pin with:
+// contracts/pi-daddy/ledger/v2/ holds the byte-exact producer artifacts and their
+// SHA-256 digests; packages/adapters/test/pi-daddy-contract.test.ts asserts those
+// digests and that this object still deep-equals the vendored bytes. Re-pin by first
+// recording the commit/version in this script's PRODUCER_RELEASES map, then run:
 //   node scripts/vendor-pi-daddy-contract.mjs <pi-daddy-checkout> <commit> [pr]
-/** pi-daddy commit whose contract artifact this schema was taken from. */
-export const PI_DADDY_CONTRACT_COMMIT = "1948b9406c13c9730f2fc103e68023d6e58c5e85";
+/** pi-daddy commit whose contract artifacts this schema was taken from. */
+export const PI_DADDY_CONTRACT_COMMIT = "c364a6717e3d5e369ecd3298b9cbb595eb94d9b2";
 /** SHA-256 of the byte-exact producer schema file this object was generated from. */
-export const PI_DADDY_LEDGER_V2_SCHEMA_SHA256 = "69c3a6856481b9250587c5785a8aadda87baba6cb03c79b209cff4f55f70a81c";
+export const PI_DADDY_LEDGER_V2_SCHEMA_SHA256 = "3862bc451c25393dd40b198c62a8f94a3f58784e31da6dff05e3f06be71a3f86";
 /** pi-daddy's canonical, closed ledgerVersion 2 event schema (JSON Schema draft 2020-12). */
 export const PI_DADDY_LEDGER_V2_SCHEMA = {
     "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -151,6 +152,7 @@ export const PI_DADDY_LEDGER_V2_SCHEMA = {
                 "LEDGER_WRITE_FAILED",
                 "FANOUT_FAILED",
                 "WORKSPACE_NOT_REGISTERED",
+                "WORKSPACE_NOT_AUTHORIZED",
                 "WORKSPACE_WRITE_CONFLICT",
                 "WORKSPACE_LEASE_STALE",
                 "CHECK_NOT_CONFIGURED",