@prismer/runtime 2.2.55 → 2.2.64

package/built-in-skills/office-artifacts/tests/test_resource_regressions.py

@@ -0,0 +1,272 @@
+"""Offline regression gates for the resource audit (unittest, no account access)."""
+import contextlib
+import importlib.util
+import io
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from docx import Document
+from docx.oxml import OxmlElement
+from openpyxl import Workbook, load_workbook
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.worksheet.table import Table
+from PIL import Image
+from pptx import Presentation
+from pptx.chart.data import CategoryChartData
+from pptx.enum.chart import XL_CHART_TYPE
+from pypdf import PdfReader, PdfWriter
+from reportlab.pdfgen.canvas import Canvas
+
+ROOT = Path(__file__).resolve().parents[1] / 'references'
+
+
+def module(kind, name):
+    path = ROOT / kind / 'scripts' / (name + '.py')
+    sys.path.insert(0, str(path.parent))
+    spec = importlib.util.spec_from_file_location(name, path)
+    result = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(result)
+    return result
+
+
+class ResourceRegression(unittest.TestCase):
+    def test_pdf_rasterizer_runtime_fallback_and_boundaries(self):
+        raster = module('pdf', '_raster')
+        with patch.object(raster, 'available_backends', return_value=['pypdfium2', 'pdftoppm']), patch.object(raster, '_via_pdfium', side_effect=RuntimeError('renderer unavailable')), patch.object(raster, '_via_pdftoppm', return_value='image') as fallback:
+            self.assertEqual(raster.rasterize_page('fake.pdf', 1), 'image')
+            fallback.assert_called_once()
+        with self.assertRaises(ValueError): raster.rasterize_page('fake.pdf', 0)
+        with self.assertRaises(ValueError): raster.rasterize_page('fake.pdf', 1, dpi=100000)
+
+    def test_docx_existing_generic_comment_part_persists_deletion(self):
+        from docx.opc.part import Part
+        from docx.opc.packuri import PackURI
+        from docx.opc.constants import RELATIONSHIP_TYPE as RT
+        comments = module('docx', 'docx_comments')
+        d = Document(); d.add_paragraph('text')
+        blob = f'<w:comments xmlns:w="{comments.W}"><w:comment w:id="0"><w:p><w:r><w:t>old</w:t></w:r></w:p></w:comment></w:comments>'.encode()
+        part = Part(PackURI('/word/comments.xml'), comments.COMMENTS_CT, blob, d.part.package)
+        d.part.relate_to(part, RT.COMMENTS)
+        self.assertTrue(comments.delete_comment(d, '0'))
+        path = self.dir / 'comments.docx'; d.save(path)
+        self.assertEqual(comments.list_comments(Document(path)), [])
+
+    def test_pdf_unicode_requires_explicit_font_and_empty_split_rejected(self):
+        create = module('pdf', 'pdf_create')
+        with contextlib.redirect_stderr(io.StringIO()):
+            self.assertNotEqual(create.build_pdf({'elements': [{'type': 'paragraph', 'text': '\u4e2d\u6587'}]}, str(self.dir / 'bad.pdf')), 0)
+        self.assertFalse((self.dir / 'bad.pdf').exists())
+        split = module('pdf', 'pdf_split')
+        with self.assertRaises(ValueError): split.parse_pages(' , ', 2)
+
+    def test_xlsx_table_partial_column_change_fails_before_output(self):
+        w = Workbook(); s = w.active
+        s.append(['first', 'second']); s.append([1, 2]); s.add_table(Table(displayName='T', ref='A1:B2'))
+        src = self.dir / 'table.xlsx'; dest = self.dir / 'edited.xlsx'; w.save(src)
+        result = self.cli('xlsx', 'xlsx_restructure', src, '--delete-cols', 'A', '--out', dest)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertFalse(dest.exists())
+        self.assertIn('table', result.stderr.lower())
+
+    def test_xlsx_insert_table_column_keeps_schema_and_filter_consistent(self):
+        w = Workbook(); s = w.active
+        s.append(['first', 'second']); s.append([1, 2]); s.add_table(Table(displayName='T', ref='A1:B2'))
+        src = self.dir / 'table.xlsx'; dest = self.dir / 'edited.xlsx'; w.save(src)
+        result = self.cli('xlsx', 'xlsx_restructure', src, '--insert-cols', 'B', '--out', dest)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        s = load_workbook(dest).active; t = s.tables['T']
+        self.assertEqual(t.ref, 'A1:C2'); self.assertEqual(t.autoFilter.ref, t.ref)
+        self.assertEqual([c.name for c in t.tableColumns], [s.cell(1, i).value for i in range(1, 4)])
+        self.assertEqual(len(t.tableColumns), 3)
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.dir = Path(self.tmp.name)
+
+    def cli(self, kind, name, *args):
+        return subprocess.run([sys.executable, '-B', str(ROOT / kind / 'scripts' / (name + '.py')),
+                               *map(str, args)], capture_output=True, text=True, timeout=20)
+
+    def test_docx_replacement_terminates_without_rescanning_new_text(self):
+        code = "from docx import Document; from docx_common import replace_in_paragraph; p=Document().add_paragraph('x x'); assert replace_in_paragraph(p,'x','xx')==2; assert p.text=='xx xx'"
+        try:
+            result = subprocess.run([sys.executable, '-B', '-c', code], timeout=2,
+                                    env={**os.environ, 'PYTHONPATH': str(ROOT / 'docx/scripts')}, capture_output=True)
+        except subprocess.TimeoutExpired:
+            self.fail('replacement rescans generated text and does not terminate')
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    def test_docx_accepted_text_and_namespace_independent_revision_detection(self):
+        d = Document(); p = d.add_paragraph('before ')
+        ins = OxmlElement('w:ins'); r = OxmlElement('w:r'); t = OxmlElement('w:t')
+        t.text = 'inserted'; r.append(t); ins.append(r); p._p.append(ins)
+        reader = module('docx', 'docx_read')
+        self.assertEqual(reader.extract_text(d)['body'], ['before inserted'])
+        p._p.remove(ins); p._p.append(OxmlElement('w:moveFrom'))
+        dest = self.dir / 'move.docx'; d.save(dest)
+        self.assertTrue(reader.detect_revisions(dest)['has_tracked_changes'])
+
+    def test_docx_structural_revision_is_not_silently_resolved(self):
+        d = Document(); p = d.add_paragraph('text')
+        props = p._p.get_or_add_pPr(); props.append(OxmlElement('w:del'))
+        revision = module('docx', 'docx_revisions')
+        self.assertEqual(revision.resolve(d, True), 0)
+        self.assertIsNotNone(props.find(revision.q('del')))
+
+    def test_docx_validator_keeps_relationship_source_parts_separate(self):
+        image = self.dir / 'tiny.png'; Image.new('RGB', (3, 3), 'red').save(image)
+        d = Document(); d.add_picture(str(image)); d.sections[0].header.paragraphs[0].add_run().add_picture(str(image))
+        path = self.dir / 'doc.docx'; d.save(path)
+        for seed in range(5):
+            code = f"from docx_validate import validate; import json; print(json.dumps(validate({str(path)!r})))"
+            p = subprocess.run([sys.executable, '-B', '-c', code], capture_output=True, text=True,
+                               env={**os.environ, 'PYTHONPATH': str(ROOT / 'docx/scripts'), 'PYTHONHASHSEED': str(seed)})
+            self.assertTrue(json.loads(p.stdout)['ok'], p.stdout)
+
+    def test_pdf_flatten_removes_fields_and_widgets_but_retains_value(self):
+        src = self.dir / 'form.pdf'; out = self.dir / 'flat.pdf'; fields = self.dir / 'values.json'
+        c = Canvas(str(src)); c.acroForm.textfield(name='name', x=20, y=700, width=100, height=20); c.showPage(); c.save()
+        fields.write_text('{"name":"Alice"}')
+        p = self.cli('pdf', 'pdf_fill_form', src, '--fields-json', fields, '-o', out, '--flatten')
+        self.assertEqual(p.returncode, 0, p.stderr)
+        doc = PdfReader(out)
+        self.assertFalse(doc.get_fields())
+        self.assertFalse(doc.pages[0].get('/Annots'))
+        self.assertIn('Alice', doc.pages[0].extract_text())
+
+    def test_pdf_attachment_names_cannot_overwrite_existing_or_drop_duplicates(self):
+        src = self.dir / 'attachments.pdf'; dest = self.dir / 'out'; dest.mkdir()
+        (dest / 'same.txt').write_bytes(b'existing')
+        writer = PdfWriter(); writer.add_blank_page(100, 100)
+        writer.add_attachment('same.txt', b'first'); writer.add_attachment('same.txt', b'second'); writer.write(src)
+        result = self.cli('pdf', 'pdf_meta', src, '--extract-attachments', dest)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual((dest / 'same.txt').read_bytes(), b'existing')
+        self.assertEqual({p.read_bytes() for p in dest.iterdir()}, {b'existing', b'first', b'second'})
+
+    def test_csv_literal_mode_does_not_create_formulas(self):
+        source = self.dir / 'in.csv'; out = self.dir / 'out.xlsx'; source.write_text('value\n=1+1\n')
+        self.assertEqual(self.cli('xlsx', 'csv_to_xlsx', source, out, '--no-infer').returncode, 0)
+        self.assertEqual(load_workbook(out).active['A2'].data_type, 's')
+
+    def test_xlsx_formula_token_types_and_whole_column_ranges(self):
+        rw = module('xlsx', 'xlsx_restructure').RefRewriter('Sheet1', 'cols', 1, 1, False)
+        for source, expected in [('=SUM(B:B)', '=SUM(C:C)'), ('=SUM(Table1[A1])', '=SUM(Table1[A1])'),
+                                 ('="A1"&A1', '="A1"&B1'), ('=SUM(1:2)', '=SUM(1:2)'),
+                                 ("='[other.xlsx]Sheet1'!A1", "='[other.xlsx]Sheet1'!A1")]:
+            self.assertEqual(rw.rewrite(source, 'Sheet1'), expected)
+
+    def test_xlsx_column_dimensions_survive_shift(self):
+        src = self.dir / 'in.xlsx'; w = Workbook(); w.active.column_dimensions['B'].width = 24; w.save(src)
+        p = self.cli('xlsx', 'xlsx_restructure', src, '--insert-cols', 'B')
+        self.assertEqual(p.returncode, 0, p.stderr)
+        self.assertEqual(load_workbook(src).active.column_dimensions['C'].width, 24)
+
+    def test_xlsx_full_delete_removes_validation_table_and_dimension(self):
+        src = self.dir / 'in.xlsx'; w = Workbook(); s = w.active
+        s.append(['name']); s.append(['value']); s.add_table(Table(displayName='Items', ref='A1:A2'))
+        dv = DataValidation(type='whole'); dv.add('A1:A2'); s.add_data_validation(dv); s.row_dimensions[1].height = 30; w.save(src)
+        p = self.cli('xlsx', 'xlsx_restructure', src, '--delete-rows', '1:2')
+        self.assertEqual(p.returncode, 0, p.stderr); s = load_workbook(src).active
+        self.assertFalse(s.tables); self.assertFalse(s.data_validations.dataValidation); self.assertNotIn(1, s.row_dimensions)
+
+    def test_pptx_mixed_runs_and_group_text_are_all_replaced(self):
+        prs = Presentation(); s = prs.slides.add_slide(prs.slide_layouts[6])
+        tf = s.shapes.add_group_shape().shapes.add_textbox(0, 0, 1000000, 1000000).text_frame
+        for value in ['foo ', 'f', 'oo']: tf.paragraphs[0].add_run().text = value
+        self.assertEqual(module('powerpoint', 'pptx_edit').replace_text(prs, 'foo', 'bar'), 2)
+        self.assertEqual(tf.text, 'bar bar')
+
+    def test_pptx_copy_preserves_background(self):
+        prs = Presentation(); s = prs.slides.add_slide(prs.slide_layouts[6]); edit = module('powerpoint', 'pptx_edit')
+        edit.set_background(s, 'FF0000'); edit.duplicate_slide(prs, 0)
+        self.assertEqual(prs.slides[1].background.fill.type, s.background.fill.type)
+
+    def test_pptx_grouped_chart_copy_is_refused(self):
+        prs = Presentation(); s = prs.slides.add_slide(prs.slide_layouts[6]); data = CategoryChartData()
+        data.categories = ['A']; data.add_series('S', [1])
+        chart = s.shapes.add_chart(XL_CHART_TYPE.COLUMN_CLUSTERED, 0, 0, 1000000, 1000000, data)
+        s.shapes.add_group_shape([chart])
+        with self.assertRaises(SystemExit): module('powerpoint', 'pptx_edit').duplicate_slide(prs, 0)
+
+    def test_render_returns_only_current_generation(self):
+        out = self.dir / 'render'; out.mkdir(); (out / 'slide-99.png').write_bytes(b'stale')
+        renderer = module('powerpoint', 'pptx_render')
+        def fake_run(cmd, **kwargs):
+            if '--outdir' in cmd: (Path(cmd[cmd.index('--outdir') + 1]) / 'deck.pdf').write_bytes(b'pdf')
+            else: Path(cmd[-1] + '-1.png').write_bytes(b'current')
+            return subprocess.CompletedProcess(cmd, 0, '', '')
+        with patch.object(renderer, 'find_tools', return_value=('soffice', 'pdftoppm', [])), patch.object(renderer.subprocess, 'run', side_effect=fake_run):
+            result = renderer.render('deck.pptx', str(out), 'slide', 100)
+        self.assertEqual(len(result['files']), 1)
+        self.assertEqual(Path(result['files'][0]).read_bytes(), b'current')
+
+    def test_pdf_reverse_and_empty_ranges_are_errors(self):
+        for name in ('pdf_page_image', 'pdf_stamp'):
+            helper = module('pdf', name)
+            for value in ('3-1', '', '0-0'):
+                with self.assertRaises(ValueError): helper.parse_pages(value, 3)
+
+    def test_docx_strict_template_failure_does_not_publish(self):
+        src = self.dir / 'in.docx'; out = self.dir / 'out.docx'; values = self.dir / 'values.json'
+        d = Document(); d.add_paragraph('{{missing}}'); d.save(src); values.write_text('{}')
+        self.assertNotEqual(self.cli('docx', 'docx_template', src, values, out, '--strict').returncode, 0)
+        self.assertFalse(out.exists())
+
+    def test_docx_linked_headers_are_not_modified_twice(self):
+        d = Document(); d.sections[0].header.paragraphs[0].text = 'x'; d.add_section()
+        common = module('docx', 'docx_common')
+        for paragraph in common.iter_all_paragraphs(d): common.replace_in_paragraph(paragraph, 'x', 'xx')
+        self.assertEqual(d.sections[0].header.paragraphs[0].text, 'xx')
+
+    def test_table_append_cannot_overwrite_cells_or_leave_stale_filter(self):
+        w = Workbook(); s = w.active; s.append(['name']); s.append(['first'])
+        table = Table(displayName='Items', ref='A1:A2'); s.add_table(table)
+        src = self.dir / 'table.xlsx'; w.save(src); s = load_workbook(src).active
+        edit = module('xlsx', 'xlsx_edit'); s['A3'] = 'existing'
+        with self.assertRaises(ValueError): edit.table_append(s, 'Items', ['second'])
+        s['A3'] = None; edit.table_append(s, 'Items', ['second'])
+        self.assertEqual(s.tables['Items'].autoFilter.ref, 'A1:A3')
+
+    def test_pymupdf_page_selection_applies_to_tables(self):
+        import types
+        helper = module('pdf', 'extract_pymupdf'); visited = []
+        class Page:
+            def __init__(self, number): self.number = number
+            def find_tables(self): visited.append(self.number); return types.SimpleNamespace(tables=[])
+        with patch.dict(sys.modules, {'pymupdf': types.SimpleNamespace(open=lambda p: [Page(0), Page(1)])}):
+            helper.extract_tables('fake.pdf', pages=[1])
+        self.assertEqual(visited, [1])
+
+    def test_marker_json_renderer_and_pil_image_output(self):
+        import types
+        helper = module('pdf', 'extract_marker'); options = []
+        class Config:
+            def __init__(self, config): options.append(config)
+            def generate_config_dict(self): return options[-1]
+            def get_renderer(self): return 'renderer'
+            def get_processors(self): return []
+            def get_llm_service(self): return None
+        rendered = types.SimpleNamespace(model_dump=lambda: {'children': [{'text': 'hello'}]})
+        def converter(**kwargs):
+            self.assertEqual(kwargs.get('renderer'), 'renderer')
+            return lambda path: rendered
+        modules = {'marker.converters.pdf': types.SimpleNamespace(PdfConverter=converter),
+                   'marker.models': types.SimpleNamespace(create_model_dict=lambda: {}),
+                   'marker.config.parser': types.SimpleNamespace(ConfigParser=Config),
+                   'marker.output': types.SimpleNamespace(text_from_rendered=lambda obj: ('', 'json', {'image.png': Image.new('RGB', (3, 3))}))}
+        output = io.StringIO()
+        with patch.dict(sys.modules, modules), contextlib.redirect_stdout(output): helper.convert('fake.pdf', str(self.dir), 'json')
+        self.assertEqual(json.loads(output.getvalue())['children'][0]['text'], 'hello')
+        self.assertTrue((self.dir / 'image.png').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()

package/built-in-skills/persona-generator/SKILL.md

@@ -38,7 +38,7 @@ metadata:
       - risk-coverage-3plus # cast covers ≥3 risk dimensions (capital/tech/market/org/compliance)
       - grounding-substring # every quote is a substring of a real search snippet (code-checked)
       - brief-boundary # no persona asserts company facts beyond the Brief
-      - honest-degradation # ungroundable → role_label; fabricated quotes are a hard fail
+      - honest-degradation # ungroundable candidates are dropped; never fabricate quotes
 ---
 
 # Persona Generator
@@ -163,7 +163,7 @@ the cloud `/api/im/councils/plan` handler after you hand over the cast.
   allowed only for *structural* checks (two people on one position? invented
   names? missing insider view?), never for factual ones.
 
-### Step 3 — Graceful degradation (three tiers, decided by the CLOUD)
+### Step 3 — Handle grounding failures (current searched-only contract)
 
 > ⚠️ This tiering is applied by the cloud grounding step, not by you — it is
 > shown here so you understand what happens to your candidates. You never set
@@ -176,13 +176,13 @@ The criterion is "**can it be found by search?**" — programmatically checkable
 | Condition | Strategy | `groundingSource` |
 | --- | --- | --- |
 | Name + topic co-occur in one sentence of a snippet | Use its verbatim substring as the quote | `searched` |
-| Not searchable, but the user supplied materials | Ground the quote in the user's materials | `user_materials` |
-| Neither | **Degrade to a role label** ("一位持保守立场的航天投资人"), quote = null | `role_label` |
+| Not searchable, including user-material-only candidates | Returned in `droppedCast[]`; propose a different verifiable candidate or ask for a changed roster | not accepted |
+| No candidate can be verified | Stop the proposal and explain the missing evidence; do not fabricate personas | not accepted |
 
-`role_label` is the most honest tier and the lowest impersonation risk. The
-generator MUST be able to fall to it and MUST NOT fabricate quotes to "stay
-famous". (Legacy tiers `parametric` / `needs_materials` are retired — they
-presumed unverifiable parametric knowledge.)
+`user_materials` and `role_label` are not current accepted fallback tiers.
+Do not set either yourself or claim the cloud accepted them. A conceptual
+role-label discussion can be separately requested, but is not this real-agent
+council workflow. Never fabricate quotes to keep a famous name.
 
 ### Step 4 — Icon acquisition (cloud-executed; you only reference the result)
 
