@lumenflow/core 1.0.0

package/dist/wu-yaml-fixer.d.ts

@@ -0,0 +1,97 @@
+/**
+ * WU YAML Auto-Fixer
+ *
+ * Detects and auto-repairs common YAML validation issues that would fail at wu:done.
+ * Part of WU-1359: Early YAML validation at wu:claim.
+ *
+ * Common issues fixed:
+ * - ISO timestamp dates → YYYY-MM-DD format
+ * - Username → email format (with configurable domain)
+ * - docs → documentation (type field)
+ * - String numbers → number (phase field)
+ *
+ * @see {@link tools/lib/wu-schema.mjs} - WU schema definition
+ * @see {@link tools/wu-claim.mjs} - Consumer
+ */
+/**
+ * Issue types that can be detected and auto-fixed
+ */
+export declare const FIXABLE_ISSUES: {
+    DATE_ISO_TIMESTAMP: string;
+    USERNAME_NOT_EMAIL: string;
+    TYPE_ALIAS: string;
+    PHASE_STRING: string;
+    PRIORITY_LOWERCASE: string;
+};
+/**
+ * Detects fixable issues in WU YAML data
+ *
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {Array<{type: string, field: string, current: unknown, suggested: unknown, description: string}>}
+ */
+export declare function detectFixableIssues(doc: any): {
+    type: string;
+    field: string;
+    current: any;
+    suggested: any;
+    description: string;
+}[];
+/**
+ * Applies fixes to WU YAML data in-place
+ *
+ * @param {object} doc - Parsed WU YAML data (will be modified)
+ * @param {Array<{type: string, field: string, suggested: unknown}>} issues - Issues to fix
+ * @returns {number} Number of fixes applied
+ */
+export declare function applyFixes(doc: any, issues: any): number;
+/**
+ * Options for auto-fixing WU YAML
+ */
+export interface AutoFixWUYamlOptions {
+    /** If true, report issues without fixing */
+    dryRun?: boolean;
+    /** If true, create .bak file before fixing */
+    backup?: boolean;
+}
+/**
+ * Auto-fix WU YAML file
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {AutoFixWUYamlOptions} options - Options
+ * @returns {{fixed: number, issues: Array, backupPath?: string}}
+ */
+export declare function autoFixWUYaml(wuPath: any, options?: AutoFixWUYamlOptions): {
+    fixed: number;
+    issues: any[];
+    wouldFix?: undefined;
+    backupPath?: undefined;
+} | {
+    fixed: number;
+    issues: {
+        type: string;
+        field: string;
+        current: any;
+        suggested: any;
+        description: string;
+    }[];
+    wouldFix: number;
+    backupPath?: undefined;
+} | {
+    fixed: number;
+    issues: {
+        type: string;
+        field: string;
+        current: any;
+        suggested: any;
+        description: string;
+    }[];
+    backupPath: any;
+    wouldFix?: undefined;
+};
+/**
+ * Format issues for CLI output
+ *
+ * @param {Array<{field: string, description: string}>} issues
+ * @returns {string}
+ */
+export declare function formatIssues(issues: any): any;

package/dist/wu-yaml-fixer.js

