fss-link 1.9.3 → 1.9.5

package/bundle/python_ast_helper.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+"""Semantic Edit Layer Python structural-facts helper.
+
+Protocol: reads a single JSON object from stdin, `{"source": "<full file text>"}`,
+writes a single JSON object to stdout, never touches the filesystem.
+
+On success: `{"ok": true, "entries": [...]}` — one entry per supported
+construct, in source order, carrying only raw positional facts (line number
++ UTF-8 byte column, matching ast.col_offset semantics exactly — conversion
+to UTF-16 offsets happens on the TypeScript side). This script does no
+shape/part/name filtering; that is the resolver's job, mirroring how the
+TypeScript adapter keeps all disambiguation centralized.
+
+On failure (source does not parse): `{"ok": false, "error": {"message",
+"line", "col"}}`.
+
+Boundary-finding for parameter lists and call-argument lists uses `ast`
+node positions to bound a minimal raw-byte scan for the enclosing '(' / ')'
+— never an unbounded scan across arbitrary expression content. The window
+being scanned is always one that Python's grammar guarantees can contain
+only whitespace/comments/a trailing comma (e.g. "end of last parameter's
+default value" to "the closing paren"), so a paren inside a string,
+f-string, or nested call default can never be mistaken for the list
+boundary — those are always bounded on both sides by real ast node
+positions first.
+"""
+import ast
+import json
+import sys
+
+
+def line_byte_starts(source_bytes):
+    starts = [0]
+    i = 0
+    n = len(source_bytes)
+    while i < n:
+        b = source_bytes[i]
+        if b == 0x0A:  # \n
+            i += 1
+            starts.append(i)
+        elif b == 0x0D:  # \r
+            i += 1
+            if i < n and source_bytes[i] == 0x0A:
+                i += 1
+            starts.append(i)
+        else:
+            i += 1
+    return starts
+
+
+class Ctx:
+    def __init__(self, source_bytes, line_starts):
+        self.source_bytes = source_bytes
+        self.line_starts = line_starts
+        self.entries = []
+
+    def offset(self, line, col):
+        return self.line_starts[line - 1] + col
+
+    def pos(self, line, col):
+        return {"line": line, "col": col}
+
+    def find_forward(self, from_offset, char_byte):
+        idx = self.source_bytes.find(char_byte, from_offset)
+        if idx == -1:
+            return None
+        return idx
+
+    def offset_to_pos(self, offset):
+        # Reverse of `offset`: locate which line contains `offset`, then the
+        # byte column within that line. Line starts are sorted, so bisect.
+        lo, hi = 0, len(self.line_starts) - 1
+        while lo < hi:
+            mid = (lo + hi + 1) // 2
+            if self.line_starts[mid] <= offset:
+                lo = mid
+            else:
+                hi = mid - 1
+        return {"line": lo + 1, "col": offset - self.line_starts[lo]}
+
+
+def node_start(ctx, node):
+    return ctx.pos(node.lineno, node.col_offset)
+
+
+def node_end(ctx, node):
+    return ctx.pos(node.end_lineno, node.end_col_offset)
+
+
+def span(ctx, node):
+    return {"start": node_start(ctx, node), "end": node_end(ctx, node)}
+
+
+def find_paren_span(ctx, anchor_after_offset, right_entities):
+    """right_entities is a list of ast nodes (may be empty); the '(' is the
+    first one found after anchor_after_offset (safe: nothing but whitespace/
+    comments can precede it), the ')' is the first one found after the max
+    end-offset among right_entities (or right after '(' if there are none —
+    same safety argument)."""
+    open_idx = ctx.find_forward(anchor_after_offset, b"(")
+    if open_idx is None:
+        return None
+    ends = [ctx.offset(n.end_lineno, n.end_col_offset) for n in right_entities if n is not None]
+    right_anchor = max(ends) if ends else open_idx + 1
+    close_idx = ctx.find_forward(right_anchor, b")")
+    if close_idx is None:
+        return None
+    return {"start": ctx.offset_to_pos(open_idx), "end": ctx.offset_to_pos(close_idx + 1)}
+
+
+def params_span(args_node):
+    left = list(args_node.posonlyargs) + list(args_node.args)
+    if args_node.vararg is not None:
+        left.append(args_node.vararg)
+    left += list(args_node.kwonlyargs)
+    if args_node.kwarg is not None:
+        left.append(args_node.kwarg)
+    right = list(left)
+    right += list(args_node.defaults)
+    right += [d for d in args_node.kw_defaults if d is not None]
+    return right
+
+
+def parent_ref(scope_stack):
+    """The innermost scope_stack frame, or None at module level — attached
+    verbatim as each entry's own "parent" field. See the module docstring's
+    Phase 2 note: this is a stable (kind, name, start, end) reference,
+    keyed on the SAME start/end a class/function's own entry carries as its
+    keyword_start/end, so the TypeScript side can deterministically match a
+    "parent" reference back to its owning entry even when names repeat
+    (two same-named nested functions, two same-named classes, etc.) —
+    matching by (start, end) span, never by name alone."""
+    return scope_stack[-1] if scope_stack else None
+
+
+def visit_function(ctx, node, kind, scope_stack):
+    name_start_offset = ctx.offset(node.lineno, node.col_offset)
+    keyword_bytes = ctx.source_bytes[name_start_offset:name_start_offset + 20]
+    # 'def '/'async def ' always precedes the name with exactly one space,
+    # per Python grammar — locate the name by finding 'def ' then skipping
+    # exactly one space, never by scanning for arbitrary identifiers.
+    def_idx = keyword_bytes.find(b"def ")
+    name_off = name_start_offset + def_idx + len(b"def ")
+    name_end_off = ctx.find_forward(name_off, b"(")
+    # trim trailing whitespace between name and '(' from the name span
+    while name_end_off is not None and name_end_off > name_off and ctx.source_bytes[name_end_off - 1] in (0x20, 0x09):
+        name_end_off -= 1
+    name_span = {"start": ctx.offset_to_pos(name_off), "end": ctx.offset_to_pos(name_end_off)} if name_end_off else None
+
+    decorators = node.decorator_list
+    decorator_start = ctx.pos(decorators[0].lineno, decorators[0].col_offset) if decorators else None
+
+    body = node.body
+    body_span = {"start": node_start(ctx, body[0]), "end": node_end(ctx, body[-1])} if body else None
+
+    params = find_paren_span(ctx, name_off, params_span(node.args))
+
+    ctx.entries.append({
+        "kind": kind,
+        "name": node.name,
+        "decorator_start": decorator_start,
+        "keyword_start": node_start(ctx, node),
+        "end": node_end(ctx, node),
+        "name_span": name_span,
+        "body": body_span,
+        "params": params,
+        "parent": parent_ref(scope_stack),
+    })
+
+
+def visit_class(ctx, node, scope_stack):
+    name_start_offset = ctx.offset(node.lineno, node.col_offset)
+    class_bytes = ctx.source_bytes[name_start_offset:name_start_offset + 6]
+    class_idx = class_bytes.find(b"class ")
+    name_off = name_start_offset + class_idx + len(b"class ")
+    # name ends at the first of '(' (base classes), ':' (no bases), or whitespace
+    candidates = [ctx.find_forward(name_off, b"("), ctx.find_forward(name_off, b":")]
+    candidates = [c for c in candidates if c is not None]
+    name_end_off = min(candidates) if candidates else None
+    while name_end_off is not None and name_end_off > name_off and ctx.source_bytes[name_end_off - 1] in (0x20, 0x09):
+        name_end_off -= 1
+    name_span = {"start": ctx.offset_to_pos(name_off), "end": ctx.offset_to_pos(name_end_off)} if name_end_off else None
+
+    decorators = node.decorator_list
+    decorator_start = ctx.pos(decorators[0].lineno, decorators[0].col_offset) if decorators else None
+
+    body = node.body
+    body_span = {"start": node_start(ctx, body[0]), "end": node_end(ctx, body[-1])} if body else None
+
+    ctx.entries.append({
+        "kind": "class",
+        "name": node.name,
+        "decorator_start": decorator_start,
+        "keyword_start": node_start(ctx, node),
+        "end": node_end(ctx, node),
+        "name_span": name_span,
+        "body": body_span,
+        "parent": parent_ref(scope_stack),
+    })
+
+
+def visit_assign(ctx, node, scope_stack):
+    if len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name):
+        return
+    target = node.targets[0]
+    ctx.entries.append({
+        "kind": "assignment",
+        "name": target.id,
+        "whole": span(ctx, node),
+        "name_span": span(ctx, target),
+        "value": span(ctx, node.value),
+        "parent": parent_ref(scope_stack),
+    })
+
+
+def visit_dict(ctx, node, scope_stack):
+    for key, value in zip(node.keys, node.values):
+        if key is None or not (isinstance(key, ast.Constant) and isinstance(key.value, str)):
+            continue
+        ctx.entries.append({
+            "kind": "dictionary_entry",
+            "name": key.value,
+            "whole": {"start": node_start(ctx, key), "end": node_end(ctx, value)},
+            "name_span": span(ctx, key),
+            "value": span(ctx, value),
+            "parent": parent_ref(scope_stack),
+        })
+
+
+def visit_import(ctx, node, scope_stack):
+    names = []
+    if isinstance(node, ast.ImportFrom):
+        if node.module:
+            names.append(node.module)
+        for alias in node.names:
+            names.append(alias.asname or alias.name)
+    else:
+        for alias in node.names:
+            names.append(alias.asname or alias.name)
+    ctx.entries.append({
+        "kind": "import",
+        "names": names,
+        "whole": span(ctx, node),
+        "parent": parent_ref(scope_stack),
+    })
+
+
+def visit_compound(ctx, node, kind, scope_stack):
+    body = node.body
+    body_span = {"start": node_start(ctx, body[0]), "end": node_end(ctx, body[-1])} if body else None
+    ctx.entries.append({
+        "kind": kind,
+        "whole": span(ctx, node),
+        "body": body_span,
+        "parent": parent_ref(scope_stack),
+    })
+
+
+def visit_call(ctx, node, scope_stack):
+    callee_end = ctx.offset(node.func.end_lineno, node.func.end_col_offset)
+    right = list(node.args) + [kw.value for kw in node.keywords]
+    args_span = find_paren_span(ctx, callee_end, right)
+    callee_start = ctx.offset(node.func.lineno, node.func.col_offset)
+    callee_text = ctx.source_bytes[callee_start:callee_end].decode("utf-8", errors="replace")
+    ctx.entries.append({
+        "kind": "call",
+        "callee_text": callee_text,
+        "args": args_span,
+        "parent": parent_ref(scope_stack),
+    })
+
+
+COMPOUND_KINDS = {
+    ast.If: "if",
+    ast.For: "for",
+    ast.While: "while",
+    ast.Try: "try",
+    ast.With: "with",
+}
+
+
+def walk(ctx, node, in_class_body, scope_stack, body_scope_stack):
+    """Manual, source-ordered recursion (ast.walk is BFS, not source order).
+
+    Two contextual threads, deliberately kept separate (Phase 2 note, see
+    implementation plan §10.6):
+      - `in_class_body` — UNCHANGED from the original single-boolean
+        design, used only to decide "method" vs "function"/"async_function"
+        naming. Still gated on `field_name == "body"` exactly as before, so
+        its existing (narrow) behavior — a def nested inside a compound
+        statement (if/for/while/try/with) within a class body is still
+        classified "function", not "method" — is preserved byte-for-byte.
+        This is a generalization of the OLD mechanism's data shape, not a
+        fix to this pre-existing, out-of-scope limitation.
+      - `scope_stack`/`body_scope_stack` — NEW, for ancestor-chain
+        tracking. Unlike `in_class_body`, this propagates through EVERY
+        field of EVERY node type unchanged by default (so a function
+        nested inside an `if` inside a function/class still correctly
+        reports its true lexical ancestor) — a frame is pushed ONLY at the
+        exact point of recursing into a ClassDef/FunctionDef/
+        AsyncFunctionDef's own `body` field (never into decorator_list/
+        bases/args/returns, which evaluate in the ENCLOSING scope — the
+        critical correctness point the mission calls out explicitly).
+        `body_scope_stack` is `scope_stack` for every node that is not
+        itself a class/function (so its own `body` field, if it has one —
+        e.g. If/For/While/Try/With — does not push a new frame); it is
+        `scope_stack + [frame]` only when `dispatch` is handling a
+        ClassDef/FunctionDef/AsyncFunctionDef.
+    """
+    for field_name, field_value in ast.iter_fields(node):
+        stack_for_field = body_scope_stack if field_name == "body" else scope_stack
+        if isinstance(field_value, list):
+            for item in field_value:
+                if not isinstance(item, ast.AST):
+                    continue
+                dispatch(ctx, item, in_class_body and field_name == "body", stack_for_field)
+        elif isinstance(field_value, ast.AST):
+            dispatch(ctx, field_value, False, stack_for_field)
+
+
+def dispatch(ctx, node, in_class_body, scope_stack):
+    if isinstance(node, ast.AsyncFunctionDef):
+        visit_function(ctx, node, "method" if in_class_body else "async_function", scope_stack)
+        frame = {"kind": "method" if in_class_body else "async_function", "name": node.name,
+                 "start": node_start(ctx, node), "end": node_end(ctx, node)}
+        walk(ctx, node, False, scope_stack, scope_stack + [frame])
+    elif isinstance(node, ast.FunctionDef):
+        visit_function(ctx, node, "method" if in_class_body else "function", scope_stack)
+        frame = {"kind": "method" if in_class_body else "function", "name": node.name,
+                 "start": node_start(ctx, node), "end": node_end(ctx, node)}
+        walk(ctx, node, False, scope_stack, scope_stack + [frame])
+    elif isinstance(node, ast.ClassDef):
+        visit_class(ctx, node, scope_stack)
+        frame = {"kind": "class", "name": node.name,
+                 "start": node_start(ctx, node), "end": node_end(ctx, node)}
+        walk(ctx, node, True, scope_stack, scope_stack + [frame])
+    elif isinstance(node, ast.Assign):
+        visit_assign(ctx, node, scope_stack)
+        walk(ctx, node, False, scope_stack, scope_stack)
+    elif isinstance(node, ast.Dict):
+        visit_dict(ctx, node, scope_stack)
+        walk(ctx, node, False, scope_stack, scope_stack)
+    elif isinstance(node, (ast.Import, ast.ImportFrom)):
+        visit_import(ctx, node, scope_stack)
+    elif isinstance(node, ast.Call):
+        visit_call(ctx, node, scope_stack)
+        walk(ctx, node, False, scope_stack, scope_stack)
+    elif type(node) in COMPOUND_KINDS:
+        visit_compound(ctx, node, COMPOUND_KINDS[type(node)], scope_stack)
+        walk(ctx, node, False, scope_stack, scope_stack)
+    else:
+        walk(ctx, node, False, scope_stack, scope_stack)
+
+
+def main():
+    payload = json.loads(sys.stdin.read())
+    source = payload["source"]
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as exc:
+        print(json.dumps({"ok": False, "error": {"message": str(exc.msg), "line": exc.lineno, "col": exc.offset}}))
+        return
+    source_bytes = source.encode("utf-8")
+    ctx = Ctx(source_bytes, line_byte_starts(source_bytes))
+    walk(ctx, tree, False, [], [])
+    print(json.dumps({"ok": True, "entries": ctx.entries}))
+
+
+if __name__ == "__main__":
+    main()

