@sapiom/harness 0.8.9 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,68 @@
 # @sapiom/harness
 
+## 0.9.0
+
+### Minor Changes
+
+- 37ab85b: Agents nested deep under a project root are discovered again: the scan now reaches 8 levels, bounded by a node budget rather than by depth alone.
+
+  `AGENT_PROJECT_SCAN_MAX_DEPTH` was 3, which predated the project-rooted rail — it assumed the directory you opened was roughly the agent's own folder. Under a root you _choose_, depth is ordinary: `<root>/backend/src/agents/<agent>` is four segments down and `<root>/apps/<app>/src/features/<x>/agents/<agent>` is six. Those agents were not found at all and landed in "No workspace" — on a measured root, well over a third of the rail.
+
+  Raising the depth alone would not have been affordable, and the numbers are why. Measured against real roots (macOS/APFS, warm cache, ~22-25 µs per directory entered):
+
+  | root                            | depth 3    | depth 8              | unbounded   |
+  | ------------------------------- | ---------- | -------------------- | ----------- |
+  | a single repo                   | 119 dirs   | 242 dirs · 7 ms      | 242 dirs    |
+  | a monorepo                      | 758 dirs   | 9,016 dirs · 196 ms  | 9,195 dirs  |
+  | a monorepo with worktree copies | 1,298 dirs | 35,489 dirs · 847 ms | 47,544 dirs |
+
+  So cost is linear and predictable in _directories entered_, and that is now what is bounded: `AGENT_PROJECT_SCAN_MAX_NODES` (10,000) for the registry scan, and a tighter `AGENT_PROJECT_WATCH_MAX_NODES` (2,500) for the workspace watcher's fingerprint, which is synchronous and re-runs on a debounce after every save. Pruning harder was the other candidate and does not pay — extending the ignored-directory list with the usual suspects removed 0.5–11% of the directories on those roots.
+
+  The registry and the watcher now share one traversal in `core/agent-project-discovery.ts`, and it is **breadth-first**, which is what makes the budget safe: every level shallower than the cut is complete, so a truncated scan degrades by depth exactly as the fixed cap did — just at a depth the tree's real width chooses instead of one guessed in advance. A scan reports how far it got (`AgentProjectScanBudget.envelopeDepth`) and the registry reconciles only within that, so a bounded scan never mistakes "I did not look there" for "it is gone".
+
+  Termination on a pathological tree does not depend on the cap: subdirectories are filtered on raw dirent type, so a symlink — including one closing a cycle — is never descended into. That is now asserted directly, and `src/core/agent-project-scan.perf.test.ts` measures the cost of both bounds on a deep monorepo fixture next to the depth-3 baseline.
+
+- b66ff0e: Show every registry-known agent contained by an Agent Studio Project in that Project's graph, including local-only and disconnected agents, while preserving partial inventory with path-free warnings.
+- b66ff0e: Detect literal direct agent `run` and `launch` relationships in Agent Studio Project graphs, distinguish blocking and asynchronous modes, and report dynamic targets without drawing misleading connectors.
+
+  The syntax-only detector recognizes the exact `ctx.sapiom.agents` form plus proven named `agents` aliases and legacy `orchestrations.launch` imports from `@sapiom/tools`. Unlike the previous text match, unrelated local objects, custom context names, destructured namespaces, namespace imports, and optional chains are not inferred. The existing per-agent Canvas remains launch-only, so blocking `agents.run` calls retain their existing capability chip there until that Canvas supports blocking relationship nodes.
+
+  TypeScript is now a Harness runtime dependency, constrained to the tested 5.9 compiler-API band, because published Harness and desktop servers execute the syntax parser locally.
+
+- 37ab85b: Agent Studio's left rail is rebuilt around where an agent **is** and what it is **related to**, and it can now move an agent's directory on disk.
+
+  **Two axes, chosen from the rail's own `Group by` control.** _Project_ files every agent under the project roots that contain it — the folder you opened, a folder you have a session in — with the branching directories between them as rows. An agent inside two roots you both opened appears under both; they are two contexts, and the old longest-prefix rule made the shallower project silently lose agents it plainly contained. _Group_ is the arrangement you make yourself: named groups per project root, seeded from the launch edges between agents and then yours to edit. The **Deployment axis is retired** — an agent's deploy state is a badge on its row, not a place it lives.
+
+  **`Remove project`** takes a root off the rail without touching anything on disk.
+
+  **`POST /api/agents/move` renames a directory in your working tree.** This is the Project axis's drag, and it is a real filesystem move, not a display preference: dropping an agent on a folder relocates that agent's directory there — `git mv` when the directory is tracked in a git repo, a plain rename otherwise. Nothing inside `sapiom.json` is rewritten, live sessions whose cwd sat inside the moved tree follow it, and the endpoint refuses on its own findings (a destination that exists, a destination inside the source, a `from` that is not a registered agent, or a destination outside the folders the rail shows) rather than trusting the caller.
+
+  **New local REST surfaces** on the same `127.0.0.1` boot-token-gated `/api` mount as the rest:
+
+  - `GET`/`PUT`/`DELETE /api/studio-rail` — the stored Group-axis arrangement, one `.sapiom/studio-rail.json` per project root. It is a committable file, so a team can share an arrangement. Writable roots are exactly the roots the rail can show.
+  - `GET /api/studio-rail/launch-edges` — which agents launch which, across every registered agent, used to seed groups.
+  - `POST /api/agents/move` — above.
+
+  **Stored UI state resets once on upgrade, deliberately.** The rail's preferences moved to keys that can name a project, a directory or a group rather than only a cwd: `collapsedCwds` → `collapsedKeys` (namespaced `project:` / `dir:` / `group:`) and `railGrouping` → `railAxis`. The old values are not migrated — they describe a rail that no longer exists — so after upgrading, every fold is open and the axis is back to _Project_. Set them again once and they stick.
+
+  There is no migration for project roots either: every directory already in your recents, and every live session's cwd, becomes a project row. Nothing is discarded, and `Remove project` is how the list gets shorter.
+
+- 37ab85b: A canvas board can now be read by agent path, with no session involved: `GET /api/workflows/:path/graph`.
+
+  The canvas was reachable only at `/canvas/:harnessSessionId/`, resolved by the session's current binding — so an agent that had never hosted a session had no board, and you could not look at agent F's board while working in agent B's session.
+
+  This adds a second, session-free entry point onto the _same_ derivation. `deriveWorkflowCanvas` is extracted out of the render-file write path and shared by both, so the document this route returns is byte-identical to the render a bound session's canvas serves for the same workflow. Nothing is written to disk.
+
+  `:path` is the agent's absolute directory, URI-encoded into one segment (`encodeURIComponent(agentPath)`), matching `/api/workflows/:id/input-contract`. It sits behind the usual `/api` boot-token middleware, so it is a `fetch` target rather than an `<iframe src>`.
+
+  Failure modes are deliberately distinct: `400` for a blank, relative or `..`-carrying path (and for a `sapiom.json` symlinked out of the project), `404` only for a path that is not a registered workflow, and `200` with `status: "empty" | "preparing" | "error" | "ok"` for everything else — a missing `sapiom.json` is an empty board, never a missing route.
+
+  Full contract: `packages/harness/docs/agent-canvas-graph.md`.
+
+- b66ff0e: Keep Agent Studio Project dependency graphs current with revisioned lifecycle snapshots, per-agent relationship caching, and last-good stale or degraded presentation during refresh failures. Opening a Project graph arms one additional session-independent recursive watcher for that Project; inventory fingerprints and the polling fallback run asynchronously so wide Projects do not block the Studio server loop.
+- b66ff0e: Render Project dependency graphs as full-main Agent Studio destinations with deterministic non-linear layout, routed invocation modes, stable per-Project pan and zoom controls, and exact agent-card navigation from both rail axes.
+- b66ff0e: Add a cached local Project dependency graph to Agent Studio. Project labels on both the Project and Group axes open the graph; use the dedicated chevron to expand or collapse the Project's agents.
+
 ## 0.8.9
 
 ### Patch Changes

