opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/accint-solve/SKILL.md

@@ -1,205 +1,35 @@
 ---
 name: accint-solve
-description: "Route agent work through AccInt's MCP memory loop: retrieve prior outcomes, resolve frames, and close commitments with evidence."
-category: ai-agents
-risk: safe
-source: community
+description: Route a goal through acc's scored-memory loop via acc_act(runtime="solve"); deliberate any returned brain_frame and submit via continue.
+risk: unknown
+source: https://github.com/maxbaluev/accreted-intelligence/tree/main/plugins/claude/skills/solve
 source_repo: maxbaluev/accreted-intelligence
 source_type: community
-date_added: "2026-06-15"
-author: maxbaluev
-tags: [mcp, memory, ai-agents, coding-agents, workflow]
-tools: [claude, codex, cursor, gemini, opencode]
-license: "Apache-2.0"
-license_source: "https://github.com/maxbaluev/accreted-intelligence/blob/main/LICENSE-APACHE-2.0.txt"
+date_added: 2026-07-01
+license: Apache-2.0
+license_source: https://github.com/maxbaluev/accreted-intelligence/blob/main/LICENSE
 ---
 
-# AccInt Solve
+# solve
+## When to Use
 
-## Overview
+Use this skill when you need route a goal through acc's scored-memory loop via acc_act(runtime="solve"); deliberate any returned brain_frame and submit via continue.
 
-AccInt is a local-first MCP memory server for coding agents. It keeps a scored
-record of retrieved experience, open commitments, continuation frames, and
-outcome feedback so the next agent run can build on what actually worked.
 
-Use this skill when AccInt is already configured in the host as an MCP server.
-The skill adapts AccInt's public `solve` Claude skill into a host-agnostic
-workflow for Claude Code, Codex CLI, Cursor, Gemini CLI, OpenCode, and other
-agent runtimes that can call MCP tools.
+Routing sugar over the two MCP verbs — no logic lives here.
 
