@miphamai/cli 0.7.9 → 0.8.0

package/bin/mipham.ts

@@ -208,25 +208,52 @@ async function runUpdate(): Promise<boolean> {
   console.log(`  Checking npm registry for latest version...`)
   console.log()
 
-  // Check latest version from npm
+  // Check latest version from npm with retry + mirror fallback
   let latestVersion = ''
   try {
     const { execSync } = await import('node:child_process')
-    const result = execSync(`npm view ${PACKAGE} version --json`, {
-      encoding: 'utf-8',
-      timeout: 10_000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim()
-    latestVersion = result.replace(/"/g, '')
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.log(`✗ Failed to check latest version: ${msg}`)
-    console.log(`  Check manually: https://www.npmjs.com/package/${PACKAGE}`)
+
+    // Registry fallback chain: npm default → npmmirror (China mirror)
+    const attempts: Array<{ label: string; registry: string; timeout: number }> = [
+      { label: 'npm registry', registry: 'https://registry.npmjs.org/', timeout: 10_000 },
+      { label: 'npm registry (retry)', registry: 'https://registry.npmjs.org/', timeout: 20_000 },
+      {
+        label: 'npmmirror (China mirror)',
+        registry: 'https://registry.npmmirror.com/',
+        timeout: 15_000,
+      },
+    ]
+
+    let lastError: Error | null = null
+
+    for (const attempt of attempts) {
+      try {
+        const result = execSync(
+          `npm view ${PACKAGE} version --json --registry=${attempt.registry}`,
+          { encoding: 'utf-8', timeout: attempt.timeout, stdio: ['pipe', 'pipe', 'pipe'] },
+        ).trim()
+        latestVersion = result.replace(/"/g, '')
+        if (latestVersion) break
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err))
+        // Continue to next attempt
+      }
+    }
+
+    if (!latestVersion && lastError) throw lastError
+  } catch (_err: unknown) {
+    console.log(`✗ Could not reach npm registry (network timeout)`)
+    console.log()
+    console.log(`  Manual update:`)
+    console.log(`    npm install -g ${PACKAGE}@latest`)
+    console.log()
+    console.log(`  Or check: https://www.npmjs.com/package/${PACKAGE}`)
     process.exit(1)
   }
 
   if (!latestVersion) {
     console.log('✗ Could not determine latest version.')
+    console.log(`  Check manually: https://www.npmjs.com/package/${PACKAGE}`)
     process.exit(1)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/commands/autoloop-journal.ts

@@ -0,0 +1,107 @@
+import { mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const AUTOLOOP_DIR = join(homedir(), '.mipham', 'autoloop')
+
+function ensureDir(): void {
+  if (!existsSync(AUTOLOOP_DIR)) mkdirSync(AUTOLOOP_DIR, { recursive: true })
+}
+
+interface AutoloopJournal {
+  sessionId: string
+  prompt: string
+  status: 'active' | 'completed' | 'stopped'
+  iterations: number
+  startedAt: string
+  lastIteration?: string
+  logs: string[]
+}
+
+function journalPath(sessionId: string): string {
+  return join(AUTOLOOP_DIR, `${sessionId}.json`)
+}
+
+/** Create or reset an autonomous loop journal. */
+export function createAutoloopJournal(sessionId: string, prompt: string): AutoloopJournal {
+  ensureDir()
+  const journal: AutoloopJournal = {
+    sessionId,
+    prompt,
+    status: 'active',
+    iterations: 0,
+    startedAt: new Date().toISOString(),
+    logs: [],
+  }
+  writeFileSync(journalPath(sessionId), JSON.stringify(journal, null, 2), 'utf-8')
+  return journal
+}
+
+/** Read the journal for an autonomous loop. */
+export function readAutoloopJournal(sessionId: string): AutoloopJournal | null {
+  const path = journalPath(sessionId)
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+/** Log an iteration in the autonomous loop journal. */
+export function logAutoloopIteration(sessionId: string, summary: string): void {
+  const journal = readAutoloopJournal(sessionId)
+  if (!journal) return
+  journal.iterations++
+  journal.lastIteration = new Date().toISOString()
+  journal.logs.push(`[${journal.lastIteration}] #${journal.iterations}: ${summary.slice(0, 200)}`)
+  // Keep last 50 log entries
+  if (journal.logs.length > 50) journal.logs = journal.logs.slice(-50)
+  writeFileSync(journalPath(sessionId), JSON.stringify(journal, null, 2), 'utf-8')
+}
+
+/** Mark an autonomous loop as completed or stopped. */
+export function completeAutoloopJournal(sessionId: string, status: 'completed' | 'stopped'): void {
+  const journal = readAutoloopJournal(sessionId)
+  if (!journal) return
+  journal.status = status
+  journal.lastIteration = new Date().toISOString()
+  writeFileSync(journalPath(sessionId), JSON.stringify(journal, null, 2), 'utf-8')
+}
+
+/** List all active autonomous loops. */
+export function listActiveAutoloops(): AutoloopJournal[] {
+  ensureDir()
+  const journals: AutoloopJournal[] = []
+  for (const file of readdirSync(AUTOLOOP_DIR)) {
+    if (!file.endsWith('.json')) continue
+    try {
+      const j = JSON.parse(readFileSync(join(AUTOLOOP_DIR, file), 'utf-8'))
+      if (j.status === 'active') journals.push(j)
+    } catch {
+      /* skip */
+    }
+  }
+  return journals
+}
+
+/** Get the autonomous loop status message. */
+export function getAutoloopStatus(sessionId: string): string {
+  const journal = readAutoloopJournal(sessionId)
+  if (!journal) return 'No active autonomous loop.'
+  const elapsed = Date.now() - new Date(journal.startedAt).getTime()
+  const mins = Math.floor(elapsed / 60000)
+  const lines = [
+    `── Autonomous Loop: ${journal.sessionId} ──`,
+    `Status:     ${journal.status === 'active' ? '🔄 Running' : journal.status === 'completed' ? '✅ Completed' : '⏹ Stopped'}`,
+    `Prompt:     "${journal.prompt.slice(0, 100)}${journal.prompt.length > 100 ? '...' : ''}"`,
+    `Iterations: ${journal.iterations}`,
+    `Started:    ${journal.startedAt} (${mins}m ago)`,
+    `Last:       ${journal.lastIteration || 'N/A'}`,
+  ]
+  if (journal.logs.length > 0) {
+    lines.push('', 'Recent activity:')
+    for (const log of journal.logs.slice(-5)) lines.push(`  ${log}`)
+  }
+  return lines.join('\n')
+}

package/src/core/engine.ts

@@ -19,6 +19,14 @@ export class QueryEngine {
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
+  /** Custom verification shell script path for goal checking. */
+  private goalVerifyScript?: string
+  /** Custom verification skill name for goal checking. */
+  private goalVerifySkill?: string
+  /** Whether to auto-decompose goal into subtasks. */
+  private goalDecompose = false
+  /** Subtask IDs created via decomposition. */
+  private goalSubtasks: string[] = []
 
   constructor(
     private registry: ProviderRegistry,
@@ -63,8 +71,37 @@ export class QueryEngine {
   }
 
   /** Set the session goal for goal-driven execution. */
-  setGoal(goal: string): void {
+  setGoal(
+    goal: string,
+    opts?: { verifyScript?: string; verifySkill?: string; decompose?: boolean },
+  ): void {
     this.goal = goal
+    this.goalVerifyScript = opts?.verifyScript
+    this.goalVerifySkill = opts?.verifySkill
+    this.goalDecompose = opts?.decompose ?? false
+    this.goalSubtasks = []
+  }
+
+  /** Get current goal state for status display. */
+  getGoalState(): {
+    goal?: string
+    verifyScript?: string
+    verifySkill?: string
+    decompose: boolean
+    subtasks: string[]
+  } {
+    return {
+      goal: this.goal,
+      verifyScript: this.goalVerifyScript,
+      verifySkill: this.goalVerifySkill,
+      decompose: this.goalDecompose,
+      subtasks: this.goalSubtasks,
+    }
+  }
+
+  /** Register subtasks created via decomposition. */
+  addGoalSubtask(taskId: string): void {
+    this.goalSubtasks.push(taskId)
   }
 
   /** Get the last assistant text content. */
@@ -291,12 +328,63 @@ export class QueryEngine {
 
       if (!this.goal) break
 
-      // Ask AI to check the goal condition
-      const checkMsg = `Has this goal been achieved? "${this.goal}" Answer YES or NO with reason.`
+      // Build verification prompt based on mode
+      const checkMsg = this.buildGoalCheckMessage()
+
+      // If using script verification, run the script instead of asking AI
+      if (this.goalVerifyScript) {
+        const passed = await this.runScriptVerification()
+        if (passed) {
+          yield { type: 'text', content: `✅ Goal verification passed: ${this.goalVerifyScript}` }
+          break
+        }
+        // Script failed — continue looping
+        yield { type: 'text', content: `🔄 Verification script failed — continuing (loop ${loop})` }
+        continue
+      }
+
+      // If using skill verification, delegate to the skill
+      if (this.goalVerifySkill) {
+        yield { type: 'text', content: `🔍 Running verification skill: ${this.goalVerifySkill}` }
+        yield* this.process(checkMsg, signal)
+        if (this.lastAssistantContent?.includes('VERIFIED')) break
+        continue
+      }
+
+      // Default: ask AI YES/NO
       yield* this.process(checkMsg, signal)
-      // If AI responds "YES", break
       if (this.lastAssistantContent?.includes('YES')) break
     }
+
+    if (loop >= this.maxGoalLoops) {
+      yield {
+        type: 'text',
+        content: `⚠ Max goal loops (${this.maxGoalLoops}) reached — goal may not be achieved.`,
+      }
+    }
+  }
+
+  /** Build the goal verification prompt. */
+  private buildGoalCheckMessage(): string {
+    if (this.goalVerifyScript) {
+      return `Run the verification script "${this.goalVerifyScript}" to check: ${this.goal}`
+    }
+    if (this.goalVerifySkill) {
+      return `Use the skill "${this.goalVerifySkill}" to verify: ${this.goal}. If the goal is achieved, respond with VERIFIED. Otherwise explain what's missing.`
+    }
+    return `Has this goal been achieved? "${this.goal}" Answer YES or NO with reason.`
+  }
+
+  /** Run a shell script for goal verification. */
+  private async runScriptVerification(): Promise<boolean> {
+    if (!this.goalVerifyScript) return false
+    try {
+      const { execSync } = await import('node:child_process')
+      execSync(this.goalVerifyScript, { timeout: 30000, stdio: 'pipe' })
+      return true // exit code 0 = success
+    } catch {
+      return false // non-zero exit = not yet achieved
+    }
   }
 
   private async *continueWithTools(signal?: AbortSignal): AsyncGenerator<StreamChunk> {

package/src/shared/types.ts

@@ -61,7 +61,14 @@ export interface Message {
 
 // ── Tool Types ──
 export type ToolPermission = 'auto' | 'ask' | 'bypass'
-export type ToolCategory = 'file' | 'exec' | 'agent' | 'network' | 'system' | 'artifact'
+export type ToolCategory =
+  | 'file'
+  | 'exec'
+  | 'agent'
+  | 'network'
+  | 'system'
+  | 'artifact'
+  | 'scheduling'
 
 export interface ToolContext {
   cwd: string

package/src/shared/update.ts

@@ -16,6 +16,12 @@ const HOME = homedir()
 const MIPHAM_HOME = join(HOME, '.mipham')
 const CONFIG_PATH = join(MIPHAM_HOME, 'config.yml')
 
+// Registry fallback chain: npm default → npmmirror (China mirror)
+const REGISTRIES = [
+  { name: 'npm', url: 'https://registry.npmjs.org/' },
+  { name: 'npmmirror', url: 'https://registry.npmmirror.com/' },
+]
+
 export interface UpdateCheck {
   /** Current installed version */
   current: string
@@ -43,18 +49,49 @@ export function getCurrentVersion(): string {
 }
 
 /**
- * Fetch the latest version from the npm registry.
+ * Run `npm view` against a specific registry with a given timeout.
  * Returns the version string, or throws on failure.
  */
-function fetchLatestVersion(): string {
-  const result = execSync(`npm view ${PACKAGE} version --json`, {
+function tryRegistry(registry: string, timeoutMs: number): string {
+  const result = execSync(`npm view ${PACKAGE} version --json --registry=${registry}`, {
     encoding: 'utf-8',
-    timeout: 30_000,
+    timeout: timeoutMs,
     stdio: ['pipe', 'pipe', 'pipe'],
   }).trim()
   return result.replace(/"/g, '')
 }
 
+/**
+ * Fetch the latest version from the npm registry with retry + mirror fallback.
+ *
+ * Strategy:
+ *   1. Try npm default registry (10s timeout)
+ *   2. Retry npm default registry (20s timeout)
+ *   3. Fall back to npmmirror.com — China mirror (15s timeout)
+ *
+ * Returns the version string, or throws on all failures.
+ */
+function fetchLatestVersion(): string {
+  const attempts: Array<{ registry: string; timeout: number }> = [
+    { registry: REGISTRIES[0]!.url, timeout: 10_000 },
+    { registry: REGISTRIES[0]!.url, timeout: 20_000 },
+    { registry: REGISTRIES[1]!.url, timeout: 15_000 },
+  ]
+
+  let lastError: Error | null = null
+
+  for (const attempt of attempts) {
+    try {
+      return tryRegistry(attempt.registry, attempt.timeout)
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err))
+      // Continue to next attempt
+    }
+  }
+
+  throw lastError ?? new Error('Failed to fetch latest version')
+}
+
 /**
  * Check if an update is available by comparing the local version
  * against the npm registry.

package/src/tools/exec/task.ts

@@ -4,15 +4,31 @@ interface Task {
   id: string
   subject: string
   description: string
-  status: 'pending' | 'in_progress' | 'completed'
+  status: 'pending' | 'in_progress' | 'completed' | 'deleted'
+  activeForm?: string
+  metadata?: Record<string, unknown>
+  blocks: string[]
+  blockedBy: string[]
+  owner?: string
+  createdAt: string
 }
 
 const tasks = new Map<string, Task>()
 let taskCounter = 0
 
+function formatTask(t: Task): string {
+  const meta = t.metadata ? ` ${JSON.stringify(t.metadata)}` : ''
+  const blocks = t.blocks.length ? ` blocks:[${t.blocks.join(',')}]` : ''
+  const blocked = t.blockedBy.length ? ` waits:[${t.blockedBy.join(',')}]` : ''
+  return `[${t.status}] #${t.id}: ${t.subject}${blocks}${blocked}${meta}`
+}
+
 export const taskTool: ToolDefinition = {
   name: 'Task',
-  description: 'Create and manage structured task lists for tracking progress.',
+  description:
+    'Create and manage structured task lists for tracking progress. ' +
+    'Supports CRUD, dependencies (blocks/blockedBy), metadata, owner assignment, and status workflow: pending → in_progress → completed. ' +
+    'Use for complex multi-step tasks, session tracking, and organizing work.',
   category: 'exec',
   permission: 'auto',
   parameters: {
@@ -20,48 +36,147 @@ export const taskTool: ToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'list', 'update'],
-        description: 'Action to perform',
+        enum: ['create', 'list', 'update', 'get', 'delete'],
+        description:
+          'Action: create a task, list all, update status/fields, get one by ID, or delete.',
+      },
+      subject: { type: 'string', description: 'A brief, actionable title (for create/update).' },
+      description: { type: 'string', description: 'What needs to be done (for create/update).' },
+      activeForm: {
+        type: 'string',
+        description: 'Present continuous form shown during work (for create/update).',
       },
-      subject: { type: 'string', description: 'Task subject (for create)' },
-      description: { type: 'string', description: 'Task description (for create)' },
-      taskId: { type: 'string', description: 'Task ID (for update)' },
+      taskId: { type: 'string', description: 'Task ID (for update/get/delete).' },
       status: {
         type: 'string',
-        enum: ['pending', 'in_progress', 'completed'],
-        description: 'New status (for update)',
+        enum: ['pending', 'in_progress', 'completed', 'deleted'],
+        description: 'New status. "deleted" permanently removes the task.',
+      },
+      addBlocks: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Task IDs that this task blocks (they depend on this one).',
+      },
+      addBlockedBy: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Task IDs that block this task (this one depends on them).',
+      },
+      owner: { type: 'string', description: 'Agent or user name assigned to this task.' },
+      metadata: {
+        type: 'object',
+        description: 'Arbitrary key-value metadata to attach to the task.',
       },
     },
     required: ['action'],
   },
+
   async execute(params, _ctx) {
     const action = params.action as string
 
+    // ── CREATE ──
     if (action === 'create') {
       const id = String(++taskCounter)
       const subject = (params.subject as string) || 'Untitled'
-      tasks.set(id, {
+      const task: Task = {
         id,
         subject,
         description: (params.description as string) || '',
         status: 'pending',
-      })
+        activeForm: (params.activeForm as string) || undefined,
+        metadata: (params.metadata as Record<string, unknown>) || undefined,
+        blocks: [],
+        blockedBy: [],
+        owner: (params.owner as string) || undefined,
+        createdAt: new Date().toISOString(),
+      }
+      tasks.set(id, task)
       return { success: true, content: `Task #${id} created: ${subject}` }
     }
 
+    // ── LIST ──
     if (action === 'list') {
-      const list = Array.from(tasks.values())
-        .map((t) => `[${t.status}] #${t.id}: ${t.subject}`)
-        .join('\n')
-      return { success: true, content: list || '(no tasks)' }
+      const all = Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
+      if (all.length === 0) return { success: true, content: '(no tasks)' }
+
+      // Group by status
+      const groups: Record<string, Task[]> = { pending: [], in_progress: [], completed: [] }
+      for (const t of all) groups[t.status]?.push(t)
+
+      const lines: string[] = []
+      for (const status of ['in_progress', 'pending', 'completed'] as const) {
+        const group = groups[status]!
+        if (group.length === 0) continue
+        const emoji = status === 'in_progress' ? '🔄' : status === 'pending' ? '📋' : '✅'
+        lines.push(`${emoji} ${status.replace('_', ' ')} (${group.length}):`)
+        for (const t of group) lines.push(`  ${formatTask(t)}`)
+      }
+      return { success: true, content: lines.join('\n') }
+    }
+
+    // ── GET ──
+    if (action === 'get') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+
+      const lines = [
+        `── Task #${task.id} ──`,
+        `Subject: ${task.subject}`,
+        `Status: ${task.status}`,
+        `Description: ${task.description || '(none)'}`,
+      ]
+      if (task.activeForm) lines.push(`Active form: ${task.activeForm}`)
+      if (task.owner) lines.push(`Owner: ${task.owner}`)
+      if (task.blocks.length) lines.push(`Blocks: ${task.blocks.join(', ')}`)
+      if (task.blockedBy.length) lines.push(`Blocked by: ${task.blockedBy.join(', ')}`)
+      if (task.metadata) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`)
+
+      return { success: true, content: lines.join('\n') }
     }
 
+    // ── UPDATE ──
     if (action === 'update') {
       const taskId = params.taskId as string
       const task = tasks.get(taskId)
       if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
-      if (params.status) task.status = params.status as Task['status']
-      return { success: true, content: `Task #${taskId} updated: ${task.status}` }
+
+      if (params.subject !== undefined) task.subject = params.subject as string
+      if (params.description !== undefined) task.description = params.description as string
+      if (params.activeForm !== undefined) task.activeForm = params.activeForm as string
+      if (params.status !== undefined) task.status = params.status as Task['status']
+      if (params.owner !== undefined) task.owner = params.owner as string
+
+      // Merge dependency arrays
+      if (Array.isArray(params.addBlocks)) {
+        for (const bid of params.addBlocks as string[]) {
+          if (!task.blocks.includes(bid)) task.blocks.push(bid)
+        }
+      }
+      if (Array.isArray(params.addBlockedBy)) {
+        for (const bid of params.addBlockedBy as string[]) {
+          if (!task.blockedBy.includes(bid)) task.blockedBy.push(bid)
+        }
+      }
+
+      // Merge metadata
+      if (params.metadata && typeof params.metadata === 'object') {
+        task.metadata = {
+          ...(task.metadata || {}),
+          ...(params.metadata as Record<string, unknown>),
+        }
+      }
+
+      return { success: true, content: `Task #${taskId} updated.\n${formatTask(task)}` }
+    }
+
+    // ── DELETE ──
+    if (action === 'delete') {
+      const taskId = params.taskId as string
+      const task = tasks.get(taskId)
+      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+      task.status = 'deleted'
+      return { success: true, content: `Task #${taskId} deleted.` }
     }
 
     return { success: false, content: '', error: `Unknown action: ${action}` }

package/src/tools/index.ts

@@ -18,6 +18,8 @@ import { configTool } from './system/config'
 import { mcpTool } from './system/mcp'
 import { artifactTool } from './artifact/artifact'
 import { computerUseTool } from './computer/computer-use'
+import { scheduleWakeupTool } from './scheduling/schedule-wakeup.js'
+import { cronCreateTool, cronDeleteTool, cronListTool } from './scheduling/cron.js'
 
 /**
  * Validate tool parameters against the tool's JSON Schema definition.
@@ -124,6 +126,11 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     withValidation(artifactTool),
     // Computer Use tools
     withValidation(computerUseTool),
+    // Scheduling tools
+    withValidation(scheduleWakeupTool),
+    withValidation(cronCreateTool),
+    withValidation(cronDeleteTool),
+    withValidation(cronListTool),
   ]
 
   const map = new Map<string, ToolDefinition>()

package/src/tools/scheduling/cron.ts

@@ -0,0 +1,168 @@
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  readdirSync,
+  existsSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { createHash } from 'node:crypto'
+import { homedir } from 'node:os'
+import type { ToolDefinition } from '../../shared/index.ts'
+
+const CRON_DIR = join(homedir(), '.mipham', 'cron')
+
+function ensureCronDir(): void {
+  if (!existsSync(CRON_DIR)) mkdirSync(CRON_DIR, { recursive: true })
+}
+
+interface CronJob {
+  id: string
+  cron: string
+  prompt: string
+  recurring: boolean
+  createdAt: string
+}
+
+function jobPath(id: string): string {
+  return join(CRON_DIR, `${id}.json`)
+}
+
+function generateId(cron: string, prompt: string): string {
+  return createHash('sha256').update(`${cron}:${prompt}`).digest('hex').slice(0, 12)
+}
+
+function readAllJobs(): CronJob[] {
+  ensureCronDir()
+  const jobs: CronJob[] = []
+  for (const file of readdirSync(CRON_DIR)) {
+    if (!file.endsWith('.json')) continue
+    try {
+      jobs.push(JSON.parse(readFileSync(join(CRON_DIR, file), 'utf-8')))
+    } catch {
+      /* skip corrupt files */
+    }
+  }
+  return jobs.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+}
+
+export const cronCreateTool: ToolDefinition = {
+  name: 'CronCreate',
+  description:
+    'Schedule a prompt to be enqueued at a future time. Uses standard 5-field cron in local timezone. ' +
+    'For recurring schedules (default): "0 9 * * *" = 9am daily. ' +
+    'For one-shot: set recurring:false with pinned minute/hour/day-of-month/month. ' +
+    'Durable — survives restarts, written to ~/.mipham/cron/.',
+  category: 'scheduling',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      cron: {
+        type: 'string',
+        description:
+          'Standard 5-field cron expression: "M H DoM Mon DoW" (e.g. "*/5 * * * *" = every 5 min).',
+      },
+      prompt: {
+        type: 'string',
+        description: 'The prompt to enqueue at each fire time.',
+      },
+      recurring: {
+        type: 'boolean',
+        description:
+          'true (default) = fire on every cron match. false = fire once then auto-delete.',
+      },
+    },
+    required: ['cron', 'prompt'],
+  },
+  async execute(params, _ctx) {
+    const cron = params.cron as string
+    const prompt = params.prompt as string
+    const recurring = params.recurring !== false
+    const id = generateId(cron, prompt)
+
+    ensureCronDir()
+
+    const job: CronJob = {
+      id,
+      cron,
+      prompt: prompt.slice(0, 1000),
+      recurring,
+      createdAt: new Date().toISOString(),
+    }
+
+    writeFileSync(jobPath(id), JSON.stringify(job, null, 2), 'utf-8')
+
+    const type = recurring ? 'recurring' : 'one-shot'
+    return {
+      success: true,
+      content:
+        `Created ${type} cron job.\n` +
+        `ID: ${id}\n` +
+        `Schedule: ${cron}\n` +
+        `Prompt: "${prompt.slice(0, 80)}${prompt.length > 80 ? '...' : ''}"`,
+    }
+  },
+}
+
+export const cronDeleteTool: ToolDefinition = {
+  name: 'CronDelete',
+  description:
+    'Cancel a cron job previously scheduled with CronCreate. Removes from ~/.mipham/cron/.',
+  category: 'scheduling',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'string',
+        description: 'Job ID returned by CronCreate.',
+      },
+    },
+    required: ['id'],
+  },
+  async execute(params, _ctx) {
+    const id = params.id as string
+    const path = jobPath(id)
+    if (!existsSync(path)) {
+      return { success: false, content: '', error: `Cron job "${id}" not found.` }
+    }
+    unlinkSync(path)
+    return { success: true, content: `Cron job "${id}" deleted.` }
+  },
+}
+
+export const cronListTool: ToolDefinition = {
+  name: 'CronList',
+  description: 'List all cron jobs scheduled via CronCreate, both durable and session-only.',
+  category: 'scheduling',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {},
+    required: [],
+  },
+  async execute(_params, _ctx) {
+    const jobs = readAllJobs()
+    if (jobs.length === 0) {
+      return {
+        success: true,
+        content:
+          'No scheduled cron jobs.\n\n' +
+          'Use CronCreate to schedule a recurring or one-shot job.\n' +
+          'Use /loop <interval> <prompt> to start a recurring task.',
+      }
+    }
+
+    const lines = [`── Scheduled Cron Jobs (${jobs.length}) ──`, '']
+    for (const j of jobs) {
+      const type = j.recurring ? 'recurring' : 'one-shot'
+      lines.push(`${j.id}  ${j.cron}  ${type}`)
+      lines.push(`  ${j.prompt.slice(0, 100)}`)
+      lines.push('')
+    }
+
+    return { success: true, content: lines.join('\n') }
+  },
+}

package/src/tools/scheduling/schedule-wakeup.ts

@@ -0,0 +1,117 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+
+/**
+ * Active wakeup timers — in-memory, per-session.
+ * Key: "sessionId:wakeup"
+ */
+const activeTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+export const scheduleWakeupTool: ToolDefinition = {
+  name: 'ScheduleWakeup',
+  description:
+    'Schedule when to resume work in /loop dynamic mode — the user invoked /loop without an interval, asking you to self-pace iterations of a specific task. Do NOT schedule a short-interval wakeup to poll for background work you started — when harness-tracked work finishes, you are re-invoked automatically. The runtime clamps to [60, 3600].',
+  category: 'scheduling',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      delaySeconds: {
+        type: 'number',
+        description: 'Seconds from now to wake up. Clamped to [60, 3600] by the runtime.',
+      },
+      reason: {
+        type: 'string',
+        description: 'One short sentence explaining the chosen delay.',
+      },
+      prompt: {
+        type: 'string',
+        description: 'The /loop input to fire on wake-up.',
+      },
+      stop: {
+        type: 'boolean',
+        description: 'Set to true to end the dynamic loop immediately.',
+      },
+    },
+    required: [],
+  },
+
+  async execute(params, ctx) {
+    const sessionId = ctx.sessionId
+
+    // ── Stop — cancel all timers for this session ──
+    if (params.stop === true) {
+      let cancelled = 0
+      for (const [key, timer] of activeTimers) {
+        if (key.startsWith(sessionId + ':')) {
+          clearTimeout(timer)
+          activeTimers.delete(key)
+          cancelled++
+        }
+      }
+      return {
+        success: true,
+        content: `Loop ended. ${cancelled} pending wakeup(s) cancelled.`,
+      }
+    }
+
+    // ── Schedule — validate and register timer ──
+    const delaySeconds = params.delaySeconds as number
+    const prompt = (params.prompt as string) || ''
+    const reason = (params.reason as string) || 'scheduled wakeup'
+
+    if (!delaySeconds || typeof delaySeconds !== 'number') {
+      return {
+        success: false,
+        content: '',
+        error: 'delaySeconds is required and must be a number in [60, 3600].',
+      }
+    }
+
+    if (delaySeconds < 60 || delaySeconds > 3600) {
+      return {
+        success: false,
+        content: '',
+        error: `delaySeconds must be in [60, 3600], got ${delaySeconds}.`,
+      }
+    }
+
+    // Cancel any previous timer for this session (one active wakeup per session)
+    for (const [key, timer] of activeTimers) {
+      if (key.startsWith(sessionId + ':')) {
+        clearTimeout(timer)
+        activeTimers.delete(key)
+      }
+    }
+
+    const timerKey = `${sessionId}:wakeup`
+    const timeoutId = setTimeout(() => {
+      activeTimers.delete(timerKey)
+    }, delaySeconds * 1000)
+
+    activeTimers.set(timerKey, timeoutId)
+
+    const mins = Math.floor(delaySeconds / 60)
+    const secs = delaySeconds % 60
+    const humanDelay = mins > 0 ? `${mins}m${secs > 0 ? `${secs}s` : ''}` : `${secs}s`
+
+    return {
+      success: true,
+      content:
+        `⏰ Wakeup scheduled in ${humanDelay} (${reason})\n` +
+        `Prompt: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+    }
+  },
+}
+
+/** Cancel all timers for a session. Called on session cleanup. */
+export function cancelAllSessionTimers(sessionId: string): number {
+  let count = 0
+  for (const [key, timer] of activeTimers) {
+    if (key.startsWith(sessionId + ':')) {
+      clearTimeout(timer)
+      activeTimers.delete(key)
+      count++
+    }
+  }
+  return count
+}

package/src/ui/commands.ts

@@ -74,7 +74,7 @@ const helpCmd: CommandHandler = (ctx) => {
       /cost          Token usage estimate
       /usage         Detailed usage dashboard
       /rename <name> Rename current session
-      /goal <text>   Set session goal
+      /goal <text> [--decompose] [--verify-script <path>] [--verify-skill <name>]   Set session goal with verification
       /recap         Summarize session so far
       /summary       Generate session summary
       /stats         Session usage statistics
@@ -129,8 +129,11 @@ const helpCmd: CommandHandler = (ctx) => {
       /pr-comments   PR review summary
       /diff          Show git diff
       /workflows     List workflow scripts
-      /loop <int> <p> Run prompt on interval
-      /loop init      Scaffold .mipham/ vault structure
+      /loop <int> <p>  Run prompt on interval
+      /loop auto <p>   Autonomous self-paced loop
+      /loop stop        Stop active autonomous loop
+      /loop init        Scaffold .mipham/ vault structure
+      /loop status      Show autonomous loop progress
       /batch          Apply changes across files
       /hooks          Manage lifecycle hook scripts
       /schedule      View scheduled tasks
@@ -570,17 +573,84 @@ const renameCmd: CommandHandler = (ctx, args) => {
 }
 
 const goalCmd: CommandHandler = (ctx, args) => {
-  const goal = args.join(' ')
-  if (!goal.trim()) {
-    return {
-      content: `Usage: /goal <statement>\n\nSet a session-level completion condition. Mipham Code will track progress toward this goal.\n\nExample: /goal Fix all TypeScript errors and make tests pass`,
+  const input = args.join(' ')
+
+  // ── Show goal status ──
+  if (!input.trim()) {
+    const state = ctx.engine.getGoalState?.() || { goal: undefined, decompose: false, subtasks: [] }
+    if (!state.goal) {
+      return {
+        content:
+          `Usage: /goal <statement> [options]\n\n` +
+          `Set a session-level completion condition with optional verification.\n\n` +
+          `Options:\n` +
+          `  --decompose              Auto-decompose goal into subtasks\n` +
+          `  --verify-script <path>   Run a shell script to check completion\n` +
+          `  --verify-skill <name>    Use a skill for verification\n\n` +
+          `Examples:\n` +
+          `  /goal Fix all TS errors and make tests pass --decompose\n` +
+          `  /goal Complete the build --verify-script ./check-build.sh\n` +
+          `  /goal Security audit passes --verify-skill security-review`,
+      }
     }
+    const lines = [`── Goal Status ──`, '', `🎯 Goal: ${state.goal}`]
+    if (state.verifyScript) lines.push(`📜 Verification: ${state.verifyScript}`)
+    if (state.verifySkill) lines.push(`🛠  Verification skill: ${state.verifySkill}`)
+    if (state.decompose) lines.push(`📋 Decompose: enabled (${state.subtasks.length} subtasks)`)
+    lines.push('', 'Type /goal without arguments to clear.')
+    return { content: lines.join('\n') }
   }
-  ctx.setGoal(goal.trim())
-  ctx.engine.setGoal(goal.trim())
-  return {
-    content: `✓ Goal set: "${goal.trim()}"\n\nUse /status to view progress. Type /goal without arguments to clear.`,
+
+  // ── Parse options ──
+  let goal = input
+  let decompose = false
+  let verifyScript: string | undefined
+  let verifySkill: string | undefined
+
+  // Extract --decompose
+  if (goal.includes(' --decompose')) {
+    decompose = true
+    goal = goal.replace(' --decompose', '')
+  }
+
+  // Extract --verify-script <path>
+  const scriptMatch = goal.match(/ --verify-script\s+(\S+)/)
+  if (scriptMatch) {
+    verifyScript = scriptMatch[1]!
+    goal = goal.replace(` --verify-script ${verifyScript}`, '')
+  }
+
+  // Extract --verify-skill <name>
+  const skillMatch = goal.match(/ --verify-skill\s+(\S+)/)
+  if (skillMatch) {
+    verifySkill = skillMatch[1]!
+    goal = goal.replace(` --verify-skill ${verifySkill}`, '')
+  }
+
+  goal = goal.trim()
+  if (!goal) {
+    return { content: 'Goal text is required. Use /goal without arguments to see usage.' }
   }
+
+  ctx.setGoal(goal)
+  ctx.engine.setGoal(goal, { verifyScript, verifySkill, decompose })
+
+  const lines = [`✓ Goal set: "${goal}"`]
+  if (decompose) {
+    lines.push('📋 Decomposition: enabled — AI will break goal into subtasks')
+    // Decompose by creating initial subtasks
+    const decomposeMsg = `Break down this goal into 3-5 subtasks: "${goal}". For each subtask, use TaskCreate with the subject and description. Mark each as blocked by the previous one to create a dependency chain.`
+    return {
+      content: lines.join('\n'),
+      forwardToAI: decomposeMsg,
+    }
+  }
+  if (verifyScript) lines.push(`📜 Verification: ${verifyScript}`)
+  if (verifySkill) lines.push(`🛠  Verification skill: ${verifySkill}`)
+  lines.push('')
+  lines.push('Use /status to view progress. Type /goal without arguments to clear.')
+
+  return { content: lines.join('\n') }
 }
 
 const recapCmd: CommandHandler = (ctx) => {
@@ -1208,25 +1278,94 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
     return { content: lines.join('\n') }
   }
 
-  // ── /loop <interval> <prompt> — recurring prompt ──
+  // ── /loop stop — stop autonomous loop ──
+  if (sub === 'stop') {
+    const { completeAutoloopJournal, listActiveAutoloops } =
+      await import('../commands/autoloop-journal.js')
+    const active = listActiveAutoloops()
+    if (active.length === 0) {
+      return { content: 'No active autonomous loops to stop.' }
+    }
+    for (const j of active) completeAutoloopJournal(j.sessionId, 'stopped')
+    return { content: `Stopped ${active.length} autonomous loop(s).` }
+  }
+
+  // ── /loop status — show autonomous loop progress ──
+  if (sub === 'status') {
+    const { listActiveAutoloops, getAutoloopStatus } =
+      await import('../commands/autoloop-journal.js')
+    const active = listActiveAutoloops()
+    if (active.length === 0) {
+      return { content: 'No active autonomous loops.\n\nUse /loop auto <prompt> to start one.' }
+    }
+    const lines = active.map((j) => getAutoloopStatus(j.sessionId))
+    return { content: lines.join('\n\n') }
+  }
+
+  // ── /loop auto <prompt> — autonomous self-paced loop ──
+  if (sub === 'auto') {
+    const prompt = args.slice(1).join(' ')
+    if (!prompt.trim()) {
+      return {
+        content:
+          'Usage: /loop auto <prompt>\n\n' +
+          'Start an autonomous self-paced loop. The AI will:\n' +
+          '1. Work on the task\n' +
+          '2. Decide how long to wait before the next iteration\n' +
+          '3. Use ScheduleWakeup to self-schedule\n' +
+          '4. Use ScheduleWakeup(stop:true) when the goal is reached\n\n' +
+          'Use /loop status to view progress.\n' +
+          'Use /loop stop to stop the loop.',
+      }
+    }
+
+    const sessionId = `autoloop-${Date.now()}`
+    const { createAutoloopJournal } = await import('../commands/autoloop-journal.js')
+    createAutoloopJournal(sessionId, prompt)
+
+    const autoPrompt =
+      `## Autonomous Loop — ${sessionId}\n\n` +
+      `Task: ${prompt}\n\n` +
+      `You are in an autonomous loop. Each iteration:\n` +
+      `1. Make progress on the task above\n` +
+      `2. When you need to wait (e.g., for a deploy, CI, external event), call ScheduleWakeup with:\n` +
+      `   - delaySeconds: your best estimate of how long to wait (60-3600)\n` +
+      `   - reason: one sentence explaining why\n` +
+      `   - prompt: include this full autonomous loop ID: ${sessionId}\n` +
+      `3. When the task is COMPLETE, call ScheduleWakeup with stop:true\n\n` +
+      `After each iteration, log progress by reading/writing the journal at ~/.mipham/autoloop/${sessionId}.json.\n` +
+      `Use the autoloop-journal module: logAutoloopIteration("${sessionId}", "<summary>").`
+
+    return {
+      content:
+        `── Autonomous Loop Started ──\n\n` +
+        `ID:      ${sessionId}\n` +
+        `Prompt:  "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"\n\n` +
+        `The AI will self-pace. Use /loop status to view progress.\n` +
+        `Use /loop stop to stop.`,
+      forwardToAI: autoPrompt,
+    }
+  }
+
+  // ── /loop <interval> <prompt> — recurring prompt (or auto-detect autonomous) ──
   if (args.length < 2) {
     return {
       content: stripIndent`
-        Usage: /loop <interval> <prompt>
-           or: /loop init [path]     Scaffold project vault structure
+        Usage: /loop <interval> <prompt>     Fixed-interval loop
+           or: /loop auto <prompt>           Autonomous self-paced loop
+           or: /loop stop                     Stop active autonomous loop
+           or: /loop status                   Show autonomous loop progress
+           or: /loop init [path]              Scaffold project vault structure
 
-        Run a prompt repeatedly on a set interval, or initialize
-        a LoopKit Vault project structure with Mipham Code config.
-
-        Interval formats:
+        Fixed interval formats:
           10s   — 10 seconds
           5m    — 5 minutes
           1h    — 1 hour
 
-        Example:
+        Examples:
           /loop 5m check the deploy status
-          /loop init              Create vault in current directory
-          /loop init ~/my-project Create vault in specific directory
+          /loop auto monitor CI and fix failing tests
+          /loop init                  Create vault in current directory
       `,
     }
   }
@@ -1235,34 +1374,66 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
   const prompt = args.slice(1).join(' ')
   const seconds = parseInterval(interval)
 
+  // Auto-detect: if first arg is not a valid interval, assume autonomous mode
   if (seconds === null) {
+    // Could be: /loop <full prompt without interval>
+    const fullPrompt = args.join(' ')
+    if (fullPrompt.length > 0) {
+      const sessionId = `autoloop-${Date.now()}`
+      const { createAutoloopJournal } = await import('../commands/autoloop-journal.js')
+      createAutoloopJournal(sessionId, fullPrompt)
+
+      const autoPrompt =
+        `## Autonomous Loop — ${sessionId}\n\n` +
+        `Task: ${fullPrompt}\n\n` +
+        `You are in an autonomous loop (auto-detected — no interval specified). Each iteration:\n` +
+        `1. Make progress on the task above\n` +
+        `2. When you need to wait, call ScheduleWakeup with your chosen delaySeconds and this loop ID: ${sessionId}\n` +
+        `3. When COMPLETE, call ScheduleWakeup with stop:true\n\n` +
+        `Log progress using logAutoloopIteration("${sessionId}", "<summary>").`
+
+      return {
+        content:
+          `── Autonomous Loop Started (auto-detected) ──\n\n` +
+          `ID:      ${sessionId}\n` +
+          `Prompt:  "${fullPrompt.slice(0, 100)}${fullPrompt.length > 100 ? '...' : ''}"\n\n` +
+          `No interval specified — using autonomous self-paced mode.\n` +
+          `Use /loop stop to stop.`,
+        forwardToAI: autoPrompt,
+      }
+    }
     return {
-      content: `── Invalid Interval ──\n\n"${interval}" is not a recognised interval.\n\nUse formats like: 10s, 5m, 1h, 30min, 2hr`,
+      content: `── Invalid Interval ──\n\n"${interval}" is not a recognised interval.\n\nUse formats like: 10s, 5m, 1h, 30min, 2hr\nOr use /loop auto <prompt> for autonomous mode.`,
     }
   }
 
-  return {
-    content: `── Loop Started ──\n\nInterval: ${interval} (${seconds}s)\nPrompt:   "${prompt}"\n\nScheduling via ScheduleWakeup — the prompt will re-schedule itself each cycle.\nUse /schedule to view active loops.`,
-    forwardToAI: `use ScheduleWakeup to set up a recurring loop. delaySeconds=${seconds}, prompt: "${prompt}". Include at the end of the prompt: "Then call ScheduleWakeup again with delaySeconds=${seconds} and the same prompt to continue the loop."`,
+  // Fixed-interval loop — directly invoke ScheduleWakeup
+  try {
+    const { scheduleWakeupTool } = await import('../tools/scheduling/schedule-wakeup.js')
+    const result = await scheduleWakeupTool.execute(
+      { delaySeconds: seconds, reason: `Loop: ${prompt.slice(0, 40)}`, prompt },
+      { cwd: process.cwd(), sessionId: 'loop-session', provider: '', model: '' },
+    )
+    return result.success
+      ? { content: result.content }
+      : { content: `Loop failed: ${result.error || 'unknown error'}` }
+  } catch (e) {
+    return { content: `Loop failed: ${e instanceof Error ? e.message : String(e)}` }
   }
 }
 
-const scheduleCmd: CommandHandler = (_ctx) => ({
-  content: stripIndent`
-    ── Scheduled Tasks ──
-
-    Fetching active scheduled tasks and loops...
-
-    Active loops are managed via ScheduleWakeup (in-session) and
-    CronCreate (durable, survives restarts).
-
-    Use /loop <interval> <prompt> to start a recurring task.
-    Use CronList to view all scheduled jobs.
-    Use CronDelete <id> to cancel a durable job.
-  `,
-  forwardToAI:
-    'Use CronList to show all currently scheduled cron jobs (both durable and session-only). Present them in a clear table with: name/ID, schedule (cron expression), type (recurring vs one-shot), and status. Also note any active ScheduleWakeup loops if visible in the current session. If no scheduled tasks exist, suggest: "No scheduled tasks. Use /loop <interval> <prompt> to create a recurring task."',
-})
+const scheduleCmd: CommandHandler = async (_ctx) => {
+  try {
+    const { cronListTool } = await import('../tools/scheduling/cron.js')
+    const result = await cronListTool.execute(
+      {},
+      { cwd: process.cwd(), sessionId: 'schedule-view', provider: '', model: '' },
+    )
+    return { content: result.content }
+  } catch (e) {
+    return { content: `Schedule check failed: ${e instanceof Error ? e.message : String(e)}` }
+  }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // Diagnostic