@theihtisham/agent-shadow-brain 7.2.0 → 7.22.1

package/dist/dashboard/live-workspace-html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-workspace-html.js","sourceRoot":"","sources":["../../src/dashboard/live-workspace-html.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+gCrC,CAAC"}

package/dist/dashboard/managed-project-skills-api.d.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage } from 'node:http';
+export declare function isManagedSkillsRoute(route: string): boolean;
+export declare function managedSkillsRequest(req: IncomingMessage, route: string, root: string, body: () => Promise<Record<string, unknown>>): Promise<{
+    projectId: string;
+    skills: import("../brain/managed-project-skills.js").ManagedSkill[];
+    invalidReceipts: number;
+} | {
+    projectId: string;
+    skill: import("../brain/managed-project-skills.js").ManagedSkill;
+    action: import("../brain/managed-project-skills.js").ManagedSkillAction;
+    planHash: string;
+    exactPaths: string[];
+    expectedHashes: {
+        receipt: string;
+        installed: string | null;
+        disabled: string | null;
+    };
+    conflicts: string[];
+    effects: string[];
+    hostRefreshNote: string;
+} | {
+    projectId: string;
+    id: string;
+    finalState: string;
+    changedPaths: string[];
+    preservedPaths: string[];
+    hostRefreshNote: string;
+}>;
+//# sourceMappingURL=managed-project-skills-api.d.ts.map

package/dist/dashboard/managed-project-skills-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-project-skills-api.d.ts","sourceRoot":"","sources":["../../src/dashboard/managed-project-skills-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAA8E;AAE1I,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;GAmBzI"}

package/dist/dashboard/managed-project-skills-api.js

@@ -0,0 +1,28 @@
+import { applyManagedProjectSkill, listManagedProjectSkills, ManagedSkillError, previewManagedProjectSkill } from '../brain/managed-project-skills.js';
+import { ProjectKitError } from '../brain/project-kit-paths.js';
+export function isManagedSkillsRoute(route) { return route === 'managed-skills' || route.startsWith('managed-skills/'); }
+export async function managedSkillsRequest(req, route, root, body) {
+    try {
+        if (req.method === 'GET' && route === 'managed-skills')
+            return listManagedProjectSkills(root);
+        if (req.method !== 'POST' || (route !== 'managed-skills/preview' && route !== 'managed-skills/apply')) {
+            throw new ManagedSkillError('MANAGED_SKILL_ROUTE', 'Use GET for inventory and POST for preview or apply.', 405);
+        }
+        const origin = req.headers.origin;
+        if ((origin && origin !== 'http://' + req.headers.host && origin !== 'https://' + req.headers.host) || req.headers['sec-fetch-site'] === 'cross-site') {
+            throw new ManagedSkillError('MANAGED_SKILL_ORIGIN', 'Cross-origin changes are not accepted.', 403);
+        }
+        const input = await body();
+        return route.endsWith('/preview') ? previewManagedProjectSkill(root, input) : applyManagedProjectSkill(root, input);
+    }
+    catch (error) {
+        if (error instanceof ManagedSkillError || error instanceof TypeError || error instanceof RangeError)
+            throw error;
+        if (error instanceof ProjectKitError)
+            throw new ManagedSkillError(error.code, error.message, error.code === 'PROJECT_KIT_WRITE_FAILED' ? 503 : 409);
+        if (error.code === 'EEXIST')
+            throw new ManagedSkillError('MANAGED_SKILL_CONFLICT', 'A managed destination appeared during application. Refresh and review it.', 409);
+        throw new ManagedSkillError('MANAGED_SKILL_STORAGE', 'Managed skill storage could not be opened. Review the current paths and try again.', 503);
+    }
+}
+//# sourceMappingURL=managed-project-skills-api.js.map

