omnius 1.0.655 → 1.0.656

package/dist/index.js

@@ -651696,6 +651696,52 @@ function resolveTrajectoryGroundingMode(explicit, subAgent) {
   }
   return subAgent ? "off" : "adaptive";
 }
+function withTaskCompleteCloseoutContract(tool) {
+  if (tool.name !== "task_complete")
+    return tool;
+  const parameters = tool.parameters && typeof tool.parameters === "object" ? tool.parameters : {};
+  const existingProperties = parameters["properties"] && typeof parameters["properties"] === "object" && !Array.isArray(parameters["properties"]) ? parameters["properties"] : {};
+  const originalDescription = String(tool.description ?? "").trim();
+  return {
+    ...tool,
+    description: originalDescription.startsWith(TASK_COMPLETE_CLOSEOUT_DESCRIPTION) ? originalDescription : `${TASK_COMPLETE_CLOSEOUT_DESCRIPTION} ${originalDescription}`.trim(),
+    parameters: {
+      ...parameters,
+      type: "object",
+      properties: {
+        ...existingProperties,
+        status: existingProperties["status"] ?? {
+          type: "string",
+          enum: [
+            "completed",
+            "blocked",
+            "incomplete",
+            "no_changes_required",
+            "needs_input"
+          ],
+          description: "Use completed only when the requested outcome is satisfied. Use blocked, incomplete, or needs_input when a known gap remains."
+        },
+        closeout_reviewed: existingProperties["closeout_reviewed"] ?? {
+          type: "boolean",
+          description: "True after comparing the active request, current todo/work graph state, and observed evidence immediately before this call."
+        },
+        remaining_gaps: existingProperties["remaining_gaps"] ?? {
+          type: "array",
+          items: { type: "string" },
+          description: "Known unfinished, blocked, superseded, or unverified items that remain after the closeout review. Use an empty array only when none remain."
+        },
+        override_closeout_review: existingProperties["override_closeout_review"] ?? {
+          type: "boolean",
+          description: "Optional explicit override. Set true only when deliberately ending without reconciling the tracked state. This never bypasses independent safety or delivery checks."
+        },
+        override_reason: existingProperties["override_reason"] ?? {
+          type: "string",
+          description: "Required by policy when override_closeout_review is true. State why ending now is the correct action."
+        }
+      }
+    }
+  };
+}
 function upsertContextFrame(messages2, frame2, marker = "[ACTIVE CONTEXT FRAME]") {
   for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
     const m2 = messages2[i2];
@@ -652425,7 +652471,7 @@ function classifyThinkOutcome(raw) {
   }
   return null;
 }
-var PRESERVE_MODEL_VISIBLE_HISTORY, TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, LEGACY_ACTION_REASON_KEYS, CLAIM_TASK_STOPWORDS, SYSTEM_PROMPT_COMMON, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, InferenceHttpError, OllamaAgenticBackend;
+var PRESERVE_MODEL_VISIBLE_HISTORY, TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, LEGACY_ACTION_REASON_KEYS, CLAIM_TASK_STOPWORDS, TASK_COMPLETE_CLOSEOUT_DESCRIPTION, SYSTEM_PROMPT_COMMON, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, InferenceHttpError, OllamaAgenticBackend;
 var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
@@ -652619,6 +652665,7 @@ var init_agenticRunner = __esm({
       "new",
       "old"
     ]);
+    TASK_COMPLETE_CLOSEOUT_DESCRIPTION = "Before task_complete, reconcile the active request, task state, and evidence; close or accurately report every gap.";
     SYSTEM_PROMPT_COMMON = `${STE_COMMUNICATION_POLICY}
 
 ${loadPrompt("agentic/system-common.md")}`;
@@ -657352,6 +657399,40 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         }
         return refreshed.authoritativeBlockers;
       }
