@aiwg/cli 2026.8.0 → 2026.8.2

package/dist/src/memory/canonical-context.js

@@ -0,0 +1,342 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { z } from 'zod';
+const DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const LocatorSchema = z.string().min(1).max(512).refine(value => !/[\r\n\0]/.test(value));
+export const CanonicalContextTargetSchema = z.enum([
+    'project-fact', 'preference', 'goal', 'project', 'person', 'decision', 'operating-rule',
+]);
+export const CanonicalContextClassificationSchema = z.enum(['public', 'internal']);
+export const CanonicalContextProposalSchema = z.object({
+    target: CanonicalContextTargetSchema,
+    key: z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._-]*$/),
+    value: z.string().min(1).max(8192),
+    sourceRef: LocatorSchema,
+    sourceDigest: DigestSchema.nullable().default(null),
+    reviewer: z.string().min(1).max(128),
+    reason: z.string().min(1).max(1024),
+    scope: z.string().min(1).max(128),
+    classification: CanonicalContextClassificationSchema,
+    reviewAt: z.string().datetime().nullable().default(null),
+    expiresAt: z.string().datetime().nullable().default(null),
+}).strict();
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function canonicalLocator(value) {
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            parsed.username = '';
+            parsed.password = '';
+            parsed.search = '';
+            parsed.hash = '';
+            return parsed.toString();
+        }
+    }
+    catch {
+        // Opaque locator.
+    }
+    return value;
+}
+function assertSafeProposal(proposal) {
+    const content = `${proposal.key}\n${proposal.value}\n${proposal.sourceRef}`;
+    if (/(?:ignore|disregard) (?:all |the )?(?:previous|prior) instructions|system prompt|developer message|(?:run|execute) (?:a )?(?:shell|command)/i.test(content)) {
+        throw new Error('canonical context proposal contains instruction-like material');
+    }
+    if (/(?:^|[?&;:\s])(?:api[_-]?key|access[_-]?token|token|secret|password|passwd|authorization)\s*[:=]\s*[^\s&;]+/i.test(content)
+        || /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/.test(content)) {
+        throw new Error('canonical context proposal contains unsafe material');
+    }
+    if (/^(?:system|developer|provider|agent)(?:\.|$)/.test(proposal.key)) {
+        throw new Error('canonical context cannot override a higher-authority namespace');
+    }
+}
+function ensureStorageInsideProject(projectRoot, target) {
+    const root = realpathSync(projectRoot);
+    const lexicalRoot = resolve(projectRoot);
+    const candidate = resolve(target);
+    if (candidate !== lexicalRoot && !candidate.startsWith(`${lexicalRoot}${sep}`)) {
+        throw new Error('canonical context storage must remain inside the project');
+    }
+    let ancestor = candidate;
+    while (!existsSync(ancestor))
+        ancestor = dirname(ancestor);
+    const actual = realpathSync(ancestor);
+    if (actual !== root && !actual.startsWith(`${root}${sep}`)) {
+        throw new Error('canonical context storage cannot traverse a link outside the project');
+    }
+}
+function writeJsonAtomic(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, filePath);
+}
+function workspaceIdentity(projectRoot) {
+    const root = realpathSync(projectRoot);
+    return sha256(relative(dirname(root), root));
+}
+function stableEntryId(proposal) {
+    return sha256(JSON.stringify({
+        target: proposal.target,
+        key: proposal.key,
+        value: proposal.value,
+        sourceRef: proposal.sourceRef,
+        sourceDigest: proposal.sourceDigest,
+        scope: proposal.scope,
+        classification: proposal.classification,
+    }));
+}
+function proposalFromEntry(entry) {
+    return CanonicalContextProposalSchema.parse({
+        target: entry.target,
+        key: entry.key,
+        value: entry.value,
+        sourceRef: entry.sourceRef,
+        sourceDigest: entry.sourceDigest,
+        reviewer: entry.reviewer,
+        reason: entry.reason,
+        scope: entry.scope,
+        classification: entry.classification,
+        reviewAt: entry.reviewAt,
+        expiresAt: entry.expiresAt,
+    });
+}
+function storeDigest(store) {
+    return sha256(JSON.stringify(store));
+}
+export class CanonicalContextRepository {
+    root;
+    statePath;
+    receiptRoot;
+    lockPath;
+    workspaceId;
+    constructor(projectRoot) {
+        this.root = resolve(projectRoot, '.aiwg/context/compound-memory');
+        this.statePath = resolve(this.root, 'context.json');
+        this.receiptRoot = resolve(this.root, 'receipts');
+        this.lockPath = resolve(this.root, '.lock');
+        ensureStorageInsideProject(projectRoot, this.root);
+        this.workspaceId = workspaceIdentity(projectRoot);
+    }
+    read() {
+        if (!existsSync(this.statePath)) {
+            return {
+                schemaVersion: 'aiwg.canonical-context.v1',
+                workspaceId: this.workspaceId,
+                revision: 0,
+                entries: {},
+            };
+        }
+        const store = JSON.parse(readFileSync(this.statePath, 'utf8'));
+        if (store.schemaVersion !== 'aiwg.canonical-context.v1'
+            || store.workspaceId !== this.workspaceId
+            || !Number.isSafeInteger(store.revision)
+            || typeof store.entries !== 'object'
+            || Array.isArray(store.entries)) {
+            throw new Error('canonical context store identity or schema is invalid');
+        }
+        return store;
+    }
+    previewUpsert(raw) {
+        const proposal = CanonicalContextProposalSchema.parse({
+            ...raw,
+            sourceRef: canonicalLocator(raw.sourceRef),
+        });
+        assertSafeProposal(proposal);
+        const store = this.read();
+        const entryId = stableEntryId(proposal);
+        const active = Object.values(store.entries).find(entry => (entry.status === 'active' && entry.target === proposal.target && entry.key === proposal.key));
+        const duplicate = active?.entryId === entryId;
+        const conflicts = active && !duplicate
+            ? [{ entryId: active.entryId, valueDigest: sha256(active.value) }]
+            : [];
+        const diff = duplicate ? [] : [
+            { field: `${proposal.target}.${proposal.key}`, before: active?.value ?? null, after: proposal.value },
+        ];
+        const snapshot = storeDigest(store);
+        return {
+            schemaVersion: 'aiwg.canonical-context-preview.v1',
+            operationId: sha256(JSON.stringify({ operation: 'upsert', proposal, snapshot })),
+            operation: 'upsert',
+            workspaceId: this.workspaceId,
+            storeDigest: snapshot,
+            duplicate,
+            confirmationRequired: true,
+            diff,
+            conflicts,
+            proposedEntryId: entryId,
+            importCount: 0,
+        };
+    }
+    previewRevoke(entryId, reviewer, reason) {
+        const store = this.read();
+        const entry = store.entries[entryId];
+        if (!entry)
+            throw new Error('canonical context entry was not found');
+        const duplicate = entry.status === 'revoked';
+        const snapshot = storeDigest(store);
+        return {
+            schemaVersion: 'aiwg.canonical-context-preview.v1',
+            operationId: sha256(JSON.stringify({ operation: 'revoke', entryId, reviewer, reason, snapshot })),
+            operation: 'revoke',
+            workspaceId: this.workspaceId,
+            storeDigest: snapshot,
+            duplicate,
+            confirmationRequired: true,
+            diff: duplicate ? [] : [{ field: `${entry.target}.${entry.key}`, before: entry.value, after: null }],
+            conflicts: [],
+            proposedEntryId: entryId,
+            importCount: 0,
+        };
+    }
+    export() {
+        const store = this.read();
+        return {
+            schemaVersion: 'aiwg.canonical-context-export.v1',
+            sourceWorkspaceId: store.workspaceId,
+            exportedAt: new Date().toISOString(),
+            entries: Object.values(store.entries).sort((left, right) => left.entryId.localeCompare(right.entryId)),
+        };
+    }
+    previewImport(bundle, allowCrossWorkspace = false) {
+        if (bundle.schemaVersion !== 'aiwg.canonical-context-export.v1' || !Array.isArray(bundle.entries)) {
+            throw new Error('canonical context import schema is invalid');
+        }
+        if (bundle.sourceWorkspaceId !== this.workspaceId && !allowCrossWorkspace) {
+            throw new Error('cross-workspace context import requires explicit authorization');
+        }
+        for (const entry of bundle.entries)
+            assertSafeProposal(proposalFromEntry(entry));
+        const store = this.read();
+        const conflicts = bundle.entries.flatMap(imported => Object.values(store.entries)
+            .filter(entry => entry.status === 'active'
+            && imported.status === 'active'
+            && entry.target === imported.target
+            && entry.key === imported.key
+            && entry.value !== imported.value)
+            .map(entry => ({ entryId: entry.entryId, valueDigest: sha256(entry.value) })));
+        const snapshot = storeDigest(store);
+        return {
+            schemaVersion: 'aiwg.canonical-context-preview.v1',
+            operationId: sha256(JSON.stringify({
+                operation: 'import',
+                bundleDigest: sha256(JSON.stringify(bundle)),
+                allowCrossWorkspace,
+                snapshot,
+            })),
+            operation: 'import',
+            workspaceId: this.workspaceId,
+            storeDigest: snapshot,
+            duplicate: bundle.entries.every(entry => Boolean(store.entries[entry.entryId])),
+            confirmationRequired: true,
+            diff: bundle.entries
+                .filter(entry => !store.entries[entry.entryId])
+                .map(entry => ({ field: `${entry.target}.${entry.key}`, before: null, after: entry.value })),
+            conflicts,
+            proposedEntryId: null,
+            importCount: bundle.entries.length,
+        };
+    }
+    confirm(input) {
+        mkdirSync(this.root, { recursive: true });
+        const lock = openSync(this.lockPath, 'wx', 0o600);
+        try {
+            const requestedReceiptPath = resolve(this.receiptRoot, `${input.preview.operationId.replace(':', '_')}.json`);
+            if (existsSync(requestedReceiptPath)) {
+                return {
+                    ...JSON.parse(readFileSync(requestedReceiptPath, 'utf8')),
+                    duplicate: true,
+                };
+            }
+            const current = input.preview.operation === 'upsert' && input.proposal
+                ? this.previewUpsert(input.proposal)
+                : input.preview.operation === 'revoke' && input.revoke
+                    ? this.previewRevoke(input.revoke.entryId, input.revoke.reviewer, input.revoke.reason)
+                    : input.preview.operation === 'import' && input.bundle
+                        ? this.previewImport(input.bundle, input.allowCrossWorkspace)
+                        : null;
+            if (!current || current.operationId !== input.preview.operationId) {
+                throw new Error('confirmation requires the exact current canonical-context preview');
+            }
+            const receiptPath = requestedReceiptPath;
+            const store = this.read();
+            const now = new Date().toISOString();
+            const changed = [];
+            if (current.operation === 'upsert' && input.proposal && current.proposedEntryId) {
+                const proposal = CanonicalContextProposalSchema.parse({
+                    ...input.proposal,
+                    sourceRef: canonicalLocator(input.proposal.sourceRef),
+                });
+                if (!current.duplicate) {
+                    const active = Object.values(store.entries).find(entry => (entry.status === 'active' && entry.target === proposal.target && entry.key === proposal.key));
+                    if (active) {
+                        active.status = 'superseded';
+                        active.updatedAt = now;
+                        active.disposition = { reviewer: proposal.reviewer, reason: proposal.reason, recordedAt: now };
+                        changed.push(active.entryId);
+                    }
+                    store.entries[current.proposedEntryId] = {
+                        ...proposal,
+                        entryId: current.proposedEntryId,
+                        status: 'active',
+                        createdAt: now,
+                        updatedAt: now,
+                        supersedes: active?.entryId ?? null,
+                        disposition: null,
+                        importedFromWorkspace: null,
+                    };
+                    changed.push(current.proposedEntryId);
+                }
+            }
+            else if (current.operation === 'revoke' && input.revoke) {
+                const entry = store.entries[input.revoke.entryId];
+                if (!current.duplicate) {
+                    entry.status = 'revoked';
+                    entry.updatedAt = now;
+                    entry.disposition = {
+                        reviewer: input.revoke.reviewer,
+                        reason: input.revoke.reason,
+                        recordedAt: now,
+                    };
+                    changed.push(entry.entryId);
+                }
+            }
+            else if (current.operation === 'import' && input.bundle) {
+                for (const imported of input.bundle.entries) {
+                    if (store.entries[imported.entryId])
+                        continue;
+                    store.entries[imported.entryId] = {
+                        ...imported,
+                        importedFromWorkspace: input.bundle.sourceWorkspaceId,
+                    };
+                    changed.push(imported.entryId);
+                }
+            }
+            if (changed.length > 0) {
+                store.revision += 1;
+                writeJsonAtomic(this.statePath, store);
+            }
+            const receipt = {
+                schemaVersion: 'aiwg.canonical-context-receipt.v1',
+                receiptId: sha256(`${current.operationId}\0${store.revision}`),
+                operationId: current.operationId,
+                operation: current.operation,
+                workspaceId: this.workspaceId,
+                entryIds: changed,
+                revision: store.revision,
+                duplicate: current.duplicate,
+                completedAt: now,
+            };
+            writeJsonAtomic(receiptPath, receipt);
+            return receipt;
+        }
+        finally {
+            closeSync(lock);
+            unlinkSync(this.lockPath);
+        }
+    }
+}
+//# sourceMappingURL=canonical-context.js.map

