cuelo 0.5.0

package/Tools/OMP_Global_Config/agent/tools/git-finalizer/index.ts

@@ -0,0 +1,83 @@
+import type { CustomToolFactory } from "@oh-my-pi/pi-coding-agent";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+interface FinalizerResult {
+  ok: boolean;
+  stage: string;
+  error?: string;
+  commitSha?: string;
+  remote?: string;
+  upstreamRef?: string;
+}
+
+const scriptPath = fileURLToPath(new URL("./finalizer.ps1", import.meta.url));
+
+function parseResult(stdout: string): FinalizerResult | undefined {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const value = JSON.parse(lines[index]) as FinalizerResult;
+      if (value && typeof value.ok === "boolean" && typeof value.stage === "string") return value;
+    } catch {
+      // PowerShell or Git may emit a non-JSON diagnostic before the final result.
+    }
+  }
+  return undefined;
+}
+
+const factory: CustomToolFactory = (pi) => ({
+  name: "git_finalize",
+  label: "Git Finalize",
+  loadMode: "essential",
+  description:
+    "Atomically finalize relative exact files in one repository. Resolve every target from its nearest existing parent. Treat matching git common-dir values as the same repository: restrict those targets to paths inside cwd or an exact direct child file of the cwd repository root, while allowing one distinct repository; reject mixed repositories before staging. Serialize by repository/upstream, verify exact paths and ancestry, commit, then push the created SHA. Main only.",
+  parameters: pi.zod.object({
+    files: pi.zod.array(pi.zod.string()),
+    message: pi.zod.string(),
+  }),
+
+  async execute(_toolCallId, params, onUpdate, _ctx, signal) {
+    const files = params.files.map((value) => value.trim()).filter(Boolean);
+    const message = params.message.trim();
+    if (files.length === 0) throw new Error("git_finalize requires at least one exact file path.");
+    if (!message) throw new Error("git_finalize requires a non-empty commit message.");
+    if (process.platform !== "win32") throw new Error("git_finalize currently requires Windows PowerShell.");
+
+    onUpdate?.({
+      content: [{ type: "text", text: "Repository finalizer lock을 획득하고 변경 경계를 확인하는 중입니다." }],
+      details: { phase: "preflight", files },
+    });
+
+    const tempDir = await mkdtemp(join(tmpdir(), "omp-git-finalize-"));
+    const requestPath = join(tempDir, "request.json");
+    try {
+      await writeFile(requestPath, JSON.stringify({ cwd: pi.cwd, files, message }), "utf8");
+      const result = await pi.exec(
+        "powershell.exe",
+        ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptPath, "-Request", requestPath],
+        { cwd: pi.cwd, signal, timeout: 180_000 },
+      );
+      const parsed = parseResult(result.stdout);
+      if (result.code !== 0 || !parsed?.ok) {
+        const detail = parsed?.error || result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`;
+        throw new Error(`git_finalize failed${parsed?.stage ? ` at ${parsed.stage}` : ""}: ${detail}`);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Committed and pushed ${parsed.commitSha} to ${parsed.remote} ${parsed.upstreamRef}.`,
+          },
+        ],
+        details: parsed,
+      };
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  },
+});
+
+export default factory;

package/Tools/OMP_Global_Config/notices/orchestrate.md