+      /**
+       * Put current unresolved leaves beside the work graph before inference can
+       * select task_complete. This guidance never holds or rejects the terminal
+       * tool, including on bounded chat surfaces that disable planning nudges.
+       */
+      _injectTaskCloseoutReconciliationContext(messages2) {
+        const marker = "[TASK CLOSEOUT REVIEW]";
+        for (let index = messages2.length - 1; index >= 0; index--) {
+          const message2 = messages2[index];
+          if (message2?.role === "system" && typeof message2.content === "string" && message2.content.startsWith(marker)) {
+            messages2.splice(index, 1);
+          }
+        }
+        if (!this.tools.has("task_complete"))
+          return;
+        const openItems = openTodoLeaves(this._normalizeTodosForPrompt(this.readSessionTodos() ?? []));
+        if (openItems.length === 0)
+          return;
+        const updateInstruction = this._todoWriteAvailable() ? "If evidence shows that an open item is already finished, use todo_write to record its completed state before you finish." : "If an open item is already finished but no tracker-update tool is available, report that state accurately in the closeout fields.";
+        messages2.push({
+          role: "system",
+          content: [
+            marker,
+            "This is an advisory closeout reminder, not a permission gate.",
+            `${openItems.length} unresolved tracked leaf item(s) are visible now:`,
+            ...openItems.slice(0, 12).map((todo) => `- ${todo.id ? `${todo.id}: ` : ""}[${todo.status}] ${todo.content}`),
+            openItems.length > 12 ? `- ${openItems.length - 12} additional unresolved item(s) remain in the current task state.` : "",
+            "Before task_complete, compare these items with the active request and actual evidence from this run.",
+            updateInstruction,
+            "Continue feasible authorized work that is genuinely unfinished. If work cannot be finished, use a truthful blocked, incomplete, or needs_input status and list the exact remaining gaps.",
+            "You can deliberately override this review by setting override_closeout_review=true and giving override_reason. The terminal signal remains callable."
+          ].filter(Boolean).join("\n")
+        });
+      }
       _gitProgressSummary() {
         return summarizeGitProgressForTrajectory(this._gitProgress);
       }
@@ -659088,6 +659169,8 @@ ${context2 ?? ""}`;
           ``,
           `Before claiming success or calling task_complete, derive the material claims from this exact request and your proposed final answer.`,
           `For each material claim, cite observed evidence from this run or mark the claim unverified/blocked. Let the current request, proposed claims, and observations determine what matters.`,
+          `Immediately before task_complete, reconcile the active request with the current todo/work graph and observed evidence. Mark completed-but-open work complete, continue feasible unfinished work, and report any remaining gap with a truthful terminal status.`,
+          `This closeout review is advisory, not a hard gate. You can override it with considered judgment by setting override_closeout_review=true and giving override_reason; do not use an override to conceal known gaps.`,
           `If completion is impossible, say so plainly and name the blocker plus the observations already collected.`,
           ``,
           formatCompletionContract(completionContract)
@@ -662760,9 +662843,10 @@ ${blob}
       registerTool(tool) {
         if (!this.isToolAllowedByProfile(tool.name, tool.aliases))
           return;
-        this.tools.set(tool.name, tool);
-        if (tool.name === "generate_image") {
-          this.maybeInstallImagePromptExpander(tool);
+        const registeredTool = withTaskCompleteCloseoutContract(tool);
+        this.tools.set(registeredTool.name, registeredTool);
+        if (registeredTool.name === "generate_image") {
+          this.maybeInstallImagePromptExpander(registeredTool);
         }
       }
       toolNameVariants(name10) {
@@ -666093,7 +666177,7 @@ ${dynamicProjectContext}`
             "\nRules:",
             "- Output EXACTLY ONE tool call per response in the JSON format above",
             "- After seeing the tool result, continue or call another tool",
-            '- When done: {"tool": "task_complete", "args": {"summary": "what you did"}}',
+            '- When done: {"tool": "task_complete", "args": {"summary": "what you did", "status": "completed", "closeout_reviewed": true, "remaining_gaps": []}}',
             "- You CAN also write ```bash ... ``` blocks which will be auto-executed"
           ].join("\n");
           toolDefs = [];
