@superjackfruitlabs/salaam 0.0.3 → 0.0.4

package/dist/src/agentpod-authority.js

@@ -1,7 +1,8 @@
 import { randomUUID, randomBytes, createHmac, createHash, timingSafeEqual } from 'node:crypto';
-import { constants, openSync, fstatSync, closeSync, readFileSync, writeFileSync, fsyncSync, realpathSync, } from 'node:fs';
+import { constants, openSync, fstatSync, closeSync, readFileSync, writeFileSync, fsyncSync, realpathSync, mkdirSync, } from 'node:fs';
 import { join } from 'node:path';
 import { canonical, digest, ServiceError, object, integer } from './protocol.js';
+import { forkPiSession } from './pi-sessions.js';
 import { agentpodBinding, AGENTPOD_LEASE_MS, } from './agentpod-protocol.js';
 function privateBytes(path) {
     const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -41,7 +42,35 @@ export function readAgentPodPins(configPath, state) {
         throw Error('AgentPod private daemon state must be outside the station workspace');
     return pins;
 }
-/** A local node admission, not an Accounts token issuer or a provider login. */
+const ruleId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** Closed: 1 to 16 rules, exact keys, a known scope, unique ids. Absent means none. */
+export function approvalRules(value) {
+    if (value === undefined)
+        return [];
+    const bad = () => {
+        throw new ServiceError('invalid_approval_rules', 'Malformed approval rules', 400);
+    };
+    if (!Array.isArray(value) || value.length < 1 || value.length > 16)
+        bad();
+    const rules = value.map((r) => {
+        if (!r || typeof r !== 'object' || Array.isArray(r))
+            bad();
+        const v = r;
+        if (Object.keys(v).sort().join(',') !== 'id,scope,set_by' ||
+            typeof v.id !== 'string' ||
+            !ruleId.test(v.id) ||
+            v.scope !== 'workspace-write' ||
+            typeof v.set_by !== 'string' ||
+            v.set_by.length < 1 ||
+            v.set_by.length > 128 ||
+            /[\u0000-\u001f\u007f]/.test(v.set_by))
+            bad();
+        return { id: v.id, scope: 'workspace-write', set_by: v.set_by };
+    });
+    if (new Set(rules.map((r) => r.id)).size !== rules.length)
+        bad();
+    return rules.sort((a, b) => a.id.localeCompare(b.id));
+}
 export class AgentPodAuthority {
     store;
     configPath;
@@ -50,12 +79,14 @@ export class AgentPodAuthority {
     boot = randomUUID();
     pins;
     key;
+    stateDir;
     constructor(store, state, configPath, cancel, ownedResourcesStopped = () => true) {
         this.store = store;
         this.configPath = configPath;
         this.cancel = cancel;
         this.ownedResourcesStopped = ownedResourcesStopped;
         this.pins = readAgentPodPins(configPath, state);
+        this.stateDir = state;
         const keyPath = join(state, 'agentpod-control-key');
         try {
             const fd = openSync(keyPath, 'wx', 0o600);
@@ -81,6 +112,7 @@ export class AgentPodAuthority {
         this.key = privateBytes(keyPath);
         if (this.key.length !== 32)
             throw Error('Invalid AgentPod control key');
+        store.db.exec('CREATE TABLE IF NOT EXISTS agentpod_approval_rules(admission_id TEXT NOT NULL,rule_id TEXT NOT NULL,scope TEXT NOT NULL,set_by TEXT NOT NULL,revoked_at TEXT,PRIMARY KEY(admission_id,rule_id))');
         store.agentpodAuthorityCheck = (session) => this.assert(this.bySession(session));
         store.requireAgentPodAuthority = true;
     }
@@ -121,6 +153,17 @@ export class AgentPodAuthority {
             throw new ServiceError('authority_expired', 'AgentPod authority lease has no remaining native grant window');
         return remaining;
     }
+    /** The session's pinned approval rules that no renewal has revoked. */
+    approvalRules(session) {
+        return this.store.db
+            .prepare('SELECT r.rule_id AS id,r.scope,r.set_by FROM agentpod_approval_rules r JOIN agentpod_admissions a ON a.id=r.admission_id WHERE a.session_id=? AND r.revoked_at IS NULL ORDER BY r.rule_id')
+            .all(session)
+            .map((r) => ({
+            id: String(r.id),
+            scope: 'workspace-write',
+            set_by: String(r.set_by),
+        }));
+    }
     checked(input) {
         const b = agentpodBinding(input);
         for (const k of Object.keys(this.pins))
@@ -191,9 +234,25 @@ export class AgentPodAuthority {
         this.assert(row);
         return { session_id: row.session_id, binding: JSON.parse(row.binding) };
     }
-    admit(input, request) {
+    /**
+     * `continueFrom` names an earlier interactive admission (its hub session id) whose conversation
+     * this new admission carries on. The earlier execution stays revoked: the new admission gets a
+     * NEW session, its own lease and its own authority, seeded with a branch of the old Pi
+     * transcript and its entries. Only a revoked, stopped and reconciled interactive admission for
+     * the same organization, station, occupant and workspace can be continued, and only once.
+     */
+    admit(input, request, continueFrom, rulesInput) {
         const b = this.checked(input);
-        const admitted = this.store.request('agentpod-node', request, { kind: 'admit', binding: b }, () => {
+        const rules = approvalRules(rulesInput);
+        if (continueFrom !== undefined &&
+            (typeof continueFrom !== 'string' || !continueFrom || continueFrom.length > 128))
+            throw new ServiceError('invalid_continuation', 'continue_from must be a hub session id', 400);
+        const admitted = this.store.request('agentpod-node', request, {
+            kind: 'admit',
+            binding: b,
+            ...(continueFrom === undefined ? {} : { continue_from: continueFrom }),
+            ...(rules.length ? { approval_rules: rules } : {}),
+        }, () => {
             const old = this.store.db
                 .prepare('SELECT id FROM agentpod_admissions WHERE hub_session_id=?')
                 .get(b.hub_session_id);
@@ -226,24 +285,61 @@ export class AgentPodAuthority {
             this.store.db
                 .prepare('INSERT INTO agentpod_station_epochs VALUES (?,?,?) ON CONFLICT(station_id) DO UPDATE SET occupancy_epoch=excluded.occupancy_epoch,principal_id=excluded.principal_id')
                 .run(b.station_id, b.occupancy_epoch, b.principal_id);
+            const prior = continueFrom === undefined ? undefined : this.continuable(b, continueFrom);
             const session = randomUUID(), id = randomUUID();
-            this.store.db
-                .prepare('INSERT INTO sessions(id,cwd,pi_session_id) VALUES (?,?,?)')
-                .run(session, b.workspace, session);
-            this.store.event(session, 'session.created', { cwd: b.workspace, authority: 'agentpod-v1' }, request);
+            if (prior) {
+                const source = this.store.session(prior.session_id);
+                const file = source.pi_session_file
+                    ? (() => {
+                        const dir = join(this.stateDir, 'workers', session, 'sessions');
+                        mkdirSync(dir, { recursive: true, mode: 0o700 });
+                        return forkPiSession(source.pi_session_file, source.cwd, dir, session);
+                    })()
+                    : null;
+                this.store.db
+                    .prepare('INSERT INTO sessions(id,cwd,pi_session_id,pi_session_file,pi_cursor,pi_leaf) VALUES (?,?,?,?,?,?)')
+                    .run(session, b.workspace, session, file, source.pi_cursor, source.pi_leaf);
+                this.store.event(session, 'session.created', { cwd: b.workspace, authority: 'agentpod-v1', forked_from: prior.session_id }, request);
+                this.store.db
+                    .prepare('INSERT INTO pi_entries SELECT ?,entry_id,payload FROM pi_entries WHERE session_id=?')
+                    .run(session, prior.session_id);
+                this.store.event(session, 'session.forked', {
+                    parent: prior.session_id,
+                    parent_revision: source.revision,
+                    leaf: source.pi_leaf,
+                    cursor: source.pi_cursor,
+                }, request);
+            }
+            else {
+                this.store.db
+                    .prepare('INSERT INTO sessions(id,cwd,pi_session_id) VALUES (?,?,?)')
+                    .run(session, b.workspace, session);
+                this.store.event(session, 'session.created', { cwd: b.workspace, authority: 'agentpod-v1' }, request);
+            }
             this.store.db
                 .prepare('INSERT INTO agentpod_admissions(id,session_id,hub_session_id,run_key,binding,digest,pins_digest,expires_at) VALUES (?,?,?,?,?,?,?,?)')
                 .run(id, session, b.hub_session_id, canonical({ org: b.organization_id, run: b.run }), canonical(b), digest(b), digest(this.pins), Date.now() + AGENTPOD_LEASE_MS);
-            this.store.event(session, 'agentpod.admitted', { admission_id: id, binding_digest: digest(b), binding: b }, request);
+            // The agent's standing rules, pinned for this run; a renewal may add or revoke one.
+            for (const r of rules)
+                this.store.db
+                    .prepare('INSERT INTO agentpod_approval_rules VALUES (?,?,?,?,NULL)')
+                    .run(id, r.id, r.scope, r.set_by);
+            this.store.event(session, 'agentpod.admitted', {
+                admission_id: id,
+                binding_digest: digest(b),
+                binding: b,
+                ...(prior ? { continued_from: continueFrom, continued_admission: prior.id } : {}),
+            }, request);
             return { admission_id: id };
         });
         const row = this.row(admitted.admission_id);
         return { ...this.status(row), token: this.token(row.id) };
     }
-    renew(input, request, sequence) {
+    renew(input, request, sequence, rulesInput) {
         const b = this.checked(input);
         integer(sequence, 'lease_sequence');
-        return this.store.request('agentpod-node', request, { kind: 'renew', binding: b, sequence }, () => {
+        const rules = approvalRules(rulesInput);
+        return this.store.request('agentpod-node', request, { kind: 'renew', binding: b, sequence, ...(rules.length ? { approval_rules: rules } : {}) }, () => {
             const row = this.bound(b);
             if (row.state === 'revoked' ||
                 this.store.execution.revocation(row.session_id) ||
@@ -258,10 +354,68 @@ export class AgentPodAuthority {
             this.store.db
                 .prepare("UPDATE agentpod_admissions SET lease_sequence=?,expires_at=?,boot_id=?,monotonic_deadline=?,state='active' WHERE id=?")
                 .run(sequence, Date.now() + AGENTPOD_LEASE_MS, this.boot, performance.now() + AGENTPOD_LEASE_MS, row.id);
+            // Revocation is immediate: a pinned rule the hub no longer lists ends now, for good.
+            const listed = new Set(rules.map((r) => r.id));
+            for (const pinned of this.store.db
+                .prepare('SELECT rule_id FROM agentpod_approval_rules WHERE admission_id=? AND revoked_at IS NULL')
+                .all(row.id)) {
+                if (listed.has(String(pinned.rule_id)))
+                    continue;
+                this.store.db
+                    .prepare('UPDATE agentpod_approval_rules SET revoked_at=? WHERE admission_id=? AND rule_id=?')
+                    .run(new Date().toISOString(), row.id, String(pinned.rule_id));
+                this.store.event(row.session_id, 'approval_rule.revoked', { admission_id: row.id, rule_id: pinned.rule_id }, request);
+            }
+            // A rule the hub newly lists joins the run now (operator ruling 2026-10-28: a person who
+            // chose "Always allow" mid-run is not asked again). One this run already holds, or held
+            // and lost to revocation, is left as it is: revocation stays final for the run.
+            for (const r of rules) {
+                const known = this.store.db
+                    .prepare('SELECT 1 FROM agentpod_approval_rules WHERE admission_id=? AND rule_id=?')
+                    .get(row.id, r.id);
+                if (known)
+                    continue;
+                this.store.db
+                    .prepare('INSERT INTO agentpod_approval_rules VALUES (?,?,?,?,NULL)')
+                    .run(row.id, r.id, r.scope, r.set_by);
+                this.store.event(row.session_id, 'approval_rule.added', { admission_id: row.id, rule_id: r.id, scope: r.scope, set_by: r.set_by }, request);
+            }
             this.store.event(row.session_id, 'agentpod.renewed', { admission_id: row.id, lease_sequence: sequence }, request);
             return this.status(this.row(row.id));
         });
     }
+    /** The earlier admission a new interactive admission may continue, or a refusal. */
+    continuable(b, continueFrom) {
+        if (b.run.source !== 'agentpod')
+            throw new ServiceError('continuation_refused', 'Only an interactive admission can continue an earlier conversation');
+        const row = this.store.db
+            .prepare('SELECT id FROM agentpod_admissions WHERE hub_session_id=?')
+            .get(continueFrom);
+        if (!row)
+            throw new ServiceError('admission_not_found', 'The session to continue has no admission', 404);
+        const prior = this.row(String(row.id));
+        const before = JSON.parse(prior.binding);
+        if (prior.binding !== canonical(before) ||
+            prior.digest !== digest(before) ||
+            before.run.source !== 'agentpod' ||
+            before.organization_id !== b.organization_id ||
+            before.station_id !== b.station_id ||
+            before.principal_id !== b.principal_id ||
+            before.workspace !== b.workspace ||
+            before.hub_session_id === b.hub_session_id)
+            throw new ServiceError('continuation_refused', 'Only the same station, occupant and workspace can continue this conversation');
+        const status = this.status(prior);
+        if (prior.state !== 'revoked' ||
+            !status.revoked ||
+            !status.owned_execution_stopped ||
+            status.unresolved_operations.length)
+            throw new ServiceError('execution_unconfirmed', 'The conversation to continue must be revoked, stopped and reconciled first');
+        if (this.store.db
+            .prepare("SELECT 1 FROM events WHERE kind='agentpod.admitted' AND json_extract(payload,'$.continued_admission')=? LIMIT 1")
+            .get(prior.id))
+            throw new ServiceError('already_continued', 'This conversation was already continued');
+        return prior;
+    }
     revoke(input, request, reason) {
         const b = this.checked(input);
         this.store.request('agentpod-node', request, { kind: 'revoke', binding: b, reason }, () => {
@@ -329,9 +483,13 @@ export class AgentPodAuthority {
             authorized = true;
         }
         catch { }
+        const continued = this.store.db
+            .prepare("SELECT json_extract(payload,'$.continued_from') AS source FROM events WHERE session_id=? AND kind='agentpod.admitted' LIMIT 1")
+            .get(row.session_id);
         return {
             admission_id: row.id,
             session_id: row.session_id,
+            continued_from: continued?.source ?? null,
             binding: JSON.parse(row.binding),
             binding_digest: row.digest,
             lease_sequence: row.lease_sequence,

package/dist/src/agentpod-default-config.js

@@ -0,0 +1,12 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * The AgentPod pins a node operator drops for this user, used when
+ * `service start` names no --agentpod-config. Without it a daemon an AgentPod
+ * node expects to bind starts unbound and the node never detects a station.
+ */
+export function defaultAgentPodConfig(env, exists) {
+    const base = env.XDG_CONFIG_HOME || join(env.HOME || homedir(), '.config');
+    const path = join(base, 'salaam', 'agentpod-pins.json');
+    return exists(path) ? path : undefined;
+}

package/dist/src/agentpod-work-decision-protocol.js

@@ -31,19 +31,31 @@ export function workDecision(value) {
         'expires_at',
         'question',
         'options',
+        ...('detail' in v ? ['detail'] : []),
     ]);
+    if ('detail' in v)
+        workDecisionDetail(v.detail);
     if (v.version !== 1 ||
         !['request_id', 'work_request_id', 'task_id', 'operation_id', 'approval_id'].every((k) => uuid(v[k])) ||
         !['binding_digest', 'operation_digest'].every((k) => typeof v[k] === 'string' && /^[a-f0-9]{64}$/.test(v[k])) ||
         !['plan_revision', 'approval_revision', 'expires_at'].every((k) => Number.isSafeInteger(v[k]) && Number(v[k]) > 0) ||
         !text(v.question, 8192) ||
         !Array.isArray(v.options) ||
-        v.options.length !== 2)
+        ![2, 3, 4].includes(v.options.length))
         fail();
-    for (let i = 0; i < 2; i++) {
-        const opt = object(v.options[i]);
-        keys(opt, ['id', 'title']);
-        if (opt.id !== ['approve', 'deny'][i] || !text(opt.title, 256))
+    // approve, [approve-run], [always], deny. Nothing else, in that order.
+    const ids = v.options.map((o) => String(object(o).id));
+    if (![
+        'approve,deny',
+        'approve,approve-run,deny',
+        'approve,always,deny',
+        'approve,approve-run,always,deny',
+    ].includes(ids.join(',')))
+        fail();
+    for (const value of v.options) {
+        const opt = object(value);
+        keys(opt, opt.id === 'always' ? ['id', 'title', 'requires'] : ['id', 'title']);
+        if (!text(opt.title, 256) || (opt.id === 'always' && opt.requires !== 'workspace-admin'))
             fail();
     }
     return v;
@@ -67,7 +79,7 @@ export function workDecisionAnswer(value) {
         !/^[a-f0-9]{64}$/.test(v.decision_digest) ||
         !text(v.elicitation_id, 128) ||
         !/^elc_[A-Za-z0-9]{6,}$/.test(v.elicitation_id) ||
-        !['approve', 'deny'].includes(String(v.option_id)) ||
+        !['approve', 'approve-run', 'always', 'deny'].includes(String(v.option_id)) ||
         !text(v.answered_by, 128) ||
         typeof v.answered_at !== 'string' ||
         !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?Z$/.test(v.answered_at) ||
@@ -76,3 +88,25 @@ export function workDecisionAnswer(value) {
         fail();
     return v;
 }
+function workDecisionDetail(value) {
+    const d = object(value);
+    keys(d, ['version', 'summary', 'reason', 'files', 'digest']);
+    if (d.version !== 1 ||
+        !text(d.summary, 200) ||
+        (d.reason !== null && !text(d.reason, 300)) ||
+        typeof d.digest !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(d.digest) ||
+        !Array.isArray(d.files) ||
+        d.files.length > 16)
+        fail();
+    for (const f of d.files) {
+        const file = object(f);
+        keys(file, ['path', 'change', 'bytes', 'preview']);
+        if (!text(file.path, 512) ||
+            !['create', 'edit', 'delete'].includes(String(file.change)) ||
+            (file.bytes !== null && (!Number.isSafeInteger(file.bytes) || Number(file.bytes) < 0)) ||
+            (file.preview !== null && (typeof file.preview !== 'string' || file.preview.length > 1200)))
+            fail();
+    }
+    return d;
+}

package/dist/src/agentpod-work-decisions.js

@@ -1,14 +1,44 @@
 import { randomUUID } from 'node:crypto';
 import { canonical, digest, ServiceError } from './protocol.js';
-import { workDecisionAnswer } from './agentpod-work-decision-protocol.js';
+import { runGrantCovers, runGrantPrefix } from './run-grants.js';
+import { workDecisionAnswer, } from './agentpod-work-decision-protocol.js';
 /** Private authenticated Hub control only. Answers choose an existing approval;
  * they never execute an operation or supply a second effect grant. */
 export class AgentPodWorkDecisions {
     work;
     managed;
-    constructor(work, managed) {
+    grants;
+    constructor(work, managed, grants) {
         this.work = work;
         this.managed = managed;
+        this.grants = grants;
+    }
+    /** The run directory a grant for this operation would cover, when it is a covered write. */
+    grantable(binding, op) {
+        if (!this.grants || op.kind !== 'workspace')
+            return null;
+        const run = binding?.run;
+        const prefix = runGrantPrefix(typeof run?.id === 'string' ? run.id : '');
+        let args = {};
+        try {
+            args = JSON.parse(op.value);
+        }
+        catch {
+            return null;
+        }
+        return prefix && runGrantCovers(prefix, args) ? prefix : null;
+    }
+    /** "Always allow" covers exactly what the standing workspace-write rule answers: a workspace
+     * write anywhere in the workspace, never a delete or a hidden path. */
+    alwaysAllowable(op) {
+        if (op.kind !== 'workspace')
+            return false;
+        try {
+            return runGrantCovers('', JSON.parse(op.value));
+        }
+        catch {
+            return false;
+        }
     }
     owner(binding) {
         const root = this.work.authority.inspect(binding);
@@ -48,9 +78,22 @@ export class AgentPodWorkDecisions {
                 version: 1,
                 request_id: randomUUID(),
                 ...identity,
-                question: 'Approve this exact operation? ' + op.kind + ' ' + op.action_key,
+                question: approvalDetail(op).summary + '?',
+                detail: approvalDetail(op),
                 options: [
                     { id: 'approve', title: 'Approve once' },
+                    ...(this.grantable(root.binding, op)
+                        ? [{ id: 'approve-run', title: 'Approve for this run' }]
+                        : []),
+                    ...(this.alwaysAllowable(op)
+                        ? [
+                            {
+                                id: 'always',
+                                title: 'Always allow this agent to write in its workspace',
+                                requires: 'workspace-admin',
+                            },
+                        ]
+                        : []),
                     { id: 'deny', title: 'Deny' },
                 ],
             }));
@@ -81,7 +124,30 @@ export class AgentPodWorkDecisions {
                 approval.operation_id !== offered.operation_id ||
                 approval.expires_at !== offered.expires_at)
                 throw new ServiceError('approval_mismatch', 'Approval ownership changed');
-            this.managed.decide(offered.approval_id, answer.request_id, offered.approval_revision, offered.operation_digest, answer.option_id);
+            // "Approve for this run" must have been offered, and still be grantable, to be chosen.
+            const prefix = answer.option_id === 'approve-run'
+                ? this.grantable(root.binding, this.managed.operation(offered.operation_id))
+                : null;
+            if (answer.option_id === 'approve-run' &&
+                (!prefix || !offered.options.some((o) => o.id === 'approve-run')))
+                throw new ServiceError('approval_mismatch', 'This approval cannot cover the run');
+            // "Always allow" approves this write; the standing rule is the hub's, set before it forwards.
+            if (answer.option_id === 'always' &&
+                (!offered.options.some((o) => o.id === 'always') ||
+                    !this.alwaysAllowable(this.managed.operation(offered.operation_id))))
+                throw new ServiceError('approval_mismatch', 'Always allow was not offered for this write');
+            this.managed.decide(offered.approval_id, answer.request_id, offered.approval_revision, offered.operation_digest, answer.option_id === 'deny' ? 'deny' : 'approve');
+            const grant = answer.option_id === 'approve-run'
+                ? this.grants.createInTransaction({
+                    session_id: root.session_id,
+                    task_id: task.id,
+                    plan_revision: offered.plan_revision,
+                    binding_digest: offered.binding_digest,
+                    path_prefix: prefix,
+                    approval_id: offered.approval_id,
+                    granted_by: answer.answered_by,
+                })
+                : null;
             this.work.store.execution.assert(root.session_id);
             return {
                 version: 1,
@@ -89,7 +155,45 @@ export class AgentPodWorkDecisions {
                 decision_digest: answer.decision_digest,
                 approval_id: offered.approval_id,
                 decision: answer.option_id,
+                ...(grant ? { grant_id: grant.id } : {}),
             };
         });
     }
 }
+/** Readable approvals: what a person approves, from the operation's own canonical arguments only.
+ * A workspace write names its file, the change, its size, a short preview and the agent's one-line
+ * reason; anything else names its kind and target. The digest still binds the exact operation. */
+export function approvalDetail(op) {
+    const base = { version: 1, reason: null, files: [], digest: op.operation_digest };
+    if (op.kind === 'review')
+        return { ...base, summary: 'Accept this step for review' };
+    if (op.kind !== 'workspace')
+        return { ...base, summary: ('Run ' + op.kind + ' ' + op.target).slice(0, 200) };
+    let args = {};
+    try {
+        args = JSON.parse(op.value);
+    }
+    catch {
+        /* not a patch: the generic form below */
+    }
+    const path = typeof args.path === 'string' ? args.path : op.target.replace(/^station:/, '');
+    const content = typeof args.content === 'string' ? args.content : null;
+    const change = args.content === null ? 'delete' : args.expected_hash === null ? 'create' : 'edit';
+    const verb = { create: 'Create', edit: 'Edit', delete: 'Delete' }[change];
+    const reason = typeof args.reason === 'string' && args.reason.trim()
+        ? args.reason.replace(/\s+/g, ' ').trim().slice(0, 300)
+        : null;
+    return {
+        ...base,
+        summary: (verb + ' ' + path + ' in the workspace').slice(0, 200),
+        reason,
+        files: [
+            {
+                path: path.slice(0, 512),
+                change,
+                bytes: content === null ? null : Buffer.byteLength(content),
+                preview: content === null ? null : content.slice(0, 1200),
+            },
+        ],
+    };
+}