workspai 0.79.0 → 0.79.1

package/README.md

@@ -7,149 +7,96 @@
 
 ## Give your AI agent the system, not just the repository
 
-**Your AI coding agent wastes time guessing your project structure. Workspai fixes that.**
+**Less rediscovery. More time building.**
+
+Give your coding agent a system map, source references, and saved project context.
+Use the same evidence yourself to understand the code and decide what to do next.
 
 > One workspace. One truth. Humans and AI aligned.
 
 ## Workspace Intelligence for software systems
 
-Workspai is an open-source CLI that gives people and AI tools one governed view
-of the software system they are changing.
-
-```bash
-npx workspai adopt .
-npx workspai workspace intelligence run --for-agent generic
-```
-
-Two commands. Your project gains a bounded, evidence-backed system view:
-
-### Before vs After
-
-| Before Workspai                              | After Workspai                                        |
-| -------------------------------------------- | ----------------------------------------------------- |
-| Agent scans thousands of files for context   | Agent starts from bounded entry and context artifacts |
-| No dependency map between services           | Searchable graph with source-level proof              |
-| Broken test blocks release, no one knows why | Doctor localizes the blocker and next target          |
-| Every AI session starts from scratch         | Sessions resume from durable evidence                 |
-
-Here is what you get:
-
-| What it produces       | Why it matters                                                                                                                                  |
-| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Workspace Model**    | A canonical inventory of registered projects, detected runtimes, frameworks, and proven dependencies                                            |
-| **Knowledge Graph**    | Searchable relationships between projects, backed by source-level proof                                                                         |
-| **Health & Readiness** | Doctor checks, verification gates, and release posture based on evidence, not guesses                                                           |
-| **Agent Context**      | Bounded, focused instructions so AI tools read what they need, not the entire repo                                                              |
-| **Agent Rules**        | Ready-to-use grounding for Cursor, Copilot, Claude, Codex, Gemini, and more                                                                     |
-| **Agent Skills**       | Runtime-, polyglot-, test-, and delivery-aware operational playbooks, with portable `SKILL.md` projections where the host supports Agent Skills |
-| **MCP Server**         | Versioned read-oriented tools for querying evidence, graph, blockers, and context live                                                          |
-
-`generic` is the safe default when you do not yet know which agent will use the
-project: Workspai builds one portable context and prepares discovery adapters
-for every supported host, without duplicating the Model or Graph.
+Workspai is an open-source CLI that helps you understand software and prepare
+focused context for Codex, Claude Code, Cursor, and GitHub Copilot.
+The system map and checks do not require an AI API key.
 
