attention-manifest-protocol 0.4.2 → 0.4.4

package/src/attention/social.ts

@@ -1,217 +0,0 @@
-import type { Id, Timestamp } from "../types/common.ts";
-import type { AttentionRequest, InterruptClass } from "./socialTypes.ts";
-
-export type Decision = "grant" | "defer" | "deny";
-
-export interface AttentionPolicy {
-    /**
-     * Grants allowed per class per rolling hour. Safety is never blocked by this.
-     */
-    budgets: Record<InterruptClass, number>;
-    quietHours?: {
-        start: number;
-        end: number;
-    };
-    cooldownMinutes?: number;
-    /**
-     * Curiosity must clear this expected value to be granted at all.
-     */
-    curiosityFloor?: number;
-}
-
-export const DefaultPolicy: AttentionPolicy = {
-    budgets: { safety: 1, commitment: 3, opportunity: 2, curiosity: 1 },
-    quietHours: { start: 22, end: 7 },
-    cooldownMinutes: 10,
-    curiosityFloor: 0.7,
-};
-
-export interface AttentionDecision {
-    request: Id;
-    decision: Decision;
-    reason: string;
-    at: Timestamp;
-    class: InterruptClass;
-    debtAdded: boolean;
-}
-
-export interface DebtEntry {
-    request: Id;
-    class: InterruptClass;
-    openedAt: Timestamp;
-    weight: number;
-    resolvedAt?: Timestamp;
-}
-
-type BrokerOptions = {
-    now: () => Timestamp;
-    policy?: Partial<AttentionPolicy>;
-};
-
-/**
- * Attention broker (Profile `Social`).
- *
- * The human's attention is a budgeted resource, not a callable function.
- * Safety bypasses the budget; everything else queues, cools down, or is denied.
- */
-export class AttentionBroker {
-    private readonly policy: AttentionPolicy;
-    private readonly now: () => Timestamp;
-    private readonly requests = new Map<Id, AttentionRequest>();
-    private readonly decisions = new Map<Id, AttentionDecision>();
-    private readonly grants = new Map<InterruptClass, Timestamp[]>();
-    private readonly lastTouch = new Map<Id, number>();
-    private readonly debt: DebtEntry[] = [];
-
-    constructor(options: BrokerOptions) {
-        this.now = options.now;
-        this.policy = {
-            ...DefaultPolicy,
-            ...options.policy,
-            budgets: { ...DefaultPolicy.budgets, ...(options.policy?.budgets ?? {}) },
-        };
-    }
-
-    submit(request: AttentionRequest): AttentionDecision {
-        if (!request.why_now || !request.if_ignored) {
-            throw new Error("an attention request needs why_now and if_ignored");
-        }
-        if (this.requests.has(request.id)) {
-            throw new Error(`duplicate request: ${request.id}`);
-        }
-        this.requests.set(request.id, request);
-
-        const at: Timestamp = this.now();
-        const kind: InterruptClass = request.class;
-        const decision: AttentionDecision = this.decide(request, at, kind);
-        this.decisions.set(request.id, decision);
-
-        if (decision.decision === "grant") {
-            this.recordGrant(kind, at);
-            this.lastTouch.set(request.target.id, Date.parse(at));
-        }
-        if (decision.decision !== "grant") {
-            this.lastTouch.set(request.id, Date.parse(at));
-        }
-        if (decision.debtAdded) {
-            this.debt.push({ request: request.id, class: kind, openedAt: at, weight: request.urgency });
-        }
-        return decision;
-    }
-
-    private decide(request: AttentionRequest, at: Timestamp, kind: InterruptClass): AttentionDecision {
-        const immediate: AttentionDecision = {
-            request: request.id,
-            decision: "grant",
-            reason: "safety_bypass",
-            at,
-            class: kind,
-            debtAdded: false,
-        };
-        if (kind === "safety") {
-            return immediate;
-        }
-
-        const hour: number = new Date(at).getUTCHours();
-        const quiet: AttentionPolicy["quietHours"] = this.policy.quietHours;
-        const inQuietHours: boolean = quiet
-            ? quiet.start <= quiet.end
-                ? hour >= quiet.start && hour < quiet.end
-                : hour >= quiet.start || hour < quiet.end
-            : false;
-        if (inQuietHours) {
-            return this.defer(request, at, kind, "quiet_hours");
-        }
-
-        const cooldown: number = this.policy.cooldownMinutes ?? 0;
-        const touched: number | undefined = this.lastTouch.get(request.target.id);
-        if (touched !== (void 0) && cooldown > 0) {
-            const elapsed: number = (Date.parse(at) - touched) / 60_000;
-            if (elapsed < cooldown) {
-                return this.defer(request, at, kind, "cooldown");
-            }
-        }
-
-        if (kind === "curiosity" && (request.expected_value ?? 0) < (this.policy.curiosityFloor ?? 0)) {
-            return { request: request.id, decision: "deny", reason: "curiosity_below_floor", at, class: kind, debtAdded: false };
-        }
-
-        if (this.grantedThisHour(kind, at) >= this.policy.budgets[kind]) {
-            return request.fallback === "queue"
-                ? this.defer(request, at, kind, "budget_exhausted")
-                : { request: request.id, decision: "deny", reason: "budget_exhausted", at, class: kind, debtAdded: false };
-        }
-
-        return { request: request.id, decision: "grant", reason: "within_budget", at, class: kind, debtAdded: false };
-    }
-
-    private defer(request: AttentionRequest, at: Timestamp, kind: InterruptClass, reason: string): AttentionDecision {
-        if (request.fallback === "drop") {
-            return { request: request.id, decision: "deny", reason: `${reason}:fallback_drop`, at, class: kind, debtAdded: false };
-        }
-        this.lastTouch.set(request.target.id, Date.parse(at));
-        return { request: request.id, decision: "defer", reason, at, class: kind, debtAdded: true };
-    }
-
-    private grantedThisHour(kind: InterruptClass, at: Timestamp): number {
-        const now: number = Date.parse(at);
-        const window: Timestamp[] = (this.grants.get(kind) ?? []).filter((stamp) => now - Date.parse(stamp) < 3_600_000);
-        this.grants.set(kind, window);
-        return window.length;
-    }
-
-    private recordGrant(kind: InterruptClass, at: Timestamp): void {
-        const list: Timestamp[] = this.grants.get(kind) ?? [];
-        list.push(at);
-        this.grants.set(kind, list);
-        this.lastTouch.set(kind, Date.parse(at));
-    }
-
-    /**
-     * Resolve a deferred request: it is answered, expired, or withdrawn.
-     */
-    resolve(requestId: Id, outcome: "answered" | "expired" | "withdrawn" = "answered"): void {
-        const entry: DebtEntry | undefined = this.debt.find((item) => item.request === requestId && !item.resolvedAt);
-        if (!entry) {
-            throw new Error(`no open debt for ${requestId}`);
-        }
-        entry.resolvedAt = this.now();
-        void outcome;
-    }
-
-    /**
-     * Age-weighted debt: minutes open × urgency. Higher means more owed.
-     */
-    debtScore(at: Timestamp = this.now()): number {
-        const now: number = Date.parse(at);
-        return Math.round(
-            this.debt.reduce((sum, entry) => {
-                const end: number = entry.resolvedAt ? Date.parse(entry.resolvedAt) : now;
-                return sum + Math.max(0, (end - Date.parse(entry.openedAt)) / 60_000) * entry.weight;
-            }, 0),
-        );
-    }
-
-    openDebt(): DebtEntry[] {
-        return this.debt.filter((entry) => !entry.resolvedAt);
-    }
-
-    /**
-     * How many requests were granted (feeds the unified ledger snapshot).
-     */
-    grantedCount(): number {
-        let count: number = 0;
-        const decisions: AttentionDecision[] = [...this.decisions.values()];
-        for (let index: number = 0; index < decisions.length; index += 1) {
-            const decision: AttentionDecision = decisions[index];
-            if (decision.decision === "grant") {
-                count += 1;
-            }
-        }
-        return count;
-    }
-
-    decisionOf(requestId: Id): AttentionDecision | undefined {
-        return this.decisions.get(requestId);
-    }
-}