package/bundle/worktrees/SKILL.md

@@ -70,9 +70,15 @@ cd /path/to/project/.fss-link/worktrees/fix-auth-bug && pip install -r requireme
 ```
 exit_worktree({ name: "fix-auth-bug", action: "keep" })      # Work in progress
 exit_worktree({ name: "fix-auth-bug", action: "remove" })    # Work committed
-exit_worktree({ name: "fix-auth-bug", action: "remove", discard_changes: true })  # Discard everything
+exit_worktree({ name: "fix-auth-bug", action: "remove", discard_changes: true })  # Discard system metadata
+exit_worktree({ name: "fix-auth-bug", action: "remove", discard_changes: true, confirm_destruction: true })  # Discard everything
 ```
 
+⚠️ **WARNING:** `discard_changes: true` is a destructive action. It will permanently delete all untracked content in the worktree.
+
+- Without `confirm_destruction`: the tool cleans up its own artifacts (.fss-link/) and lists any remaining user files. You must decide whether to delete them manually or confirm destruction.
+- With `confirm_destruction: true`: ALL untracked content is destroyed, including user files. Use only when you are certain no valuable untracked content exists.
+
 ## Quick Reference
 
 | Situation | Action |
@@ -81,14 +87,15 @@ exit_worktree({ name: "fix-auth-bug", action: "remove", discard_changes: true })
 | Already in a worktree | Do NOT call enter_worktree again |
 | Done, work in progress | `exit_worktree({ name, action: "keep" })` |
 | Done, work committed | `exit_worktree({ name, action: "remove" })` |
