vigthoria-cli 1.13.26 → 1.13.30

package/README.md

@@ -216,6 +216,18 @@ This generates a tower defense game from scratch with Agent Mode, validates it i
 
 ## Commands
 
+### Creative V2 planning
+
+Use the guarded Creative V2 route for storyboards, videos, commercials,
+avatars, music videos, and audio. The command creates a plan/preflight only;
+it never approves paid rendering, credit debits, publishing, or identity
+processing:
+
+```bash
+vigthoria creative workflows
+vigthoria creative plan --workflow storyboard --duration 30 --aspect-ratio 16:9 "Launch film for a privacy-first AI workspace"
+```
+
 ### Chat Mode
 
 ```bash

package/completions/_vigthoria

@@ -12,6 +12,7 @@ _vigthoria() {
     'chat-resume:Resume the latest chat session for the current or specified project'
     'commands:List every CLI command grouped by command family'
     'config:Configure Vigthoria CLI settings'
+    'creative:Plan guarded media workflows with the native V2 Creative Agent'
     'deploy:Deploy and host your project on Vigthoria infrastructure'
     'device:Android Developer Bridge commands via local ADB'
     'devtools:DevTools Bridge commands for browser debugging'

package/completions/vigthoria.bash

@@ -1,6 +1,6 @@
 # Generated from contracts/phase-0/command-manifest.json; do not edit.
 _vigthoria_completions() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
-  COMPREPLY=( $(compgen -W 'agent auth background bridge cancel chat chat-resume commands config deploy device devtools doctor edit explain fix fork game generate history hub hyper-loop init legion login logout menu music operator preview replay repo review security status update v4 v4-menu wallet workflow' -- "$cur") )
+  COMPREPLY=( $(compgen -W 'agent auth background bridge cancel chat chat-resume commands config creative deploy device devtools doctor edit explain fix fork game generate history hub hyper-loop init legion login logout menu music operator preview replay repo review security status update v4 v4-menu wallet workflow' -- "$cur") )
 }
 complete -F _vigthoria_completions vigthoria vig vigthoria-chat

package/completions/vigthoria.fish

@@ -8,6 +8,7 @@ complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'ch
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'chat-resume' -d 'Resume the latest chat session for the current or specified project'
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'commands' -d 'List every CLI command grouped by command family'
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'config' -d 'Configure Vigthoria CLI settings'
+complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'creative' -d 'Plan guarded media workflows with the native V2 Creative Agent'
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'deploy' -d 'Deploy and host your project on Vigthoria infrastructure'
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'device' -d 'Android Developer Bridge commands via local ADB'
 complete -c vigthoria -c vig -c vigthoria-chat -n '__fish_use_subcommand' -a 'devtools' -d 'DevTools Bridge commands for browser debugging'

package/dist/commands/chat.js

@@ -22,7 +22,7 @@ import { renderDynamicHelp } from '../utils/command-menu.js';
 import { resolvePromptWorkspace } from '../utils/prompt-workspace-resolver.js';
 import { FileUtils } from '../utils/files.js';
 import { isDirectModeFollowUpQuestion, sanitizeDirectModeOutput, stripHiddenThoughtBlocks } from '../utils/direct-output-policy.js';
-import { createLiveOutcome, evaluateExecutorSuccess, handleRunCompleteEvent, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
+import { createLiveOutcome, evaluateExecutorSuccess, handleRunCompleteEvent, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, resolveAgentPartialMutation, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
 import { formatGoaSystemGrounding, splitGoaContextFromInput, } from '../utils/goaEvents.js';
@@ -30,6 +30,7 @@ import { inferAgentTaskTypeWithContext, resolvePlannerAgentTimeoutMs, resolveWor
 import { resolveAgentRoute } from '../utils/agentRoute.js';
 import { isV3StreamKeepaliveEvent } from '../utils/v3-stream-events.js';
 import { resolveAutoApproval } from '../utils/process-policy.js';
+import { hasLocalV3ServiceIdentity } from '../utils/runtime-capability.js';
 import { ChatToolCallParser } from '../utils/chat-tool-call-parser.js';
 import { ChatPromptPolicy } from '../utils/chat-prompt-policy.js';
 import { AgentStreamState } from '../utils/agent-stream-state.js';
@@ -1333,17 +1334,18 @@ export class ChatCommand {
             isJsonOutput: () => this.jsonOutput,
             idleTimeoutMs: () => DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
         });
-        this.sessionManager = new SessionManager();
+        this.sessionManager = new SessionManager(this.config.getStateRoot());
     }
     async run(options) {
+        this.agentMode = options.agent === true;
+        this.operatorMode = options.operator === true;
         const hasRuntimeToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
-        if (!this.config.isAuthenticated() && !hasRuntimeToken) {
+        const hasAgentServiceIdentity = this.agentMode && hasLocalV3ServiceIdentity();
+        if (!this.config.isAuthenticated() && !hasRuntimeToken && !hasAgentServiceIdentity) {
             throw new CliCommandError('Not authenticated. Run: vigthoria login', {
                 code: 'AUTH_REQUIRED', category: 'authentication',
             });
         }
-        this.agentMode = options.agent === true;
-        this.operatorMode = options.operator === true;
         this.workflowTarget = typeof options.workflow === 'string' && options.workflow.trim()
             ? options.workflow.trim()
             : null;
@@ -1884,26 +1886,14 @@ export class ChatCommand {
             await this.runOperatorDirectAnswer(prompt);
             return;
         }
-        // ── Repo-grounded operator path: try V3 agent first, then fall back ──
-        // Prompts that reference files, code symbols, or analysis verbs need
-        // tool access to read actual file contents.  Route these through the
-        // V3 agent (which archives runs for history/replay/fork and supports
-        // workspace hydration) first.  Falls back to local agent loop if V3
-        // is unreachable.
-        if (this.isRepoGroundedPrompt(prompt) && this.tools) {
-            this.operatorMode = true;
-            const handledByV3 = await this.tryV3AgentWorkflow(prompt);
-            if (handledByV3) {
-                this.saveSession();
-                return;
-            }
-            await this.runLocalAgentLoop(prompt);
-            return;
-        }
         getBridgeClient()?.emitPrompt({ prompt, mode: 'operator', model: this.currentModel });
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const spinner = this.jsonOutput ? null : createSpinner({ text: 'Thinking like an operator...', spinner: 'clock' }).start();
-        const workflowType = 'full';
+        // Operator is the BMAD surface. Keep grounded repository analysis on the
+        // Operator service and make mutation intent explicit instead of silently
+        // diverting it into V3 Agent mode. Read-only is the fail-safe default.
+        const operatorTaskType = inferAgentTaskTypeWithContext(prompt);
+        const workflowType = resolveWorkflowType(operatorTaskType, prompt);
         const executionPrompt = this.buildExecutionPrompt(prompt);
         try {
             this.rememberBrainEvent('task', `GoA operator workflow started for prompt: ${prompt.slice(0, 220)}`, 'operator');
@@ -2963,6 +2953,10 @@ export class ChatCommand {
                     return false;
                 }
                 const errorMessage = `V3 agent workflow returned an incomplete result and legacy fallback is disabled. ${previewGate?.error || 'Workspace changes were not fully validated.'}`;
+                const partialMutation = resolveAgentPartialMutation(changedFileCount, response.metadata?.partialMutation);
+                liveOutcome.executorError = previewGate?.error || 'Template Service preview proof did not pass.';
+                liveOutcome.failedTaskIds.add('preview-gate');
+                liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
                 if (spinner) {
                     spinner.stop();
                 }
@@ -2972,8 +2966,8 @@ export class ChatCommand {
                 watcher?.stop();
                 throw new CliCommandError(errorMessage, {
                     code: 'AGENT_PREVIEW_FAILED',
-                    category: previewGate?.partialMutation === false ? 'execution' : 'partial_mutation',
-                    partialMutation: previewGate?.partialMutation ?? 'unknown',
+                    category: partialMutation === false ? 'execution' : 'partial_mutation',
+                    partialMutation,
                     details: { executionPath: 'v3-agent', previewGate },
                 });
             }
@@ -3168,10 +3162,11 @@ export class ChatCommand {
                 }
             }
             if (!executorSucceeded) {
+                const partialMutation = resolveAgentPartialMutation(changedFileCount, response.metadata?.partialMutation);
                 throw new CliCommandError(runEvaluation.statusHeadline, {
                     code: 'AGENT_INCOMPLETE',
-                    category: response.partial === true || liveOutcome.tasksSucceeded > 0 ? 'partial_mutation' : 'execution',
-                    partialMutation: response.partial === true || liveOutcome.tasksSucceeded > 0 ? 'unknown' : false,
+                    category: partialMutation === false ? 'execution' : 'partial_mutation',
+                    partialMutation,
                     details: {
                         mode: 'agent',
                         model: routingPolicy.selectedModel,
@@ -3217,9 +3212,61 @@ export class ChatCommand {
         catch (error) {
             this.stopV3IdleWatch();
             watcher?.stop();
+            const persistTypedAgentFailure = (failure) => {
+                const safeFailure = sanitizeUserFacingErrorText(failure.message || 'Agent execution failed.');
+                liveOutcome.streamAborted = true;
+                if (!liveOutcome.executorError)
+                    liveOutcome.executorError = safeFailure;
+                if (failure.code === 'AGENT_PLAN_INVALID')
+                    liveOutcome.failedTaskIds.add('agent-plan');
+                liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
+                this.commitAgentRunOutcome({
+                    prompt,
+                    originalPrompt: null,
+                    taskId: null,
+                    contextId: executionId,
+                    tasksSucceeded: liveOutcome.tasksSucceeded,
+                    tasksTotal: liveOutcome.tasksTotal,
+                    failedTaskIds: [...liveOutcome.failedTaskIds],
+                    unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                    qualityScore: liveOutcome.qualityScore,
+                    qualityMissing: liveOutcome.qualityMissing,
+                    qualityBlockers: liveOutcome.qualityBlockers,
+                    hasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                    answerContent: null,
+                    selfHealStatus: 'failed',
+                    selfHealTool: null,
+                    plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
+                    executorError: liveOutcome.executorError,
+                    clientToolErrors: this.api.getClientToolErrors(),
+                    transportErrors: this.api.getLastChatTransportErrors(),
+                    workspacePath: workspacePath || null,
+                    workspaceSyncIssue: null,
+                    finishedAt: Date.now(),
+                }, prompt);
+                this.updateAgentExecutionCheckpoint({
+                    status: 'failed',
+                    contextId: executionId,
+                    failedTaskIds: [...liveOutcome.failedTaskIds],
+                    unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                    error: liveOutcome.executorError,
+                });
+            };
+            if (error?.code === 'AGENT_PLAN_INVALID') {
+                const planFailure = new CliCommandError(error.message, {
+                    code: 'AGENT_PLAN_INVALID',
+                    category: 'execution',
+                    partialMutation: error?.partialMutation ?? false,
+                    details: error?.mutation ? { mutation: error.mutation } : undefined,
+                    cause: error,
+                });
+                persistTypedAgentFailure(planFailure);
+                throw planFailure;
+            }
             if (error instanceof CliCommandError) {
                 if (spinner)
                     spinner.stop();
+                persistTypedAgentFailure(error);
                 throw error;
             }
             if (!this.api.hasAgentWorkspaceOutput(workspaceContext)) {

package/dist/commands/config.js

@@ -101,8 +101,8 @@ export class ConfigCommand {
                     message: 'Default AI model:',
                     choices: [
                         { name: '═══ Code Models ═══', disabled: true },
-                        { name: 'Vigthoria v4 Creative 27B - Architect and planning', value: 'architect' },
-                        { name: 'Vigthoria v4 Code 27B - Production executor', value: 'code' },
+                        { name: 'Vigthoria v4.2 Creative 27B - Multimodal architect and planning', value: 'architect' },
+                        { name: 'Vigthoria v4.2 Code 27B - Production executor', value: 'code' },
                         { name: 'Vigthoria v4 Assistant 9B - Fast FIM and diagnostics', value: 'assistant' },
                     ],
                     default: 'code',
@@ -309,8 +309,8 @@ export class ConfigCommand {
                 name: 'defaultModel',
                 message: 'Default AI model:',
                 choices: [
-                    { name: 'Vigthoria v4 Creative 27B — Architect', value: 'architect' },
-                    { name: 'Vigthoria v4 Code 27B — Executor', value: 'code' },
+                    { name: 'Vigthoria v4.2 Creative 27B — Multimodal Architect', value: 'architect' },
+                    { name: 'Vigthoria v4.2 Code 27B — Executor', value: 'code' },
                     { name: 'Vigthoria v4 Assistant 9B — FIM and diagnostics', value: 'assistant' },
                 ],
                 default: current.preferences.defaultModel,

package/dist/commands/creative-registration.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from 'commander';
+import type { Config } from '../utils/config.js';
+import type { Logger } from '../utils/logger.js';
+export type CreativeWorkflow = 'video' | 'storyboard' | 'commercial' | 'avatar' | 'music-video' | 'music-audio';
+export declare function buildCreativePlanPrompt(options: {
+    workflow: CreativeWorkflow;
+    brief: string;
+    title?: string;
+    duration?: number;
+    aspectRatio?: string;
+    project?: string;
+}): string;
+export declare function registerCreativeCommands(program: Command, config: Config, logger: Logger): void;

package/dist/commands/creative-registration.js

@@ -0,0 +1,88 @@
+import { ChatCommand } from './chat.js';
+const CREATIVE_ROUTES = {
+    video: { taxonomy: 'v2_creative.video_project', runtime: 'v2-creative-studio-core' },
+    storyboard: { taxonomy: 'v2_creative.video_project', runtime: 'v2-creative-studio-core' },
+    commercial: { taxonomy: 'v2_creative.video_project', runtime: 'v2-creative-studio-core' },
+    avatar: { taxonomy: 'v2_creative.avatar_operator', runtime: 'v2-creative-avatar-operator' },
+    'music-video': { taxonomy: 'v2_creative.video_project', runtime: 'v2-creative-studio-core' },
+    'music-audio': { taxonomy: 'v2_creative.music_generation', runtime: 'vigthoria-music-ai' },
+};
+export function buildCreativePlanPrompt(options) {
+    const route = CREATIVE_ROUTES[options.workflow];
+    return [
+        'Route this request through the native V2 Creative Agent workflow.',
+        'Planning only: do not start paid/cloud rendering, debit credits, publish media, or process identity assets. Return the plan, preflight, quote, and explicit approval gates first.',
+        `@vigthoria-creative-v2:${JSON.stringify({
+            contract: 'vigthoria-cli-creative-v2.v1',
+            taxonomy: route.taxonomy,
+            target_runtime: route.runtime,
+            phase: 'plan_only',
+            workflow: options.workflow,
+            title: options.title?.trim() || undefined,
+            brief: options.brief.trim(),
+            duration_seconds: options.duration,
+            aspect_ratio: options.aspectRatio || '16:9',
+            workspace_root: options.project,
+            safety: {
+                paid_render_approved: false,
+                identity_processing_approved: false,
+                require_preflight_and_quote: true,
+            },
+        })}`,
+    ].join('\n');
+}
+export function registerCreativeCommands(program, config, logger) {
+    const creative = program
+        .command('creative')
+        .description('Plan guarded media workflows with the native V2 Creative Agent');
+    creative
+        .command('workflows')
+        .description('List supported Creative V2 workflow routes')
+        .action(() => {
+        for (const [name, route] of Object.entries(CREATIVE_ROUTES)) {
+            console.log(`${name}\t${route.taxonomy}\t${route.runtime}`);
+        }
+    });
+    creative
+        .command('plan <brief...>')
+        .description('Create a plan/preflight only; never approves rendering or billing')
+        .option('-w, --workflow <workflow>', 'video, storyboard, commercial, avatar, music-video, or music-audio', 'storyboard')
+        .option('-t, --title <title>', 'Project or campaign title')
+        .option('-d, --duration <seconds>', 'Target duration in seconds', (value) => Number.parseInt(value, 10), 30)
+        .option('-a, --aspect-ratio <ratio>', '16:9, 9:16, or 1:1', '16:9')
+        .option('-p, --project <path>', 'Workspace/project context', process.cwd())
+        .option('--json', 'Emit machine-readable direct-agent output', false)
+        .action(async (briefParts, options) => {
+        const workflow = String(options.workflow || '').trim();
+        if (!Object.prototype.hasOwnProperty.call(CREATIVE_ROUTES, workflow)) {
+            throw new Error(`Unsupported Creative V2 workflow: ${options.workflow}`);
+        }
+        const duration = Number(options.duration);
+        if (!Number.isFinite(duration) || duration < 5 || duration > 600) {
+            throw new Error('Creative duration must be between 5 and 600 seconds.');
+        }
+        const aspectRatio = String(options.aspectRatio || '16:9');
+        if (!['16:9', '9:16', '1:1'].includes(aspectRatio)) {
+            throw new Error('Creative aspect ratio must be 16:9, 9:16, or 1:1.');
+        }
+        const project = String(options.project || process.cwd());
+        const prompt = buildCreativePlanPrompt({
+            workflow,
+            brief: briefParts.join(' '),
+            title: options.title,
+            duration,
+            aspectRatio,
+            project,
+        });
+        await new ChatCommand(config, logger, program).run({
+            model: 'agent',
+            project,
+            projectProvided: Boolean(options.project),
+            agent: true,
+            autoApprove: false,
+            prompt,
+            json: Boolean(options.json),
+        });
+    });
+    creative.action(() => creative.outputHelp());
+}

package/dist/commands/fork.d.ts

@@ -7,10 +7,11 @@ interface ForkOptions {
 }
 export declare class ForkCommand {
     private config;
-    constructor(config: Config, _logger: Logger);
+    private logger;
+    constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
-    private resolveWorkspaceRoot;
+    private buildForkHistory;
     run(runId: string, message: string, options: ForkOptions): Promise<void>;
 }
 export {};