hippo-memory 1.61.0 → 1.63.0

package/dist/project-merge.js

@@ -1,14 +1,21 @@
-// `hippo projects`: list the project names a store holds, fold one into another, and re-tag sleep's old user-global merges.
+// `hippo projects`: list the project names a store holds, fold one into another, and repair old tags in one reversible pass.
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { setAsideRow } from './agent-memories/apply.js';
-import { AGENT_MEMORY_SOURCE_PREFIX, AGENT_MEMORY_TOOLS } from './agent-memories/tools.js';
-import { appendAuditEvent } from './audit.js';
+import { transcriptNotesProject } from './agent-memories/claude-code.js';
+import { containerId, containerPrefix } from './agent-memories/source.js';
+import { AGENT_MEMORY_SOURCE_PREFIX, AGENT_MEMORY_TOOLS, toolSourcePrefix } from './agent-memories/tools.js';
+import { appendAuditEvent, queryAuditEvents } from './audit.js';
+import { getMeta, setMeta } from './db/meta.js';
 import { insertDormantRow, listDormantSnapshots, replaceDormantEntry } from './dormant.js';
+import { processEnv } from './env.js';
 import { calculateStrength } from './memory.js';
+import { isObjectLike, isStringValue } from './capture-contract.js';
+import { isGlobalStoreRoot, projectNames, resolveProjectIdentity } from './project-identity.js';
+import { duplicateKey } from './same-text.js';
 import { removeEntryMirrors } from './store/mirrors.js';
 import { deleteEntryRowInTx, writeEntryMirrors } from './store/entry-writes.js';
