Apply this competence to the work described below. The public edition 0.3.2 includes its method, operating knowledge and worked examples. Add your context after the supplied knowledge. Use execution tools only if this host provides them. # Kernel Plugin Incarnation ## Object and destination Form the relation through which a semantic capability or kernel becomes a usable plugin in an AI environment. Understand the recipient's work and the source capability enabling it. Transfer coherent knowledge and means. Correct files represent capability; use in the recipient shows exercise. Reach the source method and its reasons. For a concrete format, installation, interface, authentication or compatibility choice, consult the chosen environment's current official documentation. Preserve observation date and scope rather than treating remembered provider behavior as current fact. ## Distinguish functions to compose them Understand what belongs in instructions: contextual interpretation, method, source selection, continuity and learning. Tools may provide current data, service access or material action. Interfaces expose options, state and consequences when they help user choices. These relations guide design while remaining revisable through the case. Reuse supported tools performing the needed function. Form a connection for an actually absent capability. A connector does not repair a semantic method; rewriting a skill does not configure account access. Keep credentials and account state outside public instructions. Let recipients understand the means needed for promised work. When a function depends on an external service, make its connection reachable and explain it in use. If an optional capability is missing, continue the valid method using available materials without simulating service data or actions. ## Follow capability into use Distinguish kernel source, plugin version, skill snapshot, linked service and recipient state. Source changes do not automatically update installed plugins. A generated folder does not prove loading, discovery or exercise. Distinguish plugin-local state, package files and durable project knowledge. Check the host's current lifecycle contract for updates and uninstallation. Keep the only copy of irreplaceable knowledge outside removable storage: plugin working space can have a different lifetime from the project. Prepare the smallest form enabling complete initial work. Check provider-required format and use a pertinent case to observe the method. A claim of recipient use should identify the version, context and observed result. “I used the skill” alone does not show which contribution changed an answer. ## Understand friction Recover the difference causing interruption: unreadable package, undiscovered skill, incomplete method, obsolete source, missing service or insufficient permission require different corrections. A research plugin may choose the right source while an index returns an old copy. Editing skill prose does not update that source. Reach the owner's current coordinate when freshness changes the decision; if unavailable, keep uncertainty with the particular affected claim. Distinguish account authentication, service authorization, host permissions and user mandate for the concrete action. Technical sending capability is not selection of a message. That distinction governs the effect without blocking useful content preparation. ## Portability and return to the method Across hosts, preserve a recognizable semantic source and adapt the mechanisms making it reachable. Matching filenames do not establish functional equivalence. Reactive chats and agentic environments may differ in tools and persistence; describe what the recipient can actually do. After meaningful use, preserve version identity, decision reasons, result and useful difference. A particular lesson changes the plugin; a packaging error changes packaging; a loss translating capability can change this transfer competence. One event may have several object-specific returns. This is a meta relation because it forms how capability becomes an operating product. It is autological when plugin work reforms transfer itself. If source selection repeatedly yields stale data, change that criterion and its rationale before another port. Continuing learning is distinct from publishing a release. ## Use and continuity in the recipient Use supplied materials in chat or actual files, tools and guides where available. Ask only for missing context that matters and proceed when a useful result is possible. Preserve reasons, decisive sources, differences and continuation in the project's actual location; otherwise return a reusable note. Instructions can change the used method without changing model weights or proving stable learning. Distinguish availability, actual use and later behavior. Accounts, tools and authority over concrete effects follow the recipient's real mandate and environment. ## Nature and provenance MAIOS adaptation of Kernel Plugin Incarnation, preserving translation between semantic capability, product and recipient. Provider-specific format and installation follow current official documentation. This kit does not establish particular compatibility or completed installation. ## Reachable operating knowledge Read [OPERATING_GUIDE.md](OPERATING_GUIDE.md) as part of this method when forming the work. It carries the practical knowledge, decision relations and available means for this capability. The complete chat starter includes this knowledge and worked examples, so it remains usable without private sources. Preserve the public source identity and adapt through the recipient's actual means. # Kernel Plugin Incarnation ## Conduct the plugin field from the actual job A plugin task may concern product purpose, component design, packaging, installation, discovery, authentication, controlled actions, evaluation, distribution, portability or troubleshooting. Let the work select the knowledge needed. Do not run every family as a checklist. Preserve one semantic source with thin receiver-specific incarnations where possible, rather than independently rewriting the product for each host. Consult current official specifications and provider documentation before making format, compatibility, permission or submission claims; keep observation date and uncertainty where they affect the choice. ## Put each function in a component that can supply it A skill carries method, examples and situated decisions. A service/tool layer can supply live data, authentication and controlled actions. UI makes human-visible state and intervention useful when the work benefits. Lifecycle actions require a host that actually executes the corresponding hooks; a file in an archive does not establish runtime execution. A specialist process is optional and requires the host's actual mechanism and the person's selected mandate. Provider-specific constructs belong to that incarnation rather than silently redefining the portable source. Make a public operation self-contained: bundle or explicitly declare the components required for the intended user goal. A private combination of several installed connectors does not mean another recipient receives those means. Keep durable project knowledge outside an uninstallable package cache; distinguish installed files, disposable local state and the project's continuing record. ## Resolve discovery and execution separately A technically valid package may be uninstalled, disabled, absent from the present session, undiscovered, unauthenticated or unused. Inspect the actual failing relation. The name and description must expose the recognizable goal so the method can be reached. Body knowledge cannot help if discovery never supplies it. A connected tool may still lack the data permission or exact effect mandate needed for the action. Put enforceable access and data controls at the service boundary. Model instructions guide conduct but do not replace server checks. Distinguish authenticated identity, service authorization, host permissions and the person's mandate. Use least privilege and minimize private data exposed to tools, logs and UI. Inspect executable scripts, hooks, dependencies and untrusted inputs where their behavior changes trust or use. Keep credentials out of source and skill text. ## Use cases that distinguish causes Choose a case capable of exposing the suspected loss: direct or indirect intent, incomplete input, unrelated request, follow-up, unavailable connection or missing permission. These are choices, not a compulsory quota. Observe activation, completeness, unsupported inference, tool use, preserved authority and context/process cost where material. Retain version, conditions, actual result and the responsible owner. Do not repair an authentication failure by changing semantics or a semantic failure by merely renaming the package. A search result or indexed repository view may be stale. When freshness changes action, recover the exact current owner coordinate and read the smallest decisive source directly. Preserve previous observations with their own scope. For distribution, distinguish a local prototype, shared repository, team installation and public submission. A source push is not installation or public approval. Port user intent, method, source/effect distinctions and useful learning while translating manifests, tools, configuration, UI and runtime mechanisms through the receiving host. Return a local lesson to the product, a provider lesson to its adapter, and a general incarnation lesson to this competence. # Kernel Plugin Incarnation — application examples [Italiano](ESEMPI_IT.md). The following cases illustrate how the method is used. ## Connect a research assistant’s method to an archive tool The method explains how to qualify and connect sources; a supported tool reads the archive. Integration connects those contributions without putting credentials in the skill. A first case observes data access and method use separately. ## Repair a competence’s entry when installation already works Real work reveals that the installed plugin’s entry does not make the useful situation recognizable. Correct discovery and the pertinent description while preserving the valid method body. Reinstallation or additional tools do not automatically address that cause. ## Correct retrieval when an index returns a superseded source The plugin finds the right document through an index but retrieves an old version. Retrieval must reach the current source or preserve uncertainty about freshness. The case can also change the porting method: retrieval evidence must concern the source actually supporting the result. ## Apply the method to your case Use [SKILL.md](SKILL.md) or [START_CHAT_EN.txt](START_CHAT_EN.txt) with the relevant sources and your actual context. Keep observations, interpretations and what remains open distinguishable. Preserve the useful reason and continuation in the project’s guide. # Your context Intention, sources, existing work, available means and entrusted actions: [add here].