@apilift/cli 1.4.22 → 1.4.23

package/dist/apilift.js

@@ -34363,6 +34363,12 @@ import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync8, readFileSyn
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname6, join as join12, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
+function missingSkill(root) {
+  return skillNames.find((name) => !existsSync4(join12(root, "skills", name, "SKILL.md")));
+}
+function completeCopy(source, target) {
+  return files(source).every((path2) => existsSync4(join12(target, path2)));
+}
 function files(root, relative = "") {
   return readdirSync(join12(root, relative), { withFileTypes: true }).flatMap((entry2) => {
     const path2 = join12(relative, entry2.name);
@@ -34405,7 +34411,7 @@ function active(agent2, expected) {
     if (typeof plugin.enabled !== "boolean" || typeof plugin.version !== "string") return { ready: false, known: false, detail: `${agent2} plugin status could not be checked: Apilift status is incomplete` };
     if (!plugin.enabled) return { ready: false, known: true, detail: "Apilift is disabled in this agent" };
     if (plugin.version !== expected) return { ready: false, known: true, detail: "The active Apilift plugin does not match the packaged version" };
-    return { ready: true, known: true, detail: "Agent setup skill is active" };
+    return { ready: true, known: true, detail: "Apilift setup, use and discovery skills are active" };
   } catch (error62) {
     const code = typeof error62 === "object" && error62 && "code" in error62 ? error62.code : void 0;
     const reason = code === "ETIMEDOUT" ? "plugin list timed out after 10 seconds" : code === "ENOENT" ? `${agent2} executable was not found` : "plugin list failed";
@@ -34415,7 +34421,8 @@ function active(agent2, expected) {
 function inspectAgentPlugin(agent2, env, sourceOverride) {
   if (env.APILIFT_DEV_PLUGIN_ROOT) return { ready: false, version: "development", detail: "Development plugin activation has not been verified" };
   const source = resolve2(sourceOverride || join12(dirname6(fileURLToPath(import.meta.url)), "plugin"));
-  if (!existsSync4(join12(source, "skills", "setup", "SKILL.md"))) return { ready: false, version: "unknown", detail: "CLI package is missing its setup skill" };
+  const missing = missingSkill(source);
+  if (missing) return { ready: false, version: "unknown", detail: `CLI package is missing its ${missing} skill` };
   const version2 = readJson(join12(source, `.${agent2}-plugin`, "plugin.json"))?.version;
   if (typeof version2 !== "string" || !/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(version2)) throw new Error("Plugin package version is invalid");
   const bundleDigest = digest(source);
@@ -34423,23 +34430,25 @@ function inspectAgentPlugin(agent2, env, sourceOverride) {
   const home = resolve2(env.APILIFT_AGENT_HOME || homedir2());
   const plugin = agent2 === "codex" ? join12(home, "plugins", "apilift") : join12(home, ".agents", "plugins", "plugins", "apilift");
   const marker = readJson(join12(plugin, markerName));
-  const staged = marker?.package === "apilift" && marker.bundleDigest === bundleDigest && marker.version === version2 && existsSync4(join12(plugin, "skills", "setup", "SKILL.md"));
-  if (!staged) return { ready: false, version: expected, detail: "Agent setup skill is missing or stale" };
-  if (env.APILIFT_AGENT_HOME || env.APILIFT_AGENT_NO_ACTIVATE === "1") return { ready: false, version: expected, detail: "Agent setup skill is staged; activation is unverified" };
+  const staged = marker?.package === "apilift" && marker.bundleDigest === bundleDigest && marker.version === version2 && completeCopy(source, plugin);
+  if (!staged) return { ready: false, version: expected, detail: "Apilift plugin files are missing or stale" };
+  if (env.APILIFT_AGENT_HOME || env.APILIFT_AGENT_NO_ACTIVATE === "1") return { ready: false, version: expected, detail: "Apilift skills are staged; activation is unverified" };
   const activation = active(agent2, expected);
   return { ready: activation.ready, version: expected, detail: activation.detail, checkFailed: !activation.known };
 }
 function ensureAgentPlugin(agent2, env, sourceOverride) {
   if (env.APILIFT_DEV_PLUGIN_ROOT) {
     const source2 = resolve2(env.APILIFT_DEV_PLUGIN_ROOT);
-    if (!existsSync4(join12(source2, "skills", "setup", "SKILL.md"))) throw new Error("Development plugin setup skill is missing");
+    const missing2 = missingSkill(source2);
+    if (missing2) throw new Error(`Development plugin ${missing2} skill is missing`);
     const bundleDigest2 = digest(source2);
     const root = resolve2(env.APILIFT_HOME || join12(homedir2(), ".local", "share", "apilift"));
     writeJson(join12(root, "agent-plugins", `${agent2}.json`), { root: source2, digest: bundleDigest2 });
     return { ready: false, version: `dev+${bundleDigest2.slice(0, 12)}`, detail: "Development plugin source recorded; activation was not verified" };
   }
   const source = resolve2(sourceOverride || join12(dirname6(fileURLToPath(import.meta.url)), "plugin"));
-  if (!existsSync4(join12(source, "skills", "setup", "SKILL.md"))) throw new Error("CLI package is missing its setup skill");
+  const missing = missingSkill(source);
+  if (missing) throw new Error(`CLI package is missing its ${missing} skill`);
   const version2 = readJson(join12(source, `.${agent2}-plugin`, "plugin.json"))?.version;
   if (typeof version2 !== "string" || !/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(version2)) throw new Error("Plugin package version is invalid");
   const bundleDigest = digest(source);
@@ -34449,7 +34458,7 @@ function ensureAgentPlugin(agent2, env, sourceOverride) {
   const marker = readJson(join12(plugin, markerName));
   if (existsSync4(plugin) && marker?.package !== "apilift") throw new Error(`Refusing to replace unmanaged plugin ${plugin}`);
   const expected = agent2 === "codex" ? `${version2}+codex.${bundleDigest.slice(0, 12)}` : version2;
-  const current = marker?.bundleDigest === bundleDigest && marker.version === version2 && existsSync4(join12(plugin, "skills", "setup", "SKILL.md"));
+  const current = marker?.bundleDigest === bundleDigest && marker.version === version2 && completeCopy(source, plugin);
   if (!current) {
     const staging = `${plugin}.stage-${process.pid}`;
     rmSync4(staging, { recursive: true, force: true });
@@ -34476,7 +34485,7 @@ function ensureAgentPlugin(agent2, env, sourceOverride) {
   if (document.name !== "personal" || !Array.isArray(document.plugins)) throw new Error("Unsupported personal plugin marketplace");
   document.plugins = [...document.plugins.filter((item) => typeof item === "object" && item !== null && item.name !== "apilift"), { name: "apilift", source: { source: "local", path: "./plugins/apilift" }, policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" }, category: "Developer Tools" }];
   writeJson(marketplacePath, document);
-  writeJson(join12(marketplace, ".claude-plugin", "marketplace.json"), { "$schema": "https://anthropic.com/claude-code/marketplace.schema.json", name: "personal", description: "Personal agent plugins", owner: { name: "Local" }, plugins: [{ name: "apilift", description: "Apilift setup", source: "./plugins/apilift", category: "development" }] });
+  writeJson(join12(marketplace, ".claude-plugin", "marketplace.json"), { "$schema": "https://anthropic.com/claude-code/marketplace.schema.json", name: "personal", description: "Personal agent plugins", owner: { name: "Local" }, plugins: [{ name: "apilift", description: "Use logged-in apps and discover missing actions with Apilift", source: "./plugins/apilift", category: "development" }] });
   if (env.APILIFT_AGENT_HOME || env.APILIFT_AGENT_NO_ACTIVATE === "1") return { ready: false, version: expected, detail: `Plugin staged at ${plugin}; activation is disabled` };
   const initial = active(agent2, expected);
   if (!initial.known) return { ready: false, version: expected, detail: initial.detail, checkFailed: true };
@@ -34500,11 +34509,12 @@ function ensureAgentPlugin(agent2, env, sourceOverride) {
   const activation = active(agent2, expected);
   return { ready: activation.ready, version: expected, detail: activation.detail, checkFailed: !activation.known };
 }
-var markerName;
+var markerName, skillNames;
 var init_plugin = __esm({
   "src/plugin.ts"() {
     "use strict";
     markerName = ".apilift-managed.json";
+    skillNames = ["setup", "use", "discover"];
   }
 });
 

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "apilift",
-  "version": "1.4.22",
-  "description": "Set up Apilift and use authenticated app interfaces.",
+  "version": "1.4.23",
+  "description": "Use logged-in apps and discover missing actions with Apilift.",
   "author": {
     "name": "Apilift"
   }

package/dist/plugin/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "apilift",
-  "version": "1.4.22",
-  "description": "Set up Apilift and use authenticated app interfaces.",
+  "version": "1.4.23",
+  "description": "Use logged-in apps and discover missing actions with Apilift.",
   "author": {
     "name": "Apilift"
   },
@@ -9,8 +9,8 @@
   "skills": "./skills/",
   "interface": {
     "displayName": "Apilift",
-    "shortDescription": "Link and check Apilift",
-    "longDescription": "Set up Apilift for this agent and check installation readiness.",
+    "shortDescription": "Agent access to your apps",
+    "longDescription": "Give your agent reusable access to logged-in apps. Apilift finds existing actions or builds and verifies missing ones from documented APIs and browser activity. Use it to read, create, and update app data. Requires the Apilift CLI; browser actions also require Chrome, the Apilift extension, and a signed-in account.",
     "developerName": "Apilift",
     "category": "Developer Tools",
     "capabilities": [
@@ -18,7 +18,15 @@
     ],
     "websiteURL": "https://apilift.dev",
     "defaultPrompt": [
-      "Run apilift setup and follow its returned steps."
-    ]
+      "Set up Apilift for this agent.",
+      "Use Apilift to complete a task in one of my logged-in apps.",
+      "Add missing actions for an app with Apilift."
+    ],
+    "brandColor": "#000000",
+    "brandColorDark": "#D8FF73",
+    "composerIcon": "./assets/apilift-icon.png",
+    "logo": "./assets/apilift-icon.png",
+    "privacyPolicyURL": "https://apilift.dev/privacy",
+    "termsOfServiceURL": "https://apilift.dev/terms"
   }
 }

package/dist/plugin/skills/discover/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: discover
+description: Create or extend a persistent Apilift interface from current documented APIs or, when unavailable, observed logged-in UI behavior. Publish only the independent resources needed for the requested outcome.
+---
+
+# Discover or extend an app
+
+Turn the requested outcome into the smallest set of reliable actions. Remain one discovery owner for the app's semantic decisions, browser operation, verification, cleanup, and publication. Do not use source code, old capture files, another worker's drafts, browser storage, or secret values as an answer key. Follow the CLI's current response and the returned editable files for command details; this skill supplies decisions that must be made before those commands.
+
+## Select scope and route
+
+Find existing coverage with `apilift apps search <query>` and focused `actions search` or `actions show`. Begin a new app with `apilift apps new <slug>` or extend the selected existing app with `apilift apps update <app>`. Use a stable root `--session <worker-label>` on every command if the runtime has no stable identity. Report the authoritative app and visibility before accessing its UI. One session owns at most one selected draft; leave another worker's draft alone.
+
+For every requested action, assess current first-party operation and access documentation before browser preflight. `apilift discover api assess <entity.verb>` creates a focused editable finding; save a researched conclusion with `discover api save`. API documentation, authorization, and credential acquisition are separate questions. A missing local key or authentication failure does not prove the API route is absent. Use [documented-api.md](references/documented-api.md) for this decision. Use [browser-capture.md](references/browser-capture.md) only when the requested operation still needs observed UI behavior.
+
+## Author one resource at a time
+
+Use `apilift discover draft <kind> [name]` for `app`, `entity`, `transport`, `browser-page`, or `action`. Its response gives a private JSONC path; edit that file. The file contains the published `definition` and local `dependencies`, `verification`, and `capture` settings. App origin is its primary UI location, not every request destination. Publish missing entity and connection resources before an action that depends on them; a browser connection also needs a published browser page. Keep credential values and recurring local context values out of every definition. Read [operation-contract.md](references/operation-contract.md) before defining an action.
+
+Check the selected file with `apilift discover check`; it sends no app request and reports independent field errors. An executable connection or action needs an explicit `apilift discover run` with representative values in `verification.inputs`; a connection also selects `verification.probeOrigin`. Inspect saved output against official documentation or observed app state and set `verification.review` to `accepted` only when its meaning is correct. A schema match or HTTP success alone is insufficient. For a mutation, assess its separate readback proof and never repeat the write merely to improve evidence. Metadata resources need no app execution. `apilift discover publish` publishes the exact selected version after its gates and sends no app request.
+
+## Recover and finish
+
+Use `apilift discover status` to recover the selected draft, result path, recording phase, or pending publication. A lost publication response is reconciled with the exact retained `discover publish` request before editing, deferring, or discarding. `discover rebase` is for a version conflict after reviewing the current resource. `discover defer` retains owned work, `discover discard` abandons only its unpublished draft, and `discover close` leaves the app when owned in-flight work has settled. A stopped recording must be confirmed or canceled before changing drafts or tabs. Follow [recovery.md](references/recovery.md) before treating a failed route as a terminal blocker.
+
+Completion means the requested actions are published and the original authorized outcome is handled, or a specific human-only or external prerequisite is identified. Inspect published consumer help from a fresh session and obtain required values through its published source actions; the author's local verification inputs are not consumer coverage. Do not send an extra mutation merely to demonstrate publication. Report actual verification, authorized test state, one optional cleanup attempt if relevant, and remaining gaps.

package/dist/plugin/skills/discover/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Discover or Extend App"
+  short_description: "Discover and publish an indexed app interface"
+  default_prompt: "Use $apilift-dev:discover to add the smallest verified app interface needed for this outcome."

package/dist/plugin/skills/discover/references/browser-capture.md

@@ -0,0 +1,13 @@
+# Observe a logged-in UI
+
+Use UI observation only after a focused current API and access assessment. Publish the browser page, then run `apilift browser check <app>` and follow its setup diagnostics before capture; the first connection need not exist for this check. Chrome with the Apilift extension must be controllable in the intended signed-in profile; an incompatible connection does not authorize another browser or account. Use `apilift browser tabs <app>` and the returned selection path if several tabs match, leaving a tab owned by another agent untouched. Follow the repository browser lease when developing inside the repository.
+
+Publish a `browser-page` definition with `pageOrigin` and `startUrl` for the selected UI page. Publish a separate browser `transport` with `mode: "browser"`, fixed `allowedOrigins`, read-only `probes` and `dependencies.browserPage` naming that published page. A safe documented page read can be a probe when no JSON route has been observed; use an empty response contract and review the bounded non-JSON format/status result. That result confirms only reachability; inspect the signed-in UI and confirm the page's meaning before accepting the probe. A safe observed read can also inform the probe. Run and semantically review each configured origin before publishing the connection. Preserve working direct connections; each action selects its own published connection.
+
+Before recording, select an action draft and describe the domain entity, verb, effect, successful result, input meanings and verification plan. Put caller-chosen representative values in `verification.inputs`, declare their schema in the definition, and select the tab in the file's `capture` settings. Arm with `apilift discover capture start` before entering the first caller value when a UI editor autosaves. Perform one authorized scenario in the selected tab and immediately run `apilift discover capture stop` after its causal request. If stop acknowledgement is lost, retry stop without replaying the app operation or changing tabs; if the scenario cannot proceed, use `discover capture cancel`.
+
+Stop returns a bounded ranked candidate list. Use `discover capture list` for further candidate metadata and `discover capture show <candidate-id>` for selected evidence. Choose the causal exchange with `discover capture select <candidate-id>`; selection updates the owned draft from the retained observation. Preserve observed structure, review every binding and response field, and replace private samples with caller inputs, generated values, public literals or reachable source actions. An observed identifier is not automatically a caller choice. Do not export raw capture data to the repository.
+
+Only when the selected request contains an unexplained authentication header, run `discover capture auth <candidate-id>` while evidence is current; no field or storage scope is required for its bounded default search of retained non-browser-owned headers against localStorage and sessionStorage. `discover capture show <candidate-id> --part request` displays header names and eligible field pointers without values. Narrow the search through the draft's `capture.authField` or `capture.authScope` only when the observed evidence supports it. Map a supported value-free locator to the browser connection's `definition.inject[].from` and its destination header to `definition.inject[].to`, then validate a safe connection probe; `definition.credentials` is only for separately saved human-provided secrets. Browser-managed cookies are sent by browser replay and do not require a storage locator. Do not turn secret values, browser-owned headers, or account data into action inputs or constants. Evidence expiry calls for a safe read or explicit primer, never another mutation.
+
+Do not change tabs, browser surfaces, or draft ownership until stop or cancel confirms the recording boundary. A capture or controller failure is a local problem; apply [recovery.md](recovery.md) before declaring an app capability absent.

package/dist/plugin/skills/discover/references/documented-api.md

@@ -0,0 +1,9 @@
+# Assess a documented API
+
+Search current first-party documentation for the selected operation and its authorization path. Record both in the file returned by `apilift discover api assess <entity.verb>`, then run `apilift discover api save`. A prose operation guide can be enough to author a selected action; an OpenAPI document is useful evidence but is not an import command. Documentation silence, a missing local credential, and an auth error are different findings. Follow explicit current documentation the user supplies even if an earlier assessment was negative.
+
+A direct connection is an independent `transport` draft. Give it a meaningful description, `mode: "direct"`, fixed `baseUrl`, explicit `allowedOrigins`, value-free `credentials` requirements and harmless read `probes` for its destinations. Research and write concrete HTTPS acquisition steps before testing an operation that needs a key. The app's `origin` is its primary UI location; it is not a substitute for a connection destination. A transport with several origins needs one successful, semantically reviewed `discover run` per origin by editing `verification.probeOrigin` between runs. For a read using POST or another non-GET method, declare its semantic read effect rather than deriving effect from method.
+
+If verification reports a missing or changed credential, follow the returned `credentials add` setup link. The person enters the value through the secure form, and the agent then selects the intended saved entry for this session with the exact CLI continuation. Do not ask for a key in chat or store it in a draft, command, environment variable, or capture. Acquisition instructions are required even if a key is already saved; they let the next user provision access. Re-run the same selected transport verification after human setup and inspect its meaning before accepting review.
+
+A scoped harmless probe can take explicit local `verification.inputs`. Publish a reachable read action that supplies an app-owned identifier for later consumers; never embed an observed account identifier in a published probe or make the origin dynamic. Do not add a published context-variable resource. Begin browser fallback only after the requested documented operation, authorization, and provisioning route have been assessed. A local environment failure is not proof that the app lacks an API capability.

package/dist/plugin/skills/discover/references/operation-contract.md

@@ -0,0 +1,15 @@
+# Define and prove an action
+
+Name a precise domain `entity.verb` for the requested outcome. Before transport capture, define its entity, semantic effect, caller decisions, useful returned result, and independent proof of a mutation. Do not expand one read into general CRUD coverage. Check whether returned objects are the requested entities or containers requiring traversal and pagination. HTTP success and a matching title do not establish complete coverage.
+
+An action's published `definition` describes its effect, JSON Schema `inputs`, request, response and, for a mutation, readback proof. `dependencies.transport` selects one published connection and is translated to the action's selected transport at publication. Request fields include method, URL, optional headers, query and JSON body. Use typed `{"$input":"name"}` and encoded `{input.name}` bindings for caller values. Public protocol literals are allowed; captured account identifiers, credential values and local defaults are not. Use generated bindings for fresh request identifiers, never a caller flag invented from a captured identifier.
+
+Each visible input and response field needs a semantic description; caller inputs also need synthetic examples. A value owned by the app needs a published source action with a compatible selected result path. Producers never run implicitly: the consumer runs the documented source and supplies its selected value. Do not use a prose-only dependency, a published context-variable resource, or the author's local verification value as a source. Per-app scalar `context` defaults are a consumer convenience with exact input-name matching, not an action contract or account model. Ambiguous generic names are passed explicitly.
+
+Select the useful response subtree with `response.path` when needed and validate it with `response.schema`; projected fields use paths relative to the selected subtree or array member. Preserve meaningful variants and nullable fields observed in real results. If verification reports a mismatch, inspect the selected value and correct its type or projection rather than weakening the contract to pass. Keep identity and relationship fields needed for further discovery.
+
+A mutation needs a separate read-only proof request and meaningful comparisons to the intended state. A proof failure leaves the write possibly applied; inspect state through an authorized read and never repeat a possibly sent write just to get stronger proof. For a delete, an explicit absence proof may establish success. A readback or probe using POST may declare semantic `effect: "read"`; method alone is not the effect.
+
+Put representative local values in `verification.inputs`, run `apilift discover check`, then explicitly `apilift discover run`. Judge the saved output against documentation or observed UI state. Set `verification.review` to `accepted` only after that judgment and `rejected` with notes otherwise; `discover publish` does not execute the app operation again. After publication, inspect `actions show` as a fresh consumer, obtain every required value through published source actions and finish the originally authorized outcome. Do not send a second mutation merely to test publication.
+
+A genuinely terminal, command-scoped unavailable boundary may be documented only with evidence. Authentication, account tier, local transport, missing permission and ambiguous UI are retryable or user-specific blockers, not proof of app-wide absence. Keep existing working actions intact and defer unresolved work.

package/dist/plugin/skills/discover/references/recovery.md

@@ -0,0 +1,7 @@
+# Recover from a failed route
+
+1. Protect owned state first. If a recording is active, confirm `discover capture stop` or `discover capture cancel`; if a publication response was lost, inspect `discover status` and reconcile the retained `discover publish` request. Keep useful drafts and evidence.
+2. Read the complete bounded diagnostic and exact continuation. Use `apilift doctor`, selected CLI help or the editable file only for the uncertainty at hand. Retry after a relevant state change or an explicitly safe recovery instruction; never infer success from a shell wrapper without the process exit status.
+3. Reassess the requested outcome. A local command, browser or credential failure is evidence about that route, not proof that the app lacks the capability. Continue through another authorized documented route or independent action when it can advance the outcome without weakening proof or policy.
+4. Ask the person only for login, MFA, CAPTCHA, WebAuthn, credential provisioning in the secure UI, new permission or a material scope choice they alone can supply. Do not ask them to paste a secret into chat or a command.
+5. If no authorized route remains, report the precise missing outcome, retained owned state, materially different routes checked and exact prerequisite. Use `discover defer` to retain retryable work and `discover close` only after selected in-flight work is settled.

package/dist/plugin/skills/use/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: use
+description: Use Apilift to read, create, update, rename, or export data in logged-in apps when no first-party CLI, SDK, MCP server, or documented API covers the task. Check existing actions before browser work and discover missing coverage.
+---
+
+# Use an indexed app
+
+Use Apilift when a more direct installed capability does not cover the requested outcome. For a task in a logged-in app, check Apilift coverage before opening or operating its browser UI. Treat the CLI's current output as the navigation and execution contract. Do not read discovery drafts, captures, registry internals, browser storage, or implementation code to learn how to call a published action.
+
+Start with `apilift` if the next command is unknown. Search by app name or domain with `apilift apps search <query>`, then select the intended app with `apilift apps use <app>`. Search unknown task vocabulary with `apilift actions search <app> <query>`; use the displayed `actions list` or `actions show` command for focused documentation. Read the selected action's effects, inputs, result, limits, and source instructions before `apilift run <app> <entity.verb> [input flags]`. A selected app is a use-session choice, not proof that any action was verified or authorized. Cached documentation is last-known; execution still requires current online authorization.
+
+Use explicit flags for ambiguous values. `apilift context set <name> <scalar> --app <app>` saves an exact-name scalar default in this agent's app session; `context show`, `unset`, and `clear` inspect or remove it. An explicit action flag wins over a default. Do not save complex objects, opaque values copied from examples, or inferred account identifiers. Obtain an app-owned value through the published source action and its documented selection path. If the source is missing, that is missing coverage. Clear defaults when the access scope changes; credential selection also invalidates them.
+
+For a direct connection requiring a saved credential, use the exact `credentials list`, `use`, or `add` continuation printed for that app and connection. Selection belongs to this agent session and does not switch browser login. Only the person uses the secure credential form; never ask for a secret in chat, shell arguments, environment variables, files, or a generic dashboard field. `credentials unbound` and `attach` are explicit recovery paths after a registry reset, never an invitation to match a secret by app name or origin. For browser actions, use the selected signed-in Chrome tab and the CLI's `browser check` or `browser tabs` guidance. An unusable Chrome connection is a local blocker, not evidence that the app lacks an action.
+
+Respect policy, entitlement, effect, cost, and unavailable boundaries before dispatch. A refusal does not authorize direct HTTP or a new interface around it. Do not automatically retry a mutation that may have reached the app, including one whose result or readback proof was lost. Follow the retained invocation's recovery instruction and inspect state through a documented read. Check returned objects against the requested domain meaning, traverse pagination and containers where needed, and do not claim completion from a title or status code alone. Read only the selected result fields needed for the decision; oversized output is saved to the path printed by the CLI.
+
+If the app, action, required input source, or result field is absent, tell the discovery owner the user outcome, the precise missing consumer capability, semantic input sources, required result, official documentation supplied by the user, and which published actions must remain intact. One owner should extend the app with the `discover` skill, then the consumer should read the newly published action help and complete the original task. Ask about test-state effects only when they are outside existing authorization. `apilift apps release <app>` ends this use session and clears its local selections and defaults when the work is done.

package/dist/plugin/skills/use/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Use Apilift Apps"
+  short_description: "Use and extend indexed app actions"
+  default_prompt: "Use $apilift-dev:use to turn this logged-in product task into a reusable CLI and complete it."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apilift/cli",
-  "version": "1.4.22",
+  "version": "1.4.23",
   "private": false,
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   "engines": {
     "node": ">=24.16.0 <27"
   },
-  "gitHead": "b15fdbdb79e9b616826f983f8963a34b81afdb5e",
+  "gitHead": "71f3e4ff037702755b511a14ec98c2ed9fb4e045",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/egor-sergeev/apilift.git",