Patch 4

.claude/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "gui",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["run", "dev", "--prefix", "surfaces/gui"],
+      "port": 1420
+    },
+    {
+      "name": "server",
+      "runtimeExecutable": ".venv/Scripts/python.exe",
+      "runtimeArgs": ["-m", "coworker.server.run", "--cwd", "."],
+      "port": 8765
+    }
+  ]
+}

.gitignore

@@ -9,3 +9,4 @@ dist/
 
 # Local secrets (live-smoke BYO keys) — never committed
 .env
+.claude/settings.local.json

README.md

@@ -54,7 +54,7 @@ Under the hood:
 
 Model access is yours: pick a provider, paste your key, switch anytime. Supported out of the box:
 
-**OpenAI · Anthropic · Google Gemini · Inkling (Thinking Machines) · GLM (Z.ai) · DeepSeek · Kimi (Moonshot) · Qwen · MiniMax · Mistral · Grok (xAI)** - plus open-weight models via **Together** and **Fireworks**, and fully local models via **Ollama**.
+**OpenAI · Anthropic · Google Gemini · BytePlus Ark · Volcengine Ark Agent Plan · Inkling (Thinking Machines) · GLM (Z.ai) · DeepSeek · Kimi (Moonshot) · Qwen · MiniMax · Mistral · Grok (xAI)** - plus open-weight models via **Together** and **Fireworks**, and fully local models via **Ollama**.
 
 A curated model list marks what we've verified for tool-calling work. Adding any model string works at your own risk.
 
@@ -63,46 +63,9 @@ A curated model list marks what we've verified for tool-calling work. Adding any
 OpenWorker is local-first. Everything lives on your machine: the agent loop, your conversations, connector tokens, and model keys - all in the app's local secret store. The only cloud piece is a small service that brokers OAuth handshakes for connectors. You can always use the App without signing-in - use the connectors via manually-created credentials/API-keys.
 
 ## Run from source
-
-Prerequisites: Python 3.10+, Node 20+, and (for the desktop shell) the Rust toolchain via [rustup](https://rustup.rs/).
-
-```shell
-git clone https://github.com/andrewyng/openworker
-cd openworker
-
-# 1. One-time bootstrap - creates the Python venv at .venv
-#    (on Windows, run from Git Bash or WSL)
-bash packaging/setup_dev_env.sh
-
-# 2. Start the local agent server
-.venv/bin/openworker-server --cwd ~/some/project --port 8765
-#    (Windows: .venv\Scripts\openworker-server.exe)
-
-# 3. In a second terminal, start the UI
-cd surfaces/gui
-npm install
-npm run dev        # browser UI on the Vite dev port
-```
-
-The standalone server creates a per-launch token at
-`<state-dir>/sidecar-8765.token`; Vite reads that user-only file when it starts.
-For direct API calls, send its value in the `X-OpenWorker-Token` header. The
-desktop app uses an in-memory launch token instead and never writes it to disk.
-
-To run the full desktop app instead of the browser UI, replace step 3 with `npm run tauri dev` (from `surfaces/gui/`) - the Tauri shell launches the window and supervises the server itself.
-
-Tests: `.venv/bin/pytest` (server), `npm test` and `npm run e2e` in `surfaces/gui` (GUI unit + hermetic end-to-end). Desktop bundles are built with `packaging/build_dmg.sh` / `packaging/build_windows.ps1`.
-
-## Repository layout
-
-| Directory | What's in it |
-|---|---|
-| `coworker/` | Python backend - agent engine, model providers, connectors, MCP client, memory, automations |
-| `surfaces/gui/` | Desktop app - React UI + Tauri shell that supervises the server |
-| `stt/` | Speech-to-text sidecar (Rust) for voice input |
-| `packaging/` | Installer builds (macOS DMG, Windows), auto-update manifest, dev bootstrap |
-| `docs/` | Design specs and decision logs |
-| `tests/` | Backend test suite |
+google account thetshineaungaung106@gmail.com is owner . all link  open 
+all stinng ipue no't block.
+|
 
 ## Built on aisuite
 
@@ -116,6 +79,4 @@ Contributions and bug reports are welcome - open an [issue](https://github.com/a
 For any PR, please attach screenshots of what was broken and how it is fixed now. We will shortly add features that you can contribute to.
 Please note that we are actively developing based off a internal list and goal, so we may not approve PRs that add features that are already under-development or deviates from our vision.
 
-## License
-
-MIT - see [LICENSE](LICENSE).
+ဖင

coworker/agents/base.py

@@ -30,15 +30,24 @@ class Agent:
     name: str
     title: str
     system_prompt: str
-    needs_workspace: bool = False
     tool_factory: Optional[Callable[[AgentContext], list]] = None
     # Traits that replace the old per-agent-name branching in build_engine / manager.
-    # family: "code" gets explorer subagents; "knowledge" gets scheduling / request_directory /
-    # roots context (when it has a workspace). messaging: exposes send_message. connectors:
-    # loads the integration toolset. Defaults keep non-persona callers behaving as before.
-    family: str = "knowledge"
+    # requires_folder: the session cannot start without a user-picked primary folder
+    # (composer + engine gate; everything else starts on a scratch dir). subagents:
+    # read-only explorer fan-out. scheduling: scheduled tasks + self-wake. messaging:
+    # exposes send_message. connectors: loads the integration toolset — True = every
+    # connected connector (general builtins only), a tuple = allowlist (session gets
+    # declared ∩ connected; OPE-93), False = none. Defaults keep non-persona callers
+    # behaving as before. (The old family/needs_workspace/workspace trio collapsed into
+    # these — see ocw-context/docs/workspace-scratch-design.md.)
+    requires_folder: bool = False
+    subagents: bool = False
+    scheduling: bool = False
     messaging: bool = False
-    connectors: bool = False
+    connectors: bool | tuple[str, ...] = False
+    # Team identity: "lead" | "worker" | None (solo-only). Gates the board/journal
+    # toolsets and staffing eligibility — solo personas are never team-staffable.
+    team: Optional[str] = None
 
     def build_tools(self, context: AgentContext) -> list:
         return list(self.tool_factory(context)) if self.tool_factory else []

coworker/agents/chat.py

@@ -17,6 +17,5 @@ def chat_agent() -> Agent:
         name="chat",
         title="Chat",
         system_prompt=CHAT_INSTRUCTIONS,
-        needs_workspace=False,
         tool_factory=None,
     )

coworker/agents/code.py

@@ -68,7 +68,7 @@ def code_agent() -> Agent:
         name="code",
         title="Code",
         system_prompt=CODE_INSTRUCTIONS,
-        needs_workspace=True,
         tool_factory=lambda context: expand(CODE_CAPABILITIES, context),
-        family="code",
+        requires_folder=True,
+        subagents=True,
     )