package/dist/dashboard/managed-project-skills-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-project-skills-api.js","sourceRoot":"","sources":["../../src/dashboard/managed-project-skills-api.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AACvJ,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,MAAM,UAAU,oBAAoB,CAAC,KAAa,IAAa,OAAO,KAAK,KAAK,gBAAgB,IAAI,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAE1I,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,GAAoB,EAAE,KAAa,EAAE,IAAY,EAAE,IAA4C;IACxI,IAAI,CAAC;QACH,IAAI,GAAG,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK,gBAAgB;YAAE,OAAO,wBAAwB,CAAC,IAAI,CAAC,CAAC;QAC9F,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,KAAK,KAAK,wBAAwB,IAAI,KAAK,KAAK,sBAAsB,CAAC,EAAE,CAAC;YACtG,MAAM,IAAI,iBAAiB,CAAC,qBAAqB,EAAE,sDAAsD,EAAE,GAAG,CAAC,CAAC;QAClH,CAAC;QACD,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;QAClC,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,MAAM,KAAK,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,YAAY,EAAE,CAAC;YACtJ,MAAM,IAAI,iBAAiB,CAAC,sBAAsB,EAAE,wCAAwC,EAAE,GAAG,CAAC,CAAC;QACrG,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,iBAAiB,IAAI,KAAK,YAAY,SAAS,IAAI,KAAK,YAAY,UAAU;YAAE,MAAM,KAAK,CAAC;QACjH,IAAI,KAAK,YAAY,eAAe;YAAE,MAAM,IAAI,iBAAiB,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EACzF,KAAK,CAAC,IAAI,KAAK,0BAA0B,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACzD,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;YAAE,MAAM,IAAI,iBAAiB,CAAC,wBAAwB,EAAE,2EAA2E,EAAE,GAAG,CAAC,CAAC;QAChM,MAAM,IAAI,iBAAiB,CAAC,uBAAuB,EAAE,oFAAoF,EAAE,GAAG,CAAC,CAAC;IAClJ,CAAC;AACH,CAAC"}

package/dist/dashboard/native-codex-api.d.ts

@@ -0,0 +1,83 @@
+import type { IncomingMessage } from 'node:http';
+import type { GlobalBrain } from '../brain/global-brain.js';
+import { type NativeCodexFactory } from '../brain/native-codex.js';
+export declare function isNativeCodexRoute(route: string): boolean;
+export declare function createNativeCodexApi(factory?: NativeCodexFactory): {
+    request: (req: IncomingMessage, route: string, url: URL, directory: string, brain: GlobalBrain, readBody: () => Promise<Record<string, unknown>>) => Promise<{
+        connected: boolean;
+        connectedAt: string | null;
+        expiresAt: string | null;
+        scope: string;
+        note: string;
+    } | {
+        connected: boolean;
+        observedAt: string;
+        threads: import("../brain/native-codex.js").NativeCodexThread[];
+        nextCursor: string | null;
+    } | {
+        thread: import("../brain/native-codex.js").NativeCodexThread;
+        messages: import("../brain/native-codex.js").NativeCodexMessage[];
+        omitted: number;
+        nextCursor: string | null;
+        pageCoverage: {
+            kind: "page";
+            direction: "newest-first";
+            hasEarlier: boolean;
+            hasLater: boolean;
+            cursorSha256: string | null;
+            omittedInPage: number;
+        };
+        sha256: string;
+        observedAt: string;
+    } | {
+        nextCursor: string | null;
+        partial: boolean;
+        projectId: string;
+        session: import("../brain/project-session-contract.js").SessionSummary;
+        messages: import("../brain/project-session-contract.js").SessionMessage[];
+        messageCount: number;
+        nextBefore: string | null;
+        checkpoints: any[];
+        handoff: import("../brain/project-session-contract.js").SessionCheckpoint | null;
+    }>;
+    close(directory: string): void;
+};
+export declare const nativeCodexRequest: (req: IncomingMessage, route: string, url: URL, directory: string, brain: GlobalBrain, readBody: () => Promise<Record<string, unknown>>) => Promise<{
+    connected: boolean;
+    connectedAt: string | null;
+    expiresAt: string | null;
+    scope: string;
+    note: string;
+} | {
+    connected: boolean;
+    observedAt: string;
+    threads: import("../brain/native-codex.js").NativeCodexThread[];
+    nextCursor: string | null;
+} | {
+    thread: import("../brain/native-codex.js").NativeCodexThread;
+    messages: import("../brain/native-codex.js").NativeCodexMessage[];
+    omitted: number;
+    nextCursor: string | null;
+    pageCoverage: {
+        kind: "page";
+        direction: "newest-first";
+        hasEarlier: boolean;
+        hasLater: boolean;
+        cursorSha256: string | null;
+        omittedInPage: number;
+    };
+    sha256: string;
+    observedAt: string;
+} | {
+    nextCursor: string | null;
+    partial: boolean;
+    projectId: string;
+    session: import("../brain/project-session-contract.js").SessionSummary;
+    messages: import("../brain/project-session-contract.js").SessionMessage[];
+    messageCount: number;
+    nextBefore: string | null;
+    checkpoints: any[];
+    handoff: import("../brain/project-session-contract.js").SessionCheckpoint | null;
+}>;
+export declare const closeNativeCodex: (directory: string) => void;
+//# sourceMappingURL=native-codex-api.d.ts.map