@@ -263,7 +263,7 @@ below are eval judgements (semantic classification):
 | Risk coverage | cast covers ≥3 of: capital / tech / market / org / compliance |
 | Grounding real | every quote is a snippet substring + same-sentence co-occurrence (code check) |
 | Brief boundary | no persona asserts company facts beyond the Brief |
-| Honest degradation | unsearchable → `role_label`, never a fabricated quote |
+| Honest degradation | unsearchable → `droppedCast[]`, substitute or stop; never fabricate a quote |
 
 ## Promote escape hatch
 

package/built-in-skills/pkf-svg/SKILL.md

@@ -3,6 +3,7 @@ name: pkf-svg
 scope: common
 description: 'Design controlled SVG, visual widgets, topology and Visual Core explainers with semantic color, safe geometry, accessibility, and bounded complexity. Use for an explicitly supported SVG/widget surface or to plan PKF visuals. PKF v1.1 has no production inline-SVG authoring surface (diagrams are Mermaid, data charts are d3); v1.2 controlled prismer-svg (pkf209 D19) is activated for PKF source authoring within the frozen validator whitelist.'
 metadata:
+  nativeReplaces: [architecture-diagram]
   aliases:
     - pkf-visual
 ---
@@ -251,3 +252,7 @@ Light mode = 50 fill + 600 stroke + 800 title; dark = 800 fill + 200 stroke
 - Color has semantic meaning plus a text cue; each visual group remains ≤2?
 - One reading direction, boundary anchors, no clipping, stable peer rhythm?
 - Unsafe tags/attributes/external references absent; fallback remains readable?
