gnosys 5.9.5 → 5.11.0

package/dist/lib/portfolio.d.ts

@@ -5,7 +5,7 @@
  * a formatted dashboard showing blockers, production readiness,
  * open questions, and roadmap status.
  */
-import { GnosysDB, DbProject } from "./db.js";
+import type { GnosysDB, DbProject } from "./db.js";
 export interface ActionItem {
     type: "question" | "blocker" | "manual" | "decision";
     text: string;
@@ -90,4 +90,3 @@ export declare function formatPortfolioCompact(report: PortfolioReport): string;
 export declare const STATUS_UPDATE_PROMPT = "# Gnosys Status Update \u2014 Guided Checklist\n\nYou are updating the project status for the Gnosys portfolio dashboard. Follow this process exactly.\n\n## Step 1: Analyze the codebase\n\nRead the project structure, recent git history, test results, build status, and any existing status memories (use gnosys_discover and gnosys_read). Fill in as much as you can from code.\n\n## Step 2: Work through every section below\n\nFor EACH section, either fill it in from your analysis or ASK the user. Do NOT skip sections. Do NOT write the status memory until all sections are addressed.\n\n### Section A: What's Complete\nList all features, milestones, and capabilities that are done and working. Be specific (e.g., \"14 Playwright E2E tests passing\" not \"tests exist\").\n\n### Section B: What's NOT Done\nList everything remaining before the project can go live. Include partial work, missing features, and known gaps.\n\n### Section C: Waiting on Human\n**YOU MUST ASK THE USER** if you cannot determine these from code:\n- Are there accounts that need to be created or configured? (Apple Developer, cloud providers, API keys, DNS, domain registrars, app store submissions)\n- Are there approvals or sign-offs needed? (legal, compliance, stakeholder review)\n- Are there purchases needed? (certificates, licenses, subscriptions)\n- Are there manual deployment steps only the user can do?\n- Is the user waiting on anyone else? (contractors, partners, third-party services)\n\nIf the code shows signs of these (e.g., placeholder API keys, TODO comments about accounts, unsigned builds), list what you found and confirm with the user.\n\n### Section D: Blockers\nItems that are actively preventing progress. Distinguish between:\n- **Technical blockers**: bugs, dependency issues, broken builds\n- **External blockers**: waiting on third-party, account access, API approval\n- **Decision blockers**: choices that need to be made before work can continue\n\n### Section E: Open Decisions\nQuestions or choices that haven't been resolved yet. **ASK the user** about any you find:\n- Architecture or technology choices still open\n- Scope decisions (what's in v1 vs deferred)\n- Prioritization questions\n- Trade-offs that need a human call\n\n### Section F: Go-Live Readiness\nAssess each area \u2014 mark as Ready, Partial, Not Started, or N/A:\n- [ ] Core features functional\n- [ ] Error handling and edge cases\n- [ ] Security review (auth, input validation, secrets management)\n- [ ] Performance acceptable (or: performance testing not done)\n- [ ] Functional testing sufficient (state coverage level and any known gaps)\n- [ ] Documentation (user-facing: README, API docs, guides)\n- [ ] Deployment pipeline (CI/CD, hosting, domain, SSL)\n- [ ] Monitoring and logging\n- [ ] Data migration / seed data\n- [ ] Legal (privacy policy, terms, licenses, compliance)\n\n### Section G: Testing Status\n- **Functional tests**: What exists? What's the coverage? Any known failing tests?\n- **Performance tests**: Have they been run? Any issues found? Any remediation done?\n- **Integration tests**: Do external services / APIs work end-to-end?\n- **Known defects**: List any open bugs with severity (critical/major/minor)\n- **Defect remediation**: Any bugs that were found and fixed recently?\n\n### Section H: Roadmap Changes\n- Has the plan changed since the last status update?\n- Any new work discovered during development?\n- Any scope added or removed?\n- What's the recommended next priority?\n\n## Step 3: Ask the user about gaps\n\nBefore writing the memory, present your findings and explicitly ask about anything you couldn't determine:\n\n> \"I've analyzed the codebase and filled in what I can. I need your input on these items before I can write the status:\n> 1. [specific question]\n> 2. [specific question]\n> ...\"\n\nIf the user says \"skip\" or \"not applicable\" for a section, mark it as \"N/A \u2014 skipped by owner\" in the status.\n\n## Step 4: Write the status memory\n\nOnce all sections are addressed, call gnosys_add_structured with:\n\n- **title**: \"[Project Name] status as of [YYYY-MM-DD] \u2014 [one-line summary]\"\n- **category**: \"landscape\"\n- **tags**: { \"type\": [\"status\", \"milestone\"], \"concern\": [\"release\"] }\n- **relevance**: \"[project-name] status complete shipped ready go-live production blockers testing\"\n- **author**: \"human+ai\"\n- **authority**: \"observed\"\n- **confidence**: 0.95\n- **projectRoot**: \"[the project's working directory]\"\n\nThe content MUST use these exact heading formats (the dashboard parser depends on them):\n\n```markdown\n# [Project Name] Status \u2014 [YYYY-MM-DD]\n\n## What's Complete\n- [from Section A]\n\n## What's NOT Done\n- [from Section B]\n\n## Waiting on Human\n- [from Section C \u2014 manual steps, accounts, approvals]\n\n## Blockers\n- [from Section D \u2014 categorized as Technical / External / Decision]\n\n## Open Decisions\n- [from Section E]\n\n## Go-Live Readiness\n- [from Section F \u2014 checklist with status per area]\n\n## Testing Status\n- [from Section G \u2014 functional, performance, integration, defects]\n\n## Roadmap Changes\n- [from Section H \u2014 plan changes, new work, next priority]\n```\n\nIMPORTANT: Be specific enough that someone reading the dashboard can take action immediately. \"Needs testing\" is useless \u2014 \"No load tests run; API response times unknown under concurrent usage\" is actionable.";
 /** Generate the status update prompt pre-filled for a specific project */
 export declare function generateStatusPrompt(projectName: string, projectRoot: string): string;
-//# sourceMappingURL=portfolio.d.ts.map

package/dist/lib/portfolio.js

@@ -5,6 +5,8 @@
  * a formatted dashboard showing blockers, production readiness,
  * open questions, and roadmap status.
  */
+import { readMachineConfig } from "./machineConfig.js";
+import { effectiveProjectPath } from "./projectPaths.js";
 // ─── Core ───────────────────────────────────────────────────────────────
 /** Parse tags from the DB column (JSON array string or comma-separated) */
 function parseTags(raw) {
@@ -335,8 +337,14 @@ function buildProjectSnapshot(db, project) {
 /** Generate the full portfolio report */
 export function generatePortfolio(db) {
     const projects = db.getAllProjects();
-    // Filter out test projects (those in /tmp/ or /private/tmp/)
-    const realProjects = projects.filter((p) => !p.working_directory.startsWith("/tmp/") && !p.working_directory.startsWith("/private/tmp/"));
+    // Filter out test projects (those in /tmp/) and projects not present on this
+    // machine. Path is resolved per-machine (machine.json) with a legacy
+    // fallback to working_directory when machine.json is absent.
+    const machine = readMachineConfig();
+    const realProjects = projects.filter((p) => {
+        const ep = effectiveProjectPath(db, p, machine);
+        return ep !== null && !ep.startsWith("/tmp/") && !ep.startsWith("/private/tmp/");
+    });
     const snapshots = realProjects.map((p) => buildProjectSnapshot(db, p));
     // Filter out projects with 0 memories
     const activeSnapshots = snapshots.filter((s) => s.memoryCounts.total > 0);
@@ -592,4 +600,3 @@ export function generateStatusPrompt(projectName, projectRoot) {
         .replace(/\[the project's working directory\]/g, projectRoot)
         .replace(/\[one-line summary\]/g, "[fill in based on analysis]");
 }
-//# sourceMappingURL=portfolio.js.map

package/dist/lib/portfolioHtml.d.ts

@@ -4,6 +4,5 @@
  * Blockers-first, production-readiness-focused dashboard.
  * Self-contained HTML with embedded data and styling.
  */
-import { PortfolioReport } from "./portfolio.js";
+import { type PortfolioReport } from "./portfolio.js";
 export declare function generatePortfolioHtml(report: PortfolioReport, outputPath?: string): string;
-//# sourceMappingURL=portfolioHtml.d.ts.map

package/dist/lib/portfolioHtml.js

@@ -534,4 +534,3 @@ document.querySelectorAll('.project-card.has-blockers').forEach(c=>c.classList.a
 </body>
 </html>`;
 }
-//# sourceMappingURL=portfolioHtml.js.map

package/dist/lib/preferences.d.ts

@@ -9,7 +9,7 @@
  * and a `value` (stored in content). They're searchable, decayable,
  * and versioned just like any other memory.
  */
-import { GnosysDB } from "./db.js";
+import { type GnosysDB } from "./db.js";
 export interface Preference {
     key: string;
     value: string;
@@ -21,6 +21,11 @@ export interface Preference {
 }
 /** Well-known preference keys used by the rules generator */
 export declare const KNOWN_PREFERENCE_KEYS: readonly ["commit-convention", "code-style", "llm-provider", "agent-behavior", "testing-approach", "documentation-style", "naming-convention", "error-handling", "review-process", "deploy-workflow"];
+/**
+ * Suggest the closest known preference key for a likely typo, or null.
+ * Returns null for exact known keys and for far custom keys (distance > 3).
+ */
+export declare function suggestPreferenceKey(input: string): string | null;
 /**
  * Set a user preference. Creates or updates a memory in the central DB
  * with scope='user' and category='preferences'.
@@ -46,4 +51,3 @@ export declare function deletePreference(db: GnosysDB, key: string): boolean;
  * Search preferences by keyword.
  */
 export declare function searchPreferences(db: GnosysDB, query: string): Preference[];
-//# sourceMappingURL=preferences.d.ts.map

package/dist/lib/preferences.js

@@ -10,6 +10,7 @@
  * and versioned just like any other memory.
  */
 import { fnv1a } from "./db.js";
+import { levenshtein } from "./setup/configSetRender.js";
 /** Well-known preference keys used by the rules generator */
 export const KNOWN_PREFERENCE_KEYS = [
     "commit-convention",
@@ -23,6 +24,24 @@ export const KNOWN_PREFERENCE_KEYS = [
     "review-process",
     "deploy-workflow",
 ];
+/**
+ * Suggest the closest known preference key for a likely typo, or null.
+ * Returns null for exact known keys and for far custom keys (distance > 3).
+ */
+export function suggestPreferenceKey(input) {
+    if (KNOWN_PREFERENCE_KEYS.includes(input))
+        return null;
+    let best = null;
+    let bestDist = Infinity;
+    for (const candidate of KNOWN_PREFERENCE_KEYS) {
+        const d = levenshtein(input, candidate);
+        if (d < bestDist) {
+            bestDist = d;
+            best = candidate;
+        }
+    }
+    return bestDist <= 3 ? best : null;
+}
 // ─── Preference CRUD ────────────────────────────────────────────────────
 /**
  * Set a user preference. Creates or updates a memory in the central DB
@@ -146,4 +165,3 @@ function formatPreferenceTitle(key) {
         .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
         .join(" ");
 }
-//# sourceMappingURL=preferences.js.map

package/dist/lib/progress.d.ts

@@ -17,7 +17,7 @@
  *     }
  *     onProgress?.({ kind: "done", text: "Pushed 42" });
  */
-export type ProgressEvent = {
+type ProgressEvent = {
     kind: "header";
     text: string;
 } | {
@@ -51,4 +51,4 @@ export interface Progress {
 export declare function createProgress(verbose: boolean): Progress;
 /** Callback shape passed into lib functions that accept progress. */
 export type ProgressCallback = (event: ProgressEvent) => void;
-//# sourceMappingURL=progress.d.ts.map
+export {};

package/dist/lib/progress.js

@@ -89,4 +89,3 @@ export function createProgress(verbose) {
         },
     };
 }
-//# sourceMappingURL=progress.js.map

package/dist/lib/projectIdentity.d.ts

@@ -7,7 +7,7 @@
  * The central DB (~/.gnosys/gnosys.db) mirrors this in the `projects` table.
  * gnosys init creates both the local identity file AND the central DB record.
  */
-import { GnosysDB } from "./db.js";
+import type { GnosysDB } from "./db.js";
 /** Shape of .gnosys/gnosys.json (project identity) */
 export interface ProjectIdentity {
     projectId: string;
@@ -119,4 +119,3 @@ export interface MigrateResult {
  * and registers in the file-based project registry.
  */
 export declare function migrateProject(opts: MigrateOptions): Promise<MigrateResult>;
-//# sourceMappingURL=projectIdentity.d.ts.map

package/dist/lib/projectIdentity.js

@@ -12,6 +12,7 @@ import fsSync from "fs";
 import path from "path";
 import crypto from "crypto";
 import os from "os";
+import { logWarn } from "./log.js";
 const IDENTITY_SCHEMA_VERSION = 1;
 /**
  * Detect which agent IDE is being used.
@@ -115,8 +116,7 @@ export async function createProjectIdentity(projectDir, opts) {
         // operators a hint.
         const existingRow = opts.centralDb.getProject(identity.projectId);
         if (existingRow && existingRow.working_directory !== identity.workingDirectory) {
-            console.error(`gnosys: project ${identity.projectName} moved: ` +
-                `${existingRow.working_directory} → ${identity.workingDirectory}`);
+            logWarn(`project ${identity.projectName} moved: ${existingRow.working_directory} → ${identity.workingDirectory}`, { module: "projectIdentity", op: "registerProject" });
         }
         const dbProject = {
             id: identity.projectId,
@@ -247,6 +247,7 @@ export async function configureClaudeCode(projectDir) {
  */
 async function registerMcpServer(ide, projectDir) {
     try {
+        // Intentional dynamic import — lazy-load setup to avoid a static cycle with setup.ts.
         const { setupIDE } = await import("./setup.js");
         return await setupIDE(ide, projectDir);
     }
@@ -432,8 +433,8 @@ export async function migrateProject(opts) {
         }
     }
     // 4. Copy entire .gnosys/ tree from source to target
-    const { execSync } = await import("child_process");
-    execSync(`cp -a "${sourceStore}" "${targetStore}"`, { stdio: "pipe" });
+    const { execFileSync } = await import("child_process");
+    execFileSync("cp", ["-a", sourceStore, targetStore], { stdio: "pipe" });
     // 5. Count memory markdown files (for reporting)
     const { glob } = await import("glob");
     const memoryFiles = await glob("**/*.md", {
@@ -489,4 +490,3 @@ export async function migrateProject(opts) {
         memoryFileCount: memoryFiles.length,
     };
 }
-//# sourceMappingURL=projectIdentity.js.map

package/dist/lib/projectPaths.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Machine-aware project path resolution (v5.11).
+ *
+ * A project's portable identity is its UUID. Its location is resolved PER
+ * MACHINE, in priority order:
+ *   1. A per-machine override row (project_locations) — used for projects
+ *      that live outside any named root.
+ *   2. join(machine.roots[root_id], rel_path) — the common, zero-touch case
+ *      (machine-independent rel_path + this machine's root).
+ *   3. null — the project is "not on this machine".
+ *
+ * Nothing here reads an absolute path that was persisted by another machine,
+ * so the same shared brain resolves correctly on the Studio, the MBP, etc.
+ */
+import type { GnosysDB, DbProject } from "./db.js";
+import { type MachineConfig } from "./machineConfig.js";
+type LocationSource = "override" | "root" | "none";
+export interface ResolvedProject {
+    project: DbProject;
+    /** Absolute path on this machine, or null when not present here. */
+    absPath: string | null;
+    source: LocationSource;
+}
+/** Resolve a single project's absolute path on this machine (or null). */
+export declare function resolveProjectPath(db: GnosysDB, machine: MachineConfig, projectId: string): string | null;
+/** Resolve a project with provenance, or null if the project is unknown. */
+export declare function resolveProject(db: GnosysDB, machine: MachineConfig, projectId: string): ResolvedProject | null;
+/** Resolve every known project for this machine (for portfolio/federation). */
+export declare function resolveAllProjects(db: GnosysDB, machine: MachineConfig): ResolvedProject[];
+/**
+ * Consumer-facing path for display/use, with a legacy fallback so callers can
+ * adopt machine-aware resolution without breaking pre-migration setups:
+ *
+ *   - machine == null (no machine.json yet)  → working_directory (legacy)
+ *   - resolvable via override/root           → that path
+ *   - legacy row not yet scanned but its     → working_directory
+ *     working_directory exists on this disk
+ *   - otherwise                              → null ("not on this machine")
+ *
+ * Pass `machine` as `readMachineConfig()` (which returns null when absent —
+ * importantly it does NOT create the file as a display side effect).
+ */
+export declare function effectiveProjectPath(db: GnosysDB, project: DbProject, machine: MachineConfig | null): string | null;
+/**
+ * Record where THIS machine keeps a project, choosing the portable storage
+ * automatically:
+ *   - If absPath sits under a named root, store the machine-INDEPENDENT
+ *     root_id + rel_path on the project row (shared across machines) and
+ *     drop any now-redundant per-machine override.
+ *   - Otherwise store a per-machine override row (project_locations).
+ *
+ * working_directory is updated as a machine-local display cache either way.
+ * Used by `gnosys projects scan` and `gnosys init`.
+ */
+export declare function recordLocation(db: GnosysDB, machine: MachineConfig, projectId: string, absPath: string): {
+    mode: "root" | "override";
+    rootId?: string;
+    relPath?: string;
+};
+export {};

package/dist/lib/projectPaths.js

@@ -0,0 +1,99 @@
+/**
+ * Machine-aware project path resolution (v5.11).
+ *
+ * A project's portable identity is its UUID. Its location is resolved PER
+ * MACHINE, in priority order:
+ *   1. A per-machine override row (project_locations) — used for projects
+ *      that live outside any named root.
+ *   2. join(machine.roots[root_id], rel_path) — the common, zero-touch case
+ *      (machine-independent rel_path + this machine's root).
+ *   3. null — the project is "not on this machine".
+ *
+ * Nothing here reads an absolute path that was persisted by another machine,
+ * so the same shared brain resolves correctly on the Studio, the MBP, etc.
+ */
+import fsSync from "fs";
+import { absPathFromRoot, relPathUnderRoot } from "./machineConfig.js";
+/** Resolve a single project's absolute path on this machine (or null). */
+export function resolveProjectPath(db, machine, projectId) {
+    const override = db.getProjectLocation(projectId, machine.machineId);
+    if (override)
+        return override.abs_path;
+    const project = db.getProject(projectId);
+    if (!project)
+        return null;
+    return absPathFromRoot(machine, project.root_id, project.rel_path);
+}
+/** Resolve a project with provenance, or null if the project is unknown. */
+export function resolveProject(db, machine, projectId) {
+    const project = db.getProject(projectId);
+    if (!project)
+        return null;
+    return resolveFor(db, machine, project);
+}
+/** Resolve every known project for this machine (for portfolio/federation). */
+export function resolveAllProjects(db, machine) {
+    return db.getAllProjects().map((project) => resolveFor(db, machine, project));
+}
+function resolveFor(db, machine, project) {
+    const override = db.getProjectLocation(project.id, machine.machineId);
+    if (override)
+        return { project, absPath: override.abs_path, source: "override" };
+    const fromRoot = absPathFromRoot(machine, project.root_id, project.rel_path);
+    return { project, absPath: fromRoot, source: fromRoot ? "root" : "none" };
+}
+/**
+ * Consumer-facing path for display/use, with a legacy fallback so callers can
+ * adopt machine-aware resolution without breaking pre-migration setups:
+ *
+ *   - machine == null (no machine.json yet)  → working_directory (legacy)
+ *   - resolvable via override/root           → that path
+ *   - legacy row not yet scanned but its     → working_directory
+ *     working_directory exists on this disk
+ *   - otherwise                              → null ("not on this machine")
+ *
+ * Pass `machine` as `readMachineConfig()` (which returns null when absent —
+ * importantly it does NOT create the file as a display side effect).
+ */
+export function effectiveProjectPath(db, project, machine) {
+    if (!machine)
+        return project.working_directory || null;
+    const override = db.getProjectLocation(project.id, machine.machineId);
+    if (override)
+        return override.abs_path;
+    const fromRoot = absPathFromRoot(machine, project.root_id, project.rel_path);
+    if (fromRoot)
+        return fromRoot;
+    if (project.working_directory && fsSync.existsSync(project.working_directory)) {
+        return project.working_directory;
+    }
+    return null;
+}
+/**
+ * Record where THIS machine keeps a project, choosing the portable storage
+ * automatically:
+ *   - If absPath sits under a named root, store the machine-INDEPENDENT
+ *     root_id + rel_path on the project row (shared across machines) and
+ *     drop any now-redundant per-machine override.
+ *   - Otherwise store a per-machine override row (project_locations).
+ *
+ * working_directory is updated as a machine-local display cache either way.
+ * Used by `gnosys projects scan` and `gnosys init`.
+ */
+export function recordLocation(db, machine, projectId, absPath) {
+    const now = new Date().toISOString();
+    const under = relPathUnderRoot(machine, absPath);
+    if (under) {
+        db.updateProject(projectId, {
+            root_id: under.rootId,
+            rel_path: under.relPath,
+            working_directory: absPath,
+            modified: now,
+        });
+        db.deleteProjectLocation(projectId, machine.machineId);
+        return { mode: "root", rootId: under.rootId, relPath: under.relPath };
+    }
+    db.setProjectLocation({ project_id: projectId, machine_id: machine.machineId, abs_path: absPath, modified: now });
+    db.updateProject(projectId, { working_directory: absPath, modified: now });
+    return { mode: "override" };
+}

package/dist/lib/projectScan.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Project discovery scan (v5.11).
+ *
+ * Walks each of this machine's named roots for `.gnosys/gnosys.json` files,
+ * and for every project found records its machine-portable location
+ * (root_id + rel_path) or a per-machine override. This is how a new machine
+ * onboards: set its roots in machine.json, then run `gnosys projects scan`.
+ *
+ * The scan is machine-local — it only ever writes paths derived from THIS
+ * machine's roots, so it can run independently on every machine without
+ * clobbering the others.
+ */
+import type { GnosysDB } from "./db.js";
+import type { MachineConfig } from "./machineConfig.js";
+interface ScanEntry {
+    projectId: string;
+    name: string;
+    absPath: string;
+    mode: "root" | "override";
+    /** True if this scan created the project row (first time seen anywhere). */
+    created: boolean;
+}
+export interface ScanResult {
+    roots: string[];
+    entries: ScanEntry[];
+}
+/**
+ * Find every project directory (the parent of a `.gnosys/gnosys.json`) under
+ * `root`, skipping build/vendor noise and not descending into `.gnosys`.
+ * Nested projects (a monorepo with several `.gnosys` stores) are all found.
+ */
+export declare function findProjectDirs(root: string, maxDepth?: number): Promise<string[]>;
+/**
+ * Scan this machine's roots and register every discovered project's location.
+ * Creates the project row from its identity file when first seen anywhere.
+ */
+export declare function scanProjects(db: GnosysDB, machine: MachineConfig, opts?: {
+    roots?: Record<string, string>;
+}): Promise<ScanResult>;
+export {};

package/dist/lib/projectScan.js

@@ -0,0 +1,96 @@
+/**
+ * Project discovery scan (v5.11).
+ *
+ * Walks each of this machine's named roots for `.gnosys/gnosys.json` files,
+ * and for every project found records its machine-portable location
+ * (root_id + rel_path) or a per-machine override. This is how a new machine
+ * onboards: set its roots in machine.json, then run `gnosys projects scan`.
+ *
+ * The scan is machine-local — it only ever writes paths derived from THIS
+ * machine's roots, so it can run independently on every machine without
+ * clobbering the others.
+ */
+import fs from "fs/promises";
+import path from "path";
+import { readProjectIdentity } from "./projectIdentity.js";
+import { recordLocation } from "./projectPaths.js";
+/** Directories never worth descending into when hunting for projects. */
+const SKIP_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", "target", "coverage",
+    ".cache", "vendor", ".next", ".gnosys",
+]);
+/**
+ * Find every project directory (the parent of a `.gnosys/gnosys.json`) under
+ * `root`, skipping build/vendor noise and not descending into `.gnosys`.
+ * Nested projects (a monorepo with several `.gnosys` stores) are all found.
+ */
+export async function findProjectDirs(root, maxDepth = 6) {
+    const found = [];
+    async function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        if (entries.some((e) => e.isDirectory() && e.name === ".gnosys")) {
+            try {
+                await fs.access(path.join(dir, ".gnosys", "gnosys.json"));
+                found.push(dir);
+            }
+            catch {
+                // .gnosys without an identity file — not a registered project
+            }
+        }
+        for (const e of entries) {
+            if (!e.isDirectory() || SKIP_DIRS.has(e.name))
+                continue;
+            await walk(path.join(dir, e.name), depth + 1);
+        }
+    }
+    await walk(path.resolve(root), 0);
+    return found;
+}
+/**
+ * Scan this machine's roots and register every discovered project's location.
+ * Creates the project row from its identity file when first seen anywhere.
+ */
+export async function scanProjects(db, machine, opts = {}) {
+    const roots = opts.roots ?? machine.roots;
+    const entries = [];
+    for (const rootPath of Object.values(roots)) {
+        const dirs = await findProjectDirs(rootPath);
+        for (const dir of dirs) {
+            const identity = await readProjectIdentity(dir);
+            if (!identity)
+                continue;
+            let created = false;
+            if (!db.getProject(identity.projectId)) {
+                const now = new Date().toISOString();
+                db.insertProject({
+                    id: identity.projectId,
+                    name: identity.projectName,
+                    working_directory: dir,
+                    user: identity.user || "unknown",
+                    agent_rules_target: identity.agentRulesTarget ?? null,
+                    obsidian_vault: identity.obsidianVault ?? null,
+                    created: identity.createdAt || now,
+                    modified: now,
+                });
+                created = true;
+            }
+            const res = recordLocation(db, machine, identity.projectId, dir);
+            entries.push({
+                projectId: identity.projectId,
+                name: identity.projectName,
+                absPath: dir,
+                mode: res.mode,
+                created,
+            });
+        }
+    }
+    return { roots: Object.values(roots), entries };
+}

package/dist/lib/recall.d.ts

@@ -20,10 +20,10 @@
  *
  * No LLM calls. No embeddings. Pure index lookup. Sub-50ms.
  */
-import { GnosysSearch } from "./search.js";
-import { GnosysResolver } from "./resolver.js";
-import { GnosysDB } from "./db.js";
-import { RecallConfig } from "./config.js";
+import type { GnosysSearch } from "./search.js";
+import type { GnosysResolver } from "./resolver.js";
+import type { GnosysDB } from "./db.js";
+import type { RecallConfig } from "./config.js";
 export interface RecallResult {
     memories: RecallMemory[];
     totalActive: number;
@@ -31,7 +31,7 @@ export interface RecallResult {
     recallTimeMs: number;
     aggressive: boolean;
 }
-export interface RecallMemory {
+interface RecallMemory {
     id: string;
     title: string;
     category: string;
@@ -79,4 +79,4 @@ export declare function formatRecall(result: RecallResult): string;
  * Format recall results as a concise CLI-friendly output.
  */
 export declare function formatRecallCLI(result: RecallResult): string;
-//# sourceMappingURL=recall.d.ts.map
+export {};

package/dist/lib/recall.js

@@ -286,4 +286,3 @@ export function formatRecallCLI(result) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=recall.js.map

package/dist/lib/remote.d.ts

@@ -9,19 +9,9 @@
  * - Conflict detection via per-memory `modified` timestamps
  * - Skip-and-flag for auto sync; AI-mediated resolution for conflicts
  */
-import { GnosysDB, DbMemory } from "./db.js";
+import { GnosysDB, type DbMemory } from "./db.js";
 import type { ProgressCallback } from "./progress.js";
-export interface RemoteConfig {
-    /** Path to remote .gnosys directory (e.g., /Volumes/nas/gnosys) */
-    path: string;
-    /** Run sync automatically in background */
-    autoSync?: boolean;
-    /** Auto-sync interval in seconds (default 300) */
-    autoSyncIntervalSeconds?: number;
-    /** Conflict handling: skip-and-flag (safe) or newer-wins (aggressive) */
-    conflictStrategy?: "skip-and-flag" | "newer-wins";
-}
-export interface ConflictInfo {
+interface ConflictInfo {
     memoryId: string;
     title: string;
     localModified: string;
@@ -167,13 +157,6 @@ export declare class RemoteSync {
  * upgrade past v5.9.4 stop seeing the stale identifier in panels.
  */
 export declare function getMachineId(localDb: GnosysDB): string;
-/**
- * Resolve a usable hostname for machine-id generation. Honours common
- * env vars first (cross-platform tests can override), then falls through
- * to `os.hostname()` so macOS shells without `HOSTNAME` still get a real
- * name. Returns `"unknown"` only when everything fails.
- */
-export declare function resolveHostname(): string;
 /** Format a sync status for human display */
 export declare function formatStatus(status: RemoteStatus): string;
-//# sourceMappingURL=remote.d.ts.map
+export {};