package/dist/dashboard/native-codex-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-codex-api.d.ts","sourceRoot":"","sources":["../../src/dashboard/native-codex-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAA2C,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG5G,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAA8E;AACxI,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE,kBAAkB;mBAkBnC,eAAe,SAAS,MAAM,OAAO,GAAG,aAAa,MAAM,SAAS,WAAW,YAAY,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2B1H,MAAM;EAU1C;AAED,eAAO,MAAM,kBAAkB,QAvCD,eAAe,SAAS,MAAM,OAAO,GAAG,aAAa,MAAM,SAAS,WAAW,YAAY,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuClH,CAAC;AAC9C,eAAO,MAAM,gBAAgB,cAbQ,MAAM,SAaF,CAAC"}

package/dist/dashboard/native-codex-api.js

@@ -0,0 +1,91 @@
+import * as path from 'node:path';
+import { requireProjectStore } from '../brain/project-memory.js';
+import { projectRoot } from '../brain/project-kit-paths.js';
+import { NativeCodexConnection, NativeCodexError } from '../brain/native-codex.js';
+import { ProjectSessions } from '../brain/project-sessions.js';
+export function isNativeCodexRoute(route) { return route === 'sessions/codex' || route.startsWith('sessions/codex/'); }
+export function createNativeCodexApi(factory) {
+    const connections = new Map();
+    // Remember only spellings already validated for this project. This also permits
+    // shutdown after a project directory has been removed, without guessing paths.
+    const aliases = new Map();
+    const pathKey = (value) => {
+        const resolved = path.resolve(value);
+        return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    };
+    function service(directory, brain) {
+        const local = requireProjectStore(directory, brain);
+        const key = pathKey(local.root);
+        let connection = connections.get(key);
+        if (!connection) {
+            connection = new NativeCodexConnection(local.root, factory);
+            connections.set(key, connection);
+        }
+        aliases.set(key, key);
+        aliases.set(pathKey(directory), key);
+        return { local, connection };
+    }
+    async function request(req, route, url, directory, brain, readBody) {
+        if ((req.headers.origin && req.headers.origin !== 'http://' + req.headers.host && req.headers.origin !== 'https://' + req.headers.host) || req.headers['sec-fetch-site'] === 'cross-site')
+            throw new NativeCodexError('CODEX_ORIGIN', 'Cross-origin connector requests are not accepted.', 403);
+        const { local, connection } = service(directory, brain);
+        const fail = () => { throw new NativeCodexError('CODEX_ROUTE', 'Unsupported Codex connector request.', 404); };
+        const match = /^sessions\/codex\/threads\/([A-Za-z0-9_-]{1,128})(?:\/(import))?$/u.exec(route);
+        if (req.method === 'GET') {
+            if (route === 'sessions/codex/status')
+                return connection.status();
+            if (route === 'sessions/codex/threads') {
+                const archived = url.searchParams.get('archived') ?? 'false';
+                if (!['true', 'false'].includes(archived))
+                    throw new NativeCodexError('CODEX_INVALID', 'Choose current or archived threads.');
+                return connection.list(archived === 'true', url.searchParams.get('cursor'));
+            }
+            if (match && !match[2])
+                return connection.read(match[1], url.searchParams.get('cursor'));
+            return fail();
+        }
+        if (req.method !== 'POST')
+            return fail();
+        const body = await readBody();
+        if (route === 'sessions/codex/connect') {
+            if (Object.keys(body).length)
+                throw new NativeCodexError('CODEX_INVALID', 'Connect accepts no arguments.');
+            return connection.connect();
+        }
+        if (route === 'sessions/codex/disconnect') {
+            if (Object.keys(body).length)
+                throw new NativeCodexError('CODEX_INVALID', 'Disconnect accepts no arguments.');
+            connection.close();
+            return connection.status();
+        }
+        if (match?.[2] === 'import') {
+            if (Object.keys(body).some(key => !['key', 'cursor', 'sha256'].includes(key)) || typeof body.key !== 'string' || !/^[A-Za-z0-9_-]{12,100}$/u.test(body.key) || typeof body.sha256 !== 'string' || !/^[0-9a-f]{64}$/u.test(body.sha256) || (body.cursor !== undefined && typeof body.cursor !== 'string'))
+                throw new NativeCodexError('CODEX_INVALID', 'Use the reviewed page fingerprint, an operation key and an optional page cursor.');
+            const { snapshot, nextCursor } = await connection.snapshot(match[1], body.cursor ?? null);
+            if (snapshot.sha256 !== body.sha256)
+                throw new NativeCodexError('CODEX_PAGE_CHANGED', 'This conversation page changed. Review it again before importing.', 409);
+            return { ...new ProjectSessions(local.root, brain).importNative(snapshot, body.key), nextCursor, partial: !!nextCursor || !!body.cursor || snapshot.omitted > 0 };
+        }
+        return fail();
+    }
+    return { request, close(directory) {
+            let key = aliases.get(pathKey(directory));
+            if (!key) {
+                try {
+                    key = aliases.get(pathKey(projectRoot(directory)));
+                }
+                catch { /* An unknown or removed path cannot be resolved safely. */ }
+            }
+            if (!key)
+                return;
+            connections.get(key)?.close();
+            connections.delete(key);
+            for (const [alias, target] of aliases)
+                if (target === key)
+                    aliases.delete(alias);
+        } };
+}
+const api = createNativeCodexApi();
+export const nativeCodexRequest = api.request;
+export const closeNativeCodex = api.close;
+//# sourceMappingURL=native-codex-api.js.map

