flowjet 2.1.0__tar.gz → 2.1.2__tar.gz

{flowjet-2.1.0 → flowjet-2.1.2}/CHANGELOG.md

@@ -10,6 +10,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.2] — 2026-10-21
+
+### Changed
+
+- **Bump `soothe` to 1.2.1.** The runtime dependency floor moves from
+  `>=1.2.0` to `>=1.2.1,<2.0.0` to track the upstream fix release. No flowjet
+  API or behavior changes; the locked dependency set is otherwise unchanged.
+
+## [2.1.1] — 2026-10-21
+
+### Fixed
+
+- **ACP clarification turns no longer end empty.** When the agent paused with
+  `ask_user` questions over ACP, the questions were only surfaced as an
+  intermediate agent thought — but hosts accumulate message chunks as the
+  turn's reply, so a clarification turn ended with no content at all. The ACP
+  agent now also emits the questions block as a message chunk (rendered via
+  `format_questions_block`), so the user sees the questions in the host's reply
+  surface and answers there.
+
+- **`format_questions_block` supports non-CLI hosts.** The resume footer
+  ("Resume with: fjf -t <thread> <your answer>") was hardcoded for the CLI.
+  ACP and other non-CLI hosts now pass `resume_hint=""` to omit the
+  CLI-specific footer; the user answers in the host's own input surface.
+  The CLI path is unchanged (footer still shown by default).
+
+- **Drop the direct `arcbox` dependency from the `server` extra.** The arcbox
+  SDK ships transitively via soothe-nano (a dependency of soothe), so the
+  explicit `arcbox>=0.1.0` pin in `pyproject.toml` was redundant and could
+  drift out of sync. The sandbox import error message is updated to point at
+  the transitive path instead of instructing `pip install arcbox`.
+
 ## [2.1.0] — 2026-10-18
 
 ### Changed