+
+## Architecture diagram resource pack
+
+Read [the architecture method](references/architecture-diagram/GUIDE.md) and adapt [its standalone HTML template](references/architecture-diagram/templates/template.html) for explicit architecture artifact requests. Preserve semantic boundaries, readable labels and legends outside all system boundaries. This HTML asset is not inline PKF: for PKF, use the native whitelist and geometry above, not HTML/defs/markers. Choose light/dark according to the existing project, use local fonts, and verify every connection and boundary before delivery.

package/built-in-skills/pkf-svg/references/architecture-diagram/GUIDE.md

@@ -0,0 +1,148 @@
+---
+name: architecture-diagram
+description: "Dark-themed SVG architecture/cloud/infra diagrams as HTML."
+version: 1.0.0
+author: Cocoon AI (hello@cocoon-ai.com), ported by Hermes Agent
+license: MIT
+dependencies: []
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [architecture, diagrams, SVG, HTML, visualization, infrastructure, cloud]
+    related_skills: [concept-diagrams, excalidraw]
+---
+
+# Architecture Diagram Skill
+
+Generate professional, dark-themed technical architecture diagrams as standalone HTML files with inline SVG graphics. No external tools, no API keys, no rendering libraries — just write the HTML file and open it in a browser.
+
+## Scope
+
+**Best suited for:**
+- Software system architecture (frontend / backend / database layers)
+- Cloud infrastructure (VPC, regions, subnets, managed services)
+- Microservice / service-mesh topology
+- Database + API map, deployment diagrams
+- Anything with a tech-infra subject that fits a dark, grid-backed aesthetic
+
+**Look elsewhere first for:**
+- Physics, chemistry, math, biology, or other scientific subjects
+- Physical objects (vehicles, hardware, anatomy, cross-sections)
+- Floor plans, narrative journeys, educational / textbook-style visuals
+- Hand-drawn whiteboard sketches (consider `excalidraw`)
+- Animated explainers (consider an animation skill)
+
+If a more specialized skill is available for the subject, prefer that. If none fits, this skill can also serve as a general SVG diagram fallback — the output will just carry the dark tech aesthetic described below.
+
+Based on [Cocoon AI's architecture-diagram-generator](https://github.com/Cocoon-AI/architecture-diagram-generator) (MIT).
+
+## Workflow
+
+1. User describes their system architecture (components, connections, technologies)
+2. Generate the HTML file following the design system below
+3. Save with `write_file` to a `.html` file (e.g. `~/architecture-diagram.html`)
+4. User opens in any browser — works offline, no dependencies
+
+### Output Location
+
+Save diagrams to a user-specified path, or default to the current working directory:
+```
+./[project-name]-architecture.html
+```
+
+### Preview
+
+After saving, suggest the user open it:
+```bash
+# macOS
+open ./my-architecture.html
+# Linux
+xdg-open ./my-architecture.html
+```
+
+## Design System & Visual Language
+
+### Color Palette (Semantic Mapping)
+
+Use specific `rgba` fills and hex strokes to categorize components:
+
+| Component Type | Fill (rgba) | Stroke (Hex) |
+| :--- | :--- | :--- |
+| **Frontend** | `rgba(8, 51, 68, 0.4)` | `#22d3ee` (cyan-400) |
+| **Backend** | `rgba(6, 78, 59, 0.4)` | `#34d399` (emerald-400) |
+| **Database** | `rgba(76, 29, 149, 0.4)` | `#a78bfa` (violet-400) |
+| **AWS/Cloud** | `rgba(120, 53, 15, 0.3)` | `#fbbf24` (amber-400) |
+| **Security** | `rgba(136, 19, 55, 0.4)` | `#fb7185` (rose-400) |
+| **Message Bus** | `rgba(251, 146, 60, 0.3)` | `#fb923c` (orange-400) |
+| **External** | `rgba(30, 41, 59, 0.5)` | `#94a3b8` (slate-400) |
+
+### Typography & Background
+- **Font:** local ui-monospace; use a licensed bundled font if exact typography is required.
+- **Sizes:** minimum 11px in the diagram coordinate system. Keep a scrollable unscaled diagram on narrow screens; verify label width.
+- **Background:** choose the existing product's light or dark theme; the supplied standalone example uses a dark diagram canvas with a system-theme page.
+
+```svg
+<!-- Background Grid Pattern -->
+<pattern id="grid" width="40" height="40" patternUnits="userSpaceOnUse">
+  <path d="M 40 0 L 0 0 0 40" fill="none" stroke="#1e293b" stroke-width="0.5"/>
+</pattern>
+```
+
+## Technical Implementation Details
+
+### Component Rendering
+Components are rounded rectangles (`rx="6"`) with 1.5px strokes. To prevent arrows from showing through semi-transparent fills, use a **double-rect masking technique**:
+1. Draw an opaque background rect (`#0f172a`)
+2. Draw the semi-transparent styled rect on top
+
+### Connection Rules
+- **Z-Order:** Draw arrows *early* in the SVG (after the grid) so they render behind component boxes
+- **Arrowheads:** Defined via SVG markers
+- **Security Flows:** Use dashed lines in rose color (`#fb7185`)
+- **Boundaries:**
+  - *Security Groups:* Dashed (`4,4`), rose color
+  - *Regions:* Large dashed (`8,4`), amber color, `rx="12"`
+
+### Spacing & Layout Logic
+- **Standard Height:** 60px (Services); 80-120px (Large components)
+- **Vertical Gap:** Minimum 40px between components
+- **Message Buses:** Must be placed *in the gap* between services, not overlapping them
+- **Legend Placement:** **CRITICAL.** Must be placed outside all boundary boxes. Calculate the lowest Y-coordinate of all boundaries and place the legend at least 20px below it.
+
+## Document Structure
+
+The generated HTML file follows a four-part layout:
+1. **Header:** Title with an optional static category indicator and subtitle
+2. **Main SVG:** A readable, horizontally scrollable diagram surface
+3. **Summary Cards:** A grid of three cards below the diagram for high-level details
+4. **Footer:** Minimal metadata
+
+### Info Card Pattern
+```html
+<div class="card">
+  <div class="card-header">
+    <div class="card-dot cyan"></div>
+    <h3>Title</h3>
+  </div>
+  <ul>
+    <li>• Item one</li>
+    <li>• Item two</li>
+  </ul>
+</div>
+```
+
+## Output Requirements
+- **Single File:** One self-contained `.html` file
+- **No External Dependencies:** All CSS and SVG must be inline (except Google Fonts)
+- **No JavaScript:** Use pure CSS for any animations (like pulsing dots)
+- **Compatibility:** Must render correctly in any modern web browser
+
+## Template Reference
+
+Load the full HTML template for the exact structure, CSS, and SVG component examples:
+
+```
+skill_view(name="architecture-diagram", file_path="templates/template.html")
+```
+
+The template contains working examples of every component type (frontend, backend, database, cloud, security), arrow styles (standard, dashed, curved), security groups, region boundaries, and the legend — use it as your structural reference when generating diagrams.

package/built-in-skills/pkf-svg/references/architecture-diagram/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nous Research
+
+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/built-in-skills/pkf-svg/references/architecture-diagram/LICENSE.hermes

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nous Research
+
+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/built-in-skills/pkf-svg/references/architecture-diagram/PROVENANCE.md

@@ -0,0 +1,7 @@
+# Resource provenance
+
+Imported from hermes-agent skills/creative/architecture-diagram at 1a1f4a59e252e1dc0137e7b2e7bcc8b0381d19c4.
+
+Prismer receiver: pkf-svg. Native replacement: architecture-diagram; this is not an alias. Preserve all source resources at their relative paths; merge packs live under references/architecture-diagram/. Source file hashes and content review: docs/bugfix223/audit-creative-media-coverage.json. Local corrections and remaining live acceptance: docs/bugfix223/implementation-creative.md.
+
+LICENSE.hermes preserves Nous Research MIT terms. External libraries, fonts, services and media have separate licenses; no third-party binary assets were included.