@cairnkeep/cli 2.26.0 → 2.27.0

package/mcp-memory-server/dist/team-cli.js

@@ -1,13 +1,15 @@
-import { closeSync, existsSync, openSync, writeFileSync, fsyncSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { readStableJson } from './stable-file.js';
-import { hardenPrivatePath } from './platform-security.js';
-import { openTeamStore, restoreTeamSnapshot, verifyTeamSnapshot, prepareTeamPrivateDirectory, TEAM_SNAPSHOT_MAX_BYTES, TeamError } from './team-store.js';
+import { openTeamStore, restoreTeamSnapshot, verifyTeamSnapshot, TEAM_SNAPSHOT_MAX_BYTES, TeamError } from './team-store.js';
+import { writePrivateExclusive } from './team-files.js';
+export { writePrivateExclusive } from './team-files.js';
 import { createTeamHttpServer, teamRequest } from './team-http.js';
 import { createTeamMcpServer, teamClientToken } from './team-mcp.js';
 import { readTeamConnection, connectionToken } from './team-client.js';
+import { verifyTeamAuditArchive } from './team-audit.js';
 const HELP = `cairn team — experimental token-first team continuity (default off)
 
 CAIRN_TEAM=1 is required. Personal memory is never uploaded.
@@ -23,7 +25,7 @@ CAIRN_TEAM=1 is required. Personal memory is never uploaded.
   cairn team disconnect [--project-root PATH] [--apply --yes]
   cairn team doctor --client [--project-root PATH]
   cairn team mcp [--project-root PATH | --connection FILE] # local stdio MCP; no review/admin tools
-  cairn team list --project ID
+  cairn team list --project ID [--page-size N --cursor CURSOR]
   cairn team proposals --project ID
   cairn team audit --project ID             # scoped, value-free metadata
   cairn team read --project ID --key KEY [--revision DIGEST]
@@ -32,8 +34,11 @@ CAIRN_TEAM=1 is required. Personal memory is never uploaded.
   cairn team proposal-show --project ID --proposal ID
   cairn team propose --project ID --input FILE --confirm VALUE_DIGEST
   cairn team review --project ID --proposal ID --decision approve|reject --confirm PROPOSAL_DIGEST
-  cairn team doctor [--data DIR]
-  cairn team backup --output FILE [--data DIR]
+  cairn team doctor [--data DIR]             # capacity and audit checkpoint
+  cairn team backup --output FILE [--read-only] [--data DIR]
+  cairn team audit-export --backup FILE --output FILE [--data DIR]
+  cairn team audit-verify --input FILE [--previous FILE]
+  cairn team audit-archive --input FILE --backup FILE --confirm DIGEST [--apply] [--data DIR]
   cairn team restore --input FILE --confirm SNAPSHOT_DIGEST --data NEW_DIR
   cairn team memory-delete --project ID --key KEY --confirm REVISION_DIGEST [--data DIR]
 
@@ -41,15 +46,25 @@ Clients require CAIRN_TEAM_URL, CAIRN_TEAM_ORGANIZATION and CAIRN_TEAM_TOKEN_FIL
 Never put tokens in command arguments, source trees or harness config.
 Team API is not OAuth MCP HTTP. Independent production security review and a
 deployment-specific approved real-data pilot remain admission gates. See docs/team.md.
+Paging is optional for list/search/history/proposals/audit. Repeat filters and
+page size with the returned next_cursor. Search pages are at most ten items.
+Audit export is metadata-only and does not mutate the store. Archival defaults
+to a no-write plan, retains files, and explicitly upgrades the team store to v2.
 `;
 function parse(args) {
     const words = [];
     const flags = {};
-    const known = new Set(['data', 'organization', 'project', 'roles', 'class', 'expires-at', 'output', 'port', 'project-root', 'key', 'revision', 'query', 'proposal', 'input', 'confirm', 'decision', 'connection']);
+    const known = new Set(['data', 'organization', 'project', 'roles', 'class', 'expires-at', 'output', 'port', 'project-root', 'key', 'revision', 'query', 'proposal', 'input', 'confirm', 'decision', 'connection', 'backup', 'apply', 'read-only', 'page-size', 'cursor', 'previous']);
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg.startsWith('--')) {
             const name = arg.slice(2);
+            if (['apply', 'read-only'].includes(name)) {
+                if (flags[name] !== undefined)
+                    throw new TeamError('invalid');
+                flags[name] = 'true';
+                continue;
+            }
             if (!known.has(name) || flags[name] !== undefined || !args[i + 1] || args[i + 1].startsWith('--'))
                 throw new TeamError('invalid');
             flags[name] = args[++i];
@@ -59,20 +74,6 @@ function parse(args) {
     }
     return { words, flags };
 }
-export function writePrivateExclusive(path, bytes) {
-    path = resolve(path);
-    const directory = dirname(path);
-    prepareTeamPrivateDirectory(directory, true);
-    const fd = openSync(path, 'wx', 0o600);
-    try {
-        hardenPrivatePath(path);
-        writeFileSync(fd, bytes, 'utf8');
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
 async function main(args) {
     if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
         console.log(HELP);
@@ -85,10 +86,12 @@ async function main(args) {
     const allowed = {
         init: ['data', 'organization'], project: ['data'], member: subcommand === 'remove' ? ['data', 'project'] : ['data', 'project', 'roles'],
         credential: subcommand === 'issue' ? ['data', 'class', 'expires-at', 'output'] : ['data'],
-        serve: ['data', 'port'], mcp: ['project-root', 'connection'], doctor: ['data'], backup: ['data', 'output'],
+        serve: ['data', 'port'], mcp: ['project-root', 'connection'], doctor: ['data'], backup: ['data', 'output', 'read-only'],
+        'audit-export': ['data', 'backup', 'output'], 'audit-archive': ['data', 'backup', 'input', 'confirm', 'apply'],
+        'audit-verify': ['input', 'previous'],
         restore: ['data', 'input', 'confirm'], 'memory-delete': ['data', 'project', 'key', 'confirm'],
-        list: ['project'], proposals: ['project'], audit: ['project'], read: ['project', 'key', 'revision'],
-        history: ['project', 'key'], search: ['project', 'query'], 'proposal-show': ['project', 'proposal'],
+        list: ['project', 'page-size', 'cursor'], proposals: ['project', 'page-size', 'cursor'], audit: ['project', 'page-size', 'cursor'], read: ['project', 'key', 'revision'],
+        history: ['project', 'key', 'page-size', 'cursor'], search: ['project', 'query', 'page-size', 'cursor'], 'proposal-show': ['project', 'proposal'],
         propose: ['project', 'input', 'confirm'], review: ['project', 'proposal', 'decision', 'confirm'],
     };
     if (!allowed[command] || Object.keys(flags).some(flag => !allowed[command].includes(flag)))
@@ -100,6 +103,19 @@ async function main(args) {
     const print = (result) => console.log(JSON.stringify(result, null, 2));
     let store;
     try {
+        if (command === 'audit-verify') {
+            if (words.length !== 1 || !flags.input)
+                throw new TeamError('invalid');
+            const load = (path) => verifyTeamAuditArchive(readStableJson(resolve(path), { label: 'Team audit archive', maxBytes: TEAM_SNAPSHOT_MAX_BYTES, private: true }));
+            const archive = load(flags.input);
+            if (flags.previous) {
+                const previous = load(flags.previous), last = previous.entries[previous.entries.length - 1], checkpoint = archive.previous_checkpoint;
+                if (previous.organization !== archive.organization || !checkpoint || checkpoint.archive_digest !== previous.digest || checkpoint.backup_digest !== previous.backup_digest || checkpoint.sequence !== last.sequence || checkpoint.digest !== last.digest || checkpoint.previous_archive_digest !== (previous.previous_checkpoint?.archive_digest ?? null))
+                    throw new TeamError('integrity');
+            }
+            print({ verified: true, archive_digest: archive.digest, events: archive.entries.length, first_sequence: archive.entries[0].sequence, last_sequence: archive.entries[archive.entries.length - 1].sequence, previous_archive_digest: archive.previous_checkpoint?.archive_digest ?? null, previous_link_verified: !!flags.previous, history_scope: 'single-segment-and-optional-previous-link' });
+            return;
+        }
         if (command === 'mcp') {
             if (words.length !== 1)
                 throw new TeamError('invalid');
@@ -122,7 +138,7 @@ async function main(args) {
             print({ restored: true, organization: store.organization, credentials_revoked: true });
             return;
         }
-        if (['init', 'project', 'member', 'credential', 'serve', 'doctor', 'backup', 'memory-delete'].includes(command)) {
+        if (['init', 'project', 'member', 'credential', 'serve', 'doctor', 'backup', 'memory-delete', 'audit-export', 'audit-archive'].includes(command)) {
             if (command === 'init' && (words.length !== 1 || !flags.organization))
                 throw new TeamError('invalid');
             store = await openTeamStore(root, command === 'init' ? { create: true, organization: flags.organization } : {});
@@ -133,11 +149,30 @@ async function main(args) {
             if (command === 'backup' && words.length === 1) {
                 if (!flags.output)
                     throw new TeamError('invalid');
-                const snapshot = await store.snapshot();
+                const snapshot = await store.snapshot({ audit: flags['read-only'] !== 'true' });
                 writePrivateExclusive(flags.output, `${JSON.stringify(snapshot)}\n`);
                 print({ snapshot_digest: snapshot.digest, written: true });
                 return;
             }
+            if (['audit-export', 'audit-archive'].includes(command) && words.length === 1) {
+                if (!flags.backup)
+                    throw new TeamError('invalid');
+                const backup = verifyTeamSnapshot(readStableJson(resolve(flags.backup), { label: 'Team archival backup', maxBytes: TEAM_SNAPSHOT_MAX_BYTES, private: true }));
+                if (command === 'audit-export') {
+                    if (!flags.output)
+                        throw new TeamError('invalid');
+                    const archive = await store.exportAudit(backup);
+                    writePrivateExclusive(flags.output, `${JSON.stringify(archive)}\n`);
+                    print({ written: true, archive_digest: archive.digest, backup_digest: archive.backup_digest, events: archive.entries.length });
+                }
+                else {
+                    if (!flags.input || !flags.confirm)
+                        throw new TeamError('invalid');
+                    const archive = verifyTeamAuditArchive(readStableJson(resolve(flags.input), { label: 'Team audit archive', maxBytes: TEAM_SNAPSHOT_MAX_BYTES, private: true }));
+                    print(await store.archiveAudit(archive, backup, flags.confirm, flags.apply === 'true'));
+                }
+                return;
+            }
             if (command === 'memory-delete' && words.length === 1) {
                 await store.admin({ operation: 'memory-delete', project: flags.project, key: flags.key, confirm: flags.confirm });
                 print({ deleted: true, backup_copies_retained: true });
@@ -216,6 +251,12 @@ async function main(args) {
         }
         else
             throw new TeamError('invalid');
+        if (flags['page-size'] || flags.cursor) {
+            const raw = flags['page-size'] ?? '100';
+            if (!/^[1-9][0-9]{0,2}$/.test(raw) || Number(raw) > 100 || (command === 'search' && Number(raw) > 10))
+                throw new TeamError('invalid');
+            input.page = { size: Number(raw), ...(flags.cursor ? { cursor: flags.cursor } : {}) };
+        }
         print(await teamRequest(process.env.CAIRN_TEAM_URL ?? '', teamClientToken(), input));
     }
     finally {

package/mcp-memory-server/dist/team-errors.js

@@ -0,0 +1,7 @@
+export class TeamError extends Error {
+    code;
+    constructor(code) {
+        super(`Team ${code}.`);
+        this.code = code;
+    }
+}

package/mcp-memory-server/dist/team-files.js

@@ -0,0 +1,28 @@
+import { closeSync, openSync, writeFileSync, fsyncSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { hardenPrivatePath } from './platform-security.js';
+import { prepareTeamPrivateDirectory } from './team-store.js';
+export function writePrivateExclusive(path, bytes) {
+    path = resolve(path);
+    prepareTeamPrivateDirectory(dirname(path), true);
+    const fd = openSync(path, 'wx', 0o600);
+    try {
+        hardenPrivatePath(path);
+        writeFileSync(fd, bytes, 'utf8');
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    // Persist the new directory entry as well as its contents on POSIX.
+    // Node cannot open/fsync a directory handle on Windows.
+    if (process.platform !== 'win32') {
+        const parent = openSync(dirname(path), 'r');
+        try {
+            fsyncSync(parent);
+        }
+        finally {
+            closeSync(parent);
+        }
+    }
+}

package/mcp-memory-server/dist/team-mcp.js

@@ -5,6 +5,7 @@ import { isCapabilityContractEnabled, resolveCapabilityStatus } from './capabili
 import { teamRequest, validateTeamUrl } from './team-http.js';
 import { TeamError, teamDigest } from './team-store.js';
 import { resolveHttpToken } from './http-security.js';
+import { teamPageSchema } from './team-pages.js';
 const observation = (title) => ({ title, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true } });
 // The bridge crosses the local process boundary into a remote team service;
 // openWorldHint is true even though team retrieval is deterministic and closed
@@ -49,10 +50,10 @@ export async function createTeamMcpServer(options) {
     const key = z.string().regex(/^(decisions|patterns|constraints|pitfalls|conventions|bugs)\/[a-z0-9][a-z0-9-]{0,95}$/);
     const hash = z.string().regex(/^[a-f0-9]{64}$/);
     const schemas = {
-        team_memory_list: { project },
+        team_memory_list: { project, page: teamPageSchema.optional() },
         team_memory_read: { project, key, revision: hash.optional() },
-        team_memory_search: { project, query: z.string().min(1).max(256) },
-        team_memory_history: { project, key },
+        team_memory_search: { project, query: z.string().min(1).max(256), page: teamPageSchema.extend({ size: z.number().int().min(1).max(10) }).optional() },
+        team_memory_history: { project, key, page: teamPageSchema.optional() },
         team_memory_propose: { project, request_id: z.string().uuid(), key, value: z.string().min(1).max(65536), source_scope: z.enum(['selected-local', 'selected-project']), source_digest: hash, base_revision: hash.nullable(), expires_at: z.iso.datetime(), confirm: hash },
     };
     const operations = { team_memory_list: 'list', team_memory_read: 'read', team_memory_search: 'search', team_memory_history: 'history', team_memory_propose: 'propose' };

package/mcp-memory-server/dist/team-pages.js

@@ -0,0 +1,40 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+import { z } from 'zod';
+import { TeamError } from './team-errors.js';
+export const teamPageSchema = z.object({ size: z.number().int().min(1).max(100), cursor: z.string().min(1).max(2048).optional() }).strict();
+const cursorSchema = z.object({ v: z.literal(1), scope: z.string().regex(/^[a-f0-9]{64}$/), view: z.string().regex(/^[a-f0-9]{64}$/), offset: z.number().int().positive().max(100000), upper: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER) }).strict();
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const mac = (key, value) => createHmac('sha256', Buffer.from(key, 'hex')).update(value).digest();
+export function pageTeamItems(items, secret, scope, page, audit = false) {
+    let offset = 0, upper = audit ? Number(items[0]?.sequence ?? 0) : 0;
+    let decoded;
+    if (page.cursor) {
+        try {
+            const match = /^([A-Za-z0-9_-]+)\.([a-f0-9]{64})$/.exec(page.cursor);
+            if (!match || !timingSafeEqual(mac(secret, match[1]), Buffer.from(match[2], 'hex')))
+                throw new Error();
+            decoded = cursorSchema.parse(JSON.parse(Buffer.from(match[1], 'base64url').toString('utf8')));
+            if (decoded.scope !== hash(scope))
+                throw new Error();
+            offset = decoded.offset;
+            upper = decoded.upper;
+        }
+        catch {
+            throw new TeamError('invalid');
+        }
+    }
+    if (audit)
+        items = items.filter(row => Number(row.sequence) <= upper);
+    const view = hash(JSON.stringify(items));
+    if (decoded && decoded.view !== view)
+        throw new TeamError('conflict');
+    if (offset > items.length)
+        throw new TeamError('invalid');
+    const selected = items.slice(offset, offset + page.size), next = offset + selected.length;
+    let cursor = null;
+    if (next < items.length) {
+        const bytes = Buffer.from(JSON.stringify({ v: 1, scope: hash(scope), view, offset: next, upper })).toString('base64url');
+        cursor = bytes + '.' + mac(secret, bytes).toString('hex');
+    }
+    return { items: selected, next_cursor: cursor };
+}

package/mcp-memory-server/dist/team-store.js

@@ -3,6 +3,10 @@ import { closeSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, op
 import { basename, dirname, isAbsolute, join, parse, resolve } from 'node:path';
 import { z } from 'zod';
 import { hardenPrivatePath, privatePathIsSafe } from './platform-security.js';
+import { TeamError } from './team-errors.js';
+export { TeamError } from './team-errors.js';
+import { teamAuditCheckpointSchema, verifyTeamAuditRows, verifyTeamAuditArchive } from './team-audit.js';
+import { teamPageSchema, pageTeamItems } from './team-pages.js';
 const id = z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
 const roles = z.array(z.enum(['reader', 'contributor', 'reviewer', 'maintainer', 'auditor'])).max(5);
 const digest = z.string().regex(/^[a-f0-9]{64}$/);
@@ -22,21 +26,21 @@ const adminSchema = z.discriminatedUnion('operation', [
     z.object({ operation: z.literal('credential-revoke'), credential: z.string().uuid() }).strict(),
     z.object({ operation: z.literal('memory-delete'), project: id, key: memoryKey, confirm: digest }).strict(),
 ]);
-const auditEntrySchema = z.object({ schema_version: z.literal(1), sequence: z.number().int().positive(), organization: id, project: id.or(z.literal('')), subject: id, credential_class: z.enum(['human', 'workload', 'local-os']), operation: z.enum(['project-create', 'member-set', 'credential-revoke', 'credential-issue', 'memory-delete', 'list', 'audit', 'read', 'history', 'search', 'propose', 'proposals', 'proposal-show', 'review', 'snapshot', 'restore', 'connection-check']), result: z.enum(['accepted', 'denied', 'conflict', 'invalid']), object_digest: digest.nullable(), previous_digest: digest.nullable(), request_id: z.string().uuid(), at: date }).strict();
-const snapshotSchema = z.object({ schema_version: z.literal(1), organization: id, records: z.array(z.object({ organization: id, project: id.or(z.literal('')), kind: z.enum(['project', 'member', 'credential', 'proposal', 'review', 'revision', 'head']), id: z.string().min(1).max(128), value: z.unknown() }).strict()).max(32768), audit: z.array(z.object({ sequence: z.number().int().positive(), organization: id, project: id.or(z.literal('')), value: z.string().max(4096), digest }).strict()).max(100000), digest }).strict();
+const legacySnapshotSchema = z.object({ schema_version: z.literal(1), organization: id, records: z.array(z.object({ organization: id, project: id.or(z.literal('')), kind: z.enum(['project', 'member', 'credential', 'proposal', 'review', 'revision', 'head']), id: z.string().min(1).max(128), value: z.unknown() }).strict()).max(32768), audit: z.array(z.object({ sequence: z.number().int().positive(), organization: id, project: id.or(z.literal('')), value: z.string().max(4096), digest }).strict()).max(100000), digest }).strict();
+const snapshotSchema = z.discriminatedUnion('schema_version', [legacySnapshotSchema, legacySnapshotSchema.extend({ schema_version: z.literal(2), audit_checkpoint: teamAuditCheckpointSchema })]);
 const MAX_RECORD_BYTES = 16 * 1024 * 1024;
 const MAX_AUDIT_BYTES = 16 * 1024 * 1024;
 export const TEAM_SNAPSHOT_MAX_BYTES = 64 * 1024 * 1024;
 const requestBase = { organization: id, project: id };
 const requestSchema = z.discriminatedUnion('operation', [
     z.object({ ...requestBase, operation: z.literal('connection-check') }).strict(),
-    z.object({ ...requestBase, operation: z.literal('list') }).strict(),
-    z.object({ ...requestBase, operation: z.literal('audit') }).strict(),
-    z.object({ ...requestBase, operation: z.literal('search'), query: z.string().min(1).max(256) }).strict(),
+    z.object({ ...requestBase, operation: z.literal('list'), page: teamPageSchema.optional() }).strict(),
+    z.object({ ...requestBase, operation: z.literal('audit'), page: teamPageSchema.optional() }).strict(),
+    z.object({ ...requestBase, operation: z.literal('search'), page: teamPageSchema.optional(), query: z.string().min(1).max(256) }).strict(),
     z.object({ ...requestBase, operation: z.literal('read'), key: memoryKey, revision: digest.optional() }).strict(),
-    z.object({ ...requestBase, operation: z.literal('history'), key: memoryKey }).strict(),
+    z.object({ ...requestBase, operation: z.literal('history'), page: teamPageSchema.optional(), key: memoryKey }).strict(),
     z.object({ ...requestBase, operation: z.literal('propose'), ...proposalInput.shape }).strict(),
-    z.object({ ...requestBase, operation: z.literal('proposals') }).strict(),
+    z.object({ ...requestBase, operation: z.literal('proposals'), page: teamPageSchema.optional() }).strict(),
     z.object({ ...requestBase, operation: z.literal('proposal-show'), proposal_id: z.string().uuid() }).strict(),
     z.object({ ...requestBase, operation: z.literal('review'), proposal_id: z.string().uuid(), confirm: digest, decision: z.enum(['approve', 'reject']) }).strict(),
 ]);
@@ -55,13 +59,6 @@ async function immediate(db, operation) {
         throw error;
     }
 }
-export class TeamError extends Error {
-    code;
-    constructor(code) {
-        super(`Team ${code}.`);
-        this.code = code;
-    }
-}
 export function teamDigest(text) { return createHash('sha256').update(text).digest('hex'); }
 function checkedProposal(input) {
     const value = valid(proposalSchema, input);
@@ -172,18 +169,7 @@ export function verifyTeamSnapshot(input) {
                 }
             }
         }
-        let previous = null;
-        let sequence = 0;
-        let auditBytes = 0;
-        for (const row of snapshot.audit) {
-            const entry = valid(auditEntrySchema, JSON.parse(row.value));
-            auditBytes += Buffer.byteLength(row.value);
-            if (row.organization !== snapshot.organization || row.sequence !== ++sequence || entry.sequence !== sequence || entry.previous_digest !== previous || entry.organization !== row.organization || entry.project !== row.project || row.digest !== teamDigest(row.value))
-                throw new Error();
-            previous = row.digest;
-        }
-        if (auditBytes > MAX_AUDIT_BYTES + 256 * 1024)
-            throw new Error();
+        verifyTeamAuditRows(snapshot.organization, snapshot.audit, snapshot.schema_version === 2 ? snapshot.audit_checkpoint : null);
         return snapshot;
     }
     catch {
@@ -301,7 +287,7 @@ export class TeamStore {
                     return options.organization;
                 });
                 const version = await db.prepare('SELECT value FROM team_meta WHERE id = ?').get('schema_version');
-                if (version?.value !== '1')
+                if (!['1', '2'].includes(String(version?.value)))
                     throw new TeamError('integrity');
                 const store = new TeamStore(agent, org, root);
                 store.harden();
@@ -368,8 +354,9 @@ export class TeamStore {
     async appendAudit(project, subject, credentialClass, operation, result, objectDigest = null) {
         const db = this.agent.getDatabase();
         const last = await db.prepare('SELECT sequence,digest FROM team_audit ORDER BY sequence DESC LIMIT 1').get();
-        const sequence = valid(z.number().int().nonnegative(), last?.sequence ?? 0) + 1;
-        const entry = { schema_version: 1, sequence, organization: this.organization, project, subject, credential_class: credentialClass, operation, result, object_digest: objectDigest, previous_digest: last?.digest ?? null, request_id: randomUUID(), at: new Date().toISOString() };
+        const checkpoint = this.auditCheckpoint();
+        const sequence = valid(z.number().int().nonnegative(), last?.sequence ?? checkpoint?.sequence ?? 0) + 1;
+        const entry = { schema_version: 1, sequence, organization: this.organization, project, subject, credential_class: credentialClass, operation, result, object_digest: objectDigest, previous_digest: last?.digest ?? checkpoint?.digest ?? null, request_id: randomUUID(), at: new Date().toISOString() };
         const value = JSON.stringify(entry);
         const size = db.prepare('SELECT count(*) AS entries,coalesce(sum(length(CAST(value AS BLOB))),0) AS bytes FROM team_audit').get();
         // Reserve bounded space for local revocation/recovery after a client's
@@ -466,8 +453,8 @@ export class TeamStore {
                         expires_at: credential.expires_at, roles: member.roles };
                 }
                 else if (request.operation === 'audit') {
-                    const rows = await this.agent.getDatabase().prepare('SELECT value,digest FROM team_audit WHERE organization=? AND project=? ORDER BY sequence DESC LIMIT 100').all(this.organization, request.project);
-                    result = rows.map(row => ({ ...JSON.parse(sqlText(row.value)), digest: row.digest }));
+                    const rows = await this.agent.getDatabase().prepare('SELECT value,digest FROM team_audit WHERE organization=? AND project=? ORDER BY sequence DESC' + (request.page ? '' : ' LIMIT 100')).all(this.organization, request.project);
+                    result = (request.page ? rows : rows.slice(0, 100)).map(row => ({ ...JSON.parse(sqlText(row.value)), digest: row.digest }));
                 }
                 else if (request.operation === 'propose') {
                     const { organization: _org, project: _project, operation: _op, ...rawInput } = request;
@@ -531,7 +518,7 @@ export class TeamStore {
                         result = proposal;
                     }
                     else {
-                        result = await Promise.all(visible.slice(0, 100).map(async (proposal) => ({ id: proposal.id, digest: proposal.digest, key: proposal.input.key, subject: proposal.subject, expires_at: proposal.input.expires_at, status: (await this.get('review', request.project, proposal.id)) ? 'reviewed' : 'pending' })));
+                        result = await Promise.all(visible.slice(0, request.page ? undefined : 100).map(async (proposal) => ({ id: proposal.id, digest: proposal.digest, key: proposal.input.key, subject: proposal.subject, expires_at: proposal.input.expires_at, status: (await this.get('review', request.project, proposal.id)) ? 'reviewed' : 'pending' })));
                     }
                 }
                 else if (request.operation === 'read') {
@@ -547,17 +534,29 @@ export class TeamStore {
                     }
                 }
                 else if (request.operation === 'history') {
-                    result = (await this.rows('revision', request.project)).map(row => checkedRevision(row.value)).filter(revision => revision.key === request.key).sort((a, b) => b.created_at.localeCompare(a.created_at) || a.revision_digest.localeCompare(b.revision_digest)).slice(0, 100).map(({ value: _value, ...metadata }) => metadata);
+                    result = (await this.rows('revision', request.project)).map(row => checkedRevision(row.value)).filter(revision => revision.key === request.key).sort((a, b) => b.created_at.localeCompare(a.created_at) || a.revision_digest.localeCompare(b.revision_digest)).slice(0, request.page ? undefined : 100).map(({ value: _value, ...metadata }) => metadata);
                 }
                 else {
                     const heads = await this.rows('head', request.project);
                     const revisions = await Promise.all(heads.map(async (head) => checkedRevision(await this.get('revision', request.project, valid(digest, head.value)))));
                     if (request.operation === 'search') {
                         const needle = request.query.toLowerCase();
-                        result = revisions.filter(revision => `${revision.key}\n${revision.value}`.toLowerCase().includes(needle)).slice(0, 10).map(revision => this.presentRevision(revision));
+                        result = revisions.filter(revision => `${revision.key}\n${revision.value}`.toLowerCase().includes(needle)).slice(0, request.page ? undefined : 10).map(revision => this.presentRevision(revision));
                     }
                     else
-                        result = revisions.slice(0, 100).map(({ value: _value, ...metadata }) => metadata);
+                        result = revisions.slice(0, request.page ? undefined : 100).map(({ value: _value, ...metadata }) => metadata);
+                }
+                if ('page' in request && request.page) {
+                    if (!Array.isArray(result) || (request.operation === 'search' && request.page.size > 10))
+                        throw new TeamError('invalid');
+                    const db = this.agent.getDatabase();
+                    let secret = db.prepare('SELECT value FROM team_meta WHERE id=?').get('pagination-secret')?.value;
+                    if (!secret) {
+                        secret = randomBytes(32).toString('hex');
+                        db.prepare('INSERT INTO team_meta(id,value) VALUES(?,?)').run('pagination-secret', secret);
+                    }
+                    const scope = JSON.stringify([this.organization, request.project, credential.id, credential.subject, credential.credential_class, member.roles, project.policy_revision, request.operation, 'key' in request ? request.key : null, 'query' in request ? request.query : null, request.page.size, this.auditCheckpoint()?.archive_digest ?? null]);
+                    result = pageTeamItems(result, valid(digest, secret), scope, request.page, request.operation === 'audit');
                 }
                 await this.appendAudit(request.project, credential.subject, credential.credential_class, request.operation, 'accepted', objectDigest);
                 return result;
@@ -583,12 +582,68 @@ export class TeamStore {
         const db = this.agent.getDatabase();
         const records = db.prepare('SELECT organization,project,kind,id,value FROM team_records ORDER BY organization,project,kind,id').all().map(row => ({ organization: sqlText(row.organization), project: sqlText(row.project), kind: sqlText(row.kind), id: sqlText(row.id), value: JSON.parse(sqlText(row.value)) }));
         const audit = db.prepare('SELECT sequence,organization,project,value,digest FROM team_audit ORDER BY sequence').all();
-        const body = { schema_version: 1, organization: this.organization, records, audit };
+        const checkpoint = this.auditCheckpoint();
+        const body = checkpoint ? { schema_version: 2, organization: this.organization, records, audit, audit_checkpoint: checkpoint } : { schema_version: 1, organization: this.organization, records, audit };
         return verifyTeamSnapshot({ ...body, digest: teamDigest(JSON.stringify(body)) });
     }
-    async snapshot() {
+    auditCheckpoint() {
+        const db = this.agent.getDatabase();
+        const version = db.prepare('SELECT value FROM team_meta WHERE id=?').get('schema_version')?.value;
+        const row = db.prepare('SELECT value FROM team_meta WHERE id=?').get('audit-checkpoint');
+        if (version === '1' && !row)
+            return null;
+        if (version !== '2' || !row)
+            throw new TeamError('integrity');
+        try {
+            return teamAuditCheckpointSchema.parse(JSON.parse(sqlText(row.value)));
+        }
+        catch {
+            throw new TeamError('integrity');
+        }
+    }
+    capacity() {
+        const db = this.agent.getDatabase();
+        const usage = (table, limit, bytesLimit) => {
+            const row = db.prepare(`SELECT count(*) AS entries,coalesce(sum(length(CAST(value AS BLOB))),0) AS bytes FROM ${table}`).get();
+            const entries = Number(row?.entries), bytes = Number(row?.bytes);
+            return { entries, bytes, limit, bytes_limit: bytesLimit, remaining_entries: Math.max(0, limit - entries), remaining_bytes: Math.max(0, bytesLimit - bytes), status: entries >= limit || bytes >= bytesLimit ? 'exhausted' : entries >= limit * 0.8 || bytes >= bytesLimit * 0.8 ? 'near-limit' : 'available' };
+        };
+        return { records: usage('team_records', 32768, MAX_RECORD_BYTES), audit: usage('team_audit', 99000, MAX_AUDIT_BYTES), local_audit_reserve: { entries: 1000, bytes: 256 * 1024 }, checkpoint: this.auditCheckpoint() };
+    }
+    async exportAudit(input) {
+        const backup = verifyTeamSnapshot(input);
+        return this.transaction(async () => {
+            const current = this.collectSnapshot();
+            if (current.digest !== backup.digest)
+                throw new TeamError('conflict');
+            const body = { schema_version: 1, organization: this.organization, backup_digest: backup.digest, previous_checkpoint: this.auditCheckpoint(), entries: current.audit };
+            return verifyTeamAuditArchive({ ...body, digest: teamDigest(JSON.stringify(body)) });
+        });
+    }
+    async archiveAudit(input, backupInput, confirm, apply = false) {
+        const archive = verifyTeamAuditArchive(input), backup = verifyTeamSnapshot(backupInput);
+        if (archive.digest !== confirm || archive.organization !== this.organization || archive.backup_digest !== backup.digest)
+            throw new TeamError('conflict');
         return this.transaction(async () => {
-            await this.appendAudit('', 'local-operator', 'local-os', 'snapshot', 'accepted');
+            const current = this.collectSnapshot();
+            if (current.digest !== backup.digest || JSON.stringify(current.audit) !== JSON.stringify(archive.entries) || JSON.stringify(this.auditCheckpoint()) !== JSON.stringify(archive.previous_checkpoint))
+                throw new TeamError('conflict');
+            const last = archive.entries[archive.entries.length - 1];
+            if (apply) {
+                const db = this.agent.getDatabase();
+                const checkpoint = { sequence: last.sequence, digest: last.digest, archive_digest: archive.digest, backup_digest: backup.digest, previous_archive_digest: archive.previous_checkpoint?.archive_digest ?? null };
+                db.prepare('INSERT INTO team_meta(id,value) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET value=excluded.value').run('audit-checkpoint', JSON.stringify(checkpoint));
+                db.prepare('UPDATE team_meta SET value=? WHERE id=?').run('2', 'schema_version');
+                db.exec('DELETE FROM team_audit');
+                await this.appendAudit('', 'local-operator', 'local-os', 'audit-archive', 'accepted', archive.digest);
+            }
+            return { applied: apply, events: archive.entries.length, archive_digest: archive.digest, backup_digest: backup.digest, last_sequence: last.sequence };
+        });
+    }
+    async snapshot(options = {}) {
+        return this.transaction(async () => {
+            if (options.audit !== false)
+                await this.appendAudit('', 'local-operator', 'local-os', 'snapshot', 'accepted');
             return this.collectSnapshot();
         });
     }
@@ -599,7 +654,7 @@ export class TeamStore {
             const snapshot = this.collectSnapshot();
             // Report only a count. Never select a restore, expose paths or delete remnants.
             const remnants = readdirSync(dirname(this.root)).filter(name => name.startsWith('.team-restore-') || name === `.${basename(this.root)}.restore.lock`).length;
-            return { ok: true, records: snapshot.records.length, audit_events: snapshot.audit.length, digest: snapshot.digest, temporary_remnants: remnants };
+            return { ok: true, records: snapshot.records.length, audit_events: snapshot.audit.length, digest: snapshot.digest, temporary_remnants: remnants, capacity: this.capacity() };
         });
     }
     static async restore(root, input, confirm) {
@@ -635,6 +690,10 @@ export class TeamStore {
                     const value = row.kind === 'credential' ? { ...valid(credentialSchema, row.value), revoked: true } : row.value;
                     db.prepare('INSERT INTO team_records(organization,project,kind,id,value) VALUES(?,?,?,?,?)').run(row.organization, row.project, row.kind, row.id, JSON.stringify(value));
                 }
+                if (snapshot.schema_version === 2) {
+                    db.prepare('UPDATE team_meta SET value=? WHERE id=?').run('2', 'schema_version');
+                    db.prepare('INSERT INTO team_meta(id,value) VALUES(?,?)').run('audit-checkpoint', JSON.stringify(snapshot.audit_checkpoint));
+                }
                 for (const row of snapshot.audit)
                     db.prepare('INSERT INTO team_audit(sequence,organization,project,value,digest) VALUES(?,?,?,?,?)').run(row.sequence, row.organization, row.project, row.value, row.digest);
                 await store.appendAudit('', 'local-operator', 'local-os', 'restore', 'accepted', snapshot.digest);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cairnkeep/cli",
-    "version": "2.26.0",
+    "version": "2.27.0",
     "description": "A durable, harness-agnostic memory + context layer for coding agents and MCP clients.",
     "license": "Apache-2.0",
     "type": "module",

package/scripts/cairn-cli.mjs

@@ -62,7 +62,7 @@ Usage:
   cairn evidence <list|show|delete|prune|doctor>
   cairn playbook <list|status|init|set|enable|disable|reset|check|record|receipts|instructions|doctor>
   cairn security doctor [--project PATH] [--json]
-  cairn team <connect|disconnect|init|project|member|credential|serve|mcp|list|read|search|history|propose|proposals|proposal-show|review|audit|doctor|backup|restore|memory-delete>
+  cairn team <connect|disconnect|init|project|member|credential|serve|mcp|list|read|search|history|propose|proposals|proposal-show|review|audit|audit-export|audit-verify|audit-archive|doctor|backup|restore|memory-delete>
   cairn memory <path|export|import>
   cairn audit-timer [--on-calendar SPEC] [--para-root PATH] [--render-only DIR]
   cairn uninstall [--dry-run] [--yes] [--purge-memory] [--purge-packs] [PROJECT ...]

package/scripts/completion.sh

@@ -27,7 +27,7 @@ _cairn_complete() {
     sync-omp) COMPREPLY=( $(compgen -W "--apply --live-root" -- "$current") ) ;;
     doctor) COMPREPLY=( $(compgen -W "--repair" -- "$current") ) ;;
     security) COMPREPLY=( $(compgen -W "doctor --project --json" -- "$current") ) ;;
-    team) COMPREPLY=( $(compgen -W "connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit doctor backup restore memory-delete --organization --data --project --roles --class --expires-at --output --input --confirm --port --key --query --proposal --decision --revision --project-root --connection --client --url --token-file --harness --access --apply --yes" -- "$current") ) ;;
+    team) COMPREPLY=( $(compgen -W "connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit audit-export audit-verify audit-archive doctor backup restore memory-delete --backup --previous --page-size --cursor --read-only --organization --data --project --roles --class --expires-at --output --input --confirm --port --key --query --proposal --decision --revision --project-root --connection --client --url --token-file --harness --access --apply --yes" -- "$current") ) ;;
     trajectory) COMPREPLY=( $(compgen -W "list show prune --json --dry-run" -- "$current") ) ;;
     artifact) COMPREPLY=( $(compgen -W "list show delete prune --kind --session --json --dry-run --include-protected" -- "$current") ) ;;
     evidence) COMPREPLY=( $(compgen -W "list show delete prune doctor --status --json --dry-run --repair" -- "$current") ) ;;
@@ -134,7 +134,7 @@ _cairn() {
     sync-omp) _arguments '--apply[apply changes]' '--live-root[omp agent root]:directory:_files -/' ;;
     doctor) _arguments '--repair[repair trajectory metadata and indexes]' ;;
     security) _values 'security command' doctor '--project[project root]:directory:_files -/' '--json[emit JSON]' ;;
-    team) _values 'team command' connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit doctor backup restore memory-delete '--organization[team option]:value:' '--data[team option]:value:' '--project[team option]:value:' '--roles[team option]:value:' '--class[team option]:value:' '--expires-at[team option]:value:' '--output[team option]:value:' '--input[team option]:value:' '--confirm[team option]:value:' '--port[team option]:value:' '--key[team option]:value:' '--query[team option]:value:' '--proposal[team option]:value:' '--decision[team option]:value:' '--revision[team option]:value:' '--apply[apply plan]' '--yes[confirm plan]' '--client[client diagnostics]' '--url[team URL]:value:' '--token-file[private credential file]:file:_files' '--harness[team adapters]:value:' '--access[tool profile]:value:(read-only full)' '--connection[private connection file]:file:_files' '--project-root[team option]:value:' ;;
+    team) _values 'team command' connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit audit-export audit-verify audit-archive doctor backup restore memory-delete '--previous[previous archive segment]:file:_files' '--backup[verified backup file]:file:_files' '--page-size[page bound]:value:' '--cursor[continuation]:value:' '--read-only[observe-only backup]' '--organization[team option]:value:' '--data[team option]:value:' '--project[team option]:value:' '--roles[team option]:value:' '--class[team option]:value:' '--expires-at[team option]:value:' '--output[team option]:value:' '--input[team option]:value:' '--confirm[team option]:value:' '--port[team option]:value:' '--key[team option]:value:' '--query[team option]:value:' '--proposal[team option]:value:' '--decision[team option]:value:' '--revision[team option]:value:' '--apply[apply plan]' '--yes[confirm plan]' '--client[client diagnostics]' '--url[team URL]:value:' '--token-file[private credential file]:file:_files' '--harness[team adapters]:value:' '--access[tool profile]:value:(read-only full)' '--connection[private connection file]:file:_files' '--project-root[team option]:value:' ;;
     trajectory) _values 'trajectory command' list show prune ;;
     artifact)
       case $words[3] in
