@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/commands/runner-queue.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const {
+  ensureRunnerQueue,
+  addTask,
+  listTasks,
+  nextPending,
+  updateTaskStatus,
+  clearQueue,
+  exportQueueMarkdown
+} = require('../runner/queue-store');
+const { launchCLI } = require('../runner/cli-launcher');
+const { runWithCascade, parseCascadeChain } = require('../runner/cascade');
+
+const STATUS_ICON = {
+  pending: '○',
+  running: '▶',
+  completed: '✓',
+  failed: '✗',
+  skipped: '—'
+};
+
+/**
+ * aioson runner:queue — gerencia e executa a fila de tasks do runner.
+ *
+ * Subcomandos:
+ *   add <path> "task description" [--agent=dev] [--cascade=haiku,sonnet]
+ *   list <path>
+ *   run <path> [--agent=dev] [--timeout=120]
+ *   export <path>
+ *   clear <path>
+ */
+async function runRunnerQueue({ args, options = {}, logger }) {
+  const sub = options.sub || args[1] || 'list';
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+
+  const handle = await openRuntimeDb(projectDir, {});
+  if (!handle) {
+    logger.error('Could not open runtime database.');
+    return { ok: false };
+  }
+  const { db } = handle;
+  ensureRunnerQueue(db);
+
+  try {
+    switch (sub) {
+      case 'add':    return await handleAdd(db, args, options, logger);
+      case 'list':   return handleList(db, logger);
+      case 'run':    return await handleRun(db, projectDir, options, logger);
+      case 'export': return handleExport(db, logger);
+      case 'clear':  return handleClear(db, logger);
+      default:
+        logger.error(`Unknown subcommand: ${sub}. Use add, list, run, export, or clear.`);
+        return { ok: false };
+    }
+  } finally {
+    try { db.close(); } catch { /* noop */ }
+  }
+}
+
+function handleAdd(db, args, options, logger) {
+  // Task pode vir de args[2] ou --task
+  const task = options.task || args[2];
+  if (!task) {
+    logger.error('Task description required. Usage: aioson runner:queue add . "task description"');
+    return { ok: false };
+  }
+  const agent = options.agent || 'dev';
+  const cascade = options.cascade || null;
+  const priority = options.priority ? Number(options.priority) : 0;
+
+  const id = addTask(db, { task, agent, cascade, priority });
+  logger.log(`[runner:queue] Added task #${id}: ${task}`);
+  logger.log(`  Agent: @${agent}${cascade ? ' | Cascade: ' + cascade : ''}`);
+  return { ok: true, id };
+}
+
+function handleList(db, logger) {
+  const tasks = listTasks(db);
+  if (tasks.length === 0) {
+    logger.log('[runner:queue] Queue is empty. Use `runner:queue add` to add tasks.');
+    return { ok: true, tasks: [] };
+  }
+
+  logger.log(`[runner:queue] ${tasks.length} task(s):`);
+  for (const t of tasks) {
+    const icon = STATUS_ICON[t.status] || '?';
+    const cascade = t.cascade ? ` [cascade: ${t.cascade}]` : '';
+    logger.log(`  ${icon} ${t.id}  @${t.agent}${cascade}  ${t.task}`);
+  }
+  return { ok: true, tasks };
+}
+
+async function handleRun(db, projectDir, options, logger) {
+  const defaultAgent = options.agent || 'dev';
+  const timeout = options.timeout ? Number(options.timeout) * 1000 : 120000;
+
+  let processed = 0;
+  let failed = 0;
+
+  logger.log('[runner:queue] Starting queue execution...');
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const task = nextPending(db);
+    if (!task) {
+      logger.log(`[runner:queue] Queue exhausted. ${processed} completed, ${failed} failed.`);
+      break;
+    }
+
+    const agent = task.agent || defaultAgent;
+    const agentFile = path.join(projectDir, '.aioson', 'agents', `${agent}.md`);
+    const prompt = buildQueuePrompt(task.task, agentFile);
+
+    logger.log(`\n[runner:queue] Running task #${task.id}: ${task.task}`);
+    logger.log(`  Agent: @${agent}`);
+
+    updateTaskStatus(db, task.id, { status: 'running' });
+
+    let result;
+    const cascadeChain = parseCascadeChain(task.cascade);
+
+    try {
+      if (cascadeChain.length > 0) {
+        const cascadeResult = await runWithCascade(projectDir, prompt, cascadeChain, {
+          timeout,
+          onProgress: ({ model, attempt, maxAttempts, status, reason }) => {
+            if (status === 'running') {
+              logger.log(`  [cascade] ${model} attempt ${attempt}/${maxAttempts}...`);
+            } else if (status === 'gate_failed') {
+              logger.log(`  [cascade] ${model} attempt ${attempt} — gate failed${reason ? ': ' + reason : ''}, escalating...`);
+            }
+          }
+        });
+        result = cascadeResult.ok
+          ? cascadeResult.result
+          : { ok: false, output: '', error: cascadeResult.error };
+      } else {
+        result = await launchCLI(projectDir, prompt, {
+          timeout,
+          onData: (chunk) => process.stdout.write(chunk)
+        });
+      }
+    } catch (err) {
+      result = { ok: false, output: '', error: err.message };
+    }
+
+    if (result.ok) {
+      updateTaskStatus(db, task.id, { status: 'completed', resultOk: true });
+      logger.log(`  [runner:queue] Task #${task.id} completed`);
+      processed++;
+    } else {
+      const errorMsg = result.error || result.stderr || 'unknown error';
+      updateTaskStatus(db, task.id, { status: 'failed', resultOk: false, errorMsg });
+      logger.error(`  [runner:queue] Task #${task.id} failed: ${errorMsg}`);
+      failed++;
+    }
+  }
+
+  return { ok: true, processed, failed };
+}
+
+function handleExport(db, logger) {
+  const markdown = exportQueueMarkdown(db);
+  process.stdout.write(markdown);
+  return { ok: true };
+}
+
+function handleClear(db, logger) {
+  clearQueue(db);
+  logger.log('[runner:queue] Queue cleared.');
+  return { ok: true };
+}
+
+function buildQueuePrompt(task, agentFile) {
+  return [
+    'You are operating in autonomous headless mode. Complete the following task independently.',
+    `Agent role: read ${agentFile} for your operating instructions.`,
+    '',
+    `Task: ${task}`,
+    '',
+    'When the task is complete, write TASK_COMPLETE on a new line as the final output.',
+    'If you cannot complete the task, write TASK_FAILED: [reason].'
+  ].join('\n');
+}
+
+module.exports = { runRunnerQueue };

