@josfox/jos 4.0.4 → 4.0.6

package/src/commands/init.js

@@ -0,0 +1,162 @@
+/**
+ * JOS INIT Command - Create new .jos artifacts
+ * Creates a minimal valid .jos with detached integrity manifest
+ * Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m',
+    purple: '\x1b[38;5;135m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', gray: '\x1b[38;5;245m'
+};
+
+exports.execute = async (args, home) => {
+    const name = args[0] || 'new-artifact';
+    const type = args.includes('--pipeline') ? 'pipeline' : 'atom';
+    const filename = `${name}.jos`;
+
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
+${C.bold}JOS INIT${C.reset} // Create new .jos artifacts
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
+
+${C.bold}Usage:${C.reset}
+  jos init <name> [options]
+
+${C.bold}Options:${C.reset}
+  --pipeline    Create a pipeline artifact (default: atom)
+
+${C.bold}Creates:${C.reset}
+  <name>.jos           The artifact file
+  <name>.jos.sig.json  Detached integrity manifest
+`);
+        return;
+    }
+
+    console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.bold}JOS INIT${C.reset} // ${C.gray}Creating ${type} artifact${C.reset}`);
+    console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
+
+    // Create artifact with full JOSFOXAI + MAGIC compliance
+    const template = {
+        "$schema": "https://josfox.ai/schemas/jos-0.0.7.json",
+        "$comment": "Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)",
+
+        // JOSFOXAI Kernel
+        "jos": {
+            "open": `jos run ${type}`,
+            "supports": ["@josfox/jos", "josctl"],
+            "canonical": "Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)"
+        },
+        "orchestration_contract": {
+            "version": "0.0.7",
+            "mode": "sync"
+        },
+        "id_jos": `${type}-${name}-${Date.now()}`,
+        "adaptive_ai": {
+            "learning_mode": "frozen",
+            "llm_friendly_sentence": `This ${type} artifact performs the ${name} task.`
+        },
+        "security": {
+            "type": "open",
+            "permissions": [],
+            "health_check": null,
+            "integrity": null,
+            "integrity_ref": `./${filename}.sig.json`
+        },
+        "files": [],
+        "orchestration": {
+            "state": { "current_status": "idle" },
+            "definitions": {
+                "main_task": {
+                    "type": "shell",
+                    "description": "Main task - replace with your command",
+                    "command": "echo 'Hello from " + name + "'"
+                }
+            },
+            "flows": {
+                "main": {
+                    "description": "Main execution flow",
+                    "steps": ["main_task"]
+                }
+            }
+        },
+        "x_run_params": {
+            "timeout": 300,
+            "retry_on_failure": false
+        },
+
+        // MAGIC Kernel
+        "meta": {
+            "version": "1.0.0",
+            "type": type,
+            "name": name,
+            "provider": "local",
+            "author": "JOS Developer",
+            "canonical_version": "Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)"
+        },
+        "artifacts": {
+            "description": `Auto-generated ${type} artifact. Update this description.`,
+            "outputs": []
+        },
+        "guardrails": {
+            "avoid": [],
+            "max_retries": 1
+        },
+        "intention": {
+            "objective": "Define your objective here",
+            "success_criteria": "Define success criteria here"
+        },
+        "capabilities": []
+    };
+
+    // Write artifact
+    const content = JSON.stringify(template, null, 2);
+    fs.writeFileSync(filename, content);
+    console.log(`${C.green}✓ Created:${C.reset} ${filename}`);
+
+    // Generate integrity manifest
+    const sha256 = crypto.createHash('sha256').update(content).digest('hex');
+    const stats = fs.statSync(filename);
+
+    const manifest = {
+        "$schema": "https://josfox.ai/schemas/jos-manifest-0.0.7.json",
+        "manifest_version": "1.0.0",
+        "artifact_ref": filename,
+        "artifact_sha256": sha256,
+        "artifact_size_bytes": stats.size,
+        "timestamp": new Date().toISOString(),
+        "generated_by": "jos init command",
+        "canonical_version": "Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)"
+    };
+
+    const manifestPath = filename + '.sig.json';
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(`${C.green}✓ Created:${C.reset} ${manifestPath}`);
+    console.log(`${C.gray}  SHA256: ${sha256}${C.reset}`);
+
+    console.log(`
+${C.cyan}Next steps:${C.reset}
+  1. Edit ${filename} to define your tasks
+  2. Run: ${C.purple}jos validate ${filename}${C.reset}
+  3. Run: ${C.purple}jos run ${filename}${C.reset}
+`);
+
+    // Log to witness
+    const runDir = path.join(home, 'runs', 'init-' + new Date().toISOString().replace(/[:.]/g, '-'));
+    if (!fs.existsSync(runDir)) fs.mkdirSync(runDir, { recursive: true });
+
+    const event = {
+        timestamp: new Date().toISOString(),
+        type: 'init:created',
+        artifact: filename,
+        manifest: manifestPath,
+        sha256: sha256
+    };
+    fs.appendFileSync(path.join(runDir, 'events.jsonl'), JSON.stringify(event) + '\n');
+};

package/src/commands/run.js

@@ -1,6 +1,8 @@
 /**
  * JOS RUN Command - Execute .jos artifacts
  * Complies with JOSFOXAI MAGIC contract
+ * Integrity Strategy: Detached Manifest (.sig.json)
+ * Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)
  */
 
 const fs = require('fs');