package/dist/dashboard/native-codex-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-codex-api.js","sourceRoot":"","sources":["../../src/dashboard/native-codex-api.ts"],"names":[],"mappings":"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"}

package/dist/dashboard/project-feedback-html.d.ts

@@ -0,0 +1,5 @@
+/** Project-local task outcomes share the workspace memory browser and API helpers. */
+export declare const PROJECT_FEEDBACK_STYLE: string;
+export declare const PROJECT_FEEDBACK_MARKUP: string;
+export declare const PROJECT_FEEDBACK_SCRIPT: string;
+//# sourceMappingURL=project-feedback-html.d.ts.map

package/dist/dashboard/project-feedback-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-feedback-html.d.ts","sourceRoot":"","sources":["../../src/dashboard/project-feedback-html.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,eAAO,MAAM,sBAAsB,QAkBlC,CAAC;AAEF,eAAO,MAAM,uBAAuB,QA6BnC,CAAC;AAEF,eAAO,MAAM,uBAAuB,QAoKnC,CAAC"}

package/dist/dashboard/project-feedback-html.js

@@ -0,0 +1,216 @@
+/** Project-local task outcomes share the workspace memory browser and API helpers. */
+export const PROJECT_FEEDBACK_STYLE = String.raw `
+  .kit-outcomes { scroll-margin-top: 56px; }
+  .outcomes-layout { display: grid; grid-template-columns: minmax(280px,.9fr) minmax(0,1.1fr); align-items: start; }
+  .outcome-editor { display: grid; gap: 10px; }
+  .outcome-history { border-left: 1px solid var(--line); min-width: 0; }
+  .outcome-history .panel-head { background: var(--inset); }
+  .outcome-list { max-height: 560px; overflow: auto; }
+  .outcome-row { display: grid; gap: 7px; padding: 11px 15px; }
+  .outcome-row h4 { margin: 0; font-size: .93rem; overflow-wrap: anywhere; }
+  .outcome-row .button { min-height: 32px; }
+  .outcome-search { display: grid; grid-template-columns: minmax(0,1fr) auto; align-items: end; gap: 6px; }
+  .outcome-reason { white-space: pre-wrap; }
+  .kit-identity .kit-outcomes-jump { margin-top: 8px; color: var(--signal); }
+  .kit-identity .kit-outcomes-jump:hover { background: #254350; }
+  @media (max-width: 985px) {
+    .outcomes-layout { grid-template-columns: minmax(0,1fr); }
+    .outcome-history { border-left: 0; border-top: 1px solid var(--line); }
+  }
+`;
+export const PROJECT_FEEDBACK_MARKUP = String.raw `
+          <section class="panel kit-outcomes" aria-labelledby="kit-outcomes-heading" id="kit-outcomes">
+            <div class="panel-head">
+              <div><h2 id="kit-outcomes-heading" tabindex="-1">Memory outcomes</h2><p class="small muted" id="kit-outcomes-policy">Adaptive retrieval can use reported outcomes when a future task matches.</p></div>
+              <button class="button switch" type="button" role="switch" id="kit-feedback-enable" aria-checked="false" aria-label="Use task outcomes in Adaptive retrieval" aria-describedby="kit-outcomes-policy" disabled><span id="kit-feedback-enabled-label" aria-hidden="true">Loading</span><span class="switch-track" aria-hidden="true"></span></button>
+            </div>
+            <div class="outcomes-layout">
+              <div class="panel-body outcome-editor">
+                <form id="kit-outcome-search-form" class="outcome-search" role="search" aria-label="Find a memory to rate">
+                  <label class="label" for="kit-outcome-query">Find project memory<input type="search" maxlength="500" id="kit-outcome-query" placeholder="Search by title or keyword"></label>
+                  <button class="button" id="kit-outcome-search" type="submit"><span data-icon="search"></span>Find</button>
+                </form>
+                <p class="small muted" id="kit-outcome-memory-status" role="status"></p>
+                <form id="kit-outcome-form" class="kit-form">
+                  <label class="label" for="kit-outcome-memory">Memory<select id="kit-outcome-memory" required><option value="">Choose a memory</option></select></label>
+                  <label class="label" for="kit-outcome-task">Task<textarea id="kit-outcome-task" rows="2" maxlength="1000" required placeholder="What were you working on?"></textarea></label>
+                  <label class="label" for="kit-outcome-rating">Outcome<select id="kit-outcome-rating" required><option value="">Choose an outcome</option><option value="useful">Useful</option><option value="not-useful">Not useful</option><option value="incorrect">Incorrect</option></select></label>
+                  <label class="label" for="kit-outcome-reason">Reason<textarea id="kit-outcome-reason" rows="3" maxlength="600" required placeholder="How did this memory affect the task?"></textarea></label>
+                  <label class="label" for="kit-outcome-evidence">Recorded references <span class="small muted">Optional. Up to 3, one per line.</span><textarea id="kit-outcome-evidence" rows="2" maxlength="542" placeholder="tests/checkout-retry.test.ts"></textarea></label>
+                  <button class="button primary" id="kit-outcome-save" type="submit" disabled>Save reported outcome</button>
+                  <div id="kit-outcome-status" class="kit-form-status" role="status"></div>
+                </form>
+              </div>
+              <div class="outcome-history">
+                <div class="panel-head"><h3>Reported outcomes</h3><span class="small muted" id="kit-outcome-count"></span></div>
+                <div id="kit-outcome-records" aria-busy="true"></div>
+              </div>
+            </div>
+          </section>
+`;
+export const PROJECT_FEEDBACK_SCRIPT = String.raw `
+const outcomes = { snapshot: null, saving: false, loading: false, memories: [], memoryRequest: 0, project: '' };
+const outcomeRatings = { useful: ['ok', 'Useful'], 'not-useful': ['warn', 'Not useful'], incorrect: ['error', 'Incorrect'] };
+
+function syncOutcomeControls() {
+  const current = outcomes.snapshot;
+  const toggle = $('kit-feedback-enable');
+  toggle.disabled = !current || outcomes.saving;
+  toggle.setAttribute('aria-checked', String(current?.enabled === true));
+  $('kit-feedback-enabled-label').textContent = !current ? 'Unavailable' : current.enabled ? 'On' : 'Off';
+  $('kit-outcome-save').disabled = !current || outcomes.saving || !$('kit-outcome-memory').value;
+  $('kit-outcomes-policy').textContent = current?.enabled === false ?
+    'Learning is off. Reports remain available for review.' : 'Adaptive retrieval can use reported outcomes when a future task matches.';
+  $('kit-outcome-records').querySelectorAll('[data-outcome-remove]').forEach((button) => { button.disabled = outcomes.saving || !current; });
+}
+
+function renderOutcomeHistory() {
+  const current = outcomes.snapshot;
+  const target = $('kit-outcome-records');
+  if (!current) return;
+  const records = [...list(current.records)].sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+  $('kit-outcome-count').textContent = countLabel(records.length, 'report');
+  const titles = new Map(outcomes.memories.map((memory) => [memory.id, memory.title]));
+  target.innerHTML = records.length ? '<ul class="list outcome-list" aria-label="Task outcomes">' + records.map((record) => {
+    const [tone, label] = Object.hasOwn(outcomeRatings, record.rating) ? outcomeRatings[record.rating] : ['', 'Reported'];
+    return '<li class="outcome-row"><h4>' + esc(record.task) + '</h4><div class="form-actions">' +
+      tags([['check-' + tone, label], ['memory', record.reporter === 'agent' ? 'Agent report' : 'User report']]) + dateMarkup(record.updatedAt, true) + '</div>' +
+      '<p class="small outcome-reason">' + esc(record.reason) + '</p>' + sourceMarkup(record.evidence) + '<div class="form-actions">' +
+      memoryLink(record.memoryId, record.projectId, titles.get(record.memoryId) || 'Open rated memory') +
+      '<button type="button" class="button quiet" data-outcome-remove="' + esc(record.id) + '">Remove report</button></div></li>';
+  }).join('') + '</ul>' : blank('activity', 'No task outcomes yet', 'Record whether a project memory helped with a specific task.');
+  syncOutcomeControls();
+}
+
+async function loadProjectFeedback() {
+  if (outcomes.loading || outcomes.saving || state.projectKit?.available !== true) return;
+  const target = $('kit-outcome-records');
+  outcomes.loading = true;
+  setBusy(target, true);
+  if (!outcomes.snapshot) target.innerHTML = skeleton('Reading reported outcomes…');
+  try {
+    const snapshot = await api('project-feedback');
+    if (!Number.isSafeInteger(snapshot.revision) || typeof snapshot.enabled !== 'boolean' || !Array.isArray(snapshot.records)) {
+      throw new Error('The server returned unreadable task outcomes.');
+    }
+    if (!outcomes.snapshot || snapshot.revision >= outcomes.snapshot.revision) outcomes.snapshot = snapshot;
+    renderOutcomeHistory();
+  } catch (error) {
+    outcomes.snapshot = null;
+    target.innerHTML = errorMarkup(error.message, 'kit-feedback');
+    $('kit-outcome-count').textContent = '';
+  } finally {
+    outcomes.loading = false;
+    setBusy(target, false);
+    syncOutcomeControls();
+  }
+}
+
+async function loadFeedbackMemories(focusMemory = '') {
+  const info = state.projectKit;
+  if (info?.available !== true) return;
+  const request = ++outcomes.memoryRequest;
+  const select = $('kit-outcome-memory');
+  const status = $('kit-outcome-memory-status');
+  const search = $('kit-outcome-search');
+  const q = $('kit-outcome-query').value.trim();
+  const selected = focusMemory || select.value;
+  status.textContent = 'Finding project memories…';
+  search.disabled = true;
+  try {
+    const result = await api(queryPath('memories', { project: info.projectId, q, limit: 25 }));
+    if (request !== outcomes.memoryRequest) return;
+    const memories = list(result.items).filter((item) => item.project === info.projectId);
+    if (focusMemory && !memories.some((item) => item.id === focusMemory)) {
+      try {
+        const detail = await api(queryPath('memory', { project: info.projectId, id: focusMemory }));
+        if (detail.memory?.project === info.projectId) memories.unshift(detail.memory);
+      } catch { /* The selected memory may no longer be available. */ }
+    }
+    if (request !== outcomes.memoryRequest) return;
+    outcomes.memories = memories;
+    outcomes.project = info.projectId;
+    optionSet('kit-outcome-memory', 'Choose a memory', memories.map((item) => ({ id: item.id, name: item.title || item.id })), selected);
+    status.textContent = memories.length ? countLabel(memories.length, 'memory', 'memories') + ' shown. Search to narrow the list.' :
+      q ? 'No memories matched this search.' : 'Save project knowledge to record a task outcome.';
+    if (focusMemory && !select.value) status.textContent = 'The requested memory is unavailable in this project.';
+    renderOutcomeHistory();
+  } catch (error) {
+    if (request === outcomes.memoryRequest) status.textContent = error.message;
+  } finally {
+    if (request === outcomes.memoryRequest) {
+      search.disabled = false;
+      syncOutcomeControls();
+    }
+  }
+}
+
+function openOutcomeEditor() {
+  $('kit-outcomes-heading').focus();
+}
+
+async function updateProjectFeedback(command) {
+  if (!outcomes.snapshot || outcomes.saving) return false;
+  const status = $('kit-outcome-status');
+  const before = outcomes.snapshot;
+  outcomes.saving = true;
+  syncOutcomeControls();
+  status.textContent = 'Saving task outcomes…';
+  let conflict = false;
+  try {
+    const result = await api('project-feedback', { body: { ...command, expectedRevision: before.revision } });
+    const snapshot = result.snapshot || result;
+    if (!Number.isSafeInteger(snapshot.revision) || typeof snapshot.enabled !== 'boolean' || !Array.isArray(snapshot.records)) {
+      throw new Error('The server returned unreadable task outcomes.');
+    }
+    outcomes.snapshot = snapshot;
+    state.context.dirty = !!state.context.pack || state.context.pending;
+    if (state.context.pack && !state.context.pending) renderContext();
+    renderOutcomeHistory();
+    status.textContent = command.kind === 'record' ? 'Reported outcome saved.' : command.kind === 'remove' ? 'Report removed.' :
+      command.enabled ? 'Outcome influence enabled.' : 'Outcome influence paused.';
+    return true;
+  } catch (error) {
+    conflict = error.status === 409;
+    status.innerHTML = errorMarkup(error.message);
+    return false;
+  } finally {
+    outcomes.saving = false;
+    syncOutcomeControls();
+    if (conflict) void loadProjectFeedback();
+  }
+}
+
+async function saveOutcome() {
+  const memoryId = $('kit-outcome-memory').value;
+  const task = $('kit-outcome-task').value.trim();
+  const rating = $('kit-outcome-rating').value;
+  const reason = $('kit-outcome-reason').value.trim();
+  const referenceInput = $('kit-outcome-evidence').value;
+  const evidence = referenceInput.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (!memoryId || !task || !reason || !Object.hasOwn(outcomeRatings, rating)) {
+    $('kit-outcome-status').innerHTML = errorMarkup('Choose a memory and provide the task, outcome, and reason.');
+    return;
+  }
+  if (evidence.length > 3 || evidence.some((line) => line.length > 180)) {
+    $('kit-outcome-status').innerHTML = errorMarkup('Enter up to three references with at most 180 characters each.');
+    return;
+  }
+  if (await updateProjectFeedback({ kind: 'record', memoryId, task, rating, reason, ...(evidence.length ? { evidence } : {}) })) {
+    if ($('kit-outcome-reason').value.trim() === reason) $('kit-outcome-reason').value = '';
+    if ($('kit-outcome-evidence').value === referenceInput) $('kit-outcome-evidence').value = '';
+  }
+}
+
+$('kit-feedback-enable').addEventListener('click', () => {
+  if (outcomes.snapshot) void updateProjectFeedback({ kind: 'enable', enabled: !outcomes.snapshot.enabled });
+});
+$('kit-outcome-search-form').addEventListener('submit', (event) => { event.preventDefault(); void loadFeedbackMemories(); });
+$('kit-outcome-form').addEventListener('submit', (event) => { event.preventDefault(); void saveOutcome(); });
+$('kit-outcome-memory').addEventListener('change', syncOutcomeControls);
+$('kit-outcome-records').addEventListener('click', (event) => {
+  const button = event.target.closest('[data-outcome-remove]');
+  if (button) void updateProjectFeedback({ kind: 'remove', id: button.dataset.outcomeRemove });
+});
+`;
+//# sourceMappingURL=project-feedback-html.js.map