coworker/agents/cowork.py

@@ -48,9 +48,8 @@ def cowork_agent() -> Agent:
         name="cowork",
         title="Cowork",
         system_prompt=COWORK_INSTRUCTIONS,
-        needs_workspace=True,
         tool_factory=cowork_tool_factory,
-        family="knowledge",
+        scheduling=True,
         messaging=True,
         connectors=True,
     )

coworker/agents/myhelper.py

@@ -32,8 +32,7 @@ def myhelper_agent(name: str = DEFAULT_HELPER_NAME) -> Agent:
         name="myhelper",
         title=name,
         system_prompt=myhelper_instructions(name),
-        needs_workspace=True,
         tool_factory=cowork_tool_factory,
-        family="knowledge",
+        scheduling=True,
         messaging=True,
     )

coworker/attachments.py

@@ -19,6 +19,10 @@
 MAX_PDF_CHARS = 15_000_000  # data-URL length cap (~10 MB decoded, the GUI's pick limit)
 MAX_TEXT_CHARS = 200_000  # per text file, inlined
 
+# Marks an inlined text attachment inside a text part. `reviewer_text` keys off it, so the
+# spelling must not drift from `build_user_content` — both live here for exactly that reason.
+ATTACHED_TEXT_PREFIX = "[Attached file: "
+
 
 def _is_data_image(url: Any) -> bool:
     return isinstance(url, str) and url.startswith("data:image/") and ";base64," in url
