vgxness 1.20.3 → 1.20.5

package/dist/runs/repositories/task-scoped-command-grants.js

@@ -0,0 +1,462 @@
+import { randomUUID } from 'node:crypto';
+const grantableCategories = new Set(['shell', 'test-run', 'git']);
+const grantStatuses = new Set(['active', 'revoked', 'expired', 'exhausted']);
+export class TaskScopedCommandGrantRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const validation = validateCreate(input);
+        if (!validation.ok)
+            return validation;
+        const run = this.getRunId(input.runId);
+        if (!run.ok)
+            return run;
+        const result = this.db.transaction(() => {
+            const id = randomUUID();
+            const createdAt = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO task_scoped_command_grants(
+          id, run_id, agent_id, task_fingerprint, categories_json, external_roots_json,
+          canonical_external_roots_json, cwd_patterns_json, command_policy_json, expires_at,
+          max_uses, used_count, status, created_by_json, created_at, audit_json
+        ) VALUES (
+          @id, @runId, @agentId, @taskFingerprint, @categoriesJson, @externalRootsJson,
+          @canonicalExternalRootsJson, @cwdPatternsJson, @commandPolicyJson, @expiresAt,
+          @maxUses, 0, 'active', @createdByJson, @createdAt, @auditJson
+        )
+      `)
+                .run({
+                id,
+                runId: input.runId,
+                agentId: input.agentId,
+                taskFingerprint: input.taskFingerprint,
+                categoriesJson: JSON.stringify(input.categories),
+                externalRootsJson: JSON.stringify(input.externalRoots),
+                canonicalExternalRootsJson: JSON.stringify(input.canonicalExternalRoots),
+                cwdPatternsJson: input.cwdPatterns === undefined ? null : JSON.stringify(input.cwdPatterns),
+                commandPolicyJson: JSON.stringify(input.commandPolicy),
+                expiresAt: input.expiresAt,
+                maxUses: input.maxUses,
+                createdByJson: JSON.stringify(input.createdBy),
+                createdAt,
+                auditJson: JSON.stringify(input.audit),
+            });
+            this.insertEvent({
+                runId: input.runId,
+                title: 'Task-scoped command grant created',
+                payload: {
+                    grantId: id,
+                    agentId: input.agentId,
+                    taskFingerprint: input.taskFingerprint,
+                    categories: input.categories,
+                    commandPolicy: { kind: input.commandPolicy.kind, ids: input.commandPolicy.ids },
+                    expiresAt: input.expiresAt,
+                    maxUses: input.maxUses,
+                    approvedScopeSummary: input.audit.approvedScopeSummary,
+                },
+                relatedId: id,
+            });
+            const created = this.get(id);
+            if (!created.ok)
+                return created;
+            return ok(created.value);
+        });
+        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
+    }
+    get(id) {
+        if (!id.trim())
+            return validationFailure('Grant id is required');
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM task_scoped_command_grants WHERE id=?').get(id);
+            if (row === undefined)
+                return missing(`Task-scoped command grant not found: ${id}`);
+            return mapGrantRow(row);
+        }
+        catch (cause) {
+            return fail('Failed to read task-scoped command grant', cause);
+        }
+    }
+    list(filters = {}) {
+        if (filters.limit !== undefined && (!Number.isInteger(filters.limit) || filters.limit < 1))
+            return validationFailure('Grant list limit must be positive');
+        if (filters.status !== undefined && !grantStatuses.has(filters.status))
+            return validationFailure(`Unsupported grant status: ${filters.status}`);
+        try {
+            const where = [];
+            const parameters = {};
+            if (filters.runId !== undefined) {
+                where.push('run_id=@runId');
+                parameters.runId = filters.runId;
+            }
+            if (filters.agentId !== undefined) {
+                where.push('agent_id=@agentId');
+                parameters.agentId = filters.agentId;
+            }
+            if (filters.status !== undefined) {
+                where.push('status=@status');
+                parameters.status = filters.status;
+            }
+            if (filters.limit !== undefined)
+                parameters.limit = filters.limit;
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM task_scoped_command_grants
+        ${where.length > 0 ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY created_at DESC, id ASC
+        ${filters.limit === undefined ? '' : 'LIMIT @limit'}
+      `)
+                .all(parameters);
+            const grants = [];
+            for (const row of rows) {
+                const mapped = mapGrantRow(row);
+                if (!mapped.ok)
+                    return mapped;
+                grants.push(mapped.value);
+            }
+            return ok(grants);
+        }
+        catch (cause) {
+            return fail('Failed to list task-scoped command grants', cause);
+        }
+    }
+    revoke(input) {
+        const validation = validateRevoke(input);
+        if (!validation.ok)
+            return validation;
+        const existing = this.get(input.grantId);
+        if (!existing.ok)
+            return existing;
+        if (existing.value.status !== 'active')
+            return validationFailure(`Grant is not active: ${existing.value.status}`);
+        const result = this.db.transaction(() => {
+            const revokedAt = input.now ?? new Date().toISOString();
+            const update = this.db.connection
+                .prepare(`
+        UPDATE task_scoped_command_grants
+        SET status='revoked', revoked_by_json=@revokedByJson, revoked_at=@revokedAt, revoke_reason=@reason
+        WHERE id=@id AND status='active'
+      `)
+                .run({ id: input.grantId, revokedByJson: JSON.stringify(input.actor), revokedAt, reason: input.reason });
+            if (update.changes === 0)
+                return validationFailure(`Grant is already inactive or changed by another writer: ${input.grantId}`);
+            this.insertEvent({
+                runId: existing.value.runId,
+                title: 'Task-scoped command grant revoked',
+                payload: {
+                    grantId: input.grantId,
+                    actor: { type: input.actor.type, id: input.actor.id, ...(input.actor.displayName === undefined ? {} : { displayName: input.actor.displayName }) },
+                    reason: input.reason,
+                    revokedAt,
+                },
+                relatedId: input.grantId,
+            });
+            return this.get(input.grantId);
+        });
+        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
+    }
+    consumeUse(input) {
+        if (!input.grantId.trim())
+            return validationFailure('Grant id is required');
+        if (!isIsoDate(input.now))
+            return validationFailure('Consume timestamp must be a valid ISO date');
+        const existing = this.get(input.grantId);
+        if (!existing.ok)
+            return existing;
+        const result = this.db.transaction(() => {
+            const update = this.db.connection
+                .prepare(`
+        UPDATE task_scoped_command_grants
+        SET
+          used_count = used_count + 1,
+          status = CASE
+            WHEN used_count + 1 >= max_uses THEN 'exhausted'
+            ELSE status
+          END
+        WHERE id = @id
+          AND status = 'active'
+          AND used_count < max_uses
+          AND expires_at > @now
+      `)
+                .run({ id: input.grantId, now: input.now });
+            if (update.changes === 0) {
+                this.markExpiredIfNeeded(input.grantId, input.now);
+                return validationFailure(`Grant cannot be consumed because it is inactive, expired, exhausted, or concurrently consumed: ${input.grantId}`);
+            }
+            const consumed = this.get(input.grantId);
+            if (!consumed.ok)
+                return consumed;
+            this.insertEvent({
+                runId: consumed.value.runId,
+                kind: 'evidence',
+                title: 'Task-scoped command grant used',
+                payload: {
+                    grantId: consumed.value.id,
+                    usedCountBefore: existing.value.usedCount,
+                    usedCountAfter: consumed.value.usedCount,
+                    status: consumed.value.status,
+                    commandId: input.commandId ?? null,
+                    canonicalCwd: input.canonicalCwd ?? null,
+                    matchedExternalRoot: input.matchedExternalRoot ?? null,
+                },
+                relatedId: consumed.value.id,
+            });
+            return ok(consumed.value);
+        });
+        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
+    }
+    getRunId(runId) {
+        try {
+            const row = this.db.connection.prepare('SELECT id FROM runs WHERE id=?').get(runId);
+            return row === undefined ? missing(`Run not found: ${runId}`) : ok(row.id);
+        }
+        catch (cause) {
+            return fail('Failed to read run for task-scoped command grant', cause);
+        }
+    }
+    markExpiredIfNeeded(grantId, now) {
+        this.db.connection
+            .prepare(`
+      UPDATE task_scoped_command_grants
+      SET status='expired'
+      WHERE id=@id AND status='active' AND expires_at <= @now
+    `)
+            .run({ id: grantId, now });
+    }
+    insertEvent(input) {
+        const next = this.nextSequence(input.runId);
+        const event = {
+            id: randomUUID(),
+            runId: input.runId,
+            sequence: next,
+            kind: input.kind ?? 'timeline',
+            title: input.title,
+            payloadJson: JSON.stringify(input.payload),
+            relatedType: 'task-scoped-command-grant',
+            relatedId: input.relatedId,
+            createdAt: new Date().toISOString(),
+        };
+        this.db.connection
+            .prepare(`
+      INSERT INTO run_events(id, run_id, sequence, kind, title, payload_json, related_type, related_id, created_at)
+      VALUES (@id, @runId, @sequence, @kind, @title, @payloadJson, @relatedType, @relatedId, @createdAt)
+    `)
+            .run(event);
+        return {
+            id: event.id,
+            runId: event.runId,
+            sequence: event.sequence,
+            kind: event.kind,
+            title: event.title,
+            payload: JSON.parse(event.payloadJson),
+            relatedType: event.relatedType,
+            relatedId: event.relatedId,
+            createdAt: event.createdAt,
+        };
+    }
+    nextSequence(runId) {
+        const row = this.db.connection.prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence FROM run_events WHERE run_id=?').get(runId);
+        return row.sequence;
+    }
+}
+function validateCreate(input) {
+    if (!input.runId.trim())
+        return validationFailure('Grant runId is required');
+    if (!input.agentId.trim())
+        return validationFailure('Grant agentId is required');
+    if (!input.taskFingerprint.trim())
+        return validationFailure('Grant taskFingerprint is required');
+    if (input.createdBy.type !== 'human')
+        return validationFailure('Grant creator must be a human actor');
+    if (!input.createdBy.id.trim())
+        return validationFailure('Grant creator id is required');
+    if (!Array.isArray(input.categories) || input.categories.length === 0)
+        return validationFailure('Grant categories are required');
+    if (new Set(input.categories).size !== input.categories.length)
+        return validationFailure('Grant categories must be unique');
+    for (const category of input.categories)
+        if (!grantableCategories.has(category))
+            return validationFailure(`Unsupported grant category: ${category}`);
+    if (!Array.isArray(input.externalRoots))
+        return validationFailure('Grant externalRoots must be an array');
+    if (!Array.isArray(input.canonicalExternalRoots))
+        return validationFailure('Grant canonicalExternalRoots must be an array');
+    if (input.cwdPatterns !== undefined && !Array.isArray(input.cwdPatterns))
+        return validationFailure('Grant cwdPatterns must be an array when provided');
+    const commandPolicy = validateCommandPolicy(input.commandPolicy);
+    if (!commandPolicy.ok)
+        return commandPolicy;
+    if (!isIsoDate(input.expiresAt))
+        return validationFailure('Grant expiresAt must be a valid ISO date');
+    if (!Number.isInteger(input.maxUses) || input.maxUses < 1)
+        return validationFailure('Grant maxUses must be a positive integer');
+    if (!input.audit.creationReason.trim())
+        return validationFailure('Grant audit creationReason is required');
+    if (!input.audit.approvedScopeSummary.trim())
+        return validationFailure('Grant audit approvedScopeSummary is required');
+    return ok(undefined);
+}
+function validateCommandPolicy(policy) {
+    if (policy.kind !== 'allowlisted-command-ids')
+        return validationFailure('Grant command policy must use allowlisted command ids');
+    if (!Array.isArray(policy.ids) || policy.ids.length === 0)
+        return validationFailure('Grant command policy ids are required');
+    if (new Set(policy.ids).size !== policy.ids.length)
+        return validationFailure('Grant command policy ids must be unique');
+    for (const id of policy.ids)
+        if (!id.trim())
+            return validationFailure('Grant command policy ids must be non-empty');
+    return ok(undefined);
+}
+function validateRevoke(input) {
+    if (!input.grantId.trim())
+        return validationFailure('Grant id is required');
+    if (input.actor.type !== 'human' && input.actor.type !== 'system')
+        return validationFailure('Grant revoke actor must be human or system');
+    if (!input.actor.id.trim())
+        return validationFailure('Grant revoke actor id is required');
+    if (!input.reason.trim())
+        return validationFailure('Grant revoke reason is required');
+    if (input.now !== undefined && !isIsoDate(input.now))
+        return validationFailure('Grant revoke timestamp must be a valid ISO date');
+    return ok(undefined);
+}
+function mapGrantRow(row) {
+    const status = readString(row.status);
+    if (!grantStatuses.has(status))
+        return validationFailure(`Persisted grant has unsupported status: ${status}`);
+    const categories = parseJsonArray(row.categories_json, isTaskScopedGrantCategory, 'categories_json');
+    if (!categories.ok)
+        return categories;
+    const externalRoots = parseJsonArray(row.external_roots_json, isString, 'external_roots_json');
+    if (!externalRoots.ok)
+        return externalRoots;
+    const canonicalExternalRoots = parseJsonArray(row.canonical_external_roots_json, isString, 'canonical_external_roots_json');
+    if (!canonicalExternalRoots.ok)
+        return canonicalExternalRoots;
+    const cwdPatterns = row.cwd_patterns_json === null ? ok(undefined) : parseJsonArray(row.cwd_patterns_json, isString, 'cwd_patterns_json');
+    if (!cwdPatterns.ok)
+        return cwdPatterns;
+    const commandPolicy = parseJsonObject(row.command_policy_json, isCommandPolicy, 'command_policy_json');
+    if (!commandPolicy.ok)
+        return commandPolicy;
+    const createdBy = parseJsonObject(row.created_by_json, isHumanActor, 'created_by_json');
+    if (!createdBy.ok)
+        return createdBy;
+    const revokedBy = row.revoked_by_json === null ? ok(undefined) : parseJsonObject(row.revoked_by_json, isRevocationActor, 'revoked_by_json');
+    if (!revokedBy.ok)
+        return revokedBy;
+    const audit = parseJsonObject(row.audit_json, isGrantAudit, 'audit_json');
+    if (!audit.ok)
+        return audit;
+    const grant = {
+        id: readString(row.id),
+        runId: readString(row.run_id),
+        agentId: readString(row.agent_id),
+        taskFingerprint: readString(row.task_fingerprint),
+        categories: categories.value,
+        externalRoots: externalRoots.value,
+        canonicalExternalRoots: canonicalExternalRoots.value,
+        commandPolicy: commandPolicy.value,
+        expiresAt: readString(row.expires_at),
+        maxUses: readNumber(row.max_uses),
+        usedCount: readNumber(row.used_count),
+        status: status,
+        createdBy: createdBy.value,
+        createdAt: readString(row.created_at),
+        audit: audit.value,
+    };
+    if (cwdPatterns.value !== undefined)
+        grant.cwdPatterns = cwdPatterns.value;
+    if (revokedBy.value !== undefined)
+        grant.revokedBy = revokedBy.value;
+    const revokedAt = readNullableString(row.revoked_at);
+    if (revokedAt !== undefined)
+        grant.revokedAt = revokedAt;
+    const revokeReason = readNullableString(row.revoke_reason);
+    if (revokeReason !== undefined)
+        grant.revokeReason = revokeReason;
+    return ok(grant);
+}
+function parseJsonArray(value, predicate, column) {
+    const parsed = parseJson(value, column);
+    if (!parsed.ok)
+        return parsed;
+    if (!Array.isArray(parsed.value) || !parsed.value.every(predicate))
+        return validationFailure(`Persisted grant ${column} is invalid`);
+    return ok(parsed.value);
+}
+function parseJsonObject(value, predicate, column) {
+    const parsed = parseJson(value, column);
+    if (!parsed.ok)
+        return parsed;
+    if (!predicate(parsed.value))
+        return validationFailure(`Persisted grant ${column} is invalid`);
+    return ok(parsed.value);
+}
+function parseJson(value, column) {
+    if (typeof value !== 'string')
+        return validationFailure(`Persisted grant ${column} is not JSON text`);
+    try {
+        return ok(JSON.parse(value));
+    }
+    catch (cause) {
+        return fail(`Persisted grant ${column} is invalid JSON`, cause);
+    }
+}
+function isTaskScopedGrantCategory(value) {
+    return typeof value === 'string' && grantableCategories.has(value);
+}
+function isCommandPolicy(value) {
+    if (!isRecord(value))
+        return false;
+    return value.kind === 'allowlisted-command-ids' && Array.isArray(value.ids) && value.ids.every(isString);
+}
+function isHumanActor(value) {
+    return isRecord(value) && value.type === 'human' && typeof value.id === 'string' && optionalString(value.displayName);
+}
+function isRevocationActor(value) {
+    return isRecord(value) && (value.type === 'human' || value.type === 'system') && typeof value.id === 'string' && optionalString(value.displayName);
+}
+function isGrantAudit(value) {
+    return isRecord(value) && typeof value.creationReason === 'string' && typeof value.approvedScopeSummary === 'string';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function optionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function readString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function readNullableString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' ? value : Number(value);
+}
+function isIsoDate(value) {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function missing(message) {
+    return { ok: false, error: { code: 'not_found', message } };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}
+function fail(message, cause, code = 'validation_failed') {
+    const error = { code, message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}

package/dist/runs/run-service.js

@@ -8,6 +8,7 @@ import { AllowlistedApplyProgressCommandExecutor } from '../workflows/command-al
 import { RunRepository, } from './repositories/runs.js';
 import { buildRunInsights, buildRunOperatorResumePlan } from './run-insights.js';
 import { buildResumeAfterApprovalResult } from './resume-after-approval-result.js';
+import { grantEvaluationPayload, TaskScopedCommandGrantService } from './task-scoped-command-grant-service.js';
 const preflightSafety = {
     operationExecuted: false,
     executorInvoked: false,
@@ -28,8 +29,10 @@ const resumeGateSafety = {
 };
 export class RunService {
     runs;
+    taskScopedCommandGrants;
     constructor(database) {
         this.runs = new RunRepository(database);
+        this.taskScopedCommandGrants = new TaskScopedCommandGrantService(database);
     }
     createRun(input) {
         return this.runs.create({ ...input, phase: canonicalRunPhase(input.workflow, input.phase) ?? input.phase });
@@ -164,6 +167,9 @@ export class RunService {
     resolveApproval(input) {
         return this.runs.resolveApproval(input);
     }
+    taskScopedCommandGrantService() {
+        return this.taskScopedCommandGrants;
+    }
     abandonReservedOperationAttempt(input) {
         return this.runs.abandonOperationAttempt(input);
     }
@@ -358,6 +364,8 @@ export class RunService {
                 requestedOperation: operationMetadata(resolved.value),
                 decisionEventId: permission.value.event.id,
                 approvalId: permission.value.approval?.id ?? null,
+                authorizationMode: permission.value.decision.authorizationMode ?? null,
+                explicitRequestAudit: (permission.value.decision.explicitRequestAudit ?? null),
                 plan: plan,
                 workspaceStrategy: workspaceStrategy,
                 ...(sandboxDecision === undefined ? {} : { sandboxDecision: sandboxDecision }),
@@ -390,6 +398,8 @@ export class RunService {
         const audit = { permissionEventId: event.id, planEventId: planEvent.id };
         if (approval !== undefined)
             audit.approvalId = approval.id;
+        if (decision.explicitRequestAudit !== undefined)
+            audit.explicitRequestAudit = decision.explicitRequestAudit;
         const sandbox = plan.sandbox;
         const sandboxRejected = sandbox?.decision === 'rejected';
         const sandboxReason = sandboxRejected ? [{ code: sandbox.reason ?? 'sandbox_boundary', message: sandbox.audit.validationSummary }] : [];
@@ -398,6 +408,7 @@ export class RunService {
             permissionEventId: event.id,
             planEventId: planEvent.id,
             ...(approval === undefined ? {} : { approvalId: approval.id }),
+            ...(decision.explicitRequestAudit === undefined ? {} : { explicitRequestAudit: decision.explicitRequestAudit }),
         });
         return {
             ok: true,
@@ -766,6 +777,8 @@ export class RunService {
                         riskReasonCodes: reusedDecision.riskReasonCodes ?? [],
                         boundary: (reusedDecision.boundary ?? null),
                         auditEvidence: reusedDecision.auditEvidence ?? [],
+                        explicitRequestAudit: (reusedDecision.explicitRequestAudit ?? null),
+                        authorizationMode: reusedDecision.authorizationMode ?? (reusedDecision.decision === 'allow' && decision.decision === 'ask' ? 'approval-reuse' : null),
                         requiresHumanApproval: reusedDecision.decision === 'ask',
                         approvalStatus: prior.value.approval.status,
                         reusedApprovalId: prior.value.approval.id,
@@ -781,6 +794,44 @@ export class RunService {
                     : { ok: false, error: event.error };
             }
         }
+        const grantAuthorization = decision.decision === 'ask' ? this.taskScopedCommandGrants.tryAuthorizeAsk({ run: run.value, request: inputWithRunContext, baseDecision: decision }) : undefined;
+        if (grantAuthorization !== undefined) {
+            if (!grantAuthorization.ok)
+                return grantAuthorization;
+            if (grantAuthorization.value.authorized) {
+                const grantedDecision = grantAuthorization.value.decision;
+                const event = this.runs.appendEvent({
+                    runId: inputWithRunContext.runId,
+                    kind: 'permission-decision',
+                    title: `Permission ${grantedDecision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
+                    payload: {
+                        runId: inputWithRunContext.runId,
+                        category: inputWithRunContext.category,
+                        operation: inputWithRunContext.operation,
+                        workflow: inputWithRunContext.workflow ?? null,
+                        phase: inputWithRunContext.phase ?? null,
+                        requestedOperation: operationMetadata(inputWithRunContext),
+                        agent,
+                        decision: grantedDecision.decision,
+                        reasons: [{ code: grantedDecision.reason, message: grantedDecision.message }],
+                        riskTier: grantedDecision.riskTier ?? null,
+                        riskReasonCodes: grantedDecision.riskReasonCodes ?? [],
+                        boundary: (grantedDecision.boundary ?? null),
+                        auditEvidence: grantedDecision.auditEvidence ?? [],
+                        explicitRequestAudit: (grantedDecision.explicitRequestAudit ?? null),
+                        authorizationMode: grantedDecision.authorizationMode ?? null,
+                        requiresHumanApproval: false,
+                        approvalStatus: 'not-required',
+                        grantEvaluation: grantEvaluationPayload(grantAuthorization.value.evaluation),
+                        grantUseEventId: grantAuthorization.value.event.id,
+                        timestamp,
+                    },
+                    relatedType: 'task-scoped-command-grant',
+                    relatedId: grantAuthorization.value.grant.id,
+                });
+                return event.ok ? { ok: true, value: { decision: grantedDecision, event: event.value } } : { ok: false, error: event.error };
+            }
+        }
         const event = this.runs.appendEvent({
             runId: inputWithRunContext.runId,
             kind: 'permission-decision',
@@ -799,8 +850,11 @@ export class RunService {
                 riskReasonCodes: decision.riskReasonCodes ?? [],
                 boundary: (decision.boundary ?? null),
                 auditEvidence: decision.auditEvidence ?? [],
+                explicitRequestAudit: (decision.explicitRequestAudit ?? null),
+                authorizationMode: decision.authorizationMode ?? null,
                 requiresHumanApproval: decision.decision === 'ask',
                 approvalStatus: decision.decision === 'ask' ? 'pending' : 'not-required',
+                ...(grantAuthorization === undefined ? {} : { grantEvaluation: grantEvaluationPayload(grantAuthorization.value.evaluation) }),
                 timestamp,
             },
             relatedType: 'permission',
@@ -881,6 +935,7 @@ export class RunService {
                 permissionEventId: audit.permissionEventId,
                 planEventId: audit.planEventId,
                 approvalId: audit.approvalId ?? null,
+                explicitRequestAudit: (audit.explicitRequestAudit ?? null),
                 executorInvoked: false,
                 operationExecuted: false,
                 timestamp: new Date().toISOString(),
@@ -1215,6 +1270,14 @@ function operationMetadata(input) {
         metadata.phase = input.phase;
     if (input.agentId !== undefined)
         metadata.agentId = input.agentId;
+    if (input.taskFingerprint !== undefined)
+        metadata.taskFingerprint = input.taskFingerprint;
+    if (input.commandId !== undefined)
+        metadata.commandId = input.commandId;
+    if (input.cwd !== undefined)
+        metadata.cwd = input.cwd;
+    if (input.targetPaths !== undefined)
+        metadata.targetPaths = input.targetPaths;
     if (input.destructive !== undefined)
         metadata.destructive = input.destructive;
     if (input.external !== undefined)
@@ -1223,6 +1286,10 @@ function operationMetadata(input) {
         metadata.privileged = input.privileged;
     if (input.ambiguous !== undefined)
         metadata.ambiguous = input.ambiguous;
+    if (input.providerConfigMutation !== undefined)
+        metadata.providerConfigMutation = input.providerConfigMutation;
+    if (input.globalConfigMutation !== undefined)
+        metadata.globalConfigMutation = input.globalConfigMutation;
     if (input.input !== undefined)
         metadata.input = input.input;
     return metadata;
@@ -1253,7 +1320,22 @@ function operationMetadataCompatible(preflightOperation, requestedOperation) {
         return jsonEqual(preflightOperation, requestedOperation);
     if (preflightOperation.category !== requestedOperation.category || preflightOperation.name !== requestedOperation.name)
         return false;
-    const strictKeys = ['workspaceRoot', 'targetPath', 'providerToolName', 'sandboxStrategy', 'destructive', 'external', 'privileged', 'ambiguous'];
+    const strictKeys = [
+        'workspaceRoot',
+        'targetPath',
+        'providerToolName',
+        'sandboxStrategy',
+        'taskFingerprint',
+        'commandId',
+        'cwd',
+        'targetPaths',
+        'destructive',
+        'external',
+        'privileged',
+        'ambiguous',
+        'providerConfigMutation',
+        'globalConfigMutation',
+    ];
     for (const key of strictKeys) {
         if (key in preflightOperation && key in requestedOperation && !jsonEqual(preflightOperation[key], requestedOperation[key]))
             return false;
@@ -1336,6 +1418,14 @@ function operationFromPendingExecution(payload) {
         operation.phase = requested.phase;
     if (typeof requested.agentId === 'string')
         operation.agentId = requested.agentId;
+    if (typeof requested.taskFingerprint === 'string')
+        operation.taskFingerprint = requested.taskFingerprint;
+    if (typeof requested.commandId === 'string')
+        operation.commandId = requested.commandId;
+    if (typeof requested.cwd === 'string')
+        operation.cwd = requested.cwd;
+    if (Array.isArray(requested.targetPaths) && requested.targetPaths.every((item) => typeof item === 'string'))
+        operation.targetPaths = requested.targetPaths;
     if (typeof requested.destructive === 'boolean')
         operation.destructive = requested.destructive;
     if (typeof requested.external === 'boolean')