@@ -222,7 +222,12 @@ complete -c cairn -n "__fish_seen_subcommand_from doctor" -l repair
 complete -c cairn -n "__fish_seen_subcommand_from security" -a "doctor"
 complete -c cairn -n "__fish_seen_subcommand_from security" -l project -r
 complete -c cairn -n "__fish_seen_subcommand_from security" -l json
-complete -c cairn -n "__fish_seen_subcommand_from team" -a "connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit doctor backup restore memory-delete"
+complete -c cairn -n "__fish_seen_subcommand_from team" -a "connect disconnect init project member credential create set remove issue revoke serve mcp list read search history propose proposals proposal-show review audit audit-export audit-verify audit-archive doctor backup restore memory-delete"
+complete -c cairn -n "__fish_seen_subcommand_from team" -l previous -r
+complete -c cairn -n "__fish_seen_subcommand_from team" -l backup -r
+complete -c cairn -n "__fish_seen_subcommand_from team" -l page-size -r
+complete -c cairn -n "__fish_seen_subcommand_from team" -l cursor -r
+complete -c cairn -n "__fish_seen_subcommand_from team" -l read-only
 complete -c cairn -n "__fish_seen_subcommand_from team" -l organization -r
 complete -c cairn -n "__fish_seen_subcommand_from team" -l data -r
 complete -c cairn -n "__fish_seen_subcommand_from team" -l project -r

