@ccoalm/ccl-skills 0.18.3 → 0.18.4

package/dist/assets/marketplace/plugins/ccl-skills/hooks/host-input.py

@@ -5,6 +5,7 @@ Codex shapes: openai/codex rust-v0.154.0 protocol/models.rs and
 core/src/tools/context.rs. Unsupported evidence remains unverifiable.
 """
 import hashlib
+import importlib.util
 import json
 import os
 from pathlib import Path
@@ -13,6 +14,10 @@ import shlex
 import stat
 import sys
 
+# Hook assets may be installed read-only; importing the optional state helper
+# must not create bytecode beside them.
+sys.dont_write_bytecode = True
+
 
 class TranscriptTruncated(ValueError):
     """The bounded scan could not establish complete transcript evidence."""
@@ -80,8 +85,11 @@ def transcript_lines(path):
     remaining = 16 * 1024 * 1024
     descriptor = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
     with os.fdopen(descriptor, 'rb') as stream:
-        if not stat.S_ISREG(os.fstat(stream.fileno()).st_mode):
+        metadata = os.fstat(stream.fileno())
+        if not stat.S_ISREG(metadata.st_mode):
             raise ValueError('transcript is not a regular file')
+        if metadata.st_size > remaining:
+            raise TranscriptTruncated()
         for _ in range(20000):
             limit = min(remaining, 1024 * 1024)
             if limit <= 0:
@@ -480,6 +488,54 @@ def machine_artifact(text):
     return False
 
 
+def stop_notice(payload, lane, message):
+    """Cap notice attempts only; these markers never establish verification."""
+    try:
+        # Reuse the installed runtime's owned-directory/no-follow/atomic claim
+        # protections. Minimal vendored runtimes may omit this optional helper.
+        source = Path(__file__).resolve().with_name('skill-loading.py')
+        spec = importlib.util.spec_from_file_location('ccl_stop_state', source)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        # Stop checks scan transcript_path even if subagent metadata also
+        # carries a separate agent_transcript_path.
+        notice_actor = dict(payload)
+        notice_actor.pop('agent_transcript_path', None)
+        key, path = module.actor(notice_actor)
+        info = module.regular_info(path)
+        state = module.State(key)
+        try:
+            if not state.claim_attempt('stop-notice-' + lane, [info.st_dev, info.st_ino]):
+                return None
+        finally:
+            state.close()
+    except Exception:
+        # Missing identity, a broken optional helper or unsafe/unavailable state
+        # must not invent success. This boundary only controls advisory output.
+        pass
+    return {'systemMessage': message}
+
+
+def extraction_overflow(payload):
+    path = payload.get('transcript_path')
+    cwd = payload.get('cwd')
+    current = context_transcript(path, cwd if isinstance(cwd, str) else os.getcwd())
+    if any(skill in ('skill-extraction-workflow', 'ccl-skills:skill-extraction-workflow')
+           for skill in current['requested_skills']):
+        # Positive current-context evidence also proves a session invocation.
+        # Missing current evidence cannot prove a missing session invocation.
+        return None
+    return stop_notice(payload, 'extraction-overflow',
+                       'Conversation history is too large for the skill workflow check. '
+                       'The check is incomplete; this does not block your task.')
+
+
+def delivery_eligible(summary):
+    return (any(skill in ('product-rd-workflow', 'ccl-skills:product-rd-workflow')
+                for skill in summary['completed_skills']) or summary['prior_handoff']
+            or summary['continuation_contract_visible'])
+
+
 def proposed_next(payload):
     if (not isinstance(payload, dict) or payload.get('hook_event_name') != 'Stop'
             or payload.get('stop_hook_active') is not False):
@@ -506,11 +562,16 @@ def proposed_next(payload):
     if not isinstance(path, str) or not path:
         return None
     cwd = payload.get('cwd')
-    summary = transcript(path, cwd if isinstance(cwd, str) else os.getcwd())
-    eligible = (any(skill in ('product-rd-workflow', 'ccl-skills:product-rd-workflow')
-                    for skill in summary['completed_skills']) or summary['prior_handoff']
-                or summary['continuation_contract_visible'])
-    if not eligible:
+    cwd = cwd if isinstance(cwd, str) else os.getcwd()
+    try:
+        summary = transcript(path, cwd)
+    except TranscriptTruncated:
+        summary = context_transcript(path, cwd)
+        if not delivery_eligible(summary):
+            # A complete recent context can establish eligibility, but cannot
+            # disprove evidence in the omitted session prefix.
+            raise
+    if not delivery_eligible(summary):
         return None
     return {'decision': 'block', 'reason': (
         'Delivery handoff reminder: repair one proposed-next: line with the next action and scope, '
@@ -538,18 +599,27 @@ def main():
                               'verifiable': False, 'truncated': True, 'prior_handoff': False,
                               'continuation_contract_visible': False}))
             return 1
-    elif sys.argv[1] == 'proposed-next':
+    elif sys.argv[1] in ('proposed-next', 'extraction-overflow'):
+        payload = {}
         try:
             raw = sys.stdin.read(2 * 1024 * 1024 + 1)
             if len(raw) > 2 * 1024 * 1024:
                 raise ValueError('oversized input')
-            result = proposed_next(json.loads(raw))
+            payload = json.loads(raw)
+            result = (extraction_overflow(payload) if sys.argv[1] == 'extraction-overflow'
+                      else proposed_next(payload))
             if result:
                 print(json.dumps(result))
         except TranscriptTruncated:
-            print(json.dumps({'systemMessage': 'Delivery handoff reminder unverified: transcript scan exceeded its bounded limit.'}))
+            result = stop_notice(payload, 'handoff-overflow',
+                                 'Delivery handoff reminder unverified: transcript scan exceeded its bounded limit.')
+            if result:
+                print(json.dumps(result))
         except (OSError, ValueError, TypeError, IndexError, AttributeError):
-            print(json.dumps({'systemMessage': 'Delivery handoff reminder unavailable: input or transcript could not be verified.'}))
+            message = ('Skill workflow check incomplete: input or conversation history could not be verified. '
+                       'This does not block your task.' if sys.argv[1] == 'extraction-overflow' else
+                       'Delivery handoff reminder unavailable: input or transcript could not be verified.')
+            print(json.dumps({'systemMessage': message}))
     return 0
 
 

package/dist/assets/marketplace/plugins/ccl-skills/hooks/proposed-next-stop.sh

@@ -2,7 +2,8 @@
 # Optional Stop handoff/continuation recheck, bounded by host stop_hook_active.
 # It neither establishes product intent nor authorizes a next action. Source
 # review that exposes the full canonical rule can produce one advisory repair.
-# No transcript echo, host configuration reads, or filesystem markers.
+# No transcript echo or host configuration reads. Incomplete-check notices use
+# optional per-actor attempt markers; markers never suppress the actual check.
 set -u
 HELPER="$(cd "$(dirname "$0")" && pwd)/host-input.py"
 if ! command -v python3 >/dev/null 2>&1 || [ ! -r "$HELPER" ]; then

package/dist/assets/marketplace/plugins/ccl-skills/hooks/skill-extraction-gate-stop.sh

@@ -46,7 +46,10 @@ command -v python3 >/dev/null 2>&1 && [ -r "$HELPER" ] || {
 CWD=$(printf '%s' "$IN" | jq -r '.cwd // empty' 2>/dev/null)
 SUMMARY=$(python3 "$HELPER" transcript "$TRANSCRIPT" "${CWD:-$PWD}" 2>/dev/null) || {
   if printf '%s' "$SUMMARY" | jq -e '.truncated == true' >/dev/null 2>&1; then
-    jq -nc '{systemMessage:"Conversation history is too large for the skill workflow check. The check is incomplete; this does not block your task."}'
+    # A complete recent context may prove invocation despite the old prefix.
+    # Otherwise the helper emits this advisory at most once per actor/file.
+    printf '%s' "$IN" | python3 "$HELPER" extraction-overflow 2>/dev/null ||
+      jq -nc '{systemMessage:"Conversation history is too large for the skill workflow check. The check is incomplete; this does not block your task."}'
   else
     jq -nc '{systemMessage:"Skill workflow check incomplete: conversation history could not be read. This does not block your task."}'
   fi

package/dist/assets/marketplace/plugins/ccl-skills/hooks/test_host_input.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """Host boundary regressions; all repositories and transcripts are synthetic."""
 import importlib.util
+from concurrent.futures import ThreadPoolExecutor
 import json
 import os
 from pathlib import Path
@@ -317,8 +318,170 @@ class HostInputTests(unittest.TestCase):
                         self.assertIn('unverified', result.get('systemMessage', '').lower())
                     self.assertNotIn('decision', result)
                     self.assertNotIn('Synthetic private status', json.dumps(result))
+                    repeat = self.run_hook('hooks/' + hook, {
+                        'session_id': 'limit-' + label, 'cwd': str(self.repo),
+                        'transcript_path': path, 'hook_event_name': 'Stop',
+                        'stop_hook_active': False, 'last_assistant_message': 'Synthetic private status.'})
+                    self.assertEqual(repeat, {}, 'unchanged incomplete checks must not repeat notices')
+
+    def test_long_history_recovers_positive_evidence_after_compaction(self):
+        for owner, hook, expected in (
+                ('skill-extraction-workflow', 'skill-extraction-gate-stop.sh', {}),
+                ('product-rd-workflow', 'proposed-next-stop.sh', {'decision': 'block'})):
+            skill = self.repo / 'skills' / owner / 'SKILL.md'
+            skill.parent.mkdir(parents=True, exist_ok=True)
+            skill.write_text(f'---\nname: {owner}\n---\n# Synthetic owner\n')
+            runtime = self.root / owner
+            shutil.copytree(ROOT / 'hooks', runtime / 'hooks')
+            canonical = runtime / 'skills' / owner / 'SKILL.md'
+            canonical.parent.mkdir(parents=True)
+            shutil.copy2(skill, canonical)
+            hosts = ('claude', 'codex')
+            if owner == 'skill-extraction-workflow':
+                hosts += ('claude-pending', 'claude-failed')
+            for host in hosts:
+                with self.subTest(owner=owner, host=host):
+                    boundaries = {'claude': {'type': 'system', 'subtype': 'compact_boundary'},
+                                  'codex': {'type': 'compacted', 'payload': {}}}
+                    loads = {
+                        'claude': [
+                            {'type': 'assistant', 'message': {'content': [{'type': 'tool_use',
+                             'id': 'load', 'name': 'Skill', 'input': {'skill': 'ccl-skills:' + owner}}]}},
+                            {'type': 'user', 'message': {'content': [{'type': 'tool_result',
+                             'tool_use_id': 'load', 'content': 'Loaded'}]}}],
+                        'codex': [self.call('exec_command', {'cmd': f'cat {skill}'}),
+                                  self.output('Process exited with code 0\nOutput:\n' + skill.read_text())]}
+                    family = host.split('-')[0]
+                    invocation = loads[family]
+                    if host == 'claude-pending':
+                        invocation = invocation[:1]
+                    elif host == 'claude-failed':
+                        invocation[1]['message']['content'][0]['is_error'] = True
+                    events = [{'type': 'ignored'}] * 20001 + [boundaries[family]] + invocation
+                    result = self.run_hook(runtime / 'hooks' / hook, {
+                        'session_id': owner + host, 'cwd': str(self.repo),
+                        'transcript_path': self.transcript(events), 'hook_event_name': 'Stop',
+                        'stop_hook_active': False, 'last_assistant_message': 'Checks recorded.'})
+                    self.assertEqual({k: v for k, v in result.items() if k != 'reason'}, expected)
+
+    def test_notice_does_not_suppress_checks_or_other_sessions(self):
+        path = self.transcript([{'type': 'ignored'}] * 20001)
+        agent_path = self.root / 'agent.jsonl'
+        agent_path.write_text('{}\n')
+        payload = {'session_id': 'first', 'cwd': str(self.repo), 'transcript_path': path,
+                   'agent_transcript_path': str(agent_path),
+                   'hook_event_name': 'Stop', 'stop_hook_active': False,
+                   'last_assistant_message': 'Checks recorded.'}
+        for hook in ('skill-extraction-gate-stop.sh', 'proposed-next-stop.sh'):
+            with self.subTest(hook=hook):
+                self.assertIn('systemMessage', self.run_hook('hooks/' + hook, payload))
+                self.assertEqual(self.run_hook('hooks/' + hook, payload), {})
+                self.assertIn('systemMessage', self.run_hook('hooks/' + hook,
+                              dict(payload, session_id='second')))
+                self.assertIn('systemMessage', self.run_hook('hooks/' + hook,
+                              dict(payload, agent_id='sibling')))
+        replacement = self.root / 'replacement.jsonl'
+        replacement.write_bytes(Path(path).read_bytes())
+        replacement.replace(path)
+        self.assertIn('systemMessage', self.run_hook('hooks/proposed-next-stop.sh', payload))
+        self.assertEqual(self.run_hook('hooks/proposed-next-stop.sh', payload), {})
+        with Path(path).open('a') as stream:
+            stream.write(json.dumps({'type': 'system', 'subtype': 'compact_boundary'}) + '\n')
+            stream.write(json.dumps({'type': 'assistant', 'message': {'content': [
+                {'type': 'text', 'text': 'proposed-next: run local checks'}]}}) + '\n')
+        self.assertEqual(self.run_hook('hooks/proposed-next-stop.sh', payload).get('decision'), 'block')
+        self.assertEqual(self.run_hook('hooks/proposed-next-stop.sh',
+                                     dict(payload, stop_hook_active=True)), {})
+
+    def test_concurrent_incomplete_notice_is_claimed_once(self):
+        payload = {'session_id': 'parallel', 'cwd': str(self.repo),
+                   'transcript_path': self.transcript([{'type': 'ignored'}] * 20001),
+                   'hook_event_name': 'Stop', 'stop_hook_active': False,
+                   'last_assistant_message': 'Checks recorded.'}
+        for hook in ('skill-extraction-gate-stop.sh', 'proposed-next-stop.sh'):
+            with self.subTest(hook=hook), ThreadPoolExecutor(max_workers=4) as pool:
+                results = list(pool.map(lambda _: self.run_hook('hooks/' + hook, payload), range(4)))
+                self.assertEqual(sum('systemMessage' in result for result in results), 1)
+                self.assertTrue(all('decision' not in result for result in results))
+
+    def test_unavailable_notice_state_keeps_truthful_output(self):
+        payload = {'session_id': 'unsafe-state', 'cwd': str(self.repo),
+                   'transcript_path': self.transcript([{'type': 'ignored'}] * 20001),
+                   'hook_event_name': 'Stop', 'stop_hook_active': False,
+                   'last_assistant_message': 'Checks recorded.'}
+        victim = self.root / 'untouched'
+        victim.mkdir()
+        (self.root / ('ccl-skill-loading-' + str(os.getuid()))).symlink_to(victim)
+        for hook in ('skill-extraction-gate-stop.sh', 'proposed-next-stop.sh'):
+            for identity in ({}, {'session_id': None}):
+                with self.subTest(hook=hook, identity=identity):
+                    for _ in range(2):
+                        result = self.run_hook('hooks/' + hook, dict(payload, **identity))
+                        self.assertIn('systemMessage', result)
+                        self.assertNotIn('decision', result)
+        self.assertEqual(list(victim.iterdir()), [])
+        runtime = self.root / 'minimal-hooks'
+        runtime.mkdir()
+        for name in ('host-input.py', 'proposed-next-stop.sh', 'skill-extraction-gate-stop.sh'):
+            shutil.copy2(ROOT / 'hooks' / name, runtime / name)
+        for body in (None, 'raise RuntimeError("synthetic-private-detail")\n', 'invalid syntax !\n'):
+            helper = runtime / 'skill-loading.py'
+            if body is not None:
+                helper.write_text(body)
+            for hook, text in (('skill-extraction-gate-stop.sh', 'check is incomplete'),
+                               ('proposed-next-stop.sh', 'unverified: transcript scan')):
+                with self.subTest(optional_helper=body, hook=hook):
+                    for _ in range(2):
+                        result = self.run_hook(runtime / hook, payload)
+                        self.assertIn(text, result.get('systemMessage', ''))
+                        self.assertNotIn('synthetic-private-detail', json.dumps(result))
+                        self.assertNotIn('decision', result)
+
+    def test_long_history_without_positive_current_evidence_stays_unknown(self):
+        marker = {'type': 'system', 'subtype': 'compact_boundary'}
+        request = {'type': 'assistant', 'message': {'content': [{'type': 'tool_use',
+                   'id': 'load', 'name': 'Skill', 'input': {'skill': 'ccl-skills:product-rd-workflow'}}]}}
+        failed = {'type': 'user', 'message': {'content': [{'type': 'tool_result',
+                  'tool_use_id': 'load', 'is_error': True, 'content': 'Failed'}]}}
+        success = {'type': 'user', 'message': {'content': [{'type': 'tool_result',
+                   'tool_use_id': 'load', 'content': 'Loaded'}]}}
+        for label, tail in [('empty-context', [marker]), ('pending-owner', [marker, request]),
+                            ('failed-owner', [marker, request, failed]),
+                            ('no-boundary', [request]),
+                            ('completed-without-boundary', [request, success]),
+                            ('invalid-context', [marker, None])]:
+            for hook in ('skill-extraction-gate-stop.sh', 'proposed-next-stop.sh'):
+                with self.subTest(label=label, hook=hook):
+                    result = self.run_hook('hooks/' + hook, {
+                        'session_id': label, 'cwd': str(self.repo),
+                        'transcript_path': self.transcript([{'type': 'ignored'}] * 20001 + tail),
+                        'hook_event_name': 'Stop', 'stop_hook_active': False,
+                        'last_assistant_message': 'Checks recorded.'})
+                    self.assertIn('systemMessage', result)
+                    self.assertNotIn('decision', result)
+
+    def test_large_session_is_rejected_before_parsing_records(self):
+        path = self.root / 'large.jsonl'
+        with path.open('wb') as stream:
+            stream.write(b'{}\n')
+            stream.truncate(17 * 1024 * 1024)
+        spec = importlib.util.spec_from_file_location('bounded_probe', ROOT / 'hooks/host-input.py')
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        with patch.object(module.json, 'loads', side_effect=AssertionError('record parsed')):
+            with self.assertRaises(module.TranscriptTruncated):
+                module.transcript(str(path), str(self.repo))
 
     def test_extraction_helper_failures_explain_task_impact_without_private_details(self):
+        for invalid in ('null', '{', '[]'):
+            with self.subTest(input=invalid):
+                result = subprocess.run(['python3', str(ROOT / 'hooks/host-input.py'),
+                                         'extraction-overflow'], input=invalid,
+                                        text=True, capture_output=True, env=self.env)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                message = json.loads(result.stdout)['systemMessage']
+                self.assertIn('Skill workflow check incomplete', message)
+                self.assertNotIn('Delivery handoff', message)
         runtime = self.root / 'runtime'
         runtime.mkdir()
         hook = runtime / 'skill-extraction-gate-stop.sh'

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/references/source-register.md

@@ -708,3 +708,4 @@ The pending classification above is superseded by the executed source comparison
 | Extraction cadence requires candidate-derived ownership | `code-review` | result-class: failure; behavioral-evidence: RED-baseline; observed-failure: yes; firing-path: command:skills/code-review/scripts/review_gate.py | updated | Owner key `code-review/SKILL.md`. An ordinary source candidate could select the extraction lane by flag while declaring the owner in its plan. The controller now requires its existing path-derived owner evidence before reviewer selection; it never adds the owner solely because the caller selected the lane. |
 | Ordinary candidates cannot select extraction review or challenge | `skill-extraction-workflow` | result-class: failure; behavioral-evidence: RED-baseline; observed-failure: yes; firing-path: command:skills/skill-extraction-workflow/scripts/test_extraction_review_gate.sh | updated | Owner key `skill-extraction-workflow/SKILL.md`. A real-controller negative fixture fails before the ownership repair and passes afterward for both extraction modes, while ordinary staged review still reaches reviewer selection. The declared extraction owner in the fixture plan cannot substitute for candidate-derived evidence. |
 | Blocker and waiting-status handoffs do not request continuation | `product-rd-workflow` | result-class: failure; behavioral-evidence: RED-baseline; observed-failure: yes; firing-path: file:skills/product-rd-workflow/references/pre-final-continuation-gate.md#Do not request continuation for | updated | Owner key `product-rd-workflow/SKILL.md`. Native-shaped fixtures expose the extra reminder for a concrete blocked handoff or a none marker with a waiting explanation. These statuses now remain non-actionable; a separate action marker and action words that merely start with none still receive the bounded recheck. |
+| Long-history Stop checks suppress repeated incomplete notices and recover positive current-context evidence | `skill-extraction-workflow` / `product-rd-workflow` / `testing-strategy` | result-class: failure; behavioral-evidence: RED-baseline; observed-failure: yes; firing-path: command:hooks/skill-extraction-gate-stop.sh | updated | `specs/146-bounded-hook-history/plan.md` binds repeated overflow, post-compaction recovery and early size-rejection cases. The strict whole-session audit remains unchanged; complete current-context evidence may prove invocation or handoff eligibility, while absence remains unknown. Atomic notice claims are isolated by session, actor and transcript identity and never suppress checks. Existing owner entrypoints remain unchanged; the executable prevention is in the shared hook helper and its subprocess regressions. |

package/dist/assets/release.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "npmPackage": "@ccoalm/ccl-skills",
-  "version": "0.18.3",
-  "sourceCommit": "29c5c6b6d0e35572de2c269ef75b3680d0b9da35",
+  "version": "0.18.4",
+  "sourceCommit": "c2455b6c9bde93b197c80139c6fa478e949a249c",
   "sourceState": "clean",
   "files": [
     {
@@ -82,7 +82,7 @@
     },
     {
       "path": "marketplace/plugins/ccl-skills/hooks/host-input.py",
-      "sha256": "546abe258e25d8103f42259a58b61142418d6c4fd1696f79cfef0fe3876a90c6",
+      "sha256": "a124c55a9ad0f24f46cf3745fed1a0bfb2fdbfb4e0a12b0acbbf8d1dfc413ba5",
       "mode": 420
     },
     {
@@ -102,7 +102,7 @@
     },
     {
       "path": "marketplace/plugins/ccl-skills/hooks/proposed-next-stop.sh",
-      "sha256": "150d6a6a2b87dec330b8affaba5497ecf40483304d52c503d8ebfe6a5e51f2f8",
+      "sha256": "f6a37016a9059d3f7d856d177cb2c02242ff4777fcddea1eadd665a5cf8f6161",
       "mode": 493
     },
     {
@@ -142,7 +142,7 @@
     },
     {
       "path": "marketplace/plugins/ccl-skills/hooks/skill-extraction-gate-stop.sh",
-      "sha256": "b4e5c96cd44d3dd9fdae3d6acd7ac7dc629b1ef52d85c6d42934bc84868fa8bd",
+      "sha256": "082eef024bde4dcd842542e398e16b44e6dc5871d4fef168c49366dae020f4fe",
       "mode": 493
     },
     {
@@ -177,7 +177,7 @@
     },
     {
       "path": "marketplace/plugins/ccl-skills/hooks/test_host_input.py",
-      "sha256": "459cc71337e1d2ddcd125652fe1cb7ed04bda2c65d0d60dcae1d145b1c78dd48",
+      "sha256": "d29cd505d0551828b1c91db8490297a48ce44801e6ec6ba998c34a5b7270fa7b",
       "mode": 420
     },
     {
@@ -2207,7 +2207,7 @@
     },
     {
       "path": "marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/references/source-register.md",
-      "sha256": "a7e0ec62d3670e802ca2ede7d73f796393f657d080a40a34df97c35458490bbc",
+      "sha256": "948afdd0f0a84ce0cdc8a451e6833810a33f970658dda0ce67301c25ba614181",
       "mode": 420
     },
     {
@@ -3518,5 +3518,5 @@
       "mode": 420
     }
   ],
-  "snapshotHash": "1f51372beb4f07851dd24d912a7e64042ccfa3bf9a76624cca9857ddf31dcac0"
+  "snapshotHash": "6fc5965309e0fb84b2392f6c57e9eeafa87d640f213dd32a0383d1af7ccaebe9"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccoalm/ccl-skills",
-	"version": "0.18.3",
+	"version": "0.18.4",
   "description": "Reusable workflows that help coding agents plan, build, test, review, and release software — for Claude Code, Codex, and OpenCode",
 	"keywords": ["skills", "agent-skills", "claude", "claude-code", "codex", "opencode", "agent", "ai", "ai-agents", "cli", "anthropic", "developer-tools"],
   "type": "module",