@flancer32/skill-adsm-ctx 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this package are documented in this file.
+
+## 0.3.0 - 2026-08-14
+
+### Changed
+
+- Made global npm installation the canonical distribution for the Node.js runtime and agent skill payload.
+- Added the public `adsm-ctx` executable, which launches this package through TeqFW explicit-host mode.
+- Replaced documented `teq adsm-ctx:*` user commands with short `adsm-ctx` commands.
+- Updated the bundled skill installation guidance and cognitive context to describe the version-matched payload workflow.
+
+### Dependencies

package/README.md

@@ -4,7 +4,7 @@ Build and evolve project cognitive context for Agent-Driven Software Management
 
 ## Overview
 
-`@flancer32/skill-adsm-ctx` is a private ADSM skill package for initializing, designing, validating, auditing, compressing, and upgrading project cognitive context.
+`@flancer32/skill-adsm-ctx` is an ADSM skill package for initializing, designing, validating, auditing, compressing, and upgrading project cognitive context.
 
 It manages the lifecycle of project context as its primary object. It does not define business requirements, backend architecture, browser architecture, deployment logic, or domain-specific documentation on its own.
 
@@ -49,32 +49,45 @@ This package does not:
 ## Requirements
 
 - Node.js with npm.
-- GitHub SSH access to the repository for global installation from GitHub.
+- An agent skills root, normally `~/.agents/skills`.
 
-## Global Installation
+## Installation And Update
 
-Install the package globally from GitHub:
+Install the package globally once for the current user:
 
 ```sh
-npm install -g git+ssh://git@github.com/flancer32/skill-adsm-ctx.git
+npm install --global @flancer32/skill-adsm-ctx
 ```
 
-This provides the CLI command:
+Install its matching agent payload into the selected skills root:
 
 ```sh
-adsm-ctx
+adsm-ctx install-skill "$HOME/.agents/skills"
+```
+
+The command replaces only `$HOME/.agents/skills/adsm-ctx`; it does not modify other installed skills.
+
+Verify the runtime and payload:
+
+```sh
+adsm-ctx --help
+test -f "$HOME/.agents/skills/adsm-ctx/SKILL.md"
 ```
 
-To install the skill payload for agent use:
+To update, update the global npm package and reinstall its payload:
 
 ```sh
+npm update --global @flancer32/skill-adsm-ctx
 adsm-ctx install-skill "$HOME/.agents/skills"
 ```
 
-This copies the payload to:
+The npm package is the canonical distribution of both artifacts. Its public `adsm-ctx` launcher runs the package as an explicit TeqFW host; the `install-skill` command copies the version-matched `skill/` bundle. Do not copy only `SKILL.md` manually: the payload also needs its references and templates.
 
-```text
-$HOME/.agents/skills/adsm-ctx
+For a project-pinned CI or team workflow, install the package locally and invoke the same public launcher with npm:
+
+```sh
+npm install --save-dev @flancer32/skill-adsm-ctx
+npm exec -- adsm-ctx validate .
 ```
 
 ## CLI Usage
@@ -121,6 +134,12 @@ Install the bundled skill payload:
 adsm-ctx install-skill <skills-root>
 ```
 
+Advanced TeqFW users may invoke the metadata-declared commands directly when `teq` is installed:
+
+```sh
+teq --host @flancer32/skill-adsm-ctx adsm-ctx:validate .
+```
+
 ## Lifecycle Modes
 
 ### `init`
@@ -133,7 +152,7 @@ Provides guidance for classifying the project, choosing relevant documentation b
 
 ### `validate`
 
-Checks baseline paths, required documentation levels, required `AGENTS.md` files, metadata, body/skin projection shape, local markdown document links, and lightweight skin-shape heuristics. When the repository provides a deterministic validator, run it and report errors and warnings separately. Validation reports findings without modifying project content.
+Checks baseline paths, required documentation levels, required `AGENTS.md` files, metadata, body/skin pairing, localized skin names, local markdown document links, and structural projection checks. When the repository provides a deterministic validator, run it and report errors and warnings separately. Validation reports findings without modifying project content.
 
 ### `quality-audit`
 
