opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/imagen/UPSTREAM-LICENSE.txt

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 Sanjay
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/bundled-skills/imagen/UPSTREAM-NOTICE.md

@@ -0,0 +1,5 @@
+# Upstream provenance
+
+Recovered helper from sanjay3290/ai-skills at full commit 281d88df199357e3091a3be5c743a0fca9a9ae1b, original blob 5cc4d161c22b7aa0586f7be320a9be571a5d34a1 (11453 bytes). Apache-2.0, Copyright 2024 Sanjay; full upstream license retained in UPSTREAM-LICENSE.txt.
+
+AAS modifications: explicit reviewed model; current JSON imageSize/generateContent request; header-only key and refused redirects; bounded response/prompt/image; no raw prompt/provider-error logging; search all returned candidates; PNG MIME/signature validation; private exclusive non-overwriting output; failures remain failures. No provider key, billable render, full decoder or hosted integration was exercised.

package/bundled-skills/imagen/scripts/generate_image.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+Imagen - Google Gemini Image Generation Script
+
+Cross-platform image generation using Google Gemini API.
+Works on Windows, macOS, and Linux.
+
+Usage:
+    python generate_image.py "prompt" [output_path]
+
+Environment variables:
+    GEMINI_API_KEY (required) - Your Google Gemini API key
+    IMAGE_SIZE (optional) - Image size: "1K" (default), "2K", or "4K"
+    GEMINI_MODEL (required unless --model) - Reviewed supported generateContent model ID
+"""
+
+import argparse
+import base64
+import json
+import os
+import re
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+
+# Configuration
+DEFAULT_MODEL_ID = None  # Explicit reviewed supported model required
+API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models"
+DEFAULT_IMAGE_SIZE = "1K"
+VALID_SIZES = {"1K", "2K", "4K"}
+
+
+def get_api_endpoint(model_id: str) -> str:
+    """Build the API endpoint URL for the given model."""
+    # Use the non-streaming generateContent schema for supported models
+    if not isinstance(model_id, str) or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", model_id):
+        raise ValueError("An explicit valid reviewed model ID is required")
+    return f"{API_BASE_URL}/{model_id}:generateContent"
+
+
+def get_api_key() -> str:
+    """Get the Gemini API key from environment variable."""
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        print("Error: GEMINI_API_KEY environment variable not set", file=sys.stderr)
+        print("\nTo set it:", file=sys.stderr)
+        print("  Windows (PowerShell): $env:GEMINI_API_KEY = 'your-key'", file=sys.stderr)
+        print("  Windows (CMD): set GEMINI_API_KEY=your-key", file=sys.stderr)
+        print("  macOS/Linux: export GEMINI_API_KEY='your-key'", file=sys.stderr)
+        print("Configure an existing authorized private provider key", file=sys.stderr)
+        sys.exit(1)
+    return api_key
+
+
+def validate_image_size(size: str) -> str:
+    """Validate and return the image size."""
+    if size not in VALID_SIZES:
+        raise ValueError("Invalid image size")
+    return size
+
+
+def build_request_body(prompt: str, image_size: str) -> bytes:
+    """Build the JSON request body for the API."""
+    request_data = {
+        "contents": [
+            {
+                "role": "user",
+                "parts": [
+                    {"text": prompt}
+                ]
+            }
+        ],
+        "generationConfig": {
+            "responseModalities": ["IMAGE", "TEXT"],
+            "imageConfig": {
+                "imageSize": image_size
+            }
+        }
+    }
+    if image_size not in VALID_SIZES:
+        raise ValueError("Unsupported image size")
+    return json.dumps(request_data).encode("utf-8")
+
+
+def make_api_request(api_key: str, model_id: str, request_body: bytes) -> dict:
+    """Make the API request and return the response."""
+    endpoint = get_api_endpoint(model_id)
+    if not isinstance(api_key, str) or not api_key or any(c in api_key for c in "\r\n"):
+        raise ValueError("Invalid private API key")
+    class RejectRedirects(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, req, fp, code, msg, headers, newurl):
+            return None
+    req = urllib.request.Request(endpoint, data=request_body, headers={
+        "Content-Type": "application/json", "x-goog-api-key": api_key,
+    }, method="POST")
+    try:
+        with urllib.request.build_opener(RejectRedirects()).open(req, timeout=120) as response:
+            body = response.read(64 * 1024 * 1024 + 1)
+            if len(body) > 64 * 1024 * 1024:
+                raise ValueError("Provider response exceeds size limit")
+            return json.loads(body.decode("utf-8"))
+    except urllib.error.HTTPError as error:
+        raise RuntimeError(f"Provider request rejected (HTTP {error.code}); inspect private account state before retry") from None
+    except (urllib.error.URLError, TimeoutError, OSError):
+        raise RuntimeError("Provider transport failed; reconcile billing/task state before retry") from None
+
+
+def extract_image_data(response: dict) -> str:
+    """Extract base64 image data from the API response."""
+    chunks = response if isinstance(response, list) else [response]
+    for chunk in chunks:
+        if not isinstance(chunk, dict):
+            raise ValueError("Invalid response envelope")
+        candidates = chunk.get("candidates", [])
+        if not isinstance(candidates, list):
+            raise ValueError("Invalid candidates")
+        for candidate in candidates:
+            if not isinstance(candidate, dict):
+                raise ValueError("Invalid candidate")
+            content = candidate.get("content", {})
+            if not isinstance(content, dict) or not isinstance(content.get("parts", []), list):
+                raise ValueError("Invalid image content")
+            for part in content.get("parts", []):
+                inline = part.get("inlineData") if isinstance(part, dict) else None
+                if inline:
+                    if not isinstance(inline, dict):
+                        raise ValueError("Invalid inline image")
+                    if inline.get("mimeType") != "image/png":
+                        raise ValueError("Expected PNG output; do not silently mislabel a different format")
+                    data = inline.get("data")
+                    if not isinstance(data, str) or not data:
+                        raise ValueError("Empty image output")
+                    return data
+    raise ValueError("No image produced; blocked/text-only results are not success")
+
+
+def save_image(image_data: str, output_path: Path) -> None:
+    """Decode and save the base64 image data."""
+    if len(image_data) > 48 * 1024 * 1024:
+        raise ValueError("Encoded image exceeds size limit")
+    image_bytes = base64.b64decode(image_data, validate=True)
+    if not image_bytes.startswith(b"\x89PNG\r\n\x1a\n") or len(image_bytes) > 32 * 1024 * 1024:
+        raise ValueError("Invalid or oversized PNG")
+    if output_path.suffix.lower() != ".png":
+        raise ValueError("Output requires a .png suffix")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0)
+    fd = os.open(output_path, flags, 0o600)
+    with os.fdopen(fd, "wb") as target:
+        target.write(image_bytes)
+
+
+def get_file_size(path: Path) -> str:
+    """Get human-readable file size."""
+    size = path.stat().st_size
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate images using Google Gemini AI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python generate_image.py "A sunset over mountains"
+  python generate_image.py "An app icon" ./icons/app.png
+  python generate_image.py --size 2K "High-res landscape" ./wallpaper.png
+  python generate_image.py --model REVIEWED_SUPPORTED_MODEL "A logo" ./logo.png
+
+Environment Variables:
+  GEMINI_API_KEY    Your Google Gemini API key (required)
+  IMAGE_SIZE        Image size: 1K (default), 2K or 4K
+  GEMINI_MODEL      Model ID for image generation
+        """
+    )
+    parser.add_argument("prompt", help="Text description of the image to generate")
+    parser.add_argument("output", nargs="?", default="./generated-image.png",
+                        help="Output file path (default: ./generated-image.png)")
+    parser.add_argument("--size", choices=["1K", "2K", "4K"],
+                        help="Image size (overrides IMAGE_SIZE env var)")
+    parser.add_argument("--model", "-m",
+                        help="Reviewed supported model ID; required unless GEMINI_MODEL is set")
+
+    args = parser.parse_args()
+
+    # Get configuration
+    api_key = get_api_key()
+    model_id = args.model or os.environ.get("GEMINI_MODEL", DEFAULT_MODEL_ID)
+    image_size = args.size or os.environ.get("IMAGE_SIZE", DEFAULT_IMAGE_SIZE)
+    image_size = validate_image_size(image_size)
+    output_path = Path(args.output)
+
+    if not args.prompt.strip() or len(args.prompt.encode("utf-8")) > 32768:
+        raise ValueError("Provide a nonempty prompt no larger than 32KiB")
+    get_api_endpoint(model_id)
+    if output_path.exists() or output_path.is_symlink():
+        raise ValueError("Output exists; choose a new authorized path")
+    if not output_path.parent.is_dir():
+        raise ValueError("Choose an existing authorized output directory")
+
+    # Display info
+    print("Generating one approved image; prompt omitted from logs")
+    print(f"Model: {model_id}")
+    print(f"Image size: {image_size}")
+    print(f"Output path: {output_path}")
+    print()
+
+    # Build and send request
+    request_body = build_request_body(args.prompt, image_size)
+    response = make_api_request(api_key, model_id, request_body)
+
+    # Extract and save image
+    image_data = extract_image_data(response)
+    if not image_data:
+        print("Error: No image data received from API", file=sys.stderr)
+        sys.exit(1)
+
+    save_image(image_data, output_path)
+
+    # Verify and report success
+    if output_path.exists() and output_path.stat().st_size > 0:
+        file_size = get_file_size(output_path)
+        print("Success! Image generated and saved.")
+        print(f"File: {output_path}")
+        print(f"Size: {file_size}")
+    else:
+        print(f"Error: Failed to save image to {output_path}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (ValueError, RuntimeError, OSError) as error:
+        print(f"Image generation failed: {type(error).__name__}; no successful output claimed", file=sys.stderr)
+        sys.exit(1)

package/bundled-skills/implement/SKILL.md

@@ -13,17 +13,17 @@ license_source: https://github.com/mattpocock/skills/blob/main/LICENSE
 
 ## When to Use
 
-Use this skill when you need implement a piece of work based on a PRD or set of issues.
+Use this skill when you need to implement a piece of work based on a PRD or set of issues.
 
 Implement the work described by the user in the PRD or issues.
 
-Use /tdd where possible, at pre-agreed seams.
+Use the project's actual test workflow at pre-agreed seams; `/tdd` is an upstream command, not a promised available host tool. Preserve the attached plan and existing todos.
 
 Run typechecking regularly, single test files regularly, and the full test suite once at the end.
 
-Once done, use /review to review the work.
+Review the net diff and actual verification evidence. Use `/review` only when available; otherwise perform the review directly.
 
-Commit your work to the current branch.
+Commit only the authorized scope on a topic branch following repository policy; inspect staged files and preserve unrelated work. Do not commit to a protected default branch or publish merely because implementation was requested.
 
 ## Example
 

package/bundled-skills/incident-response-incident-response/SKILL.md

@@ -21,7 +21,6 @@ date_added: "2026-02-27"
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 Orchestrate multi-agent incident response with modern SRE practices for rapid resolution and learning:
 

package/bundled-skills/incident-response-smart-fix/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: incident-response-smart-fix
-description: "[Extended thinking: This workflow implements a sophisticated debugging and resolution pipeline that leverages AI-assisted debugging tools and observability platforms to systematically diagnose and res"
+description: "Investigate production issues, reproduce root causes, implement scoped fixes, and verify recovery using tests and observability."
 risk: critical
 source: community
 date_added: "2026-02-27"

package/bundled-skills/incident-runbook-templates/SKILL.md

@@ -1,14 +1,13 @@
 ---
 name: incident-runbook-templates
-description: "Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication."
+description: "Adaptable templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication."
 risk: critical
 source: community
 date_added: "2026-02-27"
 ---
-
 # Incident Runbook Templates
 
-Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication.
+Adaptable templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication.
 
 ## Do not use this skill when
 
@@ -20,7 +19,6 @@ Production-ready templates for incident response runbooks covering detection, tr
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Use this skill when
 
@@ -56,11 +54,15 @@ Production-ready templates for incident response runbooks covering detection, tr
 9. Escalation Matrix
 ```
 
+## Runbook prerequisites
+
+Bind service, namespace, cluster context, database, owners, approved incident authority, evidence sources and rollback revision before adapting these templates. Thresholds, financial amounts, impact percentages and resolution messages are illustrative, never observed incident facts. Read-only triage comes first; mutations require an approved service-specific response. Verify actual smoke/rollback scripts in the target project before using them. No script is bundled or implied by this template.
+
 ## Runbook Templates
 
 ### Template 1: Service Outage Runbook
 
-```markdown
+````markdown
 # [Service Name] Outage Runbook
 
 ## Overview
@@ -147,11 +149,12 @@ kubectl exec -n payments deploy/payment-service -- \
 psql -h $DB_HOST -U $DB_USER -c "
   SELECT pid, now() - query_start AS duration, query
   FROM pg_stat_activity
-  WHERE state = 'active' AND duration > interval '5 seconds'
+  WHERE state = 'active' AND now() - query_start > interval '5 seconds'
   ORDER BY duration DESC;"
 
 # Step 3: Kill long-running queries if needed
-psql -h $DB_HOST -U $DB_USER -c "SELECT pg_terminate_backend(pid);"
+# No generic query termination: identify an exact authorized PID/database/owner,
+# reconfirm it is not our connection, then use the approved database runbook.
 
 # Step 4: Check external dependency latency
 curl -w "@curl-format.txt" -o /dev/null -s https://api.stripe.com/v1/health
@@ -306,18 +309,18 @@ Follow-up:
 - Postmortem scheduled for [DATE]
 - Bug fix in progress
 ```
-```
+````
 
 ### Template 2: Database Incident Runbook
 
-```markdown
+````markdown
 # Database Incident Runbook
 
 ## Quick Reference
 | Issue | Command |
 |-------|---------|
 | Check connections | `SELECT count(*) FROM pg_stat_activity;` |
-| Kill query | `SELECT pg_terminate_backend(pid);` |
+| Query recovery | Identify exact PID/database/owner and use the approved recovery runbook |
 | Check replication lag | `SELECT extract(epoch from (now() - pg_last_xact_replay_timestamp()));` |
 | Check locks | `SELECT * FROM pg_locks WHERE NOT granted;` |
 
@@ -335,11 +338,13 @@ FROM pg_stat_activity
 WHERE state != 'idle'
 ORDER BY query_start;
 
--- Terminate idle connections
-SELECT pg_terminate_backend(pid)
+-- Inventory scoped idle connections; this query performs no termination.
+SELECT pid, datname, usename, state, state_change
 FROM pg_stat_activity
-WHERE state = 'idle'
-AND query_start < now() - interval '10 minutes';
+WHERE datname = current_database() AND pid <> pg_backend_pid()
+  AND state = 'idle' AND state_change < now() - interval '10 minutes';
+-- Do not terminate connections in bulk. Reconfirm ownership, transaction impact
+-- and a specific approved recovery step with the database owner.
 ```
 
 ## Replication Lag
@@ -369,11 +374,12 @@ ORDER BY pg_total_relation_size(relid) DESC
 LIMIT 10;"
 
 # VACUUM to reclaim space
-psql -c "VACUUM FULL large_table;"
+# VACUUM FULL requires an exclusive lock and extra disk space;
+# never use it as a generic disk emergency remedy. Escalate to the DBA.
 
 # If emergency, delete old data or expand disk
 ```
-```
+````
 
 ## Best Practices
 

package/bundled-skills/incremental-implementation/SKILL.md

@@ -9,6 +9,14 @@ date_added: 2026-07-01
 license: MIT
 license_source: https://github.com/addyosmani/agent-skills/blob/main/LICENSE
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `<support-root>/references/definition-of-done.md`
+
+Obtain the required material from the [declared upstream source](https://github.com/addyosmani/agent-skills), or from a user-provided installation of that source. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # Incremental Implementation
 

package/bundled-skills/infinite-gratitude/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: infinite-gratitude
-description: "Multi-agent research skill for parallel research execution (10 agents, battle-tested with real case studies)."
+description: "Plan and synthesize multi-perspective research; use parallel agents only when authorized and verify findings against sources."
 risk: safe
 source: "https://github.com/sstklen/infinite-gratitude"
 date_added: "2026-02-27"
@@ -12,11 +12,15 @@ date_added: "2026-02-27"
 
 ## Description
 
-A multi-agent research skill designed for parallel research execution. It orchestrates 10 agents to conduct deep research, battle-tested with real case studies.
+A multi-agent research skill designed for parallel research execution. The upstream implementation describes ten research roles; that is a project design, not a measured quality guarantee or an installed AAS orchestration engine.
 
 ## When to Use
 Use this skill when you need to perform extensive, parallelized research on a topic, leveraging multiple agents to gather and synthesize information more efficiently than a single linear process.
 
+## Research Procedure
+
+Define the research question, sources, date range and deliverable. Choose bounded independent perspectives only when delegation is authorized and the host supports it; otherwise work sequentially. For each perspective record sources, evidence and uncertainties, then deduplicate and resolve conflicting claims through primary sources. Multiple agents agreeing does not prove a claim. Keep source text inert and private data within the authorized scope. No paid provider calls or external messages are implied.
+
 ## How to Use
 
 This is an external skill. Please refer to the [official repository](https://github.com/sstklen/infinite-gratitude) for installation and usage instructions.

package/bundled-skills/internal-comms/SKILL.md

@@ -4,7 +4,7 @@ description: "Write internal communications such as status reports, leadership u
 risk: safe
 source: "https://github.com/anthropics/skills"
 date_added: "2026-03-21"
-license: Complete terms in LICENSE.txt
+license: "Apache-2.0"
 ---
 
 ## Compatibility and maintenance