@tasksai/install 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tasksai/install",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Shared TasksAI MCP installer CLI",
   "type": "module",
   "bin": {

package/runtime/server.py

@@ -28,6 +28,7 @@ import httpx
 import uuid
 from datetime import datetime
 from pathlib import Path
+from urllib.parse import urlencode
 
 # The runtime is installed as a pair of adjacent Python files and is also
 # loaded directly by path in focused tests, so make the sibling matcher
@@ -124,7 +125,7 @@ if not LICENSE_KEY:
     print("Find your key in your purchase confirmation email.", file=sys.stderr, flush=True)
     sys.exit(1)
 
-SERVER_VERSION = "2.3.0"
+SERVER_VERSION = "2.4.1"
 
 AUTH_HEADERS = {
     "Authorization":    f"Bearer {LICENSE_KEY}",
@@ -519,6 +520,79 @@ async def api_post(path, payload):
         return resp.json()
 
 
+def jurisdiction_sources_path(arguments):
+    """Build a metadata-only source lookup path without customer or property data."""
+    skill_id = (arguments.get("skill_id") or "").strip()
+    state = (arguments.get("state") or "").strip()
+    if not skill_id:
+        raise ValueError("skill_id is required.")
+
+    params = {"skill_id": skill_id}
+    if state:
+        params["state"] = state
+    for field in ("county", "locality", "district"):
+        value = (arguments.get(field) or "").strip()
+        if value:
+            params[field] = value
+    return f"/v1/skills/jurisdiction-sources?{urlencode(params)}"
+
+
+def format_jurisdiction_source_pack(pack):
+    """Render the public source pack as compact instructions for the local AI."""
+    status = pack.get("status", "unsupported")
+    lines = [
+        "# Official Jurisdiction and Authority Source Pack",
+        "",
+        f"- Status: **{status}**",
+        f"- Coverage: **{pack.get('coverage_level', 'intake_only')}**",
+        f"- Skill: `{pack.get('skill_id', '')}`",
+        f"- Registry reviewed: {pack.get('registry_reviewed_on', 'not supplied')}",
+        f"- Registry refresh due: {pack.get('registry_refresh_due_on', 'not supplied')}",
+    ]
+    if pack.get("state_name"):
+        lines.append(f"- State: {pack['state_name']} ({pack.get('state_code', '')})")
+    if pack.get("county"):
+        lines.append(f"- County: {pack['county']}")
+    if pack.get("locality"):
+        lines.append(f"- Locality: {pack['locality']}")
+    if pack.get("district"):
+        lines.append(f"- District: {pack['district']}")
+    authority_layers = pack.get("authority_layers") or []
+    if authority_layers:
+        lines.append(f"- Authority layers: {', '.join(authority_layers)}")
+
+    sources = pack.get("sources") or []
+    if sources:
+        lines.extend(["", "## Sources"])
+        for source in sources:
+            effective = source.get("effective_date") or "not specified"
+            lines.extend(
+                [
+                    "",
+                    f"### {source.get('title', 'Official source')}",
+                    f"- Authority: {source.get('authority', '')}",
+                    f"- Jurisdiction: {source.get('jurisdiction', '')} ({source.get('scope_type', 'scope not supplied')})",
+                    f"- Effective date: {effective}",
+                    f"- Reviewed: {source.get('reviewed_on', '')}",
+                    f"- Refresh due: {source.get('refresh_due_on', '')}",
+                    f"- URL: {source.get('url', '')}",
+                    f"- Use: {source.get('purpose', '')}",
+                    f"- Limit: {source.get('limits', '')}",
+                ]
+            )
+
+    required_authorities = pack.get("required_user_authorities") or []
+    if required_authorities:
+        lines.extend(["", "## Professional-Supplied Authority Still Needed"])
+        lines.extend(f"- {item}" for item in required_authorities)
+
+    instructions = pack.get("instructions") or []
+    if instructions:
+        lines.extend(["", "## Required handling"])
+        lines.extend(f"- {instruction}" for instruction in instructions)
+    return "\n".join(lines)
+
+
 def get_install_id() -> str:
     """Stable anonymous install id for attribution; stored locally only."""
     global INSTALL_ID
@@ -828,10 +902,57 @@ def is_markdown_table_start(lines, index):
     return bool(header and markdown_table_alignments(separator))
 
 
+def inferred_plain_heading_level(lines, index):
+    """Infer conservative headings when an AI omits Markdown # markers."""
+    text = lines[index].strip()
+    if not text or len(text) > 90 or "|" in text or ":" in text:
+        return None
+    if text.endswith((".", "?", "!", ";")):
+        return None
+
+    letters = [char for char in text if char.isalpha()]
+    if len(letters) >= 4 and all(char.isupper() for char in letters):
+        return 2
+
+    next_index = index + 1
+    while next_index < len(lines) and not lines[next_index].strip():
+        next_index += 1
+    next_line = lines[next_index] if next_index < len(lines) else ""
+    introduces_list = bool(
+        re.match(r"^\s*[-*+]\s+\S", next_line)
+        or re.match(r"^\s*\d+\.\s+\S", next_line)
+    )
+    introduces_facts = bool(re.match(r"^\s*[^:\n]{1,55}:\s+\S", next_line))
+    if introduces_list or introduces_facts or text.istitle():
+        return 3
+    return None
+
+
+def labeled_fact(line):
+    """Return a label/value pair for a short professional fact line."""
+    match = re.match(r"^([^:\n]{1,55}):\s+(.+)$", line.strip())
+    if not match:
+        return None
+    return match.group(1).strip(), match.group(2).strip()
+
+
+def add_labeled_text(paragraph, label, value):
+    """Render a label/value pair in an existing Word paragraph."""
+    label_run = paragraph.add_run(f"{label}: ")
+    label_run.bold = True
+    add_markdown_text(paragraph, value)
+
+
+def add_labeled_fact(doc, label, value):
+    """Render a fact line with a bold label and distinct Word paragraph."""
+    paragraph = doc.add_paragraph()
+    add_labeled_text(paragraph, label, value)
+
+
 def iter_inline_markdown(text):
     """Yield (text, marks) spans for common inline Markdown."""
     token_re = re.compile(
-        r"(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|\*[^*\s][^*]*\*|_[^_\s][^_]*_|\[[^\]]+\]\([^)]+\))"
+        r"(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|\*[^*\s][^*]*\*|(?<!\w)_[^_\s][^_]*_(?!\w)|\[[^\]]+\]\([^)]+\))"
     )
     pos = 0
     for match in token_re.finditer(text):
@@ -934,10 +1055,81 @@ def add_horizontal_rule(paragraph):
     borders.append(bottom)
 
 
+def set_cell_shading(cell, fill):
+    """Apply a solid background color to a Word table cell."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    cell_properties = cell._tc.get_or_add_tcPr()
+    shading = cell_properties.find(qn("w:shd"))
+    if shading is None:
+        shading = OxmlElement("w:shd")
+        cell_properties.append(shading)
+    shading.set(qn("w:fill"), fill)
+
+
+def set_cell_margins(cell, top=70, start=90, bottom=70, end=90):
+    """Set compact, readable table cell margins in twentieths of a point."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    cell_properties = cell._tc.get_or_add_tcPr()
+    margins = cell_properties.first_child_found_in("w:tcMar")
+    if margins is None:
+        margins = OxmlElement("w:tcMar")
+        cell_properties.append(margins)
+    for name, value in (("top", top), ("start", start), ("bottom", bottom), ("end", end)):
+        node = margins.find(qn(f"w:{name}"))
+        if node is None:
+            node = OxmlElement(f"w:{name}")
+            margins.append(node)
+        node.set(qn("w:w"), str(value))
+        node.set(qn("w:type"), "dxa")
+
+
+def repeat_table_header(row):
+    """Repeat the first row of a long table on subsequent pages."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    row_properties = row._tr.get_or_add_trPr()
+    repeat = row_properties.find(qn("w:tblHeader"))
+    if repeat is None:
+        repeat = OxmlElement("w:tblHeader")
+        row_properties.append(repeat)
+    repeat.set(qn("w:val"), "true")
+
+
+def prevent_table_row_split(row):
+    """Keep a table row together when Word paginates the document."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    row_properties = row._tr.get_or_add_trPr()
+    if row_properties.find(qn("w:cantSplit")) is None:
+        row_properties.append(OxmlElement("w:cantSplit"))
+
+
+def add_page_number(paragraph):
+    """Add a dynamic PAGE field to a footer paragraph."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    run = paragraph.add_run()
+    begin = OxmlElement("w:fldChar")
+    begin.set(qn("w:fldCharType"), "begin")
+    instruction = OxmlElement("w:instrText")
+    instruction.set(qn("xml:space"), "preserve")
+    instruction.text = " PAGE "
+    end = OxmlElement("w:fldChar")
+    end.set(qn("w:fldCharType"), "end")
+    run._r.extend((begin, instruction, end))
+
+
 def add_markdown_table(doc, rows, alignments):
     """Render a Markdown pipe table as a native Word table."""
     from docx.enum.text import WD_ALIGN_PARAGRAPH
-    from docx.shared import Pt
+    from docx.shared import Pt, RGBColor
 
     if not rows:
         return
@@ -947,15 +1139,22 @@ def add_markdown_table(doc, rows, alignments):
     table = doc.add_table(rows=len(normalized), cols=width)
     table.style = "Table Grid"
     table.autofit = True
-
+    repeat_table_header(table.rows[0])
     for row_index, row in enumerate(normalized):
         for column_index, value in enumerate(row):
             cell = table.cell(row_index, column_index)
+            set_cell_margins(cell)
+            if row_index == 0:
+                set_cell_shading(cell, "17365D")
+            elif row_index % 2 == 0:
+                set_cell_shading(cell, "EEF3F8")
             paragraph = cell.paragraphs[0]
+            paragraph.paragraph_format.space_after = Pt(0)
             add_markdown_text(paragraph, value)
             if row_index == 0:
                 for run in paragraph.runs:
                     run.bold = True
+                    run.font.color.rgb = RGBColor(255, 255, 255)
             alignment = alignments[column_index] if column_index < len(alignments) else "left"
             if alignment == "right":
                 paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
@@ -968,16 +1167,70 @@ def add_markdown_table(doc, rows, alignments):
 
 
 def write_docx(path, title, content_markdown, product_name):
-    """Write a simple, polished DOCX file locally."""
+    """Write a professionally styled DOCX file locally."""
     try:
         from docx import Document
-        from docx.shared import Inches, Pt
+        from docx.enum.text import WD_ALIGN_PARAGRAPH
+        from docx.shared import Inches, Pt, RGBColor
     except Exception as exc:
         raise RuntimeError(
             "python-docx is not installed. Re-run the official installer or install python-docx in the MCP runtime environment."
         ) from exc
 
     doc = Document()
+    doc.core_properties.title = title or f"{product_name} Work Product"
+    doc.core_properties.author = product_name
+
+    section = doc.sections[0]
+    section.top_margin = Inches(0.55)
+    section.bottom_margin = Inches(0.55)
+    section.left_margin = Inches(0.7)
+    section.right_margin = Inches(0.7)
+    section.header_distance = Inches(0.3)
+    section.footer_distance = Inches(0.3)
+
+    styles = doc.styles
+    normal = styles["Normal"]
+    normal.font.name = "Aptos"
+    normal.font.size = Pt(9.3)
+    normal.font.color.rgb = RGBColor(31, 41, 55)
+    normal.paragraph_format.space_after = Pt(4)
+    normal.paragraph_format.line_spacing = 1.05
+
+    title_style = styles["Title"]
+    title_style.font.name = "Aptos Display"
+    title_style.font.size = Pt(19)
+    title_style.font.bold = True
+    title_style.font.color.rgb = RGBColor(23, 54, 93)
+    title_style.paragraph_format.space_after = Pt(5)
+
+    heading_sizes = {1: 14, 2: 11.5, 3: 10.5, 4: 9.5}
+    for level, size in heading_sizes.items():
+        style = styles[f"Heading {level}"]
+        style.font.name = "Aptos Display"
+        style.font.size = Pt(size)
+        style.font.bold = True
+        style.font.color.rgb = RGBColor(23, 54, 93)
+        style.paragraph_format.space_before = Pt(8 if level <= 2 else 5)
+        style.paragraph_format.space_after = Pt(3)
+        style.paragraph_format.keep_with_next = True
+
+    header = section.header.paragraphs[0]
+    header.text = f"{product_name}  |  Professional Work Product"
+    header.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    for run in header.runs:
+        run.font.name = "Aptos"
+        run.font.size = Pt(7.5)
+        run.font.color.rgb = RGBColor(100, 116, 139)
+
+    footer = section.footer.paragraphs[0]
+    footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    footer_run = footer.add_run(f"Generated locally by {product_name}  |  Private local output  |  Page ")
+    footer_run.font.name = "Aptos"
+    footer_run.font.size = Pt(7.5)
+    footer_run.font.color.rgb = RGBColor(100, 116, 139)
+    add_page_number(footer)
+
     if title:
         doc.add_heading(title, level=0)
 
@@ -987,16 +1240,24 @@ def write_docx(path, title, content_markdown, product_name):
     def flush_paragraph():
         if not paragraph_buffer:
             return
-        text = " ".join(part.strip() for part in paragraph_buffer if part.strip())
+        text_parts = []
+        for part in paragraph_buffer:
+            clean = part.strip()
+            if not clean:
+                continue
+            text_parts.append(clean)
+            text_parts.append("\n" if part.endswith("  ") else " ")
+        text = "".join(text_parts).rstrip()
         paragraph_buffer.clear()
         if text:
             add_markdown_text(doc.add_paragraph(), text)
 
     in_code_block = False
+    keep_checklist_together = False
     index = 0
     while index < len(lines):
         raw_line = lines[index]
-        line = raw_line.rstrip()
+        line = raw_line.rstrip("\r\n")
         stripped = line.strip()
         if stripped.startswith("```"):
             flush_paragraph()
@@ -1016,10 +1277,34 @@ def write_docx(path, title, content_markdown, product_name):
             continue
 
         heading = re.match(r"^(#{1,4})\s+(.+)$", stripped)
+        standalone_bold_heading = re.fullmatch(r"\*\*([^*\n]{1,120})\*\*", stripped)
+        inferred_heading = inferred_plain_heading_level(lines, index)
         bullet = re.match(r"^(\s*)[-*+]\s+(.+)$", line)
         numbered = re.match(r"^(\s*)\d+\.\s+(.+)$", line)
         quote = re.match(r"^>\s?(.+)$", stripped)
+        fact = (
+            labeled_fact(stripped)
+            if not paragraph_buffer
+            and not line.endswith("  ")
+            and not bullet
+            and not numbered
+            and not quote
+            else None
+        )
 
+        if re.fullmatch(r"<!--\s*[^\n]*?\s*-->", stripped):
+            # Public-copy delimiters and other machine-readable Markdown
+            # comments are useful in the source but must not appear in the
+            # downloadable customer document.
+            flush_paragraph()
+            index += 1
+            continue
+        if stripped == ">":
+            # A blank line inside a Markdown blockquote is structural spacing,
+            # not a literal greater-than character in the Word document.
+            flush_paragraph()
+            index += 1
+            continue
         if is_markdown_table_start(lines, index):
             flush_paragraph()
             header = markdown_table_row(lines[index])
@@ -1036,7 +1321,28 @@ def write_docx(path, title, content_markdown, product_name):
             continue
         elif heading:
             flush_paragraph()
-            doc.add_heading(heading.group(2).strip(), level=min(len(heading.group(1)), 4))
+            heading_text = heading.group(2).strip()
+            if not (
+                title
+                and index == 0
+                and re.sub(r"\W+", "", heading_text).casefold()
+                == re.sub(r"\W+", "", title).casefold()
+            ):
+                doc.add_heading(heading_text, level=min(len(heading.group(1)), 4))
+                keep_checklist_together = "checklist" in heading_text.casefold()
+            index += 1
+        elif standalone_bold_heading:
+            flush_paragraph()
+            doc.add_heading(standalone_bold_heading.group(1).strip(), level=3)
+            index += 1
+        elif inferred_heading:
+            flush_paragraph()
+            doc.add_heading(stripped, level=inferred_heading)
+            keep_checklist_together = "checklist" in stripped.casefold()
+            index += 1
+        elif fact:
+            flush_paragraph()
+            add_labeled_fact(doc, fact[0], fact[1])
             index += 1
         elif bullet:
             flush_paragraph()
@@ -1047,7 +1353,19 @@ def write_docx(path, title, content_markdown, product_name):
             checkbox = re.match(r"^\[([ xX])\]\s+(.+)$", text)
             if checkbox:
                 text = f"[{checkbox.group(1).lower()}] {checkbox.group(2).strip()}"
-            add_markdown_text(para, text)
+            bullet_fact = labeled_fact(text)
+            if bullet_fact:
+                add_labeled_text(para, bullet_fact[0], bullet_fact[1])
+            else:
+                add_markdown_text(para, text)
+            next_is_bullet = bool(
+                index + 1 < len(lines)
+                and re.match(r"^\s*[-*+]\s+\S", lines[index + 1])
+            )
+            if keep_checklist_together and next_is_bullet:
+                para.paragraph_format.keep_with_next = True
+            elif keep_checklist_together:
+                keep_checklist_together = False
             index += 1
         elif numbered:
             flush_paragraph()
@@ -1070,17 +1388,11 @@ def write_docx(path, title, content_markdown, product_name):
             add_horizontal_rule(doc.add_paragraph())
             index += 1
         else:
-            paragraph_buffer.append(stripped)
+            paragraph_buffer.append(line)
             index += 1
 
     flush_paragraph()
 
-    doc.add_paragraph()
-    footer = doc.add_paragraph()
-    run = footer.add_run(f"Generated locally by {product_name}. Content was not sent to TasksAI servers.")
-    run.italic = True
-    run.font.size = Pt(8)
-
     doc.save(path)
 
 
@@ -1145,7 +1457,7 @@ def build_tools(prefix, product_name, occupation):
     domain_adjective = normalize_domain_adjective(occ_key)
     examples = _examples.get(domain_adjective, _examples.get(product_name.replace('TasksAI','').lower().strip(), f"e.g. a {domain_adjective} task"))
 
-    return [
+    tools = [
         Tool(
             name=f"{prefix}_search",
             description=(
@@ -1250,6 +1562,46 @@ def build_tools(prefix, product_name, occupation):
         ),
     ]
 
+    if prefix in {"realtortasksai", "farmertasksai", "teachertasksai"}:
+        tools.insert(
+            2,
+            Tool(
+                name=f"{prefix}_jurisdiction_sources",
+                description=(
+                    f"Retrieve the curated current jurisdiction-and-authority source pack for a jurisdiction-sensitive {product_name} workflow. "
+                    "Use after the applicable state is known and before applying state, local, district, regulator, form, or policy requirements. "
+                    "Send only the skill ID and general authority labels; never send an address, person name, student or client facts, documents, or generated content."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "skill_id": {
+                            "type": "string",
+                            "description": "Exact workflow ID requesting a task-specific source pack.",
+                        },
+                        "state": {
+                            "type": "string",
+                            "description": "Property state name or two-letter code. Omit only to obtain a blocking missing-jurisdiction response.",
+                        },
+                        "county": {
+                            "type": "string",
+                            "description": "Optional county name only; do not include an address.",
+                        },
+                        "locality": {
+                            "type": "string",
+                            "description": "Optional city or municipality name only; do not include an address.",
+                        },
+                        "district": {
+                            "type": "string",
+                            "description": "Optional public authority or school-district name only; do not include a person, student, or record identifier.",
+                        },
+                    },
+                    "required": ["skill_id"],
+                },
+            ),
+        )
+    return tools
+
 
 def normalize_audience_label(label):
     """Return a natural audience phrase without naive pluralization."""
@@ -1441,6 +1793,16 @@ async def call_tool(name, arguments):
                 f"---\n*Credits remaining: {credits_remaining}*"
             ))]
 
+        # ── Jurisdiction Sources ─────────────────────────────────────────────
+        elif name == f"{prefix}_jurisdiction_sources" and prefix in {
+            "realtortasksai",
+            "farmertasksai",
+            "teachertasksai",
+        }:
+            path = jurisdiction_sources_path(arguments or {})
+            result = await api_get(path)
+            return [TextContent(type="text", text=format_jurisdiction_source_pack(result))]
+
         # ── Save Document ───────────────────────────────────────────────────
         elif name == f"{prefix}_save_document":
             output_path, fmt = save_document(arguments or {}, product_name)

package/runtime/skill_matcher.py

@@ -57,6 +57,12 @@ DEFAULT_CONTEXT_WORDS = {
 DEFAULT_THRESHOLDS = {"high": 90, "medium": 45}
 DEFAULT_RESULT_COUNT = 3
 MAXIMUM_RESULT_COUNT = 10
+TRIGGER_EVIDENCE_RANK = {
+    "trigger_exact": 4,
+    "trigger_complete": 3,
+    "trigger_query_complete": 2,
+    "trigger_partial": 1,
+}
 
 
 def normalize_text(value: object) -> str:
@@ -386,6 +392,7 @@ def _score_skill(
         "score": score,
         "confidence": confidence,
         "evidence": evidence,
+        "_trigger_rank": TRIGGER_EVIDENCE_RANK.get(trigger_evidence, 0),
         "_trigger_specificity": trigger_specificity,
         "_matched_tokens": matched_tokens,
         "_description_normalized": normalize_text(skill.get("description", "")),
@@ -395,6 +402,7 @@ def _score_skill(
 
 def _sort_key(result: Mapping[str, object]) -> tuple:
     return (
+        -result["_trigger_rank"],
         -result["score"],
         -result["_trigger_specificity"],
         -len(result["_matched_tokens"]),