-### What the output looks like
-
-The canonical workspace owns the Model, Graph, context, evidence index, and
-Skills. Each linked project keeps only its portable entry, scoped context, and
-workspace binding:
-
-```text
-your-workspace/
-├── .workspai/
-│   ├── reports/                       # Model, Graph, verification, context
-│   └── skills/                        # evidence-derived playbooks
-├── AGENTS.md · .codex/ · .cursor/ · .claude/ · .github/ · .agents/
-└── project/.workspai/
-    ├── agent-entry.v1.json            # portable project entry
-    └── workspace-link.local.json      # machine-local binding
-```
-
-Your agent starts with `agent-entry.v1.json`, compact workspace context, and the
-Skills index; it then retrieves task-scoped Graph evidence and targeted source.
-
-![Workspai CLI adopting and analyzing the gRPC repository](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspai-grpc-readme-cli.gif)
-
-[Get started](#start-in-two-minutes) ·
-[See what you get](#what-happens-after-the-first-run) ·
-[How it works](#how-workspace-intelligence-works) ·
+[Quickstart](#start-in-two-minutes) ·
+[Agent setup](docs/agent-entry.md) ·
 [Documentation](docs/README.md)
 
 ## Start in two minutes
 
-### Use an existing project
-
-Open the project and adopt it:
+From the directory of your existing project:
 
 ```bash
-cd /absolute/path/to/project
 npx workspai adopt .
+npx workspai workspace intelligence run --for-agent generic
 ```
 
-The project stays where it is. Workspai creates or reuses a minimal workspace
-in the default system location and records a validated local link.
+Requires **Node.js 20.19+ and npm**. Your source stays in place. Workspai adds
+project metadata and agent entry files, creates or reuses a linked workspace,
+and saves shared reports there. `generic` prepares context for supported agent
+hosts without requiring you to choose one yet. Run time depends on your project.
 
-Stay in the same project directory and run Workspace Intelligence:
+**Read the terminal summary:** which projects were detected, where context was
+saved, and which checks need attention. Rerun the intelligence command after
+changes to refresh the saved view.
 
-```bash
-npx workspai workspace intelligence run --for-agent generic
-```
+![Workspai adopting and analyzing the gRPC repository](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspai-grpc-readme-cli.gif)
 
-Workspai now knows which workspace owns the project. You only need
-`--workspace <path>` when a moved or ambiguous binding cannot be resolved.
-The shorter command is intended for a human-readable first run. CI, agents, and
-other machine consumers should use the strict JSON form shown in
-[How Workspace Intelligence works](#how-workspace-intelligence-works).
+### Create a workspace or a new project
 
-### Start new software
-
-Use the guided flow:
+Build from a starter instead of setting up every project by hand:
 
 ```bash
 npx workspai create
 ```
 
-Choose whether to create a workspace, scaffold a project, or add existing
-software. Project starters are grouped as Backend, Frontend, Desktop, AI
-Agent, AI Gateway, Extension, and Gaming.
+- **Create a workspace:** organize your projects with shared context and checks.
+- **Create a project:** pick a category, kit, and name; scaffold and register it.
+- **Add existing software:** connect a local project, Git repository, or workspace.
 
-```bash
-# Optional global installation
-npm install -g workspai
-workspai --version
-```
+| Build… | Choose from starters such as… |
+| --- | --- |
+| A backend | FastAPI, NestJS, Go, ASP.NET Core, Rust Axum, Spring Boot |
+| A frontend | Next.js, React + Vite, Vue, Angular, Astro, SvelteKit |
+| An AI agent | Google ADK, OpenAI Agents SDK, Microsoft Agent Framework |
+| A model gateway | OpenRouter with Python or TypeScript |
+| A desktop app or extension | Browse the matching category in the picker |
+
+The picker shows each kit's support status.
+
+Install once with `npm install -g workspai` to use `workspai create`.
+The optional `wspai` package provides the shorter `wspai create` command.
+
+[All workspace and project setup options](docs/creating-workspaces-and-projects.md)
 
 ## Give your agent a goal, not an open-ended prompt
 
-Describe the outcome in plain language from the adopted project:
+From your linked project:
 
 ```bash
 npx workspai goal "Raise test coverage to 85%" --for-agent generic
-npx workspai goal "Raise test coverage to 85%" --runtime cpp --for-agent generic
-npx workspai goal "Add retry with exponential backoff" --for-agent generic
 ```
 
-Workspai turns it into a bounded, evidence-backed handoff:
+Workspai prepares scope, acceptance criteria, and an agent handoff.
+The agent gets a focused objective, not permission to scan or change everything.
+The command does not edit source or claim that the outcome is complete.
+Your agent performs the implementation; verification checks the result.
 
-```text
-Intent → project scope → proof-backed context → governed plan → safe execution
-```
+[Goal guide, including multi-project and runtime choices](docs/goal-packs.md)
 
-The agent gets a focused objective, not permission to scan or change
-everything. Workspai keeps approval, verification, and rollback under CLI
-control. The command prepares governed work; it does not edit source or claim
-that the outcome is complete. Exact coverage, dependency-security, and release
-Goals have deterministic CLI verifiers; other outcomes retain CLI safety and
-rollback while the consumer performs an evidence-backed outcome review.
-Multi-project scope and polyglot runtime choices are explicit. Interactive
-users get bounded choices from the canonical Workspace Model; automation gets
-a machine-readable decision and can use `--scope` and `--runtime`.
+## Make every agent change carry proof
 
-[Learn how Goal Packs work](docs/goal-packs.md)
+Need an audit trail? **Proof-Carrying Change** connects the goal to authorized
+changes, observed effects, and independent verification.
+Prediction can guide work but can never prove its own result.
 
-## Make every agent change carry proof
+<details>
+<summary>Example change lifecycle — after creating a Goal</summary>
 
-For source-changing work, begin a Goal-bound change before mutation:
+Begin before the first source change; replace placeholders with your change ID
+and actual effect receipt. See the guide for receipt creation and the full loop.
 
 ```bash
 npx workspai change begin --json
@@ -159,186 +106,120 @@ npx workspai change verify --change <change-id> --strict --json
 npx workspai change capsule validate --change <change-id> --json
 ```
 
-The resulting capsule binds intent, baseline architecture, authorization,
-observed effects, predicted-versus-actual Graph changes, verification receipts,
-and remaining uncertainty. Prediction can guide work but can never prove its
-own result. [Learn how Proof-Carrying Change works](docs/proof-carrying-change.md).
+![Workspai records and verifies a Goal-bound change](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspai-pcc-readme-cli.gif)
 
-![Workspai creates a Goal-bound Proof-Carrying Change before source mutation](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspai-pcc-readme-cli.gif)
+</details>
 
-## What happens after the first run
+[Record and verify a change](docs/proof-carrying-change.md)
 
-The key outputs for each audience are:
+## What happens after the first run
 
-| Audience            | What to read                                                                 |
-| ------------------- | ---------------------------------------------------------------------------- |
-| **AI agent**        | `agent-entry.v1.json` (project) → `workspace-context-agent.json` (workspace) |
-| **Developer**       | Terminal summary, or `workspace-explain-last-run.json` for diagnosis         |
-| **CI / automation** | `workspace-verify-last-run.json` (exit code 0 = pass, 2 = blocked)           |
-| **MCP client**      | `workspace mcp serve` (versioned read-oriented tools over JSON-RPC)          |
-| **IDE extension**   | Same artifacts + watch events                                                |
+Your project keeps its agent entry and scoped context. The linked workspace
+keeps shared reports under `.workspai/reports/`. You can stay in the project terminal.
 
-An agent can prove that it entered through governed evidence before scanning
-the repository:
+To check the entry before handing work to an agent:
 
 ```bash
-npx workspai agent bootstrap --for-agent codex --strict --json
+npx workspai agent bootstrap --for-agent generic --strict --json
 ```
 
-The receipt validates workspace membership, artifact integrity, Model/Graph
-freshness, and the active Goal handoff. A blocked receipt prevents architecture
-claims; it never falls back silently to a broad source scan. [Learn about
-canonical-first agent entry](docs/agent-entry.md).
-
-A blocked result is useful evidence, not a crashed command. Workspai names what
-is missing or failing and keeps the generated reports available for inspection.
+A blocked result is useful evidence, not a crashed command.
+Inspect the named check and its report before claiming readiness.
+[Agent setup and entry checks](docs/agent-entry.md)
 
 ## How Workspace Intelligence works
 
-```text
-Workspace sources
-       │
-       ▼
-Canonical Workspace Model
-       │
-       ▼
-Evidence-backed Knowledge Graph
-       │
-       ▼
-Impact · Doctor · Verify · Context · Explain
-       │
-       ▼
-Humans · CI · IDEs · MCP · AI agents
-```
-
-The **Workspace Model is the canonical source of truth**. The Knowledge Graph is
-a **derived, revision-bound representation** of that model. It can add
-proof-backed detail without becoming a second source of truth or mutating the
-model that authorized the run.
+Workspai reads the workspace, builds a map, checks evidence, and prepares context.
+The **Workspace Model is the canonical source of truth**. The graph is a
+**derived, revision-bound representation**; providers enrich it without rewriting
+the model during the same run.
 
-A missing relationship means **not proven by current evidence**, not "these
-projects are independent."
+A missing relationship means **not proven**, not "these projects are independent."
 
-The full contract-backed chain is:
+<details>
+<summary>The full intelligence chain and CI command</summary>
 
 ```text
 Model → Diff → Impact → Doctor + Contract Verify + Analyze → Readiness
       → Verify → Context → Agent Sync → Explain
 ```
 
-Run it with:
-
 ```bash
 npx workspai workspace intelligence run --for-agent generic --strict --json
 ```
 
-`pipeline --json --strict` is the broader release and governance workflow. It
-complements this chain; it does not replace it.
+`pipeline --json --strict` is the broader release/governance workflow and
+complements this runner.
+
+</details>
 
-The deterministic model, graph, and checks do not require an AI API key.
+[Runner behavior and exit codes](docs/workspace-intelligence-runner.md)
 
-### See the evidence-backed graph
+<details>
+<summary>See a workspace graph</summary>
 
-The graph connects projects, APIs, packages, tests, infrastructure, ownership,
-and runtime topology only when current evidence supports the relationship.
-Every visible relationship can retain proof, while missing relationships stay
-explicitly unproven.
+![Interactive view of a Workspai workspace graph](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspace-graph.gif)
 
-![Interactive 3D view of a real Workspai workspace graph](https://raw.githubusercontent.com/chistiq/workspai/main/packages/cli/docs/workspace-graph.gif)
+[Explore the graph](docs/workspace-knowledge-graph.md)
 
-[Query, explain, and export the graph](docs/workspace-knowledge-graph.md)
+</details>
 
 ## Everyday workflows
 
-| Goal                                        | Command                                                                                          |
-| ------------------------------------------- | ------------------------------------------------------------------------------------------------ |
-| Use guided setup                            | `npx workspai create`                                                                            |
-| Link a project without moving it            | `npx workspai adopt .`                                                                           |
-| Initialize workspace and project dependencies | `npx workspai init`                                                                              |
-| Refresh the complete system view            | `npx workspai workspace intelligence run --for-agent generic --strict --json`                    |
-| Turn an outcome into governed work          | `npx workspai goal "Raise test coverage to 85%"`                                                 |
-| Prove an agent change from intent to verify | `npx workspai change begin --json`                                                               |
-| Ground an agent before source discovery     | `npx workspai agent bootstrap --for-agent generic --strict --json`                               |
-| Copy or clone a project into a workspace    | `npx workspai import <path-or-git-url> --workspace <path>`                                       |
-| Diagnose project or workspace health        | `npx workspai doctor project` / `npx workspai doctor workspace`                                 |
-| Observe CLI and Studio activity             | `npx workspai live --once --json --projection board`                                             |
-| Ask a focused architecture question         | `npx workspai workspace graph search "authentication service" --limit 12 --json`                 |
-| Verify current evidence                     | `npx workspai workspace verify --strict --json`                                                  |
-| Inspect a governed repair before execution  | `npx workspai workspace repair capabilities --json`                                              |
-| Refresh agent and IDE context               | `npx workspai workspace agent-sync --write --preset enterprise --json`                           |
-| Run the broader release gate                | `npx workspai pipeline --strict --json`                                                          |
-| Start MCP server for workspace queries      | `npx workspai workspace mcp serve`                                                               |
-
-For every command and flag, use the
-[Command Reference](docs/commands-reference.md).
+| You want to… | Run |
+| --- | --- |
+| Refresh context and checks | `npx workspai workspace intelligence run --for-agent generic` |
+| Explore a topic from your code | `npx workspai workspace graph search "authentication" --limit 5 --json` |
+| Diagnose your project or workspace | `npx workspai doctor project` / `npx workspai doctor workspace` |
+| Start a new project | `npx workspai create` |
+| Serve workspace queries to an MCP client | `npx workspai workspace mcp serve` |
 
-## Outputs and integrations
+Search results include evidence references. Follow them before changing code.
+[All commands and flags](docs/commands-reference.md)
 
-Workspai exposes the same governed data through several stable surfaces:
+## Outputs and integrations
 
-- human-readable terminal summaries;
-- JSON output for scripts and CI;
-- versioned artifacts under `.workspai/reports/`;
-- focused context and instructions for AI agents;
-- MCP server with versioned read-oriented workspace tools (`workspace mcp serve`);
-- Live activity projections and reports for IDEs and dashboards;
-- JSON, JSON-LD, Mermaid, DOT, GraphML, and GEXF graph exports.
+Use terminal summaries for a first look, JSON for automation, and saved context
+for coding agents. Graph exports include JSON, Mermaid, DOT, GraphML, and GEXF.
+Live activity projections and reports for IDEs and dashboards show current activity;
+activity alone does not prove a change is correct.
 
-The [Workspai VS Code extension](https://marketplace.visualstudio.com/items?itemName=rapidkit.rapidkit-vscode)
-uses this CLI, so visual and terminal workflows share the same contracts and
-artifacts.
+The [VS Code extension](https://marketplace.visualstudio.com/items?itemName=rapidkit.rapidkit-vscode)
+uses the same CLI and workspace artifacts.
 
 ## Requirements
 
-- Node.js `>=20.19.0`
-- npm
-
-Python, Go, Java, .NET, Rust, or PHP are needed only for workflows that use
-those runtimes. Python is not required for Python-free workspaces or npm-owned
-project generators.
-
-RapidKit Core is the optional Python engine for Python/Core-dependent kits and
-modules; Workspai remains the workspace-level CLI.
+Node.js **20.19+** and npm. Other runtimes are needed only for projects and
+workflows that use them. Python is not required for Python-free workflows;
+RapidKit Core supports the Python/Core-dependent kits and modules.
 
 ## Documentation
 
-| Goal                                          | Guide                                                                                          |
-| --------------------------------------------- | ---------------------------------------------------------------------------------------------- |
-| Learn the main terms                          | [Glossary](docs/GLOSSARY.md)                                                                   |
-| Create, adopt, import, or connect software    | [Creating workspaces and projects](docs/creating-workspaces-and-projects.md)                   |
-| Query Graph and inspect proof                 | [Workspace Knowledge Graph](docs/workspace-knowledge-graph.md)                                 |
-| Understand the exact decision loop            | [Workspace Intelligence runner](docs/workspace-intelligence-runner.md)                         |
-| Run dependency, test, and build stages         | [Workspace Run](docs/workspace-run.md)                                                         |
-| Observe CLI and Studio activity                | [Workspai Live](docs/workspace-live-activity.md)                                               |
-| Plan, approve, execute, or roll back a repair | [Workspace Repair Engine](docs/workspace-repair-engine.md)                                     |
-| Set a release, security, or coverage outcome  | [Verified engineering goals](docs/workspace-intelligence-runner.md#verified-engineering-goals) |
-| Compile plain language into a governed plan   | [Goal Packs](docs/goal-packs.md)                                                               |
-| Prove what an agent changed and why           | [Proof-Carrying Change](docs/proof-carrying-change.md)                                         |
-| Ground an agent in canonical project evidence | [Canonical-first agent entry](docs/agent-entry.md)                                             |
-| Measure bounded retrieval and model usage      | [Evaluation](docs/workspace-intelligence-evaluation.md) and [benchmark](docs/workspace-intelligence-benchmark.md) |
-| Integrate CI                                  | [CI workflows](docs/ci-workflows.md)                                                           |
-| Find generated files and schemas              | [Artifact Catalog](docs/contracts/ARTIFACT_CATALOG.md)                                         |
-| Browse all documentation                      | [Documentation index](docs/README.md)                                                          |
+| Next step | Guide |
+| --- | --- |
+| Create, adopt, or import a project | [Getting started](docs/creating-workspaces-and-projects.md) |
+| Connect your coding agent | [Agent entry](docs/agent-entry.md) |
+| Understand relationships | [Knowledge Graph](docs/workspace-knowledge-graph.md) |
+| Add checks to CI | [CI workflows](docs/ci-workflows.md) |
+| Find a command or understand a term | [Command reference](docs/commands-reference.md) · [Glossary](docs/GLOSSARY.md) |
+
+[Browse all guides](docs/README.md)
 
 ## Troubleshooting
 
-| Problem                              | Next step                                                                                |
-| ------------------------------------ | ---------------------------------------------------------------------------------------- |
-| The workspace is not detected        | Run from the project/workspace or inspect `npx workspai project workspace status --json` |
-| A check reports stale evidence       | Re-run the complete Workspace Intelligence command                                       |
-| A runtime is missing                 | Install only the runtime required by that project                                        |
-| An agent cannot find current context | Run `npx workspai workspace agent-sync --write --refresh-context --json`                 |
-| You need a specific flag             | Open the [Command Reference](docs/commands-reference.md)                                 |
+- **Workspace not detected?** Run from your linked project, or inspect
+  `npx workspai project workspace status --json`.
+- **Context is stale?** Rerun the intelligence command.
+- **A check is blocked?** Read the named report; adoption does not certify project health.
+- **Agent files need refreshing?** Run
+  `npx workspai workspace agent-sync --write --refresh-context --json`.
 
 ## Contributing
 
-Workspai is developed in the open by
-[Chistiq](https://chistiq.com/), the intelligence infrastructure company behind
-RapidKit and Workspai.
+[Contribution guide](CONTRIBUTING.md) · [Development](docs/DEVELOPMENT.md) ·
+[Security](docs/SECURITY.md)
 
-Read [CONTRIBUTING.md](CONTRIBUTING.md), the
-[Development Guide](docs/DEVELOPMENT.md), and the
-[Security Policy](docs/SECURITY.md).
+Built by [Chistiq](https://chistiq.com/), the team behind RapidKit and Workspai.
 
 ## License
 

package/dist/autopilot-release-E7ADQH2B.js

@@ -0,0 +1 @@
+export{b as AUTOPILOT_RELEASE_ALIAS_FILENAME,a as AUTOPILOT_RELEASE_LAST_RUN_FILENAME,c as runAutopilotRelease}from'./chunk-MJYWGRCY.js';

package/dist/{chunk-EPFEUMYF.js → chunk-5MRDPZU7.js}

@@ -1 +1 @@
-import a from'path';import Y from'fs-extra';import q from'chalk';async function U(p,n={}){let e=a.resolve(p),{WORKSPACE_CONTRACT_PATH:l,syncWorkspaceContract:d,verifyWorkspaceContract:S,writeWorkspaceContractVerifyEvidence:j}=await import('./workspace-contract-N2BJCAJ7.js'),w=await d({workspacePath:e,strict:true}),{syncWorkspaceReadme:E,WORKSPACE_README_PATH:R}=await import('./workspace-readme-4FCKAQME.js'),x=await E({workspacePath:e,workspaceName:w.contract.workspace.name,profile:w.contract.workspace.profile??"minimal",projectCount:w.contract.projects.length}),{buildWorkspaceModel:h,writeWorkspaceModel:g}=await import('./workspace-model-LBICKRVI.js'),r=await h({workspacePath:e,includeEvidence:true}),k=await g(r,e),{buildWorkspaceImpact:G,buildWorkspaceModelSnapshot:O,diffWorkspaceModel:$,writeWorkspaceImpact:M,writeWorkspaceModelDiff:T,writeWorkspaceModelSnapshot:_}=await import('./workspace-intelligence-ZTET7JHS.js'),{WORKSPACE_INTELLIGENCE_ARTIFACTS:s}=await import('./workspace-intelligence-runtime-registry-ZLPF7BAY.js'),{syncWorkspaceAgentGrounding:P}=await import('./workspace-agent-sync-6427FNME.js'),W=await P({workspacePath:e,model:r,write:true,refreshContext:true,strict:false,preset:"enterprise",targets:["all"],projectGrounding:n.projectGrounding??"managed"}),v=new Set(W.writtenFiles),i=new Set(W.projectLenses?.skipped.map(t=>`${t.name}: ${t.reason}`)??[]),{readWorkspaceKnowledgeGraphSnapshot:C}=await import('./workspace-knowledge-graph-snapshot-UTJHALST.js'),o=await C(e),y=false;if(o.status==="miss"){if(o.reason!=="live-input-mismatch")throw new Error(`Workspace consumer sync could not validate canonical Model/Graph evidence (${o.reason}).`);r=await h({workspacePath:e,includeEvidence:true}),k=await g(r,e);let{buildWorkspaceAgentContext:t,writeWorkspaceAgentContext:f}=await import('./workspace-context-VVZARI5K.js'),m=await t({workspacePath:e,model:r,agent:"generic",includeEvidence:true});await f(m,e);let b=await P({workspacePath:e,model:r,write:true,refreshContext:false,strict:false,preset:"enterprise",targets:["all"],projectGrounding:n.projectGrounding??"managed"});for(let c of b.writtenFiles)v.add(c);for(let c of b.projectLenses?.skipped??[])i.add(`${c.name}: ${c.reason}`);if(o=await C(e),o.status==="miss")throw new Error(`Workspace consumer reconciliation did not produce fresh canonical evidence (${o.reason}).`);y=true;}let F=a.join(e,s.snapshot),u=false;if(!await Y.pathExists(F)){let t=await O({workspacePath:e,model:r});await _(t,e),u=true;}let I=await $({workspacePath:e,fromPath:s.snapshot,model:r}),N=await T(I,e),L=await G({workspacePath:e,fromPath:s.diff}),K=await M(L,e),z=await S({workspacePath:e,strict:true}),H=await j({workspacePath:e,result:z}),V=(o.graph.source.inputs?.scopes??[]).filter(t=>t.truncated);for(let t of V)i.add(`${t.kind}:${t.id} graph inventory reached its ${t.fileLimit}-file emergency bound; inventory completeness is bounded.`);let A=o.graph.quality.completeness?.providers.bounded??0;A>0&&i.add(`${A} graph provider(s) used declared adaptive semantic/deep budgets; inspect provider inputCoverage before making exhaustive symbol-level claims.`);let D=[l,(await import('./workspace-registry-summary-3PXZENLC.js')).WORKSPACE_REGISTRY_SUMMARY_RELATIVE_PATH,a.relative(e,x).split(a.sep).join("/")||R,a.relative(e,k).split(a.sep).join("/"),s.knowledgeGraph,...u?[s.snapshot]:[],a.relative(e,N).split(a.sep).join("/"),a.relative(e,K).split(a.sep).join("/"),a.relative(e,H).split(a.sep).join("/"),...v].filter((t,f,m)=>m.indexOf(t)===f);return n.silent||console.log(q.gray(`\u2713 Workspace Intelligence synced \xB7 ${r.summary.projectCount} project(s) \xB7 model + graph + agent grounding \xB7 freshness sealed`)),{workspacePath:e,projectCount:r.summary.projectCount,baselineCreated:u,freshnessSealed:true,reconciledAfterGrounding:y,writtenFiles:D,warnings:[...i].sort()}}async function ee(p,n={}){let e=a.resolve(p),l=n.workspaceName??a.basename(e),{registerWorkspaceStrict:d}=await import('./workspace-AXU6ODER.js');return await d(e,l),U(e,{silent:n.silent})}export{U as a,ee as b};
+import a from'path';import Y from'fs-extra';import q from'chalk';async function U(p,n={}){let e=a.resolve(p),{WORKSPACE_CONTRACT_PATH:l,syncWorkspaceContract:d,verifyWorkspaceContract:S,writeWorkspaceContractVerifyEvidence:j}=await import('./workspace-contract-N2BJCAJ7.js'),w=await d({workspacePath:e,strict:true}),{syncWorkspaceReadme:E,WORKSPACE_README_PATH:R}=await import('./workspace-readme-4FCKAQME.js'),x=await E({workspacePath:e,workspaceName:w.contract.workspace.name,profile:w.contract.workspace.profile??"minimal",projectCount:w.contract.projects.length}),{buildWorkspaceModel:h,writeWorkspaceModel:g}=await import('./workspace-model-LBICKRVI.js'),r=await h({workspacePath:e,includeEvidence:true}),k=await g(r,e),{buildWorkspaceImpact:G,buildWorkspaceModelSnapshot:O,diffWorkspaceModel:$,writeWorkspaceImpact:M,writeWorkspaceModelDiff:T,writeWorkspaceModelSnapshot:_}=await import('./workspace-intelligence-ZTET7JHS.js'),{WORKSPACE_INTELLIGENCE_ARTIFACTS:s}=await import('./workspace-intelligence-runtime-registry-ZLPF7BAY.js'),{syncWorkspaceAgentGrounding:P}=await import('./workspace-agent-sync-46L7ZOQQ.js'),W=await P({workspacePath:e,model:r,write:true,refreshContext:true,strict:false,preset:"enterprise",targets:["all"],projectGrounding:n.projectGrounding??"managed"}),v=new Set(W.writtenFiles),i=new Set(W.projectLenses?.skipped.map(t=>`${t.name}: ${t.reason}`)??[]),{readWorkspaceKnowledgeGraphSnapshot:C}=await import('./workspace-knowledge-graph-snapshot-UTJHALST.js'),o=await C(e),y=false;if(o.status==="miss"){if(o.reason!=="live-input-mismatch")throw new Error(`Workspace consumer sync could not validate canonical Model/Graph evidence (${o.reason}).`);r=await h({workspacePath:e,includeEvidence:true}),k=await g(r,e);let{buildWorkspaceAgentContext:t,writeWorkspaceAgentContext:f}=await import('./workspace-context-VVZARI5K.js'),m=await t({workspacePath:e,model:r,agent:"generic",includeEvidence:true});await f(m,e);let b=await P({workspacePath:e,model:r,write:true,refreshContext:false,strict:false,preset:"enterprise",targets:["all"],projectGrounding:n.projectGrounding??"managed"});for(let c of b.writtenFiles)v.add(c);for(let c of b.projectLenses?.skipped??[])i.add(`${c.name}: ${c.reason}`);if(o=await C(e),o.status==="miss")throw new Error(`Workspace consumer reconciliation did not produce fresh canonical evidence (${o.reason}).`);y=true;}let F=a.join(e,s.snapshot),u=false;if(!await Y.pathExists(F)){let t=await O({workspacePath:e,model:r});await _(t,e),u=true;}let I=await $({workspacePath:e,fromPath:s.snapshot,model:r}),N=await T(I,e),L=await G({workspacePath:e,fromPath:s.diff}),K=await M(L,e),z=await S({workspacePath:e,strict:true}),H=await j({workspacePath:e,result:z}),V=(o.graph.source.inputs?.scopes??[]).filter(t=>t.truncated);for(let t of V)i.add(`${t.kind}:${t.id} graph inventory reached its ${t.fileLimit}-file emergency bound; inventory completeness is bounded.`);let A=o.graph.quality.completeness?.providers.bounded??0;A>0&&i.add(`${A} graph provider(s) used declared adaptive semantic/deep budgets; inspect provider inputCoverage before making exhaustive symbol-level claims.`);let D=[l,(await import('./workspace-registry-summary-3PXZENLC.js')).WORKSPACE_REGISTRY_SUMMARY_RELATIVE_PATH,a.relative(e,x).split(a.sep).join("/")||R,a.relative(e,k).split(a.sep).join("/"),s.knowledgeGraph,...u?[s.snapshot]:[],a.relative(e,N).split(a.sep).join("/"),a.relative(e,K).split(a.sep).join("/"),a.relative(e,H).split(a.sep).join("/"),...v].filter((t,f,m)=>m.indexOf(t)===f);return n.silent||console.log(q.gray(`\u2713 Workspace Intelligence synced \xB7 ${r.summary.projectCount} project(s) \xB7 model + graph + agent grounding \xB7 freshness sealed`)),{workspacePath:e,projectCount:r.summary.projectCount,baselineCreated:u,freshnessSealed:true,reconciledAfterGrounding:y,writtenFiles:D,warnings:[...i].sort()}}async function ee(p,n={}){let e=a.resolve(p),l=n.workspaceName??a.basename(e),{registerWorkspaceStrict:d}=await import('./workspace-XVPKQG5W.js');return await d(e,l),U(e,{silent:n.silent})}export{U as a,ee as b};