-## When to Use This Skill
-
-- Use when starting non-trivial coding-agent work where prior decisions,
-  debugging history, repo-specific habits, or maintainer feedback may matter.
-- Use when a task may require multiple attempts and you want an explicit
-  commitment ID that can later receive a real outcome.
-- Use when AccInt returns a continuation frame and the agent must reason locally
-  before submitting a proposal back to the memory loop.
-- Use after verification, merge, deployment, maintainer response, or other
-  reality signal to close the commitment with an honest outcome.
-- Do not use when the host has no AccInt MCP tools configured; first install or
-  configure AccInt, then rerun the workflow.
-
-## How It Works
-
-### Step 1: Confirm the AccInt MCP tools exist
-
-Use the host's available MCP/tool list to confirm an AccInt server exposes the
-two verbs:
-
-```text
-acc_retrieve(query)
-acc_act(runtime, input)
-```
-
-If the host names the tools with a namespace prefix, use the equivalent
-AccInt MCP verbs. If neither verb is available, stop and ask the user to
-configure AccInt rather than inventing memory results.
-
-### Step 2: Retrieve before planning
-
-Before a non-trivial step, retrieve relevant prior work:
-
-```json
-{"query": "the concrete task or subtask you are about to perform"}
-```
-
-Read the returned memories and cite the `[ids]` you actually build on. Treat
-retrieved memories as evidence to consider, not as a substitute for inspecting
-the current repository, running tests, or checking live external state.
-
-### Step 3: Route the goal through `solve`
-
-Open an AccInt commitment for the concrete goal:
-
-```json
-{"runtime": "solve", "input": "the concrete goal to accomplish"}
-```
-
-If the response is final, use the answer, commitment ID, and cited memory IDs.
-If the response is a `brain_frame`, keep the reasoning in the current session:
-inspect the frame, resolve the missing judgment or knowledge from the workspace,
-then submit a concise proposal through `continue`.
-
-### Step 4: Resolve continuation frames
-
-For a returned frame, submit only the frame ID and your proposal text unless the
-host explicitly manages tokens for you:
-
-```json
-{
-  "runtime": "continue",
-  "input": {
-    "frame_id": "bf_...",
-    "proposal_text": "reasoned answer, plan, or decision grounded in the current evidence"
-  }
-}
-```
-
-Do not leave a received frame unresolved. If the frame expires, close or rerun
-the bound commitment rather than pretending the continuation succeeded.
-
-### Step 5: Execute and verify outside AccInt
-
-Do the actual work in the repository, browser, shell, issue tracker, or other
-real environment. Verify with the strongest relevant evidence available: tests,
-builds, linters, link checks, PR state, screenshots, maintainer replies, or
-production telemetry.
-
-AccInt stores the learning loop; it does not replace the work or the evidence.
-
-### Step 6: Close the commitment with an outcome
-
-When reality answers, record the result:
-
-```json
-{
-  "runtime": "outcome",
-  "input": {
-    "ref": "solved:...",
-    "good": true,
-    "note": "brief evidence: tests passed, PR merged, deploy succeeded, reviewer accepted, or exact failure reason"
-  }
-}
-```
-
-Use `good: false` when the approach failed. Do not tag an outcome as external
-or owner-validated unless a real external system or the owner actually supplied
-that verdict.
-
-## Examples
-
-### Example 1: Start a repository fix with memory
-
-```text
-1. acc_retrieve({"query":"fix failing parser tests in this repo"})
-2. Read the returned memories; cite only the relevant [ids].
-3. acc_act(runtime="solve", input="Fix the failing parser tests and verify them")
-4. Inspect the repo, edit files, run the parser tests.
-5. acc_act(runtime="outcome", input={"ref":"solved:...", "good":true, "note":"parser test command passed"})
-```
-
-### Example 2: Handle a continuation frame
-
-```text
-AccInt returns frame bf_123 asking for a judgment about whether to patch the
-schema or the caller.
-
-1. Inspect the schema and caller in the current repo.
-2. Decide from code evidence, not memory alone.
-3. acc_act(runtime="continue", input={"frame_id":"bf_123", "proposal_text":"Patch the caller because..."})
-4. Continue implementation and verification.
-```
-
-## Best Practices
-
-- Cite retrieved `[ids]` whenever they shape your plan or answer.
-- Keep owner-held facts owner-held: ask instead of fabricating preferences,
-  credentials, identity, or history the repository cannot prove.
-- Use small, concrete solve goals; open a new solve for materially different
-  subproblems instead of overloading one commitment.
-- Close commitments promptly when reality answers, including failures.
-- Record evidence in outcome notes, not confidence.
-- Preserve privacy: do not store secrets, raw credentials, or unnecessary
-  sensitive user data in outcome notes.
+1. Call `acc_act(runtime="solve", input="<the goal>")`.
+2. If the result is **final**: surface the answer, the `commitment` id, and the cited `[ids]`.
+3. If the result is a **brain_frame**: it is YOUR deliberation turn — the frame is typed
+   (which hole, what was retrieved, what is predicted). Reason over it, then submit via
+   `acc_act(runtime="continue", input={"frame_id": ..., "submit_token": ..., "proposal_text": ...})`.
+4. End `proposal_text` with `PREDICT: <0.00-1.00> <why>`; acc strips that line before
+   the owner sees it and uses it to calibrate the Work Model against later outcomes.
+5. Never leave a received frame unresolved; never solo-derive outside the loop.
+6. Close the commitment honestly later with `acc_act(runtime="outcome", ...)`.
 
 ## Limitations
 
-- Requires an installed and configured AccInt MCP server exposing
-  `acc_retrieve` and `acc_act`.
-- Does not replace repository inspection, tests, review, or live-state checks.
-- Retrieved memory can be stale or wrong; current evidence wins.
-- Outcome credit is only as strong as the evidence tier. Self-graded outcomes
-  are weaker than runtime, external, or owner-validated outcomes.
-- AccInt is local-first; a different machine or database may not have the same
-  memories unless the user intentionally shares the AccInt database.
-
-## Security & Safety Notes
-
-- This skill does not require shell commands, network fetches, or credentials.
-- AccInt MCP calls can write to the configured local AccInt database by opening
-  commitments, continuations, and outcomes. Treat those writes as project
-  memory, and avoid recording sensitive data that does not need to persist.
-- If a task involves production systems, payments, private accounts, legal or
-  medical facts, or secrets, get the required authorization and verify against
-  the appropriate external source before recording an outcome.
-
-## Common Pitfalls
-
-- **Problem:** Using retrieved memory as if it were guaranteed current.
-  **Solution:** Use it to guide investigation, then verify in the current
-  workspace or live system.
-- **Problem:** Leaving a `brain_frame` open because implementation work started.
-  **Solution:** Submit a `continue` proposal first, or close/rerun the bound
-  commitment if the frame expires.
-- **Problem:** Marking an outcome good before tests, checks, or external state
-  prove it.
-  **Solution:** Wait for real evidence, then record the outcome with the exact
-  command, PR state, deploy state, or reviewer signal.
-
-## Related Skills
-
-- `@agent-memory-mcp` - Use when you need a broader overview of MCP-backed
-  agent memory systems.
-- `@verification-before-completion` - Use before claiming work is complete.
-- `@lint-and-validate` - Use to select and run repository validation commands.
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/add-app-clip/SKILL.md