package/dist/src/memory/context-pack.js

@@ -0,0 +1,282 @@
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync, } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { relative, resolve, sep } from 'node:path';
+import { loadFortemiCoreMetadataEntries } from '../artifacts/fortemi-core-query-adapter.js';
+const DEFAULT_BUDGET = {
+    totalCharacters: 8000,
+    lineCharacters: 2000,
+    wikiCharacters: 4000,
+    citationCharacters: 1500,
+    instructionCharacters: 500,
+};
+const EXCLUDED_STATES = new Set([
+    'contradicted', 'superseded', 'revoked', 'origin-unavailable',
+]);
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function projectLocator(root, target) {
+    const actual = realpathSync(target);
+    if (actual !== root && !actual.startsWith(`${root}${sep}`)) {
+        throw new Error('context source cannot traverse a link outside the project');
+    }
+    return relative(root, actual).split(sep).join('/');
+}
+function terms(value) {
+    return [...new Set(value.toLocaleLowerCase().match(/[a-z0-9][a-z0-9_-]{1,}/g) ?? [])];
+}
+function lexicalScore(taskTerms, text) {
+    if (taskTerms.length === 0)
+        return 0;
+    const normalized = text.toLocaleLowerCase();
+    const hits = taskTerms.filter(term => normalized.includes(term)).length;
+    return hits / taskTerms.length;
+}
+function normalizedClaim(value) {
+    return value.toLocaleLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+function boundedInteger(value, minimum, maximum, name) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`${name} must be an integer from ${minimum} through ${maximum}`);
+    }
+    return value;
+}
+function resolvedBudget(input = {}) {
+    const budget = { ...DEFAULT_BUDGET, ...input };
+    boundedInteger(budget.totalCharacters, 256, 65536, 'totalCharacters');
+    boundedInteger(budget.lineCharacters, 0, 65536, 'lineCharacters');
+    boundedInteger(budget.wikiCharacters, 0, 65536, 'wikiCharacters');
+    boundedInteger(budget.citationCharacters, 0, 16384, 'citationCharacters');
+    boundedInteger(budget.instructionCharacters, 0, 8192, 'instructionCharacters');
+    return budget;
+}
+function lineCandidates(root, taskTerms) {
+    const memoryPath = resolve(root, '.aiwg/memory/line-memory.txt');
+    const metadataPath = resolve(root, '.aiwg/memory/line-memory.meta.json');
+    if (!existsSync(memoryPath))
+        return [];
+    projectLocator(root, memoryPath);
+    const values = readFileSync(memoryPath, 'utf8').split(/\r?\n/).filter(value => value.trim());
+    let entries = {};
+    if (existsSync(metadataPath)) {
+        projectLocator(root, metadataPath);
+        const parsed = JSON.parse(readFileSync(metadataPath, 'utf8'));
+        entries = parsed.entries ?? {};
+    }
+    return values.map((text, index) => {
+        const entry = Object.values(entries).find(candidate => candidate.value === text && candidate.status === 'active');
+        const sources = Array.isArray(entry?.sources) ? entry.sources : [];
+        const score = lexicalScore(taskTerms, text);
+        return {
+            tier: 'line',
+            text,
+            locator: typeof entry?.id === 'string' ? `line-memory:${entry.id}` : `.aiwg/memory/line-memory.txt#line-${index + 1}`,
+            digest: typeof entry?.digest === 'string' ? entry.digest : sha256(text),
+            score,
+            backend: 'line-memory-lexical',
+            verified: sources.length > 0,
+            state: 'active',
+            freshness: typeof entry?.updatedAt === 'string' ? entry.updatedAt : null,
+        };
+    }).filter(candidate => candidate.score > 0);
+}
+function markdownText(raw) {
+    return raw
+        .replace(/^---\s*[\s\S]*?\n---\s*/m, '')
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/!\?\[\[[^\]]+\]\]/g, ' ')
+        .replace(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g, '$1')
+        .replace(/[#>*_`~-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function wikiCandidates(root, taskTerms, maxFiles) {
+    const wikiRoot = resolve(root, '.aiwg/wiki');
+    if (!existsSync(wikiRoot))
+        return [];
+    projectLocator(root, wikiRoot);
+    const pending = [wikiRoot];
+    const results = [];
+    let visited = 0;
+    while (pending.length > 0 && visited < maxFiles) {
+        const directory = pending.shift();
+        for (const entry of readdirSync(directory, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            if (visited >= maxFiles)
+                break;
+            const target = resolve(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                pending.push(target);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md') || entry.name === 'index.md')
+                continue;
+            visited += 1;
+            const locator = projectLocator(root, target);
+            const raw = readFileSync(target, 'utf8').slice(0, 65536);
+            const text = markdownText(raw).slice(0, 1200);
+            const score = lexicalScore(taskTerms, text);
+            if (score <= 0)
+                continue;
+            const stat = statSync(target);
+            results.push({
+                tier: 'wiki',
+                text,
+                locator,
+                digest: sha256(raw),
+                score,
+                backend: 'wiki-lexical-fallback',
+                verified: /(?:^|\n)(?:source|sources|provenance):/i.test(raw),
+                state: 'active',
+                freshness: stat.mtime.toISOString(),
+            });
+        }
+    }
+    return results;
+}
+function fortemiWikiCandidates(root, taskTerms, maxFiles) {
+    const loaded = loadFortemiCoreMetadataEntries(root, 'project');
+    if (loaded.reason || loaded.entries.length === 0)
+        return [];
+    const results = [];
+    for (const entry of loaded.entries
+        .filter(candidate => candidate.path.startsWith('.aiwg/wiki/') && candidate.path.endsWith('.md'))
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .slice(0, maxFiles)) {
+        const target = resolve(root, entry.path);
+        if (!existsSync(target))
+            continue;
+        const locator = projectLocator(root, target);
+        const raw = readFileSync(target, 'utf8').slice(0, 65536);
+        const text = markdownText(raw).slice(0, 1200);
+        const score = lexicalScore(taskTerms, [entry.title, entry.summary, text].join(' '));
+        if (score <= 0)
+            continue;
+        results.push({
+            tier: 'wiki',
+            text,
+            locator,
+            digest: /^(?:sha256:)?[0-9a-f]{64}$/i.test(entry.checksum)
+                ? `sha256:${entry.checksum.replace(/^sha256:/, '').toLocaleLowerCase()}`
+                : sha256(raw),
+            score,
+            backend: 'fortemi-core',
+            verified: /(?:^|\n)(?:source|sources|provenance):/i.test(raw),
+            state: 'active',
+            freshness: entry.updated || statSync(target).mtime.toISOString(),
+        });
+    }
+    return results;
+}
+function rank(candidates) {
+    const effectiveScore = (candidate) => (candidate.state === 'stale' ? candidate.score * 0.5 : candidate.score);
+    return [...candidates].sort((left, right) => (effectiveScore(right) - effectiveScore(left)
+        || (left.tier === right.tier ? 0 : left.tier === 'line' ? -1 : 1)
+        || left.locator.localeCompare(right.locator)));
+}
+export function buildContextPack(task, candidates, options = {}) {
+    const started = performance.now();
+    const budget = resolvedBudget(options.budget);
+    const maxFiles = boundedInteger(options.maxFiles ?? 1000, 1, 10000, 'maxFiles');
+    const excluded = [];
+    const deduplicated = new Map();
+    for (const candidate of rank(candidates)) {
+        if (EXCLUDED_STATES.has(candidate.state)) {
+            excluded.push({ locator: candidate.locator, reason: candidate.state });
+            continue;
+        }
+        const key = normalizedClaim(candidate.text);
+        if (!key)
+            continue;
+        if (deduplicated.has(key)) {
+            excluded.push({ locator: candidate.locator, reason: 'duplicate-claim' });
+            continue;
+        }
+        deduplicated.set(key, candidate);
+    }
+    const used = {
+        totalCharacters: 0,
+        lineCharacters: 0,
+        wikiCharacters: 0,
+        citationCharacters: 0,
+        instructionCharacters: 0,
+    };
+    const instructions = [];
+    for (const instruction of options.instructions ?? []) {
+        const cost = instruction.text.length;
+        if (used.instructionCharacters + cost > budget.instructionCharacters
+            || used.totalCharacters + cost > budget.totalCharacters) {
+            excluded.push({ locator: instruction.locator, reason: 'instruction-budget' });
+            continue;
+        }
+        instructions.push(instruction);
+        used.instructionCharacters += cost;
+        used.totalCharacters += cost;
+    }
+    const items = [];
+    for (const candidate of deduplicated.values()) {
+        const section = candidate.tier === 'line' ? 'lineCharacters' : 'wikiCharacters';
+        const sectionLimit = candidate.tier === 'line' ? budget.lineCharacters : budget.wikiCharacters;
+        const citation = `${candidate.locator}${candidate.digest ? ` ${candidate.digest}` : ''}`;
+        const contentCost = candidate.text.length;
+        const citationCost = citation.length;
+        if (used[section] + contentCost > sectionLimit) {
+            excluded.push({ locator: candidate.locator, reason: `${candidate.tier}-budget` });
+            continue;
+        }
+        if (used.citationCharacters + citationCost > budget.citationCharacters) {
+            excluded.push({ locator: candidate.locator, reason: 'citation-budget' });
+            continue;
+        }
+        if (used.totalCharacters + contentCost + citationCost > budget.totalCharacters) {
+            excluded.push({ locator: candidate.locator, reason: 'total-budget' });
+            continue;
+        }
+        items.push({ ...candidate, trust: 'quoted-data', citation });
+        used[section] += contentCost;
+        used.citationCharacters += citationCost;
+        used.totalCharacters += contentCost + citationCost;
+    }
+    const identity = {
+        taskDigest: sha256(task),
+        budget,
+        items: items.map(item => ({ locator: item.locator, digest: item.digest, text: item.text })),
+        instructions,
+    };
+    return {
+        schemaVersion: 'aiwg.compound-memory.context-pack.v1',
+        id: sha256(JSON.stringify(identity)),
+        taskDigest: identity.taskDigest,
+        backend: [...new Set(items.map(item => item.backend))].sort(),
+        budget,
+        used,
+        items,
+        instructions,
+        excluded,
+        truncated: excluded.some(item => item.reason.endsWith('budget')),
+        metrics: {
+            candidates: candidates.length,
+            selected: items.length,
+            elapsedMs: Number((performance.now() - started).toFixed(3)),
+            maxFiles,
+        },
+    };
+}
+export function buildWorkspaceContextPack(projectRoot, task, options = {}) {
+    if (!task.trim())
+        throw new Error('context task must be nonblank');
+    const root = realpathSync(projectRoot);
+    const taskTerms = terms(task);
+    const maxFiles = boundedInteger(options.maxFiles ?? 1000, 1, 10000, 'maxFiles');
+    const candidates = [
+        ...lineCandidates(root, taskTerms),
+        ...(() => {
+            const indexed = fortemiWikiCandidates(root, taskTerms, maxFiles);
+            return indexed.length > 0 ? indexed : wikiCandidates(root, taskTerms, maxFiles);
+        })(),
+    ];
+    return buildContextPack(task, candidates, { ...options, maxFiles });
+}
+//# sourceMappingURL=context-pack.js.map

package/dist/src/memory/index.js

@@ -0,0 +1,4 @@
+export * from './context-pack.js';
+export * from './canonical-context.js';
+export * from './intake.js';
+//# sourceMappingURL=index.js.map