makdoong2-team 1.3.0

package/dist/redact-secrets.js

@@ -0,0 +1,68 @@
+const SECRET_KEY_SUBSTRINGS = [
+    "TOKEN",
+    "SECRET",
+    "PASSWORD",
+    "PASSWD",
+    "APIKEY",
+    "API_KEY",
+    "API_TOKEN",
+    "CREDENTIAL",
+    "CREDENTIALS",
+    "AUTH",
+    "PRIVATE_KEY",
+    "PRIVKEY",
+    "ACCESS_KEY",
+    "SESSION_KEY",
+    "COOKIE",
+    "PAT",
+];
+const KEY_NAME_ALTERNATION = SECRET_KEY_SUBSTRINGS.join("|");
+const IDENT_CORE = `[A-Za-z0-9_]*(?:${KEY_NAME_ALTERNATION})[A-Za-z0-9_]*`;
+export const REDACTED = "***REDACTED***";
+// Shell KEY=VALUE with optional `export` prefix. `(?:^|[\s;&|(])` anchors the
+// match to a shell-boundary so URL query strings / JSON blobs are not eaten.
+// Value alternatives capture double-quoted, single-quoted, and bare forms —
+// bare stops at whitespace or shell operators to preserve command boundaries.
+const SHELL_ASSIGN_RE = new RegExp(`((?:^|[\\s;&|(])(?:export\\s+)?)(${IDENT_CORE})(=)(?:"([^"]*)"|'([^']*)'|([^\\s;&|)>]+))`, "gi");
+// CLI long-flag forms: --token=... / --api-key ... / --password="..." etc.
+// Handles both `=`-joined and space-separated values, matches secret-substring
+// keys plus a small set of common CLI-only names not covered by env-style
+// identifiers (token, api-key, api_key, bearer, cookie).
+const CLI_FLAG_RE = new RegExp(`(--(?:${KEY_NAME_ALTERNATION}|token|api[-_]?key|api[-_]?token|password|secret|auth|bearer|cookie)(?:=|\\s+))(?:"([^"]*)"|'([^']*)'|([^\\s;&|)>]+))`, "gi");
+// HTTP Auth scheme literals as they appear in curl -H / logged request bodies.
+// The 8-char minimum on the value guards against matching short scheme names
+// used as words (e.g. "Bearer strategy").
+const HTTP_AUTH_RE = /((?:Authorization\s*:\s*)?(?:Bearer|Basic|Token|Digest))\s+([A-Za-z0-9+/=._~\-]{8,})/g;
+// Well-known token prefixes with distinctive shapes: Slack, GitHub, AWS IAM,
+// npm registry, Google API, Atlassian PAT. Loose length filters chosen to
+// avoid matching short identifiers that happen to share the prefix.
+const KNOWN_PREFIX_RE = /\b((?:xox[abps]-[A-Za-z0-9-]{10,})|(?:gh[posur]_[A-Za-z0-9]{16,})|(?:AKIA[0-9A-Z]{12,})|(?:npm_[A-Za-z0-9]{20,})|(?:AIza[0-9A-Za-z_-]{20,})|(?:AT[AB][AT]T[A-Za-z0-9._~\-]{20,}))\b/g;
+export function redactSecrets(input) {
+    if (!input || typeof input !== "string")
+        return input;
+    return input
+        .replace(SHELL_ASSIGN_RE, (_m, prefix, key, eq, dq, sq) => {
+        if (dq !== undefined)
+            return `${prefix}${key}${eq}"${REDACTED}"`;
+        if (sq !== undefined)
+            return `${prefix}${key}${eq}'${REDACTED}'`;
+        return `${prefix}${key}${eq}${REDACTED}`;
+    })
+        .replace(CLI_FLAG_RE, (_m, flagAndSep, dq, sq) => {
+        if (dq !== undefined)
+            return `${flagAndSep}"${REDACTED}"`;
+        if (sq !== undefined)
+            return `${flagAndSep}'${REDACTED}'`;
+        return `${flagAndSep}${REDACTED}`;
+    })
+        .replace(HTTP_AUTH_RE, (_m, scheme) => `${scheme} ${REDACTED}`)
+        .replace(KNOWN_PREFIX_RE, () => REDACTED);
+}
+export function redactAndTruncate(input, maxChars) {
+    if (!input)
+        return input;
+    const redacted = redactSecrets(input);
+    if (redacted.length <= maxChars)
+        return redacted;
+    return `${redacted.slice(0, maxChars)}…(truncated ${redacted.length - maxChars} chars)`;
+}

package/dist/session-index.d.ts

@@ -0,0 +1,11 @@
+export type SessionIndexEntry = {
+    sessionID: string;
+    agent: string;
+    worktree: string;
+    issue: string;
+    stage?: string;
+    createdAt: string;
+};
+export declare function appendSessionIndex(entry: SessionIndexEntry): void;
+export declare function findWorktreeRoot(startFile: string): string | null;
+export declare function lookupSessionFromIndex(worktreeRoot: string, sessionID: string): SessionIndexEntry | null;

package/dist/session-index.js

@@ -0,0 +1,71 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { resolve as pathResolve, dirname as pathDirname } from "node:path";
+import { logger } from "./logger.js";
+const SESSION_INDEX_FILE = "session-index.ndjson";
+export function appendSessionIndex(entry) {
+    try {
+        const dir = `${entry.worktree}/.makdoong2-team/${entry.issue}`;
+        mkdirSync(dir, { recursive: true });
+        appendFileSync(`${dir}/${SESSION_INDEX_FILE}`, JSON.stringify(entry) + "\n");
+    }
+    catch (err) {
+        logger.debug(`[session-index] append failed sessionID=${entry.sessionID}: ${err.message}`);
+    }
+}
+export function findWorktreeRoot(startFile) {
+    if (typeof startFile !== "string" || startFile.length === 0)
+        return null;
+    let cur = pathResolve(startFile);
+    cur = pathDirname(cur);
+    for (let i = 0; i < 64; i++) {
+        try {
+            const st = statSync(`${cur}/.git`);
+            if (st.isDirectory() || st.isFile())
+                return cur;
+        }
+        catch {
+            /* .git not here — keep walking up */
+        }
+        const parent = pathDirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+    return null;
+}
+export function lookupSessionFromIndex(worktreeRoot, sessionID) {
+    if (typeof worktreeRoot !== "string" || typeof sessionID !== "string")
+        return null;
+    try {
+        const base = `${worktreeRoot}/.makdoong2-team`;
+        if (!existsSync(base))
+            return null;
+        const issues = readdirSync(base, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+        for (const issue of issues) {
+            const idx = `${base}/${issue}/${SESSION_INDEX_FILE}`;
+            if (!existsSync(idx))
+                continue;
+            const content = readFileSync(idx, "utf8");
+            const lines = content.split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj?.sessionID === sessionID)
+                        return obj;
+                }
+                catch {
+                    /* malformed line — skip */
+                }
+            }
+        }
+    }
+    catch {
+        /* index root inaccessible */
+    }
+    return null;
+}

package/dist/skill-mcp-registry.d.ts

@@ -0,0 +1,59 @@
+export interface SkillMcpEntry {
+    /** skill 디렉토리 이름 (SKILL.md 의 name 필드와 동일해야 함). */
+    skillName: string;
+    /** frontmatter mcp: 블록에서 선언된 MCP 서버 이름들. */
+    mcpNames: readonly string[];
+    /** 원본 SKILL.md 절대 경로 (디버깅용). */
+    path: string;
+}
+export interface SkillMcpRegistry {
+    /** mcp_name → 이 MCP를 embedded 로 선언한 skill 이름 (첫 번째 매칭). */
+    readonly byMcp: ReadonlyMap<string, string>;
+    /** skill_name → SkillMcpEntry. */
+    readonly bySkill: ReadonlyMap<string, SkillMcpEntry>;
+    /** 스캔한 skills 루트 경로 (디버깅용). */
+    readonly root: string;
+}
+/**
+ * SKILL.md 하나에서 frontmatter 를 추출한다. `---` 로 감싼 YAML 프론트매터가
+ * 없으면 null 을 반환한다.
+ *
+ * 파서는 다음 두 필드만 최소 파싱한다:
+ *  - `name: <string>`
+ *  - `mcp:` 하위의 최상위 키(들) — 각 키가 MCP 서버 이름
+ *
+ * 예시:
+ * ```
+ * ---
+ * name: jira-research
+ * mcp:
+ *   works:
+ *     command: bash
+ *     args: ["./run-works.sh"]
+ * ---
+ * ```
+ * → { name: "jira-research", mcpNames: ["works"] }
+ */
+export declare function parseSkillFrontmatter(src: string): {
+    name?: string;
+    mcpNames: string[];
+} | null;
+/**
+ * `skillsRoot` 하위의 SKILL.md 를 모두 스캔해 registry 를 만든다.
+ *
+ * 디렉토리가 없거나 접근 불가면 빈 registry 를 반환한다 (fail-open).
+ * 훅 로직은 registry 가 비어 있으면 정보성 힌트를 생략하고 opencode 기본
+ * 에러를 그대로 전달한다.
+ */
+export declare function scanSkillMcpRegistry(skillsRoot: string): SkillMcpRegistry;
+/**
+ * skill_mcp 호출 인자에서 mcp_name 을 안전하게 추출한다.
+ * 호출 형식은 { mcp_name: string, ... } 이며, 미제공이면 undefined.
+ */
+export declare function extractMcpName(args: unknown): string | undefined;
+/**
+ * opencode 가 반환하는 "MCP server ... not found" 에러 문자열을 감지한다.
+ * 정확한 문구는 opencode 버전에 따라 달라질 수 있으므로 관용적으로 매칭한다.
+ */
+export declare function looksLikeMcpNotFound(output: string): boolean;
+export declare function looksLikeMcpConnectionFailed(output: string): boolean;

package/dist/skill-mcp-registry.js

@@ -0,0 +1,178 @@
+// skill-mcp-registry.ts — mcp_name → skill_name 매핑 스캐너.
+//
+// 배경
+// ----
+// 이 프로젝트의 skill 은 SKILL.md frontmatter 에 MCP 서버를 embedded 로 선언한다
+// (lazy-load 아키텍처). skill 이 실제로 `skill(name="...")` 로 로드되기 전에는
+// 해당 MCP 서버가 세션에 스폰되지 않는다.
+//
+// 사용자(막둥이 에이전트)가 순서 강제 문구를 놓치고 `skill_mcp(mcp_name="works", ...)`
+// 를 먼저 호출하면 opencode 가 "MCP server not found" 로 튕기지만, 그 에러
+// 메시지는 어떤 skill 을 로드해야 하는지 명시하지 않는다.
+//
+// 이 모듈은 install 된 skills 디렉토리를 스캔해 frontmatter 의 `mcp:` 블록에서
+// 서버 이름을 추출하고, `mcp_name → skill_name` 룩업 테이블을 만든다.
+// tool.execute.before / .after 훅이 이 테이블로 사용자에게 정확한 skill 이름을
+// 지시하는 에러를 낼 수 있게 한다.
+//
+// 파서는 최소 구현으로 유지한다 — SKILL.md frontmatter 는
+// name / description / mcp / temperature / tools 등 얕은 구조만 사용하며,
+// YAML full spec 을 의존성으로 도입할 필요가 없다.
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * SKILL.md 하나에서 frontmatter 를 추출한다. `---` 로 감싼 YAML 프론트매터가
+ * 없으면 null 을 반환한다.
+ *
+ * 파서는 다음 두 필드만 최소 파싱한다:
+ *  - `name: <string>`
+ *  - `mcp:` 하위의 최상위 키(들) — 각 키가 MCP 서버 이름
+ *
+ * 예시:
+ * ```
+ * ---
+ * name: jira-research
+ * mcp:
+ *   works:
+ *     command: bash
+ *     args: ["./run-works.sh"]
+ * ---
+ * ```
+ * → { name: "jira-research", mcpNames: ["works"] }
+ */
+export function parseSkillFrontmatter(src) {
+    // frontmatter 는 파일 시작의 `---` 로 감싸진 첫 블록.
+    const m = src.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+    if (!m)
+        return null;
+    const front = m[1];
+    const lines = front.split(/\r?\n/);
+    let name;
+    const mcpNames = [];
+    let inMcp = false;
+    let mcpIndent = -1;
+    for (const raw of lines) {
+        if (!raw.trim())
+            continue;
+        // 최상위 name: <value>
+        const topLevel = raw.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+        // 들여쓰기 계산 (leading spaces 개수).
+        const indent = raw.match(/^(\s*)/)?.[1].length ?? 0;
+        if (inMcp) {
+            // mcp: 블록 종료 조건 — indent 가 mcp 헤더보다 크지 않으면 블록 밖.
+            if (indent <= mcpIndent) {
+                inMcp = false;
+            }
+            else {
+                // mcp: 블록 안. mcpIndent + 2 (표준 YAML 2-space 들여쓰기) 정확히
+                // 매칭되는 라인만 서버 이름 후보. 더 깊은 들여쓰기는 서버의 하위 옵션.
+                if (indent === mcpIndent + 2) {
+                    const kv = raw.trim().match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*:/);
+                    if (kv)
+                        mcpNames.push(kv[1]);
+                }
+                continue;
+            }
+        }
+        if (!inMcp && indent === 0 && topLevel) {
+            const key = topLevel[1];
+            const value = topLevel[2].trim();
+            if (key === "name" && value) {
+                name = value.replace(/^["']|["']$/g, "");
+            }
+            else if (key === "mcp" && value === "") {
+                inMcp = true;
+                mcpIndent = indent;
+            }
+        }
+    }
+    return { name, mcpNames };
+}
+/**
+ * `skillsRoot` 하위의 SKILL.md 를 모두 스캔해 registry 를 만든다.
+ *
+ * 디렉토리가 없거나 접근 불가면 빈 registry 를 반환한다 (fail-open).
+ * 훅 로직은 registry 가 비어 있으면 정보성 힌트를 생략하고 opencode 기본
+ * 에러를 그대로 전달한다.
+ */
+export function scanSkillMcpRegistry(skillsRoot) {
+    const byMcp = new Map();
+    const bySkill = new Map();
+    let entries;
+    try {
+        entries = readdirSync(skillsRoot);
+    }
+    catch {
+        return { byMcp, bySkill, root: skillsRoot };
+    }
+    for (const dirName of entries) {
+        const skillPath = join(skillsRoot, dirName);
+        let s;
+        try {
+            s = statSync(skillPath);
+        }
+        catch {
+            continue;
+        }
+        if (!s.isDirectory())
+            continue;
+        const mdPath = join(skillPath, "SKILL.md");
+        let src;
+        try {
+            src = readFileSync(mdPath, "utf8");
+        }
+        catch {
+            continue; // SKILL.md 없는 디렉토리는 스킵.
+        }
+        const parsed = parseSkillFrontmatter(src);
+        if (!parsed)
+            continue;
+        // frontmatter 의 name 필드가 있으면 그것을, 없으면 디렉토리명을 사용.
+        // opencode 는 skill(name=...) 호출 시 SKILL.md name 필드를 정본으로 삼는다.
+        const skillName = parsed.name || dirName;
+        const entry = {
+            skillName,
+            mcpNames: parsed.mcpNames,
+            path: mdPath,
+        };
+        bySkill.set(skillName, entry);
+        for (const mcp of parsed.mcpNames) {
+            // 첫 번째 매칭 skill 만 등록. 동일 mcp_name 을 여러 skill 이 선언하면
+            // 뒤에 오는 것은 무시하고 경고성 로그는 훅 쪽에서 처리.
+            if (!byMcp.has(mcp))
+                byMcp.set(mcp, skillName);
+        }
+    }
+    return { byMcp, bySkill, root: skillsRoot };
+}
+/**
+ * skill_mcp 호출 인자에서 mcp_name 을 안전하게 추출한다.
+ * 호출 형식은 { mcp_name: string, ... } 이며, 미제공이면 undefined.
+ */
+export function extractMcpName(args) {
+    if (args && typeof args === "object" && "mcp_name" in args) {
+        const v = args.mcp_name;
+        if (typeof v === "string" && v.trim())
+            return v.trim();
+    }
+    return undefined;
+}
+/**
+ * opencode 가 반환하는 "MCP server ... not found" 에러 문자열을 감지한다.
+ * 정확한 문구는 opencode 버전에 따라 달라질 수 있으므로 관용적으로 매칭한다.
+ */
+export function looksLikeMcpNotFound(output) {
+    if (!output)
+        return false;
+    // "MCP server \"works\" not found" / "MCP server 'works' not found" /
+    // "MCP server works not found" 모두 커버.
+    return /MCP\s+server\s+["']?[A-Za-z0-9_.-]+["']?\s+not\s+found/i.test(output);
+}
+// "Failed to connect to MCP server \"works\"." / "MCP error -32000: Connection closed" 패턴.
+// opencode 가 embedded MCP 프로세스 종료(exit non-zero) 시 반환하는 문구.
+export function looksLikeMcpConnectionFailed(output) {
+    if (!output)
+        return false;
+    return (/Failed\s+to\s+connect\s+to\s+MCP\s+server/i.test(output) ||
+        /MCP\s+error\s+-32000[^:]*:\s*Connection\s+closed/i.test(output));
+}

package/dist/stall-escalation.d.ts

@@ -0,0 +1 @@
+export declare function shouldEscalateStall(hangCount: number, threshold: number): boolean;

package/dist/stall-escalation.js

@@ -0,0 +1,22 @@
+// Cross-call stall escalation for dispatch_stage.
+//
+// Lives in its own module rather than opencode-plugin.ts because opencode's
+// plugin loader invokes EVERY named export of the plugin entry file as a
+// plugin factory (see test/plugin-exports-shape.test.mjs and the PROJ-40406
+// root-cause analysis). Helpers must therefore be imported, never re-exported
+// from the entry file.
+// dispatch_stage bounds retries with MAX_ATTEMPTS, but that budget lives
+// inside a single tool call. When the orchestrator reacts to a failure by
+// calling dispatch_stage again the budget resets, so a substage whose model
+// keeps hanging loops forever. hang_history is the only counter that survives
+// across calls, which makes it the escalation signal.
+//
+// hangCount comes from `state.sh get … | length`, so an unreadable or corrupt
+// state.json yields NaN. Treating NaN as "escalate" would deadlock every
+// workflow that cannot read its state file, so unreadable input fails open —
+// blocking happens only on a value we actually trust.
+export function shouldEscalateStall(hangCount, threshold) {
+    if (!Number.isFinite(hangCount) || !Number.isFinite(threshold))
+        return false;
+    return hangCount >= threshold;
+}

package/dist/tmux-monitor.d.ts

@@ -0,0 +1,193 @@
+type ShellTag = (strings: TemplateStringsArray, ...values: unknown[]) => {
+    cwd(dir: string): ReturnType<ShellTag>;
+    quiet(): ReturnType<ShellTag>;
+    nothrow(): ReturnType<ShellTag>;
+    then<T>(onfulfilled: (value: ShellResult) => T): Promise<T>;
+};
+interface ShellResult {
+    exitCode: number;
+    stdout?: {
+        toString(): string;
+    };
+    stderr?: {
+        toString(): string;
+    };
+}
+export type TmuxLayout = "main-vertical" | "main-horizontal" | "tiled" | "even-horizontal" | "even-vertical";
+export type TmuxPlacement = "window" | "pane";
+export declare const FOCUS_POLL_INTERVAL_MS = 2000;
+export interface TmuxMonitorConfig {
+    enabled: boolean;
+    placement: TmuxPlacement;
+    layout: TmuxLayout;
+    mainPaneSize: number;
+    agentPaneMinWidth: number;
+    splitDirection: "-h" | "-v";
+    attachCommand: string;
+    serverUrl?: string;
+    keepPaneOnSuccess: boolean;
+    autoCloseOnFailure: boolean;
+    paneCloseDelaySeconds: number;
+}
+export declare function isInsideTmux(): boolean;
+export declare function buildWindowName(stage: string, sessionId: string): string;
+export declare function buildPlaceholderCommand(stage: string, agent: string, sessionId: string): string;
+export declare const MARKER_SESSION = "@mdn2_session";
+export declare const MARKER_PID = "@mdn2_pid";
+export declare const MARKER_STAGE = "@mdn2_stage";
+export declare const MARKER_STARTED = "@mdn2_started_at";
+export declare const PARENT_MARKER_PATTERN: RegExp;
+export interface TmuxConfigBlock {
+    enabled?: boolean;
+    placement?: string;
+    layout?: string;
+    main_pane_size?: number;
+    agent_pane_min_width?: number;
+    split_direction?: string;
+    attach_command?: string;
+    server_url?: string | null;
+    keep_pane_on_success?: boolean;
+    auto_close_on_failure?: boolean;
+    pane_close_delay_seconds?: number;
+}
+export declare function readTmuxConfig(block?: TmuxConfigBlock): TmuxMonitorConfig;
+export interface OrphanScanResult {
+    paneId: string;
+    sessionId: string;
+    stage?: string;
+    startedAt?: number;
+    ownerPid?: number;
+    startCommand?: string;
+}
+export interface CleanupOrphansOptions {
+    graceSeconds?: number;
+    now?: () => number;
+}
+/** EPERM means the pid exists but belongs to another user — still alive. */
+export declare function isPidAlive(pid: number): boolean;
+/**
+ * Grace window applied to freshly spawned panes during the orphan-scan tick.
+ * opencode's session.status() is scoped to the requesting directory, so a
+ * sub-session created inside a worktree never appears in the parent's status
+ * map. Without a spawn grace the very first tick after split-window reads
+ * `status=undefined` and kills a perfectly healthy pane.
+ */
+export declare const ORPHAN_SPAWN_GRACE_MS = 120000;
+export type OrphanGuardReason = "foreign-live-owner" | "spawn-grace" | "tool-activity";
+export interface OrphanGuardContext {
+    nowMs: number;
+    ownerPid: number;
+    lastToolExecuteAtMs?: number;
+    activeToolCount?: number;
+    spawnGraceMs?: number;
+    toolAliveWindowMs?: number;
+    isPidAlive?: (pid: number) => boolean;
+}
+/** @returns the guard that fired, or undefined when the pane may be cleaned up. */
+export declare function orphanCleanupGuard(pane: Pick<OrphanScanResult, "ownerPid" | "startedAt">, ctx: OrphanGuardContext): OrphanGuardReason | undefined;
+export interface CleanupOrphansReport {
+    tracked_closed: number;
+    orphans_closed: number;
+    parents_skipped: number;
+    fresh_skipped: number;
+    total_closed: number;
+}
+export declare class TmuxMonitor {
+    private readonly panes;
+    private readonly sourcePaneId;
+    private readonly $;
+    private readonly ownerPid;
+    private tmuxVersionCache;
+    private versionBlocked;
+    private focusTimer;
+    private focusPollInFlight;
+    readonly config: TmuxMonitorConfig;
+    constructor(shell: ShellTag, config: TmuxMonitorConfig, ownerPid?: number);
+    get active(): boolean;
+    get trackedPaneCount(): number;
+    get ownerProcessId(): number;
+    checkTmuxVersion(): Promise<{
+        ok: boolean;
+        version: string;
+    }>;
+    spawnPane(sessionId: string, stage: string, agent: string, worktree: string): Promise<string | null>;
+    private spawnPaneInner;
+    /**
+     * Swap a placeholder pane over to the real `opencode attach` TUI.
+     * Pane user options (@mdn2_*) survive respawn-pane, so ownership tracking is
+     * unaffected — verified against tmux 3.6.
+     */
+    activatePane(sessionId: string): Promise<boolean>;
+    /**
+     * One focus sweep. A pane counts as focused only when it is the active pane
+     * of the active window — `pane_active` alone is 1 for every window's own
+     * active pane, so both flags are required.
+     */
+    pollFocusOnce(): Promise<number>;
+    private startFocusWatch;
+    private stopFocusWatchIfIdle;
+    /**
+     * placement=window — own tmux window; `-d` leaves the active window (and thus
+     * 부장님's pane geometry) untouched. ARCHITECTURE.md §17.6.
+     */
+    private spawnInNewWindow;
+    private resolveSourceWindowTarget;
+    /** placement=pane — legacy split of 부장님's window. Resizes the source pane. */
+    private spawnInSplitPane;
+    private rebalanceLayout;
+    /**
+     * Sub-session 완료 시 pane 처리.
+     * - opts.success === true: paneCloseDelaySeconds 초 대기 후 kill (성공 로그 확인 시간 확보).
+     * - opts.success === false: autoCloseOnFailure이 true면 kill, 아니면 유지 (실패 진단용).
+     * - opts 미지정: 기존 호환 동작 — 즉시 kill.
+     *
+     * Fallback: if the in-memory Map lost the entry (plugin re-init between spawn
+     * and close), a tmux marker scan finds the pane by @mdn2_session and kills it.
+     */
+    closePane(sessionId: string, opts?: {
+        success: boolean;
+    }): Promise<void>;
+    /** Kill every tracked pane — used when the plugin shuts down. */
+    cleanup(): Promise<void>;
+    reapDeadOwnerPanes(opts?: {
+        graceSeconds?: number;
+        now?: () => number;
+    }): Promise<number>;
+    /**
+     * Discover every pane on the tmux server that carries our @mdn2_session
+     * marker. Parent opencode panes (--port) are NEVER returned regardless of
+     * markers — safety guard against accidental self-kill if the parent ever
+     * inherited a stale marker.
+     */
+    scanOrphans(): Promise<OrphanScanResult[]>;
+    /**
+     * Cleanup entry point invoked by the cleanup_panes tool. Kills every
+     * @mdn2_session-marked pane on the tmux server.
+     *
+     * Panes newer than opts.graceSeconds (default 0) are skipped to avoid
+     * killing panes still in the spawn window.
+     */
+    cleanupOrphans(opts?: CleanupOrphansOptions): Promise<CleanupOrphansReport>;
+    /**
+     * Locate a pane by its @mdn2_session marker. Survives plugin re-init
+     * (markers persist on the tmux server even when the in-memory Map is empty).
+     * Parent opencode panes (--port) are filtered by scanOrphans.
+     */
+    private findPaneBySession;
+    /**
+     * Force-kill the marker-matched pane for the given session id. Unlike
+     * closePane this bypasses in-memory tracking entirely and only cares
+     * about the tmux state, so it survives plugin restarts.
+     *
+     * Never touches parent opencode panes — the scanOrphans PARENT filter
+     * excludes any `--port` process.
+     */
+    forceKillBySessionId(sessionId: string): Promise<boolean>;
+    private writePaneMarkers;
+    private isPidAlive;
+    private killPane;
+    private discoverServerUrl;
+    /** Maximum number of agent panes that fit beside the main pane. */
+    private computeCapacity;
+}
+export {};