@iseoane/agent-depot 0.5.2 → 0.6.1

package/dist/src/app-flow.js

@@ -29,18 +29,23 @@ export function createAppOperations(environment = {}) {
     });
     const receiptPath = (entry) => path.join(receipts, createHash("sha256").update(entry.canonicalFile).digest("hex") + ".json");
     async function read(file) {
+        let canonicalFile;
+        let content;
+        try {
+            canonicalFile = await realpath(file);
+            content = await readFile(canonicalFile);
+        }
+        catch (error) {
+            return { file, applicable: true, error: error instanceof Error ? error.message : String(error) };
+        }
+        const hash = createHash("sha256").update(content).digest("hex");
         try {
-            const canonicalFile = await realpath(file);
-            const content = await readFile(canonicalFile);
             const recipe = parseAppRecipe(JSON.parse(content.toString("utf8")));
             const currentPlatform = platform === "win32" ? "windows" : platform;
-            return {
-                file, canonicalFile, recipe, hash: createHash("sha256").update(content).digest("hex"),
-                applicable: recipe.platform === undefined || recipe.platform === currentPlatform,
-            };
+            return { file, canonicalFile, recipe, hash, applicable: recipe.platform === undefined || recipe.platform === currentPlatform };
         }
         catch (error) {
-            return { file, applicable: true, error: error instanceof Error ? error.message : String(error) };
+            return { file, canonicalFile, hash, applicable: true, error: error instanceof Error ? error.message : String(error) };
         }
     }
     function rejectDuplicates(entries) {
@@ -82,14 +87,21 @@ export function createAppOperations(environment = {}) {
             ...Object.entries({
                 install: recipe.install, update: recipe.update, uninstall: recipe.uninstall, version: recipe.version,
             }),
-            ...(recipe.latest && "argv" in recipe.latest ? [["latest", recipe.latest]] : []),
+            ...(recipe.latest ? [["latest", recipe.latest]] : []),
             ...Object.entries(recipe.setup ?? {}).map(([host, step]) => [`setup.${host}`, step]),
             ...Object.entries(recipe.teardown ?? {}).map(([host, step]) => [`teardown.${host}`, step]),
         ];
         return Promise.all(steps.map(async ([step, value]) => {
-            const resolution = value.argv ? await resolve(value.argv[0]) : undefined;
+            const resolution = "argv" in value && value.argv ? await resolve(value.argv[0]) : undefined;
             return {
-                step, ...value, executable: resolution?.executable, cwd: home,
+                step,
+                ...("argv" in value && value.argv ? { argv: value.argv } : {}),
+                ...("manual" in value && value.manual ? { manual: value.manual } : {}),
+                ...("npm" in value ? { declaration: `Latest npm package: ${value.npm}` } : {}),
+                ...("github" in value ? { declaration: `Latest GitHub repository: ${value.github}` } : {}),
+                ...("pattern" in value ? { pattern: value.pattern } : {}),
+                executable: resolution?.executable, cwd: home,
+                environment: isWsl ? "linux (WSL)" : platform,
                 warning: resolution?.blocked ? WINDOWS_EXECUTABLE_WARNING : undefined,
             };
         }));
@@ -138,39 +150,59 @@ export function createAppOperations(environment = {}) {
         return { status: approval.status, reason: approval.reason };
     }
     /** A supplied cache checks recipe approval without running version; omit it for a live check. */
-    async function inspect(entry, cached) {
+    async function inspectEntry(entry, cached, reconcileTracking) {
         if (entry.error || !entry.recipe)
             return { status: "invalid", reason: entry.error };
         if (!entry.applicable)
             return { status: "not applicable here" };
+        if (cached?.installedVersion) {
+            return { status: "installed", installedVersion: cached.installedVersion, evidence: "recorded" };
+        }
         const approval = await approvalProblem(entry);
         if (approval)
             return approval;
-        if (cached)
-            return cached.installedVersion
-                ? { status: "installed", installedVersion: cached.installedVersion, evidence: "recorded" }
-                : { status: "not installed" };
-        const { executable, blocked } = await resolve(entry.recipe.version.argv[0]);
-        if (!executable || blocked) {
-            return { status: "not installed", executable, reason: blocked ? WINDOWS_EXECUTABLE_WARNING : undefined };
+        let resolution;
+        try {
+            resolution = await resolve(entry.recipe.version.argv[0]);
+        }
+        catch (error) {
+            return { status: "unknown", reason: error instanceof Error ? error.message : String(error) };
         }
+        const { executable, blocked } = resolution;
+        if (blocked)
+            return { status: "unknown", executable, reason: WINDOWS_EXECUTABLE_WARNING };
+        if (!executable)
+            return { status: "not installed", reason: "Version executable is unavailable" };
         let installedVersion;
+        let result;
         try {
-            const result = await runner(executable, entry.recipe.version.argv.slice(1), {
+            result = await runner(executable, entry.recipe.version.argv.slice(1), {
                 cwd: home, captureStdout: true, maxOutputBytes: APP_OUTPUT_LIMIT, maxStderrBytes: APP_OUTPUT_LIMIT,
             });
             installedVersion = result.code === 0 && !result.signal && !result.outputTooLarge
                 ? new RegExp(entry.recipe.version.pattern).exec(result.stdout.toString("utf8"))?.[1]
                 : undefined;
         }
-        catch {
-            return { status: "not installed", executable };
+        catch (error) {
+            return { status: "unknown", executable, reason: error instanceof Error ? error.message : String(error) };
         }
-        if (!installedVersion)
+        if (result.signal)
+            return { status: "unknown", executable, reason: `Version command terminated by signal ${result.signal}` };
+        if (result.code !== 0)
             return { status: "not installed", executable };
-        await reconcileTracked(entry, installedVersion);
+        if (!installedVersion || result.outputTooLarge) {
+            return { status: "unknown", executable, reason: result.outputTooLarge ? "Version output exceeded the limit" : "Version output did not match the recipe" };
+        }
+        if (reconcileTracking)
+            await reconcileTracked(entry, installedVersion);
         return { status: "installed", executable, installedVersion, evidence: "verified" };
     }
+    async function inspect(entry, cached) {
+        return await inspectEntry(entry, cached, true);
+    }
+    async function inspectForExport(entry) {
+        return await inspectEntry(entry, undefined, false);
+    }
     async function checkUpdate(entry) {
         const inspection = await inspect(entry);
         let latestVersion;
@@ -448,7 +480,7 @@ export function createAppOperations(environment = {}) {
                 throw error;
         });
     }
-    return { directory, approvalStatus, checkUpdate, load, preview, approve, inspect, planLifecycle, executeLifecycle, completeManual, cancelManual, trackedApps, previewForget, forgetApp };
+    return { directory, approvalStatus, checkUpdate, load, preview, approve, inspect, inspectForExport, planLifecycle, executeLifecycle, completeManual, cancelManual, trackedApps, previewForget, forgetApp };
 }
 /** Concurrent independent checks; one broken App must not hide the rest of a batch. */
 export async function checkAppUpdates(apps) {

package/dist/src/profile-export.js

@@ -4,9 +4,10 @@ import { loadAppOwnedSkillFilter } from "./app-owned-skills.js";
 import { sourceIdForUrl } from "./git-source.js";
 import { bundleRoot, describeCoordinates } from "./package-model.js";
 import { AGENT_DEPOT_PACKAGE_VERSION } from "./project-manifest.js";
-import { parseProfile, PROFILE_FORMAT, serializeProfile } from "./profile.js";
+import { parseProfile, PROFILE_FORMAT, PROFILE_FORMAT_V2, serializeProfile } from "./profile.js";
 import { formatVersionPolicy } from "./skill-install.js";
 import { scanUserGlobalSkillInventory } from "./user-global-skill-inventory.js";
+export const SKILL_EXPORT_EXPLANATION = "Selected Skills are exported with their version policy; destination install paths and Host links are recreated. Local paths and symlink targets do not travel.";
 export function selectProfileItems(items, requested, disabled, names, block) {
     if (disabled && requested?.length)
         throw new Error(`${block}: filters cannot be combined with --no-${block}`);
@@ -32,7 +33,24 @@ export function packageFilterNames(selection) {
 }
 /** One Package line, shared by the export preview and the import plan label. */
 export function describeProfilePackage(selection) {
-    return `Package ${describeCoordinates(selection)} (${formatVersionPolicy(selection.version)})`;
+    return `Package ${describeCoordinates(selection)} from ${profileSourceIdentity(selection.source)} (${formatVersionPolicy(selection.version)}; saved selection)`;
+}
+export function describeProfileSkill(skill) {
+    return `Skill ${skill.path} from ${profileSourceIdentity(skill.source)} (${skill.version.policy})`;
+}
+export function describeProfileReplica(replica) {
+    switch (replica.kind) {
+        case "skill": return `Installed Skill ${replica.path} from ${profileSourceIdentity(replica.source)}`;
+        case "app": return `Installed App ${replica.name} (${replica.platform ?? "all platforms"})`;
+        case "package": return `Installed Package ${describeCoordinates(replica.selection)} from ${profileSourceIdentity(replica.selection.source)}`;
+    }
+}
+function profileSourceIdentity(source) {
+    if (source.kind === "builtin")
+        return "Agent Depot (built-in Source)";
+    if ("url" in source)
+        return source.url;
+    return source.path;
 }
 function validateOne(block, item) {
     const profile = parseProfile({ format: PROFILE_FORMAT, agentDepotVersion: AGENT_DEPOT_PACKAGE_VERSION,
@@ -77,6 +95,7 @@ export async function buildProfileExport(operations, apps, options = {}) {
         }
     }
     const skills = [];
+    const replicas = [];
     for (const skill of installations) {
         if (owned(path.posix.basename(skill.installation?.path ?? skill.path))) {
             exclude("skills", `Skill ${skill.path}`, "App-owned");
@@ -86,19 +105,44 @@ export async function buildProfileExport(operations, apps, options = {}) {
         const selection = { source, path: skillPath, version, hosts, ...(methods ? { methods } : {}) };
         try {
             skills.push(validateOne("skills", selection));
-            if (skill.installation)
-                exclude("skills", `installation location and version evidence for Skill ${skill.path}`, "machine-specific");
+            replicas.push({ kind: "skill", source: skill.source, path: skill.path });
         }
         catch (error) {
             exclude("skills", `Skill ${skill.path}`, `not portable (${error instanceof Error ? error.message : String(error)})`);
         }
     }
     const recipes = [];
+    let appInstallations = [];
+    try {
+        appInstallations = await apps.trackedApps(warn);
+    }
+    catch (error) {
+        warn(`App installation records could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
     for (const entry of entries) {
         try {
             if (entry.error)
                 throw new Error(entry.error);
             recipes.push(validateOne("apps", entry.recipe));
+            const tracked = entry.recipe && entry.canonicalFile && appInstallations.find(record => record.name === entry.recipe.name && path.resolve(record.recipeFile) === path.resolve(entry.canonicalFile));
+            let inspection;
+            try {
+                inspection = await apps.inspectForExport(entry);
+            }
+            catch (error) {
+                exclude("replicas", `App ${entry.recipe.name} (${entry.recipe.platform ?? "all platforms"})`, `current installation state could not be read, so it is not marked for replication (${error instanceof Error ? error.message : String(error)})`);
+                continue;
+            }
+            if (inspection.status === "installed" && entry.recipe) {
+                replicas.push({ kind: "app", name: entry.recipe.name,
+                    ...(entry.recipe.platform === undefined ? {} : { platform: entry.recipe.platform }) });
+            }
+            else if (tracked && inspection.status !== "not installed") {
+                exclude("replicas", `App ${entry.recipe.name} (${entry.recipe.platform ?? "all platforms"})`, `a tracked install record exists, but current installation state is ${inspection.status}${inspection.reason ? ` (${inspection.reason})` : ""}; not marked for replication`);
+            }
+            else if (tracked && inspection.status === "not installed") {
+                exclude("replicas", `App ${entry.recipe.name} (${entry.recipe.platform ?? "all platforms"})`, "the current version probe reports not installed; stale tracking does not create replica intent");
+            }
         }
         catch (error) {
             exclude("apps", `App recipe ${path.basename(entry.file)}`, error instanceof Error ? error.message : String(error));
@@ -108,6 +152,17 @@ export async function buildProfileExport(operations, apps, options = {}) {
     for (const record of selectedPackages) {
         try {
             packages.push(validateOne("packages", record.selection));
+            try {
+                const inspection = await options.packageOperations?.inspect(record.selection);
+                if (inspection?.installed.kind === "installed")
+                    replicas.push({ kind: "package", selection: record.selection });
+                else if (inspection?.installed.kind === "unknown") {
+                    exclude("replicas", describeProfilePackage(record.selection), `host installation state is unknown, so it is not marked for replication (${inspection.installed.reason})`);
+                }
+            }
+            catch (error) {
+                exclude("replicas", describeProfilePackage(record.selection), `host installation state could not be read, so it is not marked for replication (${error instanceof Error ? error.message : String(error)})`);
+            }
         }
         catch (error) {
             exclude("packages", describeProfilePackage(record.selection), `not portable (${error instanceof Error ? error.message : String(error)})`);
@@ -122,8 +177,8 @@ export async function buildProfileExport(operations, apps, options = {}) {
             exclude("skills", `unmanaged Skill ${name}`, "not tracked");
         }
     }
-    const profile = parseProfile({ format: PROFILE_FORMAT, agentDepotVersion: AGENT_DEPOT_PACKAGE_VERSION,
-        sources: portableSources, skills, apps: recipes, packages });
+    const profile = parseProfile({ format: replicas.length ? PROFILE_FORMAT_V2 : PROFILE_FORMAT, agentDepotVersion: AGENT_DEPOT_PACKAGE_VERSION,
+        sources: portableSources, skills, apps: recipes, packages, ...(replicas.length ? { replicas } : {}) });
     return {
         profile,
         exclusions: diagnostics.filter((item) => "block" in item),
@@ -140,14 +195,22 @@ function sourceWarnings(profile) {
         ...profile.packages.flatMap(selection => missing(selection.source, describeProfilePackage(selection))),
     ];
 }
+/** Describes whether an export diagnostic removes a selection or only omits machine-local metadata. */
+export function describeProfileExportExclusion(item) {
+    if (item.reason.startsWith("always present"))
+        return `Not transferred because it is always present: ${item.label}`;
+    return `Excluded ${item.label}: ${item.reason}`;
+}
 /** Shared preview for a frontend-selected subset; Source warnings are recomputed. */
 export function profileExportPreview(profile, diagnostics = []) {
     return ["Preview: export portable user-global profile",
+        SKILL_EXPORT_EXPLANATION,
         ...profile.sources.map(source => `Source ${sourceIdForUrl(source.url)} ${source.url} (included: ${source.included})`),
         ...profile.skills.map(skill => `Skill ${skill.path} [${skill.hosts.join(", ")}] (${skill.version.policy})`),
-        ...profile.apps.map(recipe => `App recipe ${recipe.name} (${recipe.platform ?? "all platforms"}; no approval)`),
-        ...profile.packages.map(selection => `${describeProfilePackage(selection)}; no receipt, no installed state`),
-        ...diagnostics.flatMap(item => "block" in item ? [`Excluded ${item.label}: ${item.reason}`] : item.kind === "load" ? [item.message] : []),
+        ...profile.apps.map(recipe => `App recipe ${recipe.name} (${recipe.platform ?? "all platforms"}; approval not transferred)`),
+        ...profile.packages.map(selection => `${describeProfilePackage(selection)}; no receipt or installed evidence`),
+        ...profile.replicas.map(replica => `Replica intent ${describeProfileReplica(replica)}; no installed state or approval is transferred`),
+        ...diagnostics.flatMap(item => "block" in item ? [describeProfileExportExclusion(item)] : item.kind === "load" ? [item.message] : []),
         ...sourceWarnings(profile).map(warning => warning.message)];
 }
 /** Empty profiles are valid to parse, but are not useful export artifacts. */

package/dist/src/profile-import.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { compareAppVersions } from "./app-version.js";
 import { canonicalizeGitSourceUrl, sourceIdForUrl } from "./git-source.js";
 import { selectionKey } from "./package-model.js";
-import { describeProfilePackage, packageFilterNames, selectProfileItems } from "./profile-export.js";
+import { describeProfilePackage, describeProfileReplica, packageFilterNames, selectProfileItems } from "./profile-export.js";
 import { parseProfile, PROFILE_FORMAT } from "./profile.js";
 import { AGENT_DEPOT_PACKAGE_VERSION } from "./project-manifest.js";
 import { defaultProjectSkillTreeAccess, executeSingleInstall, formatVersionPolicy, outputSingleInstallPreview, planSingleInstall } from "./skill-install.js";
@@ -175,7 +175,8 @@ export async function buildProfileImport(input, operations, apps, filters = {},
     if (AGENT_DEPOT_PACKAGE_VERSION && (compareAppVersions(profile.agentDepotVersion, AGENT_DEPOT_PACKAGE_VERSION) ?? 0) > 0) {
         preview.push(`WARNING: profile Agent Depot ${profile.agentDepotVersion} is newer than running ${AGENT_DEPOT_PACKAGE_VERSION}`);
     }
-    preview.push("Existing choices are never replaced. Source inclusion is a transient discovery choice.", "Same-name App recipes conflict only when platforms overlap; disjoint platform recipes can both be added.");
+    preview.push(...profile.replicas.map(replica => `Origin replica intent: ${describeProfileReplica(replica)}; importing this intent does not approve or install it`));
+    preview.push("Existing choices are never replaced. Source inclusion is a transient discovery choice.", "Replica intent never triggers approval or installation. Apps remain unapproved; Package selection does not install.", "Same-name App recipes conflict only when platforms overlap; disjoint platform recipes can both be added.");
     return { items, packages, preview };
 }
 /** Publish complete JSON exclusively: rename would silently overwrite an existing recipe. */

package/dist/src/profile.js

@@ -3,7 +3,9 @@ import { parseAppRecipe } from "./app-recipes.js";
 import { canonicalizeGitSourceUrl } from "./git-source.js";
 import { selectionKey } from "./package-model.js";
 import { containsCredentialArgument, parseProjectManifest, ProjectManifestError } from "./project-manifest.js";
-export const PROFILE_FORMAT = "agent-depot-profile/v1";
+export const PROFILE_FORMAT_V1 = "agent-depot-profile/v1";
+export const PROFILE_FORMAT_V2 = "agent-depot-profile/v2";
+export const PROFILE_FORMAT = PROFILE_FORMAT_V1;
 function object(value, keys, field) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`${field}: expected an object`);
@@ -127,9 +129,12 @@ function parseProfilePackage(value, field) {
 }
 /** Portable profile parsing shares the manifest and recipe safety contracts. */
 export function parseProfile(value) {
-    const root = object(value, ["format", "agentDepotVersion", "sources", "skills", "apps", "packages"], "profile");
-    if (root.format !== PROFILE_FORMAT)
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("profile: expected an object");
+    const format = value.format;
+    if (format !== PROFILE_FORMAT_V1 && format !== PROFILE_FORMAT_V2)
         throw new Error("profile.format: unsupported profile version");
+    const root = object(value, ["format", "agentDepotVersion", "sources", "skills", "apps", "packages", "replicas"], "profile");
     if (typeof root.agentDepotVersion !== "string" || !/^\d+\.\d+\.\d+(?:[-+][\w.+-]+)?$/u.test(root.agentDepotVersion)) {
         throw new Error("profile.agentDepotVersion: expected a package version");
     }
@@ -179,8 +184,25 @@ export function parseProfile(value) {
         assertPortableText(selection, field);
         return selection;
     });
+    const replicas = root.replicas === undefined
+        ? []
+        : list(root.replicas, "replicas").map((value, index) => parseProfileReplica(value, `replicas[${index}]`));
+    if (format === PROFILE_FORMAT_V2 && root.replicas === undefined)
+        throw new Error("replicas: required for profile v2");
+    if (format === PROFILE_FORMAT_V1 && replicas.length > 0)
+        throw new Error("replicas: non-empty replica intent requires profile v2");
     rejectDuplicates(sources, source => source.url, "sources");
     rejectDuplicates(packages, selectionKey, "packages");
+    rejectDuplicates(replicas, replicaIdentity, "replicas");
+    replicas.forEach((replica, index) => {
+        const exists = replica.kind === "skill"
+            ? parsedSkills.some(skill => skillIdentity(skill) === JSON.stringify([replica.source, replica.path]))
+            : replica.kind === "app"
+                ? apps.some(app => app.name === replica.name && app.platform === replica.platform)
+                : packages.some(selection => selectionKey(selection) === selectionKey(replica.selection));
+        if (!exists)
+            throw new Error(`replicas[${index}]: does not reference a profile resource`);
+    });
     apps.forEach((app, index) => {
         if (apps.slice(0, index).some(previous => previous.name === app.name &&
             (previous.platform === undefined || app.platform === undefined || previous.platform === app.platform))) {
@@ -192,14 +214,56 @@ export function parseProfile(value) {
     const sortedSkills = [...parsedSkills].sort((a, b) => compare(JSON.stringify([a.source, a.path]), JSON.stringify([b.source, b.path])));
     apps.sort((a, b) => compare(a.name, b.name) || compare(a.platform ?? "", b.platform ?? ""));
     packages.sort((a, b) => compare(selectionKey(a), selectionKey(b)));
-    return { format: PROFILE_FORMAT, agentDepotVersion: root.agentDepotVersion, sources, skills: sortedSkills, apps, packages };
+    replicas.sort((a, b) => compare(replicaIdentity(a), replicaIdentity(b)));
+    return { format, agentDepotVersion: root.agentDepotVersion, sources, skills: sortedSkills, apps, packages, replicas };
 }
 /**
  * An empty Package block is omitted, so an export with no Packages stays readable
  * by an Agent Depot version that predates the block.
  */
+function skillIdentity(skill) {
+    return JSON.stringify([skill.source, skill.path]);
+}
+function replicaIdentity(replica) {
+    switch (replica.kind) {
+        case "skill": return JSON.stringify([replica.kind, replica.source, replica.path]);
+        case "app": return JSON.stringify([replica.kind, replica.name, replica.platform ?? null]);
+        case "package": return JSON.stringify([replica.kind, selectionKey(replica.selection)]);
+    }
+}
+function parseProfileReplica(value, field) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${field}: expected an object`);
+    const kind = value.kind;
+    if (kind === "skill") {
+        const record = object(value, ["kind", "source", "path"], field);
+        const [skill] = parseProjectManifest({ version: 1, skills: [
+                { source: record.source, path: record.path, version: { policy: "latest" }, hosts: ["pi"] },
+            ] }, "profile").skills;
+        return { kind, source: skill.source, path: skill.path };
+    }
+    if (kind === "app") {
+        const record = object(value, ["kind", "name", "platform"], field);
+        if (typeof record.name !== "string" || record.name.length === 0)
+            throw new Error(`${field}.name: expected a non-empty string`);
+        const platform = record.platform;
+        if (platform !== undefined && platform !== "linux" && platform !== "windows" && platform !== "darwin") {
+            throw new Error(`${field}.platform: unsupported platform`);
+        }
+        return { kind, name: record.name, ...(platform === undefined ? {} : { platform }) };
+    }
+    if (kind === "package") {
+        const record = object(value, ["kind", "selection"], field);
+        return { kind, selection: parseProfilePackage(record.selection, `${field}.selection`) };
+    }
+    throw new Error(`${field}.kind: expected "skill", "app" or "package"`);
+}
 export function serializeProfile(profile) {
-    const parsed = parseProfile(profile);
-    const { packages, ...rest } = parsed;
-    return `${JSON.stringify(packages.length === 0 ? rest : parsed, null, 2)}\n`;
+    const format = profile.replicas.length ? PROFILE_FORMAT_V2 : PROFILE_FORMAT_V1;
+    const parsed = parseProfile({ ...profile, format });
+    const { packages, replicas, ...rest } = parsed;
+    const output = { ...rest, format,
+        ...(packages.length ? { packages } : {}),
+        ...(replicas.length ? { replicas } : {}) };
+    return `${JSON.stringify(output, null, 2)}\n`;
 }

package/dist/src/tui/app-actions.js

@@ -1,27 +1,67 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useWindowSize } from "ink";
 import { PROJECT_HOSTS } from "../project-manifest.js";
 import { errorText, runBatch } from "./batch.js";
-import { answerYesNo, hostChecklistKey } from "./mode-keys.js";
-import { HostChecklist, PreviewConfirm } from "./panel-parts.js";
-export const APP_KINDS = ["app-approve", "app-hosts", "app-confirm", "app-manual"];
+import { hostChecklistKey, movePreviewCursor } from "./mode-keys.js";
+import { BorderPanel, HostChecklist, PreviewConfirm } from "./panel-parts.js";
+import { previewViewport } from "./preview-window.js";
+export const APP_KINDS = ["app-busy", "app-approve", "app-hosts", "app-confirm", "app-manual"];
 /** Narrows the view's mode without asserting a partial mode is an App mode. */
 export function isAppMode(mode) {
     return APP_KINDS.some(kind => kind === mode.kind);
 }
 /** Recipe name, falling back to the file identity for invalid recipes. */
 export const appName = (entry) => entry.recipe?.name ?? entry.file;
+function appPreviewChrome(mode) {
+    const title = mode.kind === "app-approve" ? "Recipe approval · does not install"
+        : mode.kind === "app-manual" ? "App manual step" : `App ${mode.plan.action} confirmation`;
+    const question = mode.kind === "app-approve" ? `Approve ${appName(mode.entry)}? y/n · recipe approval does not install the App.`
+        : mode.kind === "app-manual" ? "Manual step done, check now? y/n"
+            : `${mode.plan.action} ${appName(mode.plan.entry)}? y/n`;
+    return { title, questions: [question, "Scroll to end before y; n cancels."], footerRows: 2 };
+}
 export function appStepLines(step) {
+    const argv = step.argv;
     return [
-        ...(step.argv ? [`argv: ${JSON.stringify(step.argv)}`, `Executable: ${step.executable ?? `${JSON.stringify(step.argv[0])} not found in PATH`}`] : []),
+        ...(argv ? [
+            "argv: [",
+            ...argv.map((argument, index) => `  ${JSON.stringify(argument)}${index < argv.length - 1 ? "," : ""}`),
+            "]",
+            `Executable: ${step.executable ?? `${JSON.stringify(argv[0])} not found in PATH`}`,
+        ] : []),
         ...(step.manual ? [`Manual: ${step.manual}`] : []),
+        ...(step.declaration ? [step.declaration] : []),
+        ...(step.pattern ? [`Version pattern: ${step.pattern}`] : []),
+        ...(step.environment ? [`Environment: ${step.environment}`] : []),
         `Working directory: ${step.cwd}`,
         ...(step.warning ? [step.warning] : []),
     ];
 }
+export function appRecipePreviewLines(entry, status, steps) {
+    const recipe = entry.recipe;
+    return [
+        `File: ${entry.file}`,
+        `Name: ${recipe?.name ?? entry.file}`,
+        `Platform: ${recipe?.platform ?? "all"}`,
+        `Status: ${status}`,
+        ...(recipe?.homepage ? [`Homepage: ${recipe.homepage}`] : []),
+        ...(recipe?.skills ? [`Owned Skills: ${JSON.stringify(recipe.skills)}`] : []),
+        ...steps.flatMap(step => [step.step, ...appStepLines(step)]),
+    ];
+}
+function appPreviewLines(mode) {
+    if (mode.kind === "app-approve")
+        return mode.lines;
+    return [
+        `App: ${appName(mode.plan.entry)} ${mode.plan.action}${mode.plan.host ? ` (${mode.plan.host})` : ""}`,
+        ...(mode.plan.previousVersion ? [`Previous version: ${mode.plan.previousVersion}`] : []),
+        ...(mode.plan.latestVersion ? [`Latest version: ${mode.plan.latestVersion}`] : []),
+        ...appStepLines(mode.plan),
+    ];
+}
 async function prepareNext(context, requests, results = [], failures = 0) {
     const { manage, apps } = context;
-    manage.setMode({ kind: "busy", label: "Preparing App step..." });
+    manage.setMode({ kind: "app-busy", label: "Preparing App step..." });
     // Independent planning failures never stop the remaining marked Apps.
     const [request, ...remaining] = requests;
     if (!request) {
@@ -33,7 +73,7 @@ async function prepareNext(context, requests, results = [], failures = 0) {
         if (manage.isMounted()) {
             manage.setMode({
                 kind: !plan.argv && plan.manual ? "app-manual" : "app-confirm",
-                plan, remaining, results, failures,
+                plan, remaining, results, failures, cursor: 0,
             });
         }
     }
@@ -52,10 +92,10 @@ export async function startAppAction(context, entries, input) {
             const entry = entries[0];
             if (!entry)
                 throw new Error("No App selected");
-            manage.setMode({ kind: "busy", label: "Preparing recipe approval..." });
-            const steps = await apps.preview(entry);
+            manage.setMode({ kind: "app-busy", label: "Preparing recipe approval..." });
+            const [steps, approval] = await Promise.all([apps.preview(entry), apps.approvalStatus(entry)]);
             if (manage.isMounted()) {
-                manage.setMode({ kind: "app-approve", entry, lines: steps.flatMap(step => [step.step, ...appStepLines(step)]) });
+                manage.setMode({ kind: "app-approve", entry, lines: appRecipePreviewLines(entry, approval.status, steps), cursor: 0 });
             }
         }
         else if (input === "h") {
@@ -78,7 +118,7 @@ export async function startAppAction(context, entries, input) {
 }
 async function execute(context, mode) {
     const { manage, apps } = context;
-    manage.setMode({ kind: "busy", label: "Running App step..." });
+    manage.setMode({ kind: "app-busy", label: "Running App step..." });
     let manualRequired = false;
     const [outcome] = await runBatch([mode.plan], async (plan) => {
         const result = mode.kind === "app-manual"
@@ -102,6 +142,8 @@ async function execute(context, mode) {
 /** Applies checklist and y/n keys, continuing independent batch steps after cancellation or failure. */
 export function handleAppKey(context, mode, input, key) {
     const { manage, apps } = context;
+    if (mode.kind === "app-busy")
+        return;
     const cancel = () => {
         manage.browse();
         manage.setMessage({ kind: "ok", text: "App action cancelled" });
@@ -123,35 +165,42 @@ export function handleAppKey(context, mode, input, key) {
                 void prepareNext(context, requests);
         }
     }
-    else
-        answerYesNo(input, key, () => {
-            if (mode.kind !== "app-approve") {
-                void execute(context, mode);
-                return;
-            }
-            manage.setMode({ kind: "busy", label: "Approving recipe..." });
-            void apps.approve(mode.entry).then(() => manage.finish({ kind: "ok", text: `Approved ${appName(mode.entry)}` }), error => manage.finish({ kind: "error", text: errorText(error) }));
-        }, () => {
+    else {
+        const lines = appPreviewLines(mode);
+        const viewport = previewViewport(lines, mode.cursor, context.terminalRows, context.terminalColumns, appPreviewChrome(mode));
+        const cursor = movePreviewCursor(mode.cursor, viewport.total, input, key, viewport.height);
+        if (cursor !== undefined) {
+            manage.setMode({ ...mode, cursor });
+            return;
+        }
+        if (input === "n" || key.escape) {
             if (mode.kind === "app-confirm" || mode.kind === "app-manual") {
                 void prepareNext(context, mode.remaining, [...mode.results, `${appName(mode.plan.entry)}: cancelled`], mode.failures);
             }
             else
                 cancel();
-        });
+            return;
+        }
+        if (input !== "y" || !viewport.reachedEnd)
+            return;
+        if (mode.kind !== "app-approve") {
+            void execute(context, mode);
+            return;
+        }
+        manage.setMode({ kind: "app-busy", label: "Approving recipe..." });
+        void apps.approve(mode.entry).then(() => manage.finish({ kind: "ok", text: `Approved ${appName(mode.entry)}` }), error => manage.finish({ kind: "error", text: errorText(error) }));
+    }
 }
 /** Renders App prompts using the existing checklist and preview-confirm panels. */
 export function AppPanel({ mode }) {
+    const { rows, columns } = useWindowSize();
+    if (mode.kind === "app-busy")
+        return _jsx(BorderPanel, { title: "App lifecycle", children: _jsx(Text, { children: mode.label }) });
     if (mode.kind === "app-hosts") {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["App Host steps: checked = setup, unchecked = teardown. Wiring is not tracked. Space/1-", mode.choices.length, " toggle, j/k move, Enter continue, Esc cancel."] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
-    }
-    if (mode.kind === "app-approve") {
-        return _jsx(PreviewConfirm, { lines: mode.lines, question: `Approve ${appName(mode.entry)}? y/n` });
+        return (_jsxs(BorderPanel, { title: "App Host steps", children: [_jsx(Text, { children: "Checked = setup. Unchecked = teardown. Wiring is not tracked." }), _jsxs(Text, { children: ["Space/1-", mode.choices.length, " toggle \u00B7 j/k move \u00B7 Enter continue \u00B7 Esc cancel"] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
     }
-    return (_jsx(PreviewConfirm, { lines: [
-            `Environment: ${mode.plan.environment}`,
-            `App: ${appName(mode.plan.entry)} ${mode.plan.action}${mode.plan.host ? ` (${mode.plan.host})` : ""}`,
-            ...appStepLines(mode.plan),
-        ], question: mode.kind === "app-manual"
-            ? "Manual step done, check now? y/n"
-            : `${mode.plan.action} ${appName(mode.plan.entry)}? y/n` }));
+    const lines = appPreviewLines(mode);
+    const chrome = appPreviewChrome(mode);
+    const viewport = previewViewport(lines, mode.cursor, rows || 24, columns || 80, chrome);
+    return (_jsx(PreviewConfirm, { title: chrome.title, lines: lines, cursor: mode.cursor, question: viewport.reachedEnd ? chrome.questions[0] : chrome.questions[1], chrome: chrome }));
 }