harborloop 0.3.0 → 0.4.1

package/dist/slugify.js

@@ -1,8 +0,0 @@
-export function slugify(name) {
-    const lowered = name.toLowerCase();
-    const mapped = Array.from(lowered, (ch) => (/[a-z0-9-]/.test(ch) ? ch : '-')).join('');
-    return mapped
-        .split('-')
-        .filter((part) => part.length > 0)
-        .join('-');
-}

package/dist/state.d.ts

@@ -1,23 +0,0 @@
-export type PauseMode = 'off' | 'capture' | 'on';
-export interface PauseState {
-    readonly global: PauseMode | null;
-    readonly repos: Readonly<Record<string, PauseMode>>;
-}
-export interface SyncedConfig {
-    readonly apiBase: string;
-    readonly origins: readonly string[];
-    readonly pause: PauseState;
-    readonly receipt: boolean;
-}
-export declare const EMPTY_PAUSE: PauseState;
-export interface RepoArms {
-    readonly recall: boolean;
-    readonly capture: boolean;
-}
-export declare function resolveArms(pause: PauseState, originUrl: string): RepoArms;
-export declare function readSyncedConfig(): Promise<SyncedConfig | null>;
-export declare function updateSyncedConfig(mutate: (current: SyncedConfig) => SyncedConfig): Promise<SyncedConfig>;
-export declare function withRepoPause(config: SyncedConfig, originUrl: string, mode: PauseMode | null): SyncedConfig;
-export declare function withReceipt(config: SyncedConfig, receipt: boolean): SyncedConfig;
-export declare function withGlobalPause(config: SyncedConfig, mode: PauseMode | null): SyncedConfig;
-export declare function migrateLegacyState(): Promise<'migrated' | 'skipped'>;

package/dist/state.js