-| Done, discard everything | `exit_worktree({ name, action: "remove", discard_changes: true })` |
+| Done, discard system metadata only | `exit_worktree({ name, action: "remove", discard_changes: true })` |
+| Done, discard everything | `exit_worktree({ name, action: "remove", discard_changes: true, confirm_destruction: true })` |
 
 ## Common Mistakes
 
 1. **Using relative paths** — Always use full `worktreePath` for every tool call
 2. **Creating nested worktrees** — Check path first; if it contains `.fss-link/worktrees/`, you're already in one
 3. **Running `git worktree add` manually** — Always use the `enter_worktree` tool
-4. **Removing with uncommitted changes** — Commit or stash first, or use `discard_changes: true`
+4. **Removing with uncommitted changes** — Commit or stash first, or use `discard_changes: true` (system metadata only) or `confirm_destruction: true` (everything)
 
 ## Global Flags
 

package/docs/SLASH-COMMANDS.md

@@ -7,7 +7,7 @@ Resume a previous conversation session by number, title, or session ID.
 ### Usage
 
 ```
-/resume                          # List recent sessions
+/resume                          # Open session gallery dialog
 /resume <number>                 # Resume by list position
 /resume <title substring>        # Resume by title match
 /resume <session-id>             # Resume by exact session ID
@@ -17,23 +17,53 @@ Resume a previous conversation session by number, title, or session ID.
 
 `/sessions`, `/continue` — all three names invoke the same command.
 
-### Listing Sessions
+### Interactive Gallery Dialog
 
-Running `/resume` with no arguments displays a numbered list of up to 50 recent sessions for the current project, sorted by most recently updated:
+Running `/resume` with no arguments opens an interactive gallery dialog showing up to 10 recent sessions for the current project, sorted by most recently updated:
 
 ```