package/src/commands/runner-run.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const path = require('node:path');
+const { launchCLI, detectCLI } = require('../runner/cli-launcher');
+const { runWithCascade, parseCascadeChain } = require('../runner/cascade');
+const { openRuntimeDb, startRun, updateRun, createRunKey } = require('../runtime-store');
+
+/**
+ * aioson runner:run — executa uma única task headless usando o CLI de AI ativo.
+ *
+ * Usage:
+ *   aioson runner:run . --task="Fix the auth modal" --agent=dev
+ *   aioson runner:run . --task="..." --agent=qa --timeout=300
+ *   aioson runner:run . --task="..." --agent=dev --cascade=haiku,sonnet
+ *   aioson runner:run . --task="..." --dry-run
+ */
+async function runRunnerRun({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const { task, agent = 'dev', dryRun, cascade: cascadeStr } = options;
+  const timeout = options.timeout ? Number(options.timeout) * 1000 : 120000;
+
+  if (!task) {
+    logger.error('--task is required. Example: aioson runner:run . --task="Fix the login modal"');
+    return { ok: false };
+  }
+
+  const agentFile = path.join(projectDir, '.aioson', 'agents', `${agent}.md`);
+  const prompt = buildRunnerPrompt(task, agentFile);
+
+  if (dryRun) {
+    let cli;
+    try { cli = await detectCLI(); } catch { cli = 'claude'; }
+    logger.log(`[dry-run] Would run: ${cli} -p "${prompt.slice(0, 120)}..."`);
+    logger.log(`[dry-run] Agent: @${agent} | Timeout: ${timeout / 1000}s`);
+    if (cascadeStr) logger.log(`[dry-run] Cascade: ${cascadeStr}`);
+    return { ok: true, dryRun: true };
+  }
+
+  logger.log(`[runner] Task: ${task}`);
+  logger.log(`[runner] Agent: @${agent} | Timeout: ${timeout / 1000}s`);
+  if (cascadeStr) logger.log(`[runner] Cascade: ${cascadeStr}`);
+
+  const start = Date.now();
+
+  // Abre DB para registrar evento (melhor esforço — não bloqueia se não existir)
+  let db = null;
+  let runKey = null;
+  try {
+    const handle = await openRuntimeDb(projectDir, {});
+    if (handle) {
+      db = handle.db;
+      runKey = createRunKey(agent);
+      startRun(db, {
+        runKey,
+        agentName: agent,
+        agentKind: 'runner',
+        source: 'runner',
+        title: task.slice(0, 80),
+        status: 'running',
+        message: `Runner task started: ${task.slice(0, 80)}`
+      });
+    }
+  } catch { /* dashboard logging is best-effort */ }
+
+  let result;
+  const cascadeChain = parseCascadeChain(cascadeStr);
+
+  if (cascadeChain.length > 0) {
+    const cascadeResult = await runWithCascade(projectDir, prompt, cascadeChain, {
+      timeout,
+      onProgress: ({ model, attempt, maxAttempts, status, reason }) => {
+        if (status === 'running') {
+          logger.log(`[cascade] ${model} attempt ${attempt}/${maxAttempts}...`);
+        } else if (status === 'gate_failed') {
+          logger.log(`[cascade] ${model} attempt ${attempt} — gate failed${reason ? ': ' + reason : ''}, escalating...`);
+        } else if (status === 'cli_failed') {
+          logger.log(`[cascade] ${model} attempt ${attempt} — CLI failed, retrying...`);
+        }
+      }
+    });
+    if (cascadeResult.ok) {
+      result = cascadeResult.result;
+      logger.log(`[runner] Completed via ${cascadeResult.modelUsed} (attempt ${cascadeResult.attempts})`);
+    } else {
+      result = { ok: false, output: '', completionMarker: false };
+      logger.error(`[runner] ${cascadeResult.error}`);
+    }
+  } else {
+    result = await launchCLI(projectDir, prompt, {
+      timeout,
+      onData: (chunk) => process.stdout.write(chunk)
+    });
+  }
+
+  const elapsed = Math.round((Date.now() - start) / 1000);
+  const status = result.ok ? 'completed' : 'failed';
+
+  logger.log(`\n[runner] Task ${status} in ${elapsed}s`);
+  if (result.completionMarker) logger.log('[runner] TASK_COMPLETE marker detected');
+
+  // Atualiza run no dashboard
+  if (db && runKey) {
+    try {
+      updateRun(db, {
+        runKey,
+        status,
+        message: `Runner task ${status}: ${task.slice(0, 80)}`,
+        payload: { task, agent, elapsed, ok: result.ok, completionMarker: result.completionMarker }
+      });
+    } catch { /* best-effort */ }
+    try { db.close(); } catch { /* noop */ }
+  }
+
+  return { ok: result.ok, output: result.output, elapsed, completionMarker: result.completionMarker };
+}
+
+function buildRunnerPrompt(task, agentFile) {
+  return [
+    'You are operating in autonomous headless mode. Complete the following task independently.',
+    `Agent role: read ${agentFile} for your operating instructions.`,
+    '',
+    `Task: ${task}`,
+    '',
+    'When the task is complete, write TASK_COMPLETE on a new line as the final output.',
+    'If you cannot complete the task, write TASK_FAILED: [reason].'
+  ].join('\n');
+}
+
+module.exports = { runRunnerRun };

package/src/commands/runtime.js

@@ -1179,6 +1179,11 @@ async function runAgentDone({ args, options = {}, logger, t }) {
   const summary = String(options.summary || options.message || `${normalizedAgent} session completed`).trim();
   const title = options.title ? String(options.title).trim() : null;
   const status = options.status || 'completed';
+  const verdict = options.verdict ? String(options.verdict).trim().toUpperCase() : null;
+  const planStepId = options['plan-step'] ? String(options['plan-step']).trim() : null;
+  const artifactPaths = options.artifacts
+    ? String(options.artifacts).split(',').map((p) => p.trim()).filter(Boolean)
+    : [];
 
   const { db, dbPath, runtimeDir } = await openRuntimeDb(targetDir);
 
@@ -1194,9 +1199,24 @@ async function runAgentDone({ args, options = {}, logger, t }) {
         eventType: 'agent_done',
         phase: 'live',
         status: 'running',
-        message: summary
+        message: summary,
+        verdict,
+        planStepId
       });
 
+      if (artifactPaths.length > 0) {
+        for (const filePath of artifactPaths) {
+          try {
+            attachArtifact(db, {
+              runKey: session.runKey,
+              agentName: normalizedAgent,
+              kind: 'output',
+              filePath
+            });
+          } catch { /* non-fatal */ }
+        }
+      }
+
       if (!options.json) {
         logger.log(`agent:done — ${normalizedAgent} | live session active, event logged | run: ${session.runKey} (${dbPath})`);
       }
@@ -1219,6 +1239,32 @@ async function runAgentDone({ args, options = {}, logger, t }) {
       summary
     });
 