@@ -1,161 +0,0 @@
-import { mkdir, readFile } from 'node:fs/promises';
-import { updateFileLocked } from './lock.js';
-import { normalizeOriginUrl } from './origin.js';
-import { harborDir, legacyDirs, syncedOriginsFile } from './paths.js';
-export const EMPTY_PAUSE = { global: null, repos: {} };
-export function resolveArms(pause, originUrl) {
-    const mode = pause.repos[originUrl] ?? pause.global;
-    if (mode === 'off')
-        return { recall: false, capture: false };
-    if (mode === 'capture')
-        return { recall: true, capture: false };
-    return { recall: true, capture: true };
-}
-const isMode = (value) => value === 'off' || value === 'capture' || value === 'on';
-function parsePause(raw) {
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-        return EMPTY_PAUSE;
-    }
-    const obj = raw;
-    const global = isMode(obj.global) ? obj.global : null;
-    const repos = {};
-    const rawRepos = obj.repos;
-    if (rawRepos !== null && typeof rawRepos === 'object' && !Array.isArray(rawRepos)) {
-        for (const [key, value] of Object.entries(rawRepos)) {
-            if (isMode(value))
-                repos[normalizeOriginUrl(key)] = value;
-        }
-    }
-    return { global, repos };
-}
-export async function readSyncedConfig() {
-    let raw;
-    try {
-        raw = await readFile(syncedOriginsFile(), 'utf8');
-    }
-    catch {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return null;
-    }
-    const obj = parsed;
-    if (typeof obj.apiBase !== 'string' || !Array.isArray(obj.origins))
-        return null;
-    const legacyCaptureOff = obj.capture === false;
-    const pause = parsePause(obj.pause);
-    return {
-        apiBase: obj.apiBase.replace(/\/+$/, ''),
-        origins: obj.origins
-            .map((o) => normalizeOriginUrl(String(o)))
-            .filter((o) => o !== ''),
-        pause: legacyCaptureOff && pause.global === null
-            ? { ...pause, global: 'capture' }
-            : pause,
-        receipt: readReceipt(obj),
-    };
-}
-function serialise(config) {
-    const body = {
-        apiBase: config.apiBase,
-        origins: [...config.origins],
-    };
-    if (config.pause.global !== null || Object.keys(config.pause.repos).length > 0) {
-        body.pause = { global: config.pause.global, repos: config.pause.repos };
-    }
-    if (!config.receipt)
-        body.receipt = false;
-    return `${JSON.stringify(body, null, 2)}\n`;
-}
-export async function updateSyncedConfig(mutate) {
-    await mkdir(harborDir(), { recursive: true, mode: 0o700 });
-    let result;
-    await updateFileLocked(syncedOriginsFile(), (existing) => {
-        const current = parseOrEmpty(existing);
-        result = mutate(current);
-        return serialise(result);
-    });
-    return result;
-}
-function parseOrEmpty(existing) {
-    if (existing.trim() === '') {
-        return { apiBase: '', origins: [], pause: EMPTY_PAUSE, receipt: true };
-    }
-    try {
-        const obj = JSON.parse(existing);
-        return {
-            apiBase: typeof obj.apiBase === 'string' ? obj.apiBase.replace(/\/+$/, '') : '',
-            origins: Array.isArray(obj.origins)
-                ? obj.origins.map((o) => normalizeOriginUrl(String(o))).filter((o) => o !== '')
-                : [],
-            pause: obj.capture === false && parsePause(obj.pause).global === null
-                ? { ...parsePause(obj.pause), global: 'capture' }
-                : parsePause(obj.pause),
-            receipt: readReceipt(obj),
-        };
-    }
-    catch {
-        return { apiBase: '', origins: [], pause: EMPTY_PAUSE, receipt: true };
-    }
-}
-function readReceipt(obj) {
-    return obj.receipt !== false;
-}
-export function withRepoPause(config, originUrl, mode) {
-    const repos = { ...config.pause.repos };
-    if (mode === null)
-        delete repos[originUrl];
-    else
-        repos[originUrl] = mode;
-    return { ...config, pause: { ...config.pause, repos } };
-}
-export function withReceipt(config, receipt) {
-    return { ...config, receipt };
-}
-export function withGlobalPause(config, mode) {
-    return { ...config, pause: { ...config.pause, global: mode } };
-}
-export async function migrateLegacyState() {
-    const existing = await readSyncedConfig();
-    if (existing)
-        return 'skipped';
-    let legacyRaw;
-    for (const dir of legacyDirs()) {
-        try {
-            legacyRaw = await readFile(`${dir}/synced-origins.json`, 'utf8');
-            break;
-        }
-        catch {
-        }
-    }
-    if (legacyRaw === undefined)
-        return 'skipped';
-    let parsed;
-    try {
-        parsed = JSON.parse(legacyRaw);
-    }
-    catch {
-        return 'skipped';
-    }
-    if (parsed === null || typeof parsed !== 'object')
-        return 'skipped';
-    const obj = parsed;
-    if (typeof obj.apiBase !== 'string' || !Array.isArray(obj.origins))
-        return 'skipped';
-    await updateSyncedConfig(() => ({
-        apiBase: obj.apiBase,
-        origins: obj.origins
-            .map((o) => normalizeOriginUrl(String(o)))
-            .filter((o) => o !== ''),
-        pause: obj.capture === false ? { global: 'capture', repos: {} } : EMPTY_PAUSE,
-        receipt: readReceipt(obj),
-    }));
-    return 'migrated';
-}

package/dist/sync-report.d.ts

@@ -1,59 +0,0 @@
-import { type Owner } from './context-budget.js';
-import { type EnvScanOptions } from './env-scan.js';
-export interface SyncReportFile {
-    readonly kind: 'SKILL' | 'DOCUMENT';
-    readonly agent: string;
-    readonly dir: string;
-    readonly file: string;
-    readonly sha256: string | null;
-    readonly state: 'ours' | 'forked' | 'missing' | 'unverifiable';
-}
-export interface SyncReportSkill {
-    readonly name: string;
-    readonly owner: Owner;
-    readonly tokens: number;
-    readonly undiscoverable: boolean;
-}
-export interface SyncReportBudget {
-    readonly tokens: number;
-    readonly unmeasuredLines: number;
-    readonly skillsIndexed: number;
-    readonly skillsManaged: number;
-    readonly skillsOtherTool: number;
-    readonly skillsUnowned: number;
-    readonly skillsUndiscoverable: number;
-    readonly skills: readonly SyncReportSkill[];
-}
-export interface SyncReport {
-    readonly machineId: string;
-    readonly hostname: string;
-    readonly os: string;
-    readonly osVersion: string;
-    readonly cliVersion: string;
-    readonly bundleHash?: string;
-    readonly files: readonly SyncReportFile[];
-    readonly budget?: SyncReportBudget;
-}
-export type PostSyncReportResult = {
-    readonly kind: 'ok';
-    readonly machines: number;
-} | {
-    readonly kind: 'unsupported';
-} | {
-    readonly kind: 'error';
-    readonly status: number | 'network';
-    readonly message: string;
-};
-export interface PostSyncReportInput {
-    readonly apiBase: string;
-    readonly workspaceId: string;
-    readonly bearerToken: string;
-    readonly report: SyncReport;
-    readonly fetchImpl?: typeof fetch;
-}
-export declare function syncReportUrl(apiBase: string, workspaceId: string): string;
-export declare function measureReportBudget(options: EnvScanOptions): Promise<SyncReportBudget | null>;
-export declare function buildSyncReport(options?: EnvScanOptions & {
-    readonly bundleHash?: string;
-}): Promise<SyncReport>;
-export declare function postSyncReport(input: PostSyncReportInput): Promise<PostSyncReportResult>;

