@kontourai/flow-agents 1.0.1 → 1.2.0

package/build/src/cli/promote-workflow-artifact.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { parseArgs, flagString } from "../lib/args.js";
 import { isoNow, relPath } from "../lib/fs.js";
@@ -59,5 +60,21 @@ export function main(argv = process.argv.slice(2)) {
     console.log(`archived_artifact=${archive}`);
     return 0;
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/publish-change-helper.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { parseArgs, flagString } from "../lib/args.js";
 import { readJson } from "../lib/fs.js";
@@ -150,5 +151,21 @@ export function main(argv = process.argv.slice(2)) {
         return 1;
     }
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/pull-work-provider.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import { parseArgs, flagList, flagString } from "../lib/args.js";
 const FLOW_ARTIFACT_PATTERN = /(?<path>\.flow-agents\/[^\s`'")]+)/g;
 const GITHUB_ISSUE_PATTERN = /(?:(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+))?#(?<number>\d+)/g;
@@ -465,5 +466,21 @@ export function main(argv = process.argv.slice(2)) {
     console.log(JSON.stringify({ items }, null, 2));
     return 0;
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/runtime-adapter.js

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { parseArgs, flagString } from "../lib/args.js";
 import { activateCodexLocal, activateStrandsLocal } from "../runtime-adapters.js";
@@ -23,5 +25,21 @@ export function main(argv = process.argv.slice(2)) {
     console.log(JSON.stringify(result, null, 2));
     return Array.isArray(result.errors) && result.errors.length ? 1 : 0;
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/usage-feedback.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as os from "node:os";
 import * as path from "node:path";
 import { parseArgs, flagBool, flagList, flagString } from "../lib/args.js";
@@ -439,5 +440,21 @@ export function main(argv = process.argv.slice(2)) {
         return 1;
     }
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/utterance-check.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { flagBool, flagString, parseArgs } from "../lib/args.js";
 // ---------------------------------------------------------------------------
@@ -232,5 +233,21 @@ export async function main(argv = process.argv.slice(2)) {
     }
     return runCheck(rest);
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(await main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = await main();
+}

package/build/src/cli/validate-hook-influence.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 const validTiers = new Set(["adapter", "design-target", "installed-command", "live-acceptance", "documented-runtime-gap"]);
 const validRuntimes = new Set(["codex", "claude-code", "kiro-cli"]);
 const validHooks = new Set(["workflow-steering", "stop-goal-fit"]);
@@ -148,5 +149,21 @@ export function main(argv = process.argv.slice(2)) {
         return 1;
     }
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/validate-source-tree.js

@@ -1,11 +1,11 @@
 import * as path from "node:path";
 import { parseArgs } from "../lib/args.js";
 import { validateKitRepository } from "../flow-kit/validate.js";
-export function main(argv = process.argv.slice(2)) {
+export async function main(argv = process.argv.slice(2)) {
     const args = parseArgs(argv);
     const kit = args.flags.kit;
     if (typeof kit === "string") {
-        const errors = validateKitRepository(path.resolve(kit));
+        const errors = await validateKitRepository(path.resolve(kit));
         if (errors.length) {
             console.log("Flow Kit repository validation failed:");
             for (const error of errors)
@@ -17,7 +17,7 @@ export function main(argv = process.argv.slice(2)) {
     }
     const root = path.resolve(".");
     const builder = path.join(root, "kits", "builder");
-    const errors = validateKitRepository(builder);
+    const errors = await validateKitRepository(builder);
     if (errors.length) {
         console.log("Source tree validation failed:");
         for (const error of errors)
@@ -44,5 +44,5 @@ catch {
     return process.argv[1];
 } })();
 if (_selfVST === _argv1VST) {
-    process.exitCode = main();
+    main().then((code) => { process.exitCode = code; }).catch((err) => { console.error(err); process.exitCode = 1; });
 }

package/build/src/cli/veritas-governance.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import { flagBool, flagString, parseArgs } from "../lib/args.js";
@@ -258,5 +259,21 @@ export function main(argv = process.argv.slice(2)) {
     const options = parseEvidenceOptions(argv);
     return options ? runEvidence(options) : 2;
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/workflow-artifact-cleanup-audit.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
 import { flagBool, flagString, parseArgs } from "../lib/args.js";
 const ACTIVE_STATUSES = new Set([
@@ -268,5 +269,21 @@ export function main(argv = process.argv.slice(2)) {
         printText(result);
     return 0;
 }
-if (import.meta.url === `file://${process.argv[1]}`)
-    process.exit(main());
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli.js

@@ -2,7 +2,7 @@
 import { basename } from "node:path";
 import { main as effectiveBacklogSettings } from "./cli/effective-backlog-settings.js";
 import { main as consoleLearningProjection } from "./cli/console-learning-projection.js";
-import { main as flowKit } from "./cli/flow-kit.js";
+import { main as kit } from "./cli/kit.js";
 import { main as fixtureRetirementAudit } from "./cli/fixture-retirement-audit.js";
 import { main as init } from "./cli/init.js";
 import { main as promoteWorkflowArtifact } from "./cli/promote-workflow-artifact.js";
@@ -27,7 +27,7 @@ const availableCommands = new Map([
     ["effective-backlog-settings", effectiveBacklogSettings],
     ["filter-installed-packs", filterInstalledPacks],
     ["fixture-retirement-audit", fixtureRetirementAudit],
-    ["flow-kit", flowKit],
+    ["kit", kit],
     ["init", init],
     ["promote-workflow-artifact", promoteWorkflowArtifact],
     ["publish-change", publishChange],
@@ -49,7 +49,7 @@ const aliases = new Map([
     ["flow-agents-effective-backlog-settings", "effective-backlog-settings"],
     ["flow-agents-filter-installed-packs", "filter-installed-packs"],
     ["flow-agents-fixture-retirement-audit", "fixture-retirement-audit"],
-    ["flow-agents-flow-kit", "flow-kit"],
+    ["flow-agents-kit", "kit"],
     ["flow-agents-promote-workflow-artifact", "promote-workflow-artifact"],
     ["flow-agents-publish-change", "publish-change"],
     ["flow-agents-pull-work-provider", "pull-work-provider"],

package/build/src/flow-kit/validate.js

@@ -1,49 +1,52 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { readJson } from "../lib/fs.js";
-const ASSET_CLASSES = ["flows", "skills", "docs", "adapters", "evals", "assets"];
+// Extension-only asset classes: validated by Flow Agents. Flows are validated by @kontourai/flow.
+const EXTENSION_ASSET_CLASSES = ["skills", "docs", "adapters", "evals", "assets"];
 // Core container fields owned by kontourai/flow (flow-kit-container.schema.json).
 // agent-extension fields are skills, docs, adapters, evals, assets.
 const CORE_CONTAINER_FIELDS = new Set(["schema_version", "id", "name", "description", "product_name", "flows"]);
 const AGENT_EXTENSION_CLASSES = new Set(["skills", "docs", "adapters", "evals", "assets"]);
+let _validateKitContainerCache = null;
+async function loadValidateKitContainer() {
+    if (_validateKitContainerCache)
+        return _validateKitContainerCache;
+    let mod;
+    try {
+        mod = await import("@kontourai/flow");
+    }
+    catch (err) {
+        throw new Error("container validation requires @kontourai/flow; run from an npm-installed flow-agents workspace " +
+            `or use 'flow kit validate' (original error: ${err.message})`);
+    }
+    if (typeof mod.validateKitContainer !== "function") {
+        throw new Error("@kontourai/flow did not export validateKitContainer");
+    }
+    _validateKitContainerCache = mod.validateKitContainer;
+    return _validateKitContainerCache;
+}
 /**
- * Validates that the manifest satisfies the core Flow Kit container contract
- * (as specified by kontourai/flow PR #67) with all agent-extension fields stripped.
- * Returns a list of violation messages (empty = valid).
+ * Delegates core Flow Kit container validation to @kontourai/flow's validateKitContainer.
+ * The container contract lives once, in Flow. Returns a list of violation messages (empty = valid).
  *
  * The degradation invariant: every Flow Agents Kit MUST remain a valid core
  * Flow Kit container when agent-extension fields are ignored.
+ *
+ * Loads @kontourai/flow lazily (on first call) so that runtime ops (list/status/activate)
+ * that never invoke validation can run in standalone installed bundles where
+ * @kontourai/flow is not present.
+ *
+ * @param kitDir  Real kit directory path for file-existence checks on flows[].path entries.
+ *                Pass the actual kit directory when available; pass "" for structural-only checks.
  */
-export function validateCoreContainer(manifest, label) {
-    const errors = [];
-    if (manifest.schema_version !== "1.0") {
-        errors.push(`${label}: .schema_version must be "1.0"`);
-    }
-    if (typeof manifest.id !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(manifest.id)) {
-        errors.push(`${label}: .id must be a stable kebab-case string`);
-    }
-    if (typeof manifest.name !== "string" || !manifest.name.trim()) {
-        errors.push(`${label}: .name must be a non-empty string`);
-    }
-    if (!Array.isArray(manifest.flows) || manifest.flows.length === 0) {
-        errors.push(`${label}: .flows must be a non-empty list`);
-    }
-    else {
-        manifest.flows.forEach((entry, index) => {
-            if (typeof entry !== "object" || entry === null) {
-                errors.push(`${label}: flows[${index}] must be an object`);
-                return;
-            }
-            const flow = entry;
-            if (typeof flow.id !== "string" || !flow.id) {
-                errors.push(`${label}: flows[${index}].id must be a string`);
-            }
-            if (typeof flow.path !== "string" || !flow.path) {
-                errors.push(`${label}: flows[${index}].path must be a string`);
-            }
-        });
-    }
-    return errors;
+async function delegateCoreContainerValidation(kitDir, manifest) {
+    const validateKitContainer = await loadValidateKitContainer();
+    const result = validateKitContainer(kitDir, manifest);
+    if (result.valid)
+        return [];
+    return result.diagnostics
+        .filter((d) => d.severity === "error")
+        .map((d) => `${d.path}: ${d.message}`);
 }
 /**
  * Derives the consumer-target level (K0/K1/K2) and target audience list from
@@ -56,11 +59,16 @@ export function validateCoreContainer(manifest, label) {
  *  - targets.flow: always present when K0 (any Flow consumer can evaluate gates).
  *  - targets.flow-agents: present when K1 (agent extension assets activate in >=1 harness).
  *  - third-party: any top-level keys that are not core fields and not Flow Agents extension classes.
+ *
+ * @param manifest  The kit.json manifest object.
+ * @param kitDir    Kit directory for flow file-existence checks. Defaults to "" (structural-only).
+ *                  Pass the real kit directory from `inspect` to get authoritative K0 validation.
  */
-export function deriveKitTargets(manifest) {
+export async function deriveKitTargets(manifest, kitDir = "") {
     const kitId = typeof manifest.id === "string" ? manifest.id : "<unknown>";
     const kitName = typeof manifest.name === "string" ? manifest.name : "<unknown>";
-    const coreErrors = validateCoreContainer(manifest, "kit.json");
+    // Delegate core container validation to @kontourai/flow.
+    const coreErrors = await delegateCoreContainerValidation(kitDir, manifest);
     const k0 = coreErrors.length === 0;
     const hasAgentExtension = AGENT_EXTENSION_CLASSES.size > 0 &&
         [...AGENT_EXTENSION_CLASSES].some((cls) => Array.isArray(manifest[cls]) && manifest[cls].length > 0);
@@ -87,7 +95,7 @@ export function deriveKitTargets(manifest) {
         third_party_extensions: thirdPartyExtensions,
     };
 }
-export function validateKitRepository(kitDir) {
+export async function validateKitRepository(kitDir) {
     const errors = [];
     const manifestPath = path.join(kitDir, "kit.json");
     let manifest;
@@ -98,27 +106,16 @@ export function validateKitRepository(kitDir) {
         errors.push(`${manifestPath}: invalid JSON: ${error.message}`);
         return errors;
     }
-    if (manifest.schema_version !== "1.0")
-        errors.push(`${manifestPath}: .schema_version must be "1.0"`);
-    if (typeof manifest.id !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(manifest.id)) {
-        errors.push(`${manifestPath}: .id must be a stable kebab-case string`);
-    }
-    if (typeof manifest.name !== "string" || !manifest.name.trim())
-        errors.push(`${manifestPath}: .name must be a non-empty string`);
-    // Degradation invariant: every Flow Agents Kit must remain a valid core Flow Kit container
-    // when agent-extension fields are stripped. Strip extensions and re-validate core contract.
-    const coreManifest = {};
-    for (const key of Object.keys(manifest)) {
-        if (CORE_CONTAINER_FIELDS.has(key))
-            coreManifest[key] = manifest[key];
-    }
-    const coreErrors = validateCoreContainer(coreManifest, manifestPath);
-    for (const err of coreErrors) {
-        // Deduplicate: only add if not already covered by top-level checks above.
-        if (!errors.some((existing) => existing === err))
-            errors.push(err);
-    }
-    for (const section of ASSET_CLASSES) {
+    // Delegate core container validation (schema_version, id, name, flows including file
+    // existence) to @kontourai/flow — the container contract lives once, in Flow.
+    // This enforces the degradation invariant: a Flow Agents Kit must remain a valid
+    // core Flow Kit container when extension fields are stripped.
+    const coreErrors = await delegateCoreContainerValidation(kitDir, manifest);
+    for (const err of coreErrors)
+        errors.push(err);
+    // Flow Agents extension validation: skills, docs, adapters, evals, assets.
+    // Flows are validated above by @kontourai/flow; only extension classes are checked here.
+    for (const section of EXTENSION_ASSET_CLASSES) {
         const entries = manifest[section];
         if (entries === undefined)
             continue;
@@ -155,15 +152,14 @@ export function validateKitRepository(kitDir) {
                 return;
             }
             if (!fs.existsSync(resolved)) {
-                const noun = section === "flows" ? "Flow Definition" : "asset";
-                errors.push(`${manifestPath}: ${section}[${index}].path points at missing ${noun}: ${rel}`);
+                errors.push(`${manifestPath}: ${section}[${index}].path points at missing asset: ${rel}`);
             }
         });
     }
     return errors;
 }
-export function assertKitRepository(kitDir) {
-    const errors = validateKitRepository(kitDir);
+export async function assertKitRepository(kitDir) {
+    const errors = await validateKitRepository(kitDir);
     if (errors.length) {
         const error = new Error("Flow Kit repository validation failed");
         error.diagnostics = errors;

package/build/src/runtime-adapters.js

@@ -118,31 +118,48 @@ export function readKitInventory(sourceRoot, dest) {
 function safeSegment(value) {
     return value.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "") || "asset";
 }
+// Asset classes that are directly activated (copied to the runtime directory) by both adapters.
+// flows: gate definitions read by the adapter's flow-routing layer.
+// skills: agent guidance markdown copied to skills/<kit-id>/ for agent discovery.
+// docs: documentation markdown copied to docs/<kit-id>/ for agent reference.
+const ACTIVATED_ASSET_CLASSES = new Set(["flows", "skills", "docs"]);
 export function activateCodexLocal(sourceRoot, dest) {
     const inventory = readKitInventory(sourceRoot, dest);
     const runtimeDir = path.join(dest, ".flow-agents", "runtime", "codex");
     const generated = [];
     const skipped = [];
     for (const asset of inventory.assets) {
-        if (asset.asset_class !== "flows") {
-            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: asset.asset_id, reason: "asset class is diagnostic-only for codex-local" });
-            continue;
+        if (asset.asset_class === "flows") {
+            if (!asset.asset_id) {
+                skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: null, reason: "flow asset is missing an id" });
+                continue;
+            }
+            const output = path.join(runtimeDir, "flows", safeSegment(asset.kit_id), `${safeSegment(asset.asset_id)}.flow.json`);
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.copyFileSync(asset.source_path, output);
+            generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id, source_path: asset.source_path.split(path.sep).join("/") });
         }
-        if (!asset.asset_id) {
-            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: null, reason: "flow asset is missing an id" });
-            continue;
+        else if (asset.asset_class === "skills" || asset.asset_class === "docs") {
+            // Copy skills and docs to runtime/<adapter>/<class>/<kit-id>/<filename> so the
+            // agent's guidance index (AGENTS.md) can reference them and they are co-located
+            // with flow definitions for the same kit.
+            const filename = path.basename(asset.source_path);
+            const output = path.join(runtimeDir, asset.asset_class, safeSegment(asset.kit_id), filename);
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.copyFileSync(asset.source_path, output);
+            generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id ?? "", source_path: asset.source_path.split(path.sep).join("/") });
+        }
+        else {
+            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: asset.asset_id, reason: "asset class is not activated by codex-local" });
         }
-        const output = path.join(runtimeDir, "flows", safeSegment(asset.kit_id), `${safeSegment(asset.asset_id)}.flow.json`);
-        fs.mkdirSync(path.dirname(output), { recursive: true });
-        fs.copyFileSync(asset.source_path, output);
-        generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id, source_path: asset.source_path.split(path.sep).join("/") });
     }
     fs.mkdirSync(runtimeDir, { recursive: true });
-    const manifest = { schema_version: "1.0", adapter: "codex-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+    const supportedClasses = Array.from(ACTIVATED_ASSET_CLASSES);
+    const manifest = { schema_version: "1.0", adapter: "codex-local", supported_asset_classes: supportedClasses, generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
     const manifestPath = path.join(runtimeDir, "activation.json");
     writeJson(manifestPath, manifest);
     generated.push({ asset_class: "activation-manifest", path: relPath(dest, manifestPath), kit_id: "runtime", asset_id: "codex-local.activation", source_path: manifestPath.split(path.sep).join("/") });
-    return { selected_adapter: "codex-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+    return { selected_adapter: "codex-local", supported_asset_classes: supportedClasses, generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
 }
 // Decision Q3 (Issue #32): Option (a) — new adapter id "strands-local" rather than
 // loading kit flows inside FlowAgentsHooks. Rationale: activation is a workspace-prep
@@ -154,27 +171,41 @@ export function activateStrandsLocal(sourceRoot, dest) {
     const inventory = readKitInventory(sourceRoot, dest);
     // Runtime flows land at .flow-agents/runtime/strands/flows/<kit-id>/<asset-id>.flow.json
     // so the Strands steering context can glob for *.flow.json under this path.
+    // Runtime skills land at .flow-agents/runtime/strands/skills/<kit-id>/<filename> and
+    // docs at .flow-agents/runtime/strands/docs/<kit-id>/<filename> for system-prompt injection.
     const runtimeDir = path.join(dest, ".flow-agents", "runtime", "strands");
     const generated = [];
     const skipped = [];
     for (const asset of inventory.assets) {
-        if (asset.asset_class !== "flows") {
-            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: asset.asset_id, reason: "asset class is diagnostic-only for strands-local" });
-            continue;
+        if (asset.asset_class === "flows") {
+            if (!asset.asset_id) {
+                skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: null, reason: "flow asset is missing an id" });
+                continue;
+            }
+            const output = path.join(runtimeDir, "flows", safeSegment(asset.kit_id), `${safeSegment(asset.asset_id)}.flow.json`);
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.copyFileSync(asset.source_path, output);
+            generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id, source_path: asset.source_path.split(path.sep).join("/") });
         }
