workspai 0.74.0 → 0.75.0

package/docs/agent-framework-adapters.md

@@ -0,0 +1,279 @@
+# Agent Framework Adapter Contract
+
+Workspai treats an agent framework as an execution integration, not as the
+source of repository truth. A project kit may scaffold a framework and an
+existing project may attach the same framework, but both paths must use one
+versioned adapter contract.
+
+```text
+new-project kit ----\
+                     -> framework adapter -> framework runtime
+existing project ---/            |
+                                  -> Workspai Context, Goal, PCC, and Verify
+```
+
+Microsoft Agent Framework is the first concrete implementation of this
+foundation. Its Python and .NET adapters are intentionally separate because
+their package graphs, runtime requirements, entrypoints, and verification
+commands differ. Both are available for governed attachment after their exact
+manifest digests pass the required Linux, macOS, and Windows conformance lanes
+and are bound into the reviewed release-admission inventory.
+
+## Published contracts
+
+| Contract                                                                       | Purpose                                                                               |
+| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
+| `contracts/agent-framework-capabilities.v1.json`                               | Normative ownership, capability, lifecycle, security, versioning, and admission rules |
+| `contracts/workspace-intelligence/agent-framework-adapter-manifest.v1.json`    | JSON Schema for one framework/version adapter declaration                             |
+| `contracts/workspace-intelligence/agent-framework-conformance-report.v1.json`  | JSON Schema for reproducible adapter admission evidence                               |
+| `contracts/workspace-intelligence/agent-framework-change-plan.v1.json`         | Portable, mutation-free scaffold or attach plan returned to the host                  |
+| `contracts/workspace-intelligence/agent-framework-ownership-receipt.v1.json`   | Hash-bound proof of the files Workspai may safely refresh                             |
+| `contracts/workspace-intelligence/agent-framework-admission-candidate.v1.json` | Review-pending, digest-bound index of the complete cross-platform evidence matrix     |
+
+The schemas are also discoverable through
+`contracts/published-contract-catalog.v1.json` and the extension compatibility
+contract.
+
+The CLI runtime foundation loads only bounded JSON manifests from an authorized
+root. It does not dynamically import adapter code during discovery. A manifest
+that escapes through `..` or a symlink, exceeds the size limit, fails JSON
+Schema validation, or violates semantic admission rules is rejected.
+
+## Authority boundary
+
+Workspai owns:
+
+- canonical Workspace Model and Knowledge Graph evidence;
+- bounded Context, Goal scope, and impact;
+- mutation admission, Proof-Carrying Change state, and effect receipts;
+- independent verification and canonical evidence sealing;
+- ownership-safe managed writes.
+
+The selected framework owns:
+
+- agent and workflow execution;
+- model invocation and framework-native tool dispatch;
+- conversation, memory, checkpoint, and runtime state;
+- channels, schedules, handoffs, and framework telemetry.
+
+An adapter must not convert model or framework output into verified Workspai
+evidence. Source mutation must cross the PCC or Repair approval boundary, and
+verification remains owned by the CLI.
+
+## Capability truth
+
+Every manifest declares every capability. Values are explicit:
+
+- `native`: supplied and owned by the framework;
+- `adapter-provided`: supplied by a bounded adapter implementation;
+- `conditional`: available only when declared prerequisites are satisfied;
+- `unsupported`: not available and never implied by UI or documentation.
+
+Framework identity, project runtime, and model provider are independent. A
+Python or TypeScript project can select a framework and then select any model
+provider admitted by that framework without changing Workspai truth.
+
+Detection uses weighted, typed authored probes rather than framework names or
+generated Workspai files. Supported probes are contained paths, bounded literal
+file reads, and package declarations from npm, PyPI, or NuGet manifests.
+Dependency discovery can scan only declared suffixes, within a declared maximum
+depth and a fixed global entry budget. Generated markers can confirm an already
+detected framework but can never select one. Multiple matching adapters are a
+conflict, not a ranking guess.
+
+## Microsoft Agent Framework baseline
+
+The built-in implementation currently targets the upstream stable baselines
+verified from the Microsoft source tree:
+
+| Adapter                            | Tested framework | Runtime         | Authored detection                         |
+| ---------------------------------- | ---------------- | --------------- | ------------------------------------------ |
+| `microsoft-agent-framework-python` | `1.17.0`         | Python `>=3.10` | `agent-framework` PyPI package family      |
+| `microsoft-agent-framework-dotnet` | `1.20.0`         | .NET `>=8.0`    | `Microsoft.Agents.AI` NuGet package family |
+
+The first provider profile pins its integration independently: Python uses
+`agent-framework-foundry` `1.12.0`, while .NET uses
+`Microsoft.Agents.AI.Foundry` `1.20.0-preview.260831.1` over the stable
+`Microsoft.Agents.AI` `1.20.0` core. Preview integration status is not
+misrepresented as framework stability.
+
+Each adapter implements detection, scaffold and attach planning, managed-file
+rendering, project context, validation, and runtime resolution. It never
+installs a dependency, invokes a model, executes generated code, or writes a
+source file directly. The lifecycle host binds the target project and every
+content digest into the PCC event chain, requires an explicit filesystem grant,
+then atomically applies the unchanged plan and records effect evidence.
+
+Generated starter files use an isolated `agents/<instance>` root and keep
+adapter state under `.workspai/agent-frameworks/<adapter>/<instance>.json`.
+That instance contains the only runtime dependency manifest; the project root
+does not receive an empty Python or .NET manifest that could be mistaken for a
+second executable unit. Workspace Model reports these projects as `agent`,
+retains `microsoft-agent-framework` as their framework identity, and reports
+only lifecycle stages backed by concrete manifests, entrypoints, tests, or an
+owned project runner.
+Each starter also includes credentialless tests for the bounded context
+boundary and an environment-name example with no secret values. Python uses
+the host platform's normal Python 3 launcher and remains dependency-free for
+these tests; .NET uses a separately pinned test project. The conformance matrix
+executes these tests in addition to compiling and exercising the deterministic
+framework lifecycle.
+Existing user-authored files are blockers, never overwrite targets. A managed
+comment alone does not prove ownership: refresh also requires the previous
+Workspai ownership receipt, which is bound to the exact adapter-manifest digest;
+locally modified managed files fail closed.
+Provider credentials remain environment references. The first provider profile uses
+Microsoft Foundry, but provider identity is not part of framework identity and
+additional profiles must preserve the same security boundary.
+
+A path-filtered six-lane adapter matrix compiles the generated Python and .NET
+projects on Linux, macOS, and Windows. Every lane records all 18 mandatory
+checks, the exact runtime and framework baseline, a digest of the adapter
+manifest, and one bounded evidence file per check. Reports are retained as CI
+artifacts for review. A final job validates every evidence path and admits the
+matrix only when all three operating-system lanes pass for both adapters.
+Python conformance is pinned to 3.10.11, the final Python 3.10 release with
+cross-platform binary installers; this provides one reproducible minimum-runtime
+baseline while the adapter continues to declare Python `>=3.10` support.
+
+After verification, CI emits one admission-candidate artifact. It binds the
+source commit, CLI version, adapter-manifest digests, lane reports, and every
+evidence file by SHA-256. Its status is always `pending`: successful CI produces
+reviewable evidence, not release authority. Only the protected version-update
+branch may convert that candidate into the exact release-admission inventory,
+and the resulting pull request still passes normal review and repository gates.
+
+CI evidence is not silently trusted at runtime. The default registry remains
+blocked when callers provide neither raw conformance reports nor explicit
+permission to use the bundled reviewed release inventory. User-facing commands
+enable that inventory deliberately and fail closed if an adapter version,
+manifest digest, framework baseline, runtime, or platform list has changed.
+
+## Attach an agent runtime
+
+Build current Workspace Intelligence first, then inspect the release-admitted
+runtimes:
+
+```bash
+npx workspai workspace intelligence run --for-agent generic --strict --json
+npx workspai agent framework list --json
+```
+
+Planning creates a Goal-bound, hash-bound Proof-Carrying Change but does not
+write project files:
+
+```bash
+npx workspai agent framework plan \
+  --project api \
+  --runtime python \
+  --name support-agent
+```
+
+The interactive attach command displays the same plan and asks before granting
+its filesystem effect. Automation must opt in with `--yes` and records the
+identity supplied by `--granted-by`:
+
+```bash
+npx workspai agent framework attach \
+  --project api \
+  --runtime python \
+  --name support-agent
+```
+
+The operation writes only isolated adapter-owned files, records an ownership
+receipt, and returns the canonical intelligence and Change verification
+commands to run next. It never installs packages, calls a model, persists a
+credential, or executes generated code. A separately authorized saved plan can
+be applied with `agent framework apply`.
+
+The PCC stores both the exact adapter plan and a framework-neutral architecture
+prediction. Verification compares byte-backed artifact changes, requires typed
+receipts for mutations inside the immutable project scope, and does not blame a
+Change for concurrent work in another registered project. Its actual Graph
+overlay is scoped by the same immutable lease, and entities, relations, and
+proofs derived from an explicitly predicted artifact are treated as expected
+consequences rather than unrelated surprises. A blocked or no-op
+request created without an external Goal closes its generated Change and Goal
+instead of leaving actionable lifecycle state behind.
+
+The same admitted lifecycle is available for a new project:
+
+```bash
+npx workspai create project agent.microsoft.python support-agent
+npx workspai create project agent.microsoft.dotnet operations-agent
+```
+
+Create writes a minimal runtime identity, registers the project, creates the
+Goal and PCC, applies the adapter-owned scaffold, and records its ownership
+receipt before committing the project lifecycle transaction. A failed scaffold
+rolls back the new directory and workspace registration. Detection itself
+remains read-only and never authorizes writes.
+
+A workspace may contain multiple independently scoped framework adapters. A
+project that deliberately connects two frameworks must declare that bridge;
+Workspai never infers cross-framework execution from coincidental dependencies.
+
+## Security defaults
+
+- Network access is denied unless explicitly granted.
+- Secrets are referenced from an external secret source and never persisted in
+  portable artifacts.
+- Generated-code execution is disabled unless explicitly granted.
+- Mutating tools require approval.
+- Framework state and external input remain untrusted.
+- Telemetry must redact sensitive values.
+- Paths must be relative, contained, and checked across symlink boundaries.
+
+## Version and stability policy
+
+Every adapter pins exact tested framework versions and declares a bounded
+supported range. Upstream status constrains Workspai status:
+
+- a `stable` adapter requires a stable upstream and the complete passing
+  platform/runtime conformance matrix;
+- a beta upstream can be exposed only as `preview`;
+- a maintenance-mode upstream can be exposed only as `compatibility`;
+- a deprecated upstream cannot produce a new-project scaffold.
+
+This prevents a framework upgrade from silently changing generated structure,
+tool permissions, state semantics, or verification behavior.
+
+## Conformance admission
+
+All checks listed in the capabilities contract are mandatory. They cover
+schema and protocol compatibility, truthful detection, safe scaffold and attach
+plans, managed-file ownership, user-file preservation, path containment,
+secret safety, evidence-generation binding, mutation admission, verification,
+failure isolation, idempotency, offline behavior, and cross-platform paths.
+
+A report is admitted only when every required check passes, counts match the
+recorded checks, and no blocker remains. A skipped required check is a blocked
+result, not partial support.
+
+Admission covers every advertised platform, runtime, and exact tested-framework
+version lane. Reports are bound to the manifest digest, so older evidence cannot
+authorize a changed adapter. Missing or duplicate lanes, mismatched identities,
+and unadvertised runtimes fail closed.
+
+The generic boundary was hardened against two deliberately different
+integration shapes: a filesystem-first Node.js framework and the
+multi-language Microsoft Agent Framework. Only the Microsoft adapters are now
+implemented, and their preview state still prevents premature selection.
+
+## Implementation sequence
+
+1. Keep this v1 contract stable and validate it in CLI, extension, and package
+   publication gates.
+2. Use the framework-neutral registry, detector, and bounded manifest loader.
+3. Review the Microsoft Python and .NET digest-bound evidence produced by the
+   full conformance matrix.
+4. Keep automated upstream discovery separate from release authority: open or
+   refresh one version pull request, rerun the full matrix, bind the exact green
+   candidate, then rely on protected-branch review before merge.
+5. Admit another framework only after its create and attach paths share these
+   ownership, rollback, and verification guarantees.
+
+AutoGen is not planned as a new-project target because Microsoft Agent
+Framework is its supported successor path. Eve, LangGraph, and OpenAI Agents
+SDK are not advertised; each requires its own adapter, tested baseline, and
+conformance evidence.

