vgxness 1.20.4 → 1.20.6

package/dist/sdd/sdd-continuation-plan.js

@@ -1,265 +1 @@
-export function sddContinuationPlanFrom(input) {
-    const nextPhase = input.next.nextPhase;
-    const dbFlag = continuationDbFlag(input.explicitDatabasePath);
-    const inspectCommand = `vgxness sdd cockpit --project ${input.project} --change ${input.next.change} --json${dbFlag}`;
-    const suggestedCommand = suggestedContinuationCommand(input.project, input.next, inspectCommand, dbFlag);
-    const blockerGuidance = input.next.blockerGuidance ?? [];
-    const blockerActions = blockerGuidance.map((blocker) => continuationBlockerAction(input.project, input.next.change, blocker, dbFlag));
-    const recommendedActions = continuationRecommendedActions(input.project, input.next, blockerGuidance);
-    const advice = continuationAdvice(input.next, blockerGuidance);
-    const relatedRunContext = relatedRunContextView(input.project, input.relatedRunContext, dbFlag);
-    return {
-        kind: 'sdd-continuation-plan',
-        project: input.project,
-        change: input.next.change,
-        status: input.next.status,
-        ...(nextPhase === undefined ? {} : { nextPhase }),
-        ...(input.cockpit.actionablePhase === undefined ? {} : { actionablePhase: input.cockpit.actionablePhase }),
-        recommendedAction: input.cockpit.recommendedAction,
-        reason: input.next.reason,
-        suggestedCommand,
-        inspectCommand,
-        advice,
-        blockerActions,
-        recommendedActions,
-        ...(relatedRunContext === undefined ? {} : { relatedRunContext }),
-        ...(input.explicitDatabasePath === undefined ? {} : { explicitDatabasePath: input.explicitDatabasePath }),
-        safety: [
-            'Read-only planner: this command does not execute providers or mutate SDD artifacts, runs, provider config, or openspec/ files.',
-            'Human acceptance remains explicit; artifact presence is not treated as acceptance.',
-            'Continue SDD phases in OpenCode conversation through VGXNESS MCP and hidden SDD subagents; the removed code runtime is not a CLI fallback.',
-            'No openspec/ files are created or written.',
-        ],
-    };
-}
-function continuationAdvice(next, blockerGuidance) {
-    const advice = [];
-    if (next.nextPhase === 'proposal' || hasProposalMissingBlocker(next, blockerGuidance))
-        advice.push(proposalQuestionRoundAdvice(next.change));
-    if (next.nextPhase === 'apply-progress')
-        advice.push(reviewWorkloadGuardAdvice(next.change));
-    return advice;
-}
-function hasProposalMissingBlocker(next, blockerGuidance) {
-    return (blockerGuidance.some((blocker) => blocker.phase === 'proposal' && blocker.reason === 'missing') ||
-        next.missingArtifactTopicKeys.some((topicKey) => topicKey.endsWith('/proposal')));
-}
-function proposalQuestionRoundAdvice(change) {
-    return {
-        id: `sdd.${change}.advice.proposal-question-round`,
-        kind: 'proposal-question-round',
-        title: 'Run proposal question round when product clarity is missing',
-        message: 'Before drafting or accepting the proposal, run a product/business question round if clarity is still missing; this advice does not claim low clarity from metadata alone.',
-        readOnly: true,
-        advisoryOnly: true,
-        mutating: false,
-        providerExecution: false,
-        artifactMutation: false,
-        runCreation: false,
-        openspecWrite: false,
-        reason: 'Proposal work benefits from explicit business rules, product outcomes, edge cases, non-goals, and tradeoff decisions before proposal drafting or acceptance.',
-    };
-}
-function reviewWorkloadGuardAdvice(change) {
-    return {
-        id: `sdd.${change}.advice.review-workload-guard`,
-        kind: 'review-workload-guard',
-        title: 'Inspect Review Workload Forecast before apply',
-        message: 'Before apply, inspect tasks/Review Workload Forecast and ask for a delivery decision if risk is high, estimated changes exceed 400 lines, chained PRs are recommended, or a decision is pending.',
-        readOnly: true,
-        advisoryOnly: true,
-        mutating: false,
-        providerExecution: false,
-        artifactMutation: false,
-        runCreation: false,
-        openspecWrite: false,
-        reason: 'Apply work can exceed review budget; continuation advice must surface the guard without executing providers, mutating artifacts, creating runs, or writing openspec files.',
-    };
-}
-function continuationRecommendedActions(project, next, blockerGuidance) {
-    const actions = [inspectCockpitAction(project, next.change)];
-    if (next.status === 'runnable' && next.nextPhase !== undefined)
-        actions.push(draftPhaseAction(project, next.change, next.nextPhase, next.reason));
-    for (const blocker of blockerGuidance) {
-        const action = recommendedActionForBlocker(project, next.change, blocker);
-        if (action !== undefined)
-            actions.push(action);
-    }
-    return actions;
-}
-function inspectCockpitAction(project, change) {
-    return {
-        id: `sdd.${change}.inspect-cockpit`,
-        label: 'Inspect SDD cockpit',
-        title: 'Inspect SDD cockpit',
-        description: 'Read the current SDD cockpit/read model before choosing the next action.',
-        kind: 'inspect',
-        category: 'inspection',
-        targetTool: 'vgxness_sdd_cockpit',
-        suggestedArgs: { project, change },
-        readOnly: true,
-        mutating: false,
-        agentCallable: true,
-        humanOnly: false,
-        requiresHumanApproval: false,
-        requiresHumanConfirmation: false,
-        requiresPreflight: false,
-        requiresProviderWriteConsent: false,
-        reason: 'Continuation plans are advisory; cockpit inspection is a safe MCP-native way to refresh state.',
-        rationale: 'Keeps agents grounded in current artifact states without mutating SDD state or provider configuration.',
-        blockingPrerequisites: [],
-    };
-}
-function draftPhaseAction(project, change, phase, reason) {
-    return {
-        id: `sdd.${change}.${phase}.draft`,
-        label: `Prepare ${phase} draft through normal SDD phase flow`,
-        title: `Prepare ${phase} draft`,
-        description: 'The next SDD phase appears runnable; draft generation must still use the normal phase workflow and any required preflight gates. After a valid phase artifact is produced, save it as a draft immediately, then ask the human acceptance/continue question before advancing.',
-        kind: 'draft-phase',
-        category: 'sdd-phase',
-        phase,
-        targetTool: 'vgxness_sdd_get_readiness',
-        suggestedArgs: { project, change, phase },
-        readOnly: false,
-        mutating: true,
-        agentCallable: true,
-        humanOnly: false,
-        requiresHumanApproval: false,
-        requiresHumanConfirmation: false,
-        requiresPreflight: true,
-        requiresProviderWriteConsent: false,
-        reason,
-        rationale: 'This continuation tool is read-only, so it can recommend the next phase but cannot execute providers or save artifacts itself.',
-        blockingPrerequisites: [],
-    };
-}
-function recommendedActionForBlocker(project, change, blocker) {
-    if (blocker.reason === 'draft' || blocker.reason === 'legacy')
-        return humanAcceptAction(project, change, blocker);
-    if (blocker.reason === 'rejected')
-        return humanReopenAction(project, change, blocker);
-    if (blocker.reason === 'missing')
-        return draftPhaseAction(project, change, blocker.phase, blocker.action);
-    return inspectArtifactAction(project, change, blocker);
-}
-function humanAcceptAction(project, change, blocker) {
-    return {
-        id: `sdd.${change}.${blocker.phase}.accept-human`,
-        label: `Human review and acceptance required for ${blocker.phase}`,
-        title: `Accept ${blocker.phase} artifact as a human`,
-        description: 'A human must explicitly accept this artifact before it counts as accepted; agents must not accept on the human’s behalf.',
-        kind: 'accept-human',
-        category: 'human-governance',
-        phase: blocker.phase,
-        targetTool: 'vgxness_sdd_accept_artifact',
-        suggestedArgs: { project, change, phase: blocker.phase },
-        readOnly: false,
-        mutating: true,
-        agentCallable: false,
-        humanOnly: true,
-        requiresHumanApproval: true,
-        requiresHumanConfirmation: true,
-        requiresPreflight: true,
-        requiresProviderWriteConsent: false,
-        reason: blocker.action,
-        rationale: 'Human-only acceptance is an explicit governance event and cannot be inferred from draft content, readiness, or artifact presence.',
-        blockingPrerequisites: [blockingPrerequisite(blocker)],
-    };
-}
-function humanReopenAction(project, change, blocker) {
-    return {
-        id: `sdd.${change}.${blocker.phase}.reopen-human`,
-        label: `Human reopen required for rejected ${blocker.phase}`,
-        title: `Reopen ${blocker.phase} artifact as a human`,
-        description: 'A human may reopen the rejected artifact to draft; agents must not perform this governance action on the human’s behalf.',
-        kind: 'reopen-human',
-        category: 'human-governance',
-        phase: blocker.phase,
-        targetTool: 'vgxness_sdd_reopen_artifact',
-        suggestedArgs: { project, change, phase: blocker.phase },
-        readOnly: false,
-        mutating: true,
-        agentCallable: false,
-        humanOnly: true,
-        requiresHumanApproval: true,
-        requiresHumanConfirmation: true,
-        requiresPreflight: true,
-        requiresProviderWriteConsent: false,
-        reason: blocker.action,
-        rationale: 'Reopen is a human governance transition from rejected back to draft and remains outside this read-only planner.',
-        blockingPrerequisites: [blockingPrerequisite(blocker)],
-    };
-}
-function inspectArtifactAction(project, change, blocker) {
-    return {
-        id: `sdd.${change}.${blocker.phase}.inspect`,
-        label: `Inspect ${blocker.phase} artifact`,
-        title: `Inspect ${blocker.phase} artifact`,
-        description: 'Inspect the blocking artifact before deciding whether human governance or phase work is needed.',
-        kind: 'inspect',
-        category: 'inspection',
-        phase: blocker.phase,
-        targetTool: 'vgxness_sdd_get_artifact',
-        suggestedArgs: { project, change, phase: blocker.phase, payloadMode: 'compact' },
-        readOnly: true,
-        mutating: false,
-        agentCallable: true,
-        humanOnly: false,
-        requiresHumanApproval: false,
-        requiresHumanConfirmation: false,
-        requiresPreflight: false,
-        requiresProviderWriteConsent: false,
-        reason: blocker.action,
-        rationale: 'Artifact inspection is read-only and helps agents understand the blocker without changing SDD state.',
-        blockingPrerequisites: [blockingPrerequisite(blocker)],
-    };
-}
-function blockingPrerequisite(blocker) {
-    return {
-        phase: blocker.phase,
-        topicKey: blocker.topicKey,
-        reason: blocker.reason,
-        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
-    };
-}
-function relatedRunContextView(project, relatedRunContext, dbFlag) {
-    if (relatedRunContext === undefined)
-        return undefined;
-    return {
-        ...relatedRunContext,
-        recommendation: 'Related interrupted run found by checkpoint changeId; inspect or resume it before starting duplicate SDD work. Advisory only.',
-        resumeCommand: `vgxness resume --project ${project} --run-id ${relatedRunContext.runId}${dbFlag}`,
-    };
-}
-function suggestedContinuationCommand(project, next, fallbackInspectCommand, dbFlag) {
-    if (next.status === 'runnable' && next.nextPhase !== undefined)
-        return runPhaseCommand(project, next.change, next.nextPhase, dbFlag);
-    return fallbackInspectCommand;
-}
-function continuationBlockerAction(project, change, blocker, dbFlag) {
-    return {
-        phase: blocker.phase,
-        topicKey: blocker.topicKey,
-        reason: blocker.reason,
-        action: blocker.action,
-        command: blockerCommand(project, change, blocker, dbFlag),
-        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
-    };
-}
-function blockerCommand(project, change, blocker, dbFlag) {
-    if (blocker.reason === 'missing')
-        return runPhaseCommand(project, change, blocker.phase, dbFlag);
-    if (blocker.reason === 'draft' || blocker.reason === 'legacy')
-        return `vgxness sdd accept-artifact --project ${project} --change ${change} --phase ${blocker.phase} --actor <human-id>${dbFlag}`;
-    if (blocker.reason === 'rejected')
-        return `vgxness sdd reopen-artifact --project ${project} --change ${change} --phase ${blocker.phase} --actor <human-id>${dbFlag}`;
-    return `vgxness sdd get-artifact --project ${project} --change ${change} --phase ${blocker.phase} --json${dbFlag}`;
-}
-function runPhaseCommand(project, change, phase, dbFlag) {
-    void phase;
-    return `vgxness sdd continue --project ${project} --change ${change}${dbFlag}`;
-}
-function continuationDbFlag(explicitDatabasePath) {
-    return explicitDatabasePath === undefined ? '' : ` --db ${explicitDatabasePath}`;
-}
+export * from '../application/sdd/sdd-continuation-plan.js';