package/README.md

@@ -21,7 +21,9 @@ system prompt, in whatever project directory you choose.
   Agent Studio only configures it. Multiple sessions, resumable chat history.
 - **Agents rail** — agent projects (`sapiom.json`) discovered and
   tracked, with one-click local test run, deploy, production run, and
-  open-in-Sapiom actions.
+  open-in-Sapiom actions. How that discovery is rooted and bounded, how a
+  newly-created agent gets registered, and how a stale entry leaves:
+  [docs/agent-discovery.md](docs/agent-discovery.md).
 - **Canvas** — a live pane that renders static HTML your agent writes to
   `.sapiom/canvas/` (visualize your agent, your docs, anything), plus a
   preview mode for dev servers the agent starts.
@@ -49,6 +51,14 @@ Architecture: a single Node process (Express + ws + node-pty) serves the built
 SPA, a small REST API, terminal WebSocket streams, and the local telemetry
 ingest endpoint. The interface contract lives in `src/shared/types.ts`.
 
+HTTP contracts that need more than a type to use are written up under `docs/`:
+
+- [`docs/agent-canvas-graph.md`](docs/agent-canvas-graph.md) — the session-free
+  `GET /api/workflows/:path/graph` Canvas route keyed by an agent's path.
+- [`docs/workspace-system-graph.md`](docs/workspace-system-graph.md) — the
+  Project dependency-graph endpoints, lifecycle states, cache signal, warnings,
+  and `system-graph.changed` event.
+
 ## Testing
 
 Three tiers — run whatever fits your change:

