archgraph-argo 0.5.1 → 0.5.2

package/README.md

@@ -4,12 +4,10 @@ An architecture-graph driven framework for Agentic Engineering.
 
 ## What is this?
 
-`ArchGraph` treats an **intent architecture graph** as the single source of
-truth for agentic engineering. Every piece of work starts from an element in the graph — a Work
-Package, a Skill, a Rule, a Viewpoint, or an Application Component — and every repository change is
-traced back to that element.
+ArchGraph builds a **unified language** that puts harness design and target product design into
+**one model** — so you get a single view to work and observe, and real control over your agents.
 
-The canonical graph lives at [`design/KG/SystemArchitecture.json`](design/KG/SystemArchitecture.json).
+![alt text](docs/diagrams/image.png)
 
 ## Architecture
 
@@ -21,94 +19,27 @@ engineering:
 
 Editable source: [`docs/diagrams/global-architecture.excalidraw`](docs/diagrams/global-architecture.excalidraw)
 
-## Core principles
-
-1. **Arm before acting** — before any development, pull the Work Package's associated Skills and
-   Rules and materialize them under `~/.copilot/skills/<name>/SKILL.md` (user-level) or
-   `.github/skills/<name>/SKILL.md` (project) and `*.instructions.md`.
-2. **Find the element first** — every repository change maps to an architecture element. If none
-   exists, create one inside a sensible View and Viewpoint.
-3. **Acceptance tests first** — check the affected acceptance cases before changing anything.
-   Tests verify elements from the outside (GIVEN-WHEN-THEN), never their internals.
-4. **Commit traceability** — after each change, commit and register the commit id plus file paths
-   back into the graph element.
-
-These rules are encoded as user-level instructions `argo-copilot-instructions.instructions.md`
-in the VS Code Copilot prompts folder (`%APPDATA%\Code\User\prompts`).
-
-## Repository map
-
-| Path | Purpose |
-| --- | --- |
-| `design/KG/SystemArchitecture.json` | Canonical intent architecture graph (single source of truth) |
-| `%APPDATA%\Code\User\prompts\argo-copilot-instructions.instructions.md` | Global agent rules (user-level) |
-| `~/.copilot/skills/argo-init/SKILL.md` | ARGO harness init skill (user-level) |
-| `.github/kglibrary.instructions.md` | Global rule for `KGlibrary/*/info.md` frontmatter format |
-| `.github/skills/<name>/SKILL.md` | Skills materialized from the graph (`argo-init`, `create-github-repository-page`, `diagram-draw`, `optimize-web-layout-style`) |
-| `.argo/` | ARGO harness: MCP server, schema, validators, semantic (Graph RAG) lifecycle and Neo4j sync |
-| `KGlibrary/` | Reference project knowledge library |
-| `index.html` | GitHub Pages home site |
-| `tests/` | Executable acceptance tests (Node.js built-in test runner) |
-
-## How to use
-
-`ArchGraph` is an agentic engineering framework driven by a knowledge graph —
-the intent architecture graph — whose schema complies with **ArchiMate 3.2**.
-
-To adopt it as the building framework for another project, copy the following into the target project:
-
-1. **`.argo/`** — the ARGO harness: the MCP server, the ArchiMate 3.2 schema, validators, the
-   semantic (Graph RAG) lifecycle, and Neo4j sync.
-2. **One agent-host configuration directory**, depending on which agent you use:
-   - `.github/` — GitHub Copilot / VS Code
-   - `.opencode/` — opencode
-   - `.cursor/` — Cursor
-
-   Each directory carries the global rules, the materialized skills, and the `argo` MCP wiring.
-3. **The `.feap` Enterprise Architect model** — the ArchiMate 3.2 model used to author the
-   knowledge graph (the `feap` tool).
-
-Then point your agent at the harness (`node .argo/scripts/argo-mcp-server.js`) and bootstrap the
-environment:
-
-```powershell
-node .argo/scripts/ensureArgoHarnessEnvironment.js
-```
-
-## ARGO MCP harness
-
-Read and write the intent architecture through the **ARGO MCP server** — configured in
-[`.github/mcp.json`](.github/mcp.json) and served by `node .argo/scripts/argo-mcp-server.js`.
-Never edit `design/KG/SystemArchitecture.json` directly.
-
-Bootstrap or health-check the harness with:
+## Install
 
 ```powershell
-node .argo/scripts/ensureArgoHarnessEnvironment.js
+npm install -g archgraph-argo
+argo-deploy
 ```
 
