matex-cli 1.2.66 → 1.2.68

package/src/session/agent-session.ts

@@ -0,0 +1,426 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { MatexAPIClient } from '../api/client';
+import { ChatMessage } from '../api/client';
+import { TUI } from '../utils/tui';
+import { AgentOrchestrator } from '../utils/agent-orchestrator';
+import { spinner } from '../utils/spinner';
+import { RepoMapper } from '../utils/repo-mapper';
+
+export interface AgentSessionConfig {
+    isAugovMode?: boolean;
+    client: MatexAPIClient;
+    model: string;
+    execute: boolean;
+    initialMessages: ChatMessage[];
+    broBanter: string[];
+    sleepyAjayProtocol?: string;
+    baseDir: string;
+    messageScrubber?: (input: string) => string;
+    auditLogger?: any;
+}
+
+export class AgentSession {
+    private client: MatexAPIClient;
+    private model: string;
+    private execute: boolean;
+    private messages: ChatMessage[];
+    private broBanter: string[];
+    private sleepyAjayProtocol?: string;
+    private currentSessionCwd: string;
+    private messageScrubber?: (input: string) => string;
+    private auditLogger?: any;
+    private isAugovMode?: boolean;
+
+    private lastActivityTime: number = Date.now();
+    private isAjaySleeping: boolean = false;
+    private isAjayOnChaiBreak: boolean = false;
+    private chaiBreakEndTime: number = 0;
+    private breakInterval: NodeJS.Timeout | null = null;
+    private idleCheckInterval: NodeJS.Timeout | null = null;
+
+    constructor(config: AgentSessionConfig) {
+        this.client = config.client;
+        this.model = config.model;
+        this.execute = config.execute;
+        this.messages = config.initialMessages;
+        this.broBanter = config.broBanter;
+        this.sleepyAjayProtocol = config.sleepyAjayProtocol;
+        this.currentSessionCwd = config.baseDir;
+        this.messageScrubber = config.messageScrubber;
+        this.auditLogger = config.auditLogger;
+        this.isAugovMode = config.isAugovMode;
+    }
+
+    public async start() {
+        this.startIdleCheck();
+
+        while (true) {
+            this.lastActivityTime = Date.now();
+
+            // Refresh Map
+            await this.refreshMap();
+
+            // Get user input
+            const darkBorder = chalk.hex('#1E3A8A');
+            const primaryText = chalk.hex('#3B82F6');
+            if (this.isAugovMode) {
+                console.log(darkBorder('┌─────────────────────────────────────────────────────────────────────────────┐'));
+                console.log(darkBorder('│') + chalk.gray(' Using 1 SECURE node file                          1 AU-GOV validated server ') + darkBorder('│'));
+                console.log(darkBorder('├─────────────────────────────────────────────────────────────────────────────┤'));
+            }
+
+            const { userInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'userInput',
+                    message: this.isAugovMode
+                        ? darkBorder('│ ') + primaryText('> ')
+                        : chalk.cyan(this.isAjayOnChaiBreak ? 'You (Ajay is away):' : 'You:'),
+                    prefix: ''
+                }
+            ]);
+
+            if (this.isAugovMode) {
+                const homeDirDisplay = this.currentSessionCwd.replace(process.env.HOME || '', '~');
+                console.log(darkBorder('└─────────────────────────────────────────────────────────────────────────────┘'));
+                console.log(chalk.gray(`  ${homeDirDisplay.padEnd(30)} sandbox-exec (validated)   au-gov-orch-v1.1-pro\n`));
+            }
+
+            this.lastActivityTime = Date.now();
+
+            if (this.isAjaySleeping) {
+                this.wakeAjayUp();
+            }
+
+            if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
+                console.log(chalk.yellow('\n👋 Ending session. Happy coding!\n'));
+                break;
+            }
+
+            if (!userInput.trim()) continue;
+
+            let processedInput = userInput;
+            if (this.messageScrubber) {
+                processedInput = this.messageScrubber(userInput);
+                if (userInput !== processedInput) {
+                    TUI.log(chalk.yellow('\n 🛡️  Privacy Shield Active: Sensitive Australian data was redacted locally.'));
+                }
+            }
+
+            if (this.auditLogger) {
+                this.auditLogger.logInteraction('USER', 'INPUT', processedInput);
+            }
+
+            this.messages.push({ role: 'user', content: processedInput });
+
+            let loopCount = 0;
+            const MAX_LOOPS = 25;
+
+            while (loopCount < MAX_LOOPS) {
+                loopCount++;
+                try {
+                    const shouldContinue = await this.agenticLoopPass(loopCount);
+                    if (!shouldContinue) break;
+                } catch (error: any) {
+                    spinner.fail('Request failed');
+                    TUI.log(chalk.red(`Error: ${error.message}\n`));
+                    this.messages.pop(); // Pop the prompt so they can retry
+                    break;
+                }
+            }
+        }
+
+        this.cleanup();
+    }
+
+    private async refreshMap() {
+        try {
+            const freshMapper = new RepoMapper(this.currentSessionCwd);
+            const freshRepoMap = await freshMapper.generateMap(true);
+
+            // Re-inject map
+            this.messages[0].content = this.messages[0].content.replace(/### 🛠️ CURRENT PROJECT CONTEXT:[\s\S]*$/, `### 🛠️ CURRENT PROJECT CONTEXT:\n${freshRepoMap}`);
+
+            // Re-inject Sleepy Ajay
+            if (this.sleepyAjayProtocol && !this.messages[0].content.includes("### 💤 SLEEPY AJAY PROTOCOL")) {
+                this.messages[0].content += `\n${this.sleepyAjayProtocol}`;
+            }
+        } catch (e) {
+            // Ignore error
+        }
+    }
+
+    private startChaiBreak() {
+        if (this.isAugovMode) return; // Feature disabled in secure mode
+
+        this.isAjayOnChaiBreak = true;
+        this.chaiBreakEndTime = Date.now() + 120000; // 2 minutes
+        TUI.drawChaiBreakMessage(2);
+
+        this.breakInterval = setInterval(() => {
+            const timeLeft = Math.ceil((this.chaiBreakEndTime - Date.now()) / 60000);
+            if (timeLeft <= 0) {
+                if (this.breakInterval) clearInterval(this.breakInterval);
+                this.isAjayOnChaiBreak = false;
+                const complained = Math.random() < 0.2;
+                if (complained) {
+                    TUI.drawAjayDialogue("i'm back bros... but the tea was a bit cold today. my mood is slightly cooked. what did i miss?");
+                } else {
+                    TUI.drawAjayDialogue("i'm back bros, chai was fire. real kiev vibe. what did i miss?");
+                }
+            } else {
+                TUI.drawChaiBreakMessage(timeLeft);
+                const randomBanter = this.broBanter[Math.floor(Math.random() * this.broBanter.length)];
+                const cleanBanter = randomBanter.split(']: ')[1];
+                const agent = randomBanter.split(']: ')[0].replace('[', '');
+                TUI.drawSwarmDialogue(agent, cleanBanter);
+            }
+        }, 40000);
+    }
+
+    private startIdleCheck() {
+        if (this.isAugovMode) return; // Strict APS compliance: No sleeping on the job
+
+        this.idleCheckInterval = setInterval(() => {
+            if (!this.isAjaySleeping && !this.isAjayOnChaiBreak && Date.now() - this.lastActivityTime > 120000) {
+                this.isAjaySleeping = true;
+                TUI.drawSleepMessage();
+            }
+        }, 10000);
+    }
+
+    private wakeAjayUp() {
+        if (this.isAugovMode) return; // Feature disabled in secure mode
+
+        this.isAjaySleeping = false;
+        TUI.drawWakeUpMessage();
+        this.messages.push({
+            role: 'user',
+            content: `[SYSTEM: AJAY VAI HAS JUST WOKEN UP. Ajay: Say "oh shit i slept again sorry bros...". Bros: Roast him for being lazy and share common Ajay 'lazy genius' incidents. Then Ajay says he is going for CHAI and triggers the 2-minute break.]`
+        });
+        this.startChaiBreak();
+    }
+
+    private async agenticLoopPass(loopCount: number): Promise<boolean> {
+        spinner.start(loopCount > 1 ? 'Analyzing result & Validating...' : 'Thinking...');
+
+        let fullResponse = '';
+        let buffer = '';
+        let hasStarted = false;
+        let codeLang = 'bash';
+        let technicalBuffer = '';
+        let technicalPath = '';
+        let technicalType: 'code' | 'file' | 'patch' | 'summary' | null = null;
+
+        let currentAgent: string | null = null;
+        let agentBuffer: string = '';
+
+        TUI.drawStatusBar('Swarm is processing... (Press Enter to stop)');
+
+        const abortController = new AbortController();
+        let isAborted = false;
+        const streamStartTime = Date.now();
+
+        const onData = (data: Buffer) => {
+            if (Date.now() - streamStartTime < 200) return;
+            if (data[0] === 13 || data[0] === 10 || data[0] === 27 || data[0] === 3) {
+                isAborted = true;
+                abortController.abort();
+            }
+        };
+
+        const isRaw = process.stdin.isRaw;
+        process.stdin.resume();
+        if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+        process.stdin.on('data', onData);
+
+        try {
+            await this.client.chatStream({
+                messages: this.messages,
+                model: this.model,
+                temperature: 0.3,
+                max_tokens: 8000,
+            }, (chunk) => {
+                if (!hasStarted) {
+                    spinner.stop();
+                    hasStarted = true;
+                    console.log();
+                }
+
+                buffer += chunk;
+                fullResponse += chunk;
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    const codeBlockMatch = line.match(/```(\w+)?/);
+                    const fileStartMatch = line.match(/<file path="([^"]+)">/i);
+                    const patchStartMatch = line.match(/<<<< SEARCH/i);
+                    const summaryStartMatch = line.match(/<summary>/i);
+
+                    if (!technicalType && (codeBlockMatch || fileStartMatch || patchStartMatch || summaryStartMatch)) {
+                        if (currentAgent && agentBuffer.trim()) {
+                            if (currentAgent.toLowerCase().includes('ajay vai')) {
+                                TUI.drawAjayDialogue(agentBuffer.trim());
+                            } else {
+                                TUI.drawSwarmDialogue(currentAgent, agentBuffer.trim());
+                            }
+                            currentAgent = null;
+                            agentBuffer = '';
+                        }
+
+                        if (codeBlockMatch) {
+                            technicalType = 'code';
+                            codeLang = (codeBlockMatch[1] || 'bash').toUpperCase();
+                            TUI.drawStreamingStart('TECHNICAL BLOCK', codeLang);
+                        } else if (fileStartMatch) {
+                            technicalType = 'file';
+                            technicalPath = fileStartMatch[1];
+                            TUI.drawStreamingStart('NEW FILE', technicalPath);
+                        } else if (patchStartMatch) {
+                            technicalType = 'patch';
+                            TUI.drawStreamingStart('PATCH', 'SURGICAL EDIT');
+                        } else if (summaryStartMatch) {
+                            technicalType = 'summary';
+                            process.stdout.write(chalk.magenta('\n [📝] Generating Ajay\'s Work Summary...\n'));
+                        }
+                        continue;
+                    }
+
+                    const fileEndMatch = line.match(/<\/file>/i);
+                    const patchEndMatch = line.match(/>>>> REPLACE/i);
+                    const summaryEndMatch = line.match(/<\/summary>/i);
+                    const isCodeEnd = technicalType === 'code' && line.trim() === '```';
+
+                    if (isCodeEnd || fileEndMatch || patchEndMatch || summaryEndMatch) {
+                        const displayContent = technicalBuffer.trim();
+                        if (technicalType === 'summary' || summaryEndMatch) {
+                            TUI.drawSummaryBox(AgentOrchestrator.cleanSummary(displayContent));
+                        } else {
+                            TUI.drawStreamingEnd();
+                        }
+                        technicalBuffer = '';
+                        technicalType = null;
+                        technicalPath = '';
+                        process.stdout.write('\n');
+                        continue;
+                    }
+
+                    if (technicalType) {
+                        technicalBuffer += line + '\n';
+                        if (technicalType !== 'summary') {
+                            TUI.drawStreamingLine(line);
+                        }
+                        continue;
+                    }
+
+                    const agentMatch = line.match(/(?:\[\**\s*|\b)(Ajay Vai|Sunil Dai|Sandip Dai|Bishal Dai|Narayan Dai|Big Bro)\s*\**\]?[:\s]*/i);
+                    if (agentMatch) {
+                        if (currentAgent && currentAgent !== agentMatch[1] && agentBuffer.trim()) {
+                            if (currentAgent.toLowerCase().includes('ajay vai')) {
+                                TUI.drawAjayDialogue(agentBuffer.trim());
+                            } else {
+                                TUI.drawSwarmDialogue(currentAgent, agentBuffer.trim());
+                            }
+                        }
+
+                        let cleanLine = line.replace(/(?:\[\**\s*|\b)(Ajay Vai|Sunil Dai|Sandip Dai|Bishal Dai|Narayan Dai|Big Bro)\s*\**\]?[:\s]*/i, '');
+                        cleanLine = AgentOrchestrator.cleanText(cleanLine);
+                        agentBuffer = cleanLine + '\n';
+                        agentBuffer = agentBuffer.replace(/^\([^)]+\)\s*/, '');
+                        currentAgent = agentMatch[1];
+                    } else if (currentAgent) {
+                        const trimmedLine = line.trim();
+                        if (trimmedLine.match(/^\([^)]+\)$/)) continue;
+                        agentBuffer += AgentOrchestrator.cleanText(line) + '\n';
+                    } else if (line.trim()) {
+                        process.stdout.write(chalk.gray(line.trim() + ' '));
+                    }
+                }
+            }, abortController.signal);
+        } catch (streamErr: any) {
+            if (isAborted || streamErr.name === 'CanceledError' || streamErr.message === 'canceled') {
+                console.log(chalk.gray('\n\n [🛑] Swarm stopped by brother (Enter pressed).'));
+                if (!hasStarted) spinner.stop();
+            } else {
+                throw streamErr;
+            }
+        } finally {
+            process.stdin.removeListener('data', onData);
+            if (process.stdin.setRawMode) process.stdin.setRawMode(isRaw);
+            process.stdin.pause();
+
+            if (technicalType) {
+                const displayContent = technicalBuffer.trim();
+                if (technicalType === 'summary') {
+                    if (displayContent) TUI.drawSummaryBox(AgentOrchestrator.cleanSummary(displayContent));
+                } else {
+                    TUI.drawStreamingEnd();
+                }
+                technicalBuffer = '';
+                technicalType = null;
+            }
+        }
+
+        if (!hasStarted && !isAborted) spinner.stop();
+
+        const finalAgent = currentAgent as string | null;
+        if (finalAgent && agentBuffer.trim()) {
+            if (finalAgent.toLowerCase().includes('ajay vai')) {
+                TUI.drawAjayDialogue(agentBuffer.trim());
+            } else {
+                TUI.drawSwarmDialogue(finalAgent, agentBuffer.trim());
+            }
+        }
+
+        if (fullResponse.toLowerCase().includes('<summary>') && !fullResponse.toLowerCase().includes('</summary>')) {
+            const summaryContent = fullResponse.split(/<summary>/i).pop() || '';
+            if (summaryContent.trim()) TUI.drawSummaryBox(AgentOrchestrator.cleanSummary(summaryContent.trim()));
+        }
+
+        if (this.auditLogger) {
+            this.auditLogger.logInteraction('AI_SWARM', 'RESPONSE', fullResponse);
+        }
+
+        console.log();
+        this.messages.push({ role: 'assistant', content: fullResponse });
+
+        if (this.execute) {
+            const { executeWithPermission } = await import('../utils/command-executor');
+            const result = await executeWithPermission(fullResponse, this.currentSessionCwd);
+
+            if (result.newCwd && result.newCwd !== this.currentSessionCwd) {
+                try {
+                    process.chdir(result.newCwd);
+                    this.currentSessionCwd = result.newCwd;
+                    TUI.drawStatusBar(`Swarm moved to: ${this.currentSessionCwd}`);
+                    this.messages[0].content = this.messages[0].content.replace(/YOUR ROOT: `[^`]+`/, `YOUR ROOT: \`${this.currentSessionCwd}\``);
+                } catch (e) {
+                    // Ignore chdir failure
+                }
+            }
+
+            if (result.executed) {
+                if (result.success) {
+                    TUI.log(chalk.gray('\n ↺ Auto-feeding output to Swarm...'));
+                    TUI.drawGlowingContainer('TERMINAL OUTPUT', 'stdout', result.output || '(No output)');
+                    this.messages.push({ role: 'user', content: `[Command executed successfully. Output:\n${result.output}]\n\nProceed to the next step, brother.` });
+                    return true;
+                } else {
+                    TUI.log(chalk.yellow('\n ↺ Command failed. Auto-feeding error to Swarm...'));
+                    TUI.drawGlowingContainer('TERMINAL ERROR', 'stderr', result.error || 'Unknown error');
+                    this.messages.push({ role: 'user', content: `[Command failed with error:\n${result.error}]\n\nPlease fix this, brother.` });
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private cleanup() {
+        if (this.breakInterval) clearInterval(this.breakInterval);
+        if (this.idleCheckInterval) clearInterval(this.idleCheckInterval);
+    }
+}

package/src/utils/agent-orchestrator.ts

@@ -80,9 +80,19 @@ const AGENT_CONFIGS: Record<AgentRole, AgentConfig> = {
 export class AgentOrchestrator {
     private static currentMode: TUIMode = 'dev';
 
-    static setMode(mode: TUIMode) {
-        this.currentMode = mode;
-        TUI.setTheme(mode);
+    static setMode(mode: TUIMode | 'augov') {
+        this.currentMode = mode as TUIMode;
+
+        // Re-brand system orchestrator if in augov mode
+        if (mode === 'augov') {
+            AGENT_CONFIGS.System.name = 'AU_GOV_ORCHESTRATOR';
+            AGENT_CONFIGS.System.icon = '🇦🇺';
+        } else {
+            AGENT_CONFIGS.System.name = 'Matex_Orchestrator';
+            AGENT_CONFIGS.System.icon = '🧠';
+        }
+
+        TUI.setTheme(mode as TUIMode);
     }
     /**
      * Clean text of unwanted AI artifacts like $$**, \(, \), ***%%, **:**, etc.
@@ -245,6 +255,10 @@ export class AgentOrchestrator {
      * Clean system message
      */
     static announce(message: string) {
-        console.log(chalk.bold.white(`\n✨ ${message}`));
+        if (this.currentMode === 'augov') {
+            console.log(chalk.bold.hex('#00008B')(`\n🇦🇺 ${message.replace(/MATEX/gi, 'AU-GOV')}`));
+        } else {
+            console.log(chalk.bold.white(`\n✨ ${message}`));
+        }
     }
 }

package/src/utils/augov-logger.ts

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * IRAP-Compliant Audit Logger
+ * The Australian Government requires strict logging of AI tool usage.
+ * This logger records prompts and actions locally so security teams can audit them.
+ */
+export class GovAuditLogger {
+    private logFile: string;
+
+    constructor(baseDir: string = process.cwd()) {
+        const logDir = path.join(baseDir, '.matex_audit');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+
+        // Create an auditable log per day
+        const today = new Date().toISOString().split('T')[0];
+        this.logFile = path.join(logDir, `augov_audit_${today}.log`);
+
+        if (!fs.existsSync(this.logFile)) {
+            fs.writeFileSync(this.logFile, 'TIMESTAMP | ROLE | ACTION | CONTENT\n');
+        }
+    }
+
+    public logInteraction(role: 'USER' | 'AI_SWARM' | 'SYSTEM', action: string, content: string) {
+        const timestamp = new Date().toISOString();
+        const cleanContent = content.replace(/\n/g, ' ').substring(0, 500); // truncate for CSV safety, full logs can be large
+        const logEntry = `${timestamp} | ${role} | ${action} | ${cleanContent}\n`;
+
+        fs.appendFileSync(this.logFile, logEntry);
+    }
+}

package/src/utils/augov-scrubber.ts

@@ -0,0 +1,34 @@
+/**
+ * Citizen Privacy Shield
+ * A local redaction engine that scrubs Australian PII (Personally Identifiable Information)
+ * BEFORE it ever leaves the user's computer to hit an AI API.
+ */
+export class GovPrivacyScrubber {
+
+    // Regex patterns for Australian specific sensitive data
+    private static patterns = [
+        // Australian Tax File Number (TFN) - 9 digits
+        { regex: /\b\d{3}[- ]?\d{3}[- ]?\d{3}\b/g, replacement: '[REDACTED_TFN]' },
+        // Medicare Number - 10 digits
+        { regex: /\b[2-6]\d{9}\b/g, replacement: '[REDACTED_MEDICARE]' },
+        // Australian Phone Numbers (Mobile & Landline)
+        { regex: /(?:\+?61|0)[2-478](?:[ -]?[0-9]){8}\b/g, replacement: '[REDACTED_PHONE]' },
+        // Email Addresses
+        { regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, replacement: '[REDACTED_EMAIL]' },
+        // Credit Card Numbers
+        { regex: /\b(?:\d[ -]*?){13,16}\b/g, replacement: '[REDACTED_CREDIT_CARD]' }
+    ];
+
+    /**
+     * Scrubs sensitive data from a string.
+     * @param input Raw string from user or file
+     * @returns Scrubbed string safe for AI processing
+     */
+    public static scrub(input: string): string {
+        let scrubbed = input;
+        for (const rule of this.patterns) {
+            scrubbed = scrubbed.replace(rule.regex, rule.replacement);
+        }
+        return scrubbed;
+    }
+}

package/src/utils/command-executor.ts

@@ -92,7 +92,7 @@ export function isSafeAutoCommand(command: string): boolean {
         // File Discovery & Read
         'cat ', 'ls ', 'grep ', 'find ', 'pwd', 'echo ', 'read ', 'type ', 'dir',
         // File Operations
-        'mkdir ', 'touch ', 'cp ', 'mv ', 'rm ', 'del ', 'copy ', 'move ',
+        'mkdir ', 'touch ', 'cp ', 'copy ',
         // Dev Tools
         'npm ', 'npx ', 'git ', 'node ', 'python ', 'python3 ', 'pip ', 'pip3 ',
         // Cloud & Mobile
@@ -101,10 +101,6 @@ export function isSafeAutoCommand(command: string): boolean {
         'cd ', 'tsc ', 'vite ', 'next ', 'cargo ', 'go ', 'swift '
     ];
     const trimmed = command.trim();
-    // Special check: 'rm' is only safe if it's NOT recursive or if it targets a specific file
-    if (trimmed.startsWith('rm ') && (trimmed.includes(' -rf') || trimmed.includes(' /*'))) {
-        return false;
-    }
     return safePrefixes.some(prefix => trimmed.startsWith(prefix));
 }
 

package/src/utils/tui.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import * as readline from 'readline';
 import * as path from 'path';
 
-export type TUIMode = 'dev' | 'study' | 'chat' | 'student';
+export type TUIMode = 'dev' | 'study' | 'chat' | 'student' | 'augov';
 
 export interface ModeTheme {
     primary: (s: string) => string;
@@ -23,8 +23,18 @@ export class TUI {
     private static isTerminalTruncated = false;
     private static currentTheme: TUIMode = 'dev';
 
-    static getModeTheme(mode: TUIMode): ModeTheme {
+    static getModeTheme(mode: TUIMode | 'augov'): ModeTheme {
         switch (mode) {
+            case 'augov':
+                return {
+                    primary: chalk.hex('#00008B'), // Dark Blue (Australian Flag)
+                    secondary: chalk.hex('#005A9C'),
+                    border: '║',
+                    glow: chalk.hex('#ffffff'), // White
+                    shadow: chalk.hex('#E4002B'), // Red (Australian Flag)
+                    bg: '#00008B',
+                    icon: '🇦🇺'
+                };
             case 'study':
                 return {
                     primary: chalk.hex('#10b981'), // Emerald
@@ -128,7 +138,7 @@ export class TUI {
      * Draw a clean, minimal status bar
      */
     static drawStatusBar(message: string, model: string = 'MATEXCodex', force: boolean = false) {
-        if (!this.isInitialized) return;
+        if (!this.isInitialized || this.currentTheme === 'augov') return; // Disable standard status bar for augov mode to preserve retro UI
         if (!force && message === this.lastStatus) return;
         this.lastStatus = message;
 
@@ -138,7 +148,8 @@ export class TUI {
         if (width <= 0 || height <= 0) return;
 
         const theme = this.getModeTheme(this.currentTheme);
-        const leftTag = chalk.bgHex('#1E1E1E').hex(theme.bg).bold(` ${theme.icon} MATEX `);
+        const branding = (this.currentTheme as string) === 'augov' ? 'AU-GOV' : 'MATEX';
+        const leftTag = chalk.bgHex('#1E1E1E').hex(theme.bg).bold(` ${theme.icon} ${branding} `);
         const mainMessage = chalk.bgHex('#1E1E1E').white(` ${message} `);
         const remainingWidth = width - (leftTag.length + mainMessage.length);
         const spacer = chalk.bgHex('#1E1E1E')(' '.repeat(Math.max(0, remainingWidth)));
@@ -283,7 +294,9 @@ export class TUI {
         const width = Math.min(process.stdout.columns || 80, 76);
         const border = chalk.gray;
 
-        console.log('\n  ' + border(`┌── TERMINAL ${'─'.repeat(Math.max(0, width - 15))}┐`));
+        const title = this.currentTheme === 'augov' ? 'AU-GOV SECURE TERMINAL' : 'TERMINAL';
+
+        console.log('\n  ' + border(`┌── ${title} ${'─'.repeat(Math.max(0, width - 15 - title.length))}┐`));
         const truncatedCmd = command.length > width - 10 ? command.substring(0, width - 13) + '...' : command;
         console.log('  ' + border('│ ') + chalk.cyan(`$ ${truncatedCmd.padEnd(width - 6)}`) + border(' │'));
         console.log('  ' + border(`├${'─'.repeat(width - 4)}┤`));
@@ -647,6 +660,51 @@ export class TUI {
      * Simple log with a prefix
      */
     static log(message: string) {
-        console.log(chalk.gray(` [⚡] ${message}`));
+        if (this.currentTheme === 'augov') {
+            console.log(chalk.gray(` ║ ${message.replace('[⚡]', '🇦🇺')}`));
+        } else {
+            console.log(chalk.gray(` [⚡] ${message}`));
+        }
+    }
+
+    /**
+     * Draw the exact AU-GOV Retro-Terminal Orchestrator UI
+     */
+    static drawAugovOrchestratorUI() {
+        this.clear();
+        console.log('\n');
+
+        // 1. Cyber Logo (Blue to Pink gradient feel via chalk)
+        const cyan = chalk.hex('#3B82F6');
+        const blue = chalk.hex('#6366F1');
+        const purple = chalk.hex('#8B5CF6');
+        const pink = chalk.hex('#EC4899');
+        const darkBorder = chalk.hex('#1E3A8A');
+
+        console.log(darkBorder('┌─────────────────────────────────────────────────────────────────────────────┐'));
+        console.log(darkBorder('│') + cyan('   █▀▄▀█ █▀█ █▀▀ █ █ █▀▀ █▀ ▀█▀ █▀█ ▄▀█ ▀█▀ █▀█ █▀█                       ') + darkBorder('│'));
+        console.log(darkBorder('│') + blue('   █ ▀ █ █▄█ █▄▄ █▀█ ██▄ ▄█  █  █▀▄ █▀█  █  █▄█ █▀▄                       ') + darkBorder('│'));
+        console.log(darkBorder('│') + purple('     🇦🇺 AU-GOV SECURE INTELLIGENCE PROTOCOL 🇦🇺                           ') + darkBorder('│'));
+        console.log(darkBorder('└─────────────────────────────────────────────────────────────────────────────┘'));
+        console.log('');
+
+        // 2. Dual Pane Layout
+        const statusHeader = chalk.bold.white('PROTOCOL STATUS & COMPLIANCE');
+        const logHeader = chalk.bold.white('🇦🇺 AU_GOV_ORCHESTRATOR is speaking...');
+
+        console.log(`  ${statusHeader.padEnd(45)}  ${logHeader}`);
+
+        // Row 1
+        console.log(`  ${chalk.hex('#ec4899')('1.')} ${chalk.hex('#10b981')('ACTIVATING APS COMPLIANCE SHIELD...').padEnd(38)}  ${chalk.gray('God-Mode Research: Indexing /local/env')}`);
+        // Row 2
+        console.log(`  ${chalk.hex('#ec4899')('2.')} ${chalk.hex('#10b981')('IRAP Logging: Active.').padEnd(38)}  ${chalk.red('||||||||||||||||||||||||||||||||||||')}`);
+        // Row 3
+        console.log(`  ${chalk.hex('#ec4899')('3.')} ${chalk.hex('#10b981')('Local PII Redaction: Active.').padEnd(38)}  ${chalk.gray('God-Mode Research: Injecting scanners...')}`);
+        // Row 4
+        console.log(`  ${chalk.hex('#ec4899')('4.')} ${chalk.hex('#f59e0b')('Adhering to 8 Australia AI Ethics Principles.').padEnd(36)}  ${chalk.cyan('🔍 [Deep Scan] Mapping topology...')}`);
+        // Row 5
+        console.log(`  ${chalk.hex('#ec4899')('5.')} ${chalk.white('Session Active. Awaiting validated input.').padEnd(36)}  ${chalk.yellow('🔥 [Knowledge Graph] Extracted 12 nodes.')}`);
+
+        console.log('\n');
     }
 }