@tasksai/install 0.1.38 → 0.1.40

package/runtime/server.py

@@ -7,15 +7,16 @@ then self-configures tool names, system prompt, and abbreviation maps.
 
 Tools (names are vertical-prefixed at runtime, e.g. farmertasksai_search):
   {prefix}_search     — Find the right skill for your task
-  {prefix}_execute    — Get the full expert framework for a skill (costs 1 credit)
+  {prefix}_execute    — Get the full expert framework at its configured credit charge
   {prefix}_save_document — Save the finished local output as a downloadable file
   {prefix}_balance    — Check your remaining credit balance
   {prefix}_categories — Browse skills by category
 
-Privacy: Your queries, documents, and client data never leave your machine.
-Skills run entirely locally. The API only delivers skill metadata and
-counts credits — it never sees what you're working on. Saved documents are
-created by this local MCP server, not by TasksAI websites or APIs.
+Privacy: TasksAI saves project data and document files locally. Its APIs deliver
+skill content, account/credit information and authority-source metadata; they do
+not receive customer document content through this workflow. Cloud AI processing
+is separate: the selected AI provider receives the information supplied to it.
+The local workspace asks for consent before sending selected information to AI.
 """
 
 import os
@@ -891,580 +892,9 @@ def unique_output_path(root, filename, overwrite=False):
     raise RuntimeError("Could not choose a unique output filename.")
 
 
-def markdown_table_row(line):
-    """Return parsed table cells when a line looks like a Markdown table row."""
-    stripped = line.strip()
-    if "|" not in stripped:
-        return None
-    if stripped.startswith("|"):
-        stripped = stripped[1:]
-    if stripped.endswith("|"):
-        stripped = stripped[:-1]
-    cells = []
-    current = []
-    escaped = False
-    for char in stripped:
-        if escaped:
-            current.append(char)
-            escaped = False
-        elif char == "\\":
-            escaped = True
-        elif char == "|":
-            cells.append("".join(current).strip())
-            current = []
-        else:
-            current.append(char)
-    cells.append("".join(current).strip())
-    return cells if len(cells) > 1 else None
-
-
-def markdown_table_alignments(separator_cells):
-    """Return column alignments if cells are a valid Markdown table separator."""
-    alignments = []
-    for cell in separator_cells or []:
-        compact = cell.replace(" ", "")
-        if not re.match(r"^:?-{3,}:?$", compact):
-            return None
-        if compact.startswith(":") and compact.endswith(":"):
-            alignments.append("center")
-        elif compact.endswith(":"):
-            alignments.append("right")
-        else:
-            alignments.append("left")
-    return alignments
-
-
-def is_markdown_table_start(lines, index):
-    """True when lines[index:index+2] form a Markdown table header."""
-    if index + 1 >= len(lines):
-        return False
-    header = markdown_table_row(lines[index])
-    separator = markdown_table_row(lines[index + 1])
-    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 re.match(r"^(?:[-*+]\s+|\d+\.\s+|>|<!--)", 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."""
-    bold_match = re.match(r"^\*\*([^*\n:]{1,55}):\*\*\s+(.+)$", line.strip())
-    if bold_match:
-        return bold_match.group(1).strip(), bold_match.group(2).strip()
-    match = re.match(r"^([^:\n]{1,55}):\s+(.+)$", line.strip())
-    if not match:
-        return None
-    if re.search(r"[`*_\[\]]", match.group(1)):
-        # A colon after inline Markdown is sentence punctuation, not a
-        # short label/value field. Let the normal inline parser handle it.
-        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."""
-    text = re.sub(r"\\([\\`*_{}\[\]()#+.!-])", r"\1", text)
-    token_re = re.compile(
-        r"(`[^`]+`|\*\*[^*]+\*\*|(?<!_)__(?![_\s])[^_]+?(?<!\s)__(?!_)|\*[^*\s][^*]*\*|(?<!\w)_[^_\s][^_]*_(?!\w)|\[[^\]]+\]\([^)]+\))"
-    )
-    pos = 0
-    for match in token_re.finditer(text):
-        if match.start() > pos:
-            yield text[pos:match.start()], {}
-        token = match.group(0)
-        marks = {}
-        value = token
-        if token.startswith("**") and token.endswith("**"):
-            value = token[2:-2]
-            marks["bold"] = True
-        elif token.startswith("__") and token.endswith("__"):
-            value = token[2:-2]
-            marks["bold"] = True
-        elif token.startswith("`") and token.endswith("`"):
-            value = token[1:-1]
-            marks["code"] = True
-        elif token.startswith("["):
-            link = re.match(r"^\[([^\]]+)\]\(([^)]+)\)$", token)
-            if link:
-                value = link.group(1)
-                marks["link"] = link.group(2)
-        elif token[0] in {"*", "_"} and token.endswith(token[0]):
-            value = token[1:-1]
-            marks["italic"] = True
-        yield value, marks
-        pos = match.end()
-    if pos < len(text):
-        yield text[pos:], {}
-
-
-def add_hyperlink(paragraph, text, url):
-    """Add a clickable hyperlink run when python-docx low-level APIs are available."""
-    from docx.oxml import OxmlElement
-    from docx.oxml.ns import qn
-
-    part = paragraph.part
-    relationship_id = part.relate_to(
-        url,
-        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
-        is_external=True,
-    )
-
-    hyperlink = OxmlElement("w:hyperlink")
-    hyperlink.set(qn("r:id"), relationship_id)
-    run_element = OxmlElement("w:r")
-    properties = OxmlElement("w:rPr")
-
-    color = OxmlElement("w:color")
-    color.set(qn("w:val"), "0563C1")
-    properties.append(color)
-
-    underline = OxmlElement("w:u")
-    underline.set(qn("w:val"), "single")
-    properties.append(underline)
-
-    run_element.append(properties)
-    text_element = OxmlElement("w:t")
-    text_element.text = text
-    run_element.append(text_element)
-    hyperlink.append(run_element)
-    paragraph._p.append(hyperlink)
-
-
-def add_markdown_text(paragraph, text):
-    """Add common inline Markdown formatting to a python-docx paragraph."""
-    for value, marks in iter_inline_markdown(text):
-        if not value:
-            continue
-        if marks.get("link"):
-            try:
-                add_hyperlink(paragraph, value, marks["link"])
-            except Exception:
-                paragraph.add_run(f"{value} ({marks['link']})")
-            continue
-        run = paragraph.add_run(value)
-        if marks.get("bold"):
-            run.bold = True
-            if re.match(r"^\+\d", value):
-                # Aptos substitution in some headless Word renderers maps a
-                # bold leading plus sign to a diamond. Arial preserves the
-                # intended glyph and remains portable in Office.
-                run.font.name = "Arial"
-        if marks.get("italic"):
-            run.italic = True
-        if marks.get("code"):
-            run.font.name = "Courier New"
-
-
-def add_markdown_heading(doc, text, level):
-    """Create a Word heading while parsing any inline Markdown in its text."""
-
-    paragraph = doc.add_heading(level=level)
-    add_markdown_text(paragraph, text)
-    return paragraph
-
-
-def add_horizontal_rule(paragraph):
-    """Render a horizontal Markdown rule as a Word paragraph border."""
-    from docx.oxml import OxmlElement
-    from docx.oxml.ns import qn
-
-    p_pr = paragraph._p.get_or_add_pPr()
-    borders = p_pr.first_child_found_in("w:pBdr")
-    if borders is None:
-        borders = OxmlElement("w:pBdr")
-        p_pr.append(borders)
-    bottom = OxmlElement("w:bottom")
-    bottom.set(qn("w:val"), "single")
-    bottom.set(qn("w:sz"), "6")
-    bottom.set(qn("w:space"), "1")
-    bottom.set(qn("w:color"), "BFBFBF")
-    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, RGBColor
-
-    if not rows:
-        return
-
-    width = max(len(row) for row in rows)
-    normalized = [row + [""] * (width - len(row)) for row in rows]
-    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):
-        row_characters = sum(len(value) for value in row)
-        longest_cell = max((len(value) for value in row), default=0)
-        if row_index == 0 or (row_characters <= 600 and longest_cell <= 350):
-            # Keep ordinary rows intact so a cell does not strand a fragment
-            # on the next page. Exceptionally large rows may still split to
-            # avoid creating a mostly blank page.
-            prevent_table_row_split(table.rows[row_index])
-        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
-            elif alignment == "center":
-                paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            for run in paragraph.runs:
-                run.font.size = Pt(8 if width > 6 else 9)
-
-    doc.add_paragraph()
-
-
-def write_docx(path, title, content_markdown, product_name):
-    """Write a professionally styled DOCX file locally."""
-    try:
-        from docx import Document
-        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)
-
-    lines = content_markdown.splitlines()
-    paragraph_buffer = []
-
-    def flush_paragraph():
-        if not paragraph_buffer:
-            return
-        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("\r\n")
-        stripped = line.strip()
-        if stripped.startswith("```"):
-            flush_paragraph()
-            in_code_block = not in_code_block
-            index += 1
-            continue
-        if in_code_block:
-            para = doc.add_paragraph()
-            run = para.add_run(line)
-            run.font.name = "Courier New"
-            run.font.size = Pt(9)
-            index += 1
-            continue
-        if not stripped:
-            flush_paragraph()
-            index += 1
-            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])
-            alignments = markdown_table_alignments(markdown_table_row(lines[index + 1]))
-            table_rows = [header]
-            index += 2
-            while index < len(lines):
-                row = markdown_table_row(lines[index])
-                if not row:
-                    break
-                table_rows.append(row)
-                index += 1
-            add_markdown_table(doc, table_rows, alignments)
-            continue
-        elif heading:
-            flush_paragraph()
-            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()
-            ):
-                add_markdown_heading(doc, heading_text, min(len(heading.group(1)), 4))
-                keep_checklist_together = "checklist" in heading_text.casefold()
-            index += 1
-        elif standalone_bold_heading:
-            flush_paragraph()
-            add_markdown_heading(doc, standalone_bold_heading.group(1).strip(), 3)
-            index += 1
-        elif inferred_heading:
-            flush_paragraph()
-            add_markdown_heading(doc, stripped, 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()
-            para = doc.add_paragraph(style="List Bullet")
-            indent_level = min(len(bullet.group(1).replace("\t", "    ")) // 2, 4)
-            para.paragraph_format.left_indent = Inches(0.25 * indent_level)
-            text = bullet.group(2).strip()
-            checkbox = re.match(r"^\[([ xX])\]\s+(.+)$", text)
-            if checkbox:
-                text = f"[{checkbox.group(1).lower()}] {checkbox.group(2).strip()}"
-            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()
-            para = doc.add_paragraph(style="List Number")
-            indent_level = min(len(numbered.group(1).replace("\t", "    ")) // 2, 4)
-            para.paragraph_format.left_indent = Inches(0.25 * indent_level)
-            add_markdown_text(para, numbered.group(2).strip())
-            index += 1
-        elif quote:
-            flush_paragraph()
-            try:
-                para = doc.add_paragraph(style="Quote")
-            except Exception:
-                para = doc.add_paragraph()
-            para.paragraph_format.left_indent = Inches(0.25)
-            add_markdown_text(para, quote.group(1).strip())
-            index += 1
-        elif stripped in {"---", "***", "___"}:
-            flush_paragraph()
-            add_horizontal_rule(doc.add_paragraph())
-            index += 1
-        else:
-            paragraph_buffer.append(line)
-            index += 1
-
-    flush_paragraph()
-
-    doc.save(path)
+# Also works when the server is loaded by an embedding host via a file spec.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from document_renderer import *  # shared renderer; preserves the existing helper API
 
 
 def write_markdown(path, title, content_markdown, product_name):
@@ -1749,6 +1179,8 @@ def build_tools(prefix, product_name, occupation):
             },
         ),
     )
+    if PRODUCT_ID == 'realtor' and os.getenv('TASKSAI_WORKSPACE_DIR','').strip():
+        tools.append(Tool(name=f'{prefix}_workspace',description='Open your local TasksAI workspace to list, reopen, or create projects from previously selected skills. This does not execute a skill or spend a TasksAI credit. Use for saved projects and after a workspace update.',inputSchema={'type':'object','properties':{},'additionalProperties':False}))
     return tools
 
 
@@ -1848,7 +1280,7 @@ async def call_tool(name, arguments):
     # requests. Preserve privacy if a host bypasses startup and calls search or
     # categories directly: use only bundled identity and empty/local caches.
     if _vertical is None:
-        if name.endswith("_search") or name.endswith("_categories"):
+        if name.endswith("_search") or name.endswith("_categories") or name.endswith("_workspace"):
             _vertical = fallback_vertical(PRODUCT_ID)
         else:
             await load_vertical()
@@ -1862,6 +1294,12 @@ async def call_tool(name, arguments):
     occupation   = v.get("occupation", "professionals")
 
     try:
+        if name == f'{prefix}_workspace' and product_id == 'realtor':
+            root=os.getenv('TASKSAI_WORKSPACE_DIR','').strip()
+            if not root:return [TextContent(type='text',text='The local workspace is not enabled in this installation.')]
+            from workflows.workspace_launch import launch
+            url=await asyncio.to_thread(launch,root,'local-customer')
+            return [TextContent(type='text',text=f'[Open your saved TasksAI projects]({url}). Opening saved work does not spend a TasksAI credit.')]
         # ── Search ────────────────────────────────────────────────────────────
         if name == f"{prefix}_search":
             # Discovery is snapshot-only. A user's raw prompt never causes a
@@ -1930,9 +1368,30 @@ async def call_tool(name, arguments):
             content = result.get("schema", result.get("content", ""))
             skill_name = result.get("skill_name", skill_id)
             credits_remaining = result.get("credits_remaining", "?")
+            # Capture only an already-authorized delivery. Never execute again
+            # to initialize local workflow storage, and never hide the paid
+            # response if optional workspace capture is unavailable.
+            workspace_notice = ""
+            workspace_root = os.getenv("TASKSAI_WORKSPACE_DIR", "").strip()
+            if product_id == "realtor" and workspace_root:
+                try:
+                    from workflows.licensed_delivery import capture
+                    capture(workspace_root, result)
+                    try:
+                        from workflows.account_snapshot import remember
+                        remember(workspace_root,result)
+                    except Exception:pass
+                    from workflows.workspace_launch import launch
+                    workspace_url = launch(workspace_root, "local-customer")
+                    workspace_notice = f"\n[Open your local TasksAI workspace]({workspace_url}) to create or reopen a project.\n"
+
+                except Exception:
+                    workspace_notice = "\nThe local workspace could not open. The skill below remains available; do not execute it again just to open the workspace.\n"
+
 
             return [TextContent(type="text", text=(
                 f"# {skill_name}\n\n"
+                f"{workspace_notice}"
                 f"{content}\n\n"
                 f"---\n"
                 f"**Local document output:** After you produce the user's final deliverable, call "
@@ -1963,6 +1422,13 @@ async def call_tool(name, arguments):
                         "Controlled live research was unavailable. Continue only with intake or professional-supplied current official sources; do not substitute another jurisdiction."
                     )
                     result["instructions"] = instructions
+            workspace_root = os.getenv("TASKSAI_WORKSPACE_DIR", "").strip()
+            if product_id == "realtor" and workspace_root:
+                try:
+                    from workflows.authority_guides import remember
+                    remember(workspace_root, (arguments or {}).get("skill_id", ""), result)
+                except Exception:
+                    pass  # Optional local capture must not hide the source lookup result.
             return [TextContent(type="text", text=format_jurisdiction_source_pack(result))]
 
         # ── Save Document ───────────────────────────────────────────────────
@@ -1985,6 +1451,11 @@ async def call_tool(name, arguments):
             result = await api_get("/v1/credits/balance")
             balance  = result.get("credits_balance", "?")
             lic_type = result.get("license_type", "")
+            if product_id=='realtor' and os.getenv('TASKSAI_WORKSPACE_DIR','').strip():
+                try:
+                    from workflows.account_snapshot import remember
+                    remember(os.environ['TASKSAI_WORKSPACE_DIR'],result)
+                except Exception:pass  # Optional local display must not hide the balance response.
             domain   = v.get("domain", "farmertasksai.com")
             return [TextContent(type="text", text=(
                 f"**{product_name} Credits**\n\n"
@@ -2067,4 +1538,7 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    from pathlib import Path
+    from software_use import software_use
+    with software_use(Path(__file__).resolve().parent.parent):
+        asyncio.run(main())