@madebywild/agent-harness-framework 1.4.0 → 1.6.0

package/dist/cli/adapters/interactive.js

@@ -3,12 +3,42 @@ import { Spinner, TextInput } from "@inkjs/ui";
 import { providerIdSchema } from "@madebywild/agent-harness-manifest";
 import { Box, render, Static, Text, useApp, useInput } from "ink";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { resolveHarnessPaths } from "../../paths.js";
 import { listBuiltinPresets, summarizePreset } from "../../presets.js";
 import { CLI_ENTITY_TYPES } from "../../types.js";
+import { exists } from "../../utils.js";
+import { runDoctor } from "../../versioning/doctor.js";
 import { getCommandDefinition } from "../command-registry.js";
 import { renderTextOutput } from "../renderers/text.js";
-import { AutocompleteSelect } from "./autocomplete-select.js";
+import { AutocompleteMultiSelect, AutocompleteSelect } from "./autocomplete-select.js";
 import { ToggleConfirm } from "./toggle-confirm.js";
+export async function detectWorkspaceStatus(cwd) {
+    const paths = resolveHarnessPaths(cwd);
+    const [dirExists, manifestExists] = await Promise.all([exists(paths.agentsDir), exists(paths.manifestFile)]);
+    if (!dirExists || !manifestExists) {
+        return { state: "missing" };
+    }
+    try {
+        const doctor = await runDoctor(paths);
+        if (!doctor.healthy) {
+            return { state: "unhealthy", diagnostics: doctor.diagnostics };
+        }
+        return { state: "healthy" };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            state: "unhealthy",
+            diagnostics: [
+                {
+                    code: "INTERACTIVE_WORKSPACE_STATUS_CHECK_FAILED",
+                    severity: "error",
+                    message: `Failed to determine workspace health: ${message}`,
+                },
+            ],
+        };
+    }
+}
 // ---------------------------------------------------------------------------
 // Command list shown in the main selector
 // ---------------------------------------------------------------------------