package/docs/ci-workflows.md

@@ -95,7 +95,7 @@ Validate or preview the current CLI announcement locally:
 npm --workspace workspai run check:release-announcement
 npm --workspace workspai run release:announcement -- \
   --product workspai-cli \
-  --tag v0.74.0 \
+  --tag v0.75.0 \
   --markdown-output /tmp/workspai-discord-announcement.md
 ```
 

package/docs/commands-reference.md

@@ -81,6 +81,10 @@ npx workspai change abort --change <change-id> --reason <text> [--actor <identit
 npx workspai change capsule validate --change <change-id> [--workspace <path>] [--json]
 npx workspai change capsule export --change <change-id> --output <path> [--workspace <path>] [--json]
 npx workspai agent bootstrap [--project <path>] [--for-agent <host>] [--no-live-inputs] [--strict] [--json]
+npx workspai agent framework list [--json]
+npx workspai agent framework plan --project <name> --runtime <python|dotnet> --name <agent> [--goal <goal-id>] [--workspace <path>] [--json]
+npx workspai agent framework attach --project <name> --runtime <python|dotnet> --name <agent> [-y] [--granted-by <identity>] [--workspace <path>] [--json]
+npx workspai agent framework apply --change <change-id> --project <name> --runtime <python|dotnet> [--workspace <path>] [--json]
 ```
 
 Recommended CI:
