opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/pitch-psychologist/SKILL.md

@@ -1,16 +1,22 @@
 ---
 name: pitch-psychologist
-description: "One sentence - what this skill does and when to invoke it"
+description: "Structure pitches, decks, and talk tracks around audience beliefs, proof, and a clear decision when presentations need stronger progression."
 risk: safe
 source: community
 date_added: "2026-04-04"
 ---
-You are a **Persuasion Scientist and Narrative Psychologist**. Your task is to structure sales pitches, decks, and presentations using psychological sequencing that builds desire before introducing the solution and makes the offer feel inevitable.
+Use a marketing planning and audience-research lens. Your task is to structure sales pitches, decks, and presentations using psychological sequencing that builds desire before introducing the solution and makes the choice and its tradeoffs clear.
 
 ## When to Use
 - Use when a sales, investor, or product pitch needs stronger belief progression and audience alignment.
 - Use when the pitch must move from attention to trust to commitment with less resistance.
 
+## Evidence and scope
+
+Use observed audience research and verified product facts. Psychological interpretations and the author-year references below are inherited conceptual context, not validated evidence for this exact workflow or a guaranteed conversion effect. Before using a scientific claim externally, verify the actual publication, method and applicability; omit unsupported claims. This is marketing planning, not clinical diagnosis. Do not infer sensitive traits or exploit vulnerabilities.
+
+Original contribution: [PR 451](https://github.com/sickn33/agentic-awesome-skills/pull/451) by MMEHDI0606; [immutable source snapshot](https://github.com/MMEHDI0606/antigravity-awesome-skills/blob/9c61357e3e6bb167946036f52ac1e28fc82e04d0/skills/pitch-psychologist/SKILL.md). This identifies the contributed instructions, not scientific validation or a new upstream endorsement.
+
 ## CONTEXT GATHERING
 
 Before building a pitch, establish:
@@ -31,23 +37,23 @@ People are more persuadable when they first feel the problem, the aspiration, an
 
 **Step 1 - Open with the audience's world**
 Start from the customer's current reality and stakes.
-*Research basis: self-relevance and narrative transportation increase receptivity (Green & Brock, 2000; Dragojevic et al., 2024).*
+*Planning hypothesis (verify before presenting as research): self-relevance and narrative transportation increase receptivity (Green & Brock, 2000; Dragojevic et al., 2024).*
 
 **Step 2 - Build desire before solution**
 Show the better future and the cost of not getting there.
-*Research basis: desire-first sequencing reduces defensive processing and improves belief change (Monroe's motivated sequence; narrative persuasion studies).*
+*Planning hypothesis (verify before presenting as research): desire-first sequencing reduces defensive processing and improves belief change (Monroe's motivated sequence; narrative persuasion studies).*
 
 **Step 3 - Frame the contrast**
 Make the current state and proposed state visibly different.
-*Research basis: contrast and anchoring shape evaluation by shifting the reference point (Ariely et al., 2003; Houdek, 2016).*
+*Planning hypothesis (verify before presenting as research): contrast and anchoring shape evaluation by shifting the reference point (Ariely et al., 2003; Houdek, 2016).*
 
 **Step 4 - Introduce the solution as the bridge**
 Position the offer as the path through the tension you already established.
-*Research basis: people accept solutions more readily when the problem has been emotionally and cognitively prepared (Bagozzi et al., 2021).*
+*Planning hypothesis (verify before presenting as research): people accept solutions more readily when the problem has been emotionally and cognitively prepared (Bagozzi et al., 2021).*
 
 **Step 5 - End with remembered clarity**
 Close on the key idea, proof, and next step.
-*Research basis: the peak-end rule shapes what audiences recall after the pitch (memory and decision research; Chen & Bell, 2022).*
+*Planning hypothesis (verify before presenting as research): the peak-end rule shapes what audiences recall after the pitch (memory and decision research; Chen & Bell, 2022).*
 
 ## DECISION MATRIX
 
@@ -96,16 +102,16 @@ The line between persuasion and manipulation is sequencing ideas to help a perso
 
 ## SKILL CHAINING
 
-Before invoking this skill, the agent should have completed:
+Optional context from related skills (equivalent supplied research is sufficient; do not create a prerequisite cycle):
 - [ ] `@customer-psychographic-profiler`
 - [ ] `@jobs-to-be-done-analyst`
 - [ ] `@awareness-stage-mapper`
 - [ ] `@trust-calibrator`
 
 This skill's output feeds into:
-- [ ] `@deck-writing`
-- [ ] `@sales-page`
-- [ ] `@presentation-script`
+- [ ] a deck outline
+- [ ] a sales-page draft
+- [ ] a presentation script
 
 ## OUTPUT QUALITY CHECK
 
@@ -122,6 +128,8 @@ Before finalizing output, the agent asks:
 
 > Rewrite this sales pitch with a clearer belief progression and stronger alignment to the audience.
 
+**Illustrative output:** Build an outline from a supplied problem, verified result and proposed next step; attach the source to each number and include a limitations slide when it changes the decision.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/planning-and-task-breakdown/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.
+
 
 # Planning and Task Breakdown
 

package/bundled-skills/playwright-java/SKILL.md

@@ -9,6 +9,20 @@ author: amalsam18
 tags: [playwright, java, e2e-testing, junit5, page-object-model, allure, selenium-alternative]
 tools: [claude, cursor,antigravity]
 ---
+## 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/config.md`
+- `<support-root>/references/page-objects.md`
+- `<support-root>/references/assertions.md`
+- `<support-root>/references/fixtures.md`
+- `<support-root>/templates/BaseTest.java`
+- `<support-root>/templates/BasePage.java`
+- `src/test/resources/junit-platform.properties`
+
+Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. 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.
+
 
 # Playwright Java – Advanced Test Automation
 

package/bundled-skills/podcast-generation/SKILL.md

@@ -5,6 +5,9 @@ risk: critical
 source: community
 date_added: "2026-02-27"
 ---
+## Bundled upstream support
+
+Supporting files are included at skill-relative paths. See [UPSTREAM-NOTICE.md](UPSTREAM-NOTICE.md) for their pinned sources, licenses, hashes, and import changes.
 
 # Podcast Generation with GPT Realtime Mini
 

package/bundled-skills/podcast-generation/UPSTREAM-LICENSE.txt

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/bundled-skills/podcast-generation/UPSTREAM-NOTICE.md

@@ -0,0 +1,13 @@
+# Upstream helpers for podcast-generation
+
+The files listed below were recovered from [microsoft/skills](https://github.com/microsoft/skills) at commit `fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb`. The repository ID is `1135891523`.
+
+They retain the upstream **MIT** license reproduced in [UPSTREAM-LICENSE.txt](UPSTREAM-LICENSE.txt). This notice applies to the listed support files; it does not replace the license metadata of other catalog files. Preserve the upstream license and this attribution when redistributing them.
+
+License wording is unchanged; text-only trailing whitespace and EOF blank lines are normalized. Original license: https://github.com/microsoft/skills/blob/fc164ba1d7a0c10377dbcc1c9ac07253b9329fdb/LICENSE
+
+| Local file | Original upstream path | Original Git blob SHA | Import changes |
+| --- | --- | --- | --- |
+| `scripts/pcm_to_wav.py` | `.github/skills/podcast-generation/scripts/pcm_to_wav.py` | `6f296aa89974d462d7def65daba5b91915947ec2` | text-only trailing whitespace normalized |
+| `references/architecture.md` | `.github/skills/podcast-generation/references/architecture.md` | `28e572aa1bc1b7189efdfe88fc5c8ee963c09494` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/code-examples.md` | `.github/skills/podcast-generation/references/code-examples.md` | `18bbdc306505cdb9a9afe1deec121d3da8ab45e4` | text-only trailing whitespace and EOF blank lines normalized |

package/bundled-skills/podcast-generation/references/architecture.md

@@ -0,0 +1,87 @@
+# Architecture Reference
+
+## Full-Stack Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       FRONTEND (React)                          │
+│  AudioNarrative.jsx / PodcastOverview.jsx                       │
+│    ↓ POST /api/v1/ai/audio                                     │
+│  api.js → aiAPI.generateAudio(sourceType, sourceId, ...)       │
+└────────────────────────────┬────────────────────────────────────┘
+                             │
+┌────────────────────────────▼────────────────────────────────────┐
+│                       BACKEND (FastAPI)                         │
+│  API: ai.py                                                     │
+│    @router.post("/audio") → AudioNarrativeRequest               │
+│    @router.get("/audio/{id}/stream") → WAV file                │
+│                             │                                   │
+│  Service: ai_service.py                                         │
+│    generate_audio_narrative()                                   │
+│    - Fetch content from DB (tag/bookmark/custom)               │
+│    - Build styled prompt                                        │
+│    - WebSocket connect to Azure Realtime API                   │
+│    - Stream audio chunks + transcript                           │
+│    - PCM → WAV conversion                                       │
+│    - Save to database                                           │
+│                             │                                   │
+│  Model: database.py                                             │
+│    AudioNarrative table                                         │
+└────────────────────────────┬────────────────────────────────────┘
+                             │ wss://
+┌────────────────────────────▼────────────────────────────────────┐
+│              Azure OpenAI Realtime API                          │
+│  Model: gpt-realtime-mini                                       │
+│  Output: PCM audio (24kHz, 16-bit mono) + transcript           │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Database Schema
+
+```python
+class AudioNarrative(Base):
+    __tablename__ = "audio_narratives"
+
+    id: int                          # Primary key
+    source_type: str                 # "tag", "bookmark", "custom"
+    source_id: Optional[int]         # Reference to source
+    source_name: Optional[str]       # Display name
+    title: str                       # Generated title
+    script: str                      # Transcript text
+    audio_url: Optional[str]         # Stream endpoint
+    audio_data: Optional[str]        # Base64 WAV
+    duration_seconds: Optional[int]  # Calculated from PCM length
+    voice_name: str                  # "alloy", "echo", etc.
+    created_at: datetime
+```
+
+## Pydantic Schemas
+
+```python
+class AudioNarrativeRequest(BaseModel):
+    source_type: str          # Required: "tag", "bookmark", "custom"
+    source_id: Optional[Union[int, str]] = None
+    custom_query: Optional[str] = None
+    voice_name: str = "alloy"
+    style: str = "podcast"    # "podcast", "summary", "lecture"
+
+class AudioNarrativeResponse(BaseModel):
+    id: int
+    title: str
+    script: str
+    audio_url: Optional[str]
+    audio_data: Optional[str]  # Base64 WAV
+    duration_seconds: Optional[int]
+    voice_name: str
+    created_at: datetime
+```
+
+## Style Instructions
+
+```python
+STYLE_INSTRUCTIONS = {
+    "podcast": "Speak in a conversational, engaging podcast style with natural transitions. Use phrases like 'Let's dive into...' and 'What's fascinating here is...'",
+    "summary": "Speak clearly and informatively, getting straight to the key points in a news anchor style.",
+    "lecture": "Speak in an educational, thorough style suitable for learning. Explain concepts clearly like a professor."
+}
+```

package/bundled-skills/podcast-generation/references/code-examples.md

@@ -0,0 +1,189 @@
+# Code Examples
+
+## Complete Backend Service Method
+
+```python
+async def generate_audio_narrative(
+    self,
+    source_type: str,
+    source_id: Optional[Union[int, str]] = None,
+    custom_query: Optional[str] = None,
+    voice_name: str = "alloy",
+    style: str = "podcast"
+) -> Dict[str, Any]:
+    """Generate podcast-style audio using gpt-realtime-mini"""
+
+    # 1. Validate configuration
+    if not settings.azure_openai_audio_api_key:
+        raise ValueError("AZURE_OPENAI_AUDIO_API_KEY not configured")
+
+    # 2. Gather content based on source
+    if source_type == "tag":
+        tag = await db.get_tag(source_id)
+        bookmarks = tag.bookmarks
+        title = f"Exploring {tag.name}"
+    elif source_type == "bookmark":
+        bookmark = await db.get_bookmark(source_id)
+        bookmarks = [bookmark]
+        title = f"Deep Dive: {bookmark.title}"
+    else:  # custom
+        bookmarks = await db.get_recent_bookmarks(limit=10)
+        title = f"Research Summary: {custom_query[:50]}"
+
+    # 3. Build prompt with style
+    content = "\n".join([f"**{b.title}**\n{b.summary}" for b in bookmarks[:10]])
+    prompt = f"""Create a {style} narrative from these sources:
+{content}
+
+{STYLE_INSTRUCTIONS[style]}
+Make it 1-2 minutes (150-250 words). Speak naturally."""
+
+    # 4. Connect to Realtime API
+    ws_url = settings.azure_openai_audio_endpoint.replace("https://", "wss://") + "/openai/v1"
+    client = AsyncOpenAI(websocket_base_url=ws_url, api_key=settings.azure_openai_audio_api_key)
+
+    audio_chunks, transcript_parts = [], []
+
+    async with client.realtime.connect(model=settings.azure_openai_audio_deployment) as conn:
+        await conn.session.update(session={
+            "output_modalities": ["audio"],
+            "instructions": f"Narrator creating {style}-style content. Speak naturally, don't ask questions."
+        })
+
+        await conn.conversation.item.create(item={
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": prompt}]
+        })
+
+        await conn.response.create()
+
+        async for event in conn:
+            if event.type == "response.output_audio.delta":
+                audio_chunks.append(base64.b64decode(event.delta))
+            elif event.type == "response.output_audio_transcript.delta":
+                transcript_parts.append(event.delta)
+            elif event.type == "response.done":
+                break
+            elif event.type == "error":
+                raise ValueError(f"Realtime API error: {event.error.message}")
+
+    # 5. Process audio
+    pcm_audio = b''.join(audio_chunks)
+    wav_audio = pcm_to_wav(pcm_audio, sample_rate=24000)
+    audio_base64 = base64.b64encode(wav_audio).decode('utf-8')
+    duration = len(pcm_audio) // (24000 * 2)  # 24kHz, 16-bit
+
+    # 6. Save and return
+    narrative = AudioNarrative(
+        source_type=source_type,
+        title=title,
+        script=''.join(transcript_parts),
+        audio_data=audio_base64,
+        duration_seconds=duration,
+        voice_name=voice_name
+    )
+    db.add(narrative)
+    await db.commit()
+
+    return {
+        "id": narrative.id,
+        "title": title,
+        "script": narrative.script,
+        "audio_data": audio_base64,
+        "audio_url": f"/api/v1/ai/audio/{narrative.id}/stream",
+        "duration_seconds": duration,
+        "voice_name": voice_name
+    }
+```
+
+## FastAPI Endpoints
+
+```python
+@router.post("/audio", response_model=AudioNarrativeResponse)
+async def generate_audio(request: AudioNarrativeRequest, db: AsyncSession = Depends(get_db)):
+    ai_service = AIService(db)
+    result = await ai_service.generate_audio_narrative(
+        source_type=request.source_type,
+        source_id=request.source_id,
+        custom_query=request.custom_query,
+        voice_name=request.voice_name,
+        style=request.style
+    )
+    return AudioNarrativeResponse(**result)
+
+@router.get("/audio/{narrative_id}/stream")
+async def stream_audio(narrative_id: int, db: AsyncSession = Depends(get_db)):
+    ai_service = AIService(db)
+    narrative = await ai_service.get_audio_narrative_by_id(narrative_id)
+    if not narrative:
+        raise HTTPException(404, "Not found")
+
+    audio_bytes = base64.b64decode(narrative["audio_data"])
+    return Response(
+        content=audio_bytes,
+        media_type="audio/wav",
+        headers={"Content-Disposition": f'filename="narrative-{narrative_id}.wav"'}
+    )
+```
+
+## React Component Pattern
+
+```jsx
+function AudioPlayer({ sourceType, sourceId }) {
+  const [narrative, setNarrative] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const audioRef = useRef(null);
+
+  const generate = async () => {
+    setLoading(true);
+    const response = await aiAPI.generateAudio(sourceType, sourceId, null, 'alloy', 'podcast');
+    setNarrative(response.data);
+    setLoading(false);
+  };
+
+  const play = () => {
+    if (!narrative?.audio_data) return;
+
+    const blob = base64ToBlob(narrative.audio_data, 'audio/wav');
+    const url = URL.createObjectURL(blob);
+
+    if (!audioRef.current) audioRef.current = new Audio();
+    audioRef.current.src = url;
+    audioRef.current.onended = () => setIsPlaying(false);
+    audioRef.current.play();
+    setIsPlaying(true);
+  };
+
+  return (
+    <div>
+      {!narrative && <button onClick={generate} disabled={loading}>Generate Podcast</button>}
+      {narrative && (
+        <>
+          <button onClick={play}>{isPlaying ? 'Pause' : 'Play'}</button>
+          <p>{narrative.script}</p>
+        </>
+      )}
+    </div>
+  );
+}
+```
+
+## Frontend API Service
+
+```javascript
+export const aiAPI = {
+  generateAudio: (sourceType, sourceId = null, customQuery = null,
+                  voiceName = 'alloy', style = 'podcast') =>
+    api.post('/ai/audio', {
+      source_type: sourceType,
+      source_id: sourceId,
+      custom_query: customQuery,
+      voice_name: voiceName,
+      style
+    }),
+
+  listAudioNarratives: (limit = 10) => api.get(`/ai/audio?limit=${limit}`),
+};
+```

package/bundled-skills/podcast-generation/scripts/pcm_to_wav.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Convert raw PCM audio data to WAV format.
+
+Azure OpenAI Realtime API outputs PCM audio (24kHz, 16-bit, mono).
+This script converts it to standard WAV format for browser playback.
+
+Usage:
+    from pcm_to_wav import pcm_to_wav
+    wav_bytes = pcm_to_wav(pcm_data, sample_rate=24000)
+"""
+
+import struct
+import io
+
+
+def pcm_to_wav(
+    pcm_data: bytes,
+    sample_rate: int = 24000,
+    channels: int = 1,
+    sample_width: int = 2
+) -> bytes:
+    """Convert raw PCM audio data to WAV format.
+
+    Args:
+        pcm_data: Raw PCM audio bytes
+        sample_rate: Samples per second (default 24000 for gpt-realtime-mini)
+        channels: Number of audio channels (default 1 for mono)
+        sample_width: Bytes per sample (default 2 for 16-bit)
+
+    Returns:
+        WAV-formatted audio bytes
+    """
+    wav_buffer = io.BytesIO()
+
+    # RIFF header
+    wav_buffer.write(b'RIFF')
+    wav_buffer.write(struct.pack('<I', 36 + len(pcm_data)))  # File size - 8
+    wav_buffer.write(b'WAVE')
+
+    # fmt subchunk
+    wav_buffer.write(b'fmt ')
+    wav_buffer.write(struct.pack('<I', 16))                    # Subchunk size
+    wav_buffer.write(struct.pack('<H', 1))                     # Audio format (1 = PCM)
+    wav_buffer.write(struct.pack('<H', channels))              # Number of channels
+    wav_buffer.write(struct.pack('<I', sample_rate))           # Sample rate
+    wav_buffer.write(struct.pack('<I', sample_rate * channels * sample_width))  # Byte rate
+    wav_buffer.write(struct.pack('<H', channels * sample_width))  # Block align
+    wav_buffer.write(struct.pack('<H', sample_width * 8))      # Bits per sample
+
+    # data subchunk
+    wav_buffer.write(b'data')
+    wav_buffer.write(struct.pack('<I', len(pcm_data)))
+    wav_buffer.write(pcm_data)
+
+    return wav_buffer.getvalue()
+
+
+def calculate_duration(pcm_data: bytes, sample_rate: int = 24000, sample_width: int = 2) -> int:
+    """Calculate audio duration in seconds from PCM data length."""
+    return len(pcm_data) // (sample_rate * sample_width)
+
+
+if __name__ == "__main__":
+    # Example usage
+    import sys
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'rb') as f:
+            pcm_data = f.read()
+        wav_data = pcm_to_wav(pcm_data)
+        output_path = sys.argv[1].replace('.pcm', '.wav')
+        with open(output_path, 'wb') as f:
+            f.write(wav_data)
+        print(f"Converted to {output_path} ({calculate_duration(pcm_data)}s)")

package/bundled-skills/polars/SKILL.md

@@ -8,6 +8,9 @@ risk: critical
 source: community
 date_added: "2026-09-04"
 ---
+## Bundled upstream support
+
+Supporting files are included at skill-relative paths. See [UPSTREAM-NOTICE.md](UPSTREAM-NOTICE.md) for their pinned sources, licenses, hashes, and import changes.
 
 # Polars
 

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 K-Dense Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,16 @@
+# Upstream helpers for polars
+
+The files listed below were recovered from [K-Dense-AI/scientific-agent-skills](https://github.com/K-Dense-AI/scientific-agent-skills) at commit `0936740e52033a6256085be5fc81e5e56d606110`. The repository ID is `1079456184`.
+
+They retain the upstream **MIT** license reproduced in [UPSTREAM-LICENSE.txt](UPSTREAM-LICENSE.txt). This notice applies to the listed support files; it does not replace the license metadata of other catalog files. Preserve the upstream license and this attribution when redistributing them.
+
+License wording is unchanged; text-only trailing whitespace and EOF blank lines are normalized. Original license: https://github.com/K-Dense-AI/scientific-agent-skills/blob/0936740e52033a6256085be5fc81e5e56d606110/LICENSE.md
+
+| Local file | Original upstream path | Original Git blob SHA | Import changes |
+| --- | --- | --- | --- |
+| `references/core_concepts.md` | `skills/polars/references/core_concepts.md` | `e3a0e56f5e6c09af156a73049fcf87f7d614b387` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/operations.md` | `skills/polars/references/operations.md` | `40441f58c45663be0a3da0f5561728831ff38ca7` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/io_guide.md` | `skills/polars/references/io_guide.md` | `bbb9dc92d6e0b17020d7e8ff20b7599047bc6a17` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/transformations.md` | `skills/polars/references/transformations.md` | `af57f1ce33d2ebbebe259bae844ac3772944510d` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/pandas_migration.md` | `skills/polars/references/pandas_migration.md` | `aa5fd240c779c54e62fc96891d377bf2924188a7` | text-only trailing whitespace and EOF blank lines normalized |
+| `references/best_practices.md` | `skills/polars/references/best_practices.md` | `0585ed6d9a064133e075f9bd966f5bae97e822b3` | text-only trailing whitespace and EOF blank lines normalized |