-Recent sessions:
+┌──────────────────────────────────────────────────────────┐
+│ ↩ Resume — select a session to resume                    │
+│ Search: auth                                             │
+│                                                          │
+│   [1] Fix the login bug          2h ago    5 turns       │
+│ ▶ [2] Refactor auth module       1d ago    8 turns       │
+│   [3] Add dark mode feature      3d ago   12 turns       │
+│                                                          │
+│ ↑↓ navigate · Enter confirm · Esc cancel · type to search│
+└──────────────────────────────────────────────────────────┘
+```
 
-  1. Implement auth middleware for API endpoints    2 hours ago    14 turns
-  2. Fix login bug on password reset flow           1 day ago      8 turns
-  3. Set up CI pipeline with GitHub Actions         3 days ago     22 turns
+Each row displays: session number, title (truncated at 55 chars), relative time, turn count, and model name (if available).
 
-Type a number to resume, or /resume <partial title> to match by name.
-```
+### Navigation & Search
+
+| Key | Action |
+|-----|--------|
+| `↑` / `↓` | Move selection up/down |
+| `Enter` | Confirm selection and resume |
+| `Esc` (first press) | Clear the search filter |
+| `Esc` (second press) | Close the dialog without resuming |
+| `Backspace` | Delete one character from the search filter |
+| Any printable character | Type into the search filter box |
+
+### Search
+
+The dialog has a working text filter. Type any characters to narrow the visible sessions:
+
+- **Case-insensitive substring match** on session title
+- Selection resets to the top (index 0) when the filter changes
+- Shows "No sessions match" if the filter produces zero results
+- First `Esc` clears the filter and restores the full list; second `Esc` closes the dialog
+
+**Limitations:**
+- Single-term only — multi-word queries like "auth middleware" won't work as two separate terms
+- Searches only session titles, not message content
+- No ranking or scoring — just `includes` substring match
 