@@ -262,6 +266,18 @@ the same receipt and can audit every supported host with `--for-agent all`.
 Blocked receipts exit `2`; strict mode also maps degraded evidence to exit `2`.
 See [Canonical-first agent entry](./agent-entry.md).
 
+`agent framework` is the governed bridge between Workspai evidence and an
+agent runtime. `list` exposes only exact release-admitted baselines. `plan`
+creates or reuses a scoped Goal, begins a Proof-Carrying Change, and attaches a
+hash-bound file plan without writing project files. `attach` shows that plan
+and requires an interactive confirmation or explicit `--yes` before granting
+the filesystem effect and writing an isolated `agents/<name>` directory.
+Dependency installation, credentials, generated-code execution, and model
+provider calls are never implied by that approval. `apply` is the automation
+counterpart for a plan that was separately authorized with `change authorize`.
+Any adapter, version, manifest, runtime, or platform drift invalidates its
+bundled release admission until the complete conformance matrix passes again.
+
 `workspace feedback record` is a non-interactive machine interface. It requires
 exactly one JSON object on stdin and `--json`; an empty stdin or interactive TTY
 is rejected. Required fields are `actionId`, `summary`, and `outcome`. The

package/docs/contracts/COMMAND_OWNERSHIP_MATRIX.md

@@ -78,6 +78,11 @@ These nested Commander commands are implemented and orchestrated by Workspai CLI
 - `product manifest create`
 - `product plan`
 - `agent bootstrap`
+- `agent framework`
+- `agent framework list`
+- `agent framework plan`
+- `agent framework attach`
+- `agent framework apply`
 - `project agent-entry`
 - `project commands`
 - `project coverage`

package/docs/creating-workspaces-and-projects.md

@@ -307,8 +307,8 @@ npx workspai create
 If you choose project creation, the same project flow is used.
 
 When the terminal is interactive and the current directory is not inside a
-workspace, **every supported backend, frontend, desktop, and extension kit** shows the workspace
-management question before scaffolding:
+workspace, **every supported backend, frontend, desktop, agent, and extension kit** shows the
+workspace management question before scaffolding:
 
 ```text
 This project is outside a Workspai workspace. How should it be managed?
@@ -338,6 +338,8 @@ npx workspai create project frontend.nextjs dashboard
 npx workspai create project desktop.tauri desktop-app
 npx workspai create project desktop.electron admin-console
 npx workspai create project extension.vscode editor-tools
+npx workspai create project agent.microsoft.python support-agent
+npx workspai create project agent.microsoft.dotnet operations-agent
 npx workspai create project php.laravel customer-api
 ```
 