@@ -199,7 +218,7 @@ overview.skin.en.md
 overview.skin.ru.md
 ```
 
-Use lowercase ISO 639-1 codes (`en`, `ru`, `es`); add a regional tag only for a genuine regional distinction. `overview.skin.md` is invalid. All skins with the same basename form one group with the canonical document, and may adapt the presentation for people rather than be literal translations.
+Use lowercase ISO 639-1 codes (`en`, `ru`, `es`); add a regional tag only for a genuine regional distinction. `overview.skin.md` is invalid. All skins with the same basename form one group with the canonical document, and may adapt the presentation for people rather than be literal translations. A skin uses a compact structure appropriate to its document type; its paired base is derived from the filename, so it does not need an `Agent Document` link.
 
 For `AGENTS.md` authoring, `Level Boundary` sections should stay compact and guardrail-oriented. They are intended to prevent likely scope drift, not to become exhaustive specifications.
 
@@ -228,7 +247,7 @@ When no specialized skill is available, this package should create only generic
 Run the CLI directly from the repository:
 
 ```sh
-node ./bin/cli.mjs --help
+npm exec -- adsm-ctx --help
 ```
 
 Run the tests:
@@ -237,6 +256,10 @@ Run the tests:
 npm test
 ```
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for the prepared, unpublished 0.3.0 release notes.
+
 ## Status
 
 This repository contains a working skeleton intended as a foundation for future ADSM context lifecycle tooling.

package/bin/adsm-ctx.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// @ts-check
+
+import {spawnSync} from "node:child_process";
+import {createRequire} from "node:module";
+import path from "node:path";
+import processModule from "node:process";
+import {fileURLToPath} from "node:url";
+
+const require = createRequire(import.meta.url);
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const teqPath = require.resolve("@teqfw/cli/bin/teq.mjs");
+const hostName = "@flancer32/skill-adsm-ctx";
+const commandNames = new Set(["init", "design", "validate", "upgrade", "install-skill"]);
+
+const args = normalizeArgs(processModule.argv.slice(2));
+const result = spawnSync(processModule.execPath, [
+  teqPath,
+  "--host", hostName,
+  "--host-root", packageRoot,
+  ...args,
+], {
+  cwd: processModule.cwd(),
+  env: processModule.env,
+  stdio: "inherit",
+});
+
+if (result.error) {
+  throw result.error;
+}
+processModule.exitCode = typeof result.status === "number" ? result.status : 1;
+
+/**
+ * Maps the public command surface onto the metadata-declared TeqFW commands.
+ *
+ * @param {string[]} input
+ * @returns {string[]}
+ */
+function normalizeArgs(input) {
+  if (input.length === 0 || input[0] === "--help" || input[0] === "-h") return ["help"];
+  if (input[0] === "--version" || input[0] === "-v") return ["version"];
+  if (commandNames.has(input[0])) return [`adsm-ctx:${input[0]}`, ...input.slice(1)];
+  return input;
+}

package/package.json