-Titles are truncated at 55 characters. The list is scoped to the current project (identified by project hash).
+### Selection Methods (Text Input)
 
-### Selection Methods
+You can still use text input to select sessions without opening the gallery:
 
 | Method | Example | Behavior |
 |--------|---------|----------|
@@ -50,7 +80,7 @@ Titles are truncated at 55 characters. The list is scoped to the current project
 
 ### Tab Completion
 
-Pressing Tab while typing `/resume <partial>` shows completions for session titles that **start with** the partial text (`startsWith`). This is intentionally stricter than the action's own matching (`includes`) — tab completion may show fewer options than what `/resume <text>` would actually match.
+Pressing Tab while typing `/resume <partial>` shows completions for session titles that **contain** the partial text (`includes`, case-insensitive). Empty input (bare `/resume `) returns no completions — this prevents the autocomplete dropdown from intercepting Enter, which would block the gallery dialog from opening.
 
 ### What Happens When You Resume
 
@@ -176,11 +206,11 @@ The dialog displays project-level information including:
 
 | Aspect | Welcome Back Dialog | `/resume` |
 |--------|---------------------|-----------|
-| **Trigger** | Automatic on project launch | Manual slash command |
-| **Scope** | Project-level (one choice) | Per-session picker (up to 50) |
+| **Trigger** | Automatic on project launch | Manual slash command (opens gallery) |
+| **Scope** | Project-level (one choice) | Per-session picker (up to 10 in gallery) |
 | **Data source** | `ProjectSummaryParser` (analysis of project state) | `sessions.db` (direct session records) |