{flowjet-2.1.0 → flowjet-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.1.0
+Version: 2.1.2
 Summary: FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by Soothe
 Project-URL: Homepage, https://github.com/caesar0301/flowjet
 Project-URL: Repository, https://github.com/caesar0301/flowjet
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.11
-Requires-Dist: soothe<2.0.0,>=1.2.0
+Requires-Dist: soothe<2.0.0,>=1.2.1
 Provides-Extra: dev
 Requires-Dist: httpx>=0.27.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
@@ -34,7 +34,6 @@ Requires-Dist: ruff>=0.12.0; extra == 'dev'
 Requires-Dist: twine>=5.0.0; extra == 'dev'
 Provides-Extra: server
 Requires-Dist: agent-client-protocol[http]<1.0.0,>=0.12.1; extra == 'server'
-Requires-Dist: arcbox>=0.1.0; extra == 'server'
 Requires-Dist: fastapi>=0.115.0; extra == 'server'
 Requires-Dist: langchain-core>=0.3; extra == 'server'
 Requires-Dist: pydantic-settings>=2.0; extra == 'server'

{flowjet-2.1.0 → flowjet-2.1.2}/docs/specs/RFC-005-arcbox-tool-sandbox.md

@@ -38,11 +38,16 @@ microVM duplicated soothe-nano's sandbox capability at the wrong layer.
 - Per-session guest isolation: the sandbox is **per workspace**. Concurrent
   sessions sharing one workspace share one guest (staged serially; a peer
   mid-run skips the host push so live guest state is never clobbered).
-- Guest-side deletion propagation: a host file deleted between sessions is
-  not removed from the guest (the pull direction is authoritative at close).
 - Incremental (delta) transfers: staging is a full-tree push/pull with a
   `(size, mtime_ns)` manifest skip for unchanged files.
 
+> **Revision (2026-10-21, RFC-RD-607)**: guest-side deletion propagation is no
+> longer a non-goal — `pull` now removes host files that were recorded in the
+> last push manifest but disappeared from the guest tree (so agent-side
+> deletes flow guest → host → sync checkpoint → content tree). Host files
+> created after the push are never in the manifest and can never be deleted
+> by this path.
+
 ## 4. Configuration
 
 Enabled by a `sandbox:` section in the flowjet nano.yml. Flowjet owns the

{flowjet-2.1.0 → flowjet-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.1.0"
+version = "2.1.2"
 description = "FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by Soothe"
 readme = "README.md"
 license = { text = "MIT" }
@@ -27,7 +27,7 @@ classifiers = [
 ]
 # Single-dependency CLI wheel; HTTP service deps live in the `server` extra.
 dependencies = [
-    "soothe>=1.2.0,<2.0.0",
+    "soothe>=1.2.1,<2.0.0",
 ]
 
 [project.optional-dependencies]
@@ -40,9 +40,6 @@ server = [
     "langchain-core>=0.3",
     # S3/MinIO workspace sync backend
     "s3fs>=2024.6",
-    # ArcBox microVM SDK — sandboxed tool execution via soothe's
-    # sandbox backend (https://github.com/arcboxlabs/arcbox)
-    "arcbox>=0.1.0",
 ]
 dev = [
     "pytest>=8.0.0",

{flowjet-2.1.0 → flowjet-2.1.2}/src/flowjet/builtin_skills/logo-generator-skill/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: logo-generator
+name: logo-generator-skill
 description: >
   Generate professional SVG logos and high-end showcase images. Use when the user wants to: (1) Create a logo or icon for their product/brand, (2) Generate logo design concepts based on product information, (3) Create professional logo showcase presentations with multiple background styles, (4) Export logos in various formats (SVG, PNG), or (5) Iterate on logo designs with different visual styles. Supports geometric patterns, dot matrix designs, line systems, and mixed compositions. Generates showcase images using Nano Banana (Gemini image generation) with 12 professional background styles.
 ---

{flowjet-2.1.0 → flowjet-2.1.2}/src/flowjet/cli/stream.py

@@ -276,16 +276,28 @@ class AnswerWriter:
         return self.buf
 
 
-def format_questions_block(questions: tuple[dict[str, Any], ...], thread_id: str) -> str:
+def format_questions_block(
+    questions: tuple[dict[str, Any], ...],
+    thread_id: str,
+    resume_hint: str | None = None,
+) -> str:
     """Render ``ask_user`` questions as a terminal block with a resume hint.
 
     The block is written to stdout after the ephemeral progress line is
     cleared, so it stays visible. Each question lists its options with the
     recommended one (label ending in "(Recommended)") marked. The footer
-    tells the user how to resume with an answer via ``fjf``.
+    tells the user how to resume with an answer via ``fjf``. Non-CLI hosts
+    (ACP) pass ``resume_hint=""`` to omit the CLI-specific footer — the user
+    answers in the host's own input.
     """
+    footer = (
+        f"Resume with: fjf -t {thread_id} <your answer>" if resume_hint is None else resume_hint
+    )
     if not questions:
-        return f"\n⏸ Paused for input · resume with: fjf -t {thread_id} <your answer>\n"
+        block = "\n⏸ Paused for input"
+        if footer:
+            block += f" · {footer}"
+        return block + "\n"
     lines: list[str] = ["", "⏸ Paused for input:"]
     for qi, q in enumerate(questions, 1):
         header = str(q.get("header") or "").strip()
@@ -310,7 +322,8 @@ def format_questions_block(questions: tuple[dict[str, Any], ...], thread_id: str
                     lines.append(f"      • {label}{marker} — {desc}")
                 else:
                     lines.append(f"      • {label}{marker}")
-    lines.append(f"\n  Resume with: fjf -t {thread_id} <your answer>\n")
+    if footer:
+        lines.append(f"\n  {footer}\n")
     return "\n".join(lines) + "\n"
 
 

{flowjet-2.1.0 → flowjet-2.1.2}/src/flowjet/core/runtime/isolation/workspace.py

@@ -7,6 +7,7 @@ import hashlib
 import logging
 import re
 import shutil
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -110,6 +111,29 @@ class WorkspaceResolver:
             return path == self._home
 
 
+@dataclass
+class _OpenWorkspaceEntry:
+    """One open workspace — shared by all concurrent turns of the same run_id.
+
+    ``active_runs`` counts turns currently mid-run on this workspace; the
+    lifecycle (``manager.close``) belongs to the last run out. ``manifest``
+    caches the recovered engine manifest so the per-turn refresh can protect
+    agent artifacts from deletion reconcile.
+    """
+
+    ws: Any
+    active_runs: int = 0
+    manifest: Any | None = None
+    restored: bool = False
+
+
+def _manifest_artifact_paths(manifest: Any | None) -> list[str]:
+    """Relative paths of the manifest's artifacts (reconcile protection set)."""
+    if manifest is None:
+        return []
+    return [entry.path for entry in (getattr(manifest, "artifacts", None) or [])]
+
+
 class SyncAwareWorkspaceResolver(WorkspaceResolver):
     """Workspace resolver backed by soothe's fsspec workspace sync.
 
@@ -150,7 +174,7 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
         self._manager: Any | None = None
         self._sync_backend: Any | None = None
         self._restore_cas: Any | None = None
-        self._open_workspaces: dict[str, Any] = {}
+        self._open_workspaces: dict[str, _OpenWorkspaceEntry] = {}
 
     @property
     def is_sync_enabled(self) -> bool:
@@ -263,7 +287,17 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
         return path
 
     async def open_session(self, session: str, workspace: Path) -> None:
-        """Materialize workspace from object store + start dirty tracking."""
+        """Refresh the workspace from the object store + start dirty tracking.
+
+        RFC-RD-607 §4.3: the sync boundary is the agent turn (one pair of
+        open/close hooks per prompt). Every turn unconditionally materializes
+        the content tree — including the reuse path where a peer session's
+        turn already holds the workspace open (sha-skip keeps repeat turns
+        cheap). Deletion reconcile runs only while this turn is the sole
+        active run on the workspace: deleting files under a peer's feet is
+        worse than a delayed delete, so peer-occupied turns skip it (logged).
+        Prior agent artifacts are restored once, on the opening turn.
+        """
         manager = self._ensure_manager()
         if manager is None:
             return
@@ -273,18 +307,39 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
         # for perfect consistency across resolve/open/close.
         run_id = workspace.name
 
-        # If a workspace is already open for this session (reuse), skip.
-        if run_id in self._open_workspaces:
-            return
+        entry = self._open_workspaces.get(run_id)
+        if entry is None:
+            ws = await manager.open(run_id)
+            entry = _OpenWorkspaceEntry(ws=ws)
+            self._open_workspaces[run_id] = entry
+        else:
+            ws = entry.ws
+        entry.active_runs += 1
+
+        if entry.manifest is None:
+            try:
+                entry.manifest = await self._recover_manifest(ws)
+            except Exception:
+                logger.warning("Manifest recovery failed for run %s", run_id, exc_info=True)
 
-        ws = await manager.open(run_id)
         # Dual-source sync, read path: materialize the content root (e.g.
         # triarch workspace materials) into the workspace BEFORE replaying
         # checkpoint state, so the agent sees both its prior outputs and the
-        # latest backend-uploaded files.
+        # latest backend-uploaded files. The dirty tracker only watches
+        # input/working/output + root files, so content-tree writes never
+        # pollute the dirty set.
         if hasattr(ws, "materialize_content"):
             try:
-                await ws.materialize_content()
+                if self._supports_content_reconcile(ws):
+                    await ws.materialize_content(
+                        protected=_manifest_artifact_paths(entry.manifest),
+                        reconcile=entry.active_runs == 1,
+                    )
+                else:
+                    # soothe < 2.0: no protected/reconcile kwargs — degrade to
+                    # a plain materialize (no reconcile; deletes stay until
+                    # the soothe 2.0.0 release train lands).
+                    await ws.materialize_content()
             except Exception:
                 logger.warning(
                     "Content materialization failed for run %s; continuing with "
@@ -292,19 +347,43 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
                     run_id,
                     exc_info=True,
                 )
-        await self._restore_prior_state(ws)
-        self._open_workspaces[run_id] = ws
+
+        if entry.manifest is not None and not entry.restored:
+            await self._restore_prior_state(ws, entry.manifest)
+            entry.restored = True
 
         # Start dirty tracking + background uploader for incremental persistence.
         await ws.start_tracking()
         logger.info("Opened sync workspace for session %s at %s", session, workspace)
 
-    async def _restore_prior_state(self, ws: Any) -> None:
-        """Recover the prior manifest and materialize its files locally.
+    @staticmethod
+    def _supports_content_reconcile(ws: Any) -> bool:
+        """True when the workspace's ``materialize_content`` takes RFC-RD-607 kwargs.
+
+        soothe < 2.0 lacks ``protected``/``reconcile``; probing the signature
+        keeps flowjet runnable against both release trains.
+        """
+        import inspect
+
+        try:
+            params = inspect.signature(ws.materialize_content).parameters
+        except (TypeError, ValueError):
+            return False
+        return "protected" in params and "reconcile" in params
+
+    async def _recover_manifest(self, ws: Any) -> Any | None:
+        """Recover the prior engine manifest snapshot (single call per open).
 
         Round-trip half of workspace sync: ``close_session`` checkpoints and
-        uploads dirty files; this restores them so a fresh server process (or
-        an evicted session workspace) sees the agent's prior outputs.
+        uploads dirty files; this reads back the manifest so the per-turn
+        materialize can protect agent artifacts and the opening turn can
+        restore them.
+        """
+        payload = await ws.recover()  # reads the latest checkpoint payload
+        return payload.manifest_snapshot if payload is not None else None
+
+    async def _restore_prior_state(self, ws: Any, manifest: Any | None) -> None:
+        """Materialize the recovered manifest's files locally.
 
         - Agent-written files live in ``manifest.artifacts`` (path → sha256,
           blobs under ``<root>/blobs/``) and are restored in place at their
@@ -312,8 +391,6 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
         - Declared input resources (``manifest.resources``) are materialized
           under ``<root>/input/`` via the soothe Materializer.
         """
-        payload = await ws.recover()  # restores checkpoint state, returns snapshot payload
-        manifest = payload.manifest_snapshot if payload is not None else None
         if manifest is None:
             return
 
@@ -363,20 +440,32 @@ class SyncAwareWorkspaceResolver(WorkspaceResolver):
         return self._restore_cas
 
     async def close_session(self, session: str, workspace: Path) -> None:
-        """Checkpoint dirty files + upload to object store + close workspace."""
+        """Checkpoint dirty files + upload to object store; close when last run ends.
+
+        Concurrent turns of the same workspace share one open workspace:
+        a mid-run peer's close checkpoints the shared state but keeps the
+        workspace open — the lifecycle (``manager.close``) belongs to the
+        last run out (RFC-RD-607 §4.3).
+        """
         if self._manager is None:
             return
 
         run_id = workspace.name
 
-        ws = self._open_workspaces.pop(run_id, None)
-        if ws is None:
+        entry = self._open_workspaces.get(run_id)
+        if entry is None:
             return
 
+        if entry.active_runs > 0:
+            entry.active_runs -= 1
         try:
-            await ws.checkpoint()
+            await entry.ws.checkpoint()
         except Exception:
             logger.warning("Checkpoint failed for session %s", session, exc_info=True)
+        if entry.active_runs > 0:
+            return
+
+        self._open_workspaces.pop(run_id, None)
         try:
             await self._manager.close(run_id)
         except Exception:

{flowjet-2.1.0 → flowjet-2.1.2}/src/flowjet/core/sandbox/arbox.py

@@ -26,12 +26,10 @@ def _import_arcbox() -> Any:
         import arcbox  # type: ignore[import-not-found]
     except ImportError as exc:  # pragma: no cover - environment-dependent
         raise RuntimeError(
-            "sandbox.enabled=true in nano.yml requires the external arcbox SDK "
-            "(pip install arcbox, already part of the flowjet `server` extra) "
-            "and the arcbox daemon running on the host (arcbox serve). The "
-            "daemon manages microVMs via Hypervisor.framework (macOS) or KVM "
-            "(Linux). Remove the sandbox: section or set sandbox.enabled=false "
-            "to run tools host-side."
+            "sandbox.enabled=true in nano.yml requires the arcbox SDK, which ships "
+            "transitively via soothe-nano (a dependency of soothe). Reinstall flowjet "
+            "or run `arcbox serve` on the host. Remove the sandbox: section or set "
+            "sandbox.enabled=false to run tools host-side."
         ) from exc
     return arcbox
 
@@ -118,12 +116,18 @@ class WorkspaceStager:
     ) -> dict[str, tuple[int, int]]:
         """Download the guest workspace tree back to the host (skip identical).
 
-        Returns the manifest for the next push.
+        Deletion propagation (RFC-RD-607 §4.4): files the agent deleted inside
+        the guest are absent from its tree and are removed from the host too.
+        Only paths recorded in the push manifest are eligible — host files
+        created after the push are never in it, so they can never be deleted
+        by this path. Returns the manifest for the next push.
         """
         root = Path(workspace)
         guest_root = PurePosixPath(self._settings.workspace_root)
         pulled = 0
+        deleted = 0
         next_manifest: dict[str, tuple[int, int]] = {}
+        guest_files: set[str] = set()
 
         async def walk(guest_dir: PurePosixPath, rel_dir: PurePosixPath) -> None:
             nonlocal pulled
@@ -144,6 +148,7 @@ class WorkspaceStager:
                     continue
                 if entry.kind != "file":
                     continue
+                guest_files.add(rel_entry.as_posix())
                 data = await sandbox.files.read_bytes(guest_path)
                 dest = root / Path(*rel_entry.parts)
                 if dest.is_file():
@@ -159,8 +164,34 @@ class WorkspaceStager:
                 pulled += 1
 
         await walk(guest_root, PurePosixPath("."))
-        if pulled:
-            logger.info("Sandbox pull for %s: %d files", workspace, pulled)
+        for rel in manifest:
+            if rel in guest_files:
+                continue
+            dest = root / Path(*PurePosixPath(rel).parts)
+            if not dest.is_file() or dest.is_symlink():
+                continue
+            try:
+                await asyncio.to_thread(dest.unlink)
+            except OSError:
+                logger.warning("Sandbox pull: host delete failed for %s in %s", rel, workspace)
+                continue
+            deleted += 1
+            parent = dest.parent
+            while parent != root and parent.is_relative_to(root):
+                if any(parent.iterdir()):
+                    break
+                try:
+                    parent.rmdir()
+                except OSError:
+                    break
+                parent = parent.parent
+        if pulled or deleted:
+            logger.info(
+                "Sandbox pull for %s: %d files pulled, %d guest deletions propagated",
+                workspace,
+                pulled,
+                deleted,
+            )
         return next_manifest
 
 

{flowjet-2.1.0 → flowjet-2.1.2}/src/flowjet/server/acp/agent.py

@@ -462,6 +462,24 @@ class FlowJetAcpAgent:
                             session_id,
                             update_agent_thought_text(event.message or "Waiting for input"),
                         )
+                        # Surface the ask_user questions as message chunks, not
+                        # just a thought: hosts accumulate message chunks as the
+                        # turn's reply, so a clarification turn would otherwise
+                        # end with no content at all (thoughts are intermediate
+                        # narration). The CLI renders the same block.
+                        if event.questions:
+                            from flowjet.cli.stream import format_questions_block
+
+                            block = format_questions_block(
+                                event.questions,
+                                session_id,
+                                resume_hint="",
+                            )
+                            await client.session_update(
+                                session_id,
+                                update_agent_message_text(block),
+                            )
+                            output_text += block
                 elif isinstance(event, RunCompleted):
                     output_text = event.output_text or output_text
                     usage_info = event.usage