@@ -25,6 +55,7 @@ const INTERACTIVE_COMMAND_IDS = [
     "preset.list",
     "preset.describe",
     "preset.apply",
+    "skill.import",
     "add.prompt",
     "add.skill",
     "add.mcp",
@@ -50,33 +81,66 @@ const COMMAND_OPTIONS = [
 // Build the prompt list for each command
 // ---------------------------------------------------------------------------
 function buildPromptsForCommand(commandId, presets) {
-    const providers = providerIdSchema.options.map((p) => ({ label: p, value: p }));
+    const providers = providerIdSchema.options.map((p) => ({
+        label: p,
+        value: p,
+    }));
     const entityTypes = CLI_ENTITY_TYPES.map((t) => ({ label: t, value: t }));
     switch (commandId) {
         case "init":
             return [
-                { id: "force", type: "confirm", message: "Overwrite existing .harness workspace if present?", initial: false },
+                {
+                    id: "force",
+                    type: "confirm",
+                    message: "Overwrite existing .harness workspace if present?",
+                    initial: false,
+                },
                 {
                     id: "preset",
                     type: "select",
                     message: "Select a preset to apply during init",
                     options: [
                         { value: "", label: "Skip preset" },
-                        ...presets.map((p) => ({ value: p.id, label: `${p.name} (${p.id})` })),
+                        ...presets.map((p) => ({
+                            value: p.id,
+                            label: `${p.name} (${p.id})`,
+                        })),
                     ],
                 },
                 // delegate prompt inserted dynamically when preset === "delegate"
             ];
         case "provider.enable":
         case "provider.disable":
-            return [{ id: "provider", type: "select", message: "Select provider", options: providers }];
+            return [
+                {
+                    id: "provider",
+                    type: "select",
+                    message: "Select provider",
+                    options: providers,
+                },
+            ];
         case "registry.add":
             return [
                 { id: "name", type: "text", message: "Registry name", required: true },
                 { id: "gitUrl", type: "text", message: "Git URL", required: true },
-                { id: "ref", type: "text", message: "Git ref (default: main)", required: false },
-                { id: "root", type: "text", message: "Registry root path", required: false },
-                { id: "tokenEnv", type: "text", message: "Token env var", required: false },
+                {
+                    id: "ref",
+                    type: "text",
+                    message: "Git ref (default: main)",
+                    required: false,
+                },
+                {
+                    id: "root",
+                    type: "text",
+                    message: "Registry root path",
+                    required: false,
+                },
+                {
+                    id: "tokenEnv",
+                    type: "text",
+                    message: "Token env var",
+                    required: false,
+                },
             ];
         case "registry.remove":
         case "registry.default.set":
@@ -89,58 +153,200 @@ function buildPromptsForCommand(commandId, presets) {
                     message: "Entity type filter",
                     options: [{ value: "", label: "All entity types" }, ...entityTypes],
                 },
-                { id: "id", type: "text", message: "Entity id filter", required: false },
-                { id: "registry", type: "text", message: "Registry filter", required: false },
-                { id: "force", type: "confirm", message: "Overwrite locally modified imported sources?", initial: false },
+                {
+                    id: "id",
+                    type: "text",
+                    message: "Entity id filter",
+                    required: false,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry filter",
+                    required: false,
+                },
+                {
+                    id: "force",
+                    type: "confirm",
+                    message: "Overwrite locally modified imported sources?",
+                    initial: false,
+                },
             ];
         case "preset.list":
-            return [{ id: "registry", type: "text", message: "Registry id", required: false }];
+            return [
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
         case "preset.describe":
         case "preset.apply":
             return [
                 { id: "presetId", type: "text", message: "Preset id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "skill.find":
+            return [{ id: "query", type: "text", message: "Search query", required: true }];
+        case "skill.import":
+            return [
+                {
+                    id: "source",
+                    type: "text",
+                    message: "Source (owner/repo, URL, or local path)",
+                    required: true,
+                },
+                {
+                    id: "upstreamSkill",
+                    type: "text",
+                    message: "Upstream skill id",
+                    required: true,
+                },
+                {
+                    id: "as",
+                    type: "text",
+                    message: "Target harness skill id",
+                    required: false,
+                },
+                {
+                    id: "replace",
+                    type: "confirm",
+                    message: "Replace existing skill if it already exists?",
+                    initial: false,
+                },
+                {
+                    id: "allowUnsafe",
+                    type: "confirm",
+                    message: "Allow non-pass audited skills?",
+                    initial: false,
+                },
+                {
+                    id: "allowUnaudited",
+                    type: "confirm",
+                    message: "Allow unaudited sources?",
+                    initial: false,
+                },
             ];
         case "add.prompt":
-            return [{ id: "registry", type: "text", message: "Registry id", required: false }];
+            return [
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
         case "add.skill":
             return [
                 { id: "skillId", type: "text", message: "Skill id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "add.mcp":
             return [
-                { id: "configId", type: "text", message: "MCP config id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "configId",
+                    type: "text",
+                    message: "MCP config id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "add.subagent":
             return [
-                { id: "subagentId", type: "text", message: "Subagent id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "subagentId",
+                    type: "text",
+                    message: "Subagent id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "add.hook":
             return [
                 { id: "hookId", type: "text", message: "Hook id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "add.settings":
             return [
-                { id: "provider", type: "select", message: "Provider", options: providers },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "provider",
+                    type: "select",
+                    message: "Provider",
+                    options: providers,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "add.command":
             return [
-                { id: "commandId", type: "text", message: "Command id", required: true },
-                { id: "registry", type: "text", message: "Registry id", required: false },
+                {
+                    id: "commandId",
+                    type: "text",
+                    message: "Command id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
             ];
         case "remove":
             return [
-                { id: "entityType", type: "select", message: "Entity type", options: entityTypes },
+                {
+                    id: "entityType",
+                    type: "select",
+                    message: "Entity type",
+                    options: entityTypes,
+                },
                 { id: "id", type: "text", message: "Entity id", required: true },
-                { id: "deleteSource", type: "confirm", message: "Delete source files too?", initial: true },
+                {
+                    id: "deleteSource",
+                    type: "confirm",
+                    message: "Delete source files too?",
+                    initial: true,
+                },
             ];
         case "migrate":
-            return [{ id: "dryRun", type: "confirm", message: "Run as dry-run only?", initial: false }];
+            return [
+                {
+                    id: "dryRun",
+                    type: "confirm",
+                    message: "Run as dry-run only?",
+                    initial: false,
+                },
+            ];
         default:
             return [];
     }
@@ -165,7 +371,11 @@ function buildCommandInput(commandId, values) {
         case "init":
             return {
                 command: commandId,
-                options: { force: bool("force"), preset: str("preset"), delegate: str("delegate") },
+                options: {
+                    force: bool("force"),
+                    preset: str("preset"),
+                    delegate: str("delegate"),
+                },
             };
         case "provider.enable":
         case "provider.disable":
@@ -174,7 +384,12 @@ function buildCommandInput(commandId, values) {
             return {
                 command: commandId,
                 args: { name: str("name") },
-                options: { gitUrl: str("gitUrl"), ref: str("ref"), root: str("root"), tokenEnv: str("tokenEnv") },
+                options: {
+                    gitUrl: str("gitUrl"),
+                    ref: str("ref"),
+                    root: str("root"),
+                    tokenEnv: str("tokenEnv"),
+                },
             };
         case "registry.remove":
         case "registry.default.set":
@@ -189,21 +404,66 @@ function buildCommandInput(commandId, values) {
             return { command: commandId, options: { registry: str("registry") } };
         case "preset.describe":
         case "preset.apply":
-            return { command: commandId, args: { presetId: str("presetId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { presetId: str("presetId") },
+                options: { registry: str("registry") },
+            };
+        case "skill.find":
+            return {
+                command: commandId,
+                args: { query: str("query") },
+            };
+        case "skill.import":
+            return {
+                command: commandId,
+                args: { source: str("source") },
+                options: {
+                    skill: str("upstreamSkill"),
+                    as: str("as"),
+                    replace: bool("replace"),
+                    allowUnsafe: bool("allowUnsafe"),
+                    allowUnaudited: bool("allowUnaudited"),
+                },
+            };
         case "add.prompt":
             return { command: commandId, options: { registry: str("registry") } };
         case "add.skill":
-            return { command: commandId, args: { skillId: str("skillId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { skillId: str("skillId") },
+                options: { registry: str("registry") },
+            };
         case "add.mcp":
-            return { command: commandId, args: { configId: str("configId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { configId: str("configId") },
+                options: { registry: str("registry") },
+            };
         case "add.subagent":
-            return { command: commandId, args: { subagentId: str("subagentId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { subagentId: str("subagentId") },
+                options: { registry: str("registry") },
+            };
         case "add.hook":
-            return { command: commandId, args: { hookId: str("hookId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { hookId: str("hookId") },
+                options: { registry: str("registry") },
+            };
         case "add.settings":
-            return { command: commandId, args: { provider: str("provider") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { provider: str("provider") },
+                options: { registry: str("registry") },
+            };
         case "add.command":
-            return { command: commandId, args: { commandId: str("commandId") }, options: { registry: str("registry") } };
+            return {
+                command: commandId,
+                args: { commandId: str("commandId") },
+                options: { registry: str("registry") },
+            };
         case "remove":
             return {
                 command: commandId,
@@ -211,14 +471,24 @@ function buildCommandInput(commandId, values) {
                 options: { deleteSource: bool("deleteSource", true) },
             };
         case "migrate":
-            return { command: commandId, options: { to: "latest", dryRun: bool("dryRun") } };
+            return {
+                command: commandId,
+                options: { to: "latest", dryRun: bool("dryRun") },
+            };
         default:
             return { command: commandId };
     }
 }
-function App({ api, presets, onExit }) {
+function initialStepFromStatus(status) {
+    if (!status || status.state === "healthy")
+        return { type: "select-command" };
+    if (status.state === "missing")
+        return { type: "onboarding" };
+    return { type: "workspace-warning", diagnostics: status.diagnostics };
+}
+export function App({ api, presets, workspaceStatus, onExit }) {
     const { exit } = useApp();
-    const [step, setStep] = useState({ type: "select-command" });
+    const [step, setStep] = useState(() => initialStepFromStatus(workspaceStatus));
     const [pastLines, setPastLines] = useState([{ id: 0, text: "Harness interactive mode" }]);
     const nextLineId = useRef(1);
     const [exitCode, setExitCode] = useState(0);
@@ -246,6 +516,15 @@ function App({ api, presets, onExit }) {
         }
     }, [step, exitCode, exit, onExit]);
     const renderCurrentStep = () => {
+        if (step.type === "onboarding") {
+            return (_jsx(OnboardingWizard, { api: api, presets: presets, onComplete: () => {
+                    addPastLine("Onboarding complete.");
+                    setStep({ type: "select-command" });
+                } }));
+        }
+        if (step.type === "workspace-warning") {
+            return (_jsx(WorkspaceWarningStep, { diagnostics: step.diagnostics, api: api, onDismiss: () => setStep({ type: "select-command" }) }));
+        }
         if (step.type === "select-command") {
             return (_jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Command", options: COMMAND_OPTIONS, onChange: (value) => {
                         if (value === "exit") {
@@ -254,9 +533,30 @@ function App({ api, presets, onExit }) {
                             return;
                         }
                         const commandId = value;
+                        if (commandId === "skill.import") {
+                            setStep({ type: "skills-import-workflow" });
+                            return;
+                        }
                         const prompts = buildPromptsForCommand(commandId, presets);
-                        setStep({ type: "prompt-input", commandId, collector: { prompts, values: {}, index: 0 } });
-                    } }) }));
+                        setStep({
+                            type: "prompt-input",
+                            commandId,
+                            collector: { prompts, values: {}, index: 0 },
+                        });
+                    } }, "select-command") }));
+        }
+        if (step.type === "skills-import-workflow") {
+            return (_jsx(SkillsImportWorkflow, { api: api, onCancel: () => {
+                    addPastLine("Cancelled command input.");
+                    setStep({ type: "select-command" });
+                }, onComplete: (lines, isError) => {
+                    setStep({
+                        type: "show-output",
+                        label: "Search and import third-party skills",
+                        lines,
+                        isError,
+                    });
+                }, onDismiss: () => setStep({ type: "select-command" }) }));
         }
         if (step.type === "prompt-input") {
             const { commandId, collector } = step;
@@ -273,7 +573,10 @@ function App({ api, presets, onExit }) {
                         id: "delegate",
                         type: "select",
                         message: "Select the provider CLI to delegate prompt authoring to",
-                        options: providerIdSchema.options.map((p) => ({ label: p, value: p })),
+                        options: providerIdSchema.options.map((p) => ({
+                            label: p,
+                            value: p,
+                        })),
                     };
                     newPrompts = [
                         ...collector.prompts.slice(0, collector.index + 1),
@@ -284,7 +587,11 @@ function App({ api, presets, onExit }) {
                 setStep({
                     type: "prompt-input",
                     commandId,
-                    collector: { prompts: newPrompts, values: newValues, index: collector.index + 1 },
+                    collector: {
+                        prompts: newPrompts,
+                        values: newValues,
+                        index: collector.index + 1,
+                    },
                 });
             };
             const cancelPrompt = () => {
@@ -298,7 +605,7 @@ function App({ api, presets, onExit }) {
                 return (_jsx(ToggleConfirm, { message: prompt.message, defaultValue: prompt.initial, onSubmit: advanceWith, onEscape: cancelPrompt }));
             }
             if (prompt.type === "select") {
-                return (_jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: prompt.message, options: prompt.options, onChange: (value) => advanceWith(value), onCancel: cancelPrompt }) }));
+                return (_jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: prompt.message, options: prompt.options, onChange: (value) => advanceWith(value), onCancel: cancelPrompt }, `${commandId}-${collector.index}`) }));
             }
         }
         if (step.type === "confirm-run") {
@@ -328,7 +635,12 @@ function App({ api, presets, onExit }) {
                     setStep({ type: "show-output", label, lines, isError: code !== 0 });
                 }, onError: (message) => {
                     setExitCode(1);
-                    setStep({ type: "show-output", label, lines: [`Error: ${message}`], isError: true });
+                    setStep({
+                        type: "show-output",
+                        label,
+                        lines: [`Error: ${message}`],
+                        isError: true,
+                    });
                 } }));
         }
         return null;
@@ -375,13 +687,559 @@ function RunningStep({ label, input, api, onDone, onError }) {
     }, [api, input]);
     return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Running ${label}...` }) }));
 }
+const DEFAULT_SKILL_IMPORT_OPTIONS = {
+    replace: false,
+    allowUnsafe: false,
+    allowUnaudited: false,
+};
+const SKILL_IMPORT_OPTION_PROMPTS = [
+    { key: "replace", message: "Replace existing local skills if they already exist?" },
+    { key: "allowUnsafe", message: "Allow non-pass audited skills?" },
+    { key: "allowUnaudited", message: "Allow unaudited sources?" },
+];
+function formatDiagnosticLine(diagnostic) {
+    const p = diagnostic.path ? ` (${diagnostic.path})` : "";
+    return `[${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}${p}`;
+}
+function summarizeAudit(output) {
+    if (output.family !== "skills" || output.data.operation !== "import")
+        return "";
+    const audit = output.data.result.audit;
+    if (!audit.audited)
+        return "";
+    return audit.providers.map((p) => `${p.provider}: ${p.raw}`).join(" · ");
+}
+function extractUserError(output) {
+    const errors = output.diagnostics.filter((d) => d.severity === "error");
+    if (errors.length === 0)
+        return undefined;
+    for (const e of errors) {
+        if (e.code === "SKILL_IMPORT_SUBPROCESS_FAILED")
+            return "Skill source not found or unavailable.";
+        if (e.code === "SKILL_IMPORT_AUDIT_BLOCKED")
+            return "Blocked by security audit. Use --allow-unsafe to override.";
+        if (e.code === "SKILL_IMPORT_AUDIT_UNAUDITED")
+            return "No audit report available. Use --allow-unaudited to override.";
+        if (e.code === "SKILL_IMPORT_COLLISION")
+            return "Skill already exists. Enable replace to overwrite.";
+        if (e.code?.startsWith("SKILL_IMPORT_PAYLOAD_"))
+            return "Skill payload validation failed.";
+    }
+    return errors[0]?.message;
+}
+function formatSkillResultLabel(result) {
+    return `${result.source}@${result.upstreamSkill}`;
+}
+function SkillItemLabel({ result, isFocused, isSelected, }) {
+    const nameColor = isSelected ? "green" : isFocused ? "cyan" : undefined;
+    const meta = [result.source, result.installs].filter(Boolean).join(" · ");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: nameColor, children: result.upstreamSkill }), meta && _jsx(Text, { dimColor: true, children: `    ${meta}` })] }));
+}
+function readSkillFindState(output) {
+    if (output.family !== "skills")
+        return null;
+    if (output.data.operation !== "find")
+        return null;
+    return {
+        query: output.data.query,
+        results: output.data.results,
+        diagnostics: output.diagnostics,
+        rawText: output.data.rawText,
+    };
+}
+function buildSkillImportInput(skill, options) {
+    return {
+        command: "skill.import",
+        args: { source: skill.source },
+        options: {
+            skill: skill.upstreamSkill,
+            replace: options.replace,
+            allowUnsafe: options.allowUnsafe,
+            allowUnaudited: options.allowUnaudited,
+        },
+    };
+}
+function SkillsImportWorkflow({ api, onCancel, onComplete, onDismiss }) {
+    const [step, setStep] = useState({ type: "query" });
+    const runningRef = useRef(false);
+    const onCompleteRef = useRef(onComplete);
+    onCompleteRef.current = onComplete;
+    useEffect(() => {
+        if (runningRef.current)
+            return;
+        if (step.type === "searching") {
+            runningRef.current = true;
+            api
+                .execute({ command: "skill.find", args: { query: step.query } })
+                .then((output) => {
+                const search = readSkillFindState(output);
+                if (!search) {
+                    onCompleteRef.current(["Error: Unexpected output while searching third-party skills."], true);
+                    return;
+                }
+                if (search.results.length === 0) {
+                    const lines = [`No skills found for query '${search.query}'.`];
+                    if (search.rawText.trim().length > 0) {
+                        lines.push("", search.rawText.trim());
+                    }
+                    if (search.diagnostics.length > 0) {
+                        lines.push("", ...search.diagnostics.map(formatDiagnosticLine));
+                    }
+                    onCompleteRef.current(lines, output.exitCode !== 0);
+                    return;
+                }
+                setStep({ type: "select", search });
+            })
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                onCompleteRef.current([`Error: ${message}`], true);
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+            return;
+        }
+        if (step.type === "running") {
+            runningRef.current = true;
+            (async () => {
+                const entries = [];
+                for (const skill of step.selected) {
+                    const output = await api.execute(buildSkillImportInput(skill, step.options));
+                    const fileCount = output.family === "skills" && output.data.operation === "import" ? output.data.result.fileCount : 0;
+                    entries.push({
+                        skill,
+                        ok: output.ok,
+                        fileCount,
+                        auditSummary: summarizeAudit(output),
+                        errorMessage: output.ok ? undefined : extractUserError(output),
+                    });
+                }
+                setStep({ type: "results", entries });
+            })()
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                onCompleteRef.current([`Error: ${message}`], true);
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+    }, [api, step]);
+    if (step.type === "query") {
+        return (_jsx(TextPrompt, { message: "Search third-party skills", required: true, onSubmit: (value) => {
+                const query = value.trim();
+                if (query.length === 0)
+                    return;
+                setStep({ type: "searching", query });
+            }, onCancel: onCancel }, "skill-import-query"));
+    }
+    if (step.type === "searching") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Searching skills for '${step.query}'...` }) }));
+    }
+    if (step.type === "select") {
+        const results = step.search.results;
+        const options = results.map((result, index) => ({
+            value: String(index),
+            label: formatSkillResultLabel(result),
+        }));
+        const renderSkillLabel = ({ option, isFocused, isSelected }) => {
+            const result = results[Number(option.value)];
+            if (!result)
+                return null;
+            return _jsx(SkillItemLabel, { result: result, isFocused: isFocused, isSelected: isSelected });
+        };
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: `Found ${results.length} skill(s) for '${step.search.query}'.` }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteMultiSelect, { label: "Filter skills", options: options, renderLabel: renderSkillLabel, onCancel: onCancel, onSubmit: (selectedValues) => {
+                            const selected = selectedValues
+                                .map((value) => Number.parseInt(value, 10))
+                                .filter((index) => Number.isInteger(index))
+                                .map((index) => step.search.results[index])
+                                .filter((result) => result !== undefined);
+                            if (selected.length === 0) {
+                                onComplete(["No skills selected. Nothing imported."], false);
+                                return;
+                            }
+                            setStep({
+                                type: "options",
+                                search: step.search,
+                                selected,
+                                options: { ...DEFAULT_SKILL_IMPORT_OPTIONS },
+                                optionIndex: 0,
+                            });
+                        } }, `skill-import-select-${step.search.query}`) })] }));
+    }
+    if (step.type === "options") {
+        const prompt = SKILL_IMPORT_OPTION_PROMPTS[step.optionIndex];
+        if (!prompt) {
+            return null;
+        }
+        return (_jsx(ToggleConfirm, { message: prompt.message, defaultValue: step.options[prompt.key], onEscape: onCancel, onSubmit: (value) => {
+                const nextOptions = {
+                    ...step.options,
+                    [prompt.key]: value,
+                };
+                const nextIndex = step.optionIndex + 1;
+                if (nextIndex < SKILL_IMPORT_OPTION_PROMPTS.length) {
+                    setStep({
+                        ...step,
+                        options: nextOptions,
+                        optionIndex: nextIndex,
+                    });
+                    return;
+                }
+                setStep({
+                    type: "confirm",
+                    search: step.search,
+                    selected: step.selected,
+                    options: nextOptions,
+                });
+            } }, `skill-import-option-${step.optionIndex}`));
+    }
+    if (step.type === "confirm") {
+        return (_jsx(ToggleConfirm, { message: `Import ${step.selected.length} selected skill(s) now?`, defaultValue: true, onEscape: onCancel, onSubmit: (confirmed) => {
+                if (!confirmed) {
+                    onCancel();
+                    return;
+                }
+                setStep({
+                    type: "running",
+                    search: step.search,
+                    selected: step.selected,
+                    options: step.options,
+                });
+            } }));
+    }
+    if (step.type === "running") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Importing ${step.selected.length} skill(s)...` }) }));
+    }
+    if (step.type === "results") {
+        return _jsx(SkillImportResults, { entries: step.entries, onDismiss: onDismiss });
+    }
+    return null;
+}
+function SkillImportResults({ entries, onDismiss }) {
+    useInput((_input, key) => {
+        if (key.return)
+            onDismiss();
+    });
+    const imported = entries.filter((e) => e.ok);
+    const failed = entries.filter((e) => !e.ok);
+    const allOk = failed.length === 0;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: allOk ? "green" : "yellow", children: allOk ? `✓ Imported ${imported.length} skill(s)` : `${imported.length} imported, ${failed.length} failed` }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: entries.map((entry) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: entry.ok ? "green" : "red", children: entry.ok ? "✓" : "✗" }), _jsx(Text, { bold: true, children: entry.skill.upstreamSkill }), _jsx(Text, { dimColor: true, children: entry.skill.source })] }), entry.ok && entry.fileCount > 0 && _jsx(Text, { dimColor: true, children: `    ${entry.fileCount} file(s) added` }), entry.ok && entry.auditSummary && _jsx(Text, { dimColor: true, children: `    Audit: ${entry.auditSummary}` }), !entry.ok && entry.errorMessage && _jsx(Text, { color: "red", children: `    ${entry.errorMessage}` })] }, `${entry.skill.source}/${entry.skill.upstreamSkill}`))) }), _jsx(Text, { dimColor: true, children: "Press Enter to continue..." })] }));
+}
+// ---------------------------------------------------------------------------
+// OnboardingWizard — full guided setup for new workspaces
+// ---------------------------------------------------------------------------
+const HARNESS_LOGO = `   __ __
+  / // /__ ________  ___ ___ ___
+ / _  / _ \`/ __/ _ \\/ -_|_-<(_-<
+/_//_/\\_,_/_/ /_//_/\\__/___/___/`;
+const HARNESS_TAGLINE = "Configure your AI coding agents from a single source of truth.";
+function OnboardingWizard({ api, presets, onComplete }) {
+    const [subStep, setSubStep] = useState({
+        type: "welcome",
+    });
+    const [revealIndex, setRevealIndex] = useState(0);
+    const [animationDone, setAnimationDone] = useState(false);
+    const summaryRef = useRef([]);
+    const runningRef = useRef(false);
+    const fullText = `${HARNESS_LOGO}\n\n  ${HARNESS_TAGLINE}`;
+    // Animated typing effect for welcome screen
+    useEffect(() => {
+        if (subStep.type !== "welcome")
+            return;
+        if (revealIndex >= fullText.length) {
+            setAnimationDone(true);
+            return;
+        }
+        const timer = setTimeout(() => setRevealIndex((i) => i + 1), revealIndex === 0 ? 100 : 8);
+        return () => clearTimeout(timer);
+    }, [subStep.type, revealIndex, fullText.length]);
+    useInput((_input, key) => {
+        if (subStep.type === "welcome" && key.return) {
+            if (!animationDone) {
+                setRevealIndex(fullText.length);
+                setAnimationDone(true);
+            }
+            else {
+                setSubStep({ type: "preset" });
+            }
+        }
+    });
+    // Single effect for all async onboarding actions, guarded by ref.
+    // Uses else-if so only one branch can fire per render cycle.
+    useEffect(() => {
+        if (runningRef.current)
+            return;
+        if (subStep.type === "running-init") {
+            runningRef.current = true;
+            api
+                .execute({
+                command: "init",
+                options: {
+                    force: false,
+                    preset: subStep.preset,
+                    delegate: subStep.delegate,
+                },
+            })
+                .then((output) => {
+                if (output.exitCode !== 0) {
+                    const lines = [];
+                    renderTextOutput(output, (line) => lines.push(line));
+                    setSubStep({
+                        type: "init-error",
+                        message: lines.join("\n"),
+                        preset: subStep.preset,
+                        delegate: subStep.delegate,
+                    });
+                    return;
+                }
+                summaryRef.current.push("Initialized .harness/ workspace");
+                if (subStep.preset)
+                    summaryRef.current.push(`Applied preset: ${subStep.preset}`);
+                setSubStep({ type: "providers", selected: [] });
+            })
+                .catch((err) => {
+                setSubStep({
+                    type: "init-error",
+                    message: err instanceof Error ? err.message : String(err),
+                    preset: subStep.preset,
+                    delegate: subStep.delegate,
+                });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+        else if (subStep.type === "running-providers") {
+            runningRef.current = true;
+            const { selected } = subStep;
+            (async () => {
+                for (const provider of selected) {
+                    await api.execute({ command: "provider.enable", args: { provider } });
+                }
+                summaryRef.current.push(`Enabled provider(s): ${selected.join(", ")}`);
+                setSubStep({ type: "add-prompt" });
+            })()
+                .catch((err) => {
+                summaryRef.current.push(`Warning: provider enablement failed (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "add-prompt" });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+        else if (subStep.type === "running-add-prompt") {
+            runningRef.current = true;
+            api
+                .execute({ command: "add.prompt" })
+                .then(() => {
+                summaryRef.current.push("Added system prompt entity");
+                setSubStep({ type: "running-apply" });
+            })
+                .catch((err) => {
+                summaryRef.current.push(`Warning: failed to add prompt (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "running-apply" });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+        else if (subStep.type === "running-apply") {
+            runningRef.current = true;
+            api
+                .execute({ command: "apply" })
+                .then(() => {
+                summaryRef.current.push("Applied workspace (generated provider artifacts)");
+                setSubStep({ type: "complete", summary: summaryRef.current });
+            })
+                .catch((err) => {
+                summaryRef.current.push(`Warning: apply failed (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "complete", summary: summaryRef.current });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+    }, [subStep, api]);
+    if (subStep.type === "welcome") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "cyan", children: fullText.slice(0, revealIndex) }), animationDone && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to get started..." }) }))] }));
+    }
+    if (subStep.type === "preset") {
+        const presetOptions = [
+            { value: "", label: "Skip preset" },
+            ...presets.map((p) => ({ value: p.id, label: `${p.name} (${p.id})` })),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 1/4 \u2014 Choose a preset" }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Preset", options: presetOptions, onChange: (value) => {
+                            if (value === "delegate") {
+                                setSubStep({ type: "delegate-provider" });
+                            }
+                            else {
+                                setSubStep({
+                                    type: "running-init",
+                                    preset: value || undefined,
+                                });
+                            }
+                        } }, "onboarding-preset") })] }));
+    }
+    if (subStep.type === "delegate-provider") {
+        const providers = providerIdSchema.options.map((p) => ({
+            label: p,
+            value: p,
+        }));
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 1/4 \u2014 Select delegate provider" }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Provider", options: providers, onChange: (value) => {
+                            setSubStep({
+                                type: "running-init",
+                                preset: "delegate",
+                                delegate: value,
+                            });
+                        } }, "onboarding-delegate") })] }));
+    }
+    if (subStep.type === "running-init") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Initializing workspace..." }) }));
+    }
+    if (subStep.type === "init-error") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Initialization failed" }), _jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsx(Text, { children: subStep.message }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Please resolve the issue and try again." }) }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Action", options: [
+                            { label: "Retry initialization", value: "retry" },
+                            { label: "Back", value: "back" },
+                            { label: "Continue to main menu", value: "continue" },
+                        ], onChange: (value) => {
+                            if (value === "retry") {
+                                setSubStep({
+                                    type: "running-init",
+                                    preset: subStep.preset,
+                                    delegate: subStep.delegate,
+                                });
+                                return;
+                            }
+                            if (value === "back") {
+                                if (subStep.preset === "delegate") {
+                                    setSubStep({ type: "delegate-provider" });
+                                }
+                                else {
+                                    setSubStep({ type: "preset" });
+                                }
+                                return;
+                            }
+                            onComplete();
+                        } }, "onboarding-init-error-action") })] }));
+    }
+    if (subStep.type === "providers") {
+        const remaining = providerIdSchema.options
+            .filter((p) => !subStep.selected.includes(p))
+            .map((p) => ({ label: p, value: p }));
+        const doneLabel = subStep.selected.length === 0 ? "Skip (enable later)" : `Done (${subStep.selected.join(", ")})`;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 2/4 \u2014 Enable providers" }), subStep.selected.length > 0 && _jsxs(Text, { dimColor: true, children: ["Selected: ", subStep.selected.join(", ")] }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Provider", options: [{ label: doneLabel, value: "" }, ...remaining], onChange: (value) => {
+                            if (!value) {
+                                if (subStep.selected.length === 0) {
+                                    setSubStep({ type: "add-prompt" });
+                                }
+                                else {
+                                    setSubStep({
+                                        type: "running-providers",
+                                        selected: subStep.selected,
+                                    });
+                                }
+                            }
+                            else {
+                                setSubStep({
+                                    type: "providers",
+                                    selected: [...subStep.selected, value],
+                                });
+                            }
+                        } }, `onboarding-providers-${subStep.selected.length}`) })] }));
+    }
+    if (subStep.type === "running-providers") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Enabling provider(s): ${subStep.selected.join(", ")}...` }) }));
+    }
+    if (subStep.type === "add-prompt") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 3/4 \u2014 System prompt" }), _jsx(ToggleConfirm, { message: "Add a system prompt entity?", defaultValue: true, onSubmit: (yes) => {
+                        if (yes) {
+                            setSubStep({ type: "running-add-prompt" });
+                        }
+                        else {
+                            setSubStep({ type: "running-apply" });
+                        }
+                    } })] }));
+    }
+    if (subStep.type === "running-add-prompt") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Adding system prompt..." }) }));
+    }
+    if (subStep.type === "running-apply") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Step 4/4 \u2014 Applying workspace..." }) }));
+    }
+    if (subStep.type === "complete") {
+        return _jsx(OnboardingComplete, { summary: subStep.summary, onDismiss: onComplete });
+    }
+    return null;
+}
+function OnboardingComplete({ summary, onDismiss }) {
+    useInput((_input, key) => {
+        if (key.return)
+            onDismiss();
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Setup complete!" }), summary.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: summary.map((line, i) => (
+                // biome-ignore lint/suspicious/noArrayIndexKey: static list, never reordered
+                _jsxs(Text, { dimColor: true, children: ["- ", line] }, i))) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to continue to the main menu..." }) })] }));
+}
+function WorkspaceWarningStep({ diagnostics, api, onDismiss }) {
+    const [running, setRunning] = useState(false);
+    const [output, setOutput] = useState(null);
+    const runningRef = useRef(false);
+    useEffect(() => {
+        if (!running || runningRef.current)
+            return;
+        runningRef.current = true;
+        api
+            .execute({ command: "doctor" })
+            .then((result) => {
+            const lines = [];
+            renderTextOutput(result, (line) => lines.push(line));
+            setOutput({ lines, isError: result.exitCode !== 0 });
+        })
+            .catch((err) => {
+            setOutput({
+                lines: [err instanceof Error ? err.message : String(err)],
+                isError: true,
+            });
+        })
+            .finally(() => {
+            runningRef.current = false;
+            setRunning(false);
+        });
+    }, [running, api]);
+    useInput((_input, key) => {
+        if (output && key.return)
+            onDismiss();
+    });
+    if (running) {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Running doctor..." }) }));
+    }
+    if (output) {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: output.isError ? "red" : "green", children: output.isError ? "✗ Doctor" : "✓ Doctor" }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: _jsx(Text, { children: output.lines.join("\n") }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to continue..." }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "Workspace issues detected" }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: diagnostics.map((d) => (_jsxs(Text, { children: [_jsxs(Text, { color: "yellow", children: ["[", d.severity, "]"] }), " ", d.code, ": ", d.message] }, d.code))) }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Action", options: [
+                        { label: "Run doctor", value: "doctor" },
+                        { label: "Continue to menu", value: "continue" },
+                    ], onChange: (value) => {
+                        if (value === "doctor") {
+                            setRunning(true);
+                        }
+                        else {
+                            onDismiss();
+                        }
+                    } }, "workspace-warning") })] }));
+}
 // ---------------------------------------------------------------------------
 // Exported entry point
 // ---------------------------------------------------------------------------
-export async function runInteractiveAdapter(api) {
-    const presets = (await listBuiltinPresets()).map((p) => summarizePreset(p));
+export async function runInteractiveAdapter(api, options) {
+    const cwd = options?.cwd ?? process.cwd();
+    const [presets, workspaceStatus] = await Promise.all([
+        listBuiltinPresets().then((ps) => ps.map(summarizePreset)),
+        detectWorkspaceStatus(cwd),
+    ]);
     let resolvedExitCode = 0;
-    const { waitUntilExit } = render(_jsx(App, { api: api, presets: presets, onExit: (code) => {
+    const { waitUntilExit } = render(_jsx(App, { api: api, presets: presets, workspaceStatus: workspaceStatus, onExit: (code) => {
             resolvedExitCode = code;
         } }), { exitOnCtrlC: true });
     await waitUntilExit();