@@ -666112,6 +666196,7 @@ ${dynamicProjectContext}`
         const substantiveProgressFingerprints = /* @__PURE__ */ new Set();
         let completed = false;
         let summary = "";
+        let acceptedTaskCompleteStatus;
         let bruteForceCycle = 0;
         this._assistantTextEmitted = false;
         this._microcompactHintEmitted = false;
@@ -666738,6 +666823,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
               ...openTodos.slice(0, 12).map((todo) => `  - [${todo.status}] ${todo.content}`)
             ].join("\n"), turn);
           }
+          acceptedTaskCompleteStatus = completionStatusFromTaskCompleteArgs(args);
           this._completionHoldState.count = 0;
           this._completionHoldState.lastKey = "";
           this._completionHoldState.total = 0;
@@ -667911,6 +667997,7 @@ Respond with EXACTLY this structure before your next tool call:
             continue;
           }
           this._injectOperationalWorkGraphContext(messages2, this._taskState.originalGoal || this._taskState.goal || persistentTaskGoal, turn);
+          this._injectTaskCloseoutReconciliationContext(messages2);
           if (!this.options.disableTodoPlanningNudges) {
             const maybeReminder = this.getTodoReminderContent(turn);
             if (maybeReminder) {
@@ -668571,7 +668658,7 @@ ${memoryLines.join("\n")}`
                     toolDescriptions,
                     "\nOutput EXACTLY ONE tool call per response in the JSON format above.",
                     "After seeing the tool result, continue or call another tool.",