package/dist/core/agent-project-discovery.d.ts

@@ -1,4 +1,144 @@
-export declare const AGENT_PROJECT_SCAN_MAX_DEPTH = 3;
+/**
+ * One discovery contract for Agent Studio's registry, live workspace watcher,
+ * and folder picker. Keeping marker parsing and traversal policy here prevents
+ * the three surfaces from disagreeing about whether a directory is an agent
+ * project.
+ */
+import * as fs from "node:fs";
+/**
+ * How deep a scan looks for agent projects beneath a chosen root.
+ *
+ * This was 3, which predated the project-rooted rail: it assumed the root the
+ * user opened was more or less the agent's own folder. Under a chosen project
+ * root, depth is normal — `<root>/backend/src/agents/<agent>` is four segments
+ * down and `<root>/apps/<app>/src/features/<x>/agents/<agent>` is six. At 3
+ * those agents are not found at all and file under "No workspace"; on a
+ * measured root that was well over a third of the rail.
+ *
+ * 8 leaves headroom above the deepest realistic layout without becoming a walk
+ * of the user's home directory. It is NOT what keeps the scan cheap — see
+ * AGENT_PROJECT_SCAN_MAX_NODES. What depth still buys is (a) a pathological
+ * deep chain terminating in 8 steps rather than by exhausting a node budget,
+ * and (b) a *deterministic* outer envelope, which reconciliation needs: the
+ * registry may only forget a project it can prove it would have looked for.
+ */
+export declare const AGENT_PROJECT_SCAN_MAX_DEPTH = 8;
+/**
+ * The bound that actually governs scan cost: how many directories one walk may
+ * enter. Depth alone cannot do this job, and the numbers are why.
+ *
+ * Measured on this machine (macOS/APFS) against real roots on a real install,
+ * per directory entered = one marker `lstat` + one `readdir`, warm cache
+ * ~22-25 us/dir at every depth:
+ *
+ *   root                    depth 3         depth 8            unbounded
+ *   a single repo             119 dirs         242 dirs   7 ms    242 dirs
+ *   ~/sapiom/sapiom-js        758 dirs       9,016 dirs 196 ms  9,195 dirs
+ *   ~/sapiom/Sapiom         1,298 dirs      35,489 dirs 847 ms 47,544 dirs
+ *
+ * So raising the depth cap alone makes a 32 ms scan an 847 ms one on a root a
+ * user would plausibly open, and the watcher below pays that synchronously on
+ * a debounce. Cost is linear and predictable in directories entered, so that
+ * is what we bound.
+ *
+ * Pruning harder by NAME was the other candidate and does not pay: extending
+ * the ignored-directory list with the usual suspects (`.venv`, `target`,
+ * `vendor`, `coverage`, `.turbo`, `__pycache__`, `out`, ...) removed 0.5-11% of
+ * the dirs on the roots above. What is actually there is source directories
+ * and, on the biggest root, 42,163 of 47,544 dirs in git worktree copies of the
+ * repo itself.
+ *
+ * That second half IS now reachable, and not by name: see
+ * {@link isForeignRepositoryRoot}. A walk that stops at a foreign checkout does
+ * not enter those 42,163 directories at all, which is why the node budget is no
+ * longer what ends a scan of a real root — the repository is. The budget stays
+ * as the backstop for a tree that is genuinely one enormous checkout.
+ *
+ * **The tradeoff, stated plainly:** past the budget a scan is incomplete, and
+ * an agent below the cut is not discovered on that pass. The walk is therefore
+ * breadth-first, so the budget degrades by *depth* — every level below the cut
+ * is complete, which is exactly the guarantee the old fixed cap gave, just at a
+ * depth chosen by the tree's real width instead of guessed in advance. Callers
+ * learn how far they may trust the result from
+ * {@link AgentProjectScanBudget.envelopeDepth}; nothing beyond it is reconciled
+ * away as missing.
+ *
+ * 10,000 dirs ~= 240 ms warm for the async registry scan, which runs when a
+ * session is created or the user asks — and covers a real monorepo project root
+ * outright (sapiom-js: 9,016).
+ */
+export declare const AGENT_PROJECT_SCAN_MAX_NODES = 10000;
+/**
+ * The watcher fingerprint's budget, deliberately tighter than the scan's.
+ *
+ * `snapshotWorkspaceWorkflows` is synchronous and re-runs on a 250 ms debounce
+ * after any file change under the session's cwd, so its cost lands on the event
+ * loop while the user is typing. 2,500 dirs ~= 60 ms warm, which is the same
+ * order as what depth-3 cost on the widest real root measured (1,298 dirs /
+ * 32 ms): the watcher gets the full depth on an ordinary project and gets no
+ * slower on a huge one. A truncated fingerprint means a *deep* structural
+ * change may not arm a rescan until some shallower event does; discovery depth
+ * itself is the registry scan's budget, not this one.
+ */
+export declare const AGENT_PROJECT_WATCH_MAX_NODES = 2500;
+/**
+ * The entry name that marks a directory as its own repository checkout: a
+ * `.git` DIRECTORY in an ordinary clone, a `.git` FILE in a git worktree or a
+ * submodule. Both forms are one entry called `.git`, which is all this policy
+ * needs to know.
+ */
+export declare const REPOSITORY_MARKER = ".git";
+/**
+ * Whether a directory we just listed is the root of a repository other than
+ * the one the scan started in — the boundary a walk does not cross.
+ *
+ * **Why breadth, not depth, was the real bound.** The scan that produced this
+ * install's 88-row registry was rooted one level too high, at `~/sapiom`. From
+ * there the walk crossed into twelve sibling checkouts nobody had opened, and
+ * kept going until the node budget cut it off:
+ *
+ * Measured on that install (macOS/APFS, warm cache) at the shipped 10,000-node
+ * budget. Each cell is agents registered / distinct names among them /
+ * directories entered / wall clock:
+ *
+ *   root                      today                          with the boundary
+ *   ~/sapiom/wf-demo-testing   10 / 10,     17 dirs,   0 ms   10 / 10,    17 dirs,   0 ms
+ *   ~/sapiom                   88 / 65, 10,000 dirs, 239 ms   68 / 64,   408 dirs,   8 ms
+ *                              TRUNCATED at depth 5           complete
+ *   ~/sapiom/sapiom-js         25 /  2,  9,016 dirs, 233 ms    2 /  2,   444 dirs,   8 ms
+ *   ~/sapiom/Sapiom             0 /  0, 10,000 dirs, 200 ms    0 /  0, 5,408 dirs, 107 ms
+ *                              TRUNCATED at depth 5           complete
+ *
+ * The `sapiom-js` row is the whole argument in one line. Of the 25 agents a
+ * scan of that repo used to register, 24 were the SAME agent — one e2e fixture
+ * — reachable once per git worktree under `.trees/`. Two were real. Read the
+ * name counts down the column: the rule barely changes how many *distinct*
+ * agents a scan finds, and collapses how many *rows* it writes.
+ *
+ * Letting the node budget off its leash widens the gap rather than closing it:
+ * uncapped, `~/sapiom` is 141 agents across 83,969 directories in 6.8 s — and
+ * still only 73 distinct names. Depth was never what was wrong.
+ *
+ * **The cost, stated plainly.** Across that pair, 5 distinct agents are lost at
+ * `~/sapiom` (73 names uncapped vs 68 bounded), and `~/sapiom/Sapiom` loses the
+ * single agent it has. Every one of them lives inside a checkout below the scan
+ * root, and every one is registered the moment that checkout is itself the root
+ * — opened as a project, hosting a session, or named to
+ * `POST /api/workflows/scan`. That is the trade the user asked for in as many
+ * words: "It's okay if we don't fully scan."
+ *
+ * It also costs nothing to evaluate: the walk has already listed the directory
+ * to find its subdirectories, so the check reads a `Dirent[]` already in hand —
+ * no extra syscall.
+ *
+ * **What it deliberately does NOT do.** A nested checkout that IS an agent (its
+ * own `sapiom.json` at the top) is still registered: the marker is inspected
+ * before the boundary is considered, and a marker stops the walk anyway. Only
+ * a checkout that merely *contains* agents is left alone. So `~/agents/foo`
+ * (one repo per agent) is found; `~/src/some-other-monorepo/**` is not, unless
+ * the user points a scan at that monorepo.
+ */
+export declare function isForeignRepositoryRoot(entries: fs.Dirent[]): boolean;
 export interface AgentProjectMarker {
     definitionId?: number | null;
     /** The agent's `defineAgent({ name })`, cached by `link`. */
@@ -29,4 +169,98 @@ export declare function readAgentProjectMarkerSync(dir: string): AgentProjectMar
 export declare function inspectAgentProjectMarkerSync(dir: string): AgentProjectMarkerInspection;
 export declare function readAgentProjectMarker(dir: string): Promise<AgentProjectMarker | null>;
 export declare function inspectAgentProjectMarker(dir: string): Promise<AgentProjectMarkerInspection>;
+/** Overridable halves of the traversal policy — tests and benchmarks vary these. */
+export interface AgentProjectScanLimits {
+    maxDepth: number;
+    maxNodes: number;
+}
+/**
+ * One walk's traversal allowance, and its report on what it managed to cover.
+ *
+ * A budget is single-use: it accumulates `visited` as the walk runs, so pass a
+ * fresh one per walk (the walkers below default to one). Callers that care
+ * about cost or completeness construct it themselves and read it afterwards —
+ * that is also how the perf benchmark measures nodes visited without the
+ * scanner growing a second, parallel counting path.
+ */
+export declare class AgentProjectScanBudget implements AgentProjectScanLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    /** Directories entered (marker inspected), root included. */
+    visited: number;
+    /** The depth at which `maxNodes` stopped the walk, or null if it never did. */
+    truncatedAtDepth: number | null;
+    /**
+     * Foreign repository roots the walk stopped at rather than entering.
+     *
+     * Rides on the budget for the same reason `visited` does: a caller holding the
+     * budget can read what the walk actually did without every intermediate
+     * signature having to forward it. Load-bearing for the UI — a scan of a
+     * non-repo folder full of clones finds nothing, and only this list can tell
+     * "there is nothing here" apart from "I did not look in there".
+     */
+    repositoryBoundaries: string[];
+    constructor(limits?: Partial<AgentProjectScanLimits>);
+    get truncated(): boolean;
+    /**
+     * The deepest level this walk enumerated *in full* — how deep its results may
+     * be trusted as complete, and therefore how deep a caller may reconcile a
+     * previously-known project away as gone. `maxDepth` for a walk that finished;
+     * one level above the cut for a walk the node budget stopped, because that
+     * level is the only incomplete one (the walk is breadth-first).
+     */
+    get envelopeDepth(): number;
+    /** Charges one directory. False (and records the cut) once spent. */
+    admit(depth: number): boolean;
+}
+/** What the walk should do with a directory it just entered. */
+export type AgentProjectWalkAction = 
+/** Record it and go no deeper — it is a project, or an opaque subtree. */
+"stop"
+/** Not a project: enumerate its subdirectories and keep going. */
+ | "descend";
+export interface AgentProjectWalkVisitor<Action = AgentProjectWalkAction | Promise<AgentProjectWalkAction>> {
+    /** Every directory entered, root first, shallowest level first. */
+    onDirectory(dir: string, depth: number): Action;
+    /** `dir`'s entries could not be listed, and not because it is gone. */
+    onUnreadable?(dir: string, depth: number): void;
+    /**
+     * `dir` is a repository checkout of its own and was not descended into — see
+     * {@link isForeignRepositoryRoot}. Reported so a caller can say what it
+     * declined to look inside rather than silently returning a short list.
+     */
+    onRepositoryBoundary?(dir: string, depth: number): void;
+}
+/** Traversal policy a caller may vary; the defaults are what ships. */
+export interface AgentProjectWalkOptions {
+    /**
+     * Descend into nested repository checkouts as if they were ordinary
+     * directories — the pre-boundary behaviour. Off by default, and only ever
+     * turned on to MEASURE the difference (see agent-project-scan.perf.test.ts).
+     * Turning it on in a product path re-opens the accumulation this boundary
+     * exists to stop.
+     */
+    crossRepositoryBoundaries?: boolean;
+}
+/**
+ * Breadth-first, depth- and node-bounded traversal beneath `root` — the one
+ * traversal policy the registry and the workspace watcher both run, so they
+ * cannot disagree about which directories a scan of a given root covers.
+ *
+ * Breadth-first is load-bearing rather than incidental: it is what makes the
+ * node budget degrade by depth (see AGENT_PROJECT_SCAN_MAX_NODES). Every level
+ * shallower than `budget.envelopeDepth` is complete no matter where the budget
+ * ran out, which keeps the generalized bound a superset of the fixed depth cap
+ * it replaces.
+ *
+ * Returns the budget so a caller can read `visited` / `envelopeDepth` off it.
+ */
+export declare function walkAgentProjectTree(root: string, visitor: AgentProjectWalkVisitor<AgentProjectWalkAction>, budget?: AgentProjectScanBudget, options?: AgentProjectWalkOptions): AgentProjectScanBudget;
+/**
+ * Async twin of {@link walkAgentProjectTree}, for callers that must not block
+ * the event loop on a wide tree. Same order, same bounds, same decisions — so
+ * the two produce identical results on the same tree with the same budget,
+ * which the watcher's sync/async fingerprint pair depends on.
+ */
+export declare function walkAgentProjectTreeAsync(root: string, visitor: AgentProjectWalkVisitor<AgentProjectWalkAction | Promise<AgentProjectWalkAction>>, budget?: AgentProjectScanBudget, options?: AgentProjectWalkOptions): Promise<AgentProjectScanBudget>;
 //# sourceMappingURL=agent-project-discovery.d.ts.map

package/dist/core/agent-project-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-project-discovery.d.ts","sourceRoot":"","sources":["../../src/core/agent-project-discovery.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAW9C,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GACpC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAE,GAC/C;IAAE,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,YAAY,CAAA;CAAE,CAAC;AAEpD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElE;AAED,4EAA4E;AAC5E,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,GACV,kBAAkB,GAAG,IAAI,CAS3B;AA6BD,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,GACV,kBAAkB,GAAG,IAAI,CAG3B;AAED,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,GACV,4BAA4B,CAqB9B;AAED,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAGpC;AAED,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,4BAA4B,CAAC,CAuBvC"}
+{"version":3,"file":"agent-project-discovery.d.ts","sourceRoot":"","sources":["../../src/core/agent-project-discovery.ts"],"names":[],"mappings":"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"}