@@ -11,215 +13,232 @@ const crypto = require('crypto');
 // AURORA colors
 const C = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-    purple: '\x1b[38;5;135m', magenta: '\x1b[38;5;198m', cyan: '\x1b[38;5;51m',
-    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m', gray: '\x1b[38;5;245m',
-    white: '\x1b[38;5;255m', yellow: '\x1b[38;5;220m'
+    purple: '\x1b[38;5;135m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m',
+    yellow: '\x1b[38;5;220m', white: '\x1b[38;5;255m',
+    gray: '\x1b[38;5;245m', blue: '\x1b[38;5;39m'
 };
 
+// Witness Logging
+function logWitness(home, eventType, data) {
+    const runId = global.JOS_RUN_ID || new Date().toISOString().replace(/[:.]/g, '-');
+    global.JOS_RUN_ID = runId;
+
+    const runDir = path.join(home, 'runs', runId);
+    if (!fs.existsSync(runDir)) fs.mkdirSync(runDir, { recursive: true });
+
+    const event = {
+        timestamp: new Date().toISOString(),
+        type: `run:${eventType}`,
+        ...data
+    };
+
+    fs.appendFileSync(path.join(runDir, 'events.jsonl'), JSON.stringify(event) + '\n');
+}
+
 // Compute SHA-256 integrity
 function computeIntegrity(content) {
     return crypto.createHash('sha256').update(content).digest('hex');
 }
 