-import { selectAllEntries } from './store/entry-reads.js';
+import { selectAllEntries, selectLiveEntriesBySourcePrefix } from './store/entry-reads.js';
 const ACTOR = 'cli';
 function isImport(entry) {
     return entry.source.startsWith(AGENT_MEMORY_SOURCE_PREFIX);
@@ -25,8 +32,9 @@ export function listProjects(db, tenantId) {
     for (const e of live) {
         const origin = e.origin_project ?? null;
         byOrigin.set(origin, [...(byOrigin.get(origin) ?? []), e]);
+        const key = duplicateKey(e.content);
         if (isImport(e))
-            holders.set(e.content, (holders.get(e.content) ?? new Set()).add(origin));
+            holders.set(key, (holders.get(key) ?? new Set()).add(origin));
     }
     return [...byOrigin].map(([origin, rows]) => {
         const imports = rows.filter(isImport);
@@ -35,7 +43,7 @@ export function listProjects(db, tenantId) {
             live: rows.length,
             imported: imports.length,
             newest: rows.reduce((max, e) => (e.created > max ? e.created : max), ''),
-            copiesElsewhere: imports.filter((e) => (holders.get(e.content)?.size ?? 0) > 1).length,
+            copiesElsewhere: imports.filter((e) => (holders.get(duplicateKey(e.content))?.size ?? 0) > 1).length,
         };
     }).sort((a, b) => b.newest.localeCompare(a.newest));
 }
@@ -78,44 +86,174 @@ export function mergeProjects(db, hippoRoot, opts) {
     const { tenantId, from, into, dryRun } = opts;
     const backup = dryRun ? null : backupStore(db, hippoRoot, 'before-merge');
     const result = inTransaction(db, dryRun, () => {
-        const rows = selectAllEntries(db, tenantId).filter((e) => e.origin_project === from);
-        const setAside = [];
-        for (const row of rows) {
-            const tag = toolTag(row.source);
-            if (!isImport(row) || row.superseded_by || row.kind === 'raw' || tag === null)
-                continue;
-            if (setAsideRow(db, tag, { ...row, origin_project: into }, 'project-merge').kind === 'dormant')
-                setAside.push(row.id);
-        }
-        const gone = new Set(setAside);
-        const restamped = rows.filter((e) => !gone.has(e.id)).map((e) => e.id);
-        db.prepare(`UPDATE memories SET origin_project = ?, updated_at = datetime('now') WHERE tenant_id = ? AND origin_project = ?`)
-            .run(into, tenantId, from);
-        const dormantRestamped = [];
-        for (const snap of listDormantSnapshots(db, tenantId)) {
-            if (snap.entry.origin_project !== from || gone.has(snap.entry.id))
-                continue;
-            replaceDormantEntry(db, tenantId, snap.entry.id, { ...snap.entry, origin_project: into });
-            dormantRestamped.push(snap.entry.id);
-        }
-        const compactions = Number(db.prepare(`UPDATE compactions SET origin_project = ? WHERE tenant_id = ? AND origin_project = ?`)
-            .run(into, tenantId, from).changes ?? 0);
-        appendAuditEvent(db, {
-            tenantId, actor: ACTOR, op: 'project_merge',
-            metadata: { from, into, backup, setAside, restamped, dormantRestamped, compactions },
-        });
-        return { from, into, setAside, restamped, dormantRestamped, compactions, backup };
+        const folded = foldInTx(db, tenantId, from, into);
+        appendAuditEvent(db, { tenantId, actor: ACTOR, op: 'project_merge', metadata: { from, into, backup, ...folded } });
+        return { from, into, ...folded, backup };
     });
     if (!dryRun)
         refreshMirrors(db, hippoRoot, tenantId, result.restamped, result.setAside);
     return result;
 }
-/** Reads only, so doctor can call it on a read-only handle: what the repair would do to each user-global merged row. */
-export function planUserGlobalRepair(db, tenantId) {
+function foldInTx(db, tenantId, from, into) {
+    const all = selectAllEntries(db, tenantId);
+    const rows = all.filter((e) => e.origin_project === from);
+    // The sync renames the rest to `into`'s prefix and keeps their ids; only a note `into` already holds would show twice.
+    const held = new Set(all.filter((e) => e.origin_project === into && !e.superseded_by && isImport(e)).map(noteKey));
+    const setAside = [];
+    for (const row of rows) {
+        const tag = toolTag(row.source);
+        if (!isImport(row) || row.superseded_by || row.kind === 'raw' || tag === null || !held.has(noteKey(row)))
+            continue;
+        if (setAsideRow(db, tag, { ...row, origin_project: into }, 'project-merge').kind === 'dormant')
+            setAside.push(row.id);
+    }
+    const gone = new Set(setAside);
+    const restamped = rows.filter((e) => !gone.has(e.id)).map((e) => e.id);
+    db.prepare(`UPDATE memories SET origin_project = ?, updated_at = datetime('now') WHERE tenant_id = ? AND origin_project = ?`)
+        .run(into, tenantId, from);
+    const dormantRestamped = [];
+    for (const snap of listDormantSnapshots(db, tenantId)) {
+        if (snap.entry.origin_project !== from || gone.has(snap.entry.id))
+            continue;
+        replaceDormantEntry(db, tenantId, snap.entry.id, { ...snap.entry, origin_project: into });
+        dormantRestamped.push(snap.entry.id);
+    }
+    const compactions = Number(db.prepare(`UPDATE compactions SET origin_project = ? WHERE tenant_id = ? AND origin_project = ?`)
+        .run(into, tenantId, from).changes ?? 0);
+    return { setAside, restamped, dormantRestamped, compactions };
+}
+/** Tool, note key and hash of an import, without the container, whose id hashes the project name. */
+function noteKey(entry) {
+    const rest = entry.source.slice(AGENT_MEMORY_SOURCE_PREFIX.length);
+    return `${rest.split(':')[0]}:${rest.slice(rest.indexOf('/') + 1)}`;
+}
+/** Live imports under a project name whose exact text a user-global import holds: a session folder's notes stamped with the folder it ended in. */
+function importCopies(db, tenantId) {
+    const live = selectAllEntries(db, tenantId).filter((e) => !e.superseded_by && isImport(e));
+    const userGlobal = new Set(live.filter((e) => e.origin_project === '').map((e) => duplicateKey(e.content)));
+    return live.filter((e) => e.origin_project && e.kind !== 'raw' && !e.pinned && toolTag(e.source) !== null && userGlobal.has(duplicateKey(e.content)));
+}
+/** Imports to set aside. The global store also checks each Claude session folder a compaction recorded: its notes under any other project are misfiled, edited or not, and a text copy in the right folder is kept. */
+function strayImports(db, hippoRoot, tenantId) {
+    const copies = importCopies(db, tenantId);
+    if (!isGlobalStoreRoot(hippoRoot))
+        return copies;
+    const machine = { platform: process.platform, env: processEnv() };
+    const { platform } = machine;
+    // SAFETY: the SELECT names the two columns of the row type.
+    const sessions = db.prepare(`SELECT DISTINCT transcript_path AS transcript, cwd FROM compactions WHERE tenant_id = ? AND transcript_path IS NOT NULL`)
+        .all(tenantId);
+    const owners = new Map();
+    for (const { transcript, cwd } of sessions) {
+        const project = transcriptNotesProject(transcript, cwd, machine);
+        const dir = path.join(path.dirname(transcript), 'memory');
+        if (project === null)
+            continue;
+        const ids = owners.get(dir) ?? new Map();
+        owners.set(dir, ids.set(project.name, [...new Set([...(ids.get(project.name) ?? []), ...projectNames(project)])]));
+    }
+    const tool = toolSourcePrefix('claude-code');
+    const live = selectLiveEntriesBySourcePrefix(db, tenantId, tool).filter((e) => e.kind !== 'raw' && !e.pinned);
+    const origins = new Set(live.map((e) => e.origin_project ?? ''));
+    const edges = foldEdges(db, tenantId);
+    const right = new Set();
+    const wrong = new Set();
+    for (const [dir, ids] of owners) {
+        if (ids.size !== 1)
+            continue;
+        // Its names before the id, and names folded into it, are the owner's too: the next sync moves those prefixes under the id.
+        const [names] = ids.values();
+        const own = new Set([...names, ...foldedInto(edges, names)]);
+        for (const origin of new Set([...origins, ...own]))
+            (own.has(origin) ? right : wrong).add(containerPrefix('claude-code', containerId(dir, 'project', platform, origin)));
+    }
+    const prefix = (e) => e.source.slice(0, e.source.indexOf('/', tool.length) + 1);
+    const misfiled = live.filter((e) => wrong.has(prefix(e)));
+    const seen = new Set(misfiled.map((e) => e.id));
+    return [...misfiled, ...copies.filter((e) => !seen.has(e.id) && !right.has(prefix(e)))];
+}
+/** The global store reads each name's recorded session folders, where a compaction's name came from its cwd; a project store folds only its own folder name. */
+function planFolds(db, hippoRoot, tenantId, globalFolds) {
+    // A name someone merged into by hand stays: undoing their choice would rest on the resolver alone.
+    const chosen = new Set(queryAuditEvents(db, { tenantId, op: 'project_merge', limit: 10000 }).map((e) => e.metadata.into));
+    if (!isGlobalStoreRoot(hippoRoot))
+        return { folds: ownLegacyFold(db, hippoRoot, tenantId).filter((f) => !chosen.has(f.from)), collisions: [] };
+    // SAFETY: the SELECT names the two columns of the row type.
+    const rows = db.prepare(`SELECT DISTINCT origin_project AS origin, cwd FROM compactions WHERE tenant_id = ? AND origin_project <> '' AND cwd IS NOT NULL`)
+        .all(tenantId);
+    const today = new Map();
+    for (const { origin, cwd } of rows) {
+        if (fs.existsSync(cwd))
+            today.set(origin, (today.get(origin) ?? new Set()).add(resolveProjectIdentity(cwd).name));
+    }
+    const folds = [];
+    const collisions = [];
+    for (const [from, names] of today) {
+        const [into] = names;
+        if (chosen.has(from))
+            continue;
+        if (names.size > 1)
+            collisions.push({ name: from, ids: [...names].sort() });
+        else if (into !== '' && into !== from)
+            folds.push({ from, into });
+    }
+    // A fold into a name that itself folds would land rows by run order; the next repair takes the rest of the chain.
+    const sources = new Set(folds.map((f) => f.from));
+    return { folds: globalFolds ? folds.filter((f) => !sources.has(f.into)) : [], collisions };
+}
+/** A project store's rows, dormant snapshots and compaction records written before its id existed carry its folder name. */
+function ownLegacyFold(db, hippoRoot, tenantId) {
+    const { name, legacyName } = resolveProjectIdentity(path.dirname(path.resolve(hippoRoot)));
+    if (legacyName === '' || legacyName === name)
+        return [];
+    const heldIn = (table) => db.prepare(`SELECT 1 FROM ${table} WHERE tenant_id = ? AND origin_project = ? LIMIT 1`).get(tenantId, legacyName) !== undefined;
+    const held = heldIn('memories') || heldIn('compactions') || listDormantSnapshots(db, tenantId).some((s) => s.entry.origin_project === legacyName);
+    return held ? [{ from: legacyName, into: name }] : [];
+}
+function foldOf(value) {
+    if (!isObjectLike(value) || Array.isArray(value))
+        return [];
+    const { from, into } = value;
+    return isStringValue(from) && isStringValue(into) ? [{ from, into }] : [];
+}
+function foldEdges(db, tenantId) {
+    return [
+        ...queryAuditEvents(db, { tenantId, op: 'project_merge', limit: 10000 }).flatMap((e) => foldOf(e.metadata)),
+        ...queryAuditEvents(db, { tenantId, op: 'project_repair', limit: 10000 })
+            .flatMap((e) => (Array.isArray(e.metadata.folds) ? e.metadata.folds.flatMap(foldOf) : [])),
+    ];
+}
+function foldedInto(edges, names) {
+    const seen = new Set(names);
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const { from, into } of edges) {
+            if (!seen.has(into) || seen.has(from))
+                continue;
+            seen.add(from);
+            grew = true;
+        }
+    }
+    return [...seen].filter((n) => !names.includes(n));
+}
+/** Names folded, directly or through others, into one of `names`; the sync moves imports still filed under them. */
+export function namesFoldedInto(db, tenantId, names) {
+    return foldedInto(foldEdges(db, tenantId), names);
+}
+/** Reads only, so doctor and a dry run take no write lock; merged rows are planned before any fold, so a few may re-tag differently once folds apply. */
+export function planProjectRepair(db, hippoRoot, tenantId, globalFolds = true) {
+    const { folds, collisions } = planFolds(db, hippoRoot, tenantId, globalFolds);
+    return { copies: strayImports(db, hippoRoot, tenantId).map((e) => e.id), folds, collisions, ...planUserGlobalRepair(db, tenantId, folds) };
+}
+/** Parents read with `folds` already applied, so a plan matches what apply does after folding. */
+function planUserGlobalRepair(db, tenantId, folds) {
     const all = selectAllEntries(db, tenantId);
-    const origins = new Map(listDormantSnapshots(db, tenantId).map((s) => [s.entry.id, s.entry.origin_project ?? null]));
+    const renamed = new Map(folds.map((f) => [f.from, f.into]));
+    const after = (origin) => (origin ? renamed.get(origin) ?? origin : origin ?? null);
+    const origins = new Map(listDormantSnapshots(db, tenantId).map((s) => [s.entry.id, after(s.entry.origin_project)]));
     for (const e of all)
-        origins.set(e.id, e.origin_project ?? null);
+        origins.set(e.id, after(e.origin_project));
     const toProject = [];
     const setAside = [];
     const untraced = [];
@@ -135,14 +273,22 @@ export function planUserGlobalRepair(db, tenantId) {
     }
     return { toProject, setAside, untraced };
 }