@@ -0,0 +1,297 @@
+---
+name: add-app-clip
+description: Add an iOS App Clip target to an Expo app. Use when the user mentions App Clip, AASA, apple-app-site-association, appclips, smart app banner, or wants to ship a lightweight iOS Clip invoked from a URL alongside their parent app.
+risk: unknown
+source: https://github.com/expo/skills/tree/main/plugins/expo/skills/add-app-clip
+source_repo: expo/skills
+source_type: official
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/expo/skills/blob/main/LICENSE
+---
+
+# Add an App Clip to an Expo App
+## When to Use
+
+Use this skill when you need add an iOS App Clip target to an Expo app. Use when the user mentions App Clip, AASA, apple-app-site-association, appclips, smart app banner, or wants to ship a lightweight iOS Clip invoked from a URL alongside their parent app.
+
+
+Adds an iOS App Clip target to an Expo project. The Clip lives in `targets/clip/`, ships alongside the parent app, and is invoked from a URL on the app's domain via an Apple App Site Association (AASA) file.
+
+The parent app's bundle ID becomes `com.<username>.<app-name>` and the Clip's is automatically derived as `<parent>.clip` (e.g. `com.bacon.may20.clip`).
+
+## 1. Set `bundleIdentifier` and `appleTeamId`
+
+`bun create target` warns if these are missing. Add to `app.json`:
+
+```json
+{
+  "expo": {
+    "ios": {
+      "bundleIdentifier": "com.<username>.<app-name>",
+      "appleTeamId": "XX57RJ5UTD"
+    }
+  }
+}
+```
+
+## 2. Add the App Clip target
+
+```sh
+bun create target clip
+```
+
+This installs [`@bacons/apple-targets`](https://github.com/EvanBacon/expo-apple-targets), adds it to the `plugins` array in `app.json`, and writes:
+
+- `targets/clip/expo-target.config.js` — the target's config plugin
+- `targets/clip/Info.plist` — Clip Info.plist
+- `targets/clip/AppDelegate.swift`, `Assets.xcassets`, etc.
+
+Pick a good icon or reuse the existing one defined in the app — check it with `bunx expo config` under the `icon` or `ios.icon` key.
+
+## 3. Wire up associated domains
+
+The parent app and the Clip each need the Associated Domains entitlement pointing at the domain that hosts the AASA file.
+
+In `app.json`, add both `applinks:` (parent) and `appclips:` (Clip invocation) entries:
+
+```json
+{
+  "expo": {
+    "ios": {
+      "associatedDomains": [
+        "applinks:may20.expo.app",
+        "appclips:may20.expo.app"
+      ]
+    }
+  }
+}
+```
+
+In `targets/clip/expo-target.config.js`, declare the Clip's entitlement:
+
+```js
+/** @type {import('@bacons/apple-targets/app.plugin').ConfigFunction} */
+module.exports = (config) => ({
+  type: "clip",
+  icon: "https://github.com/expo.png",
+  entitlements: {
+    "com.apple.developer.associated-domains": ["appclips:may20.expo.app"],
+  },
+});
+```
+
+> If you skip this, `expo prebuild` will print: `Apple App Clip may require the associated domains entitlement but none were found`.
+
+## 4. Register bundle IDs and create the App Store entry
+
+```sh
+bunx setup-safari
+```
+
+This logs in to the Apple Developer account, registers `com.bacon.may20`, creates the App Store Connect entry, and prints:
+
+- A starter `apple-app-site-association` JSON
+- A `<meta name="apple-itunes-app">` tag with the iTunes app id
+- Team ID, iTunes ID, and Bundle ID
+
+## 5. Host the AASA file
+
+App Clips are invoked when iOS fetches `https://<your-domain>/.well-known/apple-app-site-association` and finds a matching `appclips` entry.
+
+```sh
+mkdir -p public/.well-known
+touch public/.well-known/apple-app-site-association
+```
+
+Paste the JSON `setup-safari` printed, but **add an `appclips` block** for the Clip's full app ID (`<TeamID>.<ClipBundleID>`). The output of `setup-safari` only covers the parent app:
+
+```json
+{
+  "applinks": {
+    "details": [
+      {
+        "appIDs": ["XX57RJ5UTD.com.bacon.may20"],
+        "components": [{ "/": "*", "comment": "Matches all routes" }]
+      }
+    ]
+  },
+  "appclips": {
+    "apps": ["XX57RJ5UTD.com.bacon.may20.clip"]
+  },
+  "activitycontinuation": {
+    "apps": ["XX57RJ5UTD.com.bacon.may20"]
+  },
+  "webcredentials": {
+    "apps": ["XX57RJ5UTD.com.bacon.may20"]
+  }
+}
+```
+
+Notes:
+
+- The file has **no extension** and **no `Content-Type` requirements** beyond being served as-is. Expo Router static export serves files in `public/` verbatim.
+- The `appclips` block is what lets a URL on the domain launch the Clip.
+- `webcredentials` is used for sharing credentials between the website, parent app, and the App Clip.
+- `activitycontinuation` is optional and used for sharing the link between mobile and desktop. Must be used with `Head` from expo-router — see https://docs.expo.dev/router/advanced/apple-handoff/
+- Notation and route-disabling details: https://sosumi.ai/documentation/xcode/supporting-associated-domains
+
+## 6. Add the Smart App Banner meta tag
+
+Create `src/app/+html.tsx` (Expo Router's HTML shell) and add the tag from `setup-safari`. Create the versioned template if it doesn't exist:
+
+```sh
+bunx expo customize src/app/+html.tsx
+```
+
+Add the meta tag to the `<head>`:
+
+```tsx
+import { ScrollViewStyleReset } from "expo-router/html";
+
+export default function Root({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta httpEquiv="X-UA-Compatible" content="IE=edge" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="apple-itunes-app" content="app-id=6771566491" />
+        <ScrollViewStyleReset />
+      </head>
+      <body>{children}</body>
+    </html>
+  );
+}
+```
+
+To make the website show the App Clip card instead of the install card, use:
+
+```html
+<meta
+  name="apple-itunes-app"
+  content="app-id=6771566491, app-clip-bundle-id=com.bacon.may20.clip, app-clip-display=card"
+/>
+```
+
+## 7. Deploy the website
+
+The AASA file must be live before iOS will trust the association. Use [EAS Hosting](https://docs.expo.dev/eas/hosting/):
+
+```sh
+bunx expo export -p web
+eas deploy --prod
+```
+
+This publishes the site (including `/.well-known/apple-app-site-association`) at `https://<slug>.expo.app`. Verify:
+
+```sh
+curl https://may20.expo.app/.well-known/apple-app-site-association
+```
+
+## 8. Mirror permissions
+
+Inspect the parent app's permissions after prebuild:
+
+```sh
+npx expo config --type introspect
+```
+
+Look at the `infoPlist` object — mirror the permission keys in the App Clip's `Info.plist` so matching APIs can be used from the Clip.
+
+Set `deploymentTarget: "17.6"` in the Clip's target config — App Clips have a higher minimum size limit in iOS 17.6.
+
+If the app uses push notifications or location services, add to the App Clip's `Info.plist` to request the necessary permissions:
+
+```xml
+<key>NSAppClip</key>
+<dict>
+  <key>NSAppClipRequestEphemeralUserNotification</key>
+  <false/>
+  <key>NSAppClipRequestLocationConfirmation</key>
+  <true/>
+</dict>
+```
+
+## 9. Build and submit to TestFlight
+
+```sh
+bunx testflight
+```
+
+This will:
+
+1. Generate an `eas.json` if missing.
+2. Set up credentials for **both** targets (parent + Clip). Each gets its own provisioning profile but can share a single Distribution Certificate.
+3. Sync capabilities — note `Enabled: Associated Domains` for the Clip target.
+4. Build, upload, and schedule a TestFlight submission.
+
+## 10. Configure App Clip metadata
+
+Pull existing App Store metadata to local:
+
+```sh
+eas metadata:pull
+```
+
+Add `apple.appClip` to `store.config.json`. Up to 3 invocation URLs can launch the Clip from a web page:
+
+```json
+{
+  "configVersion": 0,
+  "apple": {
+    "appClip": {
+      "defaultExperience": {
+        "action": "PLAY",
+        "releaseWithAppStoreVersion": true,
+        "reviewDetail": {
+          "invocationUrls": ["https://may20.expo.app/", null, null]
+        },
+        "info": {
+          "en-US": {
+            "subtitle": "Instantly native with Expo",
+            "headerImage": "store/apple/app-clip/en-US/asc-app-clip.png"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+The `headerImage` must be a 1800x1200 PNG with no opacity.
+
+Push back to the store:
+
+```sh
+eas metadata:push
+```
+
+Apple's recommended App Clip metadata guidelines: https://sosumi.ai/documentation/appclip/configuring-the-launch-experience-of-your-app-clip
+
+## What you get
+
+- Parent app target: `com.bacon.may20`
+- App Clip target: `com.bacon.may20.clip`, lives in `targets/clip/`
+- AASA hosted at `https://may20.expo.app/.well-known/apple-app-site-association`
+- Smart App Banner meta tag on every web route
+- Every route linked to its native counterpart
+- TestFlight build of the parent app with the Clip embedded
+
+Once Apple invokes the Clip from a URL on the domain, iOS opens `targets/clip/`'s entry point which loads the React Native app.
+
+## Native detection (optional)
+
+To let JS detect when it's running inside an App Clip and present an install prompt for the full app, create a local Expo module (`bunx create-expo-module --local`) that exposes `navigator.appClip.prompt()`.
+
+See [./references/native-module.md](./references/native-module.md) for the Swift module, TypeScript interface, and usage.
+
+## References
+
+- ./references/native-module.md — Local Expo module to detect App Clip context and present the SKOverlay install prompt
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream product or API scope.
+- Verify commands, API behavior, pricing, quotas, credentials, and deployment effects against current official documentation before making changes.
+- Do not treat generated examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/add-app-clip/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Add App Clip"
+  short_description: "Add an iOS App Clip target to an Expo app with AASA, associated domains, and TestFlight setup"
+  default_prompt: "Use $add-app-clip when adding or reviewing an iOS App Clip target for an Expo app, including bundle IDs, associated domains, AASA files, smart app banners, App Store Connect setup, and TestFlight verification."

package/bundled-skills/add-app-clip/references/native-module.md

@@ -0,0 +1,96 @@
+# Native App Clip detection
+
+Create a local Expo module so JS can detect when the app is running inside an App Clip and present the install prompt for the full app.
+
+```sh
+bunx create-expo-module --local
+```
+
+## Swift module
+
+```swift
+import ExpoModulesCore
+import StoreKit
+
+internal class MissingCurrentWindowSceneException: Exception {
+  override var reason: String {
+    "Cannot determine the current window scene in which to present the modal for requesting a review."
+  }
+}
+
+internal class MissingContainerURLException: Exception {
+  override var reason: String {
+    "Cannot determine the container URL."
+  }
+}
+
+public class AppClipModule: Module {
+  private static let isAppClip: Bool = {
+    if let infoPlist = Bundle.main.infoDictionary, let _ = infoPlist["NSAppClip"] as? [String: Any] {
+      return true
+    }
+    return false
+  }()
+
+  public func definition() -> ModuleDefinition {
+    Name("AppClip")
+
+    Constant("isAppClip") {
+      AppClipModule.isAppClip
+    }
+
+    // Display overlay to advertise full app.
+    // https://developer.apple.com/documentation/app_clips/recommending_your_app_to_app_clip_users
+    AsyncFunction("prompt") {
+      if #available(iOS 16, *) {
+        guard let currentScene = UIApplication.shared.connectedScenes.first as? UIWindowScene else {
+          throw MissingCurrentWindowSceneException()
+        }
+
+        let config = SKOverlay.AppClipConfiguration(position: .bottom)
+        let overlay = SKOverlay(configuration: config)
+        overlay.present(in: currentScene)
+      }
+    }.runOnQueue(DispatchQueue.main)
+  }
+}
+```
+
+## TypeScript interface
+
+```ts
+import { NativeModule, requireOptionalNativeModule } from "expo";
+
+declare class AppClipModule extends NativeModule<{}> {
+  prompt(): void;
+  isAppClip?: boolean;
+}
+
+const AppClipNative = requireOptionalNativeModule<AppClipModule>("AppClip");
+
+if (AppClipNative?.isAppClip) {
+  navigator.appClip = {
+    prompt: AppClipNative.prompt,
+  };
+}
+
+declare global {
+  interface Navigator {
+    /**
+     * Only available in an App Clip context.
+     * @expo
+     */
+    appClip?: {
+      /** Open the SKOverlay */
+      prompt: () => void;
+    };
+  }
+}
+
+export {};
+```
+
+## Usage
+
+- Detect App Clip context: `if (navigator.appClip) { ... }`
+- Prompt to install the full app: `navigator.appClip?.prompt()`