@@ -384,6 +386,18 @@ Workspai has official-generator paths for:
 The ecosystem's official generator creates the application. Workspai then adds
 project metadata and performs the selected workspace registration.
 
+## Agent Framework kits
+
+| Kit                      | Runtime | Framework baseline | Behavior                                   |
+| ------------------------ | ------- | ------------------ | ------------------------------------------ |
+| `agent.microsoft.python` | Python  | Release-admitted   | Goal + PCC + owned isolated agent scaffold |
+| `agent.microsoft.dotnet` | .NET    | Release-admitted   | Goal + PCC + owned isolated agent scaffold |
+
+Agent kits require Workspace governance and therefore do not accept
+`--no-workspace`. They do not install dependencies, call a model, or store
+credentials. Their exact framework versions are promoted only after the full
+Linux, macOS, and Windows conformance matrix passes.
+
 ## Desktop, extension, and additional backend generators
 
 | Category  | Project           | Kit                | Creation owner                        |
@@ -394,8 +408,8 @@ project metadata and performs the selected workspace registration.
 | Desktop   | Electron Forge    | `desktop.electron` | create-electron-app                   |
 | Extension | VS Code Extension | `extension.vscode` | generator-code                        |
 
-Every generated project receives a canonical `kind` and `category`. The four
-user-facing categories are `backend`, `frontend`, `desktop`, and `extension`;
+Every generated project receives a canonical `kind` and `category`. The five
+user-facing creation categories are `backend`, `frontend`, `desktop`, `agent`, and `extension`;
 they remain visible in the Workspace Model and Knowledge Graph so consumers do
 not have to guess a project’s role from its runtime.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workspai",
-  "version": "0.74.0",
+  "version": "0.75.0",
   "type": "module",
   "description": "Open-source workspace intelligence CLI for software systems: create, adopt, govern, verify, and align polyglot workspaces for humans, CI, IDEs, and AI agents.",
   "keywords": [
@@ -113,6 +113,12 @@
     "test:scenarios:docker": "bash scripts/scenario-matrix.sh",
     "test:runtime-matrix": "node scripts/runtime-acceptance-matrix.mjs",
     "test:runtime-contract": "node scripts/runtime-acceptance-matrix.mjs --contract-only",
+    "test:agent-framework:python": "tsx scripts/smoke-microsoft-agent-framework-adapter.ts --runtime python",
+    "test:agent-framework:dotnet": "tsx scripts/smoke-microsoft-agent-framework-adapter.ts --runtime dotnet",
+    "verify:agent-framework:matrix": "tsx scripts/verify-agent-framework-conformance.ts --reports test-results/agent-framework-conformance",
+    "discover:agent-framework:versions": "tsx scripts/discover-agent-framework-versions.ts",
+    "propose:agent-framework:versions": "tsx scripts/propose-agent-framework-version-update.ts",
+    "promote:agent-framework:admission": "tsx scripts/promote-agent-framework-release-admission.ts",
     "prepush:test:runtime-contract": "node scripts/run-cached-prepush-gate.mjs runtime-contract",
     "test:runtime-matrix:full": "node scripts/runtime-acceptance-matrix.mjs --full",
     "test:real-world": "node scripts/real-world-qualification.mjs",

package/scripts/enterprise-package-smoke.mjs

@@ -207,6 +207,8 @@ const REQUIRED_PACKAGE_FILES = [
   'contracts/workspace-intelligence/workspace-repair-transaction.v1.json',
   'contracts/workspace-intelligence/project-agent-entry.v1.json',
   'contracts/workspace-intelligence/agent-bootstrap-receipt.v1.json',
+  'contracts/workspace-intelligence/agent-framework-change-plan.v1.json',
+  'contracts/workspace-intelligence/agent-framework-ownership-receipt.v1.json',
   'contracts/extension-cli-compatibility.v1.json',
   'data/modules-embeddings.json',
   'templates/kits/fastapi-standard/README.md.j2',
@@ -345,9 +347,104 @@ function assertCliContracts() {
     }
   }
 
+  const frameworks = parseTrailingJson(runCli(['agent', 'framework', 'list', '--json']));
+  if (
+    frameworks.schemaVersion !== 'workspai.agent-framework-list.v1' ||
+    frameworks.adapters?.length !== 2 ||
+    frameworks.adapters.some((adapter) => adapter.status !== 'admitted')
+  ) {
+    fail('published CLI does not expose the two exact release-admitted framework adapters');
+  }
+
   log(`verified CLI contract surfaces for v${version.version}`);
 }
 
+function smokeCreateAgentFrameworkKits() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workspai-agent-kit-smoke-'));
+  const workspaceName = 'agent-kit-workspace';
+  const workspacePath = path.join(tempDir, workspaceName);
+  const createWorkspace = spawnSync(
+    process.execPath,
+    [
+      cliPath,
+      'create',
+      'workspace',
+      workspaceName,
+      '--output',
+      tempDir,
+      '--profile',
+      'minimal',
+      '--skip-python-engine',
+      '--skip-git',
+      '--yes',
+    ],
+    { cwd: tempDir, encoding: 'utf8', env: cliEnv(), stdio: ['ignore', 'pipe', 'pipe'] }
+  );
+  if (createWorkspace.status !== 0) {
+    fail(
+      `agent kit workspace creation failed with exit ${createWorkspace.status}\n${createWorkspace.stdout}\n${createWorkspace.stderr}`
+    );
+  }
+
+  const scenarios = [
+    {
+      kit: 'agent.microsoft.python',
+      name: 'python-agent',
+      expectedFiles: [
+        'README.md',
+        '.workspai/project.json',
+        '.workspai/agent-frameworks/microsoft-agent-framework-python/primary.json',
+        'agents/primary/main.py',
+        'agents/primary/pyproject.toml',
+        'agents/primary/tests/test_context.py',
+        'agents/primary/.env.example',
+        'agents/primary/README.md',
+      ],
+    },
+    {
+      kit: 'agent.microsoft.dotnet',
+      name: 'dotnet-agent',
+      expectedFiles: [
+        'README.md',
+        '.workspai/project.json',
+        '.workspai/agent-frameworks/microsoft-agent-framework-dotnet/primary.json',
+        'agents/primary/Program.cs',
+        'agents/primary/WorkspaiContext.cs',
+        'agents/primary/Primary.csproj',
+        'agents/primary/tests/Primary.Tests.csproj',
+        'agents/primary/tests/WorkspaiContextTests.cs',
+        'agents/primary/.env.example',
+        'agents/primary/README.md',
+      ],
+    },
+  ];
+  try {
+    for (const scenario of scenarios) {
+      const result = spawnSync(
+        process.execPath,
+        [cliPath, 'create', 'project', scenario.kit, scenario.name, '--skip-git', '--yes'],
+        {
+          cwd: workspacePath,
+          encoding: 'utf8',
+          env: cliEnv(),
+          stdio: ['ignore', 'pipe', 'pipe'],
+        }
+      );
+      if (result.status !== 0) {
+        fail(
+          `${scenario.kit} governed create failed with exit ${result.status}\n${result.stdout}\n${result.stderr}`
+        );
+      }
+      assertGeneratedProject(path.join(workspacePath, scenario.name), scenario.expectedFiles);
+    }
+    const ownershipRoot = path.join(workspacePath, '.workspai', 'agent-frameworks', 'ownership');
+    if (!fs.existsSync(ownershipRoot)) fail('agent kit smoke did not record ownership receipts');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+  log(`verified ${scenarios.length} governed agent framework create scenarios`);
+}
+
 function assertGeneratedProject(projectPath, expectedFiles) {
   for (const relativePath of expectedFiles) {
     const absolutePath = path.join(projectPath, relativePath);
@@ -532,6 +629,7 @@ for (const relativePath of [
 assertPackContents();
 assertCliContracts();
 smokeCreateNpmBackedKits();
+smokeCreateAgentFrameworkKits();
 smokeCreateOfflineFallbackKits();
 
 log('enterprise package smoke passed');

package/dist/analyze-IA33T6MY.js

@@ -1 +0,0 @@
-export{b as printAnalyzeReport,a as runAnalyze}from'./chunk-DLLHUG2Q.js';

package/dist/autopilot-release-T327V7QK.js

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

package/dist/capabilities-command-NFGX42CH.js

@@ -1 +0,0 @@
-export{b as runDoctorCapabilities}from'./chunk-JK6XEF7K.js';