vgxness 1.8.0 → 1.9.1

package/dist/runs/run-service.js

@@ -233,22 +233,25 @@ export class RunService {
         };
     }
     planOperationExecution(input) {
-        const permission = this.evaluatePermissionForRun(input);
+        const resolved = this.buildPermissionContextForRun(input);
+        if (!resolved.ok)
+            return resolved;
+        const permission = this.evaluatePermissionForRun(resolved.value);
         if (!permission.ok)
             return permission;
         const plan = planExecutionIsolation({
-            operation: input,
+            operation: resolved.value,
             decision: permission.value.decision,
-            ...(input.gitBoundaryInspector === undefined ? {} : { gitBoundaryInspector: input.gitBoundaryInspector }),
+            ...(resolved.value.gitBoundaryInspector === undefined ? {} : { gitBoundaryInspector: resolved.value.gitBoundaryInspector }),
         });
         const sandboxDecision = sandboxDecisionSummary(plan.sandbox);
         const planEvent = this.runs.appendEvent({
-            runId: input.runId,
+            runId: resolved.value.runId,
             kind: 'execution-plan',
-            title: `Execution plan: ${input.category} ${input.operation}`,
+            title: `Execution plan: ${resolved.value.category} ${resolved.value.operation}`,
             payload: {
-                runId: input.runId,
-                requestedOperation: operationMetadata(input),
+                runId: resolved.value.runId,
+                requestedOperation: operationMetadata(resolved.value),
                 decisionEventId: permission.value.event.id,
                 approvalId: permission.value.approval?.id ?? null,
                 plan: plan,
@@ -262,17 +265,20 @@ export class RunService {
                 timestamp: new Date().toISOString(),
             },
             relatedType: 'operation',
-            relatedId: input.operation,
+            relatedId: resolved.value.operation,
         });
         if (!planEvent.ok)
             return { ok: false, error: planEvent.error };
         return { ok: true, value: { ...permission.value, plan, planEvent: planEvent.value } };
     }
     preflightOperation(input) {
-        const metadataValidation = this.validateVgxManagedPreflightMetadata(input);
+        const resolved = this.buildPermissionContextForRun(input);
+        if (!resolved.ok)
+            return resolved;
+        const metadataValidation = this.validateVgxManagedPreflightMetadata(resolved.value);
         if (!metadataValidation.ok)
             return metadataValidation;
-        const planned = this.planOperationExecution(input);
+        const planned = this.planOperationExecution(resolved.value);
         if (!planned.ok)
             return planned;
         const { decision, event, approval, plan, planEvent } = planned.value;
@@ -283,7 +289,7 @@ export class RunService {
         const sandboxRejected = sandbox?.decision === 'rejected';
         const sandboxReason = sandboxRejected ? [{ code: sandbox.reason ?? 'sandbox_boundary', message: sandbox.audit.validationSummary }] : [];
         const outcome = sandboxRejected ? 'blocked' : preflightOutcome(decision);
-        this.appendPreflightAuditEvent(input, outcome, {
+        this.appendPreflightAuditEvent(resolved.value, outcome, {
             permissionEventId: event.id,
             planEventId: planEvent.id,
             ...(approval === undefined ? {} : { approvalId: approval.id }),
@@ -313,14 +319,14 @@ export class RunService {
         const details = this.runs.getDetails(approval.value.runId);
         if (!details.ok)
             return details;
-        const permissionEvent = details.value.events.find((event) => event.id === approval.value.decisionEventId);
+        const pendingExecutionEvent = details.value.events.find((event) => isPendingExecutionEventForApproval(event, approval.value.id));
+        if (pendingExecutionEvent === undefined)
+            return validationFailure('Approved approval has no resumable pending operation event');
+        const permissionEvent = permissionEventForPendingExecution(details.value, approval.value, pendingExecutionEvent);
         if (permissionEvent === undefined)
             return validationFailure('Approval permission-decision event is missing');
         if (!isAskPermissionEvent(permissionEvent))
             return validationFailure('Approval is not linked to an ask permission decision');
-        const pendingExecutionEvent = details.value.events.find((event) => isPendingExecutionEventForApproval(event, approval.value.id));
-        if (pendingExecutionEvent === undefined)
-            return validationFailure('Approved approval has no resumable pending operation event');
         const operation = operationFromPendingExecution(pendingExecutionEvent.payload);
         if (operation === undefined)
             return validationFailure('Pending operation metadata is incomplete and cannot be resumed');
@@ -559,14 +565,19 @@ export class RunService {
             : { ok: false, error: executionEvent.error };
     }
     evaluatePermissionForRun(input) {
-        const run = this.runs.getById(input.runId);
+        const resolved = this.buildPermissionContextForRun(input);
+        if (!resolved.ok)
+            return resolved;
+        const inputWithRunContext = resolved.value;
+        const run = this.runs.getById(inputWithRunContext.runId);
         if (!run.ok)
             return { ok: false, error: run.error };
-        const decision = evaluatePermission(input);
+        const contextConflict = workflowConflictDecision(inputWithRunContext, run.value.workflow);
+        const decision = contextConflict ?? evaluatePermission(inputWithRunContext);
         const timestamp = new Date().toISOString();
-        const agent = input.agent === undefined ? { id: run.value.selectedAgentId } : { id: input.agent.id, name: input.agent.name, mode: input.agent.mode };
+        const agent = inputWithRunContext.agent === undefined ? { id: run.value.selectedAgentId } : { id: inputWithRunContext.agent.id, name: inputWithRunContext.agent.name, mode: inputWithRunContext.agent.mode };
         if (decision.decision === 'ask') {
-            const prior = this.findMatchingApproval(input, agent, input.reusePendingApproval === true);
+            const prior = this.findMatchingApproval(inputWithRunContext, agent, inputWithRunContext.reusePendingApproval === true);
             if (!prior.ok)
                 return prior;
             if (prior.value !== undefined) {
@@ -581,17 +592,23 @@ export class RunService {
                             message: `Previously ${prior.value.approval.status} approval ${prior.value.approval.id} denies this exact operation.`,
                         };
                 const event = this.runs.appendEvent({
-                    runId: input.runId,
+                    runId: inputWithRunContext.runId,
                     kind: 'permission-decision',
-                    title: `Permission ${reusedDecision.decision}: ${input.category} ${input.operation}`,
+                    title: `Permission ${reusedDecision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
                     payload: {
-                        runId: input.runId,
-                        category: input.category,
-                        operation: input.operation,
-                        requestedOperation: operationMetadata(input),
+                        runId: inputWithRunContext.runId,
+                        category: inputWithRunContext.category,
+                        operation: inputWithRunContext.operation,
+                        workflow: inputWithRunContext.workflow ?? null,
+                        phase: inputWithRunContext.phase ?? null,
+                        requestedOperation: operationMetadata(inputWithRunContext),
                         agent,
                         decision: reusedDecision.decision,
                         reasons: [{ code: reusedDecision.reason, message: reusedDecision.message }],
+                        riskTier: reusedDecision.riskTier ?? null,
+                        riskReasonCodes: reusedDecision.riskReasonCodes ?? [],
+                        boundary: (reusedDecision.boundary ?? null),
+                        auditEvidence: reusedDecision.auditEvidence ?? [],
                         requiresHumanApproval: reusedDecision.decision === 'ask',
                         approvalStatus: prior.value.approval.status,
                         reusedApprovalId: prior.value.approval.id,
@@ -608,29 +625,35 @@ export class RunService {
             }
         }
         const event = this.runs.appendEvent({
-            runId: input.runId,
+            runId: inputWithRunContext.runId,
             kind: 'permission-decision',
-            title: `Permission ${decision.decision}: ${input.category} ${input.operation}`,
+            title: `Permission ${decision.decision}: ${inputWithRunContext.category} ${inputWithRunContext.operation}`,
             payload: {
-                runId: input.runId,
-                category: input.category,
-                operation: input.operation,
-                requestedOperation: operationMetadata(input),
+                runId: inputWithRunContext.runId,
+                category: inputWithRunContext.category,
+                operation: inputWithRunContext.operation,
+                workflow: inputWithRunContext.workflow ?? null,
+                phase: inputWithRunContext.phase ?? null,
+                requestedOperation: operationMetadata(inputWithRunContext),
                 agent,
                 decision: decision.decision,
                 reasons: [{ code: decision.reason, message: decision.message }],
+                riskTier: decision.riskTier ?? null,
+                riskReasonCodes: decision.riskReasonCodes ?? [],
+                boundary: (decision.boundary ?? null),
+                auditEvidence: decision.auditEvidence ?? [],
                 requiresHumanApproval: decision.decision === 'ask',
                 approvalStatus: decision.decision === 'ask' ? 'pending' : 'not-required',
                 timestamp,
             },
             relatedType: 'permission',
-            relatedId: input.category,
+            relatedId: inputWithRunContext.category,
         });
         if (!event.ok)
             return { ok: false, error: event.error };
         if (decision.decision !== 'ask')
             return { ok: true, value: { decision, event: event.value } };
-        const approval = this.runs.createApproval({ runId: input.runId, decisionEventId: event.value.id });
+        const approval = this.runs.createApproval({ runId: inputWithRunContext.runId, decisionEventId: event.value.id });
         return approval.ok ? { ok: true, value: { decision, event: event.value, approval: approval.value } } : { ok: false, error: approval.error };
     }
     validateVgxManagedPreflightMetadata(input) {
@@ -668,6 +691,19 @@ export class RunService {
         }
         return { ok: true, value: undefined };
     }
+    buildPermissionContextForRun(input) {
+        const run = this.runs.getById(input.runId);
+        if (!run.ok)
+            return { ok: false, error: run.error };
+        const phase = input.phase ?? canonicalRunPhase(run.value.phase);
+        const merged = {
+            ...input,
+            workflow: input.workflow ?? run.value.workflow,
+            ...(phase === undefined ? {} : { phase }),
+            agentId: input.agentId ?? input.agent?.id ?? run.value.selectedAgentId,
+        };
+        return { ok: true, value: merged };
+    }
     appendPreflightAuditEvent(input, outcome, audit) {
         const run = this.runs.getById(input.runId);
         if (!run.ok || !isVgxManagedWorkflow(run.value.workflow) || !isRiskyPermissionCategory(input.category))
@@ -774,6 +810,23 @@ function isVgxManagedWorkflow(workflow) {
     const normalized = workflow.toLowerCase();
     return normalized === 'sdd' || normalized.startsWith('sdd-') || normalized.includes('sdd') || normalized.includes('vgx');
 }
+function workflowConflictDecision(input, runWorkflow) {
+    if (input.workflow === undefined || input.workflow === runWorkflow)
+        return undefined;
+    const eitherSdd = input.workflow === 'sdd' || runWorkflow === 'sdd' || input.workflow.includes('sdd') || runWorkflow.includes('sdd');
+    if (!eitherSdd)
+        return undefined;
+    return {
+        decision: 'ask',
+        category: input.category,
+        operation: input.operation,
+        reason: 'workflow_context',
+        message: `Explicit workflow ${input.workflow} conflicts with run workflow ${runWorkflow}; human validation is required before crossing SDD/non-SDD context.`,
+        workflow: input.workflow,
+        warnings: [`workflow-conflict:${runWorkflow}->${input.workflow}`],
+        auditEvidence: [`runWorkflow:${runWorkflow}`, `explicitWorkflow:${input.workflow}`],
+    };
+}
 function executionPayload(operation, executorName, status, extra) {
     return {
         status,
@@ -830,6 +883,11 @@ function resumeGateManualNextCommands(approval, details, operation) {
         commands.push(`Review operation manually: ${operation.category} ${operation.operation}`);
     return commands;
 }
+function canonicalRunPhase(phase) {
+    if (phase === undefined || phase.trim().length === 0)
+        return undefined;
+    return phase === 'apply' ? 'apply-progress' : phase;
+}
 function operationMetadata(input) {
     const metadata = { category: input.category, name: input.operation };
     if (input.workspaceRoot !== undefined)
@@ -840,6 +898,12 @@ function operationMetadata(input) {
         metadata.providerToolName = input.providerToolName;
     if (input.sandboxStrategy !== undefined)
         metadata.sandboxStrategy = input.sandboxStrategy;
+    if (input.workflow !== undefined)
+        metadata.workflow = input.workflow;
+    if (input.phase !== undefined)
+        metadata.phase = input.phase;
+    if (input.agentId !== undefined)
+        metadata.agentId = input.agentId;
     if (input.destructive !== undefined)
         metadata.destructive = input.destructive;
     if (input.external !== undefined)
@@ -859,7 +923,7 @@ function approvalEventMatches(event, input, requestedOperation, agent) {
         return false;
     if (event.payload.category !== input.category || event.payload.operation !== input.operation)
         return false;
-    if (!jsonEqual(event.payload.requestedOperation, requestedOperation))
+    if (!operationMetadataCompatible(event.payload.requestedOperation, requestedOperation))
         return false;
     if (!jsonEqual(event.payload.agent, agent))
         return false;
@@ -869,7 +933,23 @@ function isMatchingPreflightPlanEvent(event, operation) {
     if (event.kind !== 'execution-plan' || !isObject(event.payload))
         return false;
     const requestedOperation = event.payload.requestedOperation;
-    return requestedOperation !== undefined && jsonEqual(requestedOperation, operationMetadata(operation));
+    return requestedOperation !== undefined && operationMetadataCompatible(requestedOperation, operationMetadata(operation));
+}
+function operationMetadataCompatible(preflightOperation, requestedOperation) {
+    if (preflightOperation === undefined || requestedOperation === undefined)
+        return jsonEqual(preflightOperation, requestedOperation);
+    if (!isObject(preflightOperation) || !isObject(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'];
+    for (const key of strictKeys) {
+        if (key in preflightOperation && key in requestedOperation && !jsonEqual(preflightOperation[key], requestedOperation[key]))
+            return false;
+    }
+    if ('input' in preflightOperation && 'input' in requestedOperation && !jsonEqual(preflightOperation.input, requestedOperation.input))
+        return false;
+    return true;
 }
 function preflightPlanStatus(event) {
     if (!isObject(event.payload))
@@ -919,6 +999,12 @@ function isAskPermissionEvent(event) {
 function isPendingExecutionEventForApproval(event, approvalId) {
     return (event.kind === 'operation-execution' && isObject(event.payload) && event.payload.status === 'pending-approval' && event.payload.approvalId === approvalId);
 }
+function permissionEventForPendingExecution(details, approval, pendingExecutionEvent) {
+    const decisionEventId = isObject(pendingExecutionEvent.payload) && typeof pendingExecutionEvent.payload.decisionEventId === 'string'
+        ? pendingExecutionEvent.payload.decisionEventId
+        : approval.decisionEventId;
+    return details.events.find((event) => event.id === decisionEventId) ?? details.events.find((event) => event.id === approval.decisionEventId);
+}
 function operationFromPendingExecution(payload) {
     if (!isObject(payload))
         return undefined;
@@ -955,10 +1041,18 @@ function isObject(value) {
 function isPermissionCategory(value) {
     return (value === 'read' ||
         value === 'edit' ||
+        value === 'implementation-edit' ||
+        value === 'spec-write' ||
+        value === 'design-write' ||
+        value === 'task-write' ||
         value === 'shell' ||
+        value === 'test-run' ||
+        value === 'install' ||
         value === 'network' ||
         value === 'git' ||
+        value === 'git-write' ||
         value === 'memory' ||
+        value === 'memory-write' ||
         value === 'external-directory' ||
         value === 'provider-tool' ||
         value === 'secrets');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {