@aiwg/cli 2026.7.20 → 2026.7.23

package/dist/src/sessions/timeline.js

@@ -0,0 +1,148 @@
+export const TIMELINE_SCHEMA_VERSION = '1.0.0';
+export const DEFAULT_TIMELINE_GAP_MS = 30 * 60 * 1_000;
+export function deriveSessionTimeline(input, gapMs = DEFAULT_TIMELINE_GAP_MS) {
+    if (!Number.isFinite(gapMs) || gapMs < 0) {
+        throw new Error('timeline gap must be a non-negative duration');
+    }
+    const grouped = new Map();
+    for (const item of input) {
+        const group = grouped.get(item.session.sessionId) ?? [];
+        group.push(item);
+        grouped.set(item.session.sessionId, group);
+    }
+    const result = [];
+    for (const items of grouped.values()) {
+        const timed = items
+            .filter((item) => item.event.occurredAt !== null)
+            .sort(compareTimelineInput);
+        const untimed = items
+            .filter((item) => item.event.occurredAt === null)
+            .sort(compareSequence);
+        if (timed.length === 0) {
+            const first = items[0];
+            result.push({
+                schemaVersion: TIMELINE_SCHEMA_VERSION,
+                provider: first.session.provider,
+                sessionId: first.session.sessionId,
+                segmentIndex: 0,
+                startAt: null,
+                endAt: null,
+                durationMs: null,
+                eventCount: untimed.length,
+                boundaryBasis: 'unknown-time',
+                boundaryEvidence: null,
+                confidence: 'low',
+                minSequence: untimed.at(0)?.event.sequence ?? 0,
+                maxSequence: untimed.at(-1)?.event.sequence ?? 0,
+            });
+            continue;
+        }
+        const sessionSegments = [];
+        let current = null;
+        let previous = null;
+        for (const item of timed) {
+            const boundary = previous ? segmentBoundary(previous.event, item.event, gapMs) : null;
+            if (!current || boundary) {
+                current = {
+                    schemaVersion: TIMELINE_SCHEMA_VERSION,
+                    provider: item.session.provider,
+                    sessionId: item.session.sessionId,
+                    segmentIndex: sessionSegments.length,
+                    startAt: item.event.occurredAt,
+                    endAt: item.event.occurredAt,
+                    durationMs: 0,
+                    eventCount: 0,
+                    boundaryBasis: boundary?.basis ?? 'session-start',
+                    boundaryEvidence: boundary?.evidence ?? null,
+                    confidence: boundary?.confidence ?? 'high',
+                    minSequence: item.event.sequence,
+                    maxSequence: item.event.sequence,
+                };
+                sessionSegments.push(current);
+            }
+            current.eventCount += 1;
+            current.endAt = item.event.occurredAt;
+            current.durationMs = Math.max(0, Date.parse(current.endAt) - Date.parse(current.startAt));
+            current.minSequence = Math.min(current.minSequence, item.event.sequence);
+            current.maxSequence = Math.max(current.maxSequence, item.event.sequence);
+            previous = item;
+        }
+        for (const item of untimed) {
+            const destination = sessionSegments.find((segment) => item.event.sequence <= segment.maxSequence) ?? sessionSegments.at(-1);
+            destination.eventCount += 1;
+            destination.minSequence = Math.min(destination.minSequence, item.event.sequence);
+            destination.maxSequence = Math.max(destination.maxSequence, item.event.sequence);
+        }
+        result.push(...sessionSegments);
+    }
+    return result
+        .sort((left, right) => compareNullableTime(left.startAt, right.startAt)
+        || left.provider.localeCompare(right.provider)
+        || left.sessionId.localeCompare(right.sessionId)
+        || left.segmentIndex - right.segmentIndex)
+        .map(({ minSequence: _min, maxSequence: _max, ...segment }) => segment);
+}
+export function parseTimelineGap(value) {
+    if (value === undefined)
+        return DEFAULT_TIMELINE_GAP_MS;
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/.exec(value.trim());
+    if (!match)
+        throw new Error('timeline gap must use ms, s, m, h, or d (for example 30m)');
+    const factors = {
+        ms: 1,
+        s: 1_000,
+        m: 60_000,
+        h: 3_600_000,
+        d: 86_400_000,
+    };
+    const result = Number(match[1]) * factors[match[2]];
+    if (!Number.isSafeInteger(result) || result < 0) {
+        throw new Error('timeline gap is outside the supported duration range');
+    }
+    return result;
+}
+function segmentBoundary(previous, current, gapMs) {
+    if (current.activityBoundary === 'resume'
+        || current.activityBoundary === 'continuation') {
+        return {
+            basis: 'provider-explicit',
+            evidence: current.activityBoundaryBasis ?? current.activityBoundary,
+            confidence: current.activityBoundaryConfidence ?? 'high',
+        };
+    }
+    if (previous.activityBoundary === 'pause' || previous.activityBoundary === 'end') {
+        return {
+            basis: 'provider-explicit',
+            evidence: previous.activityBoundaryBasis ?? previous.activityBoundary,
+            confidence: previous.activityBoundaryConfidence ?? 'high',
+        };
+    }
+    const gap = Date.parse(current.occurredAt) - Date.parse(previous.occurredAt);
+    if (gap > gapMs) {
+        return {
+            basis: 'inferred-gap',
+            evidence: `inactivity>${gapMs}ms`,
+            confidence: 'medium',
+        };
+    }
+    return null;
+}
+function compareTimelineInput(left, right) {
+    return Date.parse(left.event.occurredAt) - Date.parse(right.event.occurredAt)
+        || left.event.sequence - right.event.sequence
+        || left.event.eventId.localeCompare(right.event.eventId);
+}
+function compareSequence(left, right) {
+    return left.event.sequence - right.event.sequence
+        || left.event.eventId.localeCompare(right.event.eventId);
+}
+function compareNullableTime(left, right) {
+    if (left === right)
+        return 0;
+    if (left === null)
+        return 1;
+    if (right === null)
+        return -1;
+    return Date.parse(left) - Date.parse(right);
+}
+//# sourceMappingURL=timeline.js.map