package/dist/dashboard/project-feedback-html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-feedback-html.js","sourceRoot":"","sources":["../../src/dashboard/project-feedback-html.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;CAkB/C,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhD,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoKhD,CAAC"}

package/dist/dashboard/project-file-watch.d.ts

@@ -0,0 +1,46 @@
+export interface ObservedProjectFile {
+    path: string;
+    operation: 'changed' | 'entry';
+    count: number;
+    exists: boolean;
+    entry: 'file' | 'directory' | 'unknown';
+}
+export interface ProjectWatchSummary {
+    status: 'off' | 'scanning' | 'watching' | 'limited';
+    directories: number;
+    inventoryCount: number;
+    inventoryLimited: boolean;
+}
+export declare class ProjectFileWatch {
+    private readonly root;
+    private readonly report;
+    private readonly changed;
+    private readonly watchers;
+    private readonly known;
+    private readonly pending;
+    private timer?;
+    private active;
+    private scanning;
+    private limited;
+    private inventoryLimited;
+    private generation;
+    private scanned;
+    private processing;
+    constructor(root: string, report: (event: ObservedProjectFile) => void, changed: () => void);
+    summary(): ProjectWatchSummary;
+    inventory(): {
+        path: string;
+        entry: "file" | "directory";
+    }[];
+    start(): void;
+    stop(): void;
+    private limit;
+    private validPath;
+    private actual;
+    private discover;
+    private remember;
+    private schedule;
+    private flush;
+    private forget;
+}
+//# sourceMappingURL=project-file-watch.d.ts.map

package/dist/dashboard/project-file-watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-file-watch.d.ts","sourceRoot":"","sources":["../../src/dashboard/project-file-watch.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;CACzC;AACD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,gBAAgB;IAaf,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqF;IAC7G,OAAO,CAAC,KAAK,CAAC,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,UAAU,CAAS;gBAEE,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,EACrF,OAAO,EAAE,MAAM,IAAI;IAEtC,OAAO,IAAI,mBAAmB;IAK9B,SAAS;;;;IAIT,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,IAAI;IAaZ,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,SAAS;YAIH,MAAM;YAYN,QAAQ;IAwCtB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,QAAQ;YAaF,KAAK;IA2BnB,OAAO,CAAC,MAAM;CAMf"}