Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

fix(access): never attest ops not yet keyed to the person; re-check attest_ops for stored writes and jobs (GST-359 C1 review H1, M1, L1, L2)

garrytane81a9c3ae75b
diff --git a/src/core/access/actor-model.ts b/src/core/access/actor-model.ts
index 2f6dc29a9f..66bde6f55e 100644
--- a/src/core/access/actor-model.ts
+++ b/src/core/access/actor-model.ts
@@ -9,6 +9,20 @@ export const ACTOR_HEADER = 'x-qm-actor';
export const ACTOR_ARGUMENT = 'acting_user';
export const ATTEST_SYSTEMS: readonly string[] = ['qm'];
export const DEFAULT_ATTEST_OPS: readonly string[] = ['memory_recall', 'memory_write'];
+/**
+ * Operations no attested call may run yet: what they read or write is not keyed to the person, so one person could
+ * see another's result (an agent job's output, a write receipt, a delta feed) or write facts and takes every reader
+ * sees. GST-359 C2 removes each entry as it keys that operation to the member (member-scoped facts, jobs, receipts).
+ * Refused at `--attest-ops`, at every call and when a stored write or job tool call is re-resolved.
+ */
+export const ACTOR_DEFERRED_OPS: ReadonlySet<string> = new Set([
+ 'submit_agent', 'get_agent_job',
+ 'get_write_request', 'list_write_requests', 'cancel_write_request', 'list_write_conflicts',
+ 'delta',
+ 'remember', 'capture', 'extract_facts', 'forget', 'forget_fact',
+ 'takes_add', 'takes_update', 'takes_resolve', 'takes_supersede',
+]);
+
/** Canonical person ids: 1-256 visible ASCII characters (QM's credential broker rule), no case folding. */
export const EXTERNAL_ID_RE = /^[\x21-\x7e]{1,256}$/;
diff --git a/src/core/access/actor.ts b/src/core/access/actor.ts
index 89c8ef51c4..d9c049048e 100644
--- a/src/core/access/actor.ts
+++ b/src/core/access/actor.ts
@@ -20,12 +20,14 @@ import type { CallerAccess } from '../search/private-visibility.ts';
import { identityFor } from './principals.ts';
import { memberIdentity } from './members.ts';
import { folderAccessFor } from './caller.ts';
-import { ACTOR_ARGUMENT, ACTOR_HEADER, attestRightFrom, DEFAULT_ATTEST_OPS, EXTERNAL_ID_RE, type AttestedActor, type AttestRight } from './actor-model.ts';
+import { ACTOR_ARGUMENT, ACTOR_DEFERRED_OPS, ACTOR_HEADER, attestRightFrom, DEFAULT_ATTEST_OPS, EXTERNAL_ID_RE, type AttestedActor, type AttestRight } from './actor-model.ts';
export * from './actor-model.ts';
const ATTESTABLE_SCOPES = new Set(['read', 'write', 'agent']);
+
+
export type ActorReason = 'no_attest_right' | 'op_not_attested' | 'argument_mismatch' | 'argument_without_attestation' | 'invalid_actor_id';
/** The operation metadata attestability reads (a subset of Operation, so this module never imports the registry). */
export interface AttestableOpShape { scope?: string; requiredScopes?: readonly string[]; localOnly?: boolean; cliOnly?: unknown }
@@ -59,6 +61,7 @@ export async function attestRightOf(engine: Pick<BrainEngine, 'executeRaw'>, cal
/** Whether an operation may ever run under an attested actor: the reserved memory pair or a read, write or agent op. */
export function attestableOp(name: string, op: AttestableOpShape | undefined): boolean {
+ if (ACTOR_DEFERRED_OPS.has(name)) return false;
if (DEFAULT_ATTEST_OPS.includes(name)) return true;
if (!op || op.localOnly || op.cliOnly) return false;
return ATTESTABLE_SCOPES.has(op.scope ?? 'read') && !(op.requiredScopes ?? []).some(s => !ATTESTABLE_SCOPES.has(s));
@@ -68,6 +71,12 @@ export function attestableOp(name: string, op: AttestableOpShape | undefined): b
export function parseAttestOps(raw: string, lookup: (name: string) => AttestableOpShape | undefined): string[] {
const ops = [...new Set(raw.split(',').map(s => s.trim()).filter(Boolean))];
if (!ops.length) throw opError('invalid_params', '--attest-ops needs at least one operation.', `Pass a comma-separated list, for example ${DEFAULT_ATTEST_OPS.join(',')}.`);
+ const deferred = ops.filter(op => ACTOR_DEFERRED_OPS.has(op));
+ if (deferred.length) {
+ throw opError('invalid_params', `--attest-ops names ${deferred.join(', ')}, which an attested actor cannot run yet: what they read or write is not yet kept to the person.`,
+ `Leave ${deferred.join(', ')} out. Not attestable yet: ${[...ACTOR_DEFERRED_OPS].join(', ')}.`,
+ { why: 'An attested call must never return or record one person\'s memory where another person reads it.' });
+ }
const refused = ops.filter(op => !/^[a-z][a-z0-9_]{0,63}$/.test(op) || !attestableOp(op, lookup(op)));
if (refused.length) {
throw opError('invalid_params', `--attest-ops names ${refused.join(', ')}, which an attested actor can never run.`,
@@ -86,17 +95,25 @@ function credentialArgv(caller: ActorCaller): string[] {
const transportOf = (transport?: string) => ({ remote: true, transport: transport === 'stdio' ? 'stdio' as const : 'http' as const });
/** actor_not_attested with its reason, remedy and (where the operator can fix it) the rescope command. */
-export function actorNotAttested(reason: ActorReason, caller: ActorCaller, ctx: { op: string; transport?: string; right?: AttestRight | null }): OperationError {
+export function actorNotAttested(reason: ActorReason, caller: ActorCaller, ctx: { op: string; transport?: string; right?: AttestRight | null; reissue?: boolean }): OperationError {
const docs = ERROR_CATALOGUE.actor_not_attested.docs;
const rescope = (extra: string[]) => ['gbrain', 'auth', 'rescope', ...credentialArgv(caller), ...extra];
const hostOnly = (message: string, argv: string[], why: string, suggestion: string) =>
Object.assign(hostOnlyError(transportOf(ctx.transport), 'actor_not_attested', message, argv, why, { reason, suggestion }), { docs });
switch (reason) {
case 'no_attest_right':
+ if (ctx.reissue) {
+ return opError('actor_not_attested', `This client holds the attest right, but this access token was not issued by the client-credentials grant since the upgrade, so it may not name the person it acts for (${ACTOR_HEADER}). Nothing was read or written.`,
+ 'Request a new token with grant_type=client_credentials (POST /token) and retry with it. Tokens issued before the upgrade, or by another grant, never attest.', { reason, docs });
+ }
return hostOnly(`This connection may not name the person it acts for (${ACTOR_HEADER}), so nothing was read or written.`, rescope(['--attest-actor', 'qm']),
'Grants this client-credentials client (or member-less legacy token) the right to name the person a QM call serves. Trusting a system to name people is the brain operator\'s decision.',
'Only a credential the brain operator granted the attest right may send the actor header. Call without it, or ask the operator to run the command in fix.');
case 'op_not_attested':
+ if (ACTOR_DEFERRED_OPS.has(ctx.op)) {
+ return opError('actor_not_attested', `${ctx.op} cannot run as an attested person yet: what it reads or writes is not yet kept to the person. Nothing was read or written.`,
+ `Call it without ${ACTOR_HEADER}, or use an attestable operation. Not attestable yet: ${[...ACTOR_DEFERRED_OPS].join(', ')}.`, { reason, docs });
+ }
return hostOnly(`${ctx.op} is not in this connection's attested operations, so nothing was read or written.`,
rescope(['--attest-actor', 'qm', '--attest-ops', [...new Set([...(ctx.right?.ops ?? DEFAULT_ATTEST_OPS), ctx.op])].sort().join(',')]),
'Lets an attested call run this operation as the person it names. Widening what a trusted system may do as a person is the brain operator\'s decision.',
@@ -143,18 +160,22 @@ export async function linkedMember(engine: Pick<BrainEngine, 'executeRaw'>, syst
* live attest right for the system, and a live link from the id to an enabled member. Returns that member's identity;
* throws actor_not_attested (no_attest_right) or actor_unlinked.
*/
-export async function actorCoverage(engine: Pick<BrainEngine, 'executeRaw'>, caller: ActorCaller, actor: { system: string; external_id: string }, transport?: string):
+export async function actorCoverage(engine: Pick<BrainEngine, 'executeRaw'>, caller: ActorCaller, actor: { system: string; external_id: string }, transport?: string, op?: string):
Promise<{ member: string; groups: string[]; identity: string[] }> {
const right = await attestRightOf(engine, caller);
- if (!right || right.system !== actor.system) throw actorNotAttested('no_attest_right', caller, { op: 'stored', transport });
+ if (!right || right.system !== actor.system) throw actorNotAttested('no_attest_right', caller, { op: op ?? 'stored', transport });
+ if (op !== undefined && (!right.ops.includes(op) || ACTOR_DEFERRED_OPS.has(op))) throw actorNotAttested('op_not_attested', caller, { op, transport, right });
const linked = EXTERNAL_ID_RE.test(actor.external_id) ? await linkedMember(engine, actor.system, actor.external_id) : null;
if (!linked) throw actorUnlinked(actor.external_id, transport);
return linked;
}
-/** A stored attested authority (a queued write, an agent job) re-resolved through actorCoverage: the same member must still be covered. */
-export async function storedActorIdentity(engine: Pick<BrainEngine, 'executeRaw'>, principal: Principal, actor: AttestedActor): Promise<string[]> {
- const covered = await actorCoverage(engine, { principal }, actor);
+/**
+ * A stored attested authority (a queued write, an agent job) re-resolved through actorCoverage: the same member must
+ * still be covered and, when `op` is given (publication, a job tool call), the operation must still be attested.
+ */
+export async function storedActorIdentity(engine: Pick<BrainEngine, 'executeRaw'>, principal: Principal, actor: AttestedActor, op?: string): Promise<string[]> {
+ const covered = await actorCoverage(engine, { principal }, actor, undefined, op);
if (covered.member !== actor.member) throw actorUnlinked(actor.external_id);
return covered.identity;
}
@@ -206,7 +227,11 @@ export async function resolveAttestedActor(engine: Pick<BrainEngine, 'executeRaw
`Send one: ${ACTOR_HEADER} from an attest credential, or X-Gbrain-On-Behalf-Of / request-level _meta.on_behalf_of from a shared agent.`);
}
const right = input.transport === 'stdio' ? null : await attestRightOf(engine, caller);
- if (!right || right.system !== 'qm') throw actorNotAttested(hasArgument ? 'argument_without_attestation' : 'no_attest_right', caller, ctx);
+ if (!right || right.system !== 'qm') {
+ const principal = input.auth?.principal;
+ const reissue = !hasArgument && !right && principal?.kind === 'oauth_client' && !!await attestRightOf(engine, { principal });
+ throw actorNotAttested(hasArgument ? 'argument_without_attestation' : 'no_attest_right', caller, { ...ctx, reissue });
+ }
if (!right.ops.includes(input.op) || !attestableOp(input.op, input.opShape)) throw actorNotAttested('op_not_attested', caller, { ...ctx, right });
if (hasArgument && argument !== header) throw actorNotAttested('argument_mismatch', caller, ctx);
const covered = await actorCoverage(engine, caller, { system: right.system, external_id: header }, input.transport);
diff --git a/src/core/access/members.ts b/src/core/access/members.ts
index e8ff58a3a7..c9778bba91 100644
--- a/src/core/access/members.ts
+++ b/src/core/access/members.ts
@@ -16,6 +16,7 @@ import type { SqlQuery } from '../sql-query.ts';
import { opError, type OperationError } from '../ops/contract.ts';
import type { Action } from '../agent-output.ts';
import { ACCESS_ID_RE, identityFor, normalizePrincipal } from './principals.ts';
+import { ACTOR_DEFERRED_OPS } from './actor-model.ts';
export interface MemberRecord {
id: string;
@@ -316,6 +317,8 @@ export async function bindCredential(engine: BrainEngine, target: { kind: 'token
const attestOps = attestActor === null ? null : patch.attestOps === undefined ? before.attest_ops : patch.attestOps;
const what = target.kind === 'token' ? 'This token' : `OAuth client ${target.id}`;
if (patch.attestOps != null && attestActor === null) throw attestRefused('--attest-ops needs the attest right.', 'Pass --attest-actor qm with it.');
+ const deferred = (patch.attestOps ?? []).filter(op => ACTOR_DEFERRED_OPS.has(op));
+ if (deferred.length) throw attestRefused(`--attest-ops names ${deferred.join(', ')}, which an attested actor cannot run yet.`, `Leave them out. Not attestable yet: ${[...ACTOR_DEFERRED_OPS].join(', ')}.`);
if (attestActor !== null && (patch.attestActor !== undefined || patch.member !== undefined)) {
if (member !== null) throw attestRefused(`${what} is bound to member "${member}", so it cannot attest other people.`, 'Use a credential bound to no member (--member none), or a separate client for the trusted system.');
if (target.kind === 'client' && (!(before.grant_types ?? []).includes('client_credentials') || before.confidential !== true)) {
diff --git a/src/core/minions/tools/brain-allowlist.ts b/src/core/minions/tools/brain-allowlist.ts
index 2a0e19a123..8c5ce0aa0c 100644
--- a/src/core/minions/tools/brain-allowlist.ts
+++ b/src/core/minions/tools/brain-allowlist.ts
@@ -321,7 +321,7 @@ function brainTool(op: Operation, opts: BuildBrainToolsOpts): ToolDef {
const agent = submitted?.kind === 'remote_agent' ? submitted : undefined;
const actor = agent?.grant.actor;
const output = agent && actor
- ? await withCallerAccess(await attestedCallerAccess(ctx.engine, actor, await storedActorIdentity(ctx.engine, agent.principal, actor)), run)
+ ? await withCallerAccess(await attestedCallerAccess(ctx.engine, actor, await storedActorIdentity(ctx.engine, agent.principal, actor, op.name)), run)
: opCtx.auth
? await withCallerAccess(await remoteCallerAccess(ctx.engine, opCtx.auth, [], undefined, actingFor), run)
: await run();
diff --git a/src/core/persistence/authority.ts b/src/core/persistence/authority.ts
index d33c9e69c9..0af2db79cf 100644
--- a/src/core/persistence/authority.ts
+++ b/src/core/persistence/authority.ts
@@ -148,7 +148,7 @@ export async function authorizeWrite(engine: SqlEngine, a: WriteAuthority, opera
if (a.actingFor && !Array.isArray(a.actingFor)) {
const actor = parseStoredActor(a.actingFor);
if (!actor) deny('The accepted attested actor is malformed.');
- await storedActorIdentity(engine, a.principal, actor);
+ await storedActorIdentity(engine, a.principal, actor, operation);
}
const suffix = lock ? ' FOR SHARE' : '';
if (a.principal.kind === 'oauth_client') {
diff --git a/test/access-qm-actor.test.ts b/test/access-qm-actor.test.ts
index 6b6ebfc43b..20ab0ddca9 100644
--- a/test/access-qm-actor.test.ts
+++ b/test/access-qm-actor.test.ts
@@ -23,7 +23,7 @@ import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import { importFromContent } from '../src/core/import-file.ts';
import { configureGateway, resetGateway, __setEmbedTransportForTests } from '../src/core/ai/gateway.ts';
import { GBrainOAuthProvider } from '../src/core/oauth-provider.ts';
-import { sqlQueryForEngine } from '../src/core/sql-query.ts';
+import { executeRawJsonb, sqlQueryForEngine } from '../src/core/sql-query.ts';
import { mintLegacyToken } from '../src/core/token-mint.ts';
import { parseRescopeTokenArgs, rescopeLegacyToken } from '../src/core/grants/legacy-token.ts';
import { dispatchToolCall, type ToolResult } from '../src/mcp/dispatch.ts';
@@ -32,7 +32,7 @@ import { RateLimiter } from '../src/mcp/rate-limit.ts';
import { GBRAIN_MCP_INSTRUCTIONS, MCP_SERVER_DESCRIPTION } from '../src/mcp/instructions.ts';
import { __resetPrivateVisibilityCacheForTests, withCallerAccess } from '../src/core/search/private-visibility.ts';
import { addMember, bindCredential, disableMember, enableMember } from '../src/core/access/members.ts';
-import { attestedCallerAccess, linkMember, listMemberLinks, parseAttestOps, unlinkMember } from '../src/core/access/actor.ts';
+import { ACTOR_DEFERRED_OPS, attestedCallerAccess, linkMember, listMemberLinks, parseAttestOps, unlinkMember } from '../src/core/access/actor.ts';
import { readAudienceAssertions } from '../src/core/access/audience.ts';
import { operationsByName } from '../src/core/operations.ts';
import { submissionAuthority, authorizeStoredRequest } from '../src/core/persistence/authority.ts';
@@ -72,7 +72,7 @@ const ALICE_ID = 'U0ALICE';
const BOB_ID = '[email protected]';
const OIDC_ID = 'oidc:3f2a9c:alice-example';
const LONG_ID = 'L'.repeat(256);
-const ATTEST_OPS = ['add_tag', 'get_page', 'list_pages', 'search', 'submit_agent', 'whoami'];
+const ATTEST_OPS = ['add_tag', 'get_page', 'list_pages', 'search', 'whoami'];
for (const kind of testBackends()) {
describe('attested actor x-qm-actor (' + kind + ', repo-less)', () => {
@@ -227,6 +227,17 @@ for (const kind of testBackends()) {
} finally {
await engine.executeRaw("UPDATE oauth_tokens SET grant_type = 'client_credentials' WHERE token_hash = $1", [hash]);
}
+ await engine.executeRaw('UPDATE oauth_tokens SET grant_type = NULL WHERE token_hash = $1', [hash]);
+ try {
+ const old = await refused(getAs(ALICE_ID, 'alice'), 'actor_not_attested', 'no_attest_right');
+ expect(old.json.message).toContain('holds the attest right');
+ expect(String(old.json.suggestion ?? old.json.next ?? old.text)).toContain('grant_type=client_credentials');
+ expect(old.structured!.error!.fix).toBeUndefined();
+ } finally {
+ await engine.executeRaw("UPDATE oauth_tokens SET grant_type = 'client_credentials' WHERE token_hash = $1", [hash]);
+ }
+ const plain = await refused(getAs(ALICE_ID, 'alice', clients.plain!.token), 'actor_not_attested', 'no_attest_right');
+ expect(plain.json.message).not.toContain('holds the attest right');
expect((await getAs(ALICE_ID, 'alice')).text).toContain(PAGES.alice.canary);
}, 60_000);
@@ -329,6 +340,13 @@ for (const kind of testBackends()) {
} finally {
await bindCredential(engine, { kind: 'client', id: clients.qm!.id }, { attestActor: 'qm', attestOps: ATTEST_OPS });
}
+ await bindCredential(engine, { kind: 'client', id: clients.qm!.id }, { attestActor: 'qm', attestOps: ATTEST_OPS.filter(op => op !== 'add_tag') });
+ try {
+ await expect(authorizeStoredRequest(engine, row)).rejects.toMatchObject({ code: 'actor_not_attested', reason: 'op_not_attested' });
+ } finally {
+ await bindCredential(engine, { kind: 'client', id: clients.qm!.id }, { attestActor: 'qm', attestOps: ATTEST_OPS });
+ }
+ await authorizeStoredRequest(engine, row);
const live = await call(qm(), 'add_tag', { slug: PAGES.alice.slug, tag: 'qm-tag' }, { actor: ALICE_ID });
expect(live.isError).toBe(false);
const hidden = await call(qm(), 'add_tag', { slug: PAGES.bob.slug, tag: 'qm-tag' }, { actor: ALICE_ID });
@@ -337,7 +355,7 @@ for (const kind of testBackends()) {
test('an agent job submitted for an attested actor reads as the member until the link is gone', async () => {
const { clientId } = await provider().registerClientManual('qm-agent-' + randomUUID().slice(0, 8), ['client_credentials'], 'read', [], SRC);
- await bindCredential(engine, { kind: 'client', id: clientId }, { attestActor: 'qm', attestOps: ['submit_agent', 'get_page'] });
+ await bindCredential(engine, { kind: 'client', id: clientId }, { attestActor: 'qm', attestOps: ['get_page'] });
await engine.executeRaw("UPDATE oauth_clients SET scope = 'read agent', bound_tools = ARRAY['get_page'], bound_source_id = source_id, federated_read = ARRAY[source_id], delegated_namespace = 'job', delegated_slug_prefixes = NULL, bound_max_concurrent = 1 WHERE client_id = $1", [clientId]);
const actor = { system: 'qm', external_id: BOB_ID, member: 'bob-example' };
const agentAuth = { token: 'x', clientId, scopes: ['read', 'agent'], sourceId: SRC, principal: { kind: 'oauth_client', id: clientId } } as unknown as AuthInfo;
@@ -363,11 +381,51 @@ for (const kind of testBackends()) {
} finally {
await linkMember(engine, 'bob-example', 'qm', BOB_ID);
}
+ await bindCredential(engine, { kind: 'client', id: clientId }, { attestActor: 'qm', attestOps: ['search'] });
+ try {
+ const removed = await read(PAGES.bob.slug);
+ expect(removed).not.toContain(PAGES.bob.canary);
+ expect(removed).toContain('get_page is not in this connection');
+ } finally {
+ await bindCredential(engine, { kind: 'client', id: clientId }, { attestActor: 'qm', attestOps: ['get_page'] });
+ }
+ expect(await read(PAGES.bob.slug)).toContain(PAGES.bob.canary);
const bad = (grant: Record<string, unknown>) => parseSubmissionAuthority({ ...authority, grant: { ...authority.grant, ...grant } });
expect(bad({ actor: { ...actor, external_id: 'has space' } })).toBeNull();
expect(bad({ actingFor: ['member:bob-example'] })).toBeNull();
}, 120_000);
+ test('operations not keyed to the person yet are never attested: refused at rescope, at bind and at every call', async () => {
+ const lookup = (name: string) => operationsByName[name];
+ for (const op of ACTOR_DEFERRED_OPS) {
+ expect(() => parseAttestOps('get_page,' + op, lookup)).toThrow(/cannot run yet/);
+ await expect(bindCredential(engine, { kind: 'client', id: clients.qm!.id }, { attestActor: 'qm', attestOps: ['get_page', op] })).rejects.toMatchObject({ code: 'invalid_params' });
+ }
+ for (const op of ['get_agent_job', 'submit_agent', 'get_write_request', 'list_write_requests', 'cancel_write_request', 'delta', 'remember', 'capture', 'extract_facts']) {
+ expect(ACTOR_DEFERRED_OPS.has(op)).toBe(true);
+ }
+ const { clientId, clientSecret } = await provider().registerClientManual('qm-jobs-' + randomUUID().slice(0, 8), ['client_credentials'], 'read write', [], SRC);
+ await engine.executeRaw("UPDATE oauth_clients SET scope = 'read write agent', bound_tools = $2, bound_source_id = source_id, federated_read = ARRAY[source_id], delegated_namespace = 'job', delegated_slug_prefixes = NULL, bound_max_concurrent = 1 WHERE client_id = $1", [clientId, ['get_page', ...ACTOR_DEFERRED_OPS]]);
+ await bindCredential(engine, { kind: 'client', id: clientId }, { attestActor: 'qm', attestOps: ['get_page'] });
+ await engine.executeRaw('UPDATE oauth_clients SET attest_ops = $2 WHERE client_id = $1', [clientId, ['get_page', ...ACTOR_DEFERRED_OPS]]);
+ const bearer = (await provider().exchangeClientCredentials(clientId, clientSecret!)).access_token;
+ const canary = 'canaryqmjobresult';
+ const [job] = await executeRawJsonb<{ id: number }>(engine,
+ `INSERT INTO minion_jobs (submission_authority, name, queue, status, data, result, finished_at) VALUES ('{}'::jsonb, 'subagent', 'default', 'completed', $1::jsonb, $2::jsonb, now()) RETURNING id`,
+ [], [{ __owner_client_id: clientId, actor: { system: 'qm', external_id: ALICE_ID, member: 'alice-example' } }, { text: canary }]);
+ expect((await call(bearer, 'get_agent_job', { id: Number(job!.id) })).text).toContain(canary);
+ const asBob = await refused(call(bearer, 'get_agent_job', { id: Number(job!.id) }, { actor: BOB_ID }), 'actor_not_attested', 'op_not_attested');
+ expect(asBob.text).not.toContain(canary);
+ expect(asBob.structured!.error!.fix).toBeUndefined();
+ const deferredCalls: Array<[string, Record<string, unknown>]> = [
+ ['list_write_requests', {}], ['get_write_request', { id: randomUUID() }], ['cancel_write_request', { id: randomUUID() }],
+ ['delta', {}], ['remember', { content: 'alice-example prefers tea' }], ['capture', { content: 'note' }],
+ ['submit_agent', { prompt: 'x' }], ['extract_facts', { text: 'x' }],
+ ];
+ for (const [op, params] of deferredCalls) await refused(call(bearer, op, params, { actor: ALICE_ID }), 'actor_not_attested', 'op_not_attested');
+ expect((await call(bearer, 'get_page', { slug: PAGES.alice.slug }, { actor: ALICE_ID })).text).toContain(PAGES.alice.canary);
+ }, 120_000);
+
test('the legacy bearer transport reads x-qm-actor over a real socket and serves the description on initialize', async () => {
const server = await startHttpTransport({ port: 0, engine, surface: 'full', limiters: {
ip: new RateLimiter({ limit: 10_000, windowMs: 60_000, lruCap: 100 }),