@@ -0,0 +1,26 @@
+<!--
+`orchestrate` 가 발동한 턴에만 주입되는 내 규칙. 이 파일만 고치면 문구가 바뀐다.
+빈 파일이나 주석만 있으면 아무것도 주입하지 않는다. 모델이 읽는 지시문이라 영어로 쓴다.
+적용: node patches/apply-notices.mjs  (setup.ps1 이 자동 실행)
+-->
+
+House additions:
+- There are exactly two role types: Main and `maker` (`maker-escalate` is the same contract on the escalated model slot). No other agent role is dispatched, and having two types never means spawning two agents.
+- Subagent brief prose, follow-up steering, progress, and final user-visible prose are Korean. Keep structural keys/headings, model IDs, code, commands, paths, APIs, and original errors verbatim; do not add an English or bilingual fallback.
+- Ordinary conversation, progress utterances, and inline child speech use natural Korean with the selected character temperament, which overrides generic report formatting. Never force report headings or a Problem/Decision/Check/Next template there; reserve structured evidence prose for completion reports, incident analyses, and explicit report requests.
+- Legacy sources (`.vb`, `.frm`, `.bas`, `.cfg`, `.csv`, `.resx`): determine encoding from BOM, reader/project convention, and strict decode/re-encode evidence before editing. No BOM alone does not mean CP949. Preserve established encoding, BOM, and line endings.
+- Main owns dialogue, approvals, requirements, routing, barriers, evidence adjudication, final verdict, supported profile installation/restart, and Git finalization. Main also implements and validates whatever it did not delegate; inside a delegated slice it never implements or runs that slice's commands. Preserve approval and material-risk boundaries.
+- Finalize only the exact files this task changed through Main's `git_finalize`; raw `git add`, `git commit`, `git push`, `git commit-tree`, and `git update-ref` are prohibited.
+
+Throughput and validation:
+- Dispatch ready independent slices without waiting for unrelated work. Dependency and synthesis barriers are allowed only when a downstream artifact or combined result genuinely requires them; `tasks[]` is a feed, so refill settled slots while real independent work remains. Never pad the queue to fill slots, and group small independent edits under one owner.
+- A delegated `maker` owns investigation, implementation, rework, and every check its slice needs, including build/test/lint/type-check and actual-surface smoke. There is no separate validator role. When several slices converge on one execution path or touch the same build output, cache, DB, or profile, Main names one of those owners to run the merged check once after convergence.
+- Verify web surfaces in a separate background Chrome/Chromium launched with a temporary profile: real rendering, clicks, input, screenshots, console errors. Never touch the user's existing tabs, cookies, or logins; use the OMP Relay only for explicitly approved work on the user's own browser. Add no new browser framework or persistent helper.
+- Main reviews a delegated slice's confirmed delta mid-flight: when a dispatch assumption conflicts with the actual code, when the slice's confirmed delta has landed, or when an owner check failed or a new risk appeared. Main inspects that delta and its evidence only; it never edits a path a live child owns, never repeats the owner's check, and never closes a revision whose required checks still run. Mid-flight review is a direction call, not the final acceptance.
+- An `integration-risk` task is reviewed by Main: Main may start reading the frozen diff in parallel with the owner's validation, but accepts only after actually consuming the current revision's raw evidence. `independent-only` work gets no such review. High-risk keeps the serial safety order: all relevant owners converge and finish their required checks, then Main reviews serially. Main never repeats an owner's check and never edits a path a live child owns.
+- Review only against immutable evidence: the reviewed revision is a raw diff locator or verbatim tool output plus the exact before/after hunk for every reviewed target and valid impact-bearing caller locators. Hand-transcribed diffs, prose reconstruction, and late errata never substitute for that evidence.
+- Never repeat an experiment that did not narrow uncertainty, and reuse evidence whose inputs did not change.
+- A routine task is owned end to end by Main with no child of any role. Reclassify to `large`/`high-risk` before any dispatch; ownership never overlaps and a path in progress is never handed off mid-way.
+- All async roles use automatic result delivery. Never timer/status poll or repeat finite-timeout hub wait. At a required dependency/synthesis barrier use timeoutMs:0 wait exactly once; re-waiting on an unchanged state is polling. User steering may skip the call; handle it then resume the still-required barrier once.
+- Child routine started/milestone/job progress stays inside its own session; MUST NOT DM or wake Main. Only a real blocker, approval need, contract/scope change, terminal task result, or a Main-requested revision/evidence relay notifies the parent; review status chatter stays out. Keep long-job launch/progress evidence for the final report and never send a duplicate completion DM.
+- Rework invalidates only the evidence whose inputs changed: the owning Maker repairs its own finding and refreshes the affected command evidence, Main re-reviews that delta only, and unaffected evidence is reused rather than rerun.