-// Validate JOSFOXAI MAGIC contract (flexible for different schemas)
-function validateMagic(artifact) {
-    const errors = [];
-    const warnings = [];
+// Verify Integrity using Detached Manifest
+function verifyIntegrity(artifactPath, content, artifact) {
+    const integrityRef = artifact.security?.integrity_ref;
+    if (!integrityRef) return { valid: true, warning: "open (no integrity_ref)" };
 
-    // MAGIC components (Intention) - flexible detection
-    const hasMeta = artifact.meta || artifact._josfox || artifact.jos_schema;
-    const hasIntention = artifact.intention || artifact.meta?.intention ||
-        artifact.description || artifact._josfox?.description;
+    const manifestPath = path.resolve(path.dirname(artifactPath), integrityRef);
+    if (!fs.existsSync(manifestPath)) {
+        return { valid: false, error: `Manifest not found at ${manifestPath}` };
+    }
 
-    if (!hasMeta) warnings.push('Recommended: meta or _josfox');
-    if (!hasIntention) warnings.push('Recommended: intention or description');
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    } catch (e) {
+        return { valid: false, error: "Invalid manifest JSON" };
+    }
 
-    // JOSFOXAI components (Execution) - at least one required
-    const hasExecution = artifact.flow || artifact.tasks || artifact.pipelines ||
-        artifact.jos || artifact.shell;
-    if (!hasExecution) errors.push('Missing: execution (flow/tasks/pipelines/shell)');
+    const actualHash = computeIntegrity(content);
+    if (actualHash !== manifest.artifact_sha256) {
+        return {
+            valid: false,
+            error: `Hash mismatch. Expected: ${manifest.artifact_sha256.substring(0, 16)}..., Got: ${actualHash.substring(0, 16)}...`
+        };
+    }
 
-    return { valid: errors.length === 0, errors, warnings };
+    return { valid: true, verified: true, hash: actualHash };
 }
 
 exports.execute = async (args, home) => {
     const target = args[0];
     const dryRun = args.includes('--dry-run');
-    const showHelp = args.includes('--help') || args.includes('-h');
+    const insecure = args.includes('--insecure');
 
-    if (showHelp || !target) {
+    if (args.includes('--help') || !target) {
         console.log(`
-${C.cyan}${C.bold}JOS RUN${C.reset} - Execute .jos artifacts
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
+${C.bold}JOS RUN${C.reset} // Execute .jos artifacts
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
 
-${C.white}Usage:${C.reset} jos run <file.jos> [options]
+${C.bold}Usage:${C.reset}
+  jos run <file.jos> [options]
 
-${C.white}Options:${C.reset}
-  --dry-run     Validate and show plan without executing
-  --task <name> Run specific task only
-  --help, -h    Show this help
+${C.bold}Options:${C.reset}
+  --flow <name>    Flow to execute (default: main)
+  --dry-run        Simulate without executing
+  --insecure       Skip integrity verification
 
-${C.white}Examples:${C.reset}
-  jos run hello.jos
-  jos run ./my-artifact.jos --dry-run
-  jos run artifact.jos --task build
+${C.bold}Example:${C.reset}
+  jos run orchestration.jos --flow publish_all --dry-run
 `);
         return;
     }
 
-    // Resolve path
-    let artifactPath = target;
+    let artifactPath = path.resolve(target);
     if (!fs.existsSync(artifactPath)) {
-        artifactPath = path.join(home, 'artifacts', target);
-        if (!fs.existsSync(artifactPath)) {
-            artifactPath = path.join(process.cwd(), target);
+        if (fs.existsSync(path.join(home, 'artifacts', target))) {
+            artifactPath = path.join(home, 'artifacts', target);
+        } else {
+            console.log(`${C.red}✖ Artifact not found:${C.reset} ${target}`);
+            process.exit(1);
         }
     }
 
-    if (!fs.existsSync(artifactPath)) {
-        console.log(`${C.red}✖ Artifact not found:${C.reset} ${target}`);
-        console.log(`${C.dim}  Searched: ./, ~/.jos/artifacts/${C.reset}`);
-        process.exit(1);
-    }
+    const content = fs.readFileSync(artifactPath, 'utf8');
+    const artifact = JSON.parse(content);
+
+    // Init Witness
+    logWitness(home, 'start', { artifact: artifactPath, dryRun: dryRun });
 
+    // Header
     console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
     console.log(`${C.cyan}${C.bold}JOS RUN${C.reset} // ${C.gray}JOSFOXAI MAGIC Runtime${C.reset}`);
     console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
 
-    // Load artifact
-    const content = fs.readFileSync(artifactPath, 'utf8');
-    const integrity = computeIntegrity(content);
-    let artifact;
+    // Mode indicator
+    if (dryRun) {
+        console.log(`${C.yellow}${C.bold}⚡ DRY RUN MODE${C.reset} ${C.gray}— No commands will be executed${C.reset}\n`);
+    }
 
-    try {
-        artifact = JSON.parse(content);
-    } catch (e) {
-        console.log(`${C.red}✖ Invalid JSON:${C.reset} ${e.message}`);
-        process.exit(1);
+    // Artifact info
+    console.log(`${C.cyan}📦 Artifact:${C.reset} ${artifact.meta?.name || path.basename(artifactPath)}`);
+    console.log(`${C.cyan}📄 File:${C.reset} ${path.basename(artifactPath)}`);
+    console.log(`${C.cyan}🆔 ID:${C.reset} ${artifact.id_jos || 'N/A'}`);
+
+    // Integrity verification
+    if (!insecure) {
+        const integrity = verifyIntegrity(artifactPath, content, artifact);
+        if (!integrity.valid) {
+            console.log(`${C.cyan}🔐 Integrity:${C.reset} ${C.red}FAILED - ${integrity.error}${C.reset}`);
+            logWitness(home, 'integrity_failed', { error: integrity.error });
+            process.exit(1);
+        } else if (integrity.verified) {
+            console.log(`${C.cyan}🔐 Integrity:${C.reset} ${C.green}✓ Verified${C.reset} ${C.gray}(${integrity.hash.substring(0, 16)}...)${C.reset}`);
+            logWitness(home, 'integrity_verified', { hash: integrity.hash });
+        } else {
+            console.log(`${C.cyan}🔐 Integrity:${C.reset} ${C.yellow}⚠ ${integrity.warning}${C.reset}`);
+        }
+    } else {
+        console.log(`${C.cyan}🔐 Integrity:${C.reset} ${C.yellow}⚠ Skipped (--insecure)${C.reset}`);
     }
 
-    // Display metadata
-    console.log(`${C.white}📦 Artifact:${C.reset} ${artifact.meta?.name || artifact.name || path.basename(artifactPath)}`);
-    console.log(`${C.white}📄 File:${C.reset} ${artifactPath}`);
-    console.log(`${C.white}🔐 Integrity:${C.reset} ${C.green}${integrity.substring(0, 16)}...${C.reset}`);
+    // MAGIC validation
+    const hasMagic = artifact.intention && artifact.guardrails && artifact.capabilities;
+    console.log(`${C.cyan}✨ MAGIC:${C.reset} ${hasMagic ? C.green + '✓ Valid' : C.yellow + '⚠ Partial'}${C.reset}`);
 
-    // Validate MAGIC
-    const validation = validateMagic(artifact);
-    if (!validation.valid) {
-        console.log(`\n${C.red}✖ MAGIC Validation Failed:${C.reset}`);
-        validation.errors.forEach(e => console.log(`  ${C.red}•${C.reset} ${e}`));
-        process.exit(1);
+    // Intention
+    if (artifact.intention?.objective) {
+        console.log(`${C.cyan}🎯 Intention:${C.reset} ${artifact.intention.objective}`);
     }
-    console.log(`${C.white}✓ MAGIC:${C.reset} ${C.green}Valid${C.reset}`);
 
-    // Show intention
-    const intention = artifact.intention?.objective || artifact.meta?.intention || 'No intention defined';
-    console.log(`${C.white}🎯 Intention:${C.reset} ${intention}`);
-
-    // Check guardrails
+    // Guardrails
     if (artifact.guardrails?.avoid?.length > 0) {
-        console.log(`${C.white}🛡️ Guardrails:${C.reset} ${artifact.guardrails.avoid.join(', ')}`);
+        console.log(`${C.cyan}🛡️ Guardrails:${C.reset} ${artifact.guardrails.avoid.join(', ')}`);
     }
 
-    // Determine execution mode
-    const taskName = args.find((a, i) => args[i - 1] === '--task');
-
-    console.log(`\n${C.cyan}▶ Execution Plan:${C.reset}`);
-
-    // Execute based on artifact type
-    if (artifact.pipelines && !taskName) {
-        // Pipeline mode
-        const pipelineNames = Object.keys(artifact.pipelines);
-        console.log(`  ${C.dim}Mode: Pipeline${C.reset}`);
-        pipelineNames.forEach(name => {
-            const pipeline = artifact.pipelines[name];
-            console.log(`  ${C.cyan}→${C.reset} ${name}: ${pipeline.steps?.length || 0} steps`);
-        });
-
-        if (dryRun) {
-            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
-            return;
+    // Flow selection
+    const flowName = args.includes('--flow') ? args[args.indexOf('--flow') + 1] : 'main';
+    const flow = artifact.orchestration?.flows?.[flowName] ||
+        artifact.orchestration?.pipelines?.[flowName];
+
+    if (!flow) {
+        console.log(`\n${C.red}✖ Flow '${flowName}' not found.${C.reset}`);
+        const available = [
+            ...Object.keys(artifact.orchestration?.flows || {}),
+            ...Object.keys(artifact.orchestration?.pipelines || {})
+        ];
+        if (available.length > 0) {
+            console.log(`${C.gray}Available flows: ${available.join(', ')}${C.reset}`);
         }
+        process.exit(1);
+    }
 
-        // Execute first pipeline
-        const firstPipeline = pipelineNames[0];
-        await executePipeline(artifact, firstPipeline, artifact.pipelines[firstPipeline]);
-
-    } else if (artifact.tasks) {
-        // Task mode
-        const taskNames = taskName ? [taskName] : Object.keys(artifact.tasks);
-        console.log(`  ${C.dim}Mode: Tasks${C.reset}`);
-        taskNames.forEach(name => {
-            const task = artifact.tasks[name];
-            console.log(`  ${C.cyan}→${C.reset} ${name}: ${task.description || ''}`);
-        });
-
-        if (dryRun) {
-            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
-            return;
+    // Execution plan
+    console.log(`\n${C.cyan}▶ Flow:${C.reset} ${C.bold}${flowName}${C.reset}`);
+    if (flow.description) {
+        console.log(`${C.gray}  ${flow.description}${C.reset}`);
+    }
+    console.log(`${C.gray}  Steps: ${flow.steps?.join(' → ') || 'none'}${C.reset}\n`);
+
+    // Execute steps
+    let stepIndex = 0;
+    for (const stepName of flow.steps || []) {
+        stepIndex++;
+        const def = artifact.orchestration.definitions?.[stepName];
+
+        if (!def) {
+            console.log(`${C.red}  [${stepIndex}] ✖ ${stepName}: Definition not found${C.reset}`);
+            logWitness(home, 'step_error', { step: stepName, error: 'definition not found' });
+            continue;
         }
 
-        // Execute tasks
-        for (const name of taskNames) {
-            await executeTask(name, artifact.tasks[name]);
-        }
+        logWitness(home, 'step_start', { step: stepName, type: def.type, index: stepIndex });
 
-    } else if (artifact.flow?.steps) {
-        // Simple flow mode
-        console.log(`  ${C.dim}Mode: Flow${C.reset}`);
-        artifact.flow.steps.forEach((step, i) => {
-            console.log(`  ${C.cyan}${i + 1}.${C.reset} ${step}`);
-        });
+        const typeIcon = def.type === 'shell' ? '⚡' : def.type === 'jos' ? '📦' : '●';
 
         if (dryRun) {
-            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
-            return;
-        }
-
-        // Execute steps
-        for (const step of artifact.flow.steps) {
-            executeStep(step);
+            console.log(`${C.yellow}  [${stepIndex}] ${typeIcon} ${stepName}${C.reset}`);
+            if (def.description) console.log(`${C.gray}      ${def.description}${C.reset}`);
+            if (def.type === 'shell') {
+                const cmdPreview = def.command.length > 60 ? def.command.substring(0, 60) + '...' : def.command;
+                console.log(`${C.dim}      $ ${cmdPreview}${C.reset}`);
+            } else if (def.type === 'jos') {
+                console.log(`${C.dim}      → ${def.artifact}${C.reset}`);
+            }
+            logWitness(home, 'step_dry_run', { step: stepName });
+            continue;
         }
-    }
-
-    console.log(`\n${C.green}✓ Execution complete${C.reset}\n`);
-};
 
-async function executePipeline(artifact, name, pipeline) {
-    console.log(`\n${C.purple}▶ Running pipeline: ${name}${C.reset}\n`);
+        // Real execution
+        console.log(`${C.blue}  [${stepIndex}] ${typeIcon} ${stepName}...${C.reset}`);
 
-    for (const stepRef of pipeline.steps || []) {
-        // Parse step reference (e.g., "tasks.build")
-        const [type, taskName] = stepRef.split('.');
-
-        if (type === 'tasks' && artifact.tasks[taskName]) {
-            await executeTask(taskName, artifact.tasks[taskName]);
-        } else {
-            console.log(`  ${C.yellow}⚠ Unknown step: ${stepRef}${C.reset}`);
-        }
-    }
-}
-
-async function executeTask(name, task) {
-    console.log(`\n${C.cyan}▶ Task: ${name}${C.reset}`);
-    if (task.description) console.log(`  ${C.dim}${task.description}${C.reset}`);
-
-    if (task.shell && Array.isArray(task.shell)) {
-        const script = task.shell.join('\n');
         try {
-            execSync(script, { stdio: 'inherit', shell: '/bin/bash' });
-            console.log(`  ${C.green}✓ Task complete${C.reset}`);
+            if (def.type === 'shell') {
+                execSync(def.command, { stdio: 'inherit', shell: '/bin/bash' });
+                console.log(`${C.green}      ✓ Complete${C.reset}`);
+            } else if (def.type === 'jos') {
+                console.log(`${C.purple}      Running sub-artifact: ${def.artifact}${C.reset}`);
+                const subPath = path.resolve(path.dirname(artifactPath), def.artifact);
+                const binJos = process.argv[1];
+                execSync(`${process.execPath} "${binJos}" run "${subPath}" ${insecure ? '--insecure' : ''} --flow main`, {
+                    stdio: 'inherit'
+                });
+            }
+            logWitness(home, 'step_complete', { step: stepName, success: true });
         } catch (e) {
-            console.log(`  ${C.red}✖ Task failed: ${e.message}${C.reset}`);
-            throw e;
+            console.log(`${C.red}      ✖ Failed: ${e.message}${C.reset}`);
+            logWitness(home, 'step_failed', { step: stepName, error: e.message });
+            logWitness(home, 'run_failed', { lastStep: stepName });
+            process.exit(1);
         }
     }
-}
 
-function executeStep(step) {
-    console.log(`  ${C.cyan}▶${C.reset} ${step}`);
-    try {
-        execSync(step, { stdio: 'inherit', shell: true });
-    } catch (e) {
-        console.log(`  ${C.red}✖ Step failed${C.reset}`);
+    // Success
+    console.log(`\n${C.green}${C.bold}✓ ${dryRun ? 'Dry run complete' : 'Execution complete'}${C.reset}`);
+    if (artifact.intention?.success_criteria) {
+        console.log(`${C.gray}  Success criteria: ${artifact.intention.success_criteria}${C.reset}`);
     }
-}
+    console.log('');
+
+    logWitness(home, 'success', { dryRun: dryRun, stepsExecuted: stepIndex });
+};