package/src/attention/socialTypes.ts

@@ -1,115 +0,0 @@
-/**
- * AMP v0.1 — social objects (Profile `Social`): other-model | common-ground | attention-request.
- * Mirrors docs/schemas/social.schema.json.
- *
- * Everything about another mind is a hypothesis carrying confidence, not a fact (W-1, INV-11).
- */
-import type { Confidence, Id, Ref, Timestamp } from "../types/common.ts";
-
-export interface OtherSubject {
-    kind: "human" | "agent";
-    id: Id;
-    label?: string;
-}
-
-export interface BeliefAscription {
-    slot: Id;
-    /**
-     * 1 = "A believes P" · 2 = "A believes B believes P". Depth above 2 is computed from records, not elicited.
-     */
-    order: 1 | 2 | 3;
-    proposition: string;
-    confidence: Confidence;
-    source: string;
-    volatility: "low" | "medium" | "high";
-    ttl: number;
-}
-
-export interface GoalAscription {
-    goal: string;
-    priority: number;
-    confidence: Confidence;
-}
-
-export interface KnowledgeState {
-    known?: Ref[];
-    unknown?: Ref[];
-    uncertain?: Ref[];
-}
-
-export interface Preference {
-    key: string;
-    value: string;
-    confidence: Confidence;
-    source?: string;
-}
-
-export interface AttentionState {
-    state: "idle" | "busy" | "interruptible";
-    load?: Confidence;
-    last_interaction?: Timestamp;
-}
-
-export interface TrustAssessment {
-    domain?: string;
-    level: Confidence;
-    basis?: string;
-}
-
-export interface Privacy {
-    scope: "turn" | "session" | "task" | "persistent";
-    retention_days?: number;
-    redact?: string[];
-}
-
-export interface OtherModel {
-    amp: "0.1";
-    kind: "other-model";
-    id: Id;
-    subject: OtherSubject;
-    beliefs: BeliefAscription[];
-    goals?: GoalAscription[];
-    knowledge?: KnowledgeState;
-    preferences?: Preference[];
-    attention?: AttentionState;
-    trust?: TrustAssessment;
-    common_ground?: Ref[];
-    privacy: Privacy;
-    confidence: Confidence;
-    updated: Timestamp;
-}
-
-export interface CommonGround {
-    amp: "0.1";
-    kind: "common-ground";
-    id: Id;
-    proposition: string;
-    /**
-     * Only the first four actually establish common ground.
-     */
-    established_by: "assertion" | "confirmation" | "repair" | "shared_observation" | "assumption";
-    participants: Ref[];
-    confidence: Confidence;
-    established_at: Timestamp;
-}
-
-export type InterruptClass = "safety" | "commitment" | "opportunity" | "curiosity";
-
-export interface AttentionRequest {
-    amp: "0.1";
-    kind: "attention-request";
-    id: Id;
-    from: Ref;
-    to: Ref;
-    target: Ref;
-    class: InterruptClass;
-    urgency: 1 | 2 | 3 | 4 | 5;
-    why_now: string;
-    if_ignored: string;
-    cost: import("../types/common.ts").Budget;
-    expected_value?: Confidence;
-    expires?: Timestamp;
-    fallback: "queue" | "drop" | "escalate";
-}
-
-export type SocialObject = OtherModel | CommonGround | AttentionRequest;

