crewly 1.6.1 → 1.6.2

package/dist/backend/backend/src/services/memory/auto-learning.subscriber.d.ts

@@ -0,0 +1,174 @@
+/**
+ * AutoLearningSubscriber (LEARN-1)
+ *
+ * Subscribes to terminal WorkItem and mission lifecycle events on the
+ * EventBus and auto-records a learning entry via the existing
+ * {@link MemoryService.recordLearning} entrypoint. Closes the
+ * "agents-forget-to-record" gap noted in `.crewly/tmp/autonomy-doc-review-2026-04-26.md`
+ * §4 item 6 without introducing the rejected new "L-Event" type (Arch Veto V7,
+ * promoted from canonical V2 per the V-numbering map of 2026-04-27) and
+ * without expanding the 3-scope memory model into the rejected 5-scope shape
+ * (Arch Veto V9, promoted from canonical V3).
+ *
+ * Subscribed events:
+ *   - `task:verified`    → `pattern`     (a passed verification — what worked)
+ *   - `task:done`        → `pattern`     (a completion — what worked)
+ *   - `task:rejected`    → `gotcha`      (TL rejected — what didn't work)
+ *   - `task:failed`      → `gotcha`      (worker failed — what broke)
+ *   - `mission:replanned`→ `sop_update`  (strategy changed — operating practice)
+ *
+ * Idempotency contract (Arch Veto V1):
+ *   Each handler dedupe-checks `${eventType}:${workItemId}` (or
+ *   `${eventType}:${missionId}:${eventId}` for mission events) against an
+ *   in-memory bounded LRU. The underlying `recordLearning()` is append-only
+ *   (no native dedup), so the subscriber owns idempotency. The LRU is capped
+ *   at {@link DEDUP_LRU_CAPACITY} entries to bound growth across long-lived
+ *   processes.
+ *
+ * No new event types (Arch Veto V7):
+ *   The subscriber listens to event types that already exist in `EVENT_TYPES`
+ *   (added by BRIDGE-1.1). It does NOT introduce a new event class or any
+ *   `learning:*` vocabulary. The implementation-detector grep at PR time —
+ *   class/interface/type/new declarations — yields empty.
+ *
+ * No memory-scope expansion (Arch Veto V9):
+ *   `recordLearning()` is called with the existing scope model. No new
+ *   `team` / `user` scope members are added, and no `Skill`-prefixed candidate
+ *   type is introduced. The implementation-detector grep at PR time yields
+ *   empty.
+ *
+ * Fire-and-forget:
+ *   Subscribers are called synchronously by the EventBus (in-process) but
+ *   `recordLearning` itself is async; we wrap each dispatch so a thrown
+ *   error is logged without affecting other subscribers or the publisher
+ *   call site (mirrors {@link EventToWorkItemBridge.safeDispatch}).
+ *
+ * @module services/memory/auto-learning.subscriber
+ */
+import { type ComponentLogger } from '../core/logger.service.js';
+import type { IMemoryService } from './memory.service.js';
+import type { EventBusService } from '../event-bus/event-bus.service.js';
+import type { EventType } from '../../types/event-bus.types.js';
+/**
+ * Tag prefix appended to the auto-recorded learning string. This is **not**
+ * the {@link RememberCategory} enum used by the unified remember operation —
+ * `recordLearning` writes free-form text to the project learnings log
+ * (no `category` field), so this string prefix exists purely for human/grep
+ * downstream filtering. Keeping it local avoids a forced extension of
+ * `RememberCategory` (Arch Veto V9 forbids enum sprawl).
+ */
+export type AutoLearningTag = 'pattern' | 'gotcha' | 'sop_update';
+/**
+ * Event types this subscriber listens to. Order mirrors the dispatch table
+ * inside {@link AutoLearningSubscriber.start} for easy audit.
+ *
+ * **Closed-set rationale (Arch N1, 2026-04-27):** This list is deliberately
+ * *closed* — only events that mark a terminal/quasi-terminal transition with
+ * a learning-worthy outcome are members. Adding a new entry requires:
+ *   1. The event type already exists in `EVENT_TYPES` (no V7 violation).
+ *   2. A corresponding entry in {@link EVENT_CATEGORY_MAP} (otherwise the
+ *      handler defensively skips with a warn — see {@link handle}).
+ *   3. A new spec in `auto-learning.subscriber.test.ts` covering the
+ *      category mapping and dedup key shape for the new event.
+ * The closed-set property is enforced at runtime by the export-allowlist
+ * check in the V7 self-check spec — adding a member without updating the
+ * allowlist fails CI.
+ *
+ * NOTE: All five exist in `EVENT_TYPES` already (added by BRIDGE-1.1). LEARN-1
+ * adds zero new event types — Arch Veto V7 holds.
+ */
+export declare const LEARN_SUBSCRIBED_EVENTS: readonly EventType[];
+/**
+ * Stable identity used as the `agentId` on every auto-recorded learning.
+ * Distinct from any human/agent session so the project learnings log makes
+ * the system origin visible (`### [system/system:auto-learning] hh:mm:ss`).
+ */
+export declare const AUTO_LEARNING_AGENT_ID = "system:auto-learning";
+export declare const AUTO_LEARNING_AGENT_ROLE = "system";
+/**
+ * Maximum entries retained in the dedup LRU. Sized for ~hours of typical
+ * event volume; the dominant cost is map memory which is negligible at 1k.
+ */
+export declare const DEDUP_LRU_CAPACITY = 1000;
+/**
+ * Optional dependency container so tests can supply fakes for the event bus
+ * and memory service without touching singletons.
+ */
+export interface AutoLearningSubscriberDependencies {
+    /** Live event bus. */
+    eventBus: EventBusService;
+    /** Memory service that owns `recordLearning`. */
+    memoryService: IMemoryService;
+    /** Project path used for the project-learnings log. Defaults to {@link process.cwd}. */
+    projectPath?: string;
+    /** Optional logger (defaults to component logger). */
+    logger?: ComponentLogger;
+    /** Optional dedup LRU capacity override (defaults to {@link DEDUP_LRU_CAPACITY}). */
+    dedupCapacity?: number;
+}
+/**
+ * AutoLearningSubscriber — the LEARN-1 deliverable.
+ *
+ * Wired in `backend/src/index.ts` via {@link AutoLearningSubscriber.boot}; tests
+ * construct via the constructor directly with fake dependencies.
+ *
+ * @example
+ * ```typescript
+ * const subscriber = AutoLearningSubscriber.boot(eventBus);
+ * subscriber.start();
+ * // … later, on shutdown:
+ * subscriber.stop();
+ * ```
+ */
+export declare class AutoLearningSubscriber {
+    private readonly eventBus;
+    private readonly memoryService;
+    private readonly projectPath;
+    private readonly logger;
+    private readonly dedup;
+    private unsubscribers;
+    private started;
+    /**
+     * In-flight async dispatch promises. Test code calls
+     * {@link flushPending} to await every in-flight call deterministically.
+     */
+    private pendingDispatches;
+    constructor(deps: AutoLearningSubscriberDependencies);
+    /**
+     * Production wiring helper. Tests should use the constructor directly.
+     *
+     * @param eventBus - The live event bus
+     * @param projectPath - Optional override for the project-learnings target path
+     * @returns A subscriber instance ready to `start()`
+     */
+    static boot(eventBus: EventBusService, projectPath?: string): AutoLearningSubscriber;
+    /**
+     * Subscribe to all configured events. Idempotent — calling twice is a no-op.
+     */
+    start(): void;
+    /**
+     * Wait for every in-flight dispatch to settle. Test affordance.
+     */
+    flushPending(): Promise<void>;
+    /**
+     * Detach all subscriptions. Safe to call more than once.
+     */
+    stop(): void;
+    /**
+     * Snapshot of the dedup state (test affordance — production code never
+     * reads this).
+     */
+    get dedupSize(): number;
+    /**
+     * Core handler. Resolves the idempotency key, dedupes, picks the category,
+     * builds the templated summary, and calls `memoryService.recordLearning()`.
+     */
+    private handle;
+    /**
+     * Wrap a dispatch so a thrown error is logged without poisoning other
+     * subscribers or the publisher. Mirrors
+     * {@link EventToWorkItemBridge.safeDispatch}.
+     */
+    private safeDispatch;
+}
+//# sourceMappingURL=auto-learning.subscriber.d.ts.map

