@a5c-ai/agent-platform 5.0.1-staging.04ca6ab00d21

package/dist/skills/discovery.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * SkillDiscoveryService — scans directories for SKILL.md files, parses
+ * frontmatter, and converts them to SkillDescriptor instances for the router.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillDiscoveryService = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// ---- frontmatter parsing ----
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    // Lightweight YAML-like parser for simple key: value pairs and arrays.
+    // Avoids pulling in a full YAML parser dependency.
+    const lines = (match[1] ?? '').split(/\r?\n/);
+    const fm = {};
+    let currentKey = '';
+    let currentArray = null;
+    for (const line of lines) {
+        const arrayItem = line.match(/^\s+-\s+(.*)/);
+        if (arrayItem && currentKey) {
+            if (!currentArray) {
+                currentArray = [];
+            }
+            currentArray.push(arrayItem[1].trim());
+            continue;
+        }
+        // Flush pending array
+        if (currentArray && currentKey) {
+            fm[currentKey] = currentArray;
+            currentArray = null;
+        }
+        const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+        if (kvMatch) {
+            currentKey = kvMatch[1];
+            const value = kvMatch[2].trim();
+            if (value.length > 0) {
+                // Inline array: [a, b, c]
+                if (value.startsWith('[') && value.endsWith(']')) {
+                    fm[currentKey] = value
+                        .slice(1, -1)
+                        .split(',')
+                        .map((s) => s.trim().replace(/^["']|["']$/g, ''))
+                        .filter((s) => s.length > 0);
+                }
+                else {
+                    fm[currentKey] = value.replace(/^["']|["']$/g, '');
+                }
+            }
+        }
+    }
+    // Flush trailing array
+    if (currentArray && currentKey) {
+        fm[currentKey] = currentArray;
+    }
+    return { frontmatter: fm, body: content.slice(match[0].length) };
+}
+function firstParagraph(body) {
+    const lines = body
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith('#') && !l.startsWith('```'));
+    return lines[0] ?? '';
+}
+function toStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === 'string' && v.length > 0);
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return [value];
+    }
+    return [];
+}
+// ---- filesystem helpers ----
+function isDir(p) {
+    try {
+        return node_fs_1.default.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readFileUtf8(p) {
+    return node_fs_1.default.readFileSync(p, 'utf8');
+}
+function walkForSkillFiles(dir) {
+    const results = [];
+    const walk = (current) => {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('.'))
+                continue;
+            const full = node_path_1.default.join(current, entry);
+            if (isDir(full)) {
+                walk(full);
+            }
+            else if (entry === 'SKILL.md') {
+                results.push(full);
+            }
+        }
+    };
+    walk(dir);
+    return results.sort();
+}
+// ---- public API ----
+class SkillDiscoveryService {
+    /**
+     * Parse a single SKILL.md file into a RawSkillEntry.
+     */
+    parseSkillFile(filePath) {
+        const content = readFileUtf8(filePath);
+        const { frontmatter, body } = parseFrontmatter(content);
+        const name = typeof frontmatter.name === 'string' && frontmatter.name.length > 0
+            ? frontmatter.name
+            : node_path_1.default.basename(node_path_1.default.dirname(filePath));
+        const description = typeof frontmatter.description === 'string' && frontmatter.description.length > 0
+            ? frontmatter.description
+            : firstParagraph(body);
+        const capabilities = toStringArray(frontmatter.capabilities);
+        const triggers = toStringArray(frontmatter.triggers);
+        const domain = typeof frontmatter.domain === 'string' && frontmatter.domain.length > 0
+            ? frontmatter.domain
+            : undefined;
+        return {
+            name,
+            description,
+            capabilities,
+            triggers,
+            domain,
+            filePath,
+            frontmatter,
+        };
+    }
+    /**
+     * Convert a RawSkillEntry (or any raw-shaped object) to a SkillDescriptor.
+     */
+    toDescriptor(raw, source = 'local') {
+        return {
+            name: raw.name,
+            description: raw.description,
+            capabilities: raw.capabilities.length > 0 ? raw.capabilities : undefined,
+            source,
+            triggers: raw.triggers.length > 0 ? raw.triggers : undefined,
+            domain: raw.domain,
+            filePath: raw.filePath,
+        };
+    }
+    /**
+     * Scan a single directory tree for SKILL.md files and return descriptors.
+     */
+    discoverLocal(dir) {
+        if (!isDir(dir))
+            return [];
+        const files = walkForSkillFiles(dir);
+        return files.map((f) => this.toDescriptor(this.parseSkillFile(f), 'local'));
+    }
+    /**
+     * Scan multiple plugin directories and return descriptors with source='plugin'.
+     */
+    discoverPlugins(dirs) {
+        const results = [];
+        for (const dir of dirs) {
+            if (!isDir(dir))
+                continue;
+            const files = walkForSkillFiles(dir);
+            for (const f of files) {
+                results.push(this.toDescriptor(this.parseSkillFile(f), 'plugin'));
+            }
+        }
+        return results;
+    }
+}
+exports.SkillDiscoveryService = SkillDiscoveryService;

package/dist/skills/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Skill routing module for L6 Agent-Platform.
+ *
+ * Provides skill registration, criteria-based matching, filesystem discovery,
+ * and chain-of-skills orchestration.
+ */
+export type { SkillDescriptor, SkillMatchCriteria, SkillMatchResult, SkillChainStep, SkillChain, } from './types';
+export { SkillRouter } from './router';
+export { SkillDiscoveryService } from './discovery';
+export type { RawSkillEntry } from './discovery';
+export { SkillChainBuilder } from './chain';
+//# sourceMappingURL=index.d.ts.map

package/dist/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,UAAU,GACX,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/skills/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Skill routing module for L6 Agent-Platform.
+ *
+ * Provides skill registration, criteria-based matching, filesystem discovery,
+ * and chain-of-skills orchestration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillChainBuilder = exports.SkillDiscoveryService = exports.SkillRouter = void 0;
+// Router
+var router_1 = require("./router");
+Object.defineProperty(exports, "SkillRouter", { enumerable: true, get: function () { return router_1.SkillRouter; } });
+// Discovery
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "SkillDiscoveryService", { enumerable: true, get: function () { return discovery_1.SkillDiscoveryService; } });
+// Chain builder
+var chain_1 = require("./chain");
+Object.defineProperty(exports, "SkillChainBuilder", { enumerable: true, get: function () { return chain_1.SkillChainBuilder; } });