+    if (verdict || planStepId) {
+      appendRunEvent(db, {
+        runKey,
+        eventType: 'agent_done',
+        phase: 'direct',
+        status: 'completed',
+        message: summary,
+        verdict,
+        planStepId
+      });
+    }
+
+    if (artifactPaths.length > 0) {
+      for (const filePath of artifactPaths) {
+        try {
+          attachArtifact(db, {
+            runKey,
+            taskKey,
+            agentName: normalizedAgent,
+            kind: 'output',
+            filePath
+          });
+        } catch { /* non-fatal */ }
+      }
+    }
+
     if (!options.json) {
       logger.log(`agent:done — ${normalizedAgent} | task: ${taskKey} | run: ${runKey} (${dbPath})`);
     }

package/src/commands/sandbox.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('node:path');
+const { executeInSandbox } = require('../sandbox');
+
+async function runSandboxExec({ args, options, logger }) {
+  const command = args[0] || options.command || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const timeout = Number(options.timeout) || 30_000;
+  const intent = options.intent || undefined;
+
+  if (!command) {
+    logger.error('Usage: aioson sandbox:exec "<command>" [--timeout=30000] [--cwd=.]');
+    return { ok: false, error: 'missing_command' };
+  }
+
+  const result = await executeInSandbox(command, { cwd, timeout, intent });
+
+  if (options.json) {
+    return { ok: result.ok, ...result };
+  }
+
+  if (result.stdout) {
+    logger.log(result.stdout);
+  }
+  if (result.stderr) {
+    logger.error(result.stderr);
+  }
+
+  if (result.timedOut) {
+    logger.error(`Command timed out after ${timeout}ms`);
+  }
+
+  return { ok: result.ok, ...result };
+}
+
+module.exports = { runSandboxExec };

package/src/commands/self-implement-loop.js

@@ -0,0 +1,256 @@
+'use strict';
+
+/**
+ * aioson self:loop — Autonomous implement + verify loop
+ *
+ * Runs an agent task, verifies with verify-gate in a fresh context,
+ * and retries with feedback injection on failure.
+ *
+ * Usage:
+ *   aioson self:loop . --agent=dev --task="implement stripe webhook handler" --max-iterations=3
+ *   aioson self:loop . --agent=dev --task="..." --verification-criteria="all tests pass"
+ *   aioson self:loop . --agent=dev --task="..." --spec=briefs/phase-1.md --artifact=src/
+ *
+ * Integrates with:
+ *   - verify-gate.js for tiered verification (tiers 1–4)
+ *   - intra-bus.js for recording attempts
+ *   - state-manager.js for recording final result
+ */
+
+const path = require('node:path');
+const { execSync, execFileSync } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+const fs = require('node:fs/promises');
+
+const bus = require('../squad/intra-bus');
+const stateManager = require('../squad/state-manager');
+
+// ─── Agent execution ─────────────────────────────────────────────────────────
+
+/**
+ * Execute an agent task via the aioson CLI.
+ * Returns { ok, output, error }.
+ */
+function executeAgent(projectDir, agent, task, feedbackContext, timeoutMs) {
+  const prompt = feedbackContext
+    ? `${task}\n\n---\nPrevious attempt feedback:\n${feedbackContext}`
+    : task;
+
+  try {
+    const output = execSync(
+      `aioson agent:prompt ${agent} . --tool=claude`,
+      {
+        cwd: projectDir,
+        input: prompt,
+        timeout: timeoutMs,
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024 * 5,
+        stdio: ['pipe', 'pipe', 'pipe']
+      }
+    );
+    return { ok: true, output: output.trim() };
+  } catch (err) {
+    return { ok: false, output: '', error: err.message.slice(0, 500) };
+  }
+}
+
+/**
+ * Run verify-gate on the result.
+ * Returns { ok, verdict, issues }.
+ */
+async function runVerification(projectDir, spec, artifact, criteria) {
+  if (!spec || !artifact) {
+    // Fallback: criteria-only verification
+    return criteriaOnlyVerify(projectDir, artifact, criteria);
+  }
+
+  try {
+    const output = execSync(
+      `aioson verify:gate . --spec="${spec}" --artifact="${artifact}" --json`,
+      {
+        cwd: projectDir,
+        timeout: 30_000,
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024
+      }
+    );
+    const result = JSON.parse(output);
+    return {
+      ok: result.verdict === 'PASS' || result.verdict === 'PASS_WITH_NOTES',
+      verdict: result.verdict,
+      issues: result.issues || []
+    };
+  } catch (err) {
+    return { ok: false, verdict: 'BLOCKED', issues: [{ message: err.message.slice(0, 200) }] };
+  }
+}
+
+/**
+ * Simple criteria-based verification when no spec/artifact is given.
+ * Checks if verification criteria strings are present in the output directory.
+ */
+async function criteriaOnlyVerify(projectDir, artifactPath, criteria) {
+  if (!criteria) {
+    return { ok: true, verdict: 'PASS', issues: [] };
+  }
+
+  const issues = [];
+  const criteriaList = criteria.split(',').map((c) => c.trim());
+
+  for (const criterion of criteriaList) {
+    if (/test/i.test(criterion)) {
+      // Check if tests pass
+      try {
+        execSync('npm test --if-present 2>&1', {
+          cwd: projectDir,
+          timeout: 60_000,
+          encoding: 'utf8'
+        });
+      } catch {
+        issues.push({ message: `Test criterion failed: "${criterion}"` });
+      }
+    }
+  }
+
+  return {
+    ok: issues.length === 0,
+    verdict: issues.length === 0 ? 'PASS' : 'FAIL_WITH_ISSUES',
+    issues
+  };
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Run the self-implement loop.
+ *
+ * @param {object} params
+ * @returns {Promise<object>}  — { ok, iterations, verdict, feedback[] }
+ */
+async function runSelfLoop({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const agent = String(options.agent || options.a || 'dev').trim();
+  const task = String(options.task || options.t || '').trim();
+  const maxIterations = Math.min(Math.max(Number(options['max-iterations'] || 3), 1), 5);
+  const spec = options.spec ? String(options.spec).trim() : null;
+  const artifact = options.artifact ? String(options.artifact).trim() : null;
+  const criteria = options['verification-criteria'] || options.criteria || '';
+  const squad = options.squad ? String(options.squad).trim() : null;
+  const timeoutMs = (Number(options.timeout) || 300) * 1000;
+
+  if (!task) {
+    logger.error('Error: --task is required');
+    return { ok: false, error: 'missing_task' };
+  }
+
+  const sessionId = randomUUID();
+  const feedbackHistory = [];
+
+  logger.log(`Self-implement loop: @${agent} — "${task.slice(0, 60)}${task.length > 60 ? '...' : ''}"`);
+  logger.log(`Max iterations: ${maxIterations}`);
+  if (spec) logger.log(`Spec: ${spec}`);
+  if (artifact) logger.log(`Artifact: ${artifact}`);
+  logger.log('');
+
+  for (let iteration = 1; iteration <= maxIterations; iteration++) {
+    logger.log(`── Iteration ${iteration}/${maxIterations} ──────────────────────────`);
+
+    // Step 1: Execute agent
+    const feedbackContext = feedbackHistory.length > 0
+      ? feedbackHistory.map((f) => `[Iteration ${f.iteration}] ${f.verdict}: ${f.issues.map((i) => i.message).join('; ')}`).join('\n')
+      : null;
+
+    logger.log(`  Running @${agent}...`);
+    const agentResult = executeAgent(targetDir, agent, task, feedbackContext, timeoutMs);
+
+    if (!agentResult.ok) {
+      logger.log(`  ✗ Agent execution failed: ${agentResult.error?.slice(0, 100)}`);
+      // Record on bus if squad context
+      if (squad) {
+        await bus.post(targetDir, squad, sessionId, {
+          from: 'self-loop',
+          type: 'status',
+          content: `Iteration ${iteration} — agent failed: ${agentResult.error?.slice(0, 200)}`
+        }).catch(() => {});
+      }
+      continue;
+    }
+
+    // Step 2: Verify (fresh context)
+    logger.log('  Verifying...');
+    const verifyResult = await runVerification(targetDir, spec, artifact, criteria);
+
+    // Record on bus
+    if (squad) {
+      await bus.post(targetDir, squad, sessionId, {
+        from: 'self-loop',
+        type: verifyResult.ok ? 'result' : 'gap_closure_attempt',
+        content: `Iteration ${iteration}: ${verifyResult.verdict}`,
+        metadata: {
+          iteration,
+          verdict: verifyResult.verdict,
+          issues_count: verifyResult.issues.length
+        }
+      }).catch(() => {});
+    }
+
+    // Step 3: Check result
+    if (verifyResult.ok) {
+      logger.log(`  ✓ PASS${iteration > 1 ? ` (after ${iteration} iteration${iteration > 1 ? 's' : ''})` : ''}`);
+
+      // Record success in state
+      if (squad) {
+        await stateManager.updateState(targetDir, squad, {
+          addDecision: [`self-loop: "${task.slice(0, 50)}" completed in ${iteration} iteration(s)`]
+        }).catch(() => {});
+      }
+
+      if (options.json) {
+        return { ok: true, iterations: iteration, verdict: verifyResult.verdict, feedback: feedbackHistory };
+      }
+
+      return { ok: true, iterations: iteration, verdict: verifyResult.verdict };
+    }
+
+    // Step 4: Collect feedback for next iteration
+    logger.log(`  ✗ ${verifyResult.verdict} — ${verifyResult.issues.length} issue(s)`);
+    for (const issue of verifyResult.issues.slice(0, 5)) {
+      logger.log(`    - ${issue.message}`);
+    }
+
+    feedbackHistory.push({
+      iteration,
+      verdict: verifyResult.verdict,
+      issues: verifyResult.issues
+    });
+  }
+
+  // Step 5: Exhausted — escalate
+  logger.log('');
+  logger.log(`✗ Max iterations (${maxIterations}) exhausted — escalating to user`);
+
+  if (squad) {
+    await bus.post(targetDir, squad, sessionId, {
+      from: 'self-loop',
+      type: 'block',
+      content: `Self-implement loop exhausted ${maxIterations} iterations for: "${task.slice(0, 100)}"`,
+      metadata: { exhausted: true, iterations: maxIterations }
+    }).catch(() => {});
+
+    await stateManager.updateState(targetDir, squad, {
+      addBlocker: [`self-loop exhausted: "${task.slice(0, 50)}" (${maxIterations} iterations)`]
+    }).catch(() => {});
+  }
+
+  const result = {
+    ok: false,
+    iterations: maxIterations,
+    verdict: 'EXHAUSTED',
+    feedback: feedbackHistory
+  };
+
+  if (options.json) return result;
+  return result;
+}
+
+module.exports = { runSelfLoop };