package/dist/sync-report.js

@@ -1,87 +0,0 @@
-import { ApiError, apiRequest } from './api.js';
-import { measureContext } from './context-budget.js';
-import { scanEnv, scannedFiles } from './env-scan.js';
-import { readMachineFacts } from './machine.js';
-function stripTrailingSlash(s) {
-    return s.endsWith('/') ? s.slice(0, -1) : s;
-}
-export function syncReportUrl(apiBase, workspaceId) {
-    return (`${stripTrailingSlash(apiBase)}/workspaces/${encodeURIComponent(workspaceId)}` +
-        `/context/sync-report`);
-}
-export async function measureReportBudget(options) {
-    try {
-        const budget = await measureContext({
-            ...(options.home === undefined ? {} : { home: options.home }),
-            ...(options.agents === undefined ? {} : { agents: options.agents }),
-            repoPath: null,
-        });
-        return {
-            tokens: budget.measuredTokens,
-            unmeasuredLines: budget.unmeasuredLines,
-            skillsIndexed: budget.skills.length - budget.undiscoverable,
-            skillsManaged: budget.ownership.harbor,
-            skillsOtherTool: budget.ownership['other-tool'],
-            skillsUnowned: budget.ownership.nobody,
-            skillsUndiscoverable: budget.undiscoverable,
-            skills: budget.skills.map((skill) => ({
-                name: skill.name,
-                owner: skill.owner,
-                tokens: skill.tokens,
-                undiscoverable: skill.undiscoverable,
-            })),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function buildSyncReport(options = {}) {
-    const { bundleHash, ...scanOptions } = options;
-    const [facts, scan, budget] = await Promise.all([
-        readMachineFacts(),
-        scanEnv(scanOptions),
-        measureReportBudget(scanOptions),
-    ]);
-    return {
-        machineId: facts.id,
-        hostname: facts.hostname,
-        os: facts.os,
-        osVersion: facts.osVersion,
-        cliVersion: facts.cliVersion,
-        ...(bundleHash === undefined ? {} : { bundleHash }),
-        files: scannedFiles(scan).map((f) => ({
-            kind: f.kind,
-            agent: f.agent,
-            dir: f.dir,
-            file: f.file,
-            sha256: f.sha256,
-            state: f.state,
-        })),
-        ...(budget === null ? {} : { budget }),
-    };
-}
-export async function postSyncReport(input) {
-    const url = syncReportUrl(input.apiBase, input.workspaceId);
-    try {
-        const body = await apiRequest(url, {
-            method: 'POST',
-            bearer: input.bearerToken,
-            body: input.report,
-            ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
-        });
-        return { kind: 'ok', machines: body?.data?.machines ?? 1 };
-    }
-    catch (err) {
-        if (!(err instanceof ApiError)) {
-            return {
-                kind: 'error',
-                status: 'network',
-                message: err instanceof Error ? err.message : String(err),
-            };
-        }
-        if (err.status === 404)
-            return { kind: 'unsupported' };
-        return { kind: 'error', status: err.status ?? 'network', message: err.message };
-    }
-}

package/hooks/_recall.mjs

@@ -1,288 +0,0 @@
-const TASK_KEY_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
-const STOPWORDS = new Set([
-    'the', 'a', 'an', 'and', 'or', 'but', 'if', 'then', 'else', 'so', 'as',
-    'of', 'to', 'in', 'on', 'at', 'by', 'for', 'with', 'from', 'into', 'onto',
-    'about', 'over', 'under', 'out', 'up', 'off', 'this', 'that', 'these',
-    'those', 'it', 'its', 'here', 'there', 'all', 'any', 'some', 'no', 'not',
-    'i', 'im', 'me', 'my', 'mine', 'we', 'us', 'our', 'ours', 'you', 'your',
-    'yours', 'he', 'him', 'his', 'she', 'her', 'they', 'them', 'their',
-    'hi', 'hey', 'hello', 'yo', 'thanks', 'thank', 'thankyou', 'please', 'pls',
-    'ok', 'okay', 'kk', 'yeah', 'yep', 'yes', 'nope', 'sure', 'cool', 'nice',
-    'great', 'lol', 'hmm', 'oh', 'ah', 'well', 'btw', 'fyi', 'actually',
-    'what', 'whats', 'why', 'how', 'when', 'where', 'who', 'which', 'whom',
-    'can', 'could', 'would', 'should', 'shall', 'will', 'wont', 'cant', 'do',
-    'does', 'did', 'is', 'are', 'am', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'having', 'may', 'might', 'must',
-    'get', 'got', 'make', 'made', 'let', 'lets', 'just', 'like', 'want',
-    'need', 'try', 'use', 'using', 'go', 'going', 'now', 'also', 'really',
-    'very', 'much', 'more', 'most', 'than', 'too', 'still', 'again', 'back',
-    'think', 'know', 'see', 'look', 'looks', 'tell', 'show', 'give', 'take',
-    'thing', 'things', 'stuff', 'something', 'anything', 'everything', 'one',
-    'ones', 'way', 'ways', 'bit', 'lot', 'good', 'bad', 'right', 'wrong',
-]);
-const ATTACHMENT_EXT_RE = /\.(?:png|jpe?g|gif|webp|svg|bmp|heic|heif|avif|pdf)$/i;
-export function tokenize(text) {
-    return text
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter((t) => t.length >= 2);
-}
-export function distinctiveTokens(text) {
-    const seen = new Set();
-    const out = [];
-    for (const tok of tokenize(text)) {
-        if (STOPWORDS.has(tok) || seen.has(tok))
-            continue;
-        seen.add(tok);
-        out.push(tok);
-    }
-    return out;
-}
-function isWhitespace(ch) {
-    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
-}
-export function stripAttachmentMentions(text) {
-    const pieces = [];
-    let cursor = 0;
-    let hadAttachment = false;
-    while (cursor < text.length) {
-        const at = text.indexOf('@', cursor);
-        if (at === -1) {
-            pieces.push(text.slice(cursor));
-            break;
-        }
-        if (at > 0 && !isWhitespace(text[at - 1] ?? '')) {
-            pieces.push(text.slice(cursor, at + 1));
-            cursor = at + 1;
-            continue;
-        }
-        let i = at + 1;
-        while (i < text.length) {
-            const ch = text[i];
-            if (ch === undefined)
-                break;
-            if (ch === '\\' && text[i + 1] === ' ') {
-                i += 2;
-                continue;
-            }
-            if (isWhitespace(ch))
-                break;
-            i += 1;
-        }
-        const rawPath = text.slice(at + 1, i);
-        const path = rawPath.replace(/\\ /g, ' ');
-        if (rawPath.length > 0 && ATTACHMENT_EXT_RE.test(path)) {
-            pieces.push(text.slice(cursor, at));
-            hadAttachment = true;
-            cursor = i;
-        }
-        else {
-            pieces.push(text.slice(cursor, i));
-            cursor = i;
-        }
-    }
-    const stripped = pieces
-        .join('')
-        .replace(/[ \t]{2,}/g, ' ')
-        .replace(/[ \t]+\n/g, '\n')
-        .trim();
-    return { stripped, hadAttachment };
-}
-function extractTaskKeys(text, issueId) {
-    const seen = new Set();
-    const out = [];
-    const push = (raw) => {
-        const key = raw.toUpperCase();
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        out.push(key);
-    };
-    for (const m of text.matchAll(TASK_KEY_RE))
-        push(m[0]);
-    if (issueId && issueId.length > 0)
-        push(issueId);
-    return out;
-}
-function fileEditTokens(fileEdits) {
-    if (!fileEdits || fileEdits.length === 0)
-        return [];
-    const seen = new Set();
-    const out = [];
-    const push = (raw) => {
-        const tok = raw.toLowerCase();
-        if (tok.length < 2 || seen.has(tok))
-            return;
-        seen.add(tok);
-        out.push(tok);
-    };
-    for (const edit of fileEdits) {
-        const base = edit.path.split(/[\\/]/).pop() ?? edit.path;
-        for (const part of base.split(/[^a-zA-Z0-9]+/))
-            push(part);
-        for (const sym of edit.symbols ?? [])
-            push(sym);
-    }
-    return out;
-}
-function normalizeDeducedTokens(deduced) {
-    if (!deduced || deduced.length === 0)
-        return [];
-    const seen = new Set();
-    const out = [];
-    for (const raw of deduced) {
-        const tok = raw.toLowerCase();
-        if (tok.length < 2 || seen.has(tok))
-            continue;
-        seen.add(tok);
-        out.push(tok);
-    }
-    return out;
-}
-export function buildRecallQuery(input) {
-    const taskKeys = extractTaskKeys(input.text, input.issueId);
-    const fileTokens = fileEditTokens(input.fileEdits);
-    const contentTokens = distinctiveTokens(input.text);
-    const deducedTokens = normalizeDeducedTokens(input.deducedTokens);
-    const tier = taskKeys.length
-        ? 'A'
-        : fileTokens.length
-            ? 'B'
-            : contentTokens.length
-                ? 'C'
-                : deducedTokens.length
-                    ? 'D'
-                    : null;
-    if (tier === null)
-        return null;
-    const queryParts = [...taskKeys, ...fileTokens, ...contentTokens, ...deducedTokens];
-    const tokenSeen = new Set();
-    const tokens = [];
-    for (const part of [
-        ...taskKeys.map((k) => k.toLowerCase()),
-        ...fileTokens,
-        ...contentTokens,
-        ...deducedTokens,
-    ]) {
-        if (tokenSeen.has(part))
-            continue;
-        tokenSeen.add(part);
-        tokens.push(part);
-    }
-    return { query: queryParts.join(' '), tokens, tier };
-}
-export const SIGNATURE_TOKEN_CAP = 40;
-function dedupe(tokens) {
-    const seen = new Set();
-    const out = [];
-    for (const tok of tokens) {
-        if (seen.has(tok))
-            continue;
-        seen.add(tok);
-        out.push(tok);
-    }
-    return out;
-}
-export const MIN_SHIFT_NEW_TOKENS = 2;
-export function evaluateShift(signature, tokens) {
-    const covered = new Set(Array.isArray(signature) ? signature : []);
-    const newTokens = dedupe(tokens).filter((t) => !covered.has(t));
-    return { shift: newTokens.length >= MIN_SHIFT_NEW_TOKENS, newTokens };
-}
-export const EMPTY_ASK_TOKEN_CAP = 200;
-export function askedAndEmpty(newTokens, emptyAsk) {
-    if (!Array.isArray(emptyAsk) || emptyAsk.length === 0)
-        return false;
-    if (!Array.isArray(newTokens) || newTokens.length === 0)
-        return false;
-    const known = new Set(emptyAsk);
-    return newTokens.every((t) => known.has(t));
-}
-export function foldEmptyAsk(emptyAsk, tokens) {
-    const existing = Array.isArray(emptyAsk) ? emptyAsk : [];
-    const merged = [...existing];
-    const present = new Set(existing);
-    for (const tok of tokens) {
-        if (present.has(tok))
-            continue;
-        present.add(tok);
-        merged.push(tok);
-    }
-    return merged.length > EMPTY_ASK_TOKEN_CAP
-        ? merged.slice(merged.length - EMPTY_ASK_TOKEN_CAP)
-        : merged;
-}
-export function commitSignature(signature, tokens) {
-    const existing = Array.isArray(signature) ? signature : [];
-    const merged = [...existing];
-    const present = new Set(existing);
-    for (const tok of tokens) {
-        if (present.has(tok))
-            continue;
-        present.add(tok);
-        merged.push(tok);
-    }
-    return merged.length > SIGNATURE_TOKEN_CAP
-        ? merged.slice(merged.length - SIGNATURE_TOKEN_CAP)
-        : merged;
-}
-export const PATH_STOPWORDS = new Set([
-    'packages', 'package', 'src', 'lib', 'libs', 'index', 'dist', 'build', 'out',
-    'node', 'modules', 'test', 'tests', 'spec', 'specs', 'mock', 'mocks',
-    'components', 'component', 'utils', 'util', 'helpers', 'helper', 'hooks',
-    'types', 'type', 'config', 'configs', 'scripts', 'script', 'app', 'apps',
-    'ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json', 'md', 'yml', 'yaml', 'css',
-    'new', 'old', 'tmp', 'temp', 'main', 'common', 'shared', 'core', 'base',
-    'file', 'files', 'data', 'docs', 'doc', 'public', 'assets', 'static',
-]);
-export function basenameTokens(filePath) {
-    const base = String(filePath).split(/[\\/]/).pop() ?? String(filePath);
-    const dot = base.lastIndexOf('.');
-    const stem = dot > 0 ? base.slice(0, dot) : base;
-    const out = [];
-    const seen = new Set();
-    for (const raw of stem.toLowerCase().split(/[^a-z0-9]+/)) {
-        if (raw.length < 3 || /^\d+$/.test(raw))
-            continue;
-        if (STOPWORDS.has(raw) || PATH_STOPWORDS.has(raw) || seen.has(raw))
-            continue;
-        seen.add(raw);
-        out.push(raw);
-    }
-    return out;
-}
-export function changeTokens(text) {
-    const out = new Set();
-    for (const raw of String(text).toLowerCase().split(/[^a-z0-9]+/)) {
-        if (raw.length < 4 || /^\d+$/.test(raw))
-            continue;
-        if (STOPWORDS.has(raw) || CODE_STOPWORDS.has(raw))
-            continue;
-        out.add(raw);
-    }
-    return out;
-}
-const CODE_STOPWORDS = new Set([
-    'const', 'let', 'var', 'function', 'return', 'import', 'export', 'from',
-    'type', 'types', 'interface', 'class', 'extends', 'implements', 'string',
-    'number', 'boolean', 'void', 'null', 'undefined', 'true', 'false', 'async',
-    'await', 'then', 'catch', 'throw', 'case', 'switch', 'break', 'continue',
-    'public', 'private', 'protected', 'readonly', 'static', 'this', 'that',
-    'with', 'when', 'where', 'which', 'while', 'each', 'into', 'over', 'they',
-    'them', 'their', 'there', 'these', 'those', 'than', 'been', 'being', 'have',
-    'has', 'had', 'does', 'done', 'will', 'would', 'could', 'should', 'must',
-]);
-export const MIN_CHANGE_OVERLAP = 3;
-export function pathTokens(filePath) {
-    const out = [];
-    const seen = new Set();
-    for (const raw of String(filePath).toLowerCase().split(/[^a-z0-9]+/)) {
-        if (raw.length < 2)
-            continue;
-        if (STOPWORDS.has(raw) || PATH_STOPWORDS.has(raw) || seen.has(raw))
-            continue;
-        seen.add(raw);
-        out.push(raw);
-    }
-    return out;
-}

package/hooks/_receipt.mjs

@@ -1,47 +0,0 @@
-const MAX_LISTED = 5;
-const TITLE_WIDTH = 72;
-export function receiptCapable(agent) {
-    return agent !== 'cursor';
-}
-function fitTitle(raw) {
-    const flat = String(raw ?? '')
-        .replace(/\s+/g, ' ')
-        .trim();
-    if (flat === '')
-        return '';
-    return flat.length > TITLE_WIDTH ? `${flat.slice(0, TITLE_WIDTH - 1)}…` : flat;
-}
-function detailRow(entry) {
-    const kind = typeof entry.kind === 'string' ? entry.kind.trim() : '';
-    const source = typeof entry.source === 'string' ? entry.source.trim() : '';
-    return [kind, source].filter(Boolean).join(' · ');
-}
-export function renderReceipt(entries, opts = {}) {
-    if (!Array.isArray(entries))
-        return null;
-    const rows = entries
-        .filter((e) => e !== null && typeof e === 'object')
-        .map((e) => ({
-        n: Number.isInteger(e.n) && e.n > 0 ? e.n : null,
-        title: fitTitle(e.title),
-        detail: detailRow(e),
-    }))
-        .filter((e) => e.title !== '');
-    if (rows.length === 0)
-        return null;
-    const noun = rows.length === 1 ? 'rule' : 'rules';
-    const head = opts.delta
-        ? `⚓ ${rows.length} new ${noun} for this turn`
-        : `⚓ ${rows.length} ${noun} from your team`;
-    const lines = [head];
-    for (const row of rows.slice(0, MAX_LISTED)) {
-        const handle = row.n === null ? '  ·' : `#${row.n}`.padStart(3);
-        lines.push(`   ${handle}  ${row.title}`);
-        if (row.detail !== '')
-            lines.push(`        ${row.detail}`);
-    }
-    const hidden = rows.length - MAX_LISTED;
-    if (hidden > 0)
-        lines.push(`   + ${hidden} more`);
-    return lines.join('\n');
-}