-/** Re-tags sleep's merged rows saved as user-global before the fix, by the projects of their parents. */
-export function repairUserGlobalMerges(db, hippoRoot, opts) {
-    const { tenantId, dryRun } = opts;
+/** Sets aside stray imports, folds the names the resolver now maps elsewhere, then re-tags sleep's user-global merges by their parents; a dry run only plans. */
+export function repairProjects(db, hippoRoot, opts) {
+    const { tenantId, dryRun, globalFolds = true } = opts;
     if (dryRun)
-        return { ...planUserGlobalRepair(db, tenantId), backup: null };
+        return { ...planProjectRepair(db, hippoRoot, tenantId, globalFolds), backup: null };
     const backup = backupStore(db, hippoRoot, 'before-repair');
-    const result = inTransaction(db, false, () => {
-        const plan = planUserGlobalRepair(db, tenantId);
+    const { result, rewrite, purge } = inTransaction(db, false, () => {
+        const copies = [];
+        for (const row of strayImports(db, hippoRoot, tenantId)) {
+            const tag = toolTag(row.source);
+            if (tag !== null && setAsideRow(db, tag, row, 'project-repair').kind === 'dormant')
+                copies.push(row.id);
+        }
+        const { folds, collisions } = planFolds(db, hippoRoot, tenantId, globalFolds);
+        const folded = folds.map((f) => foldInTx(db, tenantId, f.from, f.into));
+        const plan = planUserGlobalRepair(db, tenantId, []);
         const stamp = db.prepare(`UPDATE memories SET origin_project = ?, updated_at = datetime('now') WHERE tenant_id = ? AND id = ?`);
         for (const { id, origin } of plan.toProject)
             stamp.run(origin, tenantId, id);
@@ -152,10 +298,31 @@ export function repairUserGlobalMerges(db, hippoRoot, opts) {
             insertDormantRow(db, { entry: row, strength: calculateStrength(row, now), reason: 'project-repair', dormantAt: now.toISOString() });
             deleteEntryRowInTx(db, row, ACTOR);
         }
-        appendAuditEvent(db, { tenantId, actor: ACTOR, op: 'project_repair', metadata: { backup, ...plan } });
-        return { ...plan, backup };
+        appendAuditEvent(db, { tenantId, actor: ACTOR, op: 'project_repair', metadata: { backup, copies, folds, folded, ...plan } });
+        return {
+            result: { copies, folds, collisions, ...plan, backup },
+            rewrite: [...plan.toProject.map((r) => r.id), ...folded.flatMap((f) => f.restamped)],
+            purge: [...copies, ...plan.setAside, ...folded.flatMap((f) => f.setAside)],
+        };
     });
-    refreshMirrors(db, hippoRoot, tenantId, result.toProject.map((r) => r.id), result.setAside);
+    refreshMirrors(db, hippoRoot, tenantId, rewrite, purge);
+    return result;
+}
+const AUTO_REPAIR_META_KEY = 'project_repair_auto';
+/** True when a repair would change nothing. */
+function repairIsEmpty(r) {
+    return r.copies.length + r.folds.length + r.toProject.length + r.setAside.length === 0;
+}
+/**
+ * Sleep runs repair once per store, so an upgrade needs no command. Global-store folds stay
+ * with `hippo projects repair`: their evidence is compaction folders, blind to a same-named repo that never compacted.
+ */
+export function repairOnceOnSleep(db, hippoRoot, tenantId) {
+    if (getMeta(db, AUTO_REPAIR_META_KEY) === '1')
+        return null;
+    const plan = planProjectRepair(db, hippoRoot, tenantId, false);
+    const result = repairIsEmpty(plan) ? null : repairProjects(db, hippoRoot, { tenantId, dryRun: false, globalFolds: false });
+    setMeta(db, AUTO_REPAIR_META_KEY, '1');
     return result;
 }
 /** After commit, as the agent memory sync does: a stale mirror would bring the old tag back on the next rebuild. */

package/dist/project-remote.d.ts

@@ -0,0 +1,12 @@
+/** The config file git reads for a checkout: `.git/config`, a linked worktree's `<commondir>/config`, a submodule's `<gitdir>/config`. */
+export declare function gitConfigPath(gitRoot: string): string | null;
+/** `remote.origin.url` from a config file's text, the first value as git fetch uses; the subsection name is case-sensitive. */
+export declare function originUrlFromConfig(text: string): string | null;
+/** `host/path` for a network remote, so ssh, scp and https forms agree; null for a local path, which would put a user path into rows. */
+export declare function normaliseRemote(url: string): string | null;
+/** The normalised origin of the checkout rooted at gitRoot, or null when it has none a project can be named by. */
+export declare function originRemoteId(gitRoot: string): string | null;
+export declare const PROJECT_FILE = ".hippo-project.json";
+/** The `id` a team committed in `.hippo-project.json` at root, lowercased like every project name; null when absent or unusable. */
+export declare function projectFileId(root: string): string | null;
+//# sourceMappingURL=project-remote.d.ts.map

package/dist/project-remote.js

@@ -0,0 +1,138 @@
+// A checkout's `origin` remote, read from its git config file and normalised into a project id; no git process, so the prompt hook can call it.
+import * as fs from 'fs';
+import * as path from 'path';
+import { isObjectLike, isStringValue } from './capture-contract.js';
+import { log } from './log.js';
+/** The config file git reads for a checkout: `.git/config`, a linked worktree's `<commondir>/config`, a submodule's `<gitdir>/config`. */
+export function gitConfigPath(gitRoot) {
+    const marker = path.join(gitRoot, '.git');
+    try {
+        if (fs.statSync(marker).isDirectory())
+            return path.join(marker, 'config');
+        const gitDir = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(marker, 'utf8'))?.[1]?.trim();
+        if (!gitDir)
+            return null;
+        const linkDir = path.resolve(gitRoot, gitDir);
+        const commondir = path.join(linkDir, 'commondir');
+        if (!fs.existsSync(commondir))
+            return path.join(linkDir, 'config');
+        return path.join(path.resolve(linkDir, fs.readFileSync(commondir, 'utf8').trim()), 'config');
+    }
+    catch (err) {
+        log.debug(`project remote: no git config for ${gitRoot}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/** One config value with git's quoting: `"` toggles quoting, backslash escapes, and an unquoted `#` or `;` starts a comment. */
+function configValue(raw) {
+    let out = '';
+    let quoted = false;
+    for (let i = 0; i < raw.length; i++) {
+        const c = raw[i];
+        if (c === '\\' && i + 1 < raw.length) {
+            const next = raw[++i];
+            out += next === 'n' ? '\n' : next === 't' ? '\t' : next === 'b' ? '' : next;
+        }
+        else if (c === '"') {
+            quoted = !quoted;
+        }
+        else if (!quoted && (c === '#' || c === ';')) {
+            break;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out.trim();
+}
+const SECTION = /^\[\s*([A-Za-z0-9.-]+)(?:\s+"((?:[^"\\]|\\.)*)")?\s*\](.*)$/;
+const ENTRY = /^([A-Za-z][A-Za-z0-9-]*)\s*(?:=(.*))?$/;
+/** `remote.origin.url` from a config file's text, the first value as git fetch uses; the subsection name is case-sensitive. */
+export function originUrlFromConfig(text) {
+    let inOrigin = false;
+    for (const raw of text.split(/\r?\n/)) {
+        let line = raw.trim();
+        const section = SECTION.exec(line);
+        if (section) {
+            const [, name, sub, rest] = section;
+            inOrigin = sub === undefined
+                ? name.toLowerCase() === 'remote.origin'
+                : name.toLowerCase() === 'remote' && sub.replace(/\\(.)/g, '$1') === 'origin';
+            line = rest.trim();
+        }
+        const entry = inOrigin ? ENTRY.exec(line) : null;
+        if (entry && entry[1].toLowerCase() === 'url' && entry[2] !== undefined) {
+            const value = configValue(entry[2]);
+            if (value !== '')
+                return value;
+        }
+    }
+    return null;
+}
+/** Azure DevOps names one repo three ways; all become `dev.azure.com/org/project/repo`. */
+function azureDevOps(hostPath) {
+    const ssh = /^(?:ssh\.dev\.azure\.com|vs-ssh\.visualstudio\.com)\/v3\/(.+)$/.exec(hostPath);
+    if (ssh)
+        return `dev.azure.com/${ssh[1]}`;
+    const legacy = /^([^/.]+)\.visualstudio\.com\/(?:defaultcollection\/)?(.+)$/.exec(hostPath);
+    const https = legacy ? `dev.azure.com/${legacy[1]}/${legacy[2]}` : hostPath;
+    return https.startsWith('dev.azure.com/') ? https.replace('/_git/', '/') : https;
+}
+/** `host/path` for a network remote, so ssh, scp and https forms agree; null for a local path, which would put a user path into rows. */
+export function normaliseRemote(url) {
+    // A query or fragment can carry a token (`?private_token=`) and never names the repo.
+    const u = url.trim().replace(/[?#].*$/, '');
+    if (u === '' || u.includes('::') || /^file:/i.test(u) || /^[A-Za-z]:[\\/]/.test(u) || /^[./\\~]/.test(u))
+        return null;
+    let hostPath;
+    const withScheme = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/([^/]*)(.*)$/.exec(u);
+    if (withScheme) {
+        // Userinfo can hold a token, and a port differs between ssh and https.
+        hostPath = withScheme[1].replace(/^.*@/, '').replace(/:\d*$/, '') + withScheme[2];
+    }
+    else {
+        const scp = /^(?:[^@/]+@)?([^:/]+):(.*)$/.exec(u);
+        if (!scp)
+            return null;
+        hostPath = `${scp[1]}/${scp[2]}`;
+    }
+    const tidy = hostPath.toLowerCase().replace(/\\/g, '/').replace(/\/{2,}/g, '/').replace(/\/+$/, '').replace(/\.git$/, '').replace(/\/+$/, '');
+    const id = azureDevOps(tidy);
+    // A colon would break the `shared:<project>:` source format; whitespace means this was no URL; an `@` left in a path may be a credential.
+    return /^[^/]+\/./.test(id) && !/[:\s@]/.test(id) ? id : null;
+}
+/** The normalised origin of the checkout rooted at gitRoot, or null when it has none a project can be named by. */
+export function originRemoteId(gitRoot) {
+    const file = gitConfigPath(gitRoot);
+    if (file === null)
+        return null;
+    try {
+        const url = originUrlFromConfig(fs.readFileSync(file, 'utf8'));
+        return url === null ? null : normaliseRemote(url);
+    }
+    catch (err) {
+        log.debug(`project remote: ${file} not read: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+export const PROJECT_FILE = '.hippo-project.json';
+/** The `id` a team committed in `.hippo-project.json` at root, lowercased like every project name; null when absent or unusable. */
+export function projectFileId(root) {
+    const file = path.join(root, PROJECT_FILE);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const raw = isObjectLike(parsed) && 'id' in parsed ? parsed.id : undefined;
+        const id = isStringValue(raw) ? raw.trim().toLowerCase() : '';
+        // No slash: a committed file in an untrusted clone must not claim a remote-shaped id like `github.com/acme/api`.
+        if (id !== '' && id.length <= 200 && !/[:\s/\\]/.test(id))
+            return id;
+        log.warn(`${file}: "id" must be a non-empty string with no colon, slash or spaces; using the remote or folder name instead`);
+    }
+    catch (err) {
+        log.warn(`${file} not read: ${err instanceof Error ? err.message : String(err)}; using the remote or folder name instead`);
+    }
+    return null;
+}
+//# sourceMappingURL=project-remote.js.map

package/dist/prompt-recall.js

@@ -1,5 +1,4 @@
-/** Z1: recall gated on the hook prompt, not the five newest memories (pure, no I/O).
- *  See docs/plans/2026-09-26-z1-prompt-recall.md. */
+/** Recall gated on the hook prompt, not the five newest memories (pure, no I/O). */
 import { tokenize } from './tokenize.js';
 import { STOP_WORDS } from './audit.js';
 // Latency bound, not tuned: fixed in the prereg regardless of gate config.

package/dist/rate-limit.d.ts

@@ -1,7 +1,7 @@
 /**
  * Per-key token-bucket rate limiter for inbound /v1/* requests.
  *
- * Bounds api-key-id enumeration (the v0.40 follow-up noted in auth.ts): a
+ * Bounds api-key-id enumeration: a
  * client that drains its bucket is denied until it refills. Dependency-free
  * and unit-testable in isolation via the injectable `now`.
  */

package/dist/rate-limit.js

@@ -1,7 +1,7 @@
 /**
  * Per-key token-bucket rate limiter for inbound /v1/* requests.
  *
- * Bounds api-key-id enumeration (the v0.40 follow-up noted in auth.ts): a
+ * Bounds api-key-id enumeration: a
  * client that drains its bucket is denied until it refills. Dependency-free
  * and unit-testable in isolation via the injectable `now`.
  */

package/dist/raw-archive.d.ts

@@ -11,5 +11,14 @@ export interface ArchiveOpts {
      */
     afterArchive?: (db: DatabaseSyncLike, archivedMemoryId: string) => void;
 }
+/**
+ * The only legitimate path to remove a `kind='raw'` row from `memories`.
+ *
+ * Snapshots the full row into `raw_archive`, flips `kind` to `'archived'` so the
+ * append-only trigger lets the delete through, then deletes the row. All in one
+ * SAVEPOINT so it can be nested inside an outer transaction (e.g. batchWriteAndDelete).
+ *
+ * Throws if the row does not exist or is not `kind='raw'`.
+ */
 export declare function archiveRawMemory(db: DatabaseSyncLike, id: string, opts: ArchiveOpts): void;
 //# sourceMappingURL=raw-archive.d.ts.map

package/dist/raw-archive.js

@@ -2,7 +2,7 @@ import { BadRequestError, NotFoundError } from './api-errors.js';
 import { isFtsAvailable } from './db.js';
 import { appendAuditEvent, reportAuditWriteFailure } from './audit.js';
 import { markSummaryDirtyInTx } from './summary-dirty.js';
-export function archiveRawMemory(db, id, opts) {
+function loadRawRow(db, id) {
     // SAFETY: SELECT * FROM memories returns every column of the memories table; only
     // kind, tenant_id, and dag_parent_id are read below, all guaranteed present (possibly
     // null) by the memories schema.
@@ -12,65 +12,82 @@ export function archiveRawMemory(db, id, opts) {
     if (row.kind !== 'raw') {
         throw new BadRequestError(`memory ${id} is not raw (kind=${String(row.kind)})`);
     }
+    return row;
+}
+function moveRowToArchive(db, id, row, opts) {
+    // GDPR: raw_archive stores ONLY metadata, not the original
+    // memory content. The audit_log row appended below carries op='archive_raw'
+    // for the compliance audit trail. True right-to-be-forgotten — the original
+    // content is unrecoverable from raw_archive after this point.
+    const archivedAt = new Date().toISOString();
+    const redactedPayload = JSON.stringify({
+        redacted: true,
+        archived_at: archivedAt,
+        tenant_id: row.tenant_id ?? 'default',
+        kind: row.kind,
+        reason: opts.reason,
+    });
+    db.prepare(`INSERT INTO raw_archive (memory_id, archived_at, reason, archived_by, payload_json) VALUES (?, ?, ?, ?, ?)`).run(id, archivedAt, opts.reason, opts.who, redactedPayload);
+    // Flip kind to 'archived' so the BEFORE DELETE trigger no longer fires, then delete.
+    db.prepare(`UPDATE memories SET kind = 'archived' WHERE id = ?`).run(id);
+    db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+    // FTS5 is a virtual table — no FK CASCADE applies. Purge the FTS row so the
+    // archived content is not searchable after archive. Without this the original
+    // raw text remains in memories_fts until the next DB-open backfill, defeating
+    // GDPR right-to-be-forgotten.
+    if (isFtsAvailable(db)) {
+        try {
+            db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(id);
+        }
+        catch {
+            // Best effort only. The DELETE on memories already succeeded; FTS will
+            // self-heal on next DB open via backfillFtsIndex.
+        }
+    }
+}
+// Emit the archive_raw audit event inside the SAVEPOINT so the audit row is
+// committed atomically with the row deletion. Use the row's own tenant_id
+// (fetched above as part of SELECT *), not the env. Archives must be
+// attributed to the tenant that owns the row, not whatever HIPPO_TENANT
+// happens to be set to in the calling shell.
+function auditArchive(db, id, row, opts) {
+    try {
+        appendAuditEvent(db, {
+            tenantId: String(row.tenant_id ?? 'default'),
+            actor: opts.who || 'cli',
+            op: 'archive_raw',
+            targetId: id,
+            metadata: { reason: opts.reason },
+        });
+    }
+    catch (error) {
+        // The archive itself has already succeeded; an unwritable audit table must not undo it.
+        reportAuditWriteFailure('archive_raw', String(error), id);
+    }
+}
+/**
+ * The only legitimate path to remove a `kind='raw'` row from `memories`.
+ *
+ * Snapshots the full row into `raw_archive`, flips `kind` to `'archived'` so the
+ * append-only trigger lets the delete through, then deletes the row. All in one
+ * SAVEPOINT so it can be nested inside an outer transaction (e.g. batchWriteAndDelete).
+ *
+ * Throws if the row does not exist or is not `kind='raw'`.
+ */
+export function archiveRawMemory(db, id, opts) {
+    const row = loadRawRow(db, id);
     // SAVEPOINT (not BEGIN) so this works whether or not we're already inside a
     // transaction. SQLite refuses BEGIN within a transaction; SAVEPOINT nests safely.
     db.exec('SAVEPOINT archive_raw');
     try {
-        // GDPR Path A (v0.39): raw_archive stores ONLY metadata, not the original
-        // memory content. The audit_log row appended below carries op='archive_raw'
-        // for the compliance audit trail. True right-to-be-forgotten — the original
-        // content is unrecoverable from raw_archive after this point.
-        const archivedAt = new Date().toISOString();
-        const redactedPayload = JSON.stringify({
-            redacted: true,
-            archived_at: archivedAt,
-            tenant_id: row.tenant_id ?? 'default',
-            kind: row.kind,
-            reason: opts.reason,
-        });
-        db.prepare(`INSERT INTO raw_archive (memory_id, archived_at, reason, archived_by, payload_json) VALUES (?, ?, ?, ?, ?)`).run(id, archivedAt, opts.reason, opts.who, redactedPayload);
-        // Flip kind to 'archived' so the BEFORE DELETE trigger no longer fires, then delete.
-        db.prepare(`UPDATE memories SET kind = 'archived' WHERE id = ?`).run(id);
-        db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
-        // FTS5 is a virtual table — no FK CASCADE applies. Purge the FTS row so the
-        // archived content is not searchable after archive. Without this the original
-        // raw text remains in memories_fts until the next DB-open backfill, defeating
-        // GDPR right-to-be-forgotten.
-        if (isFtsAvailable(db)) {
-            try {
-                db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(id);
-            }
-            catch {
-                // Best effort only. The DELETE on memories already succeeded; FTS will
-                // self-heal on next DB open via backfillFtsIndex.
-            }
-        }
-        // A5 audit: emit archive_raw event inside the SAVEPOINT so the audit row is
-        // committed atomically with the row deletion. Use the row's own tenant_id
-        // (fetched above as part of SELECT *), not the env. Archives must be
-        // attributed to the tenant that owns the row, not whatever HIPPO_TENANT
-        // happens to be set to in the calling shell.
-        try {
-            appendAuditEvent(db, {
-                tenantId: String(row.tenant_id ?? 'default'),
-                actor: opts.who || 'cli',
-                op: 'archive_raw',
-                targetId: id,
-                metadata: { reason: opts.reason },
-            });
-        }
-        catch (error) {
-            // The archive itself has already succeeded; an unwritable audit table must not undo it.
-            reportAuditWriteFailure('archive_raw', String(error), id);
-        }
-        // v0.30 / E2 — DAG live-coupling: archive of a child under a level-2
-        // summary marks parent dirty. Inside the SAVEPOINT so the dirty-mark
-        // commits atomically with the archive. row.dag_parent_id was fetched
-        // via SELECT * at L28 (schema v28 includes it).
+        moveRowToArchive(db, id, row, opts);
+        auditArchive(db, id, row, opts);
+        // Archiving a child under a level-2 summary marks the parent dirty, inside the
+        // SAVEPOINT so the dirty-mark commits atomically with the archive.
         if (row.dag_parent_id) {
             markSummaryDirtyInTx(db, String(row.dag_parent_id), String(row.tenant_id ?? 'default'), opts.who || 'cli');
         }
-        // afterArchive hook (v0.39 commit 3): connector-level idempotency markers
+        // afterArchive hook: connector-level idempotency markers
         // (e.g. slack_event_log) must commit atomically with the archive itself.
         // Throwing here rolls back the entire SAVEPOINT — both the archive and any
         // hook side effects. The hook runs INSIDE the SAVEPOINT so its writes