@@ -1,33 +1,87 @@
 {
   "name": "@flancer32/skill-adsm-ctx",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Build and evolve project cognitive context for Agent-Driven Software Management (ADSM).",
   "license": "Apache-2.0",
   "type": "module",
   "engines": {
     "node": ">=20"
   },
+  "types": "types.d.ts",
+  "files": [
+    "skill/",
+    "bin/",
+    "src/",
+    "migrations/",
+    "jsconfig.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "types.d.ts"
+  ],
   "bin": {
-    "adsm-ctx": "bin/cli.mjs"
+    "adsm-ctx": "bin/adsm-ctx.mjs"
   },
-  "types": "types.d.ts",
   "scripts": {
-    "start": "node ./bin/cli.mjs",
-    "install:skill": "node ./bin/cli.mjs install-skill \"$HOME/.agents/skills\"",
+    "start": "adsm-ctx",
+    "init": "adsm-ctx init",
+    "design": "adsm-ctx design",
+    "validate": "adsm-ctx validate",
+    "upgrade": "adsm-ctx upgrade",
+    "install:skill": "adsm-ctx install-skill \"$HOME/.agents/skills\"",
     "test:unit": "find test/unit -name '*.test.mjs' -print0 | xargs -0 -r node --test",
     "test:integration": "find test/integration -name '*.test.mjs' -print0 | xargs -0 -r node --test",
     "test": "npm run test:unit && npm run test:integration"
   },
   "dependencies": {
+    "@teqfw/cli": "^2.2.0",
     "@teqfw/di": ">=2.5.1 <3.0.0"
   },
   "teqfw": {
-    "namespaces": [
-      {
-        "prefix": "Fl32_Skill_Adsm_Ctx_",
-        "path": "./src",
-        "ext": ".mjs"
+    "fw": {
+      "di": {
+        "namespaces": [
+          {
+            "prefix": "Fl32_Skill_Adsm_Ctx_",
+            "path": "./src",
+            "ext": ".mjs"
+          }
+        ]
+      },
+      "cli": {
+        "commands": [
+          {
+            "id": "adsm-ctx:init",
+            "summary": "Initialize an ADSM context.",
+            "arguments": [{"name": "target-path", "kind": "string", "description": "Project root; defaults to the current working directory."}],
+            "component": "Fl32_Skill_Adsm_Ctx_Cli_Command_Init$"
+          },
+          {
+            "id": "adsm-ctx:design",
+            "summary": "Show ADSM context design guidance.",
+            "arguments": [{"name": "target-path", "kind": "string", "description": "Project root; defaults to the current working directory."}],
+            "component": "Fl32_Skill_Adsm_Ctx_Cli_Command_Design$"
+          },
+          {
+            "id": "adsm-ctx:validate",
+            "summary": "Validate an ADSM context.",
+            "arguments": [{"name": "target-path", "kind": "string", "description": "Project root; defaults to the current working directory."}],
+            "component": "Fl32_Skill_Adsm_Ctx_Cli_Command_Validate$"
+          },
+          {
+            "id": "adsm-ctx:upgrade",
+            "summary": "Upgrade an ADSM context.",
+            "arguments": [{"name": "target-path", "kind": "string", "description": "Project root; defaults to the current working directory."}],
+            "component": "Fl32_Skill_Adsm_Ctx_Cli_Command_Upgrade$"
+          },
+          {
+            "id": "adsm-ctx:install-skill",
+            "summary": "Install the bundled agent skill payload.",
+            "arguments": [{"name": "skills-root", "kind": "string", "required": true, "description": "Directory that contains installed agent skills."}],
+            "component": "Fl32_Skill_Adsm_Ctx_Cli_Command_InstallSkill$"
+          }
+        ]
       }
-    ]
+    }
   }
 }

package/skill/SKILL.md

@@ -13,7 +13,7 @@ Humans own direction, accepted meaning, approval, and accountability. Agents ref
 
 1. Identify the target repository and the requested lifecycle mode.
 2. Read the applicable `AGENTS.md` hierarchy. If `ctx/` exists, read `ctx/AGENTS.md` and `ctx/docs/filesystem.md` before deeper context work.
-3. Read [document-projections.md](references/document-projections.md) for any work under `ctx/docs/`.
+3. Read [document-projections.md](references/document-projections.md) for any work under `ctx/docs/`; for skin work, also read [semantic-skins.md](references/semantic-skins.md).
 4. Use the routing table below, then load only the references needed for the requested mode.
 
 ## Route The Request
@@ -30,7 +30,7 @@ Humans own direction, accepted meaning, approval, and accountability. Agents ref
 | `ctx/agent/`, templates, or generic ownership boundary | Load [orchestration-model.md](references/orchestration-model.md). |
 | Browser, backend, data, deployment, or concrete tool workflow | Load [specialized-skills.md](references/specialized-skills.md), then use a matching available specialized skill. |
 
-`install-skill` installs this payload into a skills root; it is not a lifecycle mode.
+`adsm-ctx install-skill <skills-root>` installs this payload from the globally installed npm package into a skills root; it is not a lifecycle mode.
 
 ## Non-Negotiable Boundaries
 

package/skill/references/context-lifecycle.md

@@ -1,7 +1,7 @@
 # Context Lifecycle
 
 - Path: `skill/references/context-lifecycle.md`
-- Changed: `20260715`
+- Changed: `20260814`
 
 `adsm-ctx` manages six lifecycle modes for project cognitive context.
 
@@ -13,7 +13,7 @@ The skill manages generic lifecycle structure. It does not define a project's bu
 
 - `init` creates the baseline. Create the root `AGENTS.md`, `ctx/` baseline, starter documents, and `ctx/adsm.json` only where they are missing. Use `templates/ctx/`; create placeholders rather than project facts when context is unknown.
 - `design` shapes context for the actual project. Classify the project, choose justified generic branches and nested structure, decide whether semantic skins are needed, and route specializations. Use [design-questionnaire.md](design-questionnaire.md) and [specialized-skills.md](specialized-skills.md).
-- `validate` checks structural integrity without destructive edits. Check baseline paths, context metadata, the four top-level documentation levels, local `AGENTS.md` placement, document headers, agent/skin pairs, required skin structure, local document links, and `ctx/assets/**` exclusion.
+- `validate` checks structural integrity without destructive edits. Check baseline paths, context metadata, the four top-level documentation levels, local `AGENTS.md` placement, document headers, agent/skin pairs, reversible skin naming, compactness, local document links, and `ctx/assets/**` exclusion.
 - `quality-audit` guides semantic documentation review. It is report-only by default; use [documentation-quality-audit.md](documentation-quality-audit.md) after validation.
 - `documentation-compression` guides controlled documentation rewrite that preserves accepted meaning. Use [documentation-compression.md](documentation-compression.md); do not treat it as an automatic semantic rewrite.
 - `upgrade` migrates context non-destructively. Read metadata first, preserve project-specific content, and use [upgrade-policy.md](upgrade-policy.md) for safe boundaries.
@@ -24,7 +24,7 @@ The lifecycle is iterative. A project may return to `design`, `validate`, `quali
 
 `documentation-compression` is an agent-guided rewrite mode. It is not a CLI semantic scoring command and must not change project meaning.
 
-The package-level `install-skill` command installs the skill payload into an agent skills root.
+The package-level `adsm-ctx install-skill <skills-root>` command installs the version-matched skill payload into an agent skills root.
 
 It is not a context lifecycle mode.
 

package/skill/references/document-projections.md

@@ -1,7 +1,7 @@
 # Documentation Projections
 
 - Path: `skill/references/document-projections.md`
-- Changed: `20260715`
+- Changed: `20260814`
 
 Use this reference whenever an agent initializes, designs, validates, audits, compresses, or upgrades ADSM documentation under `ctx/docs/`.
 
@@ -59,71 +59,15 @@ An agent document should reduce ambiguity and statistical guessing by making exp
 
 ## Semantic Skins
 
-A skin is a `*.skin.<lang>.md` document in the same directory as its matching agent document.
+A skin is a `*.skin.<lang>.md` document beside its paired agent document.
 
-Pairing rule:
+`name.md → name.skin.<lang>.md` and `name.skin.<lang>.md → name.md` are reversible pairing rules; an unmarked `name.skin.md` is invalid.
 
-```text
-name.md
-name.skin.en.md
-name.skin.ru.md
-```
-
-Use a lowercase ISO 639-1 language code such as `en`, `ru`, or `es`; use a regional tag only when a real regional distinction is needed. An unmarked `name.skin.md` is invalid.
-
-One agent document and all skins sharing its basename form one document group. A skin represents the same cognitive content for humans, but may reorganize or explain it for its named audience and is not required to be a literal translation.
-
-A skin is not a summary.
-
-A skin is a human-facing semantic layer.
-
-Its job is to help a human quickly restore the correct purpose, mental model, scope, and invariants of the same object described by the paired agent document.
-
-Skins should stay compact and easy to read during supervision.
-
-Recommended skin structure:
-
-```md
-# <Title>
-
-## Purpose
-
-One short sentence.
-
-## Mental Model
-
-One or two short paragraphs.
-
-## Scope
-
-Includes:
-
-- one to three items.
-
-Excludes:
-
-- one to three items.
-
-## Invariants
-
-- normally no more than five to seven items.
-
-## Agent Document
-
-`name.md`
-```
-
-Equivalent section titles are acceptable when the meaning remains clear.
-
-Do not move detailed operational instructions, verification checklists, implementation workflows, or exhaustive inventories into skins.
-
-Skin compactness is guided first by section budgets and only second by total content words.
-
-For validation, content-word counting ignores headings and document metadata where practical, strips fenced code blocks, and counts the remaining prose and list text.
+A skin is a compact skeletal human projection, not a summary or a second operational document. Its purpose is to preserve the documented object's semantic frame for human supervision.
 
-Deterministic validation treats up to 160 content words as normal, 161 through 240 content words as a warning range, and anything above 240 as an error.
+Use type-appropriate structure rather than a fixed heading template. Do not add an `Agent Document` section: pairing is already unambiguous from the filename.
 
-Missing skins are acceptable unless the document is a key human-direction document where preserving human intent is especially important.
+Read [semantic-skins.md](semantic-skins.md) for the projection model, structure examples, naming details, information-budget guidance, and review checklist.
 
 ## Read And Edit Behavior
 
@@ -256,11 +200,9 @@ Documentation quality audit should:
 Deterministic validation should:
 
 - require every `*.skin.<lang>.md` file to have a paired non-skin `*.md` document and an explicit valid language marker;
-- require the standard skin sections and the `Agent Document` reference;
-- require both `Includes:` and `Excludes:` blocks inside the skin `Scope` section;
+- require an explicit valid language marker, reversible paired-base resolution, and no redundant `Agent Document` section;
 - verify local markdown document links under `ctx/docs/**`;
 - warn when a documentation level contains more than nine direct directories or more than nine direct ordinary files (excluding `AGENTS.md` and paired `*.skin.<lang>.md` files), and require an explicit `Documentation Capacity Exception` in that level's `AGENTS.md`;
-- measure skin compactness using only the content of `Purpose`, `Mental Model`, `Scope`, and `Invariants`; exclude metadata, headings, and `Agent Document`; count Unicode-aware words and meaningful list items only; warn above 160 words or 12 list items and fail above 240 words or 20 list items;
 - keep ordinary agent-document shape checks minimal instead of imposing a rigid body template.
 
 ## Compression Rules

package/skill/references/documentation-quality-audit.md

@@ -1,7 +1,7 @@
 # Documentation Quality Audit
 
 - Path: `skill/references/documentation-quality-audit.md`
-- Changed: `20260708`
+- Changed: `20260814`
 
 Use this reference when an agent must audit an existing documentation corpus as an ADSM cognitive context.
 
@@ -59,24 +59,32 @@ Apply the criteria according to the document's projection role:
 
 ### Skin Documents
 
-Review each `*.skin.<lang>.md` file as a human-facing semantic layer.
+Review each `*.skin.<lang>.md` file as a compact skeletal human projection.
 
 Check whether:
 
-- the paired non-skin document exists when required;
-- both documents describe the same object;
-- the skin preserves purpose, mental model, scope, invariants, and a reference to the paired agent document;
-- the skin adds untracked requirements not present in the paired agent document;
-- the skin contradicts the paired agent document;
-- the skin stays compact, human-readable, and free of excessive operational detail.
+- the paired non-skin document exists and both documents describe the same object;
+- the skin preserves the main meaning and exposes the base document's load-bearing structure;
+- boundaries, key constraints, and likely misreadings are retained;
+- the structure suits the base document's type rather than following a fixed heading set;
+- the skin adds no untracked requirements or facts and does not contradict the base;
+- operational detail and redundant pairing navigation are excluded; and
+- the skin remains small enough for human cognitive use.
 
-The review should answer:
+### Cognitive Information Budget
+
+Use evidence from the skin and its paired base; do not claim universal cognitive limits. Check whether:
+
+- one central thesis is identifiable after one reading;
+- 3–5 meaningful chunks normally organize the frame, and more than 7 is justified by a shared reader schema;
+- each block adds an irreducible distinction rather than formatting, repetition, navigation, or methodology noise;
+- boundaries, key constraints, and dangerous misreadings survive compression;
+- operational detail is excluded; and
+- a longer skin (roughly 300–350 words) is justified by irreducible distinctions, while a shorter one has not made meaning ambiguous.
+
+The ranges are editorial review prompts, not automatic pass/fail thresholds.
 
-- does the document work as a human-facing semantic layer;
-- does it preserve the same meaning as the paired agent document;
-- does it avoid operational overload;
-- does it add untracked requirements;
-- what must be changed.
+The review should distinguish a meaningful skeletal projection from a short operational summary. See [semantic-skins.md](semantic-skins.md) for structure examples.
 
 ### Agent Documents
 

package/skill/references/semantic-skins.md

@@ -0,0 +1,65 @@
+# Semantic Skins
+
+- Path: `skill/references/semantic-skins.md`
+- Changed: `20260814`
+
+A semantic skin is a compact skeletal human projection of its paired agent document.
+
+It lets a human recover the documented object's semantic frame without loading operational detail.
+
+A skin is neither a mechanical summary nor a second operational specification.
+
+## Pairing And Naming
+
+A skin is located beside its paired ordinary `*.md` agent document.
+
+`name.md → name.skin.<language>.md`
+
+`name.skin.<language>.md → name.md`
+
+Use lowercase ISO 639-1 language codes such as `en`, `ru`, or `es`; add a regional tag only for a genuine distinction.
+
+The reversible filename convention is the authoritative pairing navigation. Do not add an `Agent Document` section or a redundant link.
+
+## Projection Rule
+
+State the purpose of the documented object, not the purpose of its file or skin.
+
+Preserve the base document's load-bearing meaning: its decisive concepts, boundaries, constraints, relations, and likely misreadings.
+
+Do not add requirements, facts, or decisions absent from the paired agent document. Do not reproduce verification steps, exhaustive inventories, implementation procedure, or agent-routing detail.
+
+## Information Budget
+
+A skin has an information budget, not a universal word budget: a human should restore its semantic frame in one calm reading without loading operations.
+
+A semantic chunk is one meaningful, mutually distinct unit needed to recover that frame. It is not a heading, list item, sentence, or word count.
+
+As soft editorial prompts, prefer 3–5 chunks; more than 7 needs review unless readers share a strong schema. About 120–250 words is often suitable. 300–350 words needs a stated reason: irreducible distinctions, not verbosity. These ranges are not scientific limits and never drive automatic validation.
+
+A longer skin is justified when omitting a load-bearing distinction would mislead. A shorter skin is insufficient when compression makes a required distinction ambiguous.
+
+## Choose The Skeleton
+
+Use the cognitive form of the documented object rather than a universal heading set.
+
+- overview or identity — purpose, mental model, boundaries, invariants;
+- domain model — concepts, levels, key relations, constraints;
+- decision — decision, rationale, consequences, rejected alternatives;
+- process — goal, flow, inputs and outcomes, exceptions;
+- reference or map — navigational structure, terms, governing rules.
+
+Equivalent concise headings are valid. A skin need not use every suggested heading.
+
+## Creation And Review
+
+Read every existing matching skin before changing its agent document.
+
+When creating or reviewing a skin, verify that it:
+
+- preserves the document's main meaning and load-bearing structure;
+- retains boundaries, key constraints, and likely misreadings;
+- uses a skeleton appropriate to the document type;
+- adds no untracked facts or requirements and does not contradict its base;
+- excludes operational detail and redundant navigation; and
+- remains compact enough for human cognitive use.

package/skill/templates/work/context/semantic-skin.md

@@ -1,27 +1,16 @@
-# <Title>
+# <Document Title>
 
-## Purpose
+- Path: `ctx/docs/{{subdir}}/<name>.skin.<lang>.md`
+- Changed: `YYYYMMDD`
 
-One short sentence.
+Use a compact, type-appropriate skeleton that lets a human recover the documented object's meaning.
 
-## Mental Model
+Do not describe this file or skin. Do not include an `Agent Document` link: its paired base is derived from the filename.
 
-One or two short paragraphs that restore the human frame.
+Choose only the relevant sections, for example:
 
-## Scope
-
-Includes:
-
-- one to three items.
-
-Excludes:
-
-- one to three items.
-
-## Invariants
-
-- normally no more than five to seven items.
-
-## Agent Document
-
-`name.md`
+- overview — purpose, mental model, boundaries, invariants;
+- domain model — concepts, relations, constraints;
+- decision — decision, rationale, consequences;
+- process — goal, flow, outcomes, exceptions;
+- reference — map, terms, governing rules.

package/src/Cli/Command/Design.mjs

@@ -0,0 +1,17 @@
+// @ts-check
+
+import processModule from "node:process";
+
+/** @namespace Fl32_Skill_Adsm_Ctx_Cli_Command_Design */
+export default class Design {
+  constructor({config, design}) {
+    this.id = "adsm-ctx:design";
+    this.summary = "Show ADSM context design guidance.";
+    this.lifetime = "finite";
+    this.execute = async function ({args}) {
+      processModule.stdout.write(`${await design.execute({targetPath: args["target-path"] ?? config.cwd})}\n`);
+    };
+  }
+}
+
+export const __deps__ = Object.freeze({default: Object.freeze({config: "TeqFw_Cli_Config$", design: "Fl32_Skill_Adsm_Ctx_Design_Service$"})});

package/src/Cli/Command/Init.mjs

@@ -0,0 +1,22 @@
+// @ts-check
+
+import processModule from "node:process";
+
+/** @namespace Fl32_Skill_Adsm_Ctx_Cli_Command_Init */
+export default class Init {
+  constructor({config, init}) {
+    this.id = "adsm-ctx:init";
+    this.summary = "Initialize an ADSM context.";
+    this.lifetime = "finite";
+    this.execute = async function ({args}) {
+      const result = await init.execute({targetPath: args["target-path"] ?? config.cwd});
+      processModule.stdout.write(`${formatInitReport(result)}\n`);
+    };
+  }
+}
+
+function formatInitReport(result) {
+  return [`Initialized ADSM context in ${result.ctxRoot}`, ...result.created.map((entry) => `Created: ${entry}`), ...result.skipped.map((entry) => `Skipped: ${entry}`)].join("\n");
+}
+
+export const __deps__ = Object.freeze({default: Object.freeze({config: "TeqFw_Cli_Config$", init: "Fl32_Skill_Adsm_Ctx_Init_Service$"})});

package/src/Cli/Command/InstallSkill.mjs

@@ -0,0 +1,18 @@
+// @ts-check
+
+import processModule from "node:process";
+
+/** @namespace Fl32_Skill_Adsm_Ctx_Cli_Command_InstallSkill */
+export default class InstallSkill {
+  constructor({installer}) {
+    this.id = "adsm-ctx:install-skill";
+    this.summary = "Install the bundled agent skill payload.";
+    this.lifetime = "finite";
+    this.execute = async function ({args}) {
+      const targetDir = await installer.execute({targetRoot: args["skills-root"]});
+      processModule.stdout.write(`Installed skill payload to ${targetDir}\n`);
+    };
+  }
+}
+
+export const __deps__ = Object.freeze({default: Object.freeze({installer: "Fl32_Skill_Adsm_Ctx_Skill_Installer$"})});