package/dist/skills/router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SkillRouter — registers skill descriptors and scores them against match criteria.
+ *
+ * Scoring strategy:
+ *   1. Keyword overlap between criteria text (taskType + context) and the skill's
+ *      description / capabilities / triggers.
+ *   2. Exact domain match bonus.
+ *   3. Trigger pattern match bonus.
+ *   4. Capability intersection bonus.
+ */
+import type { SkillDescriptor, SkillMatchCriteria, SkillMatchResult } from './types';
+export declare class SkillRouter {
+    private readonly skills;
+    /** Register a skill descriptor. Replaces any existing entry with the same name. */
+    register(descriptor: SkillDescriptor): void;
+    /** Remove a skill by name. Returns true if it existed. */
+    unregister(name: string): boolean;
+    /** Return the number of registered skills. */
+    get size(): number;
+    /** Iterate over all registered descriptors. */
+    descriptors(): IterableIterator<SkillDescriptor>;
+    /** Retrieve a registered descriptor by name. */
+    get(name: string): SkillDescriptor | undefined;
+    /**
+     * Score every registered skill against the given criteria and return
+     * results sorted by descending score. Skills that score 0 are excluded.
+     */
+    match(criteria: SkillMatchCriteria): SkillMatchResult[];
+    /**
+     * Return the single best matching skill, or undefined when nothing matches.
+     */
+    select(criteria: SkillMatchCriteria): SkillMatchResult | undefined;
+    private scoreSkill;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/skills/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/skills/router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AA2BjB,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;IAE7D,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAI3C,0DAA0D;IAC1D,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,8CAA8C;IAC9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+CAA+C;IAC/C,WAAW,IAAI,gBAAgB,CAAC,eAAe,CAAC;IAIhD,gDAAgD;IAChD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9C;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,EAAE;IAavD;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,SAAS;IAOlE,OAAO,CAAC,UAAU;CAwEnB"}

package/dist/skills/router.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * SkillRouter — registers skill descriptors and scores them against match criteria.
+ *
+ * Scoring strategy:
+ *   1. Keyword overlap between criteria text (taskType + context) and the skill's
+ *      description / capabilities / triggers.
+ *   2. Exact domain match bonus.
+ *   3. Trigger pattern match bonus.
+ *   4. Capability intersection bonus.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillRouter = void 0;
+/** Normalize a string to lowercase tokens for keyword overlap scoring. */
+function tokenize(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/[\s,.\-_/|:;]+/)
+        .filter((token) => token.length > 1));
+}
+/** Count how many tokens from `query` appear in `corpus`. */
+function tokenOverlap(query, corpus) {
+    let count = 0;
+    for (const token of query) {
+        if (corpus.has(token)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+const DOMAIN_BONUS = 15;
+const TRIGGER_BONUS = 10;
+const CAPABILITY_BONUS = 5;
+class SkillRouter {
+    skills = new Map();
+    /** Register a skill descriptor. Replaces any existing entry with the same name. */
+    register(descriptor) {
+        this.skills.set(descriptor.name, descriptor);
+    }
+    /** Remove a skill by name. Returns true if it existed. */
+    unregister(name) {
+        return this.skills.delete(name);
+    }
+    /** Return the number of registered skills. */
+    get size() {
+        return this.skills.size;
+    }
+    /** Iterate over all registered descriptors. */
+    descriptors() {
+        return this.skills.values();
+    }
+    /** Retrieve a registered descriptor by name. */
+    get(name) {
+        return this.skills.get(name);
+    }
+    /**
+     * Score every registered skill against the given criteria and return
+     * results sorted by descending score. Skills that score 0 are excluded.
+     */
+    match(criteria) {
+        const results = [];
+        for (const skill of this.skills.values()) {
+            const { score, reason } = this.scoreSkill(skill, criteria);
+            if (score > 0) {
+                results.push({ skill, score, reason });
+            }
+        }
+        return results.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Return the single best matching skill, or undefined when nothing matches.
+     */
+    select(criteria) {
+        const matches = this.match(criteria);
+        return matches.length > 0 ? matches[0] : undefined;
+    }
+    // ---- private helpers ----
+    scoreSkill(skill, criteria) {
+        let score = 0;
+        const reasons = [];
+        // Build a query token set from taskType + context
+        const queryParts = [];
+        if (criteria.taskType)
+            queryParts.push(criteria.taskType);
+        if (criteria.context)
+            queryParts.push(criteria.context);
+        const queryTokens = tokenize(queryParts.join(' '));
+        // Build a corpus token set from skill description + capabilities + triggers
+        const corpusParts = [skill.description];
+        if (skill.capabilities)
+            corpusParts.push(...skill.capabilities);
+        if (skill.triggers)
+            corpusParts.push(...skill.triggers);
+        const corpusTokens = tokenize(corpusParts.join(' '));
+        // 1. Keyword overlap
+        if (queryTokens.size > 0 && corpusTokens.size > 0) {
+            const overlap = tokenOverlap(queryTokens, corpusTokens);
+            if (overlap > 0) {
+                score += overlap;
+                reasons.push(`keyword overlap (${overlap})`);
+            }
+        }
+        // 2. Domain exact match bonus
+        if (criteria.domain &&
+            skill.domain &&
+            criteria.domain.toLowerCase() === skill.domain.toLowerCase()) {
+            score += DOMAIN_BONUS;
+            reasons.push('domain match');
+        }
+        // 3. Trigger pattern match
+        if (skill.triggers && queryTokens.size > 0) {
+            for (const trigger of skill.triggers) {
+                const triggerLower = trigger.toLowerCase();
+                // Check if the full trigger phrase appears in the raw query text
+                const rawQuery = queryParts.join(' ').toLowerCase();
+                if (rawQuery.includes(triggerLower)) {
+                    score += TRIGGER_BONUS;
+                    reasons.push(`trigger "${trigger}"`);
+                    break; // only count trigger bonus once
+                }
+            }
+        }
+        // 4. Capability intersection bonus
+        if (criteria.capabilities && criteria.capabilities.length > 0 && skill.capabilities) {
+            const skillCaps = new Set(skill.capabilities.map((c) => c.toLowerCase()));
+            let capMatches = 0;
+            for (const cap of criteria.capabilities) {
+                if (skillCaps.has(cap.toLowerCase())) {
+                    capMatches += 1;
+                }
+            }
+            if (capMatches > 0) {
+                score += capMatches * CAPABILITY_BONUS;
+                reasons.push(`capability match (${capMatches})`);
+            }
+        }
+        return {
+            score,
+            reason: reasons.length > 0 ? reasons.join(', ') : 'no match',
+        };
+    }
+}
+exports.SkillRouter = SkillRouter;

package/dist/skills/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Skill routing types for the L6 Agent-Platform skill router.
+ */
+export interface SkillDescriptor {
+    name: string;
+    description: string;
+    capabilities?: string[];
+    source: 'local' | 'plugin' | 'remote';
+    triggers?: string[];
+    domain?: string;
+    filePath?: string;
+}
+export interface SkillMatchCriteria {
+    taskType?: string;
+    context?: string;
+    capabilities?: string[];
+    domain?: string;
+}
+export interface SkillMatchResult {
+    skill: SkillDescriptor;
+    score: number;
+    reason: string;
+}
+export interface SkillChainStep {
+    skillName: string;
+    input?: unknown;
+    dependsOn?: string[];
+}
+export interface SkillChain {
+    steps: SkillChainStep[];
+    description: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/skills/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/skills/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/dist/skills/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Skill routing types for the L6 Agent-Platform skill router.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/atomic.d.ts

@@ -0,0 +1,2 @@
+export declare function writeFileAtomic(targetPath: string, data: string | Buffer, retries?: number): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/storage/atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../../src/storage/atomic.ts"],"names":[],"mappings":"AAcA,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,SAAI,iBAiC3F"}

package/dist/storage/atomic.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomic = writeFileAtomic;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const RETRYABLE_ERRORS = new Set(["EBUSY", "ETXTBSY", "EPERM", "EACCES"]);
+async function fsyncPath(targetPath) {
+    const handle = await node_fs_1.promises.open(targetPath, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function writeFileAtomic(targetPath, data, retries = 3) {
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+    const handle = await node_fs_1.promises.open(tempPath, "w");
+    try {
+        if (typeof data === "string") {
+            await handle.writeFile(data, "utf8");
+        }
+        else {
+            await handle.writeFile(data);
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await node_fs_1.promises.rename(tempPath, targetPath);
+            await fsyncPath(node_path_1.default.dirname(targetPath));
+            return;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                await node_fs_1.promises.writeFile(targetPath, data);
+                return;
+            }
+            if (attempt === retries || !err.code || !RETRYABLE_ERRORS.has(err.code)) {
+                await node_fs_1.promises.rm(tempPath, { force: true });
+                throw err;
+            }
+            await new Promise((resolve) => setTimeout(resolve, (attempt + 1) * 25));
+        }
+    }
+}

package/dist/storage/clock.d.ts

@@ -0,0 +1,2 @@
+export declare function getClockIsoString(): string;
+//# sourceMappingURL=clock.d.ts.map

package/dist/storage/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/storage/clock.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/storage/clock.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClockIsoString = getClockIsoString;
+function getClockIsoString() {
+    return new Date().toISOString();
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,7 @@
+export { createJournalWatcher } from "./journalWatcher";
+export type { JournalWatcher, JournalWatcherOptions } from "./journalWatcher";
+export { snapshotState } from "./snapshotState";
+export { storeTaskArtifacts } from "./storeTaskArtifacts";
+export type { SnapshotStateOptions, StoreTaskArtifactsOptions } from "./types";
+export type { JournalEvent, JsonRecord } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAC/E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeTaskArtifacts = exports.snapshotState = exports.createJournalWatcher = void 0;
+var journalWatcher_1 = require("./journalWatcher");
+Object.defineProperty(exports, "createJournalWatcher", { enumerable: true, get: function () { return journalWatcher_1.createJournalWatcher; } });
+var snapshotState_1 = require("./snapshotState");
+Object.defineProperty(exports, "snapshotState", { enumerable: true, get: function () { return snapshotState_1.snapshotState; } });
+var storeTaskArtifacts_1 = require("./storeTaskArtifacts");
+Object.defineProperty(exports, "storeTaskArtifacts", { enumerable: true, get: function () { return storeTaskArtifacts_1.storeTaskArtifacts; } });

package/dist/storage/journalWatcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GAP-JSON-005: JournalWatcher — real-time event streaming from journal dir.
+ *
+ * Watches a run's journal/ directory for new .json files. Emits events
+ * incrementally (only seq > lastSeenSeq) in strict seq order. Supports
+ * fs.watch with automatic polling fallback.
+ */
+import type { JournalEvent } from "./types";
+export interface JournalWatcherOptions {
+    runDir: string;
+    afterSeq?: number;
+    pollIntervalMs?: number;
+    useFsWatch?: boolean;
+    onEvent: (event: JournalEvent) => void;
+    onError?: (error: Error) => void;
+    onDone?: () => void;
+}
+export interface JournalWatcher {
+    readonly lastSeenSeq: number;
+    onEvent: (event: JournalEvent) => void;
+    close(): void;
+}
+export declare function createJournalWatcher(options: JournalWatcherOptions): JournalWatcher;
+//# sourceMappingURL=journalWatcher.d.ts.map

package/dist/storage/journalWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journalWatcher.d.ts","sourceRoot":"","sources":["../../src/storage/journalWatcher.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,KAAK,IAAI,IAAI,CAAC;CACf;AAQD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CA0InF"}