-        if (!asset.asset_id) {
-            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: null, reason: "flow asset is missing an id" });
-            continue;
+        else if (asset.asset_class === "skills" || asset.asset_class === "docs") {
+            // Mirror the codex-local layout: strands/<class>/<kit-id>/<filename>.
+            // The Strands system-prompt injection layer can glob for all *.md files under
+            // .flow-agents/runtime/strands/skills/ to include agent guidance in the context.
+            const filename = path.basename(asset.source_path);
+            const output = path.join(runtimeDir, asset.asset_class, safeSegment(asset.kit_id), filename);
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.copyFileSync(asset.source_path, output);
+            generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id ?? "", source_path: asset.source_path.split(path.sep).join("/") });
+        }
+        else {
+            skipped.push({ asset_class: asset.asset_class, path: asset.relative_path, kit_id: asset.kit_id, asset_id: asset.asset_id, reason: "asset class is not activated by strands-local" });
         }
-        const output = path.join(runtimeDir, "flows", safeSegment(asset.kit_id), `${safeSegment(asset.asset_id)}.flow.json`);
-        fs.mkdirSync(path.dirname(output), { recursive: true });
-        fs.copyFileSync(asset.source_path, output);
-        generated.push({ asset_class: asset.asset_class, path: relPath(dest, output), kit_id: asset.kit_id, asset_id: asset.asset_id, source_path: asset.source_path.split(path.sep).join("/") });
     }
     fs.mkdirSync(runtimeDir, { recursive: true });
-    const manifest = { schema_version: "1.0", adapter: "strands-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+    const supportedClasses = Array.from(ACTIVATED_ASSET_CLASSES);
+    const manifest = { schema_version: "1.0", adapter: "strands-local", supported_asset_classes: supportedClasses, generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
     const manifestPath = path.join(runtimeDir, "activation.json");
     writeJson(manifestPath, manifest);
     generated.push({ asset_class: "activation-manifest", path: relPath(dest, manifestPath), kit_id: "runtime", asset_id: "strands-local.activation", source_path: manifestPath.split(path.sep).join("/") });
-    return { selected_adapter: "strands-local", supported_asset_classes: ["flows"], generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
+    return { selected_adapter: "strands-local", supported_asset_classes: supportedClasses, generated_runtime_files: generated, skipped_assets: skipped, warnings: inventory.warnings, errors: inventory.errors };
 }