-| **Selection** | Continue / Restart / Cancel | Number, title substring, or session ID |
+| **Selection** | Continue / Restart / Cancel | Gallery dialog or text input (number/title/ID) |
 | **Context** | Smart summary built from project analysis | Full conversation history restored verbatim |
-| **Search** | None — single decision point | Substring search across session titles |
+| **Search** | None — single decision point | Title substring search in gallery dialog |
 
 The Welcome Back dialog is best for quick decisions at project launch. `/resume` is for browsing and selecting from multiple saved sessions within an active conversation.

package/docs/TOOLS.md

@@ -408,10 +408,13 @@ Exits a worktree previously created by `enter_worktree`.
 |-----------|------|-------------|
 | `name` | string | Slug of the worktree to exit (must match the name used in `enter_worktree`). |
 | `action` | string | `"keep"` preserves the worktree on disk; `"remove"` deletes it and its branch. |
-| `discard_changes` | boolean | When `action="remove"`, must be true to delete a worktree with uncommitted changes. |
+| `discard_changes` | boolean | When `action="remove"`, bypasses the dirty-worktree check. Automatically cleans up system metadata (.fss-link/). Lists remaining user files. |
+| `confirm_destruction` | boolean | When `action="remove"` and `discard_changes=true`, destroys ALL untracked content including user files. Requires `discard_changes=true`. |
 
 - `action='keep'` — preserves the worktree directory and branch on disk so it can be revisited later
 - `action='remove'` — deletes the worktree directory and branch. Refuses to run if the worktree contains uncommitted changes unless `discard_changes: true` is set