@@ -0,0 +1,264 @@
+/**
+ * WU YAML Auto-Fixer
+ *
+ * Detects and auto-repairs common YAML validation issues that would fail at wu:done.
+ * Part of WU-1359: Early YAML validation at wu:claim.
+ *
+ * Common issues fixed:
+ * - ISO timestamp dates → YYYY-MM-DD format
+ * - Username → email format (with configurable domain)
+ * - docs → documentation (type field)
+ * - String numbers → number (phase field)
+ *
+ * @see {@link tools/lib/wu-schema.mjs} - WU schema definition
+ * @see {@link tools/wu-claim.mjs} - Consumer
+ */
+import { readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { parseYAML, stringifyYAML } from './wu-yaml.js';
+import { STRING_LITERALS } from './wu-constants.js';
+// Valid type values from wu-schema.mjs
+const VALID_TYPES = ['feature', 'bug', 'documentation', 'process', 'tooling', 'chore', 'refactor'];
+// Common type aliases that should be auto-fixed
+const TYPE_ALIASES = {
+    docs: 'documentation',
+    doc: 'documentation',
+    feat: 'feature',
+    fix: 'bug',
+    bugfix: 'bug',
+    tool: 'tooling',
+    tools: 'tooling',
+    ref: 'refactor',
+    proc: 'process',
+};
+// Default email domain for username → email conversion
+const DEFAULT_EMAIL_DOMAIN = 'patientpath.co.uk';
+/**
+ * Issue types that can be detected and auto-fixed
+ */
+export const FIXABLE_ISSUES = {
+    DATE_ISO_TIMESTAMP: 'DATE_ISO_TIMESTAMP',
+    USERNAME_NOT_EMAIL: 'USERNAME_NOT_EMAIL',
+    TYPE_ALIAS: 'TYPE_ALIAS',
+    PHASE_STRING: 'PHASE_STRING',
+    PRIORITY_LOWERCASE: 'PRIORITY_LOWERCASE',
+};
+/**
+ * Check created field for ISO timestamp issues
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {object|null} Issue object or null
+ */
+function checkCreatedField(doc) {
+    if (!doc.created)
+        return null;
+    const createdStr = String(doc.created);
+    // Match ISO 8601 timestamp (2025-12-02T00:00:00.000Z or similar)
+    if (/^\d{4}-\d{2}-\d{2}T/.test(createdStr)) {
+        const dateOnly = createdStr.slice(0, 10);
+        return {
+            type: FIXABLE_ISSUES.DATE_ISO_TIMESTAMP,
+            field: 'created',
+            current: createdStr,
+            suggested: dateOnly,
+            description: `ISO timestamp should be YYYY-MM-DD: ${createdStr} → ${dateOnly}`,
+        };
+    }
+    // Handle Date objects that YAML parser may create
+    if (doc.created instanceof Date) {
+        const dateOnly = doc.created.toISOString().slice(0, 10);
+        return {
+            type: FIXABLE_ISSUES.DATE_ISO_TIMESTAMP,
+            field: 'created',
+            current: doc.created.toISOString(),
+            suggested: dateOnly,
+            description: `Date object should be YYYY-MM-DD string: ${doc.created.toISOString()} → ${dateOnly}`,
+        };
+    }
+    return null;
+}
+/**
+ * Check assigned_to field for username without email domain
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {object|null} Issue object or null
+ */
+function checkAssignedToField(doc) {
+    if (!doc.assigned_to || typeof doc.assigned_to !== 'string')
+        return null;
+    const assignee = doc.assigned_to.trim();
+    if (assignee && !assignee.includes('@')) {
+        const suggested = `${assignee}@${DEFAULT_EMAIL_DOMAIN}`;
+        return {
+            type: FIXABLE_ISSUES.USERNAME_NOT_EMAIL,
+            field: 'assigned_to',
+            current: assignee,
+            suggested,
+            description: `Username should be email format: ${assignee} → ${suggested}`,
+        };
+    }
+    return null;
+}
+/**
+ * Check type field for common aliases or typos
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {object|null} Issue object or null
+ */
+function checkTypeField(doc) {
+    if (!doc.type || typeof doc.type !== 'string')
+        return null;
+    const typeLower = doc.type.toLowerCase();
+    if (TYPE_ALIASES[typeLower]) {
+        return {
+            type: FIXABLE_ISSUES.TYPE_ALIAS,
+            field: 'type',
+            current: doc.type,
+            suggested: TYPE_ALIASES[typeLower],
+            description: `Type alias should use canonical form: ${doc.type} → ${TYPE_ALIASES[typeLower]}`,
+        };
+    }
+    // Check for invalid type not in aliases - try fuzzy match
+    if (!VALID_TYPES.includes(typeLower)) {
+        const closest = VALID_TYPES.find((t) => t.startsWith(typeLower.slice(0, 3)) || typeLower.startsWith(t.slice(0, 3)));
+        if (closest) {
+            return {
+                type: FIXABLE_ISSUES.TYPE_ALIAS,
+                field: 'type',
+                current: doc.type,
+                suggested: closest,
+                description: `Invalid type "${doc.type}" - did you mean "${closest}"?`,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Check phase field for string instead of number
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {object|null} Issue object or null
+ */
+function checkPhaseField(doc) {
+    if (doc.phase == null || typeof doc.phase !== 'string')
+        return null;
+    const num = parseInt(doc.phase, 10);
+    if (!isNaN(num) && num > 0) {
+        return {
+            type: FIXABLE_ISSUES.PHASE_STRING,
+            field: 'phase',
+            current: doc.phase,
+            suggested: num,
+            description: `Phase should be number: "${doc.phase}" → ${num}`,
+        };
+    }
+    return null;
+}
+/**
+ * Check priority field for lowercase
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {object|null} Issue object or null
+ */
+function checkPriorityField(doc) {
+    if (!doc.priority || typeof doc.priority !== 'string')
+        return null;
+    const upper = doc.priority.toUpperCase();
+    if (doc.priority !== upper && /^P[0-3]$/i.test(doc.priority)) {
+        return {
+            type: FIXABLE_ISSUES.PRIORITY_LOWERCASE,
+            field: 'priority',
+            current: doc.priority,
+            suggested: upper,
+            description: `Priority should be uppercase: ${doc.priority} → ${upper}`,
+        };
+    }
+    return null;
+}
+/**
+ * Detects fixable issues in WU YAML data
+ *
+ * @param {object} doc - Parsed WU YAML data
+ * @returns {Array<{type: string, field: string, current: unknown, suggested: unknown, description: string}>}
+ */
+export function detectFixableIssues(doc) {
+    const checks = [
+        checkCreatedField,
+        checkAssignedToField,
+        checkTypeField,
+        checkPhaseField,
+        checkPriorityField,
+    ];
+    return checks.map((check) => check(doc)).filter((issue) => issue !== null);
+}
+/**
+ * Applies fixes to WU YAML data in-place
+ *
+ * @param {object} doc - Parsed WU YAML data (will be modified)
+ * @param {Array<{type: string, field: string, suggested: unknown}>} issues - Issues to fix
+ * @returns {number} Number of fixes applied
+ */
+export function applyFixes(doc, issues) {
+    let fixed = 0;
+    for (const issue of issues) {
+        switch (issue.type) {
+            case FIXABLE_ISSUES.DATE_ISO_TIMESTAMP:
+                doc[issue.field] = issue.suggested;
+                fixed++;
+                break;
+            case FIXABLE_ISSUES.USERNAME_NOT_EMAIL:
+                doc[issue.field] = issue.suggested;
+                fixed++;
+                break;
+            case FIXABLE_ISSUES.TYPE_ALIAS:
+                doc[issue.field] = issue.suggested;
+                fixed++;
+                break;
+            case FIXABLE_ISSUES.PHASE_STRING:
+                doc[issue.field] = issue.suggested;
+                fixed++;
+                break;
+            case FIXABLE_ISSUES.PRIORITY_LOWERCASE:
+                doc[issue.field] = issue.suggested;
+                fixed++;
+                break;
+        }
+    }
+    return fixed;
+}
+/**
+ * Auto-fix WU YAML file
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {AutoFixWUYamlOptions} options - Options
+ * @returns {{fixed: number, issues: Array, backupPath?: string}}
+ */
+export function autoFixWUYaml(wuPath, options = {}) {
+    const { dryRun = false, backup = true } = options;
+    // Read and parse
+    const text = readFileSync(wuPath, { encoding: 'utf-8' });
+    const doc = parseYAML(text);
+    // Detect issues
+    const issues = detectFixableIssues(doc);
+    if (issues.length === 0) {
+        return { fixed: 0, issues: [] };
+    }
+    if (dryRun) {
+        return { fixed: 0, issues, wouldFix: issues.length };
+    }
+    // Create backup if requested
+    let backupPath;
+    if (backup) {
+        backupPath = `${wuPath}.bak`;
+        copyFileSync(wuPath, backupPath);
+    }
+    // Apply fixes
+    const fixed = applyFixes(doc, issues);
+    // Write back
+    const newText = stringifyYAML(doc);
+    writeFileSync(wuPath, newText, { encoding: 'utf-8' });
+    return { fixed, issues, backupPath };
+}
+/**
+ * Format issues for CLI output
+ *
+ * @param {Array<{field: string, description: string}>} issues
+ * @returns {string}
+ */
+export function formatIssues(issues) {
+    return issues.map((i) => `  - ${i.field}: ${i.description}`).join(STRING_LITERALS.NEWLINE);
+}

package/dist/wu-yaml.d.ts

@@ -0,0 +1,86 @@
+/**
+ * WU-1352: Standardized YAML stringify options.
+ *
+ * Ensures consistent output across all WU tools:
+ * - lineWidth: 100 (wrap long lines)
+ * - singleQuote: true (prefer 'single' over "double")
+ * - defaultKeyType: PLAIN (unquoted keys when safe)
+ *
+ * @type {import('yaml').ToStringOptions}
+ */
+export declare const YAML_STRINGIFY_OPTIONS: Readonly<{
+    lineWidth: 100;
+    singleQuote: true;
+    defaultKeyType: "PLAIN";
+}>;
+/**
+ * Read and parse WU YAML file.
+ *
+ * Validates:
+ * - File exists
+ * - YAML is valid
+ * - WU ID matches expected ID
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {string} expectedId - Expected WU ID (e.g., 'WU-123')
+ * @returns {object} Parsed YAML document
+ * @throws {Error} If file not found, YAML invalid, or ID mismatch
+ */
+export declare function readWU(wuPath: any, expectedId: any): any;
+/**
+ * Parse YAML string to object.
+ * WU-1352: Centralized YAML parsing for consistency.
+ *
+ * @param {string} text - YAML string to parse
+ * @returns {object} Parsed object
+ * @throws {Error} If YAML is invalid
+ */
+export declare function parseYAML(text: any): any;
+/**
+ * Stringify object to YAML with standardized options.
+ * WU-1352: Centralized YAML serialization for consistency.
+ *
+ * @param {object} doc - Object to stringify
+ * @param {object} [options] - Additional stringify options (merged with YAML_STRINGIFY_OPTIONS)
+ * @returns {string} YAML string
+ */
+export declare function stringifyYAML(doc: any, options?: {}): string;
+/**
+ * Read and parse YAML file without ID validation.
+ * WU-1352: For cases where you don't know/need to validate the WU ID.
+ *
+ * @param {string} yamlPath - Path to YAML file
+ * @returns {object} Parsed YAML document
+ * @throws {Error} If file not found or YAML invalid
+ */
+export declare function readWURaw(yamlPath: any): any;
+/**
+ * Write WU YAML file with consistent formatting.
+ * WU-1352: Uses YAML_STRINGIFY_OPTIONS for consistent output.
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {object} doc - YAML document to write
+ */
+export declare function writeWU(wuPath: any, doc: any): void;
+/**
+ * Append note to WU document's notes field.
+ *
+ * Always outputs a string (Zod schema requires string type).
+ * Handles various input formats:
+ * - undefined/null/empty: Set note directly as string
+ * - string: Append with newline separator
+ * - array: Convert to newline-separated string, then append
+ * - other: Replace with note
+ *
+ * @param {object} doc - WU document
+ * @param {string} note - Note to append
+ */
+export declare function appendNote(doc: any, note: any): void;
+/**
+ * Append an agent session entry to a WU's agent_sessions[] array
+ *
+ * @param {string} wuId - WU ID (e.g., "WU-1234")
+ * @param {object} sessionData - Session summary from endSession()
+ * @throws {Error} if WU file not found
+ */
+export declare function appendAgentSession(wuId: any, sessionData: any): void;

package/dist/wu-yaml.js

@@ -0,0 +1,222 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { parse, stringify } from 'yaml';
+import { createError, ErrorCodes } from './error-handler.js';
+import { STRING_LITERALS } from './wu-constants.js';
+/**
+ * Unified WU YAML I/O module.
+ *
+ * Replaces 4 duplicate read/write functions scattered across wu-claim, wu-done,
+ * wu-block, and wu-unblock. Single source of truth for WU YAML operations.
+ *
+ * WU-1352: Standardized on yaml v2.8.1 (eemeli) with consistent stringify options.
+ *
+ * Functions:
+ * - readWU(path, id): Read and validate WU YAML
+ * - readWURaw(path): Read YAML without ID validation
+ * - parseYAML(text): Parse YAML string to object
+ * - writeWU(path, doc): Write WU YAML with consistent formatting
+ * - stringifyYAML(doc): Stringify object to YAML with consistent formatting
+ * - appendNote(doc, note): Append note to doc.notes field
+ *
+ * @example
+ * import { readWU, writeWU, appendNote } from './lib/wu-yaml.js';
+ *
+ * // Read WU
+ * const doc = readWU('docs/04-operations/tasks/wu/WU-123.yaml', 'WU-123');
+ *
+ * // Modify doc
+ * doc.status = 'in_progress';
+ * appendNote(doc, 'Started work on this WU');
+ *
+ * // Write back
+ * writeWU('docs/04-operations/tasks/wu/WU-123.yaml', doc);
+ */
+/**
+ * WU-1352: YAML scalar type constants (from yaml library).
+ * These match the string values expected by the yaml package.
+ * @see https://github.com/eemeli/yaml/blob/main/docs/03_options.md
+ */
+const YAML_SCALAR_TYPES = Object.freeze({
+    /** Unquoted string (when safe) */
+    PLAIN: 'PLAIN',
+    /** Single-quoted string */
+    QUOTE_SINGLE: 'QUOTE_SINGLE',
+    /** Double-quoted string */
+    QUOTE_DOUBLE: 'QUOTE_DOUBLE',
+    /** Block literal (|) */
+    BLOCK_LITERAL: 'BLOCK_LITERAL',
+    /** Block folded (>) */
+    BLOCK_FOLDED: 'BLOCK_FOLDED',
+});
+/** Standard line width for WU YAML files */
+const YAML_LINE_WIDTH = 100;
+/**
+ * WU-1352: Standardized YAML stringify options.
+ *
+ * Ensures consistent output across all WU tools:
+ * - lineWidth: 100 (wrap long lines)
+ * - singleQuote: true (prefer 'single' over "double")
+ * - defaultKeyType: PLAIN (unquoted keys when safe)
+ *
+ * @type {import('yaml').ToStringOptions}
+ */
+export const YAML_STRINGIFY_OPTIONS = Object.freeze({
+    lineWidth: YAML_LINE_WIDTH,
+    singleQuote: true,
+    defaultKeyType: YAML_SCALAR_TYPES.PLAIN,
+});
+/**
+ * Read and parse WU YAML file.
+ *
+ * Validates:
+ * - File exists
+ * - YAML is valid
+ * - WU ID matches expected ID
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {string} expectedId - Expected WU ID (e.g., 'WU-123')
+ * @returns {object} Parsed YAML document
+ * @throws {Error} If file not found, YAML invalid, or ID mismatch
+ */
+export function readWU(wuPath, expectedId) {
+    if (!existsSync(wuPath)) {
+        throw createError(ErrorCodes.FILE_NOT_FOUND, `WU file not found: ${wuPath}`, {
+            path: wuPath,
+            expectedId,
+        });
+    }
+    const text = readFileSync(wuPath, { encoding: 'utf-8' });
+    let doc;
+    try {
+        doc = parse(text);
+    }
+    catch (e) {
+        throw createError(ErrorCodes.YAML_PARSE_ERROR, `Failed to parse YAML ${wuPath}: ${e.message}`, {
+            path: wuPath,
+            originalError: e.message,
+        });
+    }
+    // Validate ID matches
+    if (!doc || doc.id !== expectedId) {
+        throw createError(ErrorCodes.WU_NOT_FOUND, `WU YAML id mismatch. Expected ${expectedId}, found ${doc && doc.id}`, { path: wuPath, expectedId, foundId: doc && doc.id });
+    }
+    return doc;
+}
+/**
+ * Parse YAML string to object.
+ * WU-1352: Centralized YAML parsing for consistency.
+ *
+ * @param {string} text - YAML string to parse
+ * @returns {object} Parsed object
+ * @throws {Error} If YAML is invalid
+ */
+export function parseYAML(text) {
+    return parse(text);
+}
+/**
+ * Stringify object to YAML with standardized options.
+ * WU-1352: Centralized YAML serialization for consistency.
+ *
+ * @param {object} doc - Object to stringify
+ * @param {object} [options] - Additional stringify options (merged with YAML_STRINGIFY_OPTIONS)
+ * @returns {string} YAML string
+ */
+export function stringifyYAML(doc, options = {}) {
+    return stringify(doc, { ...YAML_STRINGIFY_OPTIONS, ...options });
+}
+/**
+ * Read and parse YAML file without ID validation.
+ * WU-1352: For cases where you don't know/need to validate the WU ID.
+ *
+ * @param {string} yamlPath - Path to YAML file
+ * @returns {object} Parsed YAML document
+ * @throws {Error} If file not found or YAML invalid
+ */
+export function readWURaw(yamlPath) {
+    if (!existsSync(yamlPath)) {
+        throw createError(ErrorCodes.FILE_NOT_FOUND, `YAML file not found: ${yamlPath}`, {
+            path: yamlPath,
+        });
+    }
+    const text = readFileSync(yamlPath, { encoding: 'utf-8' });
+    try {
+        return parse(text);
+    }
+    catch (e) {
+        throw createError(ErrorCodes.YAML_PARSE_ERROR, `Failed to parse YAML ${yamlPath}: ${e.message}`, {
+            path: yamlPath,
+            originalError: e.message,
+        });
+    }
+}
+/**
+ * Write WU YAML file with consistent formatting.
+ * WU-1352: Uses YAML_STRINGIFY_OPTIONS for consistent output.
+ *
+ * @param {string} wuPath - Path to WU YAML file
+ * @param {object} doc - YAML document to write
+ */
+export function writeWU(wuPath, doc) {
+    const out = stringify(doc, YAML_STRINGIFY_OPTIONS);
+    writeFileSync(wuPath, out, { encoding: 'utf-8' });
+}
+/**
+ * Append note to WU document's notes field.
+ *
+ * Always outputs a string (Zod schema requires string type).
+ * Handles various input formats:
+ * - undefined/null/empty: Set note directly as string
+ * - string: Append with newline separator
+ * - array: Convert to newline-separated string, then append
+ * - other: Replace with note
+ *
+ * @param {object} doc - WU document
+ * @param {string} note - Note to append
+ */
+export function appendNote(doc, note) {
+    // Do nothing if note is falsy
+    if (!note)
+        return;
+    const existing = doc.notes;
+    if (existing === undefined || existing === null || existing === '') {
+        // No existing notes: set directly as string
+        doc.notes = note;
+    }
+    else if (Array.isArray(existing)) {
+        // Array notes: convert to string first (schema requires string), then append
+        const joined = existing.filter(Boolean).join(STRING_LITERALS.NEWLINE).trimEnd();
+        doc.notes = joined ? `${joined}${STRING_LITERALS.NEWLINE}${note}` : note;
+    }
+    else if (typeof existing === 'string') {
+        // String notes: append with newline
+        const trimmed = existing.trimEnd();
+        doc.notes = trimmed ? `${trimmed}${STRING_LITERALS.NEWLINE}${note}` : note;
+    }
+    else {
+        // Invalid type: replace with note
+        doc.notes = note;
+    }
+}
+/**
+ * Append an agent session entry to a WU's agent_sessions[] array
+ *
+ * @param {string} wuId - WU ID (e.g., "WU-1234")
+ * @param {object} sessionData - Session summary from endSession()
+ * @throws {Error} if WU file not found
+ */
+export function appendAgentSession(wuId, sessionData) {
+    const wuPath = `docs/04-operations/tasks/wu/${wuId}.yaml`;
+    if (!existsSync(wuPath)) {
+        throw new Error(`WU file not found: ${wuPath}`);
+    }
+    // Parse WU YAML
+    const doc = readWU(wuPath, wuId);
+    // Initialize agent_sessions array if needed
+    if (!doc.agent_sessions) {
+        doc.agent_sessions = [];
+    }
+    // Append session
+    doc.agent_sessions.push(sessionData);
+    // Write back
+    writeWU(wuPath, doc);
+}