netizen-cli 0.14.1__tar.gz → 0.14.2__tar.gz

{netizen_cli-0.14.1/netizen_cli.egg-info → netizen_cli-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netizen-cli
-Version: 0.14.1
+Version: 0.14.2
 Summary: Use native Codex threads through a Feishu Channel.
 Requires-Python: <3.15,>=3.11
 Requires-Dist: h11==0.16.0

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/__init__.py

@@ -1,3 +1,3 @@
 """Netizen: a thin Feishu Channel for native Codex Threads."""
 
-__version__ = "0.14.1"
+__version__ = "0.14.2"

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/admin/static/admin.js

@@ -3392,6 +3392,8 @@ function renderScheduleTarget() {
   scheduleInput("chat-target").hidden = binding;
   if (binding) { scheduleInput("chat").required = false; chatTarget("schedule").close(); }
   scheduleInput("session-settings").hidden = binding;
+  scheduleInput("auto-archive-field").hidden = binding;
+  scheduleInput("auto-archive").disabled = binding;
   renderScheduleWorkspace();
   const target = editor.targetSession;
   const selected = editor.plan?.target_binding_id || target?.bindingId || "";
@@ -3445,6 +3447,7 @@ function scheduleEditorValues() {
     .filter((input) => input.checked).map((input) => input.value);
   return { name: scheduleInput("name").value, instructions: scheduleInput("instructions").value,
     enabled: scheduleInput("enabled").checked, targetKind: scheduleTargetKind(),
+    autoArchive: binding ? null : scheduleInput("auto-archive").checked,
     binding: binding ? scheduleInput("binding").value : "",
     project: binding ? "" : scheduleInput("project").value,
     chat: binding ? "" : scheduleInput("chat").value, rule,
@@ -3458,7 +3461,7 @@ function scheduleEditorHasChanges() {
 }
 
 function captureScheduleDraft() {
-  const fields = ["name", "instructions", "enabled", "kind", "timezone", "time", "at", "offset", "end-at", "end-offset", "every"];
+  const fields = ["name", "instructions", "enabled", "auto-archive", "kind", "timezone", "time", "at", "offset", "end-at", "end-offset", "every"];
   return {
     discardBase: structuredClone(scheduleEditor.discardBase), dirty: scheduleEditorHasChanges(),
     fields: fields.map((id) => ({ id, value: scheduleInput(id).value, checked: scheduleInput(id).checked })),
@@ -3963,6 +3966,7 @@ function openScheduleEditor(plan = null, source = {}) {
   chatTarget("schedule", changeScheduleChat).set({ chatId: plan?.chat_id, chat: plan?.chat });
   scheduleInput("instructions").value = plan?.instructions || "";
   scheduleInput("enabled").checked = plan?.enabled ?? true;
+  scheduleInput("auto-archive").checked = plan?.auto_archive ?? false;
   scheduleInput("timezone").value = rule.timezone;
   scheduleInput("kind").value = rule.kind;
   scheduleInput("time").value = ["daily", "weekly"].includes(rule.kind) ? rule.at : "09:00";
@@ -4051,6 +4055,7 @@ async function saveSchedule(event) {
   } else {
     definition.project = scheduleInput("project").value.trim();
     definition.chat_id = scheduleInput("chat").value.trim();
+    definition.auto_archive = scheduleInput("auto-archive").checked;
     if (scheduleWorkspaceChanged()) {
       definition.workspace = structuredClone(editor.workspace);
       if (editor.workspaceOptions?.projectAlias === definition.project) {
@@ -4324,6 +4329,9 @@ async function showSchedule(planId, returnFocus = document.activeElement) {
       : scheduleSessionSummary(data.plan.session_settings || defaultScheduleSessionSettings());
     scheduleInput("detail-settings").textContent += ` · ${data.plan.target_kind === "binding"
       ? scheduleInheritedWorkspace(data.plan) : workspacePolicySummary(data.plan.workspace, { scheduled: true })}`;
+    if (data.plan.target_kind !== "binding") {
+      scheduleInput("detail-settings").textContent += ` · 成功后自动归档：${data.plan.auto_archive ? "开启" : "关闭"}`;
+    }
     scheduleInput("detail-rule").textContent = scheduleRuleLabel(data.plan.schedule);
     renderSchedulePreview("#schedule-detail-preview", data.preview);
     scheduleInput("detail-note").textContent = "";

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/admin/static/index.html

@@ -466,6 +466,10 @@
                 </div>
               </div>
             </section>
+            <section id="schedule-auto-archive-field" class="schedule-editor-section">
+              <label class="schedule-checkbox"><input id="schedule-auto-archive" type="checkbox" aria-describedby="schedule-auto-archive-help">成功后自动归档</label>
+              <p id="schedule-auto-archive-help" class="schedule-field-help">首轮正常结束且结果送达后归档，恢复使用 /sessions archived。</p>
+            </section>
             <details id="schedule-session-settings" class="schedule-editor-section schedule-session-settings" open>
               <summary>会话配置<span id="schedule-session-summary">继承 Codex · 当前消息</span></summary>
               <div class="schedule-section-fields">

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/admin/web.py

@@ -986,7 +986,7 @@ class AdminWebApplication:
         )
         definition = payload.get("definition", {})
         if not isinstance(definition, dict) or set(definition) - {
-            "name", "instructions", "project", "expected_project_revision", "chat_id", "schedule", "enabled", "session_settings", "workspace", "target_kind", "target_binding_id",
+            "name", "instructions", "project", "expected_project_revision", "chat_id", "schedule", "enabled", "session_settings", "workspace", "target_kind", "target_binding_id", "auto_archive",
         }:
             raise AdminWebError(400, "invalid_input", "定时任务定义字段无效。")
         request: dict[str, object] = {

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/bindings.py

@@ -40,7 +40,7 @@ from .worktrees.models import WorktreeRecord
 from .worktrees.store import WorktreeStore, create_schema as create_worktree_schema
 
 
-SCHEMA_VERSION = 19
+SCHEMA_VERSION = 20
 
 # Includes the running query and all submitted queries waiting for the reader.
 _ADMIN_QUERY_CAPACITY = 32
@@ -467,7 +467,7 @@ def _require_current_schema(connection: sqlite3.Connection) -> None:
     _require_project_metadata_schema(connection)
     require_schema(connection)
     require_defaults_schema(connection)
-    from .migrations.v19 import validate
+    from .migrations.v20 import validate
     validate(connection)
 
 

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/cards/scheduled.py

@@ -385,6 +385,7 @@ def _plan_summary(plan: Mapping[str, Any]) -> str:
         + ("工作目录：" if plan.get("target_kind") == "binding" else "worktree 使用方式：")
         + workspace_summary(None if plan.get("target_kind") == "binding"
             else plan.get("workspace", {"mode": "project"}), new_label="每次执行新建 worktree") + "\n"
+        + ("" if plan.get("target_kind") == "binding" else f"成功后自动归档：{'开启' if plan.get('auto_archive') else '关闭'}\n")
         + f"启停：{'已启用' if plan.get('enabled') else '已暂停'}\n"
         + f"时间：{rule_text} · {rule.get('timezone', '')}\n"
         f"状态：{status}" + (f" · {_display_state(blocked)}" if blocked else "")
@@ -492,9 +493,12 @@ def _input(name: str, label: str, value: str = "", *, required: bool = True, mul
 
 def _select(name: str, label: str, options: Sequence[tuple[str, str]], selected: str | None = None) -> dict[str, Any]:
     result: dict[str, Any] = {"tag": "select_static", "name": name, "required": True,
-        "width": "fill", "placeholder": _plain_text(label), "options": [{"text": _plain_text(text), "value": value} for value, text in options]}
+        "width": "fill", "options": [{"text": _plain_text(text), "value": value} for value, text in options]}
     if selected is not None:
+        # Invisible placeholders still consume Feishu's card element budget.
         result["initial_option"] = selected
+    else:
+        result["placeholder"] = _plain_text(label)
     return result
 
 
@@ -573,6 +577,7 @@ def schedule_form_card(scope: FeishuScope, *, projects: Sequence[Project], defau
         meta["target_workspace_description"] = _binding_workspace_summary(
             existing.get("effective_workspace") or effective_workspace)
     else:
+        fields["cron_auto_archive"] = "true" if existing.get("auto_archive", False) else "false"
         meta["project"] = existing.get("project_alias") or initial_project or projects[0].alias
         project = next((project for project in projects if project.alias == meta["project"]), None)
         meta["project_revision"] = project.revision if project is not None and project.revision > 0 else None
@@ -661,7 +666,7 @@ def _render_schedule_draft_card(draft: ScheduleFormDraft, *, projects: Sequence[
         _form_columns(
             (1, _labeled("截止日期", _draft_picker("cron_end_date", "date_picker", fields.get("cron_end_date", "")))),
             (1, _labeled("截止时间（含该时刻）", _draft_picker(end_time_name, "picker_time", fields.get("cron_end_time", ""))))),
-        _form_hint("截止日期与时间使用上方时区；同时留空可取消截止。"),
+        _form_hint("截止日期与时间使用上方时区；同时留空可取消截止。\n只使用所选频率对应的日期、时间、星期或间隔；日期与时间以所填时区为准。"),
     ]
     project_meta = {key: value for key, value in meta.items()
         if key not in {"plan_id", "expected_revision", "anchor", "original_at", "original_end_at"}}
@@ -694,7 +699,10 @@ def _render_schedule_draft_card(draft: ScheduleFormDraft, *, projects: Sequence[
             new_label="每次执行新建 worktree",
             footer="已有 worktree 由各次执行共享文件；不可用时不新建话题，不切回项目目录。已生成 worktree 需在 Admin 显式管理。",
         )))
-    elements.append(_form_hint("只使用所选频率对应的日期、时间、星期或间隔；日期与时间以所填时区为准。"))
+        if "cron_auto_archive" in fields:
+            elements.extend(_labeled("成功后自动归档\n<font color='grey'>首轮正常结束且结果送达后归档，恢复使用 /sessions archived。</font>",
+                _select("cron_auto_archive", "成功后自动归档",
+                [("false", "关闭"), ("true", "开启")], fields["cron_auto_archive"])))
     elements.append({"tag": "button", "name": "cron_save", "text": _plain_text("保存修改" if editing else "创建任务"),
         "type": "primary_filled", "width": "fill", "form_action_type": "submit"})
     if not binding_target:
@@ -884,7 +892,7 @@ def read_schedule_form(scope: FeishuScope, form: Mapping[str, Any]) -> ScheduleF
     allowed = {"cron_name", "cron_instructions", "cron_project", "cron_timezone", "cron_kind",
         "cron_every_minutes", "cron_at", "cron_date", "cron_weekdays", "cron_end_date", "cron_end_time"}
     if not binding_target:
-        allowed.update({"cron_target_mode", "cron_group_id", "cron_chat_id", "cron_chat_query", "cron_chat_page"})
+        allowed.update({"cron_target_mode", "cron_group_id", "cron_chat_id", "cron_chat_query", "cron_chat_page", "cron_auto_archive"})
     for key, value in form.items():
         if not isinstance(key, str):
             raise CardActionError("表单字段格式无效，无法恢复。")
@@ -934,6 +942,8 @@ def read_schedule_form(scope: FeishuScope, form: Mapping[str, Any]) -> ScheduleF
             elif value and base in {"cron_at", "cron_end_time"}:
                 value = _picker_clock(value)
         fields[base] = value
+    if "cron_auto_archive" in fields:
+        _decode_auto_archive(fields["cron_auto_archive"])
     if not {"cron_name", "cron_instructions", "cron_project", "cron_timezone", "cron_kind"} <= fields.keys():
         raise CardActionError("定时任务表单缺少字段。")
     if fields["cron_kind"] not in _KINDS:
@@ -1063,7 +1073,7 @@ def _decode_form(scope: FeishuScope, form: Any, *, value: Any = None) -> Schedul
         expected.add("cron_target_mode")
     optional = {"cron_every_minutes", "cron_at", "cron_date", "cron_weekdays", "cron_end_date", "cron_end_time"}
     if not binding_target:
-        optional.update({"cron_group_id", "cron_chat_id", "cron_chat_query", "cron_chat_page"})
+        optional.update({"cron_group_id", "cron_chat_id", "cron_chat_query", "cron_chat_page", "cron_auto_archive"})
     if not expected <= set(form) or set(form) - expected - optional:
         raise CardActionError("定时任务表单缺少字段或混入其他操作。")
     rule: dict[str, Any] = {"kind": kind, "timezone": _text(form["cron_timezone"], "时区")}
@@ -1095,6 +1105,8 @@ def _decode_form(scope: FeishuScope, form: Any, *, value: Any = None) -> Schedul
     else:
         assert settings is not None
         draft.update(project=meta["project"], session_settings=settings.to_dict())
+        if "cron_auto_archive" in form:
+            draft["auto_archive"] = _decode_auto_archive(form["cron_auto_archive"])
         if workspace_fields:
             draft["workspace"] = decode_workspace_form(workspace_fields, prefix="cron",
                 project=meta["project"], revision=meta.get("project_revision"))
@@ -1111,6 +1123,12 @@ def _decode_form(scope: FeishuScope, form: Any, *, value: Any = None) -> Schedul
     return ScheduleCardAction("save", draft, meta["request_id"], meta["navigation"])
 
 
+def _decode_auto_archive(value: Any) -> bool:
+    if not isinstance(value, str) or value not in {"false", "true"}:
+        raise CardActionError("成功后自动归档选项无效，请重新选择。")
+    return value == "true"
+
+
 def schedule_retry_card(*, app_id: str, chat_id: str, value: Any, form: Any,
                         notice: str, projects: Sequence[Project],
                         scope: FeishuScope | None = None,

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/channel_app.py

@@ -586,6 +586,12 @@ class _SentMessage:
     parent_id: str | None
 
 
+@dataclass(slots=True)
+class _ScheduledCompletion:
+    partial_answers_confirmed: bool = True
+    delivery_state: str | None = None
+
+
 class ChannelApplication:
     def __init__(
         self,
@@ -616,9 +622,9 @@ class ChannelApplication:
         self._management.enable_schedules(app_id=app_id, chat_info=channel)
         self._management.enable_defaults(app_id=app_id, chat_info=channel)
         self._scope_coordinator = management.scope_coordinator
-        # Whether earlier standalone answers in this completion were confirmed.
-        # Only the final send writes the aggregate Scheduled Run receipt.
-        self._scheduled_completions: dict[str, bool] = {}
+        # Only the final send writes the aggregate Scheduled Run receipt. Keep
+        # this completion's receipt through pruning of the persisted Run.
+        self._scheduled_completions: dict[str, _ScheduledCompletion] = {}
         self._reactions = _ReactionController(channel)
         self._progress_cards = _ReplyCardPresenter(channel, runtime)
         runtime.set_completion_handler(self.handle_completion)
@@ -1014,7 +1020,8 @@ class ChannelApplication:
             assert origin_message.thread_id is not None
             scope = FeishuScope(self._app_id, run.chat_id, ScopeKind.TOPIC, origin_message.thread_id)
             origin = ScheduledOrigin(self._app_id, run.chat_id, origin_message.message_id,
-                                     ScheduledConversation(origin_message.thread_id), plan.id, run.id)
+                                     ScheduledConversation(origin_message.thread_id), plan.id, run.id,
+                                     auto_archive=plan.auto_archive)
             store.set_run(run.id, topic_id=scope.topic_id, origin_message_id=origin_message.message_id)
             context_anchor = (
                 await self._resolve_context_anchor(scope, origin_message.message_id)
@@ -1517,7 +1524,13 @@ class ChannelApplication:
         except Exception:
             logger.warning("scheduled result card destination was not confirmed", extra={"run_id": origin.run_id})
         finally:
-            self._bindings.schedules.set_run(origin.run_id, delivery_state=state)
+            self._record_scheduled_delivery(origin, state)
+
+    def _record_scheduled_delivery(self, origin: ScheduledOrigin, state: str) -> None:
+        self._bindings.schedules.set_run(origin.run_id, delivery_state=state)
+        completion = self._scheduled_completions.get(origin.run_id)
+        if completion is not None:
+            completion.delivery_state = state
 
     async def _scheduled_reply_confirmed(self, message: ScheduledOrigin, result: object) -> bool:
 
@@ -1556,17 +1569,17 @@ class ChannelApplication:
                     raw = _object_field(result, "raw")
                     data = _object_field(raw, "data")
                     if await self._scheduled_reply_confirmed(message, result):
-                        state = "sent" if self._scheduled_completions[message.run_id] else "unknown"
+                        state = "sent" if self._scheduled_completions[message.run_id].partial_answers_confirmed else "unknown"
                     else:
                         logger.warning("scheduled reply destination was not confirmed", extra={
                             "run_id": message.run_id,
                             "expected_topic_id": message.conversation.thread_id,
                             "returned_topic_id": _nonempty_field(data, "thread_id"),
                         })
-                self._bindings.schedules.set_run(message.run_id, delivery_state=state)
+                self._record_scheduled_delivery(message, state)
         except BaseException:
             if scheduled:
-                self._bindings.schedules.set_run(message.run_id, delivery_state="unknown")
+                self._record_scheduled_delivery(message, "unknown")
             raise
         return result
 
@@ -2205,10 +2218,17 @@ class ChannelApplication:
     ) -> None:
         origin = getattr(outcome, "origin", None)
         scheduled = isinstance(outcome, TurnOutcome) and isinstance(origin, ScheduledOrigin)
+        completion = _ScheduledCompletion()
         if scheduled:
-            self._scheduled_completions[origin.run_id] = True
+            self._scheduled_completions[origin.run_id] = completion
         try:
             await self._handle_completion(outcome)
+            if (scheduled and origin.auto_archive and outcome.error is None
+                    and outcome.status == "completed" and completion.delivery_state == "sent"):
+                # The initial submission carries the immutable claim policy.
+                # Later input deliberately does not cancel this archive intent.
+                # Recovery never replays this completion or its side effects.
+                await self._archive_scheduled_completion(outcome)
         finally:
             if scheduled:
                 self._scheduled_completions.pop(origin.run_id, None)
@@ -2221,6 +2241,23 @@ class ChannelApplication:
                 except ScheduleNotFound:
                     pass  # A completed receipt may have allowed normal pruning.
 
+    async def _archive_scheduled_completion(self, outcome: TurnOutcome) -> None:
+        origin = outcome.origin
+        assert isinstance(origin, ScheduledOrigin)
+        scope = FeishuScope(origin.app_id, origin.chat_id, ScopeKind.TOPIC,
+                            origin.conversation.thread_id)
+        try:
+            await self._management.archive_exact_binding(target=ExactBindingTarget(
+                scope.key, outcome.binding_id, expected_active_binding_id=None,
+            ))
+        except Exception as error:
+            # Native lifecycle handling owns reconciliation/uncertainty. The
+            # successful execution and delivery stay intact, without a retry.
+            logger.warning("scheduled completion archive did not finish", extra={
+                "run_id": origin.run_id, "binding_id": outcome.binding_id,
+                "error_type": type(error).__name__,
+            })
+
     async def _handle_completion(
         self,
         outcome: (
@@ -6315,7 +6352,7 @@ class ChannelApplication:
                     if unconfirmed_content is not None:
                         content = unconfirmed_content
                 if isinstance(target, ScheduledOrigin) and target.run_id in self._scheduled_completions:
-                    self._scheduled_completions[target.run_id] = confirmed
+                    self._scheduled_completions[target.run_id].partial_answers_confirmed = confirmed
                 await final_reply(content)
         except TimeoutError:
             # A timed-out post may already have published SDK chunks. Do not

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/database_migrations.py

@@ -21,6 +21,7 @@ from .migrations.v16 import apply as apply_v16, validate as validate_v16
 from .migrations.v17 import apply as apply_v17, validate as validate_v17
 from .migrations.v18 import apply as apply_v18, validate as validate_v18
 from .migrations.v19 import apply as apply_v19, validate as validate_v19
+from .migrations.v20 import apply as apply_v20, validate as validate_v20
 
 
 MIN_SUPPORTED_SCHEMA_VERSION = 14
@@ -42,6 +43,7 @@ MIGRATIONS: tuple[Migration, ...] = (
     Migration(16, 17, apply_v17, validate_v17),
     Migration(17, 18, apply_v18, validate_v18),
     Migration(18, 19, apply_v19, validate_v19),
+    Migration(19, 20, apply_v20, validate_v20),
 )
 
 

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/domain.py

@@ -85,6 +85,7 @@ class ScheduledOrigin:
     conversation: ScheduledConversation
     plan_id: str
     run_id: str
+    auto_archive: bool = False
 
     @property
     def id(self) -> str:

netizen_cli-0.14.2/netizen_cli/migrations/v20.py

@@ -0,0 +1,96 @@
+"""Frozen v19 -> v20 scheduled new-conversation auto-archive policy migration.
+
+Existing plans retain their execution behavior with the policy disabled. The
+policy belongs to the plan; Run rows retain only their existing receipts.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+
+from .schema import require_schema
+from .v16 import _require_workspace
+from .v19 import SCHEMA as V19_SCHEMA, _require_progress_card_intent, _require_session_settings
+
+
+AUTO_ARCHIVE = (
+    "auto_archive INTEGER NOT NULL DEFAULT 0 CHECK("
+    "typeof(auto_archive) = 'integer' AND auto_archive IN (0,1) "
+    "AND (auto_archive = 0 OR (target_kind = 'new_topic' AND deleted = 0)))"
+)
+SCHEMA = tuple(
+    statement.replace("target_binding_id TEXT,", f"target_binding_id TEXT, {AUTO_ARCHIVE},")
+    if statement.startswith("CREATE TABLE schedule_plans (") else statement
+    for statement in V19_SCHEMA
+)
+
+
+def apply(connection: sqlite3.Connection) -> None:
+    connection.execute(f"ALTER TABLE schedule_plans ADD COLUMN {AUTO_ARCHIVE}")
+
+
+def validate(connection: sqlite3.Connection) -> None:
+    require_schema(connection, SCHEMA)
+    if connection.execute(
+        "SELECT 1 FROM schedule_plans WHERE typeof(auto_archive) != 'integer' OR auto_archive NOT IN (0,1) "
+        "OR (auto_archive != 0 AND (target_kind != 'new_topic' OR deleted != 0)) LIMIT 1"
+    ).fetchone():
+        raise RuntimeError("schema v20 scheduling auto archive is invalid")
+    if connection.execute(
+        "SELECT 1 FROM schedule_runs WHERE (target_kind='binding' AND (binding_id IS NULL OR binding_id='')) "
+        "OR (disposition IS NOT NULL AND (target_kind!='binding' "
+        "OR initial_turn_id IS NULL OR initial_turn_id='' OR barrier!='released')) LIMIT 1"
+    ).fetchone():
+        raise RuntimeError("schema v20 scheduling input receipt is invalid")
+    if connection.execute(
+        "SELECT 1 FROM session_defaults_order WHERE app_id IS NULL OR app_id = '' "
+        "OR typeof(revision) != 'integer' OR revision < 1 LIMIT 1"
+    ).fetchone():
+        raise RuntimeError("schema v20 defaults order revision is invalid")
+    try:
+        for row in connection.execute("SELECT progress_card_settings_json FROM bindings"):
+            _require_progress_card_intent(json.loads(row["progress_card_settings_json"]))
+        for row in connection.execute("SELECT deleted, session_settings_json, workspace_json, target_kind, target_binding_id FROM schedule_plans"):
+            if (row["target_kind"] == "binding") != bool(row["target_binding_id"]):
+                raise ValueError("invalid scheduling target identity")
+            if row["target_kind"] == "binding" or row["deleted"]:
+                if row["session_settings_json"] is not None or row["workspace_json"] is not None:
+                    raise ValueError("unexpected scheduling session settings or workspace policy")
+            else:
+                _require_session_settings(row["session_settings_json"])
+                _require_workspace(row["workspace_json"])
+        positions: dict[str, list[int]] = {}
+        for row in connection.execute("SELECT * FROM session_defaults ORDER BY app_id, position"):
+            if not all(isinstance(row[key], str) and row[key] for key in ("id", "app_id", "project")):
+                raise ValueError("missing default identity")
+            _require_session_settings(row["session_settings_json"])
+            _require_workspace(row["workspace_json"])
+            if row["kind"] == "group_name":
+                if row["keyword"] != row["keyword"].strip():
+                    raise ValueError("invalid group keyword")
+                positions.setdefault(row["app_id"], []).append(row["position"])
+        for app_id, values in positions.items():
+            if len(values) > 200 or values != list(range(len(values))):
+                raise ValueError("invalid defaults group order")
+            if connection.execute("SELECT 1 FROM session_defaults_order WHERE app_id = ?", (app_id,)).fetchone() is None:
+                raise ValueError("missing defaults group order revision")
+        for row in connection.execute("SELECT * FROM managed_worktrees"):
+            if any(not isinstance(row[key], str) or not row[key].startswith("/")
+                   for key in ("root", "cwd", "common_dir")):
+                raise ValueError("invalid worktree paths")
+            if row["git_dir"] is not None and not row["git_dir"].startswith("/"):
+                raise ValueError("invalid worktree Git directory")
+        for row in connection.execute(
+            "SELECT b.worktree_id,b.working_cwd,w.cwd,w.project_alias,b.project_alias AS binding_project "
+            "FROM bindings b LEFT JOIN managed_worktrees w ON w.worktree_id=b.worktree_id "
+            "WHERE b.worktree_id IS NOT NULL"
+        ):
+            if row["cwd"] is None or row["working_cwd"] != row["cwd"] or row["project_alias"] != row["binding_project"]:
+                raise ValueError("invalid worktree Binding association")
+        if connection.execute(
+            "SELECT 1 FROM bindings WHERE working_cwd IS NOT NULL AND substr(working_cwd,1,1) != '/' LIMIT 1"
+        ).fetchone():
+            raise ValueError("invalid Binding working directory")
+    except (TypeError, ValueError) as error:
+        raise RuntimeError(f"schema v20 persisted configuration is invalid: {error}") from error

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/schedules/mcp.py

@@ -69,9 +69,10 @@ TOOL_DESCRIPTION = """Manage Netizen scheduled tasks with cron_manage: options,
 Find candidates by name before using an exact plan_id; clarify ambiguous matches. Resolve relative times into a structured schedule and IANA timezone, and save reusable instructions with explicit resource references. target_kind=new_topic (default) starts an independent ordinary Thread in a new Feishu topic. target_kind=binding submits to the exact original Binding and shares its context, current settings and ordinary start/steer behavior. For requests such as 'continue here in ten minutes', use binding. Pausing prevents automatic claims; deleting prevents all new claims. Already claimed work may continue and uses ordinary stop/continue controls.
 For create/update/delete/run_now supply a UUID request_id; retry the same request with the same ID after a timeout. For update/delete/run_now copy the exact current revision from the latest list/view/create/update result into expected_revision; never increment it yourself. An existing current result does not require another view call. Omitted chat_id/project on create use the calling native Thread's Binding: the current Feishu conversation may be a group or a private chat; a topic uses its containing conversation. list defaults to that current conversation; all=true lists this instance's plans. update keeps omitted fields unchanged. No native Thread identity belongs in tool arguments.
 run_now executes the saved plan once, including manually paused or ended plans, without changing its schedule, next due time or enabled state. Supply only mode, plan_id, expected_revision and request_id; instructions and destination come from that saved version. The result is an acceptance receipt with run_id and current run information, not proof of completion. Results go to the saved target; share the returned feishu_url when available. For new_topic an unfinished or uncertain previous initial Turn blocks another run. For binding, started/steered records prove input acceptance only: subsequent scheduled inputs remain independent even after an unknown outcome, while ordinary Runtime admission still applies. Inactive targets cannot run_now; this never switches or restores a conversation. Inspect view/runs when blocked; do not rewrite or duplicate the plan or execute its instructions yourself as a workaround. After a management timeout, reuse the original request_id; never generate a new one merely to retry an uncertain trigger.
-For binding, omitted target_binding_id uses the calling ordinary Thread's exact Binding; Side or unmapped callers must supply an exact Binding ID returned by options. Native Thread IDs are never tool arguments. The target identity is immutable after creation. Do not supply project, chat_id, session_settings or workspace for binding: these follow the target conversation and its actual working directory at execution time. enabled remains the user's pause preference; suspended_reason separately reports automatic suspension, and can_run_now reports target eligibility. options supplies source_binding_id and binding_targets; list may filter target_kind/target_binding_id.
+For binding, omitted target_binding_id uses the calling ordinary Thread's exact Binding; Side or unmapped callers must supply an exact Binding ID returned by options. Native Thread IDs are never tool arguments. The target identity is immutable after creation. Do not supply project, chat_id, session_settings, workspace or auto_archive for binding: settings and the actual working directory come from the target conversation at execution time, and this target does not support automatic archiving. enabled remains the user's pause preference; suspended_reason separately reports automatic suspension, and can_run_now reports target eligibility. options supplies source_binding_id and binding_targets; list may filter target_kind/target_binding_id.
 For new_topic, create copies the calling Binding's session settings once; later Binding changes do not change the plan. session_settings is a partial override: turn_settings=null explicitly inherits native Codex settings; a model override supplies all three IDs. Other fields control reaction pulse, progress card and message context. Use options to discover current model/effort/service-tier IDs and defaults when choosing settings; ordinary creation needs no preliminary options call. A private target supports only current-only; an inherited catch-up default is normalized, but explicitly requesting catch-up is rejected. Updating unrelated fields retains the plan's settings even if its model is no longer available.
 For new_topic, workspace is a complete policy object: {"mode":"project"}, {"mode":"existing","worktree_id":"exact managed ID"}, {"mode":"new"}, or {"mode":"new","ref":"refs/heads/main"}. Omitted workspace on create uses the Project directory; omitted workspace on update preserves the saved policy. It never reads chat defaults or inherits the caller's Worktree. existing shares that resource's current files and branch; new creates one detached Worktree per accepted run, using that execution's Project HEAD when ref is omitted. Saving/options never creates directories. Use options with project and optional expected_project_revision to discover available choices; an exact known ID can be used directly without another lookup. Missing, replaced or unreadable resources block execution without fallback; inspect workspace_error and can_run_now. enabled stays unchanged. Unrelated edits may preserve an unavailable policy. run_now cannot override workspace. Do not create Worktrees yourself to simulate the new policy.
+For new_topic, auto_archive is an optional boolean completion policy, disabled by default. When enabled, the created conversation is archived after its initial Turn completes without error and its existing result delivery to Feishu succeeds. This measures process success, not business-goal fulfillment. The saved value is fixed when a scheduled or manual occurrence is claimed; later plan edits do not change that occurrence. Restore archived conversations through /sessions archived. Omit auto_archive on update to retain it; binding targets and run_now arguments do not accept this field.
 Recurring daily/weekly/interval schedules have no cutoff by default. Optional schedule.end_at is an inclusive cutoff timestamp with an explicit UTC offset and minute precision; turn a requested cutoff date into a specific time and timezone. Once schedules cannot use end_at.
 Providing schedule on update replaces the whole rule: include unchanged kind/time/timezone and end_at to keep them. To remove end_at, omit it or set it to null in the replacement schedule. Omitting schedule entirely keeps the existing rule and cutoff.
 Use the exact fields mode, instructions and schedule.kind. After invalid_request, correct the indicated fields and call cron_manage again; no shell commands or resource listing are needed to repair arguments.
@@ -175,6 +176,7 @@ class _Arguments(BaseModel):
     )
     timezone: str | None = Field(default=None, min_length=1, description="IANA timezone, e.g. Asia/Shanghai.")
     enabled: bool | None = None
+    auto_archive: bool = Field(default=None, description="new_topic create/update only. Automatically archive the created conversation after its initial Turn completes without error and its result is delivered to Feishu. Defaults to false on create; omit on update to preserve. run_now uses the saved value. This does not evaluate business-goal success or wait for subsequent conversation activity.")
     session_settings: _SessionSettingsArguments = Field(default=None, description="Optional partial session settings. Omitted fields copy the source Binding at creation or keep the plan's existing values on update. Explicit turn_settings=null resets model settings to native inheritance.")
     workspace: Annotated[
         _ProjectWorkspaceArguments | _ExistingWorkspaceArguments | _NewWorkspaceArguments,
@@ -194,8 +196,8 @@ class _Arguments(BaseModel):
             raise ValueError("Required fields are missing for this mode.")
         if self.mode == "run_now" and self.model_fields_set - _RUN_NOW_FIELDS:
             raise ValueError("run_now only accepts exact plan identity, revision and request_id.")
-        if self.target_kind == "binding" and {"workspace", "expected_project_revision"} & self.model_fields_set:
-            raise ValueError("binding targets inherit their actual workspace and do not accept overrides.")
+        if self.target_kind == "binding" and {"workspace", "expected_project_revision", "auto_archive"} & self.model_fields_set:
+            raise ValueError("binding targets do not accept workspace or auto-archive overrides.")
         if self.workspace is not None:
             WorkspacePolicy.from_dict(self.workspace.model_dump(exclude_unset=True))
         return self
@@ -218,7 +220,7 @@ def _tool_schema() -> dict[str, Any]:
     })
     schema["allOf"].append({
         "if": {"required": ["target_kind"], "properties": {"target_kind": {"const": "binding"}}},
-        "then": {"properties": {"workspace": False, "expected_project_revision": False}},
+        "then": {"properties": {"workspace": False, "expected_project_revision": False, "auto_archive": False}},
     })
     return schema
 
@@ -238,6 +240,7 @@ _FIELD_HINTS = {
     "schedule": "Supply a structured schedule with kind and its required fields: once/daily use at; weekly uses at and weekdays; interval uses every_minutes. Remove unsupported schedule fields.",
     "timezone": "Supply an IANA timezone string, such as Asia/Shanghai.",
     "enabled": "Use the boolean true or false.",
+    "auto_archive": "Use boolean true or false only for new_topic create/update. Default false on create; omit on update to preserve. Never supply for binding or run_now.",
     "expected_revision": "Copy the exact current integer revision (at least 1) from the latest list/view/create/update result. Do not increment it or call view again if already known.",
     "request_id": "Supply a nonempty stable UUID request_id for this mutation.",
     "cursor": "Use the cursor string returned by the previous page, or omit it for the first page.",

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/schedules/models.py

@@ -296,6 +296,7 @@ class Plan:
     target_kind: str = "new_topic"
     target_binding_id: str | None = None
     workspace: WorkspacePolicy | None = WorkspacePolicy()
+    auto_archive: bool = False
 
 
 @dataclass(frozen=True, slots=True)

{netizen_cli-0.14.1 → netizen_cli-0.14.2}/netizen_cli/schedules/service.py

@@ -40,8 +40,8 @@ _FIELDS = {
     "options": {"chat_id", "binding_query", "project", "expected_project_revision"},
     "list": {"chat_id", "project", "enabled", "ended", "all", "cursor", "limit", "name", "target_kind", "target_binding_id"},
     "view": {"plan_id"},
-    "create": {"name", "instructions", "project", "chat_id", "schedule", "timezone", "enabled", "request_id", "session_settings", "workspace", "expected_project_revision", "target_kind", "target_binding_id"},
-    "update": {"plan_id", "expected_revision", "request_id", "name", "instructions", "project", "chat_id", "schedule", "timezone", "enabled", "session_settings", "workspace", "expected_project_revision", "target_kind", "target_binding_id"},
+    "create": {"name", "instructions", "project", "chat_id", "schedule", "timezone", "enabled", "request_id", "session_settings", "workspace", "expected_project_revision", "target_kind", "target_binding_id", "auto_archive"},
+    "update": {"plan_id", "expected_revision", "request_id", "name", "instructions", "project", "chat_id", "schedule", "timezone", "enabled", "session_settings", "workspace", "expected_project_revision", "target_kind", "target_binding_id", "auto_archive"},
     "delete": {"plan_id", "expected_revision", "request_id"},
     "run_now": {"plan_id", "expected_revision", "request_id"},
     "runs": {"plan_id", "cursor", "limit"},
@@ -140,10 +140,10 @@ class ScheduleService:
             mode = request.get("mode")
             if not isinstance(mode, str) or mode not in _FIELDS:
                 raise ScheduleError("请选择 options/list/view/create/update/delete/run_now/runs 操作。")
-            # Optional arguments treat null as omission, except the settings
-            # object. False remains a real pause/filter value.
+            # Optional arguments treat null as omission, except settings,
+            # workspace and the strict completion policy. False is a value.
             data = {key: value for key, value in request.items()
-                    if mode == "run_now" or value is not None or key in {"session_settings", "workspace"}}
+                    if mode == "run_now" or value is not None or key in {"session_settings", "workspace", "auto_archive"}}
             if set(data) - (_FIELDS[mode] | {"mode"}):
                 raise ScheduleError("该操作包含不支持的字段。")
             if "expected_project_revision" in data:
@@ -224,6 +224,8 @@ class ScheduleService:
                 rule = self._rule(data, now=now)
                 enabled = data.get("enabled", True)
                 _boolean(enabled, "enabled")
+                auto_archive = data.get("auto_archive", False)
+                _boolean(auto_archive, "auto_archive")
                 result = self._store.create(
                     name=_text(data.get("name"), "name"),
                     instructions=_text(data.get("instructions"), "instructions"),
@@ -232,6 +234,7 @@ class ScheduleService:
                     session_settings=settings,
                     workspace=workspace, checked_project_revision=checked_project_revision,
                     target_kind=target_kind, target_binding_id=target_binding_id,
+                    auto_archive=auto_archive,
                     request_id=_text(data.get("request_id"), "request_id"), now=now,
                     request_payload=request_payload,
                 )
@@ -287,9 +290,11 @@ class ScheduleService:
                 return {"ok": True, "plan_id": result.plan_id, "revision": result.revision,
                         "inflight": inflight, "replayed": result.replayed}
             self._validate_target_update(data, plan)
-            changes = {key: data[key] for key in ("name", "instructions", "chat_id", "enabled") if key in data}
+            changes = {key: data[key] for key in ("name", "instructions", "chat_id", "enabled", "auto_archive") if key in data}
             if "enabled" in changes:
                 _boolean(changes["enabled"], "enabled")
+            if "auto_archive" in changes:
+                _boolean(changes["auto_archive"], "auto_archive")
             if "project" in data:
                 changes["project_alias"] = _text(data["project"], "project")
             if "chat_id" in changes:
@@ -350,10 +355,13 @@ class ScheduleService:
                 settings = await self._resolve_session_settings(request, binding=binding, previous=plan.session_settings if plan else None, chat_kind=kind)
                 effective = settings.to_dict()
             rule = self._rule(request, now=now, previous=plan.schedule if plan else None)
+            auto_archive = request.get("auto_archive", plan.auto_archive if plan else False)
+            _boolean(auto_archive, "auto_archive")
             boundary = max(now, plan.processed_through or now) if plan else now
             return {"ok": True, "schedule": rule.to_dict(),
                     "preview": _preview(rule, boundary),
                     "target_kind": target_kind,
+                    "auto_archive": auto_archive,
                     "session_settings": settings.to_dict() if settings is not None else None,
                     "effective_session_settings": effective, "default_timezone": self.default_timezone}
         except (ScheduleError, SessionSettingsError, BindingNotFound, ScopeNotFound, ProjectNotFound, ProjectConflict) as error:
@@ -361,6 +369,8 @@ class ScheduleService:
 
     @staticmethod
     def _reject_binding_overrides(request: Mapping[str, Any]) -> None:
+        if "auto_archive" in request:
+            raise ScheduleError("执行成功后自动归档仅适用于新话题计划。")
         if {"project", "chat_id", "session_settings", "workspace", "expected_project_revision"}.intersection(request):
             raise ScheduleError("Agent 会话计划沿用目标 Binding 的 Project、位置、配置和实际工作目录，不接受独立覆盖。")