+- `discard_changes: true` — cleans up system metadata (.fss-link/). If other untracked files remain, lists them and refuses to proceed unless `confirm_destruction: true`
+- `confirm_destruction: true` — destroys ALL untracked content. Requires `discard_changes: true`. Use with caution.
 - Only invoke when the user explicitly asks to leave or clean up a worktree
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fss-link",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/FSSCoding/fss-link.git"
   },
   "config": {
-    "sandboxImageUri": "ghcr.io/fsscoding/fss-link:1.9.3"
+    "sandboxImageUri": "ghcr.io/fsscoding/fss-link:1.9.4"
   },
   "scripts": {
     "start": "node scripts/start.js",
@@ -28,7 +28,7 @@
     "build:all": "npm run build && npm run build:sandbox && npm run build:vscode",
     "build:packages": "npm run build --workspaces",
     "build:sandbox": "node scripts/build_sandbox.js --skip-npm-install-build",
-    "bundle": "npm run generate && node scripts/prebundle-sync-dist.js && node esbuild.config.js && node scripts/copy_bundle_assets.js",
+    "bundle": "npm run generate && node scripts/prebundle-sync-dist.js && node esbuild.config.js && node scripts/copy_bundle_assets.js && node bundle/fss-link.js --version",
     "prepublishOnly": "node scripts/check-publish.js",
     "test": "npm run test --workspaces --if-present",
     "test:ci": "npm run test:ci --workspaces --if-present && npm run test:scripts",
@@ -95,6 +95,7 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-vitest": "^0.5.4",
+    "fast-check": "^4.9.0",
     "globals": "^16.0.0",
     "ink": "^6.8.0",
     "ink-testing-library": "^4.0.0",
@@ -189,7 +190,7 @@
     "turndown": "^7.2.0",
     "turndown-plugin-gfm": "^1.0.2",
     "undici": "^7.10.0",
-    "vite": "^8.0.14",
+    "vite": "^6.3.5",
     "vitest": "^4.1.7",
     "xml2js": "^0.6.0",
     "yargs": "^17.7.2",

package/scripts/build_package.js

@@ -18,8 +18,8 @@
 // limitations under the License.
 
 import { execSync } from 'child_process';
-import { writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
+import { writeFileSync, rmSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
 
 if (!process.cwd().includes('packages')) {
   console.error('must be invoked from a package directory');
@@ -31,7 +31,33 @@ if (!process.cwd().includes('packages')) {
 // leaves that cache out of sync with what's actually on disk, which surfaces
 // as TS5055 "Cannot write file ... because it would overwrite input file".
 // Same fix already applied in prebundle-sync-dist.js for the bundle path.
-rmSync(join(process.cwd(), 'dist'), { recursive: true, force: true });
+//
+// `tsc --build` also follows tsconfig.json project `references` and rebuilds
+// those referenced packages too (e.g. packages/cli references ../core) — so
+// their dist/ must be cleaned as well, not just this package's own. Missing
+// this was the actual cause of TS5055 surfacing specifically on the
+// *referenced* package's files: this package's own dist was cleaned, but the
+// referenced package's stale dist/.tsbuildinfo was not, so tsc tried to
+// rebuild it against out-of-sync cached state.
+function cleanDistRecursive(pkgDir, seen = new Set()) {
+  const resolved = resolve(pkgDir);
+  if (seen.has(resolved)) return;
+  seen.add(resolved);
+
+  rmSync(join(resolved, 'dist'), { recursive: true, force: true });
+
+  let tsconfig;
+  try {
+    tsconfig = JSON.parse(readFileSync(join(resolved, 'tsconfig.json'), 'utf-8'));
+  } catch {
+    return;
+  }
+  for (const ref of tsconfig.references ?? []) {
+    cleanDistRecursive(resolve(resolved, ref.path), seen);
+  }
+}
+
+cleanDistRecursive(process.cwd());
 
 // build typescript files
 execSync('tsc --build', { stdio: 'inherit' });

package/scripts/copy_bundle_assets.js

@@ -64,4 +64,23 @@ if (skillFiles.length > 0) {
   console.log(`Bundled skills copied to bundle/ (${skillFiles.length} file(s))`);
 }
 
+// Copy the Python SEL adapter's subprocess helper alongside the bundled
+// JS. pythonAdapter.ts resolves it via
+// `new URL('./python_ast_helper.py', import.meta.url)` — since esbuild
+// concatenates every module into one output file, import.meta.url for ALL
+// bundled code resolves to bundle/fss-link-main.js's own location at
+// runtime (not each source file's original directory), so the helper must
+// live at the bundle root, not mirrored under tools/semanticEditAdapters/.
+const pythonHelperSrc = join(
+  root,
+  'packages',
+  'core',
+  'src',
+  'tools',
+  'semanticEditAdapters',
+  'python_ast_helper.py',
+);
+copyFileSync(pythonHelperSrc, join(bundleDir, 'python_ast_helper.py'));
+console.log('Python SEL adapter helper copied to bundle/python_ast_helper.py');
+
 console.log('Assets copied to bundle/');