attention-manifest-protocol 0.4.0 → 0.4.2

package/lib/database/entity/process.d.ts

@@ -0,0 +1,30 @@
+import type { Entity } from "./entity.js";
+import type { TableMeta } from "./meta.js";
+/**
+ * Row shape of `processes`: a persistent agent, not a task.
+ */
+export interface ProcessEntity {
+    pid: number;
+    id: string;
+    name: string;
+    role: string | null;
+    state: string;
+    priority: number;
+    budget: string;
+    used: string;
+    parent_pid: number | null;
+    created_at: string;
+    started_at: string | null;
+    terminated_at: string | null;
+    exit_code: string | null;
+    exit_note: string | null;
+    version: number;
+}
+/**
+ * JPA metadata for the process/agent table.
+ */
+export declare const ProcessEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const ProcessTable: TableMeta;

package/lib/database/entity/process.js

@@ -0,0 +1,40 @@
+import { defineEntity, toTableMeta } from "./entity.js";
+/**
+ * JPA metadata for the process/agent table.
+ */
+export const ProcessEntityMeta = defineEntity({
+    name: "Process",
+    table: {
+        name: "processes",
+        uniqueConstraints: [{ columnNames: ["id"] }],
+    },
+    fields: [
+        { name: "pid", id: true, generated: { strategy: "Identity" } },
+        { name: "id" },
+        { name: "name" },
+        { name: "role" },
+        { name: "state" },
+        { name: "priority" },
+        { name: "budget" },
+        { name: "used" },
+        { name: "parent_pid" },
+        { name: "created_at" },
+        { name: "started_at" },
+        { name: "terminated_at" },
+        { name: "exit_code" },
+        { name: "exit_note" },
+        { name: "version", version: true },
+    ],
+    relations: [
+        {
+            name: "parent",
+            target: "Process",
+            optional: true,
+            joinColumns: [{ name: "parent_pid" }],
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const ProcessTable = toTableMeta(ProcessEntityMeta);

package/lib/database/entity/registry.d.ts

@@ -0,0 +1,81 @@
+import type { Entity } from "./entity.js";
+import type { TableMeta } from "./meta.js";
+/**
+ * Current state of one concept; history lives in `objects`.
+ */
+export interface ConceptEntity {
+    cid: number;
+    id: string;
+    label: string;
+    definition: string;
+    status: string;
+    version: number;
+    object_seq: number | null;
+    digest: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * JPA metadata for the concept registry.
+ */
+export declare const ConceptEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const ConceptTable: TableMeta;
+/**
+ * Current state of one module (a code directory is only its physical shadow).
+ */
+export interface ModuleEntity {
+    mid: number;
+    id: string;
+    kind: string;
+    entry: string;
+    description: string;
+    status: string;
+    version: number;
+    object_seq: number | null;
+    digest: string | null;
+    content_digest: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * JPA metadata for the module registry.
+ */
+export declare const ModuleEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const ModuleTable: TableMeta;
+/**
+ * Link between a module and a concept.
+ */
+export interface ModuleConceptEntity {
+    mid: number;
+    cid: number;
+    role: string;
+}
+/**
+ * JPA metadata for the module-concept join table.
+ */
+export declare const ModuleConceptEntityMeta: Entity;
+/**
+ * Current state of one attestation.
+ */
+export interface AttestationEntity {
+    aid: number;
+    subject_kind: string;
+    subject_id: string;
+    claim_id: string;
+    object_seq: number | null;
+    at: string;
+}
+/**
+ * JPA metadata for registry attestations.
+ */
+export declare const AttestationEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const AttestationTable: TableMeta;

package/lib/database/entity/registry.js

@@ -0,0 +1,91 @@
+import { defineEntity, toTableMeta } from "./entity.js";
+/**
+ * JPA metadata for the concept registry.
+ */
+export const ConceptEntityMeta = defineEntity({
+    name: "Concept",
+    table: {
+        name: "concepts",
+        uniqueConstraints: [{ columnNames: ["id"] }],
+    },
+    fields: [
+        { name: "cid", id: true, generated: { strategy: "Identity" } },
+        { name: "id" },
+        { name: "label" },
+        { name: "definition" },
+        { name: "status" },
+        { name: "version", version: true },
+        { name: "object_seq" },
+        { name: "digest" },
+        { name: "created_at" },
+        { name: "updated_at" },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const ConceptTable = toTableMeta(ConceptEntityMeta);
+/**
+ * JPA metadata for the module registry.
+ */
+export const ModuleEntityMeta = defineEntity({
+    name: "Module",
+    table: {
+        name: "modules",
+        uniqueConstraints: [{ columnNames: ["id"] }],
+    },
+    fields: [
+        { name: "mid", id: true, generated: { strategy: "Identity" } },
+        { name: "id" },
+        { name: "kind" },
+        { name: "entry" },
+        { name: "description" },
+        { name: "status" },
+        { name: "version", version: true },
+        { name: "object_seq" },
+        { name: "digest" },
+        { name: "content_digest" },
+        { name: "created_at" },
+        { name: "updated_at" },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const ModuleTable = toTableMeta(ModuleEntityMeta);
+/**
+ * JPA metadata for the module-concept join table.
+ */
+export const ModuleConceptEntityMeta = defineEntity({
+    name: "ModuleConcept",
+    table: {
+        name: "module_concepts",
+    },
+    idClass: "ModuleConceptId",
+    fields: [
+        { name: "mid", id: true },
+        { name: "cid", id: true },
+        { name: "role", id: true },
+    ],
+});
+/**
+ * JPA metadata for registry attestations.
+ */
+export const AttestationEntityMeta = defineEntity({
+    name: "Attestation",
+    table: {
+        name: "attestations",
+    },
+    fields: [
+        { name: "aid", id: true, generated: { strategy: "Identity" } },
+        { name: "subject_kind" },
+        { name: "subject_id" },
+        { name: "claim_id" },
+        { name: "object_seq" },
+        { name: "at" },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const AttestationTable = toTableMeta(AttestationEntityMeta);

package/lib/database/entity/runtimeApproval.d.ts

@@ -0,0 +1,23 @@
+import type { TableMeta } from "./meta.js";
+export interface RuntimeApprovalRow {
+    id: number;
+    pid: number;
+    turn_id: string;
+    operation_id: string;
+    tool: string;
+    risk: string;
+    decision: string;
+    status: string;
+    created_at: string;
+}
+export declare const RuntimeApprovalTable: TableMeta;
+export interface RuntimeApprovalInput {
+    pid: number;
+    turnId: string;
+    operationId: string;
+    tool: string;
+    risk: string;
+    decision: string;
+    status: string;
+    at: string;
+}

package/lib/database/entity/runtimeApproval.js

@@ -0,0 +1,5 @@
+export const RuntimeApprovalTable = {
+    table: "runtime_approvals",
+    primaryKey: "id",
+    columns: ["id", "pid", "turn_id", "operation_id", "tool", "risk", "decision", "status", "created_at"],
+};

package/lib/database/entity/runtimeSession.d.ts

@@ -0,0 +1,7 @@
+import type { TableMeta } from "./meta.js";
+export interface RuntimeSessionRow {
+    pid: number;
+    data: string;
+    updated_at: string;
+}
+export declare const RuntimeSessionTable: TableMeta;

package/lib/database/entity/runtimeSession.js

@@ -0,0 +1,5 @@
+export const RuntimeSessionTable = {
+    table: "runtime_sessions",
+    primaryKey: "pid",
+    columns: ["pid", "data", "updated_at"],
+};

package/lib/database/entity/runtimeTurn.d.ts

@@ -0,0 +1,9 @@
+import type { TableMeta } from "./meta.js";
+export interface RuntimeTurnRow {
+    id: string;
+    pid: number;
+    session_id: string | null;
+    data: string;
+    created_at: string;
+}
+export declare const RuntimeTurnTable: TableMeta;

package/lib/database/entity/runtimeTurn.js

@@ -0,0 +1,5 @@
+export const RuntimeTurnTable = {
+    table: "runtime_turns",
+    primaryKey: "id",
+    columns: ["id", "pid", "session_id", "data", "created_at"],
+};

package/lib/database/entity/thread.d.ts

@@ -0,0 +1,35 @@
+import type { Entity } from "./entity.js";
+import type { TableMeta } from "./meta.js";
+/**
+ * Row shape of `threads`: one task/goal an agent is executing.
+ */
+export interface ThreadEntity {
+    tid: number;
+    id: string;
+    pid: number;
+    goal: string;
+    statement: string;
+    success: string;
+    state: string;
+    priority: number;
+    quantum_ms: number;
+    slice_used_ms: number;
+    budget: string;
+    used: string;
+    blocked_on: string | null;
+    wake_at: string | null;
+    created_at: string;
+    finished_at: string | null;
+    exit_note: string | null;
+    owner_worker: string | null;
+    lease: number;
+    version: number;
+}
+/**
+ * JPA metadata for the thread/task table.
+ */
+export declare const ThreadEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const ThreadTable: TableMeta;

package/lib/database/entity/thread.js

@@ -0,0 +1,55 @@
+import { defineEntity, toTableMeta } from "./entity.js";
+/**
+ * JPA metadata for the thread/task table.
+ */
+export const ThreadEntityMeta = defineEntity({
+    name: "Thread",
+    table: {
+        name: "threads",
+        uniqueConstraints: [{ columnNames: ["id"] }],
+    },
+    fields: [
+        { name: "tid", id: true, generated: { strategy: "Identity" } },
+        { name: "id" },
+        { name: "pid" },
+        { name: "goal" },
+        { name: "statement" },
+        { name: "success" },
+        { name: "state" },
+        { name: "priority" },
+        { name: "quantum_ms" },
+        { name: "slice_used_ms" },
+        { name: "budget" },
+        { name: "used" },
+        { name: "blocked_on" },
+        { name: "wake_at" },
+        { name: "created_at" },
+        { name: "finished_at" },
+        { name: "exit_note" },
+        { name: "owner_worker" },
+        { name: "lease" },
+        { name: "version", version: true },
+    ],
+    relations: [
+        {
+            name: "process",
+            target: "Process",
+            joinColumns: [{ name: "pid" }],
+        },
+        {
+            name: "steps",
+            target: "Step",
+            mappedBy: "tid",
+        },
+        {
+            name: "ownerWorker",
+            target: "Worker",
+            optional: true,
+            joinColumns: [{ name: "owner_worker" }],
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const ThreadTable = toTableMeta(ThreadEntityMeta);

package/lib/database/entity/window.d.ts

@@ -0,0 +1,39 @@
+import type { Entity } from "./entity.js";
+import type { TableMeta } from "./meta.js";
+/**
+ * Row shape of a thread's context window.
+ */
+export interface WindowEntity {
+    tid: number;
+    capacity_tokens: number;
+    used_tokens: number;
+    updated_at: string;
+}
+/**
+ * JPA metadata for context windows.
+ */
+export declare const WindowEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const WindowTable: TableMeta;
+/**
+ * Row shape of one resident window page.
+ */
+export interface WindowPageEntity {
+    tid: number;
+    page_id: string;
+    object_kind: string;
+    object_id: string;
+    tokens: number;
+    pinned: number;
+    last_used: number;
+}
+/**
+ * JPA metadata for window pages.
+ */
+export declare const WindowPageEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const WindowPageTable: TableMeta;

package/lib/database/entity/window.js

@@ -0,0 +1,56 @@
+import { defineEntity, toTableMeta } from "./entity.js";
+/**
+ * JPA metadata for context windows.
+ */
+export const WindowEntityMeta = defineEntity({
+    name: "Window",
+    table: {
+        name: "windows",
+    },
+    fields: [{ name: "tid", id: true }, { name: "capacity_tokens" }, { name: "used_tokens" }, { name: "updated_at" }],
+    relations: [
+        {
+            name: "thread",
+            target: "Thread",
+            joinColumns: [{ name: "tid" }],
+        },
+        {
+            name: "pages",
+            target: "WindowPage",
+            mappedBy: "tid",
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const WindowTable = toTableMeta(WindowEntityMeta);
+/**
+ * JPA metadata for window pages.
+ */
+export const WindowPageEntityMeta = defineEntity({
+    name: "WindowPage",
+    table: {
+        name: "window_pages",
+    },
+    fields: [
+        { name: "tid" },
+        { name: "page_id", id: true },
+        { name: "object_kind" },
+        { name: "object_id" },
+        { name: "tokens" },
+        { name: "pinned" },
+        { name: "last_used" },
+    ],
+    relations: [
+        {
+            name: "window",
+            target: "Window",
+            joinColumns: [{ name: "tid" }],
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const WindowPageTable = toTableMeta(WindowPageEntityMeta);

package/lib/database/entity/worker.d.ts

@@ -0,0 +1,42 @@
+import type { Entity } from "./entity.js";
+import type { TableMeta } from "./meta.js";
+/**
+ * Row shape of the worker heartbeat registry.
+ */
+export interface WorkerEntity {
+    worker_id: string;
+    host: string | null;
+    pid: number | null;
+    started_at: string;
+    heartbeat_at: string;
+    expires_at: string;
+}
+/**
+ * JPA metadata for the worker registry.
+ */
+export declare const WorkerEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const WorkerTable: TableMeta;
+/**
+ * Row shape of one execution step.
+ */
+export interface StepEntity {
+    step_id: number;
+    pid: number;
+    tid: number;
+    at: string;
+    outcome: string;
+    usage: string;
+    note: string | null;
+    receipt_id: string | null;
+}
+/**
+ * JPA metadata for execution steps.
+ */
+export declare const StepEntityMeta: Entity;
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export declare const StepTable: TableMeta;

package/lib/database/entity/worker.js

@@ -0,0 +1,58 @@
+import { defineEntity, toTableMeta } from "./entity.js";
+/**
+ * JPA metadata for the worker registry.
+ */
+export const WorkerEntityMeta = defineEntity({
+    name: "Worker",
+    table: {
+        name: "workers",
+    },
+    fields: [{ name: "worker_id", id: true }, { name: "host" }, { name: "pid" }, { name: "started_at" }, { name: "heartbeat_at" }, { name: "expires_at" }],
+    relations: [
+        {
+            name: "process",
+            target: "Process",
+            optional: true,
+            joinColumns: [{ name: "pid" }],
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const WorkerTable = toTableMeta(WorkerEntityMeta);
+/**
+ * JPA metadata for execution steps.
+ */
+export const StepEntityMeta = defineEntity({
+    name: "Step",
+    table: {
+        name: "steps",
+    },
+    fields: [
+        { name: "step_id", id: true, generated: { strategy: "Identity" } },
+        { name: "pid" },
+        { name: "tid" },
+        { name: "at" },
+        { name: "outcome" },
+        { name: "usage" },
+        { name: "note" },
+        { name: "receipt_id" },
+    ],
+    relations: [
+        {
+            name: "process",
+            target: "Process",
+            joinColumns: [{ name: "pid" }],
+        },
+        {
+            name: "thread",
+            target: "Thread",
+            joinColumns: [{ name: "tid" }],
+        },
+    ],
+});
+/**
+ * Table view used by the repository and SQL layers.
+ */
+export const StepTable = toTableMeta(StepEntityMeta);

package/lib/database/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./entity/index.js";
+export * from "./repository/index.js";
+export * from "./service/index.js";
+export * from "./sql/index.js";
+export * from "./store/index.js";
+export * from "./adapter/index.js";

package/lib/database/index.js

@@ -0,0 +1,6 @@
+export * from "./entity/index.js";
+export * from "./repository/index.js";
+export * from "./service/index.js";
+export * from "./sql/index.js";
+export * from "./store/index.js";
+export * from "./adapter/index.js";

package/lib/database/repository/addressSpaceRepository.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Address-space adapter: process_objects <-> objects.
+ *
+ * This is a separate aggregate from the execution state machine, so it gets its
+ * own repository instead of bloating ExecutionRepository.
+ */
+import type { DatabaseSync } from "node:sqlite";
+import type { AddressMode, AddressRole, ProcessObjectRecord } from "../../process/process.js";
+export declare class AddressSpaceRepository {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    hasObject(seq: number): boolean;
+    attach(pid: number, seq: number, role: AddressRole, mode: AddressMode, at: string): void;
+    list(pid: number): ProcessObjectRecord[];
+    read(pid: number, seq: number): ProcessObjectRecord | undefined;
+    fork(parentPid: number, childPid: number, at: string): void;
+    join(parentPid: number, childPid: number, at: string): number;
+}

package/lib/database/repository/addressSpaceRepository.js

@@ -0,0 +1,40 @@
+export class AddressSpaceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    hasObject(seq) {
+        const row = this.db.prepare("SELECT seq FROM objects WHERE seq = ?").get(seq);
+        return row !== (void 0);
+    }
+    attach(pid, seq, role, mode, at) {
+        this.db.prepare("INSERT OR REPLACE INTO process_objects (pid, seq, role, mode, attached_at) VALUES (?, ?, ?, ?, ?)").run(pid, seq, role, mode, at);
+    }
+    list(pid) {
+        return this.db
+            .prepare(`SELECT o.seq, o.kind, o.id, o.body, p.role, p.mode
+                 FROM process_objects p JOIN objects o ON o.seq = p.seq
+                 WHERE p.pid = ? ORDER BY o.seq ASC`)
+            .all(pid);
+    }
+    read(pid, seq) {
+        return this.db
+            .prepare(`SELECT o.seq, o.kind, o.id, o.body, p.role, p.mode
+                 FROM process_objects p JOIN objects o ON o.seq = p.seq
+                 WHERE p.pid = ? AND p.seq = ?`)
+            .get(pid, seq);
+    }
+    fork(parentPid, childPid, at) {
+        this.db
+            .prepare(`INSERT OR REPLACE INTO process_objects (pid, seq, role, mode, attached_at)
+                 SELECT ?, seq, 'inherited', 'read', ? FROM process_objects WHERE pid = ?`)
+            .run(childPid, at, parentPid);
+    }
+    join(parentPid, childPid, at) {
+        const result = this.db
+            .prepare(`INSERT OR REPLACE INTO process_objects (pid, seq, role, mode, attached_at)
+                 SELECT ?, seq, 'joined', 'read', ? FROM process_objects WHERE pid = ? AND role = 'own'`)
+            .run(parentPid, at, childPid);
+        return Number(result.changes);
+    }
+}