package/src/authz/authz.ts

@@ -1,305 +0,0 @@
-/**
- * Capability-based authorization.
- *
- * A logical process has no MMU, so isolation is a policy decision: by default a
- * subject may touch only its own resources, and any cross-subject access needs a
- * live capability row. Capabilities are attenuating (rights and expiry can only
- * shrink), recursive (revoking a parent revokes its grants) and auditable (every
- * grant/revoke appends an event to the object chain).
- */
-import type { DatabaseSync } from "node:sqlite";
-
-import type { Id } from "../types/common.ts";
-import { AuthzError } from "../error/authzError.ts";
-import { putObject } from "../database/store/database.ts";
-
-export type SubjectKind = "host" | "process" | "thread";
-
-export interface Subject {
-    kind: SubjectKind;
-    id: Id;
-    pid?: number;
-    tid?: number;
-}
-
-export type PermissionAction = "read" | "write" | "append" | "grant" | "revoke" | "spawn" | "kill" | "send" | "receive" | "fork" | "join";
-
-/**
- * @deprecated Use `PermissionAction`; `Action` is reserved for the runtime's
- * goal-directed intent (see `src/runtime/action.ts`).
- */
-export type Action = PermissionAction;
-
-export type ResourceKind = "object" | "process" | "thread" | "mailbox" | "budget";
-
-export interface Resource {
-    kind: ResourceKind;
-    id: Id;
-    /**
-     * The process that owns the resource; omitted for kernel/global objects.
-     */
-    ownerPid?: number;
-}
-
-export interface CapabilityRecord {
-    hid: number;
-    id: Id;
-    subject: Subject;
-    resource: Resource;
-    rights: Action[];
-    scope: "process" | "thread" | "shared";
-    parentHid?: number;
-    expiresAt?: string;
-    revokedAt?: string;
-    grantedBy?: Id;
-    createdAt: string;
-}
-
-export interface GrantInput {
-    grantor: Subject;
-    grantee: Subject;
-    resource: Resource;
-    rights: Action[];
-    scope?: "process" | "thread" | "shared";
-    expiresAt?: string;
-}
-
-interface HandleRow {
-    hid: number;
-    id: string;
-    subject_kind: SubjectKind;
-    subject_id: string;
-    subject_pid: number | null;
-    resource_kind: ResourceKind;
-    resource_id: string;
-    owner_pid: number | null;
-    rights: string;
-    scope: "process" | "thread" | "shared";
-    parent_hid: number | null;
-    expires_at: string | null;
-    revoked_at: string | null;
-    granted_by: string | null;
-    created_at: string;
-}
-
-const AllActions: readonly Action[] = ["read", "write", "append", "grant", "revoke", "spawn", "kill", "send", "receive", "fork", "join"];
-
-const toCapability = (row: HandleRow): CapabilityRecord => {
-    const subject: Subject = { kind: row.subject_kind, id: row.subject_id };
-    if (row.subject_pid !== null) {
-        subject.pid = row.subject_pid;
-    }
-    const resource: Resource = { kind: row.resource_kind, id: row.resource_id };
-    if (row.owner_pid !== null) {
-        resource.ownerPid = row.owner_pid;
-    }
-    const capability: CapabilityRecord = {
-        hid: row.hid,
-        id: row.id,
-        subject,
-        resource,
-        rights: JSON.parse(row.rights) as Action[],
-        scope: row.scope,
-        createdAt: row.created_at,
-    };
-    if (row.parent_hid !== null) {
-        capability.parentHid = row.parent_hid;
-    }
-    if (row.expires_at !== null) {
-        capability.expiresAt = row.expires_at;
-    }
-    if (row.revoked_at !== null) {
-        capability.revokedAt = row.revoked_at;
-    }
-    if (row.granted_by !== null) {
-        capability.grantedBy = row.granted_by;
-    }
-    return capability;
-};
-
-const live = (row: HandleRow, at: string): boolean => row.revoked_at === null && (row.expires_at === null || row.expires_at > at);
-
-const rowsFor = (db: DatabaseSync, subject: Subject, resource: Resource, at: string): HandleRow[] => {
-    const subjects: Subject[] = [subject];
-    // A thread also acts with the capabilities of its process (fds are shared).
-    if (subject.kind === "thread" && subject.pid !== (void 0)) {
-        subjects.push({ kind: "process", id: `p.${subject.pid}`, pid: subject.pid });
-    }
-    const rows: HandleRow[] = [];
-    for (const candidate of subjects) {
-        const found = db
-            .prepare(
-                `SELECT * FROM handles
-                 WHERE subject_kind = ? AND subject_id = ?
-                   AND resource_kind = ? AND resource_id = ?
-                 ORDER BY hid ASC`,
-            )
-            .all(candidate.kind, candidate.id, resource.kind, resource.id) as unknown as HandleRow[];
-        rows.push(...found.filter((row) => live(row, at)));
-    }
-    if (subject.kind === "thread" && subject.pid !== (void 0)) {
-        const inherited = db
-            .prepare(
-                `SELECT * FROM handles
-                 WHERE subject_kind = 'process' AND subject_pid = ?
-                   AND resource_kind = ? AND resource_id = ?
-                 ORDER BY hid ASC`,
-            )
-            .all(subject.pid, resource.kind, resource.id) as unknown as HandleRow[];
-        rows.push(...inherited.filter((row) => live(row, at)));
-    }
-    return rows;
-};
-
-const isOwner = (subject: Subject, resource: Resource): boolean => resource.ownerPid !== (void 0) && subject.pid === resource.ownerPid;
-
-/**
- * Rights the subject actually holds on the resource, including ownership.
- */
-export const effectiveRights = (db: DatabaseSync, subject: Subject, resource: Resource, at: string): Action[] => {
-    if (subject.kind === "host" || isOwner(subject, resource)) {
-        return [...AllActions];
-    }
-    const rights = new Set<Action>();
-    for (const row of rowsFor(db, subject, resource, at)) {
-        for (const right of JSON.parse(row.rights) as Action[]) {
-            rights.add(right);
-        }
-    }
-    return [...rights];
-};
-
-export const can = (db: DatabaseSync, subject: Subject, action: Action, resource: Resource, at: string): boolean => {
-    return effectiveRights(db, subject, resource, at).includes(action);
-};
-
-/**
- * Throws unless the subject holds `action` on `resource`.
- */
-export const requirePermission = (db: DatabaseSync, subject: Subject, action: Action, resource: Resource, at: string): void => {
-    if (can(db, subject, action, resource, at)) {
-        return;
-    }
-    throw new AuthzError("permission_denied", [`${subject.kind}:${subject.id} may not ${action} ${resource.kind}:${resource.id}`]);
-};
-
-export const listCapabilities = (db: DatabaseSync, subject: Subject): CapabilityRecord[] => {
-    const rows = db
-        .prepare("SELECT * FROM handles WHERE subject_kind = ? AND subject_id = ? ORDER BY hid ASC")
-        .all(subject.kind, subject.id) as unknown as HandleRow[];
-    return rows.map(toCapability);
-};
-
-/**
- * Grant a subset of the grantor's rights to another subject.
- *
- * Amplification is rejected in both dimensions the model cares about: no new
- * right may appear, and the new expiry may not outlive the grantor's own.
- */
-export const grant = (db: DatabaseSync, input: GrantInput, at: string): CapabilityRecord => {
-    if (input.rights.length === 0) {
-        throw new AuthzError("invalid_grant", ["rights must not be empty"]);
-    }
-    if (input.grantee.kind === "host") {
-        throw new AuthzError("invalid_grant", ["cannot grant to host"]);
-    }
-    requirePermission(db, input.grantor, "grant", input.resource, at);
-
-    const available: Action[] = effectiveRights(db, input.grantor, input.resource, at);
-    const amplified: Action[] = input.rights.filter((right) => !available.includes(right));
-    if (amplified.length > 0) {
-        throw new AuthzError("rights_amplification", [`grantor does not hold ${amplified.join(", ")}`]);
-    }
-
-    const source = rowsFor(db, input.grantor, input.resource, at).find((row) => (JSON.parse(row.rights) as Action[]).includes("grant"));
-    const sourceExpiry: string | undefined = source?.expires_at ?? undefined;
-    if (sourceExpiry !== (void 0) && (input.expiresAt === (void 0) || input.expiresAt > sourceExpiry)) {
-        throw new AuthzError("expiry_amplification", [`grant expires after the grantor's capability (${sourceExpiry})`]);
-    }
-
-    const count = db.prepare("SELECT COUNT(*) AS n FROM handles").get() as { n: number };
-    const hid: number = count.n + 1;
-    const id: Id = `h.${hid}`;
-    const scope = input.scope ?? (input.grantee.kind === "thread" ? "thread" : "process");
-    const result = db
-        .prepare(
-            `INSERT INTO handles
-             (id, subject_kind, subject_id, subject_pid, resource_kind, resource_id, owner_pid, rights, scope, parent_hid, expires_at, granted_by, created_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        )
-        .run(
-            id,
-            input.grantee.kind,
-            input.grantee.id,
-            input.grantee.pid ?? null,
-            input.resource.kind,
-            input.resource.id,
-            input.resource.ownerPid ?? null,
-            JSON.stringify(input.rights),
-            scope,
-            source?.hid ?? null,
-            input.expiresAt ?? null,
-            input.grantor.id,
-            at,
-        );
-    const row = db.prepare("SELECT * FROM handles WHERE hid = ?").get(Number(result.lastInsertRowid)) as unknown as HandleRow;
-    putObject(
-        db,
-        "event",
-        `ev.authz.grant.${row.hid}`,
-        {
-            amp: "0.1",
-            kind: "event",
-            id: `ev.authz.grant.${row.hid}`,
-            at,
-            actor: { kind: input.grantor.kind === "host" ? "self" : "agent", id: input.grantor.id },
-            type: "authz.granted",
-            payload: { capability: id, grantee: input.grantee.id, resource: input.resource, rights: input.rights },
-        },
-        at,
-    );
-    return toCapability(row);
-};
-
-/**
- * Revoke a capability and every grant derived from it.
- */
-export const revoke = (db: DatabaseSync, subject: Subject, hid: number, at: string): number => {
-    const row = db.prepare("SELECT * FROM handles WHERE hid = ?").get(hid) as unknown as HandleRow | undefined;
-    if (row === (void 0)) {
-        throw new AuthzError("unknown_capability", [`hid ${hid}`]);
-    }
-    const capability = toCapability(row);
-    requirePermission(db, subject, "revoke", capability.resource, at);
-    const result = db
-        .prepare(
-            `WITH RECURSIVE tree(hid) AS (
-               SELECT ?
-               UNION ALL
-               SELECT h.hid FROM handles h JOIN tree t ON h.parent_hid = t.hid
-             )
-             UPDATE handles SET revoked_at = ?
-             WHERE hid IN (SELECT hid FROM tree) AND revoked_at IS NULL`,
-        )
-        .run(hid, at);
-    const count: number = Number(result.changes);
-    if (count === 0) {
-        return 0;
-    }
-    putObject(
-        db,
-        "event",
-        `ev.authz.revoke.${hid}.${count}`,
-        {
-            amp: "0.1",
-            kind: "event",
-            id: `ev.authz.revoke.${hid}.${count}`,
-            at,
-            actor: { kind: "self", id: subject.id },
-            type: "authz.revoked",
-            payload: { capability: hid, revoked: count },
-        },
-        at,
-    );
-    return count;
-};

package/src/authz/index.ts

@@ -1 +0,0 @@
-export * from "./authz.ts";