@leejungkiin/awkit 1.7.5 → 1.7.6

package/bin/awk.js

@@ -2241,6 +2241,40 @@ function cmdGreet(args) {
     }
 }
 
+function cmdGoal(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        log('');
+        log(`${C.cyan}${C.bold}🎯 awkit goal — Codex Goal Mode Orchestrator${C.reset}`);
+        log('');
+        log('Usage:');
+        log('  awkit goal "<objective>"');
+        log('  awkit goal --status');
+        log('  awkit goal --pause');
+        log('  awkit goal --resume');
+        log('  awkit goal --cancel');
+        log('');
+        return;
+    }
+
+    try {
+        const scriptPath = path.join(__dirname, '..', 'scripts', 'codex-goal.js');
+        const passArgs = [];
+        
+        if (args.length > 0 && !args[0].startsWith('-')) {
+            passArgs.push('--prompt', args.join(' '));
+        } else {
+            passArgs.push(...args);
+        }
+
+        const result = spawnSync('node', [scriptPath, ...passArgs], { stdio: 'inherit' });
+        if (result.status !== 0) {
+            process.exit(result.status || 1);
+        }
+    } catch (e) {
+        err('Failed to execute Codex Goal Mode: ' + e.message);
+    }
+}
+
 function cmdHelp() {
     const line = `${C.gray}${'─'.repeat(56)}${C.reset}`;
     log('');
@@ -2339,6 +2373,16 @@ function cmdHelp() {
     log(`  ${C.gray}  -t, --timezone <tz>${C.reset} Timezone parameter`);
     log('');
 
+    // Goal Mode
+    log(`${C.bold}🎯  Goal Mode${C.reset}`);
+    log(line);
+    log(`  ${C.green}goal${C.reset} <objective>    Pursue a high-level goal using Codex Goal Conductor`);
+    log(`  ${C.green}goal --status${C.reset}       Check active goal status and task progress`);
+    log(`  ${C.green}goal --pause${C.reset}        Pause active goal execution loop`);
+    log(`  ${C.green}goal --resume${C.reset}       Resume paused goal execution`);
+    log(`  ${C.green}goal --cancel${C.reset}       Cancel and reset active goal session`);
+    log('');
+
     // Symphony
     log(`${C.bold}🎶  Symphony${C.reset}`);
     log(line);
@@ -2774,6 +2818,16 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
         automation: {
             autoQA: true,
             maxSelfCorrectionLoops: 3,
+            multiAgent: {
+                enabled: true,
+                routingMode: 'cost-optimized',
+                audioAlerts: true,
+                runners: {
+                    claude: 'claude',
+                    codex: 'codex',
+                    qwen: 'qwen'
+                }
+            },
             telegram: {
                 enabled: true,
                 chatId: "",
@@ -3021,6 +3075,16 @@ async function cmdInit(forceFlag = false) {
             currentIdentity.automation = {
                 autoQA: true,
                 maxSelfCorrectionLoops: 3,
+                multiAgent: {
+                    enabled: true,
+                    routingMode: 'cost-optimized',
+                    audioAlerts: true,
+                    runners: {
+                        claude: 'claude',
+                        codex: 'codex',
+                        qwen: 'qwen'
+                    }
+                },
                 telegram: {
                     enabled: true,
                     chatId: "",
@@ -3061,6 +3125,33 @@ async function cmdInit(forceFlag = false) {
                 currentIdentity.automation.maxSelfCorrectionLoops = 3;
                 changed = true;
             }
+            if (!currentIdentity.automation.multiAgent) {
+                currentIdentity.automation.multiAgent = {
+                    enabled: true,
+                    routingMode: 'cost-optimized',
+                    audioAlerts: true,
+                    runners: {
+                        claude: 'claude',
+                        codex: 'codex',
+                        qwen: 'qwen'
+                    }
+                };
+                changed = true;
+            } else {
+                if (!currentIdentity.automation.multiAgent.runners) {
+                    currentIdentity.automation.multiAgent.runners = {
+                        claude: 'claude',
+                        codex: 'codex',
+                        qwen: 'qwen'
+                    };
+                    changed = true;
+                } else {
+                    const runners = currentIdentity.automation.multiAgent.runners;
+                    if (!runners.claude) { runners.claude = 'claude'; changed = true; }
+                    if (!runners.codex) { runners.codex = 'codex'; changed = true; }
+                    if (!runners.qwen) { runners.qwen = 'qwen'; changed = true; }
+                }
+            }
             if (!currentIdentity.automation.obsidian) {
                 currentIdentity.automation.obsidian = { enabled: false, path: "", autoSync: false };
                 changed = true;
@@ -5150,6 +5241,9 @@ const [, , command, ...args] = process.argv;
         case 'greet':
             cmdGreet(args);
             break;
+        case 'goal':
+            cmdGoal(args);
+            break;
         case 'config-global':
             cmdGlobalConfig(args);
             break;

package/bin/codex-generators.js

@@ -76,7 +76,8 @@ function generateCodexAgents(srcDir, destDir, selectedSkills = null) {
         'problem-solving-pro',
         'swiftui-pro',
         'android-re-analyzer',
-        'brainstorm-agent'
+        'brainstorm-agent',
+        'codex-goal'
     ];
 
     let count = 0;

package/core/GEMINI.md

@@ -191,5 +191,5 @@ Complete>Shortcuts, Evidence>Assumptions, Standard>Custom, Explicit>Implicit, Te
 - **Gate skills:** `orchestrator` (triage) → `brainstorm-agent` (G1) → `module-spec-writer` (G1.5) → `spec-gate` (G2) → `visual-design-gate` (G2.5) → `symphony-enforcer` (G3) → `verification-gate` (G5)
 - **Code intelligence:** `gitnexus-intelligence` (impact analysis, blast radius, safe refactoring)
 - **Skill catalog:** xem `orchestrator/SKILL.md`
-- **Workflows:** 75+ (/xxx). Core: /init /code /debug /recap /next /todo /gitnexus /teach
-- **Shortcuts:** `/todo` `/done` `/next`
+- **Workflows:** 75+ (/xxx). Core: /init /code /debug /recap /next /todo /gitnexus /teach /goal
+- **Shortcuts:** `/todo` `/done` `/next` `/goal`

package/core/skill-runtime-manifest.json

@@ -15,6 +15,7 @@
         "brainstorm-agent",
         "code-review",
         "codex-conductor",
+        "codex-goal",
         "gemini-conductor",
         "generate-gui-assets",
         "gitnexus-intelligence",

package/docs/history/implementation_plan.v1.md

@@ -1,58 +1,62 @@
-# Add Game Development Skills (Unity, Godot, Expo)
+# Implementation Plan - GreetingApp Feature
 
-Implement dedicated game development skills inside `main-awf/skills` to enhance the orchestrator's capability in building games using Unity, Godot, and Expo.
-
-## User Review Required
-
-> [!NOTE]
-> All new skills will be created directly in `skills/` of `main-awf` workspace and then deployed to `~/.gemini/antigravity` via `awkit install`.
-
-## Proposed Changes
-
-### AWKit Skills
+## Revision History
+| Version | Date | Description | Author |
+|---|---|---|---|
+| v1.0 | 2026-06-22 | Initial implementation plan for GreetingApp | Antigravity Orchestrator |
 
 ---
 
-#### [NEW] [unity-game-development/SKILL.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/unity-game-development/SKILL.md)
-Contains high-density instructions for Unity game development, enforcing:
-- C# coding style (PascalCase public, camelCase private, `m_` fields prefix).
-- Component-based architecture and ScriptableObjects for data-driven game structures.
-- Performance optimization: avoiding `Find`/`GetComponent` in hot paths (`Update()`), caching, object pooling.
-- Separate Editor code via `#if UNITY_EDITOR`.
-- Direct Unity MCP server integration.
-
-#### [NEW] [godot-game-development/SKILL.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/godot-game-development/SKILL.md)
-Contains guidelines for Godot 4.x game development, enforcing:
-- Godot 4 API standards (rejecting Godot 3 syntax).
-- GDScript style preferences (`@export`, `@onready`, `await` signals).
-- Composition-first scene tree structure over deep class inheritance.
-- Signal connection best practices (`signal.connect(callback)`).
-- Physics and locomotion handling via parameterless `move_and_slide()`.
-
-#### [NEW] [expo-game-development/SKILL.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/expo-game-development/SKILL.md)
-Contains instructions for Expo/React Native game development, covering:
-- High-frequency drawing techniques (React Native Skia, Expo GL/Three.js).
-- State optimization: keeping physics/game tick loop decoupled from heavy React re-renders.
-- User input handling (React Native Gesture Handler).
-- Game loop implementations using `requestAnimationFrame`.
-- Asset management and sound effects via `expo-av`.
+## 1. Objectives
+Implement the GreetingApp feature within the `main-awf` workspace, integrating:
+- A shared Greeting Engine at `core/GreetingEngine`.
+- CLI Interface command `awkit greet` in `bin/awk.js`.
+- REST API endpoint `GET /api/greet` in `symphony/app/api/greet/route.js`.
+- Light history logging via JSON Lines at `~/.gemini/antigravity/greeting_history.jsonl` (and local project fallback).
 
 ---
 
-#### [MODIFY] [CATALOG.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/CATALOG.md)
-Add the three new skills to the active skills table.
-
-#### [MODIFY] [TRIGGER_INDEX.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/TRIGGER_INDEX.md)
-Register keywords and triggers for the new game skills.
+## 2. Proposed Changes
+
+### Phase A: Core Engine and Locales
+#### 1. Locales Definition
+Create locales JSON files under `core/GreetingEngine/locales/`:
+- `en.json`: English templates.
+- `vi.json`: Vietnamese templates.
+- `ja.json`: Japanese templates.
+
+#### 2. Greeting Engine (`core/GreetingEngine/index.js`)
+Create the core processor. It will:
+- Parse `name` (default: "Guest"), `lang` (default: "en"), and `timezone` (default: local).
+- Determine time-of-day period (`morning` 5-11:59, `afternoon` 12-17:59, `evening` 18-21:59, `night` 22-4:59).
+- Load localization strings, format the template by replacing `{name}`, and return the object.
+- Record transactions to `greeting_history.jsonl`.
+- Provide stats functions.
+
+### Phase B: CLI Integration
+#### 1. CLI Commands (`bin/awk.js`)
+- Register the `greet` subcommand in the main switch-case.
+- Parse flags: `--name` / `-n`, `--lang` / `-l`, and `--timezone` / `-t` (or use system timezone).
+- Print the generated greeting and save to the history log.
+
+### Phase C: REST API Integration
+#### 1. API Route Handler (`symphony/app/api/greet/route.js`)
+- Define `GET` handler.
+- Extract `name`, `lang`, and `timezone` query parameters.
+- Call the Greeting Engine.
+- Return structured JSON response following spec.
 
 ---
 
-## Verification Plan
+## 3. Verification Plan
 
-### Automated Verification
-- Run `awkit status` to inspect mapping diffs.
-- Deploy to runtime using `awkit install`.
-- Verify CLI integration and syntax using `awkit doctor`.
+### Automated/Unit Tests
+- Verify engine resolves times and timezones correctly.
+- Verify fallback to `en` on unrecognized language inputs.
+- Verify JSON structure matches specifications.
 
 ### Manual Verification
-- Ask the user to verify the added skills locally or confirm availability in future workspace tasks.
+- Execute `node bin/awk.js greet --name="Alice" --lang="vi"`.
+- Execute `node bin/awk.js greet --name="Bob" --lang="ja"`.
+- Query Symphony REST API `/api/greet?name=Charlie&lang=en` locally.
+- Inspect the history log at the designated path.

package/docs/history/implementation_plan.v2.md

@@ -0,0 +1,87 @@
+# Implementation Plan - Codex Goal Mode Integration
+
+## Revision History
+| Version | Date | Description | Author |
+|---|---|---|---|
+| v1.0 | 2026-06-22 | Initial plan for Codex Goal Mode, skill, and workflow integration | Antigravity Orchestrator |
+
+---
+
+## Goal Description
+Implement a **Goal Mode** (including a new **Skill** and a **Workflow**) that utilizes the Codex goal-execution capabilities for centralized task orchestration. In this mode, Codex serves as the master coordinator (Goal Conductor), partitioning a high-level user goal into subtasks, tracking progress in Symphony, and delegating specific duties back to other specialized agents (Claude, Qwen, Gemini/AGY) or its own independent sub-agents (e.g., critic, coder, tester, ios-engineer) in a collaborative loop.
+
+---
+
+## User Review Required
+
+> [!IMPORTANT]
+> **Orchestration Loop Protocol:** Codex Goal Mode runs as a closed-loop execution system. Checkpoints are automatically bypassed when `goal_mode = true` (using best-effort AI verification) except for safety-critical, destructive, or security tasks.
+
+---
+
+## Open Questions
+- Do we want to support persistent background session resume for long-running goals (e.g., using `codex resume --last`)? *(Currently planned to support resume by storing execution states in `codex-reports/goals/`).*
+
+---
+
+## Proposed Changes
+
+### Core Orchestration Layer
+
+#### [NEW] [codex-goal.js](file:///Users/trungkientn/Dev/NodeJS/main-awf/scripts/codex-goal.js)
+Create a new script that coordinates the Goal loop:
+1. Initializes a goal workspace under `codex-reports/goals/<goal_id>/`.
+2. Sets `goal_mode = true` in the process context.
+3. Invokes Codex CLI to analyze the initial goal, parse it into subtasks, and map them to appropriate agents.
+4. Orchestrates task execution:
+   - For architecture & specs: Delegates to Claude via `scripts/claude-plan.js`.
+   - For coding/refactoring: Delegates to Qwen via `scripts/qwen-exec.js`.
+   - For general tasks/fallbacks: Delegates to AGY (Gemini).
+   - For reviews, tests, visual QA: Delegates to Codex sub-agents (`critic`, `tester`, `ios-visual-qa-strategist`).
+5. Tracks states, saves progress reports to `.md` files, and updates Symphony tickets.
+
+---
+
+### Workflows
+
+#### [NEW] [goal.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/workflows/lifecycle/goal.md)
+Define the `/goal` workflow containing:
+- Pre-requisites checks for Codex CLI.
+- Workflow subcommands: `/goal "[objective]"`, `/goal:status`, `/goal:resume`, `/goal:pause`, `/goal:cancel`.
+- Detailed description of the autonomous goal execution loop.
+- Fallback policies and recovery steps.
+
+---
+
+### Skills
+
+#### [NEW] [SKILL.md](file:///Users/trungkientn/Dev/NodeJS/main-awf/skills/codex-goal/SKILL.md)
+Create a new skill for the Codex Goal Orchestrator defining:
+- Developer instructions for the master Goal Conductor role.
+- Task breakdown schemas and JSON mapping format.
+- Sub-agent specifications (definitions, system prompts, capabilities).
+- Call-back protocols for Claude, Qwen, and AGY.
+
+---
+
+### CLI & Code Integration
+
+#### [MODIFY] [awk.js](file:///Users/trungkientn/Dev/NodeJS/main-awf/bin/awk.js)
+1. Register `goal` in the CLI command list and register the command parser.
+2. Include the new `/goal` and `/goal-mode` commands in the help usage block.
+3. Add the `codex-goal` skill folder to the default runtime list, ensuring it gets synced during `awkit install`.
+
+#### [MODIFY] [codex-generators.js](file:///Users/trungkientn/Dev/NodeJS/main-awf/bin/codex-generators.js)
+Add `codex-goal` to `SPECIALIST_SKILLS` list so that a Codex-compatible `.toml` agent spec is automatically generated for it.
+
+---
+
+## Verification Plan
+
+### Automated Tests
+- Run `node bin/awk.js doctor` to check installation state.
+- Run `awkit status` to ensure all files are synchronized.
+
+### Manual Verification
+- Execute `node bin/awk.js goal "Build a simple greeting command line tool"` and verify that the orchestration loop initializes the plan, registers tasks, calls Qwen for implementation, and reviews using the critic sub-agent.
+- Verify status checks, pause, and resume capabilities.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.7.5",
+  "version": "1.7.6",
   "description": "Antigravity Workflow Kit v1.6 Unified AI agent orchestration system with Mindful Checkpoints.",
   "main": "bin/awk.js",
   "private": false,

package/scripts/codex-goal.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/**
+ * Codex Goal Conductor - Goal Orchestration Runner for AWKit
+ * Pursues high-level development goals autonomously by executing Codex CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const os = require('os');
+
+const GOALS_DIR = path.join(process.cwd(), 'codex-reports', 'goals');
+const ACTIVE_GOAL_FILE = path.join(GOALS_DIR, 'active_goal.json');
+
+const C = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m',
+};
+
+const log = (msg) => console.log(msg);
+const ok = (msg) => log(`${C.green}✔${C.reset} ${msg}`);
+const warn = (msg) => log(`${C.yellow}⚠${C.reset} ${msg}`);
+const err = (msg) => log(`${C.red}✖${C.reset} ${msg}`);
+const info = (msg) => log(`${C.cyan}ℹ${C.reset} ${msg}`);
+
+// Parse args
+const args = process.argv.slice(2);
+let prompt = '';
+let checkStatus = false;
+let pauseGoal = false;
+let resumeGoal = false;
+let cancelGoal = false;
+
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--prompt' && args[i + 1]) {
+        prompt = args[i + 1];
+        i++;
+    } else if (args[i] === '--status') {
+        checkStatus = true;
+    } else if (args[i] === '--pause') {
+        pauseGoal = true;
+    } else if (args[i] === '--resume') {
+        resumeGoal = true;
+    } else if (args[i] === '--cancel') {
+        cancelGoal = true;
+    }
+}
+
+// Ensure goals directory exists
+fs.mkdirSync(GOALS_DIR, { recursive: true });
+
+function getActiveGoal() {
+    if (fs.existsSync(ACTIVE_GOAL_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(ACTIVE_GOAL_FILE, 'utf8'));
+        } catch (_) {}
+    }
+    return null;
+}
+
+function saveActiveGoal(state) {
+    fs.writeFileSync(ACTIVE_GOAL_FILE, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function runGoal(goalPrompt) {
+    info(`Setting up Goal Conductor for: "${goalPrompt}"`);
+
+    // Load codex-goal skill rules
+    const skillPath = path.join(__dirname, '..', 'skills', 'codex-goal', 'SKILL.md');
+    let skillContent = '';
+    if (fs.existsSync(skillPath)) {
+        skillContent = fs.readFileSync(skillPath, 'utf8');
+    }
+
+    const fullPrompt = `${skillContent}\n\n[USER GOAL / OBJECTIVE]\n${goalPrompt}\n\nPlease parse the goal, partition it into steps, and coordinate execution. Call Claude, Qwen, and sub-agents as described in the guidelines.`;
+
+    const goalId = `goal_${Date.now()}`;
+    const state = {
+        goalId,
+        prompt: goalPrompt,
+        status: 'running',
+        timestamp: Date.now()
+    };
+    saveActiveGoal(state);
+
+    // Set goal_mode = true in current context if running checks
+    process.env.goal_mode = 'true';
+
+    info(`Launching Codex CLI Agent in Goal Orchestration Mode...`);
+    try {
+        const result = spawnSync('codex', [
+            fullPrompt,
+            '-s', 'workspace-write',
+            '--ask-for-approval', 'untrusted'
+        ], { stdio: 'inherit' });
+
+        if (result.status === 0) {
+            state.status = 'completed';
+            saveActiveGoal(state);
+            ok('🏆 Codex Goal Conductor execution finished.');
+        } else {
+            state.status = 'failed';
+            saveActiveGoal(state);
+            err('Codex Goal Conductor exited with an error.');
+        }
+    } catch (e) {
+        state.status = 'failed';
+        saveActiveGoal(state);
+        err('Failed to execute Codex CLI: ' + e.message);
+    }
+}
+
+// CLI Command Handling
+if (checkStatus) {
+    const state = getActiveGoal();
+    if (!state) {
+        log('No active goal session tracked.');
+    } else {
+        log(`\n🎯 Active Goal: "${state.prompt}"`);
+        log(`Status: ${state.status === 'running' ? C.cyan : state.status === 'completed' ? C.green : C.red}${state.status.toUpperCase()}${C.reset}`);
+        log(`Goal ID: ${state.goalId}`);
+        log(`To resume/check the Codex session, run: ${C.green}awkit goal --resume${C.reset}\n`);
+    }
+} else if (pauseGoal) {
+    log('To pause Codex CLI execution, please press Ctrl+C in the active terminal run window.');
+} else if (resumeGoal) {
+    const state = getActiveGoal();
+    if (state) {
+        info('Resuming last Codex session...');
+        try {
+            spawnSync('codex', ['resume', '--last'], { stdio: 'inherit' });
+        } catch (e) {
+            err('Failed to resume Codex session: ' + e.message);
+        }
+    } else {
+        warn('No active goal session to resume.');
+    }
+} else if (cancelGoal) {
+    const state = getActiveGoal();
+    if (state) {
+        if (fs.existsSync(ACTIVE_GOAL_FILE)) {
+            fs.unlinkSync(ACTIVE_GOAL_FILE);
+        }
+        ok('Goal session cleared locally.');
+    } else {
+        warn('No active goal session to cancel.');
+    }
+} else if (prompt) {
+    runGoal(prompt);
+} else {
+    log('Usage:');
+    log('  node scripts/codex-goal.js --prompt "Goal Description"');
+    log('  node scripts/codex-goal.js --status');
+    log('  node scripts/codex-goal.js --pause');
+    log('  node scripts/codex-goal.js --resume');
+    log('  node scripts/codex-goal.js --cancel');
+}

package/scripts/exec-rtk.js

@@ -24,6 +24,7 @@ function checkRtk() {
  * @returns {Buffer|string}
  */
 function execRtkSync(command, options = {}) {
+    const opts = { timeout: 30000, ...options };
     const trimmed = command.trim();
     
     // Only compress developer commands known to be verbose
@@ -33,10 +34,10 @@ function execRtkSync(command, options = {}) {
     const isEligible = allEligible.some(prefix => trimmed.startsWith(prefix));
 
     if (!checkRtk()) {
-        if (isEligible && !options.stdio) {
-            return execSync(`${command} 2>&1 | tail -c 8000`, { ...options, shell: true });
+        if (isEligible && !opts.stdio) {
+            return execSync(`${command} 2>&1 | tail -c 8000`, { ...opts, shell: true });
         }
-        return execSync(command, options);
+        return execSync(command, opts);
     }
 
     if (trimmed.startsWith('rtk ')) {

package/skills/codex-goal/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: codex-goal
+description: >-
+  Codex Goal Conductor — Centralized autonomous goal-execution loop.
+  Orchestrates complex feature development by partitioning high-level goals
+  into tasks and distributing them to Claude, Qwen, standard agents, and sub-agents.
+metadata:
+  stage: core
+  version: "1.0"
+  requires: codex (npm i -g @openai/codex)
+  tags: [goal, conductor, orchestration, multi-agent, autonomous]
+agent: Goal Conductor
+trigger: command
+invocation-type: manual
+priority: 5
+---
+
+# 🎯 Codex Goal Conductor — Goal Execution Skill
+
+> **Purpose:** Centralized orchestrator to pursue high-level development goals autonomously.
+> **Principle:** Codex plans the tasks, registers them in Symphony, and delegates executions to other specialized agents.
+
+---
+
+## 🏗️ Execution Model
+
+In Goal Mode, Codex acts as the **Goal Conductor**. It runs an autonomous loop:
+
+```
+                  ┌──────────────────────┐
+                  │ User Goal Prompt     │
+                  └──────────┬───────────┘
+                             │
+                             ▼
+                  ┌──────────────────────┐
+                  │ Codex Conductor      │◄────────────────────────┐
+                  └──────────┬───────────┘                         │
+                             │ (Partitions & Delegates)            │
+        ┌────────────────────┼────────────────────┐                │
+        ▼                    ▼                    ▼                │
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐         │
+│  Claude CLI  │     │   Qwen CLI   │     │ Codex Sub-   │         │
+│ (Architect)  │     │  (Executor)  │     │   agents     │         │
+└──────────────┘     └──────────────┘     └──────┬───────┘         │
+                                                 │                 │
+                                                 ▼ (Inspect/Review)│
+                                          ┌──────────────┐         │
+                                          │ standard     │         │
+                                          │  verification│─────────┘
+                                          └──────────────┘
+```
+
+---
+
+## 📋 Operational Guidelines
+
+### 1. Goal Partitioning
+- Upon receiving a goal, the Conductor MUST create a local session tracker at `codex-reports/goals/<goal_id>/state.json`.
+- It must partition the goal into explicit, non-overlapping step tasks (following Symphony task schema).
+
+### 2. Task Delegation Protocol
+For each task, the Goal Conductor selects the optimal runner:
+- **Claude (Architect):** Runs for PRD generation, architectural design, and planning checks.
+  Command: `node scripts/claude-plan.js --prompt-file <prompt_file> --output <output_file>`
+- **Qwen (Executor):** Runs for code implementation, refactoring, and file modifications.
+  Command: `node scripts/qwen-exec.js --prompt-file <prompt_file> --output <output_file> --sandbox workspace-write`
+- **Gemini / AGY (General):** Runs for light scripting, quick checks, and fallback execution.
+  Command: `agy --model gemini-3.5-flash --print "<prompt>"`
+- **Codex Sub-agents (Headless Experts):** Used for verification, reviews, and test generation.
+  Command: `codex exec "<prompt>" -s workspace-write`
+
+### 3. Sub-Agent Autonomy & Callback
+- Codex sub-agents (e.g. `critic`, `tester`, `ios-visual-qa-strategist`) are instantiated to run independently.
+- When running, these sub-agents may delegate sub-problems back to Claude, Qwen, or AGY by executing the respective wrapper CLI commands.
+- Sub-agents report their outputs back to the Goal Conductor in standardized Markdown files in `codex-reports/goals/<goal_id>/`.
+
+---
+
+## 🚫 Safety & Mindful Rest Guards
+- **destructive_actions:** If a proposed task involves destructive modifications (e.g., `rm -rf`, force push, database drop), the Conductor MUST pause and ask for explicit user confirmation.
+- **loop_prevention:** If a single task fails or undergoes retry loops more than 3 times, the Conductor must pause, report the blocker details, and ask the user for guidance.
+- **state_saves:** Save state changes to `codex-reports/goals/<goal_id>/state.json` at the end of every task execution.

package/workflows/lifecycle/goal.md

@@ -0,0 +1,86 @@
+---
+description: 🎯 Codex Goal Conductor — Pursue high-level goals autonomously using Codex coordination
+---
+
+# /goal — Codex Goal Mode Workflow
+
+> Launch Codex in Goal Mode to orchestrate multi-agent task execution and pursue complex goals.
+
+---
+
+## 🛠️ Step-by-Step Execution
+
+### 1. Prerequisites Check
+Ensure Codex CLI is installed on the system:
+```bash
+which codex || echo "NOT_INSTALLED"
+```
+If missing, suggest the user install it:
+```bash
+npm i -g @openai/codex
+```
+
+### 2. Launching the Goal
+Initiate the goal execution loop:
+```bash
+awkit goal "Build a simple greeting command line tool"
+```
+Or execute through a specific pipeline command:
+```bash
+awkit pipeline goal "FeatureName"
+```
+
+### 3. Loop Execution Flow
+1. **Initialize State:** Create directory `codex-reports/goals/<goal_id>/` and output the planned task list.
+2. **Set Goal Mode:** Set `goal_mode = true` globally so that checkpoints automatically verify and bypass user blocks.
+3. **Task Orchestration:** The loop script (`scripts/codex-goal.js`) executes tasks sequentially:
+   - Partition goal → Delegate plan/design to Claude.
+   - Implement code → Delegate implementation to Qwen.
+   - Verification → Run Codex sub-agents (`critic` or `tester`).
+4. **State Persistence:** Save logs and state changes at the end of each step.
+
+---
+
+## 🔔 Sub-commands
+
+### `/goal:status`
+Check the status of the currently active goal and print active task reports:
+```bash
+node scripts/codex-goal.js --status
+```
+
+### `/goal:pause`
+Pause the active goal execution loop and save the current state:
+```bash
+node scripts/codex-goal.js --pause
+```
+
+### `/goal:resume`
+Resume the most recently paused or saved goal session:
+```bash
+node scripts/codex-goal.js --resume
+```
+
+### `/goal:cancel`
+Cancel the active goal session, clean up temporary resources, and reset `goal_mode = false`:
+```bash
+node scripts/codex-goal.js --cancel
+```
+
+---
+
+## 🔔 Sound Notifications
+
+Upon task completion or session completion, trigger sound alerts:
+- Success: `afplay /System/Library/Sounds/Glass.aiff && say "Goal phase completed successfully"`
+- Paused/Blocker: `afplay /System/Library/Sounds/Basso.aiff && say "Goal execution paused. User attention required."`
+
+---
+
+## 🚫 Fallback Policy
+
+- If Codex CLI fails to launch or encounters critical issues:
+  - Fall back to standard **Gemini Conductor** or **Claude Planner** workflows (`scripts/claude-plan.js` or `agy`).
+- If Qwen CLI is not available during execution:
+  - Fall back to `agy --model gemini-3.5-flash` for code generation.
+- Ensure the orchestration script does not crash and logs error outputs gracefully to `codex-reports/goals/error.log`.