package/scripts/test-ci-sharding.sh

@@ -12,12 +12,17 @@ const root = process.argv[2];
 const { buildShardPlan, smokeChecks } = await import(
   pathToFileURL(join(root, "mcp-memory-server", "scripts", "run-smoke-suite.mjs")));
 const plan = buildShardPlan(3);
+const measured = JSON.parse(readFileSync(join(root, 'mcp-memory-server/scripts/fixtures/windows-smoke-timings.json'), 'utf8'));
+assert.equal(measured.schema_version,1);
+for (const [name,seconds] of Object.entries(measured.measurements)) {
+  assert.equal(smokeChecks.find(row=>row.name===name)?.weight,seconds,`measured weight drift: ${name}`);
+}
 const flattened = plan.flatMap(({ checks }) => checks.map(({ name }) => name));
 assert.equal(flattened.length, smokeChecks.length);
 assert.equal(new Set(flattened).size, smokeChecks.length);
 assert.deepEqual([...flattened].sort(), smokeChecks.map(({ name }) => name).sort());
 assert.ok(plan.every(({ checks }) => checks.length > 0));
-const teamContracts = ['team', 'team-review', 'team-http', 'team-mcp', 'team-restore', 'team-cli', 'team-onboarding'];
+const teamContracts = ['team', 'team-review', 'team-http', 'team-mcp', 'team-restore', 'team-cli', 'team-onboarding', 'team-operations'];
 for (const name of teamContracts) assert.ok(flattened.includes(name), `missing team contract: ${name}`);
 assert.ok(plan.every(({ checks }) => checks.some(({ name }) => teamContracts.includes(name))),
   'native ACL-heavy team contracts must be distributed across all Windows shards');