@multileaf/ai-workflow 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project are documented in this file. The format foll
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-08
+
+### Added
+
+- Interactive optional-model onboarding during `aiw install`: in an interactive terminal, the installer asks whether to enable semantic mapping and advisory decision triage and writes `.aiw/semantic.yml` / `.aiw/decision.yml` with defaults before `/ai-init` runs. Non-interactive installs skip the prompts, and existing configuration files are never overwritten.
+
 ## [0.3.0] - 2026-10-08
 
 ### Added

package/dist/decision.d.ts

@@ -43,6 +43,7 @@ export type DecisionProvider = {
 export declare const DECISION_CONFIG_PATH = "decision.yml";
 export declare const DEFAULT_DECISION_CONFIG: DecisionConfig;
 export declare function parseDecisionConfig(text: string): DecisionConfig;
+export declare function serializeDecisionConfig(config: DecisionConfig): string;
 export declare function loadDecisionConfig(fs: FileSystem, aiwPath: string): DecisionConfig | undefined;
 export declare function parseDecisionResponse(text: string): DecisionResponse;
 export declare function createOllamaDecisionProvider(config: DecisionConfig): DecisionProvider;

package/dist/decision.js

@@ -24,6 +24,9 @@ export function parseDecisionConfig(text) {
         throw new Error("decision.baseUrl must be an http(s) URL when decision mapping is enabled");
     return { enabled: true, model, baseUrl };
 }
+export function serializeDecisionConfig(config) {
+    return `decision:\n  enabled: ${config.enabled}\n  model: ${config.model}\n  baseUrl: ${config.baseUrl}\n`;
+}
 export function loadDecisionConfig(fs, aiwPath) {
     const configPath = `${aiwPath}/${DECISION_CONFIG_PATH}`;
     if (!fs.exists(configPath))

package/dist/semantic.d.ts

@@ -29,6 +29,7 @@ export declare const SEMANTIC_CONFIG_PATH = "semantic.yml";
 export declare const SEMANTIC_INDEX_PATH = "semantic/index.json";
 export declare const DEFAULT_SEMANTIC_CONFIG: SemanticConfig;
 export declare function parseSemanticConfig(text: string): SemanticConfig;
+export declare function serializeSemanticConfig(config: SemanticConfig): string;
 export declare function loadSemanticConfig(fs: FileSystem, aiwPath: string): SemanticConfig | undefined;
 export declare function createOllamaEmbeddingProvider(config: SemanticConfig): EmbeddingProvider;
 export declare function chunkText(content: string, chunkChars: number): string[];

package/dist/semantic.js

@@ -35,6 +35,9 @@ export function parseSemanticConfig(text) {
         throw new Error("semantic.topK must be a positive integer");
     return { enabled: true, model, baseUrl, chunkChars: parsedChunk, topK: parsedTopK };
 }
+export function serializeSemanticConfig(config) {
+    return `semantic:\n  enabled: ${config.enabled}\n  model: ${config.model}\n  baseUrl: ${config.baseUrl}\n  chunkChars: ${config.chunkChars}\n  topK: ${config.topK}\n`;
+}
 export function loadSemanticConfig(fs, aiwPath) {
     const configPath = `${aiwPath}/${SEMANTIC_CONFIG_PATH}`;
     if (!fs.exists(configPath))

package/dist/workflow.d.ts

@@ -2,3 +2,5 @@ import type { CommandResult, FileSystem } from "./types.js";
 import type { WorkflowDependencies } from "./services.js";
 export type WorkflowServices = WorkflowDependencies;
 export declare function runCommand(args: string[], root: string, fs: FileSystem, services?: WorkflowServices): Promise<CommandResult>;
+export type ConfirmQuestion = (question: string) => Promise<string>;
+export declare function configureOptionalModels(fs: FileSystem, aiwPath: string, answer: ConfirmQuestion): Promise<string[]>;

package/dist/workflow.js

@@ -21,8 +21,8 @@ import { validatePackageContract } from "./package-contract.js";
 import { parseLock, resolvePackage, serializeLock } from "./lockfile.js";
 import { executeVercelSkills, installVercelSkill, nodeCommandExecutor } from "./vercel-skills.js";
 import { scanProject } from "./scanner.js";
-import { buildEvidenceTriageRequest, createOllamaDecisionProvider, loadDecisionConfig, DECISION_CONFIG_PATH, } from "./decision.js";
-import { buildSemanticIndex, createOllamaEmbeddingProvider, loadSemanticConfig, parseSemanticIndex, querySemanticIndex, SEMANTIC_INDEX_PATH, serializeSemanticIndex, } from "./semantic.js";
+import { buildEvidenceTriageRequest, createOllamaDecisionProvider, DEFAULT_DECISION_CONFIG, DECISION_CONFIG_PATH, loadDecisionConfig, serializeDecisionConfig, } from "./decision.js";
+import { buildSemanticIndex, createOllamaEmbeddingProvider, DEFAULT_SEMANTIC_CONFIG, loadSemanticConfig, parseSemanticIndex, querySemanticIndex, SEMANTIC_CONFIG_PATH, SEMANTIC_INDEX_PATH, serializeSemanticConfig, serializeSemanticIndex, } from "./semantic.js";
 import { assertKnownPermissions, assertPermissions, assertPackagePermissions, serializePermissionReview, } from "./package-audit.js";
 import { planPackageUpdate } from "./package-updates.js";
 import { searchRegistry, serializeRegistry } from "./registry.js";
@@ -327,9 +327,22 @@ export async function runCommand(args, root, fs, services = {}) {
             pendingWrites.delete(manifestPath);
             pendingWrites.set(manifestPath, `schema: 1\nproject:\n  name: ${root.split("/").pop()}\ntarget:\n  active: ${target}\npolicies:\n  artifact_language: en\n`);
             writeProjectFilesAtomically(fs, root, [...pendingWrites].map(([path, content]) => ({ path, content })), [...BASE_DIRECTORIES.map((directory) => join(aiw, directory)), join(root, ".context/adrs")]);
+            let optionalModels = [];
+            if (stdin.isTTY) {
+                const terminal = createInterface({ input: stdin, output: stdout });
+                try {
+                    optionalModels = await configureOptionalModels(fs, aiw, (question) => terminal.question(question));
+                }
+                finally {
+                    terminal.close();
+                }
+            }
             return {
                 exitCode: 0,
-                output: `AI Workflow initialized for target: ${target} with only the ai-init skill. Run /ai-init to scan the project and choose which resources to install.`,
+                output: `AI Workflow initialized for target: ${target} with only the ai-init skill. Run /ai-init to scan the project and choose which resources to install.` +
+                    (optionalModels.length
+                        ? ` Optional models enabled: ${optionalModels.join(", ")}. They activate once the models are available.`
+                        : ""),
             };
         }
         if (command === "telemetry") {
@@ -1781,6 +1794,30 @@ function approvalArtifactPath(aiw, stage) {
     };
     return resolve(aiw, paths[stage]);
 }
+export async function configureOptionalModels(fs, aiwPath, answer) {
+    const enabled = [];
+    const semanticPath = join(aiwPath, SEMANTIC_CONFIG_PATH);
+    if (!fs.exists(semanticPath)) {
+        const response = (await answer(`Enable semantic mapping with a local embedding model (default: ${DEFAULT_SEMANTIC_CONFIG.model} at ${DEFAULT_SEMANTIC_CONFIG.baseUrl})? [y/N] `))
+            .trim()
+            .toLowerCase();
+        if (response === "y" || response === "yes") {
+            fs.write(semanticPath, serializeSemanticConfig({ ...DEFAULT_SEMANTIC_CONFIG, enabled: true }));
+            enabled.push(`semantic (${DEFAULT_SEMANTIC_CONFIG.model})`);
+        }
+    }
+    const decisionPath = join(aiwPath, DECISION_CONFIG_PATH);
+    if (!fs.exists(decisionPath)) {
+        const response = (await answer(`Enable advisory decision triage with a local decision model (default: ${DEFAULT_DECISION_CONFIG.model} at ${DEFAULT_DECISION_CONFIG.baseUrl})? [y/N] `))
+            .trim()
+            .toLowerCase();
+        if (response === "y" || response === "yes") {
+            fs.write(decisionPath, serializeDecisionConfig({ ...DEFAULT_DECISION_CONFIG, enabled: true }));
+            enabled.push(`decision (${DEFAULT_DECISION_CONFIG.model})`);
+        }
+    }
+    return enabled;
+}
 function formatConfidence(confidence) {
     return confidence === undefined ? "unknown" : confidence.toFixed(3);
 }

package/docs/semantic-mapping.md

@@ -1,6 +1,6 @@
 # Semantic Mapping
 
-AI Workflow can build a semantic index of the scanned project with a local embedding model such as `embeddinggemma-2` served by Ollama. Semantic mapping is opt-in and flag-gated: it activates only when a valid configuration exists, and every scan and flow query re-reads the flag.
+AI Workflow can build a semantic index of the scanned project with a local embedding model such as `embeddinggemma-2` served by Ollama. Semantic mapping is opt-in and flag-gated: it activates only when a valid configuration exists, and every scan and flow query re-reads the flag. During an interactive `aiw install`, the installer offers to create this configuration with defaults; answering `y` writes it before `/ai-init` runs. Declining, or installing non-interactively, leaves the file absent.
 
 ## Configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multileaf/ai-workflow",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Portable spec-driven development workflow for AI coding agents",
   "license": "MIT",
   "repository": {