-The harness validates the graph against `.argo/schema/SystemArchitecture.schema.json`, supports a
-semantic (Graph RAG) query lifecycle, and can sync the graph into Neo4j (`neo4j-driver`).
-
-## KGlibrary reference library
+Done &mdash; the ARGO toolchain, skills, and rules are deployed, and the `argo` MCP server is registered automatically.
 
-Each project under `KGlibrary/<project>/` provides an `info.md` with YAML frontmatter keys
-(`name`, `description`, `repo`, `branch`, `commit_id`) so the home site and agents can uniformly
-consume reference project information. See
-[`.github/kglibrary.instructions.md`](.github/kglibrary.instructions.md).
+> Semantic (Graph RAG) queries also need **Neo4j** and a **vector engine** configured in
+> `~/.argo/.env`; everything else works out of the box.
 
-## Tests
-
-Run the acceptance suite with:
+## How to use
 
-```powershell
-node --test "tests/*.test.js"
-```
+After installing, open your project and start a coding agent. It will:
 
-## Requirements
+1. locate the architecture element behind the task before changing anything,
+2. arm itself with that element's Skills and Rules,
+3. work test-first (GIVEN-WHEN-THEN), and trace every commit back to the graph.
 
-- Node.js (built-in `node:test` runner)
-- Optional: a reachable Neo4j database for the semantic lifecycle / sync tooling
+The intent architecture graph — modelled in **ArchiMate 3.2** — is the single source of truth.
 
 ## License
 

package/argo/defaults/design/KG/SystemArchitecture.json

