vgxness 1.5.0 → 1.5.2

package/dist/mcp/validation.js

@@ -66,6 +66,8 @@ export function validateVgxMcpToolCall(call) {
             return validationSuccess(tool.value, validateSessionCloseInput(input, tool.value));
         case 'vgxness_session_restore':
             return validationSuccess(tool.value, validateSessionRestoreInput(input, tool.value));
+        case 'vgxness_context_cockpit':
+            return validationSuccess(tool.value, validateContextCockpitInput(input, tool.value));
         case 'vgxness_agent_resolve':
             return validationSuccess(tool.value, validateAgentResolveInput(input, tool.value));
         case 'vgxness_agent_activate':
@@ -185,7 +187,7 @@ function validateProviderHealthInput(input, tool) {
         return scope;
     if (scope.value !== undefined)
         result.scope = scope.value;
-    const providerAdapter = readOptionalOneOf(record.value, 'providerAdapter', ['opencode'], tool);
+    const providerAdapter = readOptionalOneOf(record.value, 'providerAdapter', ['opencode', 'claude'], tool);
     if (!providerAdapter.ok)
         return providerAdapter;
     if (providerAdapter.value !== undefined)
@@ -234,6 +236,26 @@ function validateSddCockpitInput(input, tool) {
         return record;
     return readProjectAndChange(record.value, tool);
 }
+function validateContextCockpitInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'directory', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const directory = readOptionalNonEmptyString(record.value, 'directory', tool);
+    if (!directory.ok)
+        return directory;
+    if (directory.value !== undefined)
+        result.directory = directory.value;
+    if (record.value.limit !== undefined) {
+        if (typeof record.value.limit !== 'number' || !Number.isSafeInteger(record.value.limit) || record.value.limit < 1 || record.value.limit > 100)
+            return validationFailure('limit must be an integer between 1 and 100', tool);
+        result.limit = record.value.limit;
+    }
+    return { ok: true, value: result };
+}
 function readProjectAndChange(record, tool) {
     const project = readNonEmptyString(record, 'project', tool);
     if (!project.ok)

package/dist/memory/memory-service.js

@@ -50,6 +50,54 @@ export class MemoryService {
         const result = this.observations.searchPreviews(filters);
         return this.record(result, context, { operation: 'observation.search', targetType: 'observation', topicKey: filters.topicKey });
     }
+    /** Read memory previews without writing provenance traces. */
+    searchObservationPreviewsNoTrace(filters) {
+        return this.observations.searchPreviews(filters);
+    }
+    /** Read compact current context without writing traces or mutating durable state. */
+    getContextCockpit(input) {
+        const limit = normalizeContextLimit(input.limit);
+        const memories = this.searchObservationPreviewsNoTrace({ project: input.project, limit });
+        if (!memories.ok)
+            return { ok: false, error: memories.error };
+        const session = this.restoreSession(input.directory === undefined ? { project: input.project } : { project: input.project, directory: input.directory });
+        if (!session.ok && session.error.code !== 'not_found')
+            return { ok: false, error: session.error };
+        const latestRestorableSession = session.ok ? session.value : undefined;
+        const newestMemoryUpdatedAt = memories.value[0]?.updatedAt;
+        const latestSessionEndedAt = latestRestorableSession?.endedAt;
+        const stale = latestRestorableSession === undefined || (newestMemoryUpdatedAt !== undefined && latestSessionEndedAt !== undefined && newestMemoryUpdatedAt > latestSessionEndedAt);
+        const staleness = {
+            stale,
+            reason: latestRestorableSession === undefined ? 'no-restorable-session' : stale ? 'memory-newer-than-session' : 'current',
+            ...(newestMemoryUpdatedAt === undefined ? {} : { newestMemoryUpdatedAt }),
+            ...(latestSessionEndedAt === undefined ? {} : { latestSessionEndedAt }),
+        };
+        return {
+            ok: true,
+            value: {
+                version: 1,
+                kind: 'context-cockpit',
+                project: input.project,
+                ...(input.directory === undefined ? {} : { directory: input.directory }),
+                ...(latestRestorableSession === undefined ? {} : { latestRestorableSession }),
+                memoryPreviews: memories.value,
+                staleness,
+                optionalSectionsOmitted: ['sdd', 'runs'],
+                notes: ['SDD and run summaries are omitted because safe no-trace metadata-only aggregation is not part of this cockpit path yet.'],
+                safety: {
+                    readOnly: true,
+                    recordsTraces: false,
+                    mutatesSessions: false,
+                    mutatesMemories: false,
+                    mutatesArtifacts: false,
+                    mutatesRuns: false,
+                    writesProviderConfig: false,
+                    mutatesRepository: false,
+                },
+            },
+        };
+    }
     listObservationRevisions(id, context) {
         const result = this.observations.listRevisions(id);
         return this.record(result, context, { operation: 'observation.revisions.list', targetType: 'observation', targetId: id });
@@ -113,6 +161,10 @@ export class MemoryService {
         const result = this.artifacts.listByTopicPrefix(project, topicPrefix);
         return this.record(result, context, { operation: 'artifact.list', targetType: 'artifact', topicKey: topicPrefix });
     }
+    /** Read artifacts for read-only/status projections without writing provenance traces. */
+    listArtifactsByTopicPrefixNoTrace(project, topicPrefix) {
+        return this.artifacts.listByTopicPrefix(project, topicPrefix);
+    }
     close() {
         this.database.close();
     }
@@ -140,3 +192,10 @@ class MemoryServiceTransactionRollback extends Error {
         super('Memory service transaction rolled back');
     }
 }
+function normalizeContextLimit(limit) {
+    if (limit === undefined)
+        return 5;
+    if (!Number.isFinite(limit))
+        return 5;
+    return Math.max(1, Math.min(100, Math.trunc(limit)));
+}

package/dist/memory/repositories/sessions.js

@@ -39,7 +39,7 @@ export class SessionRepository {
           AND summary IS NOT NULL
           AND TRIM(summary) <> ''
           AND (@directory IS NULL OR directory = @directory)
-        ORDER BY ended_at DESC
+        ORDER BY ended_at DESC, started_at DESC, id DESC
         LIMIT 1
       `)
                 .get({ project: input.project, directory: input.directory ?? null });

package/dist/sdd/sdd-workflow-service.js

@@ -21,7 +21,9 @@ export class SddWorkflowService {
         if (!validated.ok)
             return validated;
         const phases = this.getPhaseStatuses(validated.value.project, validated.value.change);
-        const readiness = getReadinessFromStatuses(validated.value.change, validated.value.phase, phases);
+        if (!phases.ok)
+            return phases;
+        const readiness = getReadinessFromStatuses(validated.value.change, validated.value.phase, phases.value);
         return {
             ok: true,
             value: {
@@ -36,20 +38,27 @@ export class SddWorkflowService {
         if (!validated.ok)
             return validated;
         const phases = this.getPhaseStatuses(validated.value.project, validated.value.change);
-        return statusFromPhases(validated.value.change, phases);
+        if (!phases.ok)
+            return phases;
+        return statusFromPhases(validated.value.change, phases.value);
     }
     getNext(input) {
         const validated = validateProjectAndChange(input.project, input.change);
         if (!validated.ok)
             return validated;
         const phases = this.getPhaseStatuses(validated.value.project, validated.value.change);
-        return ok(nextDecisionFromStatuses(validated.value.change, phases));
+        if (!phases.ok)
+            return phases;
+        return ok(nextDecisionFromStatuses(validated.value.change, phases.value));
     }
     getCockpit(input) {
         const validated = validateProjectAndChange(input.project, input.change);
         if (!validated.ok)
             return validated;
-        const phases = this.getPhaseStatuses(validated.value.project, validated.value.change);
+        const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
+        if (!snapshot.ok)
+            return snapshot;
+        const phases = snapshot.value.phases;
         const next = nextDecisionFromStatuses(validated.value.change, phases);
         const cockpitPhases = phases.map((phaseStatus) => {
             const readiness = {
@@ -57,9 +66,7 @@ export class SddWorkflowService {
                 phase: phaseStatus.phase,
                 ...getReadinessFromStatuses(validated.value.change, phaseStatus.phase, phases),
             };
-            const artifact = phaseStatus.present
-                ? this.artifactSummaryForPhase(validated.value.project, validated.value.change, phaseStatus.phase, phaseStatus.topicKey)
-                : undefined;
+            const artifact = phaseStatus.present ? cockpitArtifactSummaryFromSnapshotItem(phaseStatus) : undefined;
             const blockers = cockpitBlockersForPhase(phaseStatus, readiness);
             return {
                 phase: phaseStatus.phase,
@@ -100,6 +107,39 @@ export class SddWorkflowService {
         };
         return ok(cockpit);
     }
+    getGovernanceSnapshot(input) {
+        const validated = validateProjectAndChange(input.project, input.change);
+        if (!validated.ok)
+            return validated;
+        const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
+        if (!snapshot.ok)
+            return snapshot;
+        const phases = snapshot.value.phases;
+        const status = statusFromPhases(validated.value.change, phases);
+        if (!status.ok)
+            return status;
+        const warnings = [];
+        const artifacts = phases.flatMap((phase) => {
+            if (phase.artifact === undefined)
+                return [];
+            const envelope = normalizeSddArtifact(phase.artifact);
+            warnings.push(...envelope.warnings);
+            if ((input.payloadMode ?? 'compact') === 'compact') {
+                const compactArtifact = compactGovernanceArtifact(envelope.artifact);
+                return [
+                    {
+                        phase: phase.phase,
+                        topicKey: phase.topicKey,
+                        artifact: compactArtifact,
+                        envelope: { ...envelope, artifact: compactArtifact },
+                    },
+                ];
+            }
+            return [{ phase: phase.phase, topicKey: phase.topicKey, artifact: phase.artifact, envelope }];
+        });
+        const readiness = input.phase === undefined ? undefined : { change: validated.value.change, phase: input.phase, ...getReadinessFromStatuses(validated.value.change, input.phase, phases) };
+        return ok({ status: status.value, artifacts, ...(readiness === undefined ? {} : { readiness }), warnings });
+    }
     saveArtifact(input) {
         const validated = this.validatePhaseInput(input);
         if (!validated.ok)
@@ -161,12 +201,33 @@ export class SddWorkflowService {
         if (input.payloadMode !== 'compact')
             return artifact;
         const statuses = this.getPhaseStatuses(validated.value.project, validated.value.change);
-        return ok(compactArtifactProjection(artifact.value, validated.value.change, validated.value.phase, getReadinessFromStatuses(validated.value.change, validated.value.phase, statuses)));
+        if (!statuses.ok)
+            return statuses;
+        return ok(compactArtifactProjection(artifact.value, validated.value.change, validated.value.phase, getReadinessFromStatuses(validated.value.change, validated.value.phase, statuses.value)));
     }
     listArtifacts(input) {
         const validated = validateProjectAndChange(input.project, input.change);
         if (!validated.ok)
             return validated;
+        if (input.payloadMode === 'compact') {
+            const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
+            if (!snapshot.ok)
+                return snapshot;
+            return ok({
+                project: validated.value.project,
+                change: validated.value.change,
+                artifacts: snapshot.value.phases.flatMap((phase) => {
+                    if (phase.artifact === undefined)
+                        return [];
+                    return [compactArtifactProjection(phase.artifact, validated.value.change, phase.phase, getReadinessFromStatuses(validated.value.change, phase.phase, snapshot.value.phases))];
+                }),
+                fullRetrieval: {
+                    tool: 'vgxness_sdd_list_artifacts',
+                    payloadMode: 'verbose',
+                    input: { project: validated.value.project, change: validated.value.change },
+                },
+            });
+        }
         const listed = this.memory.listArtifactsByTopicPrefix(validated.value.project, `sdd/${validated.value.change}/`, this.context);
         if (!listed.ok)
             return listed;
@@ -174,22 +235,7 @@ export class SddWorkflowService {
         const artifacts = sddPhases
             .map((phase) => artifactsByTopicKey.get(sddTopicKey(validated.value.change, phase)))
             .filter((artifact) => artifact !== undefined);
-        if (input.payloadMode !== 'compact')
-            return ok({ project: validated.value.project, change: validated.value.change, artifacts });
-        const statuses = this.getPhaseStatuses(validated.value.project, validated.value.change);
-        return ok({
-            project: validated.value.project,
-            change: validated.value.change,
-            artifacts: artifacts.map((artifact) => {
-                const phase = isSddPhase(artifact.phase) ? artifact.phase : phaseFromTopicKey(validated.value.change, artifact.topicKey);
-                return compactArtifactProjection(artifact, validated.value.change, phase, getReadinessFromStatuses(validated.value.change, phase, statuses));
-            }),
-            fullRetrieval: {
-                tool: 'vgxness_sdd_list_artifacts',
-                payloadMode: 'verbose',
-                input: { project: validated.value.project, change: validated.value.change },
-            },
-        });
+        return ok({ project: validated.value.project, change: validated.value.change, artifacts });
     }
     validatePhaseInput(input) {
         const validated = validateProjectAndChange(input.project, input.change);
@@ -200,31 +246,38 @@ export class SddWorkflowService {
         return { ok: true, value: { ...validated.value, phase: input.phase } };
     }
     getPhaseStatuses(project, change) {
-        return sddPhases.map((phase) => {
+        const snapshot = this.loadPhaseSnapshot(project, change);
+        if (!snapshot.ok)
+            return snapshot;
+        return ok(snapshot.value.phases.map(({ artifact, acceptance, createdAt, updatedAt, warnings, ...status }) => status));
+    }
+    loadPhaseSnapshot(project, change) {
+        const listed = this.memory.listArtifactsByTopicPrefixNoTrace(project, `sdd/${change}/`);
+        if (!listed.ok)
+            return listed;
+        const artifactsByTopicKey = new Map(listed.value.map((artifact) => [artifact.topicKey, artifact]));
+        const phases = sddPhases.map((phase) => {
             const topicKey = sddTopicKey(change, phase);
-            const artifact = this.memory.getArtifact(project, topicKey, this.context);
-            if (!artifact.ok)
-                return { phase, topicKey, present: false, state: 'missing', accepted: false, legacy: false };
-            return phaseStatusFromArtifact(phase, topicKey, artifact.value);
+            const artifact = artifactsByTopicKey.get(topicKey);
+            if (artifact === undefined)
+                return { phase, topicKey, present: false, state: 'missing', accepted: false, legacy: false, warnings: [] };
+            const envelope = normalizeSddArtifact(artifact);
+            return {
+                phase,
+                topicKey,
+                present: true,
+                state: envelope.metadata.status,
+                accepted: envelope.metadata.status === 'accepted',
+                legacy: envelope.warnings.includes('legacy-artifact-defaulted-to-draft'),
+                artifactId: artifact.id,
+                artifact,
+                ...(envelope.metadata.acceptance === undefined ? {} : { acceptance: envelope.metadata.acceptance }),
+                createdAt: artifact.createdAt,
+                updatedAt: artifact.updatedAt,
+                warnings: envelope.warnings,
+            };
         });
-    }
-    artifactSummaryForPhase(project, change, phase, topicKey) {
-        const artifact = this.memory.getArtifact(project, topicKey, this.context);
-        if (!artifact.ok)
-            return undefined;
-        const envelope = normalizeSddArtifact(artifact.value);
-        return {
-            phase,
-            topicKey,
-            present: true,
-            accepted: envelope.metadata.status === 'accepted',
-            legacy: envelope.warnings.includes('legacy-artifact-defaulted-to-draft'),
-            state: envelope.metadata.status,
-            artifactId: artifact.value.id,
-            ...(envelope.metadata.acceptance === undefined ? {} : { acceptance: envelope.metadata.acceptance }),
-            createdAt: artifact.value.createdAt,
-            updatedAt: artifact.value.updatedAt,
-        };
+        return ok({ project, change, phases });
     }
 }
 export function nextDecisionFromStatuses(change, phases) {
@@ -336,18 +389,6 @@ function getReadinessFromStatuses(change, phase, phases) {
         blockedPrerequisites,
     };
 }
-function phaseStatusFromArtifact(phase, topicKey, artifact) {
-    const envelope = normalizeSddArtifact(artifact);
-    return {
-        phase,
-        topicKey,
-        present: true,
-        state: envelope.metadata.status,
-        accepted: envelope.metadata.status === 'accepted',
-        legacy: envelope.warnings.includes('legacy-artifact-defaulted-to-draft'),
-        artifactId: artifact.id,
-    };
-}
 function compactArtifactProjection(artifact, change, phase, readiness) {
     const envelope = normalizeSddArtifact(artifact);
     const summary = summarizePayloadContent(artifact.content);
@@ -370,6 +411,35 @@ function compactArtifactProjection(artifact, change, phase, readiness) {
         updatedAt: artifact.updatedAt,
     };
 }
+function cockpitArtifactSummaryFromSnapshotItem(item) {
+    if (item.artifact === undefined || item.artifactId === undefined || item.createdAt === undefined || item.updatedAt === undefined)
+        return undefined;
+    return {
+        phase: item.phase,
+        topicKey: item.topicKey,
+        present: true,
+        accepted: item.accepted === true,
+        legacy: item.legacy === true,
+        state: item.state ?? 'draft',
+        artifactId: item.artifactId,
+        ...(item.acceptance === undefined ? {} : { acceptance: item.acceptance }),
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+    };
+}
+function compactGovernanceArtifact(artifact) {
+    return {
+        id: artifact.id,
+        project: artifact.project,
+        topicKey: artifact.topicKey,
+        phase: artifact.phase,
+        observationId: artifact.observationId,
+        createdAt: artifact.createdAt,
+        updatedAt: artifact.updatedAt,
+        contentLength: artifact.content.length,
+        contentOmitted: true,
+    };
+}
 function cockpitBlockersForPhase(status, readiness) {
     const blockers = [];
     if (!status.present)

package/dist/setup/providers/claude-setup-adapter.js

@@ -4,17 +4,20 @@ export const claudeSetupAdapter = {
     id: 'claude',
     displayName: 'Claude',
     supportLevel: 'preview-only',
-    capabilities: ['mcp-preview', 'manual-guidance'],
-    targets: [{ kind: 'manual', label: 'Claude MCP config snippet', writableBySetup: false }],
+    capabilities: ['mcp-preview', 'mcp-install-plan', 'agent-preview', 'doctor', 'manual-guidance'],
+    targets: [
+        { kind: 'project-config', label: 'Project .mcp.json', path: '.mcp.json', writableBySetup: false },
+        { kind: 'project-config', label: 'Project Claude agents', path: '.claude/agents/*.md', writableBySetup: false },
+    ],
     getStatus(context) {
         return {
             providerId: 'claude',
             status: 'preview-only',
-            summary: 'Claude setup is preview-only with manual MCP guidance.',
+            summary: 'Claude setup supports project-local read-only planning for .mcp.json and .claude/agents/*.md; confirmed writes are handled by guarded install flows.',
             evidence: context.databasePath !== undefined
                 ? ['Claude MCP preview can be generated from the selected database path.']
                 : ['Claude MCP preview uses a placeholder until a database path is selected.'],
-            guidance: ['Copy snippets manually after reviewing them. The TUI does not install or apply Claude config.'],
+            guidance: ['Review the Claude plan before any write. VGXNESS never writes ~/.claude.json, CLAUDE.md, or .claude/CLAUDE.md and does not execute/install Claude Code.'],
             actions: [
                 {
                     id: 'claude-manual-guidance',