package/dist/backend/backend/src/services/memory/auto-learning.subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-learning.subscriber.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/memory/auto-learning.subscriber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,mCAAmC,CAAC;AAC/F,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAO5E;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,CAAC;AAMlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,SAAS,EAM9C,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAC7D,eAAO,MAAM,wBAAwB,WAAW,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAoHvC;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,sBAAsB;IACtB,QAAQ,EAAE,eAAe,CAAC;IAC1B,iDAAiD;IACjD,aAAa,EAAE,cAAc,CAAC;IAC9B,wFAAwF;IACxF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,qFAAqF;IACrF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAC/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAS;IACxB;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAiC;gBAE9C,IAAI,EAAE,kCAAkC;IASpD;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,eAAe,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,sBAAsB;IAQpF;;OAEG;IACH,KAAK,IAAI,IAAI;IAgBb;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAOnC;;OAEG;IACH,IAAI,IAAI,IAAI;IAaZ;;;OAGG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAMD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAmDZ;IAEF;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAwBrB"}

package/dist/backend/backend/src/services/memory/auto-learning.subscriber.js

@@ -0,0 +1,375 @@
+/**
+ * AutoLearningSubscriber (LEARN-1)
+ *
+ * Subscribes to terminal WorkItem and mission lifecycle events on the
+ * EventBus and auto-records a learning entry via the existing
+ * {@link MemoryService.recordLearning} entrypoint. Closes the
+ * "agents-forget-to-record" gap noted in `.crewly/tmp/autonomy-doc-review-2026-04-26.md`
+ * §4 item 6 without introducing the rejected new "L-Event" type (Arch Veto V7,
+ * promoted from canonical V2 per the V-numbering map of 2026-04-27) and
+ * without expanding the 3-scope memory model into the rejected 5-scope shape
+ * (Arch Veto V9, promoted from canonical V3).
+ *
+ * Subscribed events:
+ *   - `task:verified`    → `pattern`     (a passed verification — what worked)
+ *   - `task:done`        → `pattern`     (a completion — what worked)
+ *   - `task:rejected`    → `gotcha`      (TL rejected — what didn't work)
+ *   - `task:failed`      → `gotcha`      (worker failed — what broke)
+ *   - `mission:replanned`→ `sop_update`  (strategy changed — operating practice)
+ *
+ * Idempotency contract (Arch Veto V1):
+ *   Each handler dedupe-checks `${eventType}:${workItemId}` (or
+ *   `${eventType}:${missionId}:${eventId}` for mission events) against an
+ *   in-memory bounded LRU. The underlying `recordLearning()` is append-only
+ *   (no native dedup), so the subscriber owns idempotency. The LRU is capped
+ *   at {@link DEDUP_LRU_CAPACITY} entries to bound growth across long-lived
+ *   processes.
+ *
+ * No new event types (Arch Veto V7):
+ *   The subscriber listens to event types that already exist in `EVENT_TYPES`
+ *   (added by BRIDGE-1.1). It does NOT introduce a new event class or any
+ *   `learning:*` vocabulary. The implementation-detector grep at PR time —
+ *   class/interface/type/new declarations — yields empty.
+ *
+ * No memory-scope expansion (Arch Veto V9):
+ *   `recordLearning()` is called with the existing scope model. No new
+ *   `team` / `user` scope members are added, and no `Skill`-prefixed candidate
+ *   type is introduced. The implementation-detector grep at PR time yields
+ *   empty.
+ *
+ * Fire-and-forget:
+ *   Subscribers are called synchronously by the EventBus (in-process) but
+ *   `recordLearning` itself is async; we wrap each dispatch so a thrown
+ *   error is logged without affecting other subscribers or the publisher
+ *   call site (mirrors {@link EventToWorkItemBridge.safeDispatch}).
+ *
+ * @module services/memory/auto-learning.subscriber
+ */
+import { LoggerService } from '../core/logger.service.js';
+import { MemoryService } from './memory.service.js';
+import { formatError } from '../../utils/format-error.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * Event types this subscriber listens to. Order mirrors the dispatch table
+ * inside {@link AutoLearningSubscriber.start} for easy audit.
+ *
+ * **Closed-set rationale (Arch N1, 2026-04-27):** This list is deliberately
+ * *closed* — only events that mark a terminal/quasi-terminal transition with
+ * a learning-worthy outcome are members. Adding a new entry requires:
+ *   1. The event type already exists in `EVENT_TYPES` (no V7 violation).
+ *   2. A corresponding entry in {@link EVENT_CATEGORY_MAP} (otherwise the
+ *      handler defensively skips with a warn — see {@link handle}).
+ *   3. A new spec in `auto-learning.subscriber.test.ts` covering the
+ *      category mapping and dedup key shape for the new event.
+ * The closed-set property is enforced at runtime by the export-allowlist
+ * check in the V7 self-check spec — adding a member without updating the
+ * allowlist fails CI.
+ *
+ * NOTE: All five exist in `EVENT_TYPES` already (added by BRIDGE-1.1). LEARN-1
+ * adds zero new event types — Arch Veto V7 holds.
+ */
+export const LEARN_SUBSCRIBED_EVENTS = [
+    'task:verified',
+    'task:done',
+    'task:rejected',
+    'task:failed',
+    'mission:replanned',
+];
+/**
+ * Stable identity used as the `agentId` on every auto-recorded learning.
+ * Distinct from any human/agent session so the project learnings log makes
+ * the system origin visible (`### [system/system:auto-learning] hh:mm:ss`).
+ */
+export const AUTO_LEARNING_AGENT_ID = 'system:auto-learning';
+export const AUTO_LEARNING_AGENT_ROLE = 'system';
+/**
+ * Maximum entries retained in the dedup LRU. Sized for ~hours of typical
+ * event volume; the dominant cost is map memory which is negligible at 1k.
+ */
+export const DEDUP_LRU_CAPACITY = 1000;
+/**
+ * Mapping from event type to the {@link AutoLearningTag} the auto-recorder
+ * stamps onto the learning string. Kept as a runtime object so a missing
+ * entry yields `undefined` and the dispatcher can default rather than crash.
+ */
+const EVENT_CATEGORY_MAP = {
+    'task:verified': 'pattern',
+    'task:done': 'pattern',
+    'task:rejected': 'gotcha',
+    'task:failed': 'gotcha',
+    'mission:replanned': 'sop_update',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Bounded set with FIFO eviction. Used as a cheap LRU-ish dedup cache for the
+ * subscriber's idempotency key set. We don't strictly need recency ordering
+ * (events arrive in roughly chronological order), so FIFO is fine and avoids
+ * the per-access mutation cost of a true LRU.
+ */
+class BoundedSet {
+    capacity;
+    data = new Set();
+    constructor(capacity) {
+        if (capacity <= 0) {
+            throw new Error('BoundedSet capacity must be positive');
+        }
+        this.capacity = capacity;
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    /**
+     * Add a key; evict the oldest insertion when the set is at capacity.
+     * Returns `true` if the key was newly added, `false` if it was already
+     * present (caller-side idempotency check piggy-backs on this).
+     */
+    add(key) {
+        if (this.data.has(key))
+            return false;
+        if (this.data.size >= this.capacity) {
+            // Set iteration is insertion-ordered → first iter step yields the oldest.
+            const oldest = this.data.values().next().value;
+            if (oldest !== undefined)
+                this.data.delete(oldest);
+        }
+        this.data.add(key);
+        return true;
+    }
+    get size() {
+        return this.data.size;
+    }
+    clear() {
+        this.data.clear();
+    }
+}
+/**
+ * Build the deterministic idempotency key for an event. Task events key on
+ * `workItemId` (or `taskId` fallback) so a single WI-lifecycle transition
+ * dedupes across replays. Mission events key on `missionId:eventId` so each
+ * replan produces one learning even if the mission has many.
+ *
+ * @param event - The event being handled
+ * @returns A stable key, or null if the event doesn't carry enough identity
+ */
+function buildIdempotencyKey(event) {
+    if (event.type === 'mission:replanned') {
+        if (!event.missionId)
+            return null;
+        return `${event.type}:${event.missionId}:${event.id}`;
+    }
+    const wiKey = event.workItemId ?? event.taskId;
+    if (!wiKey)
+        return null;
+    return `${event.type}:${wiKey}`;
+}
+/**
+ * Format a templated learning summary. Includes the WorkItem id, transition
+ * (previous→new), resolver session, mission/team context, and timestamp —
+ * everything an operator skimming the learnings log needs to find the
+ * underlying WorkItem without re-running a query.
+ *
+ * Uses the `[[Entity]]` Karpathy-lite convention so the auto-recorded
+ * learnings live in the same shape as agent-recorded ones.
+ *
+ * @param event - The event being summarized
+ * @returns A single-line markdown-safe summary
+ */
+function buildLearningSummary(event) {
+    const entity = event.workItemId ?? event.taskId ?? event.missionId ?? 'unknown';
+    const entityKind = event.type.startsWith('mission:') ? 'Mission' : 'WorkItem';
+    const transition = event.previousValue && event.newValue
+        ? `${event.previousValue}→${event.newValue}`
+        : event.newValue || event.type;
+    const teamCtx = event.teamId ? ` team=${event.teamId}` : '';
+    const missionCtx = event.missionId ? ` mission=${event.missionId}` : '';
+    const resolverCtx = event.sessionName ? ` resolver=${event.sessionName}` : '';
+    return (`[[${entityKind}-${entity}]] ${event.type} ${transition}.` +
+        `${teamCtx}${missionCtx}${resolverCtx} timestamp=${event.timestamp}. Source: ${event.id}.`);
+}
+/**
+ * AutoLearningSubscriber — the LEARN-1 deliverable.
+ *
+ * Wired in `backend/src/index.ts` via {@link AutoLearningSubscriber.boot}; tests
+ * construct via the constructor directly with fake dependencies.
+ *
+ * @example
+ * ```typescript
+ * const subscriber = AutoLearningSubscriber.boot(eventBus);
+ * subscriber.start();
+ * // … later, on shutdown:
+ * subscriber.stop();
+ * ```
+ */
+export class AutoLearningSubscriber {
+    eventBus;
+    memoryService;
+    projectPath;
+    logger;
+    dedup;
+    unsubscribers = [];
+    started = false;
+    /**
+     * In-flight async dispatch promises. Test code calls
+     * {@link flushPending} to await every in-flight call deterministically.
+     */
+    pendingDispatches = new Set();
+    constructor(deps) {
+        this.eventBus = deps.eventBus;
+        this.memoryService = deps.memoryService;
+        this.projectPath = deps.projectPath ?? process.cwd();
+        this.logger =
+            deps.logger ?? LoggerService.getInstance().createComponentLogger('AutoLearningSubscriber');
+        this.dedup = new BoundedSet(deps.dedupCapacity ?? DEDUP_LRU_CAPACITY);
+    }
+    /**
+     * Production wiring helper. Tests should use the constructor directly.
+     *
+     * @param eventBus - The live event bus
+     * @param projectPath - Optional override for the project-learnings target path
+     * @returns A subscriber instance ready to `start()`
+     */
+    static boot(eventBus, projectPath) {
+        return new AutoLearningSubscriber({
+            eventBus,
+            memoryService: MemoryService.getInstance(),
+            projectPath,
+        });
+    }
+    /**
+     * Subscribe to all configured events. Idempotent — calling twice is a no-op.
+     */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        for (const eventType of LEARN_SUBSCRIBED_EVENTS) {
+            this.unsubscribers.push(this.eventBus.onInProcess(eventType, (e) => this.safeDispatch(eventType, e)));
+        }
+        this.logger.info('AutoLearningSubscriber subscribed', {
+            eventTypes: LEARN_SUBSCRIBED_EVENTS,
+            projectPath: this.projectPath,
+        });
+    }
+    /**
+     * Wait for every in-flight dispatch to settle. Test affordance.
+     */
+    async flushPending() {
+        while (this.pendingDispatches.size > 0) {
+            const inFlight = Array.from(this.pendingDispatches);
+            await Promise.allSettled(inFlight);
+        }
+    }
+    /**
+     * Detach all subscriptions. Safe to call more than once.
+     */
+    stop() {
+        for (const unsubscribe of this.unsubscribers) {
+            try {
+                unsubscribe();
+            }
+            catch (err) {
+                this.logger.warn('AutoLearning unsubscribe threw', { error: formatError(err) });
+            }
+        }
+        this.unsubscribers = [];
+        this.started = false;
+        this.logger.info('AutoLearningSubscriber stopped');
+    }
+    /**
+     * Snapshot of the dedup state (test affordance — production code never
+     * reads this).
+     */
+    get dedupSize() {
+        return this.dedup.size;
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    /**
+     * Core handler. Resolves the idempotency key, dedupes, picks the category,
+     * builds the templated summary, and calls `memoryService.recordLearning()`.
+     */
+    handle = async (eventType, event) => {
+        const key = buildIdempotencyKey(event);
+        if (!key) {
+            this.logger.debug('AutoLearning skipping event without identifying key', {
+                eventType,
+                eventId: event.id,
+            });
+            return;
+        }
+        // Pre-add the dedup key BEFORE awaiting recordLearning. Tradeoff (Arch N2,
+        // 2026-04-27): a recordLearning failure leaves the key claimed, so a
+        // subsequent retry of the same event is suppressed — we lose one
+        // learning entry. The alternative — add-on-success — opens a TOCTOU race
+        // where two near-simultaneous deliveries of the same event each pass the
+        // .has() check and produce a duplicate. We pick "lose-one-on-failure"
+        // because (a) recordLearning is best-effort and append-only by design,
+        // (b) the BRIDGE-1.4 V1 contract similarly favours dedup-correctness over
+        // delivery-completeness, and (c) the loss is logged at error level so an
+        // operator can manually re-record if needed.
+        if (!this.dedup.add(key)) {
+            this.logger.debug('AutoLearning dedup hit — skipping replay', { key, eventId: event.id });
+            return;
+        }
+        const category = EVENT_CATEGORY_MAP[eventType];
+        if (!category) {
+            // Defensive: an unknown event slipped past the subscription filter.
+            // Skip rather than recording a category-less learning.
+            this.logger.warn('AutoLearning got unmapped event — skipping', { eventType });
+            return;
+        }
+        const summary = buildLearningSummary(event);
+        const relatedTask = event.workItemId ?? event.taskId;
+        await this.memoryService.recordLearning({
+            agentId: AUTO_LEARNING_AGENT_ID,
+            agentRole: AUTO_LEARNING_AGENT_ROLE,
+            projectPath: this.projectPath,
+            // Prefix the learning with category so downstream readers (and grep
+            // audits) can filter without parsing the structured metadata.
+            learning: `[${category}] ${summary}`,
+            relatedTask,
+        });
+        this.logger.info('AutoLearning recorded', {
+            eventType,
+            category,
+            key,
+            relatedTask,
+        });
+    };
+    /**
+     * Wrap a dispatch so a thrown error is logged without poisoning other
+     * subscribers or the publisher. Mirrors
+     * {@link EventToWorkItemBridge.safeDispatch}.
+     */
+    safeDispatch(eventType, event) {
+        const dispatch = (async () => {
+            try {
+                await this.handle(eventType, event);
+            }
+            catch (err) {
+                this.logger.error('AutoLearning handler threw', {
+                    eventType,
+                    eventId: event.id,
+                    error: formatError(err),
+                });
+            }
+        })();
+        this.pendingDispatches.add(dispatch);
+        dispatch
+            .finally(() => {
+            this.pendingDispatches.delete(dispatch);
+        })
+            .catch(() => {
+            // Suppress unhandled-rejection warning — flushPending callers see
+            // the outcome via Promise.allSettled, and the logger.error has
+            // already recorded the throw.
+        });
+        return dispatch;
+    }
+}
+//# sourceMappingURL=auto-learning.subscriber.js.map

package/dist/backend/backend/src/services/memory/auto-learning.subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-learning.subscriber.js","sourceRoot":"","sources":["../../../../../../backend/src/services/memory/auto-learning.subscriber.ts"],"names":[],"mappings":"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"}

package/dist/backend/backend/src/services/memory/learning-format.validator.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Learning format validator (Karpathy-lite / Entity-Centric)
+ *
+ * Implements the 4-rule preflight defined by ARCHIVIST-V2.f1
+ * (`.crewly/tasks/autonomy_v1/follow-up/archivist-v2-record-learning-preflight.md`).
+ *
+ * Rules:
+ *   1. Entity opener — text MUST start with `[[Entity Name]]` (one bracketed token).
+ *   2. Sentence count — 1..3 sentences (split on `[.!?]+\s+`, filter empties).
+ *   3. Linked or sourced — at minimum one of:
+ *        - a second `[[Entity]]` link, OR
+ *        - a `PR #...`, `Task #...`, `Issue #...`, `#NNN`, `Ref:`, `See:`, `Log:` source citation.
+ *   4. No log-style anti-pattern — soft check: warn (don't reject) if text begins
+ *      with a personal pronoun ("I fixed", "I tried", "We added", etc.).
+ *
+ * Default mode (`strict: false`):
+ *   - Rule 1 → hard error (the entity opener is the joinability hook for
+ *     Archivist v2 cross-doc synthesis; without it the learning has no anchor).
+ *   - Rules 2..4 → soft warnings (accept the learning, surface the violation).
+ *
+ * Strict mode (`strict: true`):
+ *   - All 4 rules emit hard errors. Used by CI / Archivist v2 callers that
+ *     enforce full conformance.
+ *
+ * Lax-by-controller policy (v1.5 / convention-only):
+ *   The controller wiring is deferred. The validator is shipped as a
+ *   reusable utility so callers (CLI, tests, future Archivist v2 synthesizer,
+ *   future controller integration) can opt into enforcement as needed.
+ *   See `archivist-v2-record-learning-preflight.md` § Validator behavior and
+ *   the orc note ("Convention-only enforcement is OK in v1.5").
+ *
+ * @module services/memory/learning-format.validator
+ */
+/** A single rule violation produced by {@link validateLearningFormat}. */
+export interface LearningValidationIssue {
+    /** Numeric rule id (1..4) */
+    rule: 1 | 2 | 3 | 4;
+    /** Stable machine-readable rule name */
+    ruleName: 'entity_opener' | 'sentence_count' | 'linked_or_sourced' | 'no_log_style';
+    /** Human-readable description of the violation */
+    message: string;
+    /** Optional suggested fix (entity opener / shortening / link insertion) */
+    suggestion?: string;
+    /** Pointer to the SKILL.md mandate section */
+    skillRef: string;
+}
+/** Result returned by {@link validateLearningFormat}. */
+export interface LearningValidationResult {
+    /** True when no errors (warnings are not failure). */
+    pass: boolean;
+    /** Hard violations — caller MUST reject when `pass === false`. */
+    errors: LearningValidationIssue[];
+    /** Soft violations — caller SHOULD log/surface but MAY accept. */
+    warnings: LearningValidationIssue[];
+}
+/** Options for {@link validateLearningFormat}. */
+export interface LearningValidationOptions {
+    /**
+     * When true, escalate all soft warnings (rules 2..4) to hard errors.
+     * Rule 1 is always a hard error regardless of this flag.
+     * @default false
+     */
+    strict?: boolean;
+}
+/**
+ * Validate a learning text against the Karpathy-lite format rules.
+ *
+ * @param rawText - The learning text submitted to `record-learning`.
+ * @param options - Validator options ({@link LearningValidationOptions}).
+ * @returns A {@link LearningValidationResult} with errors and warnings split.
+ *
+ * @example
+ * ```typescript
+ * const result = validateLearningFormat('I fixed the bug today', { strict: false });
+ * // → { pass: false, errors: [<rule 1>], warnings: [<rule 3>, <rule 4>] }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const result = validateLearningFormat(
+ *   '[[Fts5IndexService]] FTS5 rank is negative; invert. PR #320',
+ *   { strict: true }
+ * );
+ * // → { pass: true, errors: [], warnings: [] }
+ * ```
+ */
+export declare function validateLearningFormat(rawText: string, options?: LearningValidationOptions): LearningValidationResult;
+/**
+ * Format a {@link LearningValidationIssue} as a multi-line string suitable
+ * for stderr / log output. Includes the offending text snippet and SKILL ref.
+ *
+ * @param issue - The issue to format.
+ * @param rawText - The full learning text (for snippet context).
+ * @returns A multi-line formatted string.
+ */
+export declare function formatValidationMessage(issue: LearningValidationIssue, rawText: string): string;
+//# sourceMappingURL=learning-format.validator.d.ts.map

package/dist/backend/backend/src/services/memory/learning-format.validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-format.validator.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/memory/learning-format.validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACvC,6BAA6B;IAC7B,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,wCAAwC;IACxC,QAAQ,EAAE,eAAe,GAAG,gBAAgB,GAAG,mBAAmB,GAAG,cAAc,CAAC;IACpF,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,yDAAyD;AACzD,MAAM,WAAW,wBAAwB;IACxC,sDAAsD;IACtD,IAAI,EAAE,OAAO,CAAC;IACd,kEAAkE;IAClE,MAAM,EAAE,uBAAuB,EAAE,CAAC;IAClC,kEAAkE;IAClE,QAAQ,EAAE,uBAAuB,EAAE,CAAC;CACpC;AAED,kDAAkD;AAClD,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAwBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,yBAA8B,GACrC,wBAAwB,CAyE1B;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,MAAM,GACb,MAAM,CAWR"}