@@ -0,0 +1,207 @@
+{
+    "name": "System",
+    "description": "Exported from EA package System",
+    "elements": [
+        {
+            "id": "1207",
+            "name": "StakeholderIntentViewpoint",
+            "type": "Grouping",
+            "description": "Baseline viewpoint for stakeholder concerns, business intent, and success value.",
+            "attributes": [
+                {
+                    "name": "modelingSkillPaths",
+                    "value": ".argo/skills/modeling/stakeholder-viewpoint/SKILL.md; .argo/skills/modeling/goal-realization-viewpoint/SKILL.md; .argo/skills/modeling/motivation-viewpoint/SKILL.md"
+                }
+            ],
+            "subdiagram_views": [
+                {
+                    "view_id": "159",
+                    "view_name": "StakeholderIntentViewpoint"
+                }
+            ]
+        },
+        {
+            "id": "1208",
+            "name": "OutcomeCapabilityViewpoint",
+            "type": "Grouping",
+            "description": "Baseline viewpoint for outcomes, capabilities, value streams, and capability boundaries.",
+            "attributes": [
+                {
+                    "name": "modelingSkillPaths",
+                    "value": ".argo/skills/modeling/strategy-viewpoint/SKILL.md; .argo/skills/modeling/capability-map-viewpoint/SKILL.md; .argo/skills/modeling/value-stream-viewpoint/SKILL.md; .argo/skills/modeling/outcome-realization-viewpoint/SKILL.md; .argo/skills/modeling/resource-map-viewpoint/SKILL.md"
+                }
+            ],
+            "subdiagram_views": [
+                {
+                    "view_id": "160",
+                    "view_name": "OutcomeCapabilityViewpoint"
+                }
+            ]
+        },
+        {
+            "id": "1209",
+            "name": "BusinessBehaviorViewpoint",
+            "type": "Grouping",
+            "description": "Baseline viewpoint for business roles, processes, events, and domain objects.",
+            "attributes": [
+                {
+                    "name": "modelingSkillPaths",
+                    "value": ".argo/skills/modeling/organization-viewpoint/SKILL.md; .argo/skills/modeling/product-viewpoint/SKILL.md; .argo/skills/modeling/business-process-cooperation-viewpoint/SKILL.md; .argo/skills/modeling/service-realization-viewpoint/SKILL.md"
+                }
+            ],
+            "subdiagram_views": [
+                {
+                    "view_id": "161",
+                    "view_name": "BusinessBehaviorViewpoint"
+                }
+            ]
+        },
+        {
+            "id": "1210",
+            "name": "CapabilityRealizationViewpoint",
+            "type": "Grouping",
+            "description": "Baseline viewpoint for tracing business capabilities to application services, components, and system responsibilities.",
+            "attributes": [
+                {
+                    "name": "modelingSkillPaths",
+                    "value": ".argo/skills/modeling/requirements-realization-viewpoint/SKILL.md; .argo/skills/modeling/application-usage-viewpoint/SKILL.md; .argo/skills/modeling/application-structure-viewpoint/SKILL.md; .argo/skills/modeling/application-cooperation-viewpoint/SKILL.md; .argo/skills/modeling/information-structure-viewpoint/SKILL.md; .argo/skills/modeling/technology-usage-viewpoint/SKILL.md; .argo/skills/modeling/technology-viewpoint/SKILL.md; .argo/skills/modeling/implementation-deployment-viewpoint/SKILL.md"
+                }
+            ],
+            "subdiagram_views": [
+                {
+                    "view_id": "162",
+                    "view_name": "CapabilityRealizationViewpoint"
+                }
+            ]
+        },
+        {
+            "id": "1211",
+            "name": "AcceptanceDeliveryViewpoint",
+            "type": "Grouping",
+            "description": "Baseline viewpoint for acceptance semantics, risk, cross-cutting concerns, dependency order, and delivery sequencing.",
+            "attributes": [
+                {
+                    "name": "modelingSkillPaths",
+                    "value": ".argo/skills/modeling/project-viewpoint/SKILL.md; .argo/skills/modeling/migration-viewpoint/SKILL.md; .argo/skills/modeling/implementation-migration-viewpoint/SKILL.md; .argo/skills/modeling/layered-viewpoint/SKILL.md; .argo/skills/modeling/physical-viewpoint/SKILL.md"
+                }
+            ],
+            "subdiagram_views": [
+                {
+                    "view_id": "163",
+                    "view_name": "AcceptanceDeliveryViewpoint"
+                }
+            ]
+        }
+    ],
+    "relationships": [
+        {
+            "id": "3001",
+            "name": "Baseline viewpoint association",
+            "type": "Association",
+            "source_id": "1207",
+            "target_id": "1208",
+            "source_name": "StakeholderIntentViewpoint",
+            "target_name": "OutcomeCapabilityViewpoint",
+            "description": "Baseline navigation from stakeholder intent to outcome and capability scope.",
+            "statement": "StakeholderIntentViewpoint --(Association)--> OutcomeCapabilityViewpoint"
+        },
+        {
+            "id": "3002",
+            "name": "Baseline viewpoint association",
+            "type": "Association",
+            "source_id": "1208",
+            "target_id": "1209",
+            "source_name": "OutcomeCapabilityViewpoint",
+            "target_name": "BusinessBehaviorViewpoint",
+            "description": "Baseline navigation from outcome and capability scope to observable business behavior.",
+            "statement": "OutcomeCapabilityViewpoint --(Association)--> BusinessBehaviorViewpoint"
+        },
+        {
+            "id": "3003",
+            "name": "Baseline viewpoint association",
+            "type": "Association",
+            "source_id": "1209",
+            "target_id": "1210",
+            "source_name": "BusinessBehaviorViewpoint",
+            "target_name": "CapabilityRealizationViewpoint",
+            "description": "Baseline navigation from business behavior to capability realization responsibilities.",
+            "statement": "BusinessBehaviorViewpoint --(Association)--> CapabilityRealizationViewpoint"
+        },
+        {
+            "id": "3004",
+            "name": "Baseline viewpoint association",
+            "type": "Association",
+            "source_id": "1210",
+            "target_id": "1211",
+            "source_name": "CapabilityRealizationViewpoint",
+            "target_name": "AcceptanceDeliveryViewpoint",
+            "description": "Baseline navigation from realization responsibilities to acceptance and delivery sequencing.",
+            "statement": "CapabilityRealizationViewpoint --(Association)--> AcceptanceDeliveryViewpoint"
+        }
+    ],
+    "views": [
+        {
+            "view_id": "159",
+            "view_name": "StakeholderIntentViewpoint",
+            "parent_element_id": "1207",
+            "parent_element_name": "StakeholderIntentViewpoint",
+            "description": "ArchiMate-inspired motivation viewpoint for framing stakeholder concerns before modeling solution details. Stakeholders: business partners, business managers, requirements owners, enterprise architects, and acceptors. Concerns: architecture mission, drivers for change, assessments, high-level goals, desired outcomes, value, principles, and hard constraints. Purpose: designing, deciding, and informing. Scope: motivation and strategy context. Use this view to answer who cares, why the change matters, what success means, and which constraints cannot be violated. Typical elements: Stakeholder, Driver, Assessment, Goal, Outcome, Value, Meaning, Principle, Requirement, Constraint, Course of Action. Do not place implementation components here unless they are needed only as evidence for a stakeholder concern.",
+            "included_elements": [],
+            "included_relationships": []
+        },
+        {
+            "view_id": "160",
+            "view_name": "OutcomeCapabilityViewpoint",
+            "parent_element_id": "1208",
+            "parent_element_name": "OutcomeCapabilityViewpoint",
+            "description": "ArchiMate-inspired strategy viewpoint combining Strategy, Capability Map, Value Stream, and Outcome Realization concerns. Stakeholders: business managers, product owners, enterprise architects, business architects, and portfolio decision-makers. Concerns: business-oriented results, capability boundaries, value streams, resources, investment focus, and capability-to-outcome coverage. Purpose: designing and deciding. Scope: strategy with links to motivation and core elements when needed. Use this view to answer what business outcomes are in scope, which capabilities create or support them, and where value is produced. Typical elements: Outcome, Capability, Value Stream, Resource, Course of Action, Product, Value, Meaning, and selectively core elements that realize outcomes. Do not decompose detailed workflows or technical implementation here.",
+            "included_elements": [],
+            "included_relationships": []
+        },
+        {
+            "view_id": "161",
+            "view_name": "BusinessBehaviorViewpoint",
+            "parent_element_id": "1209",
+            "parent_element_name": "BusinessBehaviorViewpoint",
+            "description": "ArchiMate-inspired business behavior viewpoint drawing from Organization, Product, and Business Process Cooperation viewpoints. Stakeholders: process owners, domain experts, operational managers, business analysts, and product managers. Concerns: responsibilities, authority, business process dependencies, business services, product composition, contracts, shared information, and observable business events. Purpose: designing, deciding, and informing. Scope: mainly Business layer, with application links only when they explain business process support. Use this view to answer how the business works, who performs behavior, what events trigger it, what business objects are used, and what services or products are exposed. Typical elements: Business Actor, Business Role, Business Collaboration, Business Process, Business Function, Business Interaction, Business Event, Business Service, Business Object, Contract, Product, Representation. Do not turn this view into an application structure or code module map.",
+            "included_elements": [],
+            "included_relationships": []
+        },
+        {
+            "view_id": "162",
+            "view_name": "CapabilityRealizationViewpoint",
+            "parent_element_id": "1210",
+            "parent_element_name": "CapabilityRealizationViewpoint",
+            "description": "ArchiMate-inspired realization and usage viewpoint combining Requirements Realization, Application Usage, Service Realization, Application Cooperation, and Implementation and Deployment concerns. Stakeholders: enterprise architects, application architects, solution architects, process architects, and implementation designers. Concerns: how requirements, capabilities, business processes, and business services are realized by application services, components, data objects, and supporting technology; consistency, completeness, dependency visibility, and service orchestration. Purpose: designing and deciding. Scope: multiple layers and multiple aspects, but only along business-to-system realization paths. Use this view to answer how a business capability is carried by system responsibilities and which application or technology elements are relevant to that realization. Typical elements: Requirement, Constraint, Capability, Business Service, Business Process, Application Service, Application Component, Application Interface, Application Function or Process, Data Object, Technology Service, Node, Artifact. Do not include low-level implementation detail unless it changes a business-visible responsibility or dependency.",
+            "included_elements": [],
+            "included_relationships": []
+        },
+        {
+            "view_id": "163",
+            "view_name": "AcceptanceDeliveryViewpoint",
+            "parent_element_id": "1211",
+            "parent_element_name": "AcceptanceDeliveryViewpoint",
+            "description": "ArchiMate-inspired implementation and migration viewpoint extended with ARGO acceptance semantics. Stakeholders: business acceptors, project managers, operational managers, enterprise architects, delivery owners, and downstream agents. Concerns: acceptance control points, observation points, risk, work package scope, deliverables, plateaus, gaps, migration order, cross-cutting concerns, and consistency between delivery dependencies and architecture dependencies. Purpose: deciding and informing, with enough design detail to plan delivery. Scope: implementation and migration plus explicit business acceptance semantics. Use this view to answer how the change will be accepted, what must be observed, which work packages or plateaus are involved, what depends on what, and what risks could invalidate delivery. Typical elements: Goal, Outcome, Requirement, Constraint, Work Package, Deliverable, Implementation Event, Plateau, Gap, Business Actor, Business Role, and core elements affected by delivery. Do not use this view as a backlog dump; every item must affect acceptance, sequencing, or risk.",
+            "included_elements": [],
+            "included_relationships": []
+        },
+        {
+            "view_id": "158",
+            "view_name": "SystemArchitecture",
+            "description": "Top-level baseline architecture map governed by five universal business viewpoints. It follows the ArchiMate viewpoint mechanism: select content by stakeholder concerns, purpose, and scope, not by layer folders. The five child viewpoints provide the default AI navigation path from stakeholder intent to outcomes and capabilities, business behavior, capability realization, and acceptance-delivery sequencing. ArchiMate layers remain implicit in element types and may be used by validators or specialized sub-views, but they are not the default modeling entry point.",
+            "included_elements": [
+                "1207",
+                "1208",
+                "1209",
+                "1210",
+                "1211"
+            ],
+            "included_relationships": [
+                "3001",
+                "3002",
+                "3003",
+                "3004"
+            ]
+        }
+    ]
+}