package/Tools/OMP_Global_Config/notices/ultrathink.md

@@ -0,0 +1,9 @@
+<!--
+`ultrathink` 가 발동한 턴에만 주입되는 내 규칙. 이 파일만 고치면 문구가 바뀐다.
+빈 파일이나 주석만 있으면 아무것도 주입하지 않는다. 모델이 읽는 지시문이라 영어로 쓴다.
+적용: node patches/apply-notices.mjs  (setup.ps1 이 자동 실행)
+-->
+
+House additions:
+- Enumerate the plausible failure modes first, then rule each out with a fact you observed this turn (file content, command output, log line). Unobserved claims are marked `[INFERENCE]`.
+- Prefer reading the actual source over reconstructing behavior from memory of similar systems.

package/Tools/OMP_Global_Config/notices/workflow.md

@@ -0,0 +1,16 @@
+<!--
+`workflowz` 가 발동한 턴에만 주입되는 내 규칙. 이 파일만 고치면 문구가 바뀐다.
+빈 파일이나 주석만 있으면 아무것도 주입하지 않는다. 모델이 읽는 지시문이라 영어로 쓴다.
+적용: node patches/apply-notices.mjs  (setup.ps1 이 자동 실행)
+-->
+
+House additions:
+- Role types are Main and `maker` (`maker-escalate` is the same contract on the escalated model slot); no other role exists. Main owns a routine change end to end - investigation, implementation, rework, validation, verdict - with no child at all. Reclassify to `large`/`high-risk` before any dispatch, and never dispatch a child for a path or check Main already owns.
+- In a delegated slice the `maker` owns investigation, implementation, rework, and every check that slice needs, including build/test/lint/type-check and actual-surface smoke. Main orchestrates and adjudicates without running that slice's commands. When several slices converge on one execution path or share build output, cache, DB, or profile, Main names one of those owners to run the merged check once after convergence.
+- Main reviews a delegated slice's confirmed delta mid-flight: when a dispatch assumption conflicts with the actual code, when the slice's confirmed delta has landed, or when an owner check failed or a new risk appeared. Main inspects that delta and its evidence only; it never edits a path a live child owns, never repeats the owner's check, and never closes a revision whose required checks still run. Mid-flight review is a direction call, not the final acceptance.
+- Verify web surfaces in a separate background Chrome/Chromium with a temporary profile (rendering, clicks, input, screenshots, console errors); never touch the user's tabs, cookies, or logins, and use the OMP Relay only for explicitly approved work on the user's own browser.
+- Relay only task-relevant facts, acceptance criteria, constraints, decisions, and applicable upstream deltas with evidence links; do not copy full conversations or reports when a short delta and link suffice.
+- Preserve approval and material-risk boundaries, including the high-risk serial order: all relevant owners converge and finish their required checks, then Main reviews serially and issues the verdict.
+- Every async role uses automatic result delivery. Never timer/status poll or repeat finite-timeout hub wait. At a real dependency/synthesis barrier use timeoutMs:0 wait exactly once; re-waiting on an unchanged state is polling. If user steering skips it, handle steering then resume the still-required barrier once.
+- Keep routine started/milestone/job progress inside the child's session; MUST NOT DM or wake Main. Notify the parent only for a real blocker, approval need, contract/scope change, terminal task result, or a Main-requested revision/evidence relay; review status chatter stays out. Preserve long-job launch/progress evidence in the final report. Terminal delivery is automatic, without a duplicate DM.
+- Report in Korean with the covered revision and inputs, exact command, cwd, exit status, concise observation, raw artifact locator, reused evidence with its basis, and unverified conditions. Reuse unchanged evidence instead of rerunning it. Main owns final acceptance.