package/dist/src/sessions/workspace-discovery.js

@@ -0,0 +1,319 @@
+import { createReadStream } from 'node:fs';
+import { access, mkdir, readFile, realpath, rename, stat, writeFile, } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ClaudeSessionAdapter } from './adapters/claude.js';
+import { CodexSessionAdapter } from './adapters/codex.js';
+import { CursorSessionAdapter } from './adapters/cursor.js';
+import { FactorySessionAdapter } from './adapters/factory.js';
+import { SESSION_PROVIDER_IDS, sha256, } from './contracts.js';
+import { redactSourceLocator } from './discovery.js';
+import { fingerprintSourceFile } from './readers.js';
+export const DISCOVERY_MANIFEST_VERSION = '1.0.0';
+const MANUAL_EXPORT_PROVIDERS = new Set([
+    'copilot', 'hermes', 'opencode', 'openclaw', 'openhuman',
+    'warp', 'devin-desktop', 'generic',
+]);
+export async function discoverWorkspaceHistories(options) {
+    const workspacePath = await canonicalPath(options.workspace);
+    const workspaceId = workspacePath;
+    const providerHomes = providerHomeCandidates(options.providerHome, options.operatorHome);
+    const keyWithLeadingDash = workspaceKey(workspacePath, true);
+    const keyWithoutLeadingDash = workspaceKey(workspacePath, false);
+    const discoverable = [
+        {
+            provider: 'claude',
+            adapter: new ClaudeSessionAdapter(),
+            roots: providerHomes.map((providerHome) => join(providerHome, '.claude', 'projects', keyWithLeadingDash)),
+        },
+        {
+            provider: 'codex',
+            adapter: new CodexSessionAdapter(),
+            roots: options.codexRoot
+                ? [resolve(options.codexRoot)]
+                : options.providerHome
+                    ? [join(resolve(options.providerHome), '.codex', 'sessions')]
+                    : [],
+        },
+        {
+            provider: 'cursor',
+            adapter: new CursorSessionAdapter(),
+            roots: providerHomes.map((providerHome) => join(providerHome, '.cursor', 'projects', keyWithoutLeadingDash, 'agent-transcripts')),
+        },
+        {
+            provider: 'factory',
+            adapter: new FactorySessionAdapter(),
+            roots: providerHomes.flatMap((providerHome) => [
+                join(providerHome, '.factory', 'projects', keyWithLeadingDash),
+                join(providerHome, '.factory', 'sessions', keyWithLeadingDash),
+            ]),
+        },
+    ];
+    const reports = new Map();
+    const candidates = [];
+    const seen = new Set();
+    for (const entry of discoverable) {
+        const availableRoots = [];
+        for (const root of entry.roots) {
+            if (await pathExists(root))
+                availableRoots.push(await canonicalPath(root));
+        }
+        if (availableRoots.length === 0) {
+            const codexNeedsAuthorization = entry.provider === 'codex'
+                && entry.roots.length === 0;
+            reports.set(entry.provider, providerReport(entry.provider, codexNeedsAuthorization ? 'export-required' : 'unavailable', codexNeedsAuthorization ? 'manual-export' : 'discoverable', [], codexNeedsAuthorization
+                ? 'SHARED_ROOT_AUTHORIZATION_REQUIRED'
+                : 'PROVIDER_ROOT_UNAVAILABLE', codexNeedsAuthorization
+                ? 'Pass --codex-root with an explicitly authorized Codex sessions or App Server export root.'
+                : `No authorized ${entry.provider} workspace history root was found.`));
+            continue;
+        }
+        const scope = {
+            workspaceId,
+            allowedRoots: availableRoots,
+        };
+        const providerSources = [];
+        for await (const descriptor of entry.adapter.discover(scope)) {
+            const locator = await canonicalPath(descriptor.locator);
+            if (entry.provider === 'codex'
+                && !await codexSourceMatchesWorkspace(locator, workspacePath))
+                continue;
+            const details = await stat(locator);
+            const authorizedRoot = scope.allowedRoots.find((root) => locator === root || locator.startsWith(`${root}/`));
+            if (!authorizedRoot)
+                continue;
+            const fingerprint = await fingerprintSourceFile({
+                selectedPath: locator,
+                allowedRoots: [authorizedRoot],
+            });
+            const dedupeKey = `${entry.provider}\0${fingerprint.digest}\0${fingerprint.size}`;
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            const source = sourceFromDescriptor(descriptor, locator, authorizedRoot, details, fingerprint.digest);
+            providerSources.push(source);
+            candidates.push(source);
+        }
+        reports.set(entry.provider, providerReport(entry.provider, 'checked', 'discoverable', providerSources, providerSources.length === 0 ? 'NO_WORKSPACE_SOURCES' : null, providerSources.length === 0
+            ? `The ${entry.provider} root was checked, but no source matched the authorized workspace.`
+            : null));
+    }
+    for (const provider of SESSION_PROVIDER_IDS) {
+        if (reports.has(provider))
+            continue;
+        const manual = MANUAL_EXPORT_PROVIDERS.has(provider);
+        reports.set(provider, providerReport(provider, manual ? 'export-required' : 'not-checked', manual ? 'manual-export' : 'unsupported', [], manual ? 'EXPLICIT_EXPORT_REQUIRED' : 'PROVIDER_NOT_CHECKED', manual
+            ? `Select and authorize a supported ${provider} export before importing it.`
+            : `No discovery strategy is registered for ${provider}.`));
+    }
+    const sources = candidates.sort(compareSources);
+    const providers = [...reports.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+    const identity = {
+        schemaVersion: DISCOVERY_MANIFEST_VERSION,
+        workspaceId,
+        sources: sources.map((source) => ({
+            sourceId: source.sourceId,
+            provider: source.provider,
+            locatorClass: source.locatorClass,
+            locator: source.locator,
+            modifiedAt: source.modifiedAt,
+            sizeBytes: source.sizeBytes,
+            digest: source.digest,
+        })),
+        providers: providers.map((provider) => ({
+            provider: provider.provider,
+            status: provider.status,
+            reasonCode: provider.reasonCode,
+        })),
+    };
+    return {
+        schemaVersion: DISCOVERY_MANIFEST_VERSION,
+        manifestId: sha256(JSON.stringify(identity)),
+        createdAt: options.createdAt ?? new Date().toISOString(),
+        workspaceId,
+        workspacePath,
+        providers,
+        sources,
+    };
+}
+export function defaultDiscoveryManifestPath(workspace) {
+    return resolve(workspace, '.aiwg', 'sessions', 'discovery-manifest.json');
+}
+export async function writeDiscoveryManifest(path, manifest) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+}
+export async function readDiscoveryManifest(path) {
+    const value = JSON.parse(await readFile(path, 'utf8'));
+    if (value.schemaVersion !== DISCOVERY_MANIFEST_VERSION
+        || typeof value.manifestId !== 'string'
+        || typeof value.workspaceId !== 'string'
+        || !Array.isArray(value.providers)
+        || !Array.isArray(value.sources)) {
+        throw new Error('session discovery manifest is malformed or unsupported');
+    }
+    const expected = await rediscoverManifestIdentity(value);
+    if (expected !== value.manifestId) {
+        throw new Error('session discovery manifest identity does not match its contents');
+    }
+    return value;
+}
+export function publicDiscoveryManifest(manifest) {
+    return {
+        schemaVersion: manifest.schemaVersion,
+        manifestId: manifest.manifestId,
+        createdAt: manifest.createdAt,
+        workspaceId: manifest.workspaceId,
+        workspacePath: manifest.workspacePath,
+        providers: manifest.providers,
+        sources: manifest.sources.map(({ locator: _locator, authorizedRoot: _root, ...source }) => source),
+        totals: {
+            providers: manifest.providers.length,
+            sources: manifest.sources.length,
+        },
+    };
+}
+function sourceFromDescriptor(descriptor, locator, authorizedRoot, details, digest) {
+    return {
+        sourceId: sha256([
+            'workspace-source-v1', descriptor.provider, descriptor.locatorClass, digest,
+        ].join('\0')),
+        provider: descriptor.provider,
+        locator,
+        redactedLocator: redactSourceLocator(locator),
+        locatorClass: descriptor.locatorClass,
+        authorizedRoot,
+        modifiedAt: details.mtime.toISOString(),
+        sizeBytes: Number(details.size),
+        digest,
+    };
+}
+function providerReport(provider, status, disposition, sources, reasonCode, remediation) {
+    const timestamps = sources.map((source) => source.modifiedAt).sort();
+    return {
+        provider,
+        status,
+        disposition,
+        sourceCount: sources.length,
+        dateRange: {
+            earliest: timestamps.at(0) ?? null,
+            latest: timestamps.at(-1) ?? null,
+        },
+        dateRangeBasis: 'source-mtime',
+        reasonCode,
+        remediation,
+    };
+}
+async function rediscoverManifestIdentity(manifest) {
+    const identity = {
+        schemaVersion: manifest.schemaVersion,
+        workspaceId: manifest.workspaceId,
+        sources: manifest.sources.map((source) => ({
+            sourceId: source.sourceId,
+            provider: source.provider,
+            locatorClass: source.locatorClass,
+            locator: source.locator,
+            modifiedAt: source.modifiedAt,
+            sizeBytes: source.sizeBytes,
+            digest: source.digest,
+        })),
+        providers: manifest.providers.map((provider) => ({
+            provider: provider.provider,
+            status: provider.status,
+            reasonCode: provider.reasonCode,
+        })),
+    };
+    return sha256(JSON.stringify(identity));
+}
+async function codexSourceMatchesWorkspace(locator, workspacePath) {
+    const input = createReadStream(locator, { encoding: 'utf8' });
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    let count = 0;
+    try {
+        for await (const line of lines) {
+            if (++count > 50)
+                break;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const cwd = codexWorkspaceField(value);
+            if (!cwd)
+                continue;
+            try {
+                return await canonicalPath(cwd) === workspacePath;
+            }
+            catch {
+                return resolve(cwd) === workspacePath;
+            }
+        }
+        return false;
+    }
+    finally {
+        lines.close();
+        input.destroy();
+    }
+}
+function codexWorkspaceField(value) {
+    const root = asObject(value);
+    const payload = asObject(root.payload);
+    const result = asObject(root.result);
+    const resultThread = asObject(result.thread);
+    const params = asObject(root.params);
+    const paramsThread = asObject(params.thread);
+    for (const candidate of [
+        payload.cwd, result.cwd, resultThread.cwd, params.cwd, paramsThread.cwd,
+    ]) {
+        if (typeof candidate === 'string' && candidate.length > 0)
+            return candidate;
+    }
+    return null;
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+async function canonicalPath(path) {
+    return realpath(resolve(path));
+}
+function workspaceKey(path, retainLeadingSeparator) {
+    const normalized = path.replace(/\\/g, '/');
+    const input = retainLeadingSeparator ? normalized : normalized.replace(/^\/+/, '');
+    return input.replace(/[/:]+/g, '-');
+}
+function providerHomeCandidates(explicit, operatorHome) {
+    if (explicit)
+        return [resolve(explicit)];
+    let accountHome = operatorHome;
+    if (!accountHome) {
+        try {
+            accountHome = userInfo().homedir;
+        }
+        catch {
+            accountHome = undefined;
+        }
+    }
+    return [...new Set([homedir(), accountHome].filter((candidate) => Boolean(candidate)).map((candidate) => resolve(candidate)))];
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function compareSources(left, right) {
+    return left.provider.localeCompare(right.provider)
+        || left.locator.localeCompare(right.locator)
+        || basename(left.locator).localeCompare(basename(right.locator));
+}
+//# sourceMappingURL=workspace-discovery.js.map

package/dist/src/skills/adapters/agent-skills.js

@@ -0,0 +1,59 @@
+/**
+ * Managed Agent Skills adapter.
+ *
+ * Imported sources remain separate from provider deployments. This adapter
+ * supports inspection and import only; provider projection is implemented by
+ * the deployment layer.
+ *
+ * @implements #1877
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getImportedAgentSkill, importAgentSkill, listImportedAgentSkills, } from '../importer.js';
+export class AgentSkillsAdapter {
+    projectDir;
+    id = 'agentskills';
+    name = 'Agent Skills (Managed Imports)';
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+    }
+    resolveProjectDir() {
+        return this.projectDir ?? process.cwd();
+    }
+    async isAvailable() {
+        return true;
+    }
+    async list() {
+        return listImportedAgentSkills(this.resolveProjectDir()).map((record) => ({
+            name: record.name,
+            description: record.description,
+            source: this.id,
+            installed: true,
+        }));
+    }
+    async search(query) {
+        const normalized = query.toLowerCase();
+        return (await this.list()).filter((skill) => (skill.name.toLowerCase().includes(normalized)
+            || skill.description.toLowerCase().includes(normalized)));
+    }
+    async info(name) {
+        const record = getImportedAgentSkill(this.resolveProjectDir(), name);
+        if (!record)
+            return undefined;
+        const skillPath = path.join(record.managedLocation, 'SKILL.md');
+        const managedDrift = record.diagnostics.some((item) => item.code === 'AS_IMPORT_MANAGED_DRIFT');
+        return {
+            name: record.name,
+            description: record.description,
+            source: this.id,
+            installed: true,
+            path: skillPath,
+            content: managedDrift ? undefined : fs.readFileSync(skillPath, 'utf8'),
+            imported: record,
+        };
+    }
+    async importSource(source, options) {
+        return importAgentSkill(source, options);
+    }
+}
+//# sourceMappingURL=agent-skills.js.map

package/dist/src/skills/adapters/local.js

@@ -11,7 +11,25 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { getProviderDefinition, resolveProviderPathValue, } from '../../providers/provider-definitions.js';
 const _scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const AIWG_ROOT = process.env.AIWG_ROOT || path.resolve(_scriptDir, '../../../');
+function resolveAiwgRoot() {
+    if (process.env.AIWG_ROOT)
+        return process.env.AIWG_ROOT;
+    const candidates = [
+        path.resolve(_scriptDir, '../../../'),
+        path.resolve(_scriptDir, '../../../../'),
+    ];
+    const repoRoot = candidates.find((candidate) => (fs.existsSync(path.join(candidate, 'package.json'))
+        && fs.existsSync(path.join(candidate, 'agentic', 'code'))));
+    if (repoRoot)
+        return repoRoot;
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(candidate, 'agentic', 'code'))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+const AIWG_ROOT = resolveAiwgRoot();
 function resolveSkillFallbackPath(target, projectDir, name) {
     const definition = getProviderDefinition(target);
     if (!definition)