-                    'When done, output: {"tool": "task_complete", "args": {"summary": "what you did"}}'
+                    'When done, output: {"tool": "task_complete", "args": {"summary": "what you did", "status": "completed", "closeout_reviewed": true, "remaining_gaps": []}}'
                   ].join("\n");
                   chatRequest.messages = this._prepareModelFacingMessages([
                     ...requestMessages2,
@@ -668595,6 +668682,16 @@ ${memoryLines.join("\n")}`
                             content: `Tool result (${parsed.tool}): ${result.output.slice(0, 2e3)}`
                           });
                           if (resolvedParsedTool.name === "task_complete") {
+                            if (!result.success) {
+                              messages2.push({
+                                role: "system",
+                                content: this.buildTaskCompleteToolFailureGuard(result.error || result.output)
+                              });
+                              continue;
+                            }
+                            if (holdTaskCompleteGates(parsed.args ?? {}, turn)) {
+                              continue;
+                            }
                             completed = true;
                             summary = String(parsed.args?.summary ?? content);
                             this._onTypedEvent?.({
@@ -672792,6 +672889,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               continue;
             }
             this._injectOperationalWorkGraphContext(messages2, this._taskState.originalGoal || this._taskState.goal || persistentTaskGoal, turn);
+            this._injectTaskCloseoutReconciliationContext(messages2);
             let compactedMsgs;
             if (this._pendingCompaction) {
               const strategy = this._pendingCompaction;
@@ -673338,7 +673436,16 @@ ${terminalFeedback.slice(0, 4e3)}`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
-        let runStatus = completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" || this._completionLedger?.status === "incomplete_verification" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
+        const declaredDegradedCompletion = acceptedTaskCompleteStatus === "blocked" || acceptedTaskCompleteStatus === "incomplete" || acceptedTaskCompleteStatus === "needs_input";
+        if (completed && declaredDegradedCompletion) {
+          completed = false;
+          this.emit({
+            type: "status",
+            content: `task_complete retained truthful degraded status: ${acceptedTaskCompleteStatus}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        let runStatus = declaredDegradedCompletion ? "incomplete" : completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" || this._completionLedger?.status === "incomplete_verification" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
         const terminalReceipt = this._commitTerminalFinalization({
           status: runStatus,
           summary,
@@ -796047,12 +796154,16 @@ Scoped workspace: ${scopedRoot}`,
       buildTelegramTool(context2, repoRoot, chatId, currentMsg) {
         const bridge = this;
         const adminDm = context2 === "telegram-admin-dm";
+        const exposedActions = Object.keys(TELEGRAM_TOOL_ACTION_GROUP).filter(
+          (action) => this.telegramToolActionEnabled(action, chatId)
+        );
         return {
           name: "telegram",
           description: [
-            "Unified scoped Telegram tool. Use action to inspect chat state, send messages/files, delete messages, manage reactions, or manage Telegram tool policy.",
+            "Use approval-gated kick_chat_member for remove, kick, or eject requests; never substitute ban_chat_member.",
+            "Use action to inspect chat state, send messages/files, delete messages, manage reactions, or manage Telegram tool policy.",
             "kick_chat_member stages an immutable, expiring request and asks the numeric global human admin for verbal approval; it never removes a member in the tool call.",
-            "A reply to the target member's message can supply the kick target without copying a user id. ban_chat_member is also approval-gated, and unban_chat_member cannot be used as an unapproved kick.",
+            "A reply to the target member's message, a numeric user_id, or an exact uniquely observed target_username can supply the kick target. ban_chat_member is a persistent or expiring ban only, and unban_chat_member cannot be used as an unapproved kick.",
             "Deletion and other moderation actions require authenticated admin context, Omnius Telegram tool policy enablement, current/known chat scoping, and Telegram bot rights.",
             "Use scope_status before risky actions when uncertain. Use render_admin_buttons to show clickable admin toggles."
           ].join(" "),
@@ -796061,8 +796172,8 @@ Scoped workspace: ${scopedRoot}`,
             properties: {
               action: {
                 type: "string",
-                enum: Object.keys(TELEGRAM_TOOL_ACTION_GROUP),
-                description: "Telegram action to perform."
+                enum: exposedActions,
+                description: "Telegram operation. kick_chat_member is the only remove/kick/eject operation: it stages immutable global-admin approval and permits later rejoin. ban_chat_member creates a persistent or expiring ban only and must never substitute for a kick; it is omitted when direct moderation policy is disabled."
               },
               target: {
                 type: "string",
@@ -796080,7 +796191,11 @@ Scoped workspace: ${scopedRoot}`,
               },
               user_id: {
                 type: "number",
-                description: "Telegram user id for member/moderation/reaction actions. kick_chat_member may omit this only when the current message directly replies to the target member."
+                description: "Numeric Telegram user id for member/moderation/reaction actions. For kick_chat_member, use this, target_username, or a direct reply to the target member."
+              },
+              target_username: {
+                type: "string",
+                description: "Exact Telegram username for kick_chat_member. It must resolve case-insensitively to one positive numeric user id already observed in the current chat; unknown or conflicting identities fail closed."
               },
               text: { type: "string", description: "Text for send/edit actions." },
               caption: {
@@ -796525,13 +796640,18 @@ Scoped workspace: ${scopedRoot}`,
           }
           case "kick_chat_member":
           case "ban_chat_member": {
+            const targetUsername = String(args["target_username"] ?? "").trim();
             const moderationTargetUserId = userId ?? this.telegramModerationReplyTargetUserId(
               env2.currentMsg,
               targetChatId
-            );
+            ) ?? (targetUsername && targetChatId !== void 0 ? this.telegramModerationUsernameTargetUserId(
+              targetUsername,
+              targetChatId,
+              env2.currentMsg
+            ) : void 0);
             if (targetChatId === void 0 || moderationTargetUserId === void 0)
               throw new Error(
-                `target/chat_id and a numeric user_id are required for ${action}. You may omit user_id only when the request directly replies to that member's message in the target chat.`
+                `target/chat_id and a verified member identity are required for ${action}. Supply a numeric user_id, an exact uniquely observed target_username, or directly reply to that member's message in the target chat.`
               );
             if (dryRun)
               return this.telegramDryRun(action, targetChatId, {
@@ -796734,6 +796854,46 @@ Scoped workspace: ${scopedRoot}`,
         }
         return reply.sender.id;
       }
+      telegramModerationUsernameTargetUserId(rawUsername, targetChatId, currentMsg) {
+        const username = rawUsername.trim().replace(/^@/, "").toLowerCase();
+        if (!username) {
+          throw new Error(
+            "target_username must contain an exact Telegram username."
+          );
+        }
+        this.ensureAllTelegramConversationsLoaded();
+        const observedIds = /* @__PURE__ */ new Set();
+        const addObserved = (candidateUsername, candidateId) => {
+          if (candidateUsername?.trim().replace(/^@/, "").toLowerCase() === username && Number.isSafeInteger(candidateId) && Number(candidateId) > 0) {
+            observedIds.add(Number(candidateId));
+          }
+        };
+        if (String(currentMsg?.chatId) === String(targetChatId)) {
+          addObserved(currentMsg?.username, currentMsg?.fromUserId);
+          addObserved(
+            currentMsg?.replyContext?.sender?.username,
+            currentMsg?.replyContext?.sender?.id
+          );
+        }
+        const history = this.chatHistory.get(`chat:${String(targetChatId)}`) ?? [];
+        for (const entry of history) {
+          if (String(entry.chatId) !== String(targetChatId)) continue;
+          addObserved(entry.username, entry.fromUserId);
+          addObserved(
+            entry.replyContext?.sender?.username,
+            entry.replyContext?.sender?.id
+          );
+        }
+        if (observedIds.size === 1) return [...observedIds][0];
+        if (observedIds.size > 1) {
+          throw new Error(
+            `target_username @${username} maps to conflicting observed Telegram user ids in chat ${String(targetChatId)}. Reply directly to the target message or supply the verified numeric user_id.`
+          );
+        }
+        throw new Error(
+          `target_username @${username} has no exact positive numeric user-id observation in chat ${String(targetChatId)}. Reply directly to the target message or supply the verified numeric user_id.`
+        );
+      }
       telegramModerationActionDigest(action) {
         return createHash74("sha256").update(JSON.stringify(action)).digest("hex");
       }
@@ -797493,6 +797653,12 @@ ${this.quoteTelegramContextBlock(msg.text, 800)}`,
         }
         if (!this.telegramToolActionEnabled(action, targetChatId)) {
           const scope = targetChatId !== void 0 && this.telegramToolPolicy.chatOverrides?.[String(targetChatId)] ? `chat ${String(targetChatId)}` : "global/default";
+          if (action === "ban_chat_member") {
+            return {
+              ok: false,
+              error: `Direct ban_chat_member remains disabled by ${scope} policy. For a remove, kick, or eject request that permits later rejoin, use kick_chat_member with a numeric user_id, exact observed target_username, or direct reply; it stages global-admin approval. If the user explicitly requested a persistent or expiring ban, do not substitute a kick; an administrator must enable the moderation action first.`
+            };
+          }
           return {
             ok: false,
             error: `Telegram action ${action} is disabled by ${scope} policy. Enable ${group} or ${action} first.`

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.655",
+  "version": "1.0.656",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.655",
+      "version": "1.0.656",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.655",
+  "version": "1.0.656",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",

package/prompts/agentic/system-common.md

@@ -108,5 +108,7 @@ Do not repeat a recorded change without new evidence that requires repetition.
 
 - Report only verified results.
 - If a required result is blocked, identify the blocker and its evidence.
+- Immediately before `task_complete`, compare the active request with the current todo/work graph and observed evidence. Mark finished-but-open items complete, continue feasible unfinished work, and accurately list unresolved gaps with a blocked, incomplete, or needs-input status.
+- This closeout review is advisory. You can override it with considered judgment by setting `override_closeout_review=true` and giving `override_reason`; do not use an override to hide a known gap.
 - Continue authorized work when the user says `finish` or `do not stop`.
 - Do not treat a terminal phrase as new authority for unrelated work.