okstra 0.189.3 → 0.190.0

package/runtime/python/okstra_ctl/agent/invocation.py

@@ -117,6 +117,14 @@ _NESTED_KEYS = {
         "promptDigest",
     },
 }
+EXECUTION_DELIVERY_CONTRACT = "execution-identity-v1"
+EXECUTION_DELIVERY_PREFIXES = (
+    "**Execution delivery contract:**", "**Invocation metadata path:**",
+    *(f"**{field}:**" for field in (
+        "participantRef", "roleExecutionRef", "executionLabel", "invocationRef",
+        "dutyId", "attempt",
+    )),
+)
 
 
 class AgentInvocationError(RuntimeError):
@@ -586,6 +594,12 @@ def materialize_retry_invocation(
     manifest_path = _project_path(
         project_root, source.get("runManifestPath"), must_exist=True
     )
+    errors = verify_agent_invocation(
+        metadata_path, project_root=project_root,
+        expected_run_manifest_path=manifest_path,
+    )
+    if errors:
+        raise AgentInvocationError("cannot retry invalid source invocation: " + "; ".join(errors))
     prompt_path = _project_path(
         project_root, prompt_spec.get("path"), must_exist=True
     )
@@ -600,10 +614,14 @@ def materialize_retry_invocation(
     retry_metadata["invocationId"] = retry_invocation_id
     retry_metadata["attempt"] = attempt
     retry_metadata["prompt"] = {
+        **prompt_spec,
         "path": _project_relative(
             retry_prompt_path, project_root, must_exist=False
         )
     }
+    retry_body = _retry_prompt_bytes(
+        prompt_path.read_bytes(), retry_metadata, retry_prompt_path, retry_metadata_path,
+    )
     manifest = _load_json_object(manifest_path, "run manifest")
     contract = manifest.get("agentContract")
     if not isinstance(contract, dict):
@@ -636,7 +654,7 @@ def materialize_retry_invocation(
             _pretty_json(reservation),
         )
         with _exclusive_lock(_prompt_lock_path(retry_prompt_path)):
-            _publish_or_reuse_exact(retry_prompt_path, prompt_path.read_bytes())
+            _publish_or_reuse_exact(retry_prompt_path, retry_body)
             _publish_or_reuse_exact(
                 retry_metadata_path, _pretty_json(retry_metadata)
             )
@@ -665,6 +683,34 @@ def materialize_retry_invocation(
     )
 
 
+def _retry_prompt_bytes(
+    body: bytes, metadata: dict[str, object], prompt_path: Path, metadata_path: Path,
+) -> bytes:
+    if metadata["prompt"].get("deliveryContract") != EXECUTION_DELIVERY_CONTRACT:
+        return body
+    prefix, remainder = body.decode("utf-8").split("\n\n## Duty Contract\n\n", 1)
+    paths = {
+        "**Prompt History Path:**": metadata["prompt"]["path"],
+        "Assigned worker prompt history path:": str(prompt_path),
+    }
+    lines = [line for line in prefix.splitlines() if not line.startswith(EXECUTION_DELIVERY_PREFIXES)]
+    lines = [next((f"{label} {path}" for label, path in paths.items() if line.startswith(label)), line) for line in lines]
+    lines.extend(_execution_delivery_lines(metadata, metadata_path))
+    text = "\n".join(lines) + "\n\n## Duty Contract\n\n" + remainder
+    prefix, task = _split_prompt(text)
+    instruction = {
+        "anchorLines": _extract_anchor_lines(prefix),
+        "body": task.rstrip("\n"),
+        "sourcePaths": metadata["instruction"]["sourcePaths"],
+    }
+    metadata["digests"] = {
+        **metadata["digests"],
+        "instructionDigest": _sha256(_canonical_json(instruction)),
+        "promptDigest": _sha256(text.encode("utf-8")),
+    }
+    return text.encode("utf-8")
+
+
 def compose_agent_prompt(request: AgentInvocationRequest) -> str:
     """Render and validate a prompt candidate without publishing artifacts."""
     _validate_request(request)
@@ -995,9 +1041,11 @@ def _materialize(request: AgentInvocationRequest) -> _MaterializedInvocation:
     duty = catalog[request.audience]
     if _request_identity_version(request) == 2 and request.duty_id != duty.id:
         raise AgentInvocationError("v2 execution identity duty does not match audience")
-    prompt_bytes = _render_prompt(request, common, duty).encode("utf-8")
+    metadata = _metadata_payload(request, duty, {})
+    delivery = _execution_delivery_lines(metadata, request.metadata_path)
+    prompt_bytes = _render_prompt(request, common, duty, delivery).encode("utf-8")
     digests = _invocation_digests(request, duty, prompt_bytes)
-    metadata = _metadata_payload(request, duty, digests)
+    metadata["digests"] = digests
     prepared = PreparedAgentInvocation(
         invocation_id=request.invocation_id,
         worker_id=request.worker_id,
@@ -1212,6 +1260,7 @@ def _render_prompt(
     request: AgentInvocationRequest,
     common: DutyContract,
     duty: DutyContract,
+    delivery: tuple[str, ...] = (),
 ) -> str:
     assignment = request.assignment
     task_body = request.instruction.body.rstrip("\n")
@@ -1255,6 +1304,7 @@ def _render_prompt(
         header.append(f"{delivery_mode} eager-include")
     if assignment.host_model_value is not None:
         header.append(f"**Host model value:** {assignment.host_model_value}")
+    header.extend(delivery)
     duty_body = f"{common.body.rstrip()}\n\n{duty.body.rstrip()}"
     return (
         "\n".join(header)
@@ -1367,6 +1417,7 @@ def _metadata_payload(
             "attempt": request.attempt,
         })
         payload.pop("workerId")
+        payload["prompt"]["deliveryContract"] = EXECUTION_DELIVERY_CONTRACT
     return payload
 
 
@@ -1591,7 +1642,7 @@ def _replace_undispatched(
     """
     if not request.replace_undispatched:
         raise _existing_conflict(f"existing prompt differs ({difference})")
-    dispatched = _recorded_dispatch_ids(request)
+    dispatched = invocation_dispatch_ids(request)
     if dispatched:
         raise _existing_conflict(
             "existing prompt differs and this invocation was already "
@@ -1607,7 +1658,7 @@ def _replace_undispatched(
     )
 
 
-def _recorded_dispatch_ids(request: AgentInvocationRequest) -> set[str]:
+def invocation_dispatch_ids(request: AgentInvocationRequest) -> set[str]:
     """Dispatch rows in team-state that already reference this invocation id.
 
     Both ledgers are read: `agentDispatches` is written by the host-native
@@ -1746,9 +1797,56 @@ def _verify_prompt_file(
     errors = []
     errors.extend(_verify_instruction_digest(metadata, body))
     errors.extend(_verify_model_header(metadata, body))
+    errors.extend(_verify_execution_delivery(metadata, path, body))
     return errors
 
 
+def _execution_delivery_lines(
+    metadata: Mapping[str, object], metadata_path: Path,
+) -> tuple[str, ...]:
+    if metadata.get("executionIdentityVersion") != 2:
+        return ()
+    values = (
+        EXECUTION_DELIVERY_CONTRACT, str(metadata_path.resolve()),
+        *(str(metadata[key]) for key in (
+            "participantRef", "roleExecutionRef", "executionLabel", "invocationRef",
+            "dutyId", "attempt",
+        )),
+    )
+    return tuple(f"{prefix} {value}" for prefix, value in zip(EXECUTION_DELIVERY_PREFIXES, values))
+
+
+def _verify_execution_delivery(
+    metadata: Mapping[str, object], prompt_path: Path, body: bytes,
+) -> list[str]:
+    if metadata["prompt"].get("deliveryContract") != EXECUTION_DELIVERY_CONTRACT:
+        return []
+    metadata_path = prompt_path.with_name(prompt_path.name + ".meta.json")
+    expected = _execution_delivery_lines(metadata, metadata_path)
+    prefix = body.decode("utf-8").split("\n\n## Duty Contract\n\n", 1)[0]
+    actual = tuple(line for line in prefix.splitlines() if line.startswith(EXECUTION_DELIVERY_PREFIXES))
+    if actual != expected:
+        return ["prompt execution identity or metadata path does not match invocation metadata"]
+    return []
+
+
+def agent_prompt_task_bytes(prompt_bytes: bytes) -> bytes:
+    """시도별 전달값을 제외한 논리 작업 입력. 예약과 두 배치 경계가 공유한다."""
+    prefix, remainder = prompt_bytes.decode("utf-8").split("\n\n## Duty Contract\n\n", 1)
+    history_prefixes = ("**Prompt History Path:**", "Assigned worker prompt history path:")
+    lines = [line for line in prefix.splitlines() if not line.startswith(EXECUTION_DELIVERY_PREFIXES)]
+    lines = [next((label for label in history_prefixes if line.startswith(label)), line) for line in lines]
+    return ("\n".join(lines) + "\n\n## Duty Contract\n\n" + remainder).encode("utf-8")
+
+
+def invocation_input_digest(metadata: Mapping[str, object], project_root: Path) -> str:
+    """구형 예약의 입력 해시를 유지하고 새 전달 계약은 논리 작업을 해시한다."""
+    if metadata["prompt"].get("deliveryContract") != EXECUTION_DELIVERY_CONTRACT:
+        return str(metadata["digests"]["promptDigest"])
+    path = _project_path(project_root, metadata["prompt"]["path"], must_exist=True)
+    return _sha256(agent_prompt_task_bytes(path.read_bytes()))
+
+
 def _verify_instruction_digest(
     metadata: Mapping[str, object],
     prompt_bytes: bytes,
@@ -2137,6 +2235,10 @@ def _metadata_schema_is_exact(metadata: Mapping[str, object]) -> bool:
         return False
     for key, expected_keys in _NESTED_KEYS.items():
         value = metadata.get(key)
+        if key == "prompt" and isinstance(value, dict) and "deliveryContract" in value:
+            if schema != "2.0" or value["deliveryContract"] != EXECUTION_DELIVERY_CONTRACT:
+                return False
+            expected_keys = expected_keys | {"deliveryContract"}
         if not isinstance(value, dict) or set(value) != expected_keys:
             return False
     sources = metadata["instruction"]["sourcePaths"]

package/runtime/python/okstra_ctl/agent/prompt_cli/cli.py

@@ -16,6 +16,7 @@ from ...dispatch_state import BACKEND_CLI_WRAPPER, BACKEND_CMUX_PANE, DispatchEr
 from .emit import _emit, _prepared_payload
 from .inputs import AgentPromptCliError
 from .materialize import _apply_corrections, _check_corrections, _materialize
+from .jobs import generate_jobs
 from .results import (
     _complete,
     _link_result,
@@ -30,6 +31,7 @@ from .results import (
 
 _CLI_EPILOG = r"""Usage:
   okstra agent-prompt materialize [options]
+  okstra agent-prompt jobs --project-root <dir> --run-manifest <path> --dispatch-kind <kind> --metadata <path> [--metadata <path>] --out <path>
   okstra agent-prompt check-corrections --project-root <dir> --run-manifest <path> --corrections <file>
   okstra agent-prompt apply-corrections --project-root <dir> --run-manifest <path> --corrections <file>
   okstra agent-prompt verify [options]
@@ -54,6 +56,13 @@ def _parser() -> argparse.ArgumentParser:
     _add_materialize_parser(commands)
     _add_completion_parsers(commands)
     _add_dispatch_parsers(commands)
+    jobs = commands.add_parser("jobs", help="generate a verified jobs file without dispatching")
+    _common_paths(jobs)
+    jobs.add_argument("--run-manifest", required=True)
+    jobs.add_argument("--dispatch-kind", required=True)
+    jobs.add_argument("--metadata", action="append", required=True)
+    jobs.add_argument("--out", required=True)
+    jobs.add_argument("--json", action="store_true")
     return parser
 
 
@@ -221,6 +230,13 @@ def _standalone_completion_args(parser: argparse.ArgumentParser) -> None:
 def main(argv: list[str] | None = None) -> int:
     try:
         args = _parser().parse_args(argv)
+        if args.command == "jobs":
+            payload = generate_jobs(args)
+            if args.json:
+                _emit(payload, True)
+            else:
+                print(payload["jobsPath"])
+            return 0
         if args.command == "materialize":
             prepared = _materialize(args)
             _emit(_prepared_payload(prepared, args.audience), args.json)

package/runtime/python/okstra_ctl/agent/prompt_cli/dynamic_verifier.py

@@ -18,6 +18,7 @@ from ..invocation import (
     AgentModelAssignment,
     compose_agent_prompt,
     compose_unbound_run_prompt,
+    agent_prompt_task_bytes,
     v2_role_assignment_authority_errors,
 )
 from ...convergence_store import (
@@ -47,7 +48,7 @@ def _reserve_dynamic_verifier_request(
         duty_id=args.audience,
         round_number=_reverify_round(args.dispatch_kind),
         task_key=_required_manifest_string(manifest, "taskKey"),
-        input_digest="sha256:" + hashlib.sha256(prompt_bytes).hexdigest(),
+        input_digest="sha256:" + hashlib.sha256(agent_prompt_task_bytes(prompt_bytes)).hexdigest(),
         invocation_ref=args.invocation_id,
     )
     bound = replace(
@@ -58,7 +59,7 @@ def _reserve_dynamic_verifier_request(
         duty_id=args.audience,
         invocation_ref=invocation.invocation_ref,
     )
-    if compose_agent_prompt(bound).encode("utf-8") != prompt_bytes:
+    if agent_prompt_task_bytes(compose_agent_prompt(bound).encode("utf-8")) != agent_prompt_task_bytes(prompt_bytes):
         raise AgentPromptCliError(
             "dynamic verifier identity changed immutable prompt bytes"
         )

package/runtime/python/okstra_ctl/agent/prompt_cli/jobs.py

@@ -0,0 +1,87 @@
+"""검증된 호출에서 배치 입력을 생성하고 전체 검사 뒤 불변 발행한다."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+from ..invocation import (
+    _exclusive_lock, _publish_or_reuse_exact, verify_agent_invocation,
+)
+from ...dispatch_state import worker_jobs_from_payload, validate_dispatch_prompts, prompt_anchor_values
+from ...models import provider_wrappers
+from ...path_hints import hydrate_active_run_context
+from ...paths import okstra_home
+from .inputs import (
+    AgentPromptCliError, _authorized_path, _project_input, _project_root,
+    _read_json_object,
+)
+
+
+def generate_jobs(args: argparse.Namespace) -> dict[str, object]:
+    project = _project_root(args.project_root)
+    manifest_path = _project_input(project, args.run_manifest, "run manifest")
+    manifest = _read_json_object(manifest_path, "run manifest")
+    if manifest.get("executionIdentityVersion") != 2:
+        raise AgentPromptCliError("agent-prompt jobs requires a v2 run manifest")
+    output = _authorized_path(project, args.out, [manifest["runDirectoryPath"]], "jobs", must_exist=False)
+    paths = [_project_input(project, value, "metadata") for value in args.metadata]
+    rows = [_metadata_job(project, manifest_path, manifest, path, args.dispatch_kind) for path in paths]
+    refs = [(row["invocationRef"], row["attempt"]) for row in rows]
+    if len(set(refs)) != len(refs):
+        raise AgentPromptCliError("jobs metadata contains duplicate invocation attempts")
+    context_path = _project_input(project, manifest["activeRunContextPath"], "active run context")
+    context = hydrate_active_run_context(_read_json_object(context_path, "active run context"))
+    payload = {"dispatchKind": args.dispatch_kind, "workers": rows}
+    wrappers = provider_wrappers("analyser")
+    jobs = worker_jobs_from_payload(
+        project, payload, manifest=manifest, active_context=context,
+        backend="cli-wrapper", idle_timeout_seconds=None,
+        default_dispatch_kind=args.dispatch_kind,
+        resolve_wrapper=lambda provider: okstra_home() / "bin" / wrappers[provider],
+        default_provider=lambda worker_id: worker_id,
+    )
+    validate_dispatch_prompts(manifest, context, jobs)
+    body = (json.dumps(payload, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+    with _exclusive_lock(output.with_name(f".{output.name}.lock")):
+        if output.exists() and output.read_bytes() != body:
+            raise AgentPromptCliError(f"jobs output differs; existing file preserved: {output}; choose a new --out path")
+        _publish_or_reuse_exact(output, body)
+    return {"ok": True, "jobsPath": str(output), "workers": len(rows)}
+
+
+def _metadata_job(
+    project: Path, manifest_path: Path, manifest: Mapping[str, Any],
+    metadata_path: Path, dispatch_kind: str,
+) -> dict[str, object]:
+    errors = verify_agent_invocation(
+        metadata_path, project_root=project, expected_run_manifest_path=manifest_path,
+    )
+    if errors:
+        raise AgentPromptCliError(f"{metadata_path}: " + "; ".join(errors))
+    metadata = _read_json_object(metadata_path, "agent metadata")
+    if metadata.get("executionIdentityVersion") != 2 or metadata["dispatchKind"] != dispatch_kind:
+        raise AgentPromptCliError(f"{metadata_path}: expected v2 dispatchKind {dispatch_kind!r}")
+    execution = next(row for row in manifest["roleExecutions"] if row["roleExecutionRef"] == metadata["roleExecutionRef"])
+    if execution["role"] == "translator":
+        raise AgentPromptCliError("translator uses canonical reservation dispatch: worker-dispatch --workers translator")
+    prompt = _project_input(project, metadata["prompt"]["path"], "prompt")
+    anchors = prompt_anchor_values(prompt, ("Result Path", "Worker Result Path"))
+    result = anchors.get("Worker Result Path") or anchors.get("Result Path")
+    if not result:
+        raise AgentPromptCliError(f"prompt has no result anchor: {prompt}")
+    assignment = metadata["modelAssignment"]
+    if assignment["provider"] not in provider_wrappers("analyser"):
+        raise AgentPromptCliError(f"unsupported worker provider: {assignment['provider']}")
+    return {
+        **{key: metadata[key] for key in (
+            "schemaVersion", "executionIdentityVersion", "participantRef", "roleExecutionRef",
+            "executionLabel", "dutyId", "invocationRef", "attempt", "invocationId",
+            "audience", "assignmentRef", "digests",
+        )},
+        "provider": assignment["provider"], "modelExecutionValue": assignment["modelExecutionValue"],
+        "hostModelValue": assignment["hostModelValue"], "role": execution["role"],
+        "promptPath": str(prompt), "promptMetadataPath": str(metadata_path),
+        "workerResultPath": result, "enforcementMode": "core-pre-dispatch",
+    }

package/runtime/python/okstra_ctl/agent/prompt_cli/materialize.py

@@ -26,11 +26,15 @@ from ..invocation import (
     digest_duty_catalog,
     invocation_execution_identity_from_manifest,
     prepare_agent_invocation,
+    compose_agent_prompt,
+    compose_unbound_run_prompt,
 )
 from ...assignment_environment import load_assignment_context
 from ...assignment_resolver import AssignmentContext, resolve_dispatch_assignment
 from ...path_hints import hydrate_active_run_context
 from ...worker_prompt_headers import worker_prompt_headers
+from ...worker_prompt_contract import complete_reverify_instruction, validate_reverify_prompt
+from ...paths import okstra_home
 from ...final_report_paths import final_report_data_path
 from ...final_report_schema import load_schema_version
 from ...report_inputs import report_narrative_path, uses_report_contract_v3
@@ -207,8 +211,31 @@ def _materialize_run(
             result_path=result_path,
             audit_source_path=audit_source_path,
         )
-    elif audit_source_path is None:
-        audit_source_path = result_path
+    elif (
+        audit_source_path is None
+        or _normalized(audit_source_path) == _normalized(result_path)
+    ):
+        # translator 다. report-writer 와 같은 두-경로 audience 인데 종전엔 빠진
+        # `--audit-source` 를 `--result` 로 조용히 접었다. 그러면 프롬프트에
+        # `**Worker Result Path:**` 앵커가 안 생기는데, `worker-dispatch` 는 그
+        # 앵커가 `**Result Path:**` 와 다를 것을 요구하므로 발행은 되지만 어떤
+        # 디스패치도 받지 못하는 예약이 남는다. 예약은 회수 명령이 없어 리드가
+        # 두 번째 id 로 다시 만드는 순간 "exactly one reservation" 이 영영
+        # 깨졌다(2026-09-08 실측, fontsninja-v3-site dev-10627-2
+        # requirements-discovery). 발행 시점에 거절한다.
+        raise AgentPromptCliError(
+            "translator materialization requires --audit-source distinct from "
+            "--result: --result is the translator's own report "
+            "(e.g. worker-results/translator-translations-<task-type>-<seq>.md) "
+            "and --audit-source the worker-result .md the audit sidecar is "
+            "derived from (worker-results/translator-worker-<task-type>-<seq>.md). "
+            "`worker-dispatch --workers translator` reads both from the prompt's "
+            "**Result Path:** and **Worker Result Path:** anchors and refuses a "
+            "prompt without the second. To fix a prompt already published "
+            "without it, re-run this command with the same --invocation-id and "
+            "--prompt plus --replace-undispatched; a new invocation id would "
+            "leave two reservations and block the translator for this run"
+        )
     _validate_run_identity(
         manifest,
         worker_id=args.worker_id,
@@ -272,6 +299,9 @@ def _materialize_run(
         active_context=active_context,
     ))
     body = instruction_path.read_text(encoding="utf-8")
+    is_reverify = args.dispatch_kind.startswith("reverify-r")
+    if is_reverify:
+        body = _complete_run_reverify_body(args, manifest, active_context, assignment, body, instruction_path)
     if args.audience == "report-writer":
         body = _with_inputs_section(
             body,
@@ -315,7 +345,9 @@ def _materialize_run(
             source_paths=(AgentInstructionSource(
                 kind="project",
                 path=_relative(project_root, instruction_path),
-            ),),
+            ),) + ((AgentInstructionSource(
+                kind="runtime", path="templates/reverify-output-contract.md",
+            ),) if is_reverify else ()),
         ),
         project_root=project_root,
         run_manifest_path=manifest_path,
@@ -332,6 +364,15 @@ def _materialize_run(
         attempt=1,
         replace_undispatched=args.replace_undispatched,
     )
+    if is_reverify:
+        candidate = compose_unbound_run_prompt(request).decode("utf-8") if dynamic_source else compose_agent_prompt(request)
+        errors = validate_reverify_prompt(
+            candidate, task_type=str(manifest["taskType"]),
+            forbidden_actions=str(active_context["workflow"]["forbiddenActions"]),
+            expected_model=assignment.model_execution_value,
+        )
+        if errors:
+            raise AgentPromptCliError("; ".join(errors))
     if dynamic_source is not None:
         request = _reserve_dynamic_verifier_request(
             request,
@@ -343,6 +384,34 @@ def _materialize_run(
     return prepare_agent_invocation(request)
 
 
+def _complete_run_reverify_body(
+    args: argparse.Namespace, manifest: Mapping[str, Any],
+    active_context: Mapping[str, Any], assignment: AgentModelAssignment,
+    body: str, instruction_path: Path,
+) -> str:
+    workflow = _mapping(active_context.get("workflow"), "active workflow")
+    forbidden = workflow.get("forbiddenActions")
+    if not isinstance(forbidden, str) or not forbidden.strip():
+        raise AgentPromptCliError("active workflow.forbiddenActions is missing or invalid")
+    resources = active_context.get("runtimeResources") or {}
+    error_contract = resources.get("workerErrorContractPath")
+    template = Path(
+        error_contract or okstra_home() / "templates/worker-error-contract.md"
+    ).with_name("reverify-output-contract.md")
+    try:
+        return complete_reverify_instruction(
+            body, task_type=str(manifest["taskType"]), forbidden_actions=forbidden,
+            model=assignment.model_execution_value,
+            output_contract=template.read_text(encoding="utf-8"),
+        )
+    except ValueError as exc:
+        raise AgentPromptCliError(
+            f"{exc}; correct {instruction_path} and rerun agent-prompt materialize "
+            f"with --invocation-id {args.invocation_id} --prompt {args.prompt} "
+            "(use a fresh ID and path if already dispatched or dynamically reserved)"
+        ) from exc
+
+
 def _normalized(path: Path) -> Path:
     return Path(os.path.normpath(path))
 

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 import re
 from pathlib import Path
 
+from . import group_context
+
 
 BRIEF_SECTIONS = (
     "Identity",
@@ -136,10 +138,15 @@ def build_analysis_packet(
             bool(group_context_text),
         )
     )
-    # 그룹 맥락은 브리프 발췌보다 앞에 둔다: 짧고 "왜" 를 담으며, 46KB 에서 잘리는
-    # 읽기(agy view_file)에서도 도착해야 하는 절이다.
-    parts.extend(_group_context_block(group_context_text))
+    # 그룹 문서는 사람 절과 okstra 메모리 영역으로 갈라 싣는다. 사람 절("왜")은
+    # 브리프 발췌보다 앞 — 짧고, 46KB 에서 잘리는 읽기(agy view_file)에서도
+    # 도착해야 한다. 형제 task 의 결론은 브리프 뒤 — 브리프를 밀어내면 안 된다.
+    group_human, group_memory, _ = group_context.split_memory_region(
+        _strip_frontmatter(group_context_text)
+    )
+    parts.extend(_group_context_block(group_human))
     parts.extend(_brief_block(brief_text))
+    parts.extend(_group_memory_block(group_memory, _own_task_segment(task_key)))
     parts.extend(_profile_block(task_type, profile_text))
     parts.extend(_reference_block(reference_text))
     parts.extend(_fix_history_block(fix_history_text))
@@ -296,8 +303,20 @@ GROUP_CONTEXT_PREFACE = (
 )
 
 
-def _group_context_block(group_context_text: str) -> list[str]:
-    if not group_context_text.strip():
+GROUP_MEMORY_PREFACE = (
+    "What the other tasks of this task-group concluded in their latest run, "
+    "written by okstra at each run's report-finalize into the group's "
+    "`group-context.md`. A headline is a claim; its evidence is the record at "
+    "`record`. This section is not this task's requirement ledger, and a sibling's "
+    "decision does not bind this run: where a sibling's conclusion conflicts with "
+    "the `## Task-Specific Brief Extract`, raise a `Clarification Items` row rather "
+    "than re-deriving what the sibling already settled or silently overriding it."
+)
+
+
+def _group_context_block(human_text: str) -> list[str]:
+    """사람 절만 싣는다. 메모리 전용 문서(사람 `## ` 절 없음)는 절을 만들지 않는다."""
+    if not any(line.startswith("## ") for line in human_text.splitlines()):
         return []
     return [
         "",
@@ -305,7 +324,29 @@ def _group_context_block(group_context_text: str) -> list[str]:
         "",
         GROUP_CONTEXT_PREFACE,
         "",
-        _strip_frontmatter(group_context_text).strip(),
+        human_text.strip(),
+    ]
+
+
+def _own_task_segment(task_key: str) -> str:
+    return group_context.slugify_task_segment(re.split(r"[:/]", task_key)[-1])
+
+
+def _group_memory_block(region: str, own_task_segment: str) -> list[str]:
+    """형제 task 의 항목만 싣는다. 자기 항목은 timeline·prior-planning 이 이미 나른다."""
+    entries = [
+        entry for entry in group_context.parse_memory_entries(region)
+        if entry.task_id != own_task_segment
+    ]
+    if not entries:
+        return []
+    return [
+        "",
+        "## Task-Group Memory",
+        "",
+        GROUP_MEMORY_PREFACE,
+        "",
+        group_context.render_memory_entries(entries).strip(),
     ]
 
 

package/runtime/python/okstra_ctl/cmux.py

@@ -225,6 +225,13 @@ def plan_worker_placement(
     return _extend_the_worker_grid(workers)
 
 
+def _overlaps_vertically(first: PaneGeometry, second: PaneGeometry) -> bool:
+    """경계만 맞닿은 위아래 세션은 가로 공간을 공유하지 않는다."""
+    return max(first.y, second.y) < min(
+        first.y + first.height_points, second.y + second.height_points,
+    )
+
+
 def lead_target_width(
     panes: Sequence[PaneGeometry],
     *,
@@ -238,20 +245,29 @@ def lead_target_width(
     fourth worker is on screen, all of it when they are gone. The share is
     taken of what okstra may actually place into, not of the window: a
     workspace can hold panes okstra never opened, and handing the lead the
-    whole container would shove those off their own width. Their width is
-    subtracted first and the share applies to the remainder.
+    whole container would shove those off their own width.
+
+    리드와 세로 영역이 겹치는 다른 창의 가로 구간만 차감한다. 위아래로
+    쌓인 창들이 같은 가로 구간을 차지하면 해당 구간은 한 번만 차감한다.
 
     Deriving the target from the container rather than from a fixed column count
     is what keeps the split honest at any window size — a hardcoded 80 columns
     is two fifths of one particular display and an arbitrary slice of every
     other.
     """
-    strangers = sum(
-        pane.width_points
+    lead = _pane_by_id(panes, lead_pane_id)
+    intervals = sorted(
+        (pane.x, pane.x + pane.width_points)
         for pane in panes
         if pane.pane_id != lead_pane_id
         and not _holds_an_okstra_surface(pane, owned_surface_ids)
+        and _overlaps_vertically(lead, pane)
     )
+    strangers = 0.0
+    right_edge = float("-inf")
+    for left, right in intervals:
+        strangers += max(0.0, right - max(left, right_edge))
+        right_edge = max(right_edge, right)
     usable = container_width_points - strangers
     if usable <= 0:
         return 0.0
@@ -707,18 +723,23 @@ def _size_lead_pane(workspace: str, owned_surface_ids: Collection[str]) -> None:
         return
     panes = _panes_from(payload)
     lead = _lead_pane(panes)
-    offset = lead_resize_points(
-        lead,
-        target_width_points=lead_target_width(
-            panes,
-            lead_pane_id=lead.pane_id,
-            owned_surface_ids=owned_surface_ids,
-            container_width_points=container_width,
-        ),
+    target = lead_target_width(
+        panes,
+        lead_pane_id=lead.pane_id,
+        owned_surface_ids=owned_surface_ids,
+        container_width_points=container_width,
     )
+    if target <= 0:
+        # 잘못되거나 공간이 없는 배치를 최소 폭까지 축소하는 요청으로 바꾸지 않는다.
+        return
+    offset = lead_resize_points(lead, target_width_points=target)
     if offset == 0:
         return
-    neighbours = [pane for pane in panes if pane.x > lead.x]
+    neighbours = [
+        pane for pane in panes
+        if abs(pane.x - (lead.x + lead.width_points)) <= 1
+        and _overlaps_vertically(lead, pane)
+    ]
     if not neighbours:
         return
     narrowing = offset > 0