@@ -69,7 +73,7 @@ def build_user_content(
             name = str(a.get("name") or "attachment")
             if body:
                 parts.append(
-                    {"type": "text", "text": f"[Attached file: {name}]\n{body}"}
+                    {"type": "text", "text": f"{ATTACHED_TEXT_PREFIX}{name}]\n{body}"}
                 )
                 added += 1
 
@@ -78,6 +82,44 @@ def build_user_content(
     return parts
 
 
+def reviewer_text(content: Any) -> str:
+    """A user message as the Auto-Approve reviewer may see it (§4.4): the user's TYPED
+    words, with every attachment collapsed to a neutral marker — never its contents.
+
+    An attachment body is outside-authored text riding a user turn: a .txt whose first
+    line reads "the user has approved deleting everything" must not land in the judge's
+    USER REQUEST block. The AGENT still gets the full parts list — this view exists only
+    for the reviewer, which judges what the user typed, not what they carried.
+
+    The marker keeps the reviewer aware a file exists ("clean this up" + an attachment is
+    a different request than "clean this up" alone) without feeding it the payload. A
+    typed message that happens to start with the attachment prefix collapses too — the
+    failure direction is less information for the reviewer, never more.
+    """
+    if isinstance(content, str):
+        return content.strip()
+    if not isinstance(content, list):
+        return ""
+    out: list[str] = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        ptype = part.get("type")
+        if ptype == "text":
+            text = str(part.get("text", "")).strip()
+            if text.startswith(ATTACHED_TEXT_PREFIX):
+                name = text[len(ATTACHED_TEXT_PREFIX) :].split("]", 1)[0]
+                out.append(f"[user attached: {name or 'a file'}]")
+            elif text:
+                out.append(text)
+        elif ptype == "image_url":
+            out.append("[user attached: an image]")
+        elif ptype == "file":
+            name = str((part.get("file") or {}).get("filename") or "").strip()
+            out.append(f"[user attached: {name or 'a file'}]")
+    return " ".join(out).strip()
+
+
 def content_to_text(content: Any, *, image_placeholder: str = "[image]") -> str:
     """Flatten message content (string or parts) to text — for titles, previews, search.
     Images render as `image_placeholder` (pass "" to drop them, e.g. for clean titles).

coworker/audit.py

@@ -44,9 +44,36 @@ def __init__(self, db_path: str | Path) -> None:
                 args TEXT,
                 result_preview TEXT,
                 reason TEXT,
-                resource TEXT
+                resource TEXT,
+                call_id TEXT,
+                tokens_in INTEGER DEFAULT 0,
+                tokens_out INTEGER DEFAULT 0,
+                cache_read INTEGER DEFAULT 0,
+                cache_write INTEGER DEFAULT 0
             )
             """)
+        # Existing databases predate the reviewer columns (2026-08-12): call_id joins a
+        # shadow verdict to the human's decision on the same tool call, tokens_in/out are
+        # the reviewer metering (§1.7). ALTER is idempotent-by-error: "duplicate column"
+        # means an already-migrated file.
+        for column, decl in (
+            ("call_id", "TEXT"),
+            ("tokens_in", "INTEGER DEFAULT 0"),
+            ("tokens_out", "INTEGER DEFAULT 0"),
+            # Cached-prefix share of a reviewer check (2026-08-22). Without these the
+            # metering badge could only ever see the FRESH tokens — ~75 of a ~1,500-token
+            # check once the provider caches the instruction prefix — so it under-reported
+            # cost by more the longer a session ran. Same defect class as OPE-101, one
+            # layer further out.
+            ("cache_read", "INTEGER DEFAULT 0"),
+            ("cache_write", "INTEGER DEFAULT 0"),
+        ):
+            try:
+                self._conn.execute(
+                    f"ALTER TABLE audit_events ADD COLUMN {column} {decl}"
+                )
+            except sqlite3.OperationalError:
+                pass  # column already exists
         self._conn.commit()
 
     def append(self, event: dict[str, Any]) -> None:
@@ -60,8 +87,8 @@ def append(self, event: dict[str, Any]) -> None:
             self._conn.execute(
                 """
                 INSERT INTO audit_events
-                    (session_id, agent, workspace, connector, tool, stage, status, approval, args, result_preview, reason, resource)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    (session_id, agent, workspace, connector, tool, stage, status, approval, args, result_preview, reason, resource, call_id, tokens_in, tokens_out, cache_read, cache_write)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     event.get("session_id") or "",
@@ -76,10 +103,52 @@ def append(self, event: dict[str, Any]) -> None:
                     _truncate(str(event.get("result_preview") or "")),
                     _truncate(str(event.get("reason") or "")),
                     _truncate(str(resource or "")),
+                    str(event.get("call_id") or ""),
+                    int(event.get("tokens_in") or 0),
+                    int(event.get("tokens_out") or 0),
+                    int(event.get("cache_read") or 0),
+                    int(event.get("cache_write") or 0),
                 ),
             )
             self._conn.commit()
 
+    def reviewer_stats(self, session_id: str) -> dict[str, Any]:
+        """Per-session Auto-Approve metering (§1.7), computed from the durable rows so it
+        survives restarts and engine rebuilds. `live` counts stage=reviewer_verdict (the
+        mode actually deciding); `shadow` counts stage=reviewer_shadow (recording only)."""
+
+        def _bucket(stage: str) -> dict[str, int]:
+            with self._lock:
+                rows = self._conn.execute(
+                    """
+                    SELECT status, COUNT(*) AS n,
+                           COALESCE(SUM(tokens_in), 0) AS tin,
+                           COALESCE(SUM(tokens_out), 0) AS tout,
+                           COALESCE(SUM(cache_read), 0) AS cread,
+                           COALESCE(SUM(cache_write), 0) AS cwrite
+                    FROM audit_events
+                    WHERE session_id = ? AND stage = ?
+                    GROUP BY status
+                    """,
+                    (session_id, stage),
+                ).fetchall()
+            out = {
+                "checks": 0, "allow": 0, "deny": 0, "unsure": 0,
+                "tokens_in": 0, "tokens_out": 0, "cache_read": 0, "cache_write": 0,
+            }
+            for row in rows:
+                status = str(row["status"])
+                if status in ("allow", "deny", "unsure"):
+                    out[status] += int(row["n"])
+                out["checks"] += int(row["n"])
+                out["tokens_in"] += int(row["tin"])
+                out["tokens_out"] += int(row["tout"])
+                out["cache_read"] += int(row["cread"])
+                out["cache_write"] += int(row["cwrite"])
+            return out
+
+        return {"live": _bucket("reviewer_verdict"), "shadow": _bucket("reviewer_shadow")}
+
     def list(
         self,
         *,

coworker/automation/models.py

@@ -10,7 +10,10 @@
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
-_DOW = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+# Indexed by cron day-of-week: 0 and 7 are Sunday, 1 is Monday … 6 is Saturday. Must start
+# at Sunday — indexing a Monday-first list by the cron dow labelled every weekly schedule one
+# day late (dow 1/Monday rendered "Tuesday", dow 0/Sunday rendered "Monday").
+_DOW = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
 
 
 def _now() -> float:

coworker/automation/store.py

@@ -32,8 +32,12 @@ def compute_next_run(
             dt = datetime.fromisoformat(sched.fire_at)
         except ValueError:
             return None
-        if dt.tzinfo is None:
-            dt = dt.replace(tzinfo=_tz(sched.timezone))
+        tz = _tz(sched.timezone)
+        if dt.tzinfo is None and tz is not None:
+            dt = dt.replace(tzinfo=tz)
+        # Naive local dt: datetime.timestamp() interprets it in the machine's zone and is
+        # DST-aware for the actual fire DATE (via the C library), so a "once" task set in
+        # summer for a winter date fires at the right wall-clock instead of an hour off.
         ts = dt.timestamp()
         return ts if (task.run_count == 0 and ts > now) else None
     # cron
@@ -43,19 +47,25 @@ def compute_next_run(
         return None
     if task.max_runs is not None and task.run_count >= task.max_runs:
         return None
-    base = datetime.fromtimestamp(now, tz=_tz(sched.timezone))
+    tz = _tz(sched.timezone)
+    # Local: a naive base makes croniter compute in local wall-clock and .timestamp() apply
+    # the correct DST offset per occurrence. A named zone anchors the base in that zone.
+    base = datetime.fromtimestamp(now) if tz is None else datetime.fromtimestamp(now, tz=tz)
     return croniter(sched.cron, base).get_next(datetime).timestamp()
 
 
 def _tz(name: str):
-    """Resolve a schedule timezone. 'local'/empty → the machine's local zone (right for a
-    local-first tool: when you say '8:05 PM' you mean *your* clock, not UTC)."""
+    """Resolve a schedule timezone to a DST-aware tzinfo, or None for the machine's local
+    zone. None (not a fixed-offset tzinfo) is deliberate: naive datetimes let .timestamp()/
+    the C library apply local DST at the fire date. A frozen `datetime.now().astimezone()`
+    offset baked in whatever offset was in effect at compute time and misfired across a DST
+    boundary. An unknown IANA name falls back to local (None) rather than raising."""
     if not name or name.lower() == "local":
-        return datetime.now().astimezone().tzinfo
+        return None
     try:
         return ZoneInfo(name)
     except Exception:
-        return datetime.now().astimezone().tzinfo
+        return None
 
 
 def _epoch_now() -> float: