@jaimevalasek/aioson 1.3.0 → 1.5.1

package/src/cli.js

@@ -11,6 +11,7 @@ const { runDoctorCommand } = require('./commands/doctor');
 const { runI18nAdd } = require('./commands/i18n-add');
 const { runAgentsList, runAgentPrompt } = require('./commands/agents');
 const { runContextValidate } = require('./commands/context-validate');
+const { runContextPack } = require('./commands/context-pack');
 const { runSetupContext } = require('./commands/setup-context');
 const { runLocaleApply } = require('./commands/locale-apply');
 const { runSmokeTest } = require('./commands/smoke');
@@ -19,6 +20,7 @@ const { runMcpDoctor } = require('./commands/mcp-doctor');
 const { runPackageTest } = require('./commands/package-e2e');
 const { runWorkflowPlan } = require('./commands/workflow-plan');
 const { runWorkflowNext } = require('./commands/workflow-next');
+const { runWorkflowStatus } = require('./commands/workflow-status');
 const { runParallelInit } = require('./commands/parallel-init');
 const { runParallelDoctor } = require('./commands/parallel-doctor');
 const { runParallelAssign } = require('./commands/parallel-assign');
@@ -30,6 +32,8 @@ const { runQaInit } = require('./commands/qa-init');
 const { runQaRun } = require('./commands/qa-run');
 const { runQaScan } = require('./commands/qa-scan');
 const { runQaReport } = require('./commands/qa-report');
+const { runWebMap } = require('./commands/web-map');
+const { runWebScrape } = require('./commands/web-scrape');
 const { runScanProject } = require('./commands/scan-project');
 const { runConfig } = require('./commands/config');
 const { runGenomeDoctor } = require('./commands/genome-doctor');
@@ -40,6 +44,23 @@ const { runSquadRepairGenomes } = require('./commands/squad-repair-genomes');
 const { runSquadValidate } = require('./commands/squad-validate');
 const { runSquadExport } = require('./commands/squad-export');
 const { runSquadPipeline } = require('./commands/squad-pipeline');
+const { runSquadAgentCreate } = require('./commands/squad-agent-create');
+const { runSquadInvestigate } = require('./commands/squad-investigate');
+const { runImplementationPlan } = require('./commands/implementation-plan');
+const { runSquadPlan } = require('./commands/squad-plan');
+const { runSquadLearning } = require('./commands/squad-learning');
+const { runLearning } = require('./commands/learning');
+const { runSquadDashboard } = require('./commands/squad-dashboard');
+const { runSquadWorker } = require('./commands/squad-worker');
+const { runSquadDaemon } = require('./commands/squad-daemon');
+const { runSquadMcp } = require('./commands/squad-mcp');
+const { runSquadRoi } = require('./commands/squad-roi');
+const { runSquadScore } = require('./commands/squad-score');
+const { runSquadProcesses } = require('./commands/squad-processes');
+const { runSquadWorktrees, runSquadMerge } = require('./commands/squad-worktrees');
+const { runSquadRecovery } = require('./commands/squad-recovery');
+const { runSquadDeploy } = require('./commands/squad-deploy');
+const { runSquadWebhook } = require('./commands/squad-webhook');
 const {
   runRuntimeInit,
   runRuntimeIngest,
@@ -51,14 +72,43 @@ const {
   runRuntimeTaskFail,
   runRuntimeFail,
   runRuntimeStatus,
-  runRuntimeLog
+  runRuntimeLog,
+  runAgentDone,
+  runAgentRecover,
+  runRuntimeSessionStart,
+  runRuntimeSessionLog,
+  runRuntimeSessionFinish,
+  runRuntimeSessionStatus,
+  runDeliver,
+  runOutputStrategyExport,
+  runOutputStrategyImport,
+  runDevlogSync,
+  runRuntimePrune
 } = require('./commands/runtime');
+const {
+  runLiveStart,
+  runRuntimeEmit,
+  runLiveHandoff,
+  runLiveStatus,
+  runLiveClose,
+  runLiveList
+} = require('./commands/live');
 const {
   runCloudImportSquad,
   runCloudImportGenome,
   runCloudPublishGenome,
   runCloudPublishSquad
 } = require('./commands/cloud');
+const {
+  runRuntimeBackup,
+  runRuntimeRestore
+} = require('./commands/backup');
+const {
+  runSkillInstall,
+  runSkillList,
+  runSkillRemove
+} = require('./commands/skill');
+const { runBackupLocal } = require('./commands/backup-local-cmd');
 
 const JSON_SUPPORTED_COMMANDS = new Set([
   'init',
@@ -77,6 +127,8 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'doctor',
   'context:validate',
   'context-validate',
+  'context:pack',
+  'context-pack',
   'test:smoke',
   'test-smoke',
   'test:agents',
@@ -89,6 +141,8 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'workflow-plan',
   'workflow:next',
   'workflow-next',
+  'workflow:status',
+  'workflow-status',
   'agent:next',
   'agent-next',
   'parallel:init',
@@ -121,6 +175,10 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'qa-scan',
   'qa:report',
   'qa-report',
+  'web:map',
+  'web-map',
+  'web:scrape',
+  'web-scrape',
   'scan:project',
   'scan-project',
   'config',
@@ -140,6 +198,49 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'squad-export',
   'squad:pipeline',
   'squad-pipeline',
+  'squad:agent-create',
+  'squad-agent-create',
+  'squad:investigate',
+  'squad-investigate',
+  'squad:dashboard',
+  'squad-dashboard',
+  'squad:worker',
+  'squad-worker',
+  'squad:daemon',
+  'squad-daemon',
+  'squad:mcp',
+  'squad-mcp',
+  'squad:mcp:call',
+  'squad:roi',
+  'squad-roi',
+  'squad:score',
+  'squad-score',
+  'squad:processes',
+  'squad-processes',
+  'squad:worktrees',
+  'squad-worktrees',
+  'squad:merge',
+  'squad-merge',
+  'squad:recovery',
+  'squad-recovery',
+  'squad:deploy',
+  'squad-deploy',
+  'squad:webhook',
+  'squad-webhook',
+  'plan:show',
+  'plan:status',
+  'plan:checkpoint',
+  'plan:stale',
+  'plan:register',
+  'plan',
+  'squad:plan',
+  'squad-plan',
+  'squad:learning',
+  'squad-learning',
+  'learning',
+  'learning:list',
+  'learning:stats',
+  'learning:promote',
   'runtime:init',
   'runtime-init',
   'runtime:ingest',
@@ -162,6 +263,33 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'runtime-status',
   'runtime:log',
   'runtime-log',
+  'agent:done',
+  'agent-done',
+  'agent:recover',
+  'agent-recover',
+  'runtime:session:start',
+  'runtime-session-start',
+  'runtime:session:log',
+  'runtime-session-log',
+  'runtime:session:finish',
+  'runtime-session-finish',
+  'runtime:session:status',
+  'runtime-session-status',
+  'runtime:emit',
+  'runtime-emit',
+  'live:start',
+  'live-start',
+  'live:status',
+  'live-status',
+  'live:handoff',
+  'live-handoff',
+  'live:close',
+  'live-close',
+  'live:list',
+  'live-list',
+  'deliver',
+  'output-strategy:export',
+  'output-strategy:import',
   'cloud:import:squad',
   'cloud-import-squad',
   'cloud:import:genome',
@@ -170,6 +298,16 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'cloud-publish-squad',
   'cloud:publish:genome',
   'cloud-publish-genome',
+  'runtime:backup',
+  'runtime-backup',
+  'runtime:restore',
+  'runtime-restore',
+  'skill:install',
+  'skill-install',
+  'skill:list',
+  'skill-list',
+  'skill:remove',
+  'skill-remove',
   'version',
   '--version',
   '-v'
@@ -223,6 +361,7 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_agents');
   logHelpLine(t, logger, 'cli.help_agent_prompt');
   logHelpLine(t, logger, 'cli.help_context_validate');
+  logHelpLine(t, logger, 'cli.help_context_pack');
   logHelpLine(t, logger, 'cli.help_setup_context');
   logHelpLine(t, logger, 'cli.help_locale_apply');
   logHelpLine(t, logger, 'cli.help_locale_diff');
@@ -231,6 +370,7 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_test_package');
   logHelpLine(t, logger, 'cli.help_workflow_plan');
   logHelpLine(t, logger, 'cli.help_workflow_next');
+  logHelpLine(t, logger, 'cli.help_workflow_status');
   logHelpLine(t, logger, 'cli.help_parallel_init');
   logHelpLine(t, logger, 'cli.help_parallel_doctor');
   logHelpLine(t, logger, 'cli.help_parallel_assign');
@@ -242,6 +382,8 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_qa_run');
   logHelpLine(t, logger, 'cli.help_qa_scan');
   logHelpLine(t, logger, 'cli.help_qa_report');
+  logHelpLine(t, logger, 'cli.help_web_map');
+  logHelpLine(t, logger, 'cli.help_web_scrape');
   logHelpLine(t, logger, 'cli.help_scan_project');
   logHelpLine(t, logger, 'cli.help_config');
   logHelpLine(t, logger, 'cli.help_genome_doctor');
@@ -252,6 +394,16 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_squad_validate');
   logHelpLine(t, logger, 'cli.help_squad_export');
   logHelpLine(t, logger, 'cli.help_squad_pipeline');
+  logHelpLine(t, logger, 'cli.help_squad_agent_create');
+  logHelpLine(t, logger, 'cli.help_squad_investigate');
+  logHelpLine(t, logger, 'cli.help_squad_dashboard');
+  logHelpLine(t, logger, 'cli.help_squad_worker');
+  logHelpLine(t, logger, 'cli.help_squad_daemon');
+  logHelpLine(t, logger, 'cli.help_squad_mcp');
+  logHelpLine(t, logger, 'cli.help_squad_roi');
+  logHelpLine(t, logger, 'cli.help_squad_score');
+  logHelpLine(t, logger, 'cli.help_squad_learning');
+  logHelpLine(t, logger, 'cli.help_learning');
   logHelpLine(t, logger, 'cli.help_runtime_init');
   logHelpLine(t, logger, 'cli.help_runtime_ingest');
   logHelpLine(t, logger, 'cli.help_runtime_task_start');
@@ -262,6 +414,20 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_runtime_task_fail');
   logHelpLine(t, logger, 'cli.help_runtime_fail');
   logHelpLine(t, logger, 'cli.help_runtime_status');
+  logHelpLine(t, logger, 'cli.help_runtime_session_start');
+  logHelpLine(t, logger, 'cli.help_runtime_session_log');
+  logHelpLine(t, logger, 'cli.help_runtime_session_finish');
+  logHelpLine(t, logger, 'cli.help_runtime_session_status');
+  logHelpLine(t, logger, 'cli.help_runtime_emit');
+  logHelpLine(t, logger, 'cli.help_live_start');
+  logHelpLine(t, logger, 'cli.help_live_status');
+  logHelpLine(t, logger, 'cli.help_live_handoff');
+  logHelpLine(t, logger, 'cli.help_live_close');
+  logHelpLine(t, logger, 'cli.help_runtime_backup');
+  logHelpLine(t, logger, 'cli.help_runtime_restore');
+  logHelpLine(t, logger, 'cli.help_skill_install');
+  logHelpLine(t, logger, 'cli.help_skill_list');
+  logHelpLine(t, logger, 'cli.help_skill_remove');
   logHelpLine(t, logger, 'cli.help_cloud_import_squad');
   logHelpLine(t, logger, 'cli.help_cloud_import_genome');
   logHelpLine(t, logger, 'cli.help_cloud_publish_squad');
@@ -339,6 +505,8 @@ async function main() {
       result = await runAgentPrompt({ args, options, logger: commandLogger, t });
     } else if (command === 'context:validate' || command === 'context-validate') {
       result = await runContextValidate({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:pack' || command === 'context-pack') {
+      result = await runContextPack({ args, options, logger: commandLogger, t });
     } else if (command === 'setup:context' || command === 'setup-context') {
       result = await runSetupContext({ args, options, logger: commandLogger, t });
     } else if (command === 'locale:apply' || command === 'locale-apply') {
@@ -359,7 +527,17 @@ async function main() {
       command === 'agent:next' ||
       command === 'agent-next'
     ) {
-      result = await runWorkflowNext({ args, options, logger: commandLogger, t });
+      // --status flag routes to workflow:status
+      if (options.status) {
+        result = await runWorkflowStatus({ args, options, logger: commandLogger, t });
+      } else {
+        result = await runWorkflowNext({ args, options, logger: commandLogger, t });
+      }
+    } else if (
+      command === 'workflow:status' ||
+      command === 'workflow-status'
+    ) {
+      result = await runWorkflowStatus({ args, options, logger: commandLogger, t });
     } else if (
       command === 'parallel:init' ||
       command === 'parallel-init' ||
@@ -402,6 +580,10 @@ async function main() {
       result = await runQaScan({ args, options, logger: commandLogger, t });
     } else if (command === 'qa:report' || command === 'qa-report') {
       result = await runQaReport({ args, options, logger: commandLogger, t });
+    } else if (command === 'web:map' || command === 'web-map') {
+      result = await runWebMap({ args, options, logger: commandLogger, t });
+    } else if (command === 'web:scrape' || command === 'web-scrape') {
+      result = await runWebScrape({ args, options, logger: commandLogger, t });
     } else if (command === 'scan:project' || command === 'scan-project') {
       result = await runScanProject({ args, options, logger: commandLogger, t });
     } else if (command === 'config') {
@@ -422,6 +604,52 @@ async function main() {
       result = await runSquadExport({ args, options, logger: commandLogger, t });
     } else if (command === 'squad:pipeline' || command === 'squad-pipeline') {
       result = await runSquadPipeline({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:agent-create' || command === 'squad-agent-create') {
+      result = await runSquadAgentCreate({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:investigate' || command === 'squad-investigate') {
+      result = await runSquadInvestigate({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:dashboard' || command === 'squad-dashboard') {
+      result = await runSquadDashboard({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:worker' || command === 'squad-worker') {
+      const sub = options.sub || 'list';
+      result = await runSquadWorker({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:daemon' || command === 'squad-daemon') {
+      const sub = options.sub || 'status';
+      result = await runSquadDaemon({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:mcp:call') {
+      result = await runSquadMcp({ args, options: { ...options, sub: 'call' }, logger: commandLogger, t });
+    } else if (command === 'squad:mcp' || command === 'squad-mcp') {
+      const sub = options.sub || 'status';
+      result = await runSquadMcp({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:roi' || command === 'squad-roi') {
+      const sub = options.sub || 'report';
+      result = await runSquadRoi({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:score' || command === 'squad-score') {
+      result = await runSquadScore({ args, options, logger: commandLogger, translator: t });
+    } else if (command === 'squad:processes' || command === 'squad-processes') {
+      result = await runSquadProcesses({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:worktrees' || command === 'squad-worktrees') {
+      result = await runSquadWorktrees({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:merge' || command === 'squad-merge') {
+      result = await runSquadMerge({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:recovery' || command === 'squad-recovery') {
+      result = await runSquadRecovery({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:deploy' || command === 'squad-deploy') {
+      result = await runSquadDeploy({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:webhook' || command === 'squad-webhook') {
+      const sub = options.sub || 'start';
+      result = await runSquadWebhook({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command === 'squad:plan' || command === 'squad-plan') {
+      result = await runSquadPlan({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:learning' || command === 'squad-learning') {
+      const sub = args[1] || 'list';
+      result = await runSquadLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command.startsWith('learning:') || command === 'learning') {
+      const sub = command === 'learning' ? (args[1] || 'list') : command.split(':')[1];
+      result = await runLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command.startsWith('plan:') || command === 'plan') {
+      const sub = command === 'plan' ? (args[1] || 'show') : command.split(':')[1];
+      result = await runImplementationPlan({ args, options: { ...options, sub }, logger: commandLogger, t });
     } else if (command === 'runtime:init' || command === 'runtime-init') {
       result = await runRuntimeInit({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:ingest' || command === 'runtime-ingest') {
@@ -444,6 +672,52 @@ async function main() {
       result = await runRuntimeStatus({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:log' || command === 'runtime-log') {
       result = await runRuntimeLog({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:done' || command === 'agent-done') {
+      result = await runAgentDone({ args, options, logger: commandLogger, t });
+    } else if (command === 'agent:recover' || command === 'agent-recover') {
+      result = await runAgentRecover({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:start' || command === 'runtime-session-start') {
+      result = await runRuntimeSessionStart({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:log' || command === 'runtime-session-log') {
+      result = await runRuntimeSessionLog({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:finish' || command === 'runtime-session-finish') {
+      result = await runRuntimeSessionFinish({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:status' || command === 'runtime-session-status') {
+      result = await runRuntimeSessionStatus({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:emit' || command === 'runtime-emit') {
+      result = await runRuntimeEmit({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:start' || command === 'live-start') {
+      result = await runLiveStart({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:status' || command === 'live-status') {
+      result = await runLiveStatus({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:handoff' || command === 'live-handoff') {
+      result = await runLiveHandoff({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:close' || command === 'live-close') {
+      result = await runLiveClose({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:list' || command === 'live-list') {
+      result = await runLiveList({ args, options, logger: commandLogger, t });
+    } else if (command === 'deliver') {
+      result = await runDeliver({ args, options, logger: commandLogger, t });
+    } else if (command === 'output-strategy:export') {
+      result = await runOutputStrategyExport({ args, options, logger: commandLogger, t });
+    } else if (command === 'output-strategy:import') {
+      result = await runOutputStrategyImport({ args, options, logger: commandLogger, t });
+    } else if (command === 'devlog:sync' || command === 'devlog-sync') {
+      result = await runDevlogSync({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:prune' || command === 'runtime-prune') {
+      result = await runRuntimePrune({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:backup' || command === 'runtime-backup') {
+      result = await runRuntimeBackup({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:restore' || command === 'runtime-restore') {
+      result = await runRuntimeRestore({ args, options, logger: commandLogger, t });
+    } else if (command === 'backup:local' || command === 'backup-local') {
+      result = await runBackupLocal({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:install' || command === 'skill-install') {
+      result = await runSkillInstall({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:list' || command === 'skill-list') {
+      result = await runSkillList({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:remove' || command === 'skill-remove') {
+      result = await runSkillRemove({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:squad' || command === 'cloud-import-squad') {
       result = await runCloudImportSquad({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:genome' || command === 'cloud-import-genome') {

package/src/commands/agents.js

@@ -17,6 +17,18 @@ const {
   classifyDirectAgentRuntime
 } = require('../execution-gateway');
 
+const WORKFLOW_AGENT_IDS = new Set([
+  'setup',
+  'product',
+  'analyst',
+  'architect',
+  'ux-ui',
+  'pm',
+  'orchestrator',
+  'dev',
+  'qa'
+]);
+
 async function resolveLocaleForTarget(targetDir, options) {
   const fromOption = options.language || options.lang;
   if (fromOption) return resolveAgentLocale(fromOption);
@@ -44,7 +56,13 @@ async function runAgentsList({ args, options, logger, t }) {
   for (const agent of agents) {
     const deps = agent.dependsOn.length > 0 ? agent.dependsOn.join(', ') : t('agents.none');
     const instructionPath = await resolveExistingInstructionPath(targetDir, agent, locale);
-    logger.log(t('agents.agent_line', { command: agent.command, id: agent.id }));
+    logger.log(
+      t('agents.agent_line', {
+        label: agent.displayName || agent.id,
+        command: agent.command,
+        id: agent.id
+      })
+    );
     logger.log(t('agents.path_line', { path: instructionPath }));
     logger.log(t('agents.active_path_line', { path: agent.path }));
     logger.log(t('agents.depends_line', { value: deps }));
@@ -76,10 +94,10 @@ async function runAgentPrompt({ args, options, logger, t }) {
   let instructionPath = null;
   let prompt = null;
 
-  const context = await validateProjectContextFile(targetDir);
-  if (context.valid) {
+  if (WORKFLOW_AGENT_IDS.has(requestedAgent)) {
     const loaded = await loadOrCreateState(targetDir, options);
-    if (loaded.state.sequence.includes(requestedAgent)) {
+    const hasWorkflowStage = Boolean(loaded.state.current || loaded.state.next || loaded.state.sequence.length > 0);
+    if (hasWorkflowStage) {
       const workflowResult = await runWorkflowNext({
         args: [targetDir],
         options: {

package/src/commands/backup-local-cmd.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const path = require('node:path');
+const { backupAiosonDocs } = require('../backup-local');
+
+/**
+ * aioson backup:local [.]
+ *
+ * Manually backs up all .md files from .aioson/context/ and .aioson/plans/
+ * to ~/.aioson/backups/{project}/{timestamp}/
+ */
+async function runBackupLocal({ args, options, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const result = await backupAiosonDocs(targetDir);
+
+  if (result.count === 0) {
+    logger.log('backup:local — nothing to back up (no .md files found in .aioson/context/ or .aioson/plans/)');
+    return { ok: true, count: 0, backupPath: null };
+  }
+
+  logger.log(`backup:local — ${result.count} file(s) backed up → ${result.backupPath}`);
+  return { ok: true, count: result.count, backupPath: result.backupPath };
+}
+
+module.exports = { runBackupLocal };