package/argo/scripts/argo-mcp-server.js

@@ -17,6 +17,7 @@ const {
 const {
   getWorkspaceRoot,
   hasStaticWorkspace,
+  resolveArgoPath,
   setMcpWorkspaceRoots,
 } = require('./argo-paths.js');
 const canonicalSemanticInitStorage = new AsyncLocalStorage();
@@ -25,6 +26,9 @@ const HANDOFF_FILES_TO_RESET = [
   ['.argo', 'temp', 'IntentToImplementationHandoff.json'],
   ['.argo', 'temp', 'ImplementationToCodingHandoff.json'],
 ];
+const WORKSPACE_GRAPH_PATH_SEGMENTS = ['design', 'KG', 'SystemArchitecture.json'];
+const BUNDLED_GRAPH_DEFAULT_SEGMENTS = ['defaults', 'design', 'KG', 'SystemArchitecture.json'];
+const BUNDLED_EA_TEMPLATE_SEGMENTS = ['defaults', 'EA-model-template.feap'];
 const EA_TEMPLATE_PATH_CANDIDATES = [
   ['.opencode', 'customtools', 'EA-model-template.feap'],
   ['.opencode', 'EA-model-template.feap'],
@@ -409,6 +413,17 @@ async function initializeWorkspace(workspaceRoot) {
   const removedFiles = [];
   const skippedSteps = [];
 
+  const graphTargetPath = path.join(workspaceRoot, ...WORKSPACE_GRAPH_PATH_SEGMENTS);
+  const graphRelativePath = normalizeRelativePath(path.relative(workspaceRoot, graphTargetPath));
+  if (!fs.existsSync(graphTargetPath)) {
+    const graphSourcePath = resolveGraphDefaultSourcePath();
+    await fs.promises.mkdir(path.dirname(graphTargetPath), { recursive: true });
+    await fs.promises.copyFile(graphSourcePath, graphTargetPath);
+    createdFiles.push(graphRelativePath);
+  } else {
+    skippedSteps.push(`${graphRelativePath} already exists`);
+  }
+
   const templateSourcePath = resolveTemplateSourcePath(workspaceRoot);
   const targetFeapName = buildTargetFileName(workspaceName);
   const targetFeapPath = path.join(workspaceRoot, targetFeapName);
@@ -445,7 +460,22 @@ function resolveTemplateSourcePath(workspaceRoot) {
       return absolutePath;
     }
   }
-  throw new Error(`Unable to locate EA template. Checked: ${EA_TEMPLATE_PATH_CANDIDATES.map(candidate => candidate.join('/')).join(', ')}`);
+
+  const bundledPath = resolveArgoPath(...BUNDLED_EA_TEMPLATE_SEGMENTS);
+  if (fs.existsSync(bundledPath)) {
+    return bundledPath;
+  }
+
+  throw new Error(`Unable to locate EA template. Checked: ${EA_TEMPLATE_PATH_CANDIDATES.map(candidate => candidate.join('/')).join(', ')}, and bundled ${BUNDLED_EA_TEMPLATE_SEGMENTS.join('/')}`);
+}
+
+function resolveGraphDefaultSourcePath() {
+  const bundledPath = resolveArgoPath(...BUNDLED_GRAPH_DEFAULT_SEGMENTS);
+  if (fs.existsSync(bundledPath)) {
+    return bundledPath;
+  }
+
+  throw new Error(`Unable to locate default SystemArchitecture template. Checked: bundled ${BUNDLED_GRAPH_DEFAULT_SEGMENTS.join('/')}`);
 }
 
 function buildTargetFileName(workspaceName) {

package/argo/scripts/ensureArgoHarnessEnvironment.js

@@ -45,6 +45,10 @@ async function main() {
   };
 
   try {
+    report.workspaceBootstrap = await ensureWorkspaceBootstrap({
+      checkOnly: options.checkOnly,
+      workspaceRoot,
+    });
     report.mcp = verifyArgoMcpServer({ workspaceRoot });
     report.systemArchitecture = await verifyCanonicalSystemArchitecture();
     report.neo4j = await ensureNeo4jProjection({ checkOnly: options.checkOnly });
@@ -58,6 +62,9 @@ async function main() {
     report.error = formatErrorForReport(error);
   }
 
+  if (report.workspaceBootstrap && report.workspaceBootstrap.status === 'failed') {
+    report.status = 'failed';
+  }
   if (report.mcp && report.mcp.status === 'failed') {
     report.status = 'failed';
   }
@@ -99,6 +106,33 @@ function resolveWorkspaceRoot() {
   return getWorkspaceRoot();
 }
 
+async function ensureWorkspaceBootstrap({ checkOnly, workspaceRoot }) {
+  if (checkOnly) {
+    return {
+      status: 'skipped',
+      reason: 'check-only',
+    };
+  }
+
+  try {
+    const workspace = await argoMcp.initializeWorkspace(workspaceRoot);
+    return {
+      status: 'ok',
+      workspaceRoot: workspace.workspaceRoot,
+      targetFeapName: workspace.targetFeapName,
+      createdFiles: workspace.createdFiles,
+      updatedFiles: workspace.updatedFiles,
+      removedFiles: workspace.removedFiles,
+      skippedSteps: workspace.skippedSteps,
+    };
+  } catch (error) {
+    return {
+      status: 'failed',
+      error: String(error && error.message ? error.message : error),
+    };
+  }
+}
+
 async function ensureCanonicalSemanticLifecycle({ checkOnly, workspaceRoot, neo4j }) {
   if (checkOnly) {
     return {

package/argo/skills/argo-init/SKILL.md

@@ -11,6 +11,7 @@ disable-model-invocation: true
 
 - `argo` MCP 服务器（全局 `.argo` 安装）能正常初始化、列出关键工具并响应 `ping`。
 - `design/KG/SystemArchitecture.json` 可通过 `argo` MCP 正常读取和校验。
+- 工作区缺少 `design/KG/SystemArchitecture.json` 时，非 `--check-only` 模式会自动从部署的 `defaults` 拷贝默认模板；工作区没有 `.feap` 时，自动以当前项目名拷贝默认 `EA-model-template.feap`。
 - 本机 Neo4j 连接可用。
 - canonical intent graph 至少完成一次 JSON -> Neo4j 初始同步，并通过一致性校验。
 - 非 `--check-only` 模式会在结构同步后执行语义生命周期：双 gate 未开启时记录 pending/disabled；双 gate 开启时执行全量 embedding backfill 与 readiness 对齐。

package/install-argo.ps1

@@ -23,28 +23,33 @@ Write-Host '==> Deploying Argo toolchain'
 
 $schemaSrc = Join-Path $argoDir 'schema'
 $schemaDest = Join-Path $ArgoRoot 'schema'
-Write-Host "[1/4] argo\schema -> $schemaDest"
+Write-Host "[1/6] argo\schema -> $schemaDest"
 Copy-Tree -Source $schemaSrc -Destination $schemaDest
 
 $scriptsSrc = Join-Path $argoDir 'scripts'
 $scriptsDest = Join-Path $ArgoRoot 'scripts'
-Write-Host "[2/4] argo\scripts -> $scriptsDest"
+Write-Host "[2/6] argo\scripts -> $scriptsDest"
 Copy-Tree -Source $scriptsSrc -Destination $scriptsDest
 
+$defaultsSrc = Join-Path $argoDir 'defaults'
+$defaultsDest = Join-Path $ArgoRoot 'defaults'
+Write-Host "[3/6] argo\defaults -> $defaultsDest"
+Copy-Tree -Source $defaultsSrc -Destination $defaultsDest
+
 $skillSrc = Join-Path (Join-Path $argoDir 'skills') 'argo-init'
 $skillDest = Join-Path $SkillsRoot 'argo-init'
-Write-Host "[3/4] argo\skills\argo-init -> $skillDest"
+Write-Host "[4/6] argo\skills\argo-init -> $skillDest"
 Copy-Tree -Source $skillSrc -Destination $skillDest
 
 $ruleSrc = Join-Path (Join-Path $argoDir 'rules') 'archgraph.instructions.md'
 $ruleDest = Join-Path $PromptsRoot 'archgraph.instructions.md'
-Write-Host "[4/4] argo\rules\archgraph.instructions.md -> $ruleDest"
+Write-Host "[5/6] argo\rules\archgraph.instructions.md -> $ruleDest"
 New-Item -ItemType Directory -Force -Path $PromptsRoot | Out-Null
 Copy-Item -Force -Path $ruleSrc -Destination $ruleDest
 
 $depsSrc = Join-Path $argoDir 'package.json'
 $depsDest = Join-Path $ArgoRoot 'package.json'
-Write-Host "[5/5] argo\package.json -> $depsDest"
+Write-Host "[6/6] argo\package.json -> $depsDest"
 Copy-Item -Force -Path $depsSrc -Destination $depsDest
 
 if ($SkipDeps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "argo/scripts",
     "argo/schema",
+    "argo/defaults",
     "argo/skills/argo-init",
     "argo/rules",
     "argo/package.json",