triflux 10.34.0 → 10.35.0

package/hub/server.mjs

@@ -246,7 +246,9 @@ async function parseBody(req) {
   return JSON.parse(Buffer.concat(chunks).toString());
 }
 
-const PID_DIR = join(homedir(), ".claude", "cache", "tfx-hub");
+const PID_DIR =
+  process.env.TFX_HUB_PID_DIR?.trim() ||
+  join(homedir(), ".claude", "cache", "tfx-hub");
 const PID_FILE = join(PID_DIR, "hub.pid");
 const TOKEN_FILE = join(homedir(), ".claude", ".tfx-hub-token");
 
@@ -1004,7 +1006,7 @@ export async function startHub({
     // DB를 npm 패키지 밖에 저장하여 npm update 시 EBUSY 방지
     // 기존: PROJECT_ROOT/.tfx/state/state.db (패키지 내부 → 락 충돌)
     // 변경: ~/.claude/cache/tfx-hub/state.db (패키지 외부 → 안전)
-    const hubCacheDir = join(homedir(), ".claude", "cache", "tfx-hub");
+    const hubCacheDir = PID_DIR;
     mkdirSync(hubCacheDir, { recursive: true });
     dbPath = join(hubCacheDir, "state.db");
   }

package/hub/team/build-worker-prompt.mjs

@@ -22,10 +22,23 @@ function formatLeaseFiles(leaseFiles) {
   return normalized.map((file) => `- ${file}`).join("\n");
 }
 
-export function buildLeaseScopedAcceptanceAppendix({ leaseFiles = [] } = {}) {
+function normalizeWorktreePath(worktreePath) {
+  return typeof worktreePath === "string" ? worktreePath.trim() : "";
+}
+
+export function buildLeaseScopedAcceptanceAppendix({
+  leaseFiles = [],
+  worktreePath,
+} = {}) {
+  const normalizedWorktreePath = normalizeWorktreePath(worktreePath);
+  const rootLine = normalizedWorktreePath
+    ? `작업 루트(절대경로): ${normalizedWorktreePath} — 아래 lease 경로와 모든 상대경로는 이 루트 기준으로만 해석한다.\n`
+    : "";
+
   return `
 
 ## Lease-scoped Acceptance / Lint Guard (자동 삽입됨)
+${rootLine}- 위 PRD 본문의 모든 제약과 acceptance 기준은 이 appendix 이후에도 그대로 유효하다.
 - 이 shard 의 파일 lease:
 ${formatLeaseFiles(leaseFiles)}
 - Acceptance, lint, and format checks are scoped to files changed by this shard; if that set is unclear, use only the lease list above.
@@ -51,7 +64,10 @@ ${SENTINEL_END}
 규약:
 - 두 sentinel 마커는 각자 자기 줄에 단독으로 출력 (앞뒤 newline)
 - 마커 사이 본문은 단일 JSON object (배열/primitive 금지)
-- commits_made 가 비어 있어도 됨 (no-op shard)
+- status 값은 ok | failed | blocked 중 하나
+- payload 출력 직전 \`git log -1 --format=%H\` 로 보고할 sha 가 실재하는지 검증하라
+- 코드 변경이 기대되는 shard 에서 변경/커밋을 못 했으면 status:failed 와 함께 reason 필드로 사유를 보고하라 — 그 경우 빈 commits_made 에 status:ok 는 금지
+- no-op shard 는 status:ok + 빈 commits_made 배열 허용
 - 마커 쌍은 stdout 에 정확히 한 번만 출력해야 함. 재emit 시 conductor 는 첫 BEGIN..END 한 쌍만 채택하며, 이후 stdout 은 무시한다.
 - ${SENTINEL_BEGIN} 만 출력하고 ${SENTINEL_END} 누락 시 conductor 가 truncation 으로 명확히 reject
 `;
@@ -60,14 +76,17 @@ ${SENTINEL_END}
  * Append the Completion Protocol section to a PRD prompt.
  *
  * @param {string|null|undefined} prdPrompt — original PRD body
- * @param {{ leaseFiles?: string[] }} [opts] — shard file lease for scoped acceptance
+ * @param {{ leaseFiles?: string[], worktreePath?: string }} [opts] — shard file lease and absolute worktree root for scoped acceptance
  * @returns {string} prompt with appendix
  */
 export function buildWorkerPrompt(prdPrompt, opts = {}) {
   const body = typeof prdPrompt === "string" ? prdPrompt : "";
   return (
     body +
-    buildLeaseScopedAcceptanceAppendix({ leaseFiles: opts.leaseFiles }) +
+    buildLeaseScopedAcceptanceAppendix({
+      leaseFiles: opts.leaseFiles,
+      worktreePath: opts.worktreePath,
+    }) +
     COMPLETION_PROTOCOL_APPENDIX
   );
 }

package/hub/team/claude-daemon-control.mjs

@@ -16,7 +16,24 @@ import {
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
-  return path.join(os.homedir(), ".claude");
+  return path.join(resolveClaudeHomeDir(env), ".claude");
+}
+
+export function resolveClaudeHomeDir(
+  env = process.env,
+  platform = process.platform,
+) {
+  // win32: claude daemon launcher 의 os.homedir() 는 USERPROFILE 기반이고
+  // HOME 을 보지 않는다. git-bash 가 HOME 을 따로 잡아도 launcher 폴백을
+  // 그대로 미러해야 socket hash 가 daemon 과 일치한다 (HOME 수용 금지).
+  if (platform === "win32") {
+    const userProfile = nullableEnv(env.USERPROFILE);
+    return userProfile ? path.resolve(userProfile) : os.homedir();
+  }
+  // POSIX 는 HOME 우선 — sandbox HOME 오버라이드를 추적하는 provenance
+  // 해석(#382)과 일치 (os.homedir() 도 POSIX 에서는 HOME 을 우선한다).
+  const home = nullableEnv(env.HOME);
+  return home ? path.resolve(home) : os.homedir();
 }
 
 export function deriveClaudeDaemonPaths({
@@ -44,6 +61,316 @@ export function deriveClaudeDaemonPaths({
   };
 }
 
+function nullableEnv(value) {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text.length > 0 ? text : null;
+}
+
+function defaultClaudeConfigDir(env = process.env) {
+  return path.join(resolveClaudeHomeDir(env), ".claude");
+}
+
+export function detectCallerProvenance(env = process.env) {
+  const claudeConfigDir = nullableEnv(env.CLAUDE_CONFIG_DIR);
+  const omxSessionId = nullableEnv(env.OMX_SESSION_ID);
+  const omxEntryPath = nullableEnv(env.OMX_ENTRY_PATH);
+  const codexThreadId = nullableEnv(env.CODEX_THREAD_ID);
+  const codexLauncher =
+    omxSessionId || omxEntryPath ? "omx" : codexThreadId ? "codex" : "unknown";
+  return {
+    claudeLauncher: "unknown",
+    codexLauncher,
+    signals: {
+      claudeConfigDir,
+      omxSessionId,
+      omxEntryPath,
+      codexThreadId,
+    },
+  };
+}
+
+export async function readOmcLaunchProfile(configDir) {
+  if (!configDir) return null;
+  try {
+    // Provenance hint only: OMC writes this profile in its runtime config dir.
+    // It is not an auth/security boundary and must not override explicit/env
+    // config-dir authority.
+    const parsed = JSON.parse(
+      await fs.readFile(
+        path.join(path.resolve(configDir), ".omc-launch-profile.json"),
+        "utf8",
+      ),
+    );
+    const sourceConfigDir = nullableEnv(parsed?.sourceConfigDir);
+    if (!sourceConfigDir) return null;
+    const sourceClaudeMd = nullableEnv(parsed?.sourceClaudeMd);
+    return {
+      sourceConfigDir: path.resolve(sourceConfigDir),
+      sourceClaudeMd: sourceClaudeMd ? path.resolve(sourceClaudeMd) : null,
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT" || error instanceof SyntaxError) return null;
+    return null;
+  }
+}
+
+async function buildClaudeDaemonCandidate({
+  configDir,
+  configDirSource,
+  selectionMode,
+  env,
+  uid,
+  tmpRoot,
+}) {
+  const paths = deriveClaudeDaemonPaths({ configDir, uid, tmpRoot });
+  const defaultConfig = path.resolve(defaultClaudeConfigDir(env));
+  const omcProfile = await readOmcLaunchProfile(paths.configDir);
+  const claudeLauncher = omcProfile
+    ? "omc"
+    : paths.configDir === defaultConfig
+      ? "claude"
+      : "unknown";
+  return {
+    ...paths,
+    configDirSource,
+    selectionMode,
+    claudeLauncher,
+    sourceConfigDir: omcProfile?.sourceConfigDir,
+    sourceClaudeMd: omcProfile?.sourceClaudeMd ?? null,
+    callerProvenance: detectCallerProvenance(env),
+  };
+}
+
+export async function buildClaudeDaemonDiscoveryCandidates({
+  configDir,
+  env = process.env,
+  uid = typeof process.getuid === "function" ? process.getuid() : 0,
+  tmpRoot = "/tmp",
+} = {}) {
+  const explicitConfigDir = nullableEnv(configDir);
+  if (explicitConfigDir) {
+    return [
+      await buildClaudeDaemonCandidate({
+        configDir: explicitConfigDir,
+        configDirSource: "explicit",
+        selectionMode: "exact",
+        env,
+        uid,
+        tmpRoot,
+      }),
+    ];
+  }
+
+  const envConfigDir = nullableEnv(env.CLAUDE_CONFIG_DIR);
+  if (envConfigDir) {
+    return [
+      await buildClaudeDaemonCandidate({
+        configDir: envConfigDir,
+        configDirSource: "env",
+        selectionMode: "env-strict",
+        env,
+        uid,
+        tmpRoot,
+      }),
+    ];
+  }
+
+  const candidates = [];
+  const defaultConfig = defaultClaudeConfigDir(env);
+  const omcRuntime = path.join(defaultConfig, ".omc-launch");
+  if (await readOmcLaunchProfile(omcRuntime)) {
+    candidates.push(
+      await buildClaudeDaemonCandidate({
+        configDir: omcRuntime,
+        configDirSource: "omc-runtime",
+        selectionMode: "ambient",
+        env,
+        uid,
+        tmpRoot,
+      }),
+    );
+  }
+  candidates.push(
+    await buildClaudeDaemonCandidate({
+      configDir: defaultConfig,
+      configDirSource: "default",
+      selectionMode: "ambient",
+      env,
+      uid,
+      tmpRoot,
+    }),
+  );
+  return candidates;
+}
+
+export function publicClaudeDaemonCandidate(candidate) {
+  if (!candidate) return null;
+  return {
+    configDirSource: candidate.configDirSource,
+    selectionMode: candidate.selectionMode,
+    claudeLauncher: candidate.claudeLauncher,
+    configDir: candidate.configDir,
+    sourceConfigDir: candidate.sourceConfigDir ?? null,
+    sourceClaudeMd: candidate.sourceClaudeMd ?? null,
+    hash: candidate.hash,
+    controlSock: candidate.controlSock,
+  };
+}
+
+function sessionsFromDaemonList(listResponse) {
+  // probe 경로도 list/find 경로와 같은 정규화 row 를 내보내야 한다
+  // (jobs/sessions, snake_case, dispatch 중첩 변형 흡수 — 8016b724).
+  return extractClaudeAgentSessions(listResponse);
+}
+
+function errorMessage(error) {
+  return error?.message || String(error);
+}
+
+function findDaemonTargetInSessions(sessions, { short, sessionId } = {}) {
+  if (sessionId) {
+    return findDaemonJobBySessionId({ jobs: sessions }, sessionId);
+  }
+  if (short) {
+    return findDaemonJobByShort({ jobs: sessions }, short);
+  }
+  return null;
+}
+
+function candidateResultSummary(result) {
+  const summary = publicClaudeDaemonCandidate(result.candidate);
+  return {
+    ...summary,
+    ok: result.ok === true,
+    error: result.error ?? null,
+    sessionCount: Array.isArray(result.sessions) ? result.sessions.length : 0,
+  };
+}
+
+function buildProbeResponse({
+  candidates,
+  results,
+  selected,
+  matches,
+  targetRequested,
+  callerProvenance,
+}) {
+  const reachable = results.filter((result) => result.ok === true);
+  let ok = false;
+  let reason = "daemon-unavailable";
+  let error = null;
+
+  if (targetRequested && matches.length > 1) {
+    reason = "ambiguous-target";
+    error = `Claude daemon target ambiguous across ${matches.length} candidates`;
+  } else if (selected) {
+    ok = true;
+    reason = selected.target ? "target-found" : "daemon-available";
+  } else if (targetRequested && reachable.length > 0) {
+    reason = "target-not-found";
+    error = "Claude daemon target not found in reachable candidates";
+  } else if (results.length > 0) {
+    error =
+      results
+        .map((result) => result.error)
+        .filter(Boolean)
+        .join("; ") || "Claude daemon unavailable";
+  }
+
+  const selectedSessions = selected
+    ? selected.sessions
+    : targetRequested
+      ? []
+      : reachable.flatMap((result) => result.sessions);
+  const selectedDaemon = publicClaudeDaemonCandidate(selected?.candidate);
+  const reachableDaemons = reachable.map((result) =>
+    publicClaudeDaemonCandidate(result.candidate),
+  );
+
+  return {
+    ok,
+    reason,
+    controlSock: selected?.candidate?.controlSock,
+    daemon: selectedDaemon,
+    daemons: reachableDaemons,
+    sessions: selectedSessions,
+    target: selected?.target || undefined,
+    matches: matches.map((match) => ({
+      daemon: publicClaudeDaemonCandidate(match.candidate),
+      target: match.target,
+    })),
+    candidateResults: results.map(candidateResultSummary),
+    callerProvenance,
+    candidates: candidates.map(publicClaudeDaemonCandidate),
+    error: ok ? undefined : error,
+  };
+}
+
+export async function probeClaudeDaemonCandidates({
+  configDir,
+  env = process.env,
+  short,
+  sessionId,
+  timeoutMs = 6000,
+} = {}) {
+  const candidates = await buildClaudeDaemonDiscoveryCandidates({
+    configDir,
+    env,
+  });
+  const callerProvenance = detectCallerProvenance(env);
+  const targetRequested = Boolean(short || sessionId);
+  const results = [];
+
+  for (const candidate of candidates) {
+    try {
+      const list = await sendClaudeControlRequest(
+        candidate.controlSock,
+        { proto: 1, op: "list" },
+        { timeoutMs },
+      );
+      const sessions = sessionsFromDaemonList(list);
+      const ok = list?.ok !== false;
+      results.push({
+        ok,
+        candidate,
+        list,
+        sessions: ok ? sessions : [],
+        target: ok
+          ? findDaemonTargetInSessions(sessions, { short, sessionId })
+          : null,
+        error: ok ? null : list?.error || "Claude daemon list failed",
+      });
+    } catch (error) {
+      results.push({
+        ok: false,
+        candidate,
+        list: null,
+        sessions: [],
+        target: null,
+        error: errorMessage(error),
+      });
+    }
+  }
+
+  const matches = targetRequested
+    ? results.filter((result) => result.ok === true && result.target)
+    : [];
+  const selected = targetRequested
+    ? matches.length === 1
+      ? matches[0]
+      : null
+    : results.find((result) => result.ok === true) || null;
+
+  return buildProbeResponse({
+    candidates,
+    results,
+    selected,
+    matches,
+    targetRequested,
+    callerProvenance,
+  });
+}
+
 export function getProcStart(pid = process.pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     throw new Error(`invalid pid: ${pid}`);
@@ -141,6 +468,7 @@ export function buildDaemonAttachRequest({
   cols = DEFAULT_DAEMON_ATTACH_COLS,
   rows = 40,
   caps = { terminal: null, mux: null, ssh: false },
+  auth,
 } = {}) {
   if (!short) throw new Error("short is required");
   return {
@@ -150,6 +478,7 @@ export function buildDaemonAttachRequest({
     cols,
     rows,
     caps,
+    ...(auth ? { auth } : {}),
   };
 }
 
@@ -683,6 +1012,7 @@ export function attachClaudeDaemonSession({
   controlSock,
   short,
   input,
+  auth,
   cols = DEFAULT_DAEMON_ATTACH_COLS,
   rows = 40,
   caps,
@@ -790,7 +1120,9 @@ export function attachClaudeDaemonSession({
     });
     socket.on("connect", () => {
       socket.write(
-        `${JSON.stringify(buildDaemonAttachRequest({ short, cols, rows, caps }))}\n`,
+        `${JSON.stringify(
+          buildDaemonAttachRequest({ short, cols, rows, caps, auth }),
+        )}\n`,
       );
     });
     socket.on("data", (chunk) => {
@@ -906,6 +1238,7 @@ export function attachClaudeDaemonSession({
 export function interruptClaudeDaemonSession({
   controlSock,
   short,
+  auth,
   cols = DEFAULT_DAEMON_ATTACH_COLS,
   rows = 40,
   caps,
@@ -956,7 +1289,9 @@ export function interruptClaudeDaemonSession({
     socket.on("error", fail);
     socket.on("connect", () => {
       socket.write(
-        `${JSON.stringify(buildDaemonAttachRequest({ short, cols, rows, caps }))}\n`,
+        `${JSON.stringify(
+          buildDaemonAttachRequest({ short, cols, rows, caps, auth }),
+        )}\n`,
       );
     });
     socket.on("data", (chunk) => {
@@ -1182,6 +1517,7 @@ export async function sendKillBySessionId({
   daemonPaths,
   sessionId,
   timeoutMs = 6000,
+  auth,
 } = {}) {
   const controlSock = daemonPaths?.controlSock;
   if (!controlSock || !sessionId) {
@@ -1201,12 +1537,16 @@ export async function sendKillBySessionId({
     if (!job?.short) {
       return { ok: true, killed: false, reason: "not_found" };
     }
+    const controlAuth = auth
+      ? { auth }
+      : await buildDaemonControlAuth(daemonPaths?.configDir);
     return await sendClaudeControlRequest(
       controlSock,
       {
         proto: 1,
         op: "kill",
         short: job.short,
+        ...controlAuth,
       },
       { timeoutMs },
     );
@@ -1356,6 +1696,7 @@ export async function teardownClaudeDaemonJob({
     _deps.removeClaudeSessionProjection || removeClaudeSessionProjection;
   const killJob = _deps.killDaemonJob || killDaemonJob;
   const removeJobStateImpl = _deps.removeClaudeJobState;
+  const buildAuth = _deps.buildDaemonControlAuth || buildDaemonControlAuth;
   const resolvedControlSock = controlSock || paths?.controlSock;
   const resolvedJobsDir =
     jobsDir ||
@@ -1371,7 +1712,10 @@ export async function teardownClaudeDaemonJob({
     steps.push(sendKillBySessionId({ daemonPaths, sessionId }).catch(() => {}));
   }
   if (resolvedControlSock && short) {
-    steps.push(killJob(resolvedControlSock, short).catch(() => {}));
+    const controlAuth = await buildAuth(paths?.configDir);
+    steps.push(
+      killJob(resolvedControlSock, short, controlAuth).catch(() => {}),
+    );
   }
   if (removeJobState && removeJobStateImpl && resolvedJobsDir && short) {
     steps.push(removeJobStateImpl(resolvedJobsDir, short).catch(() => {}));

package/hub/team/claude-native-bridge.mjs

@@ -10,6 +10,7 @@ import {
   dispatchClaudeDaemonJob,
   getProcStart,
   killDaemonJob,
+  resolveClaudeConfigDir,
   resolveDaemonBridgeSessionId,
   sendClaudeControlRequest,
   teardownClaudeDaemonJob,
@@ -22,9 +23,11 @@ import {
 } from "./claude-session-projection.mjs";
 import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
 
-// daemon-control 이 deriveClaudeDaemonPaths / getProcStart 의 단일 owner 다.
-// 기존 native-bridge import 경로 (headless 포함) 호환을 위해 re-export 한다.
-export { deriveClaudeDaemonPaths, getProcStart };
+// daemon-control 이 deriveClaudeDaemonPaths / getProcStart /
+// resolveClaudeConfigDir 의 단일 owner 다. configDir 해석이 갈리면 양쪽이
+// 서로 다른 control.sock hash 를 보게 되므로 (HOME 오버라이드 split-brain)
+// 로컬 복제본을 두지 않는다. 기존 import 경로 호환을 위해 re-export 한다.
+export { deriveClaudeDaemonPaths, getProcStart, resolveClaudeConfigDir };
 
 const DEFAULT_ROWS = 40;
 const DEFAULT_COLS = 120;
@@ -33,11 +36,6 @@ const ROSTER_LOCK_STALE_MS = 30_000;
 const ROSTER_LOCK_TIMEOUT_MS = 5_000;
 const ROSTER_LOCK_RETRY_MS = 10;
 
-export function resolveClaudeConfigDir(env = process.env) {
-  if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
-  return path.join(os.homedir(), ".claude");
-}
-
 export function buildPtyDataFrame(value) {
   const payload = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
   const frame = Buffer.allocUnsafe(5 + payload.length);

package/hub/team/conductor.mjs

@@ -1140,6 +1140,7 @@ export function createConductor(opts = {}) {
       const sandbox = buildWorkerSandboxEnv({
         cwd: resolvedConfig.workdir || process.cwd(),
         sessionId: resolvedConfig.id,
+        agent: resolvedConfig.agent,
         env: { ...process.env, ...(resolvedConfig.env || {}) },
       });
       resolvedConfig = {

package/hub/team/handoff.mjs

@@ -23,7 +23,7 @@ After completing the task, you MUST output a HANDOFF block in exactly this forma
 status: ok | partial | failed
 lead_action: accept | needs_read | retry | reassign
 task: <1-3 word task type>
-files_changed: <comma-separated file paths, or "none">
+files_changed: <comma-separated repo-root relative file paths, or "none">
 verdict: <one sentence conclusion>
 confidence: high | medium | low
 risk: low | med | high
@@ -36,21 +36,25 @@ partial_output: yes | no
 
 Rules:
 - The HANDOFF block must start with exactly "--- HANDOFF ---"
+- Set status: ok only after you have verified the work (file/diff/test evidence) — unverified claims must use partial or failed.
 - Each field must be on its own line as "key: value"
+- Report files_changed as repo-root relative paths
 - verdict must be a single concise sentence
 - Do not skip any required field
+- This block owns the final output position; this block must be the last thing you output
 `.trim();
 
 /**
  * CLI 프롬프트 길이 제한을 고려한 축약 HANDOFF 지시
  */
-export const HANDOFF_INSTRUCTION_SHORT = `After completing, output this block at the end:
+export const HANDOFF_INSTRUCTION_SHORT = `After completing, output this block at the end; this block must be the last thing you output:
 --- HANDOFF ---
 status: ok | partial | failed
 lead_action: accept | needs_read | retry | reassign
 verdict: <one sentence>
-files_changed: <comma-separated paths or "none">
-confidence: high | medium | low`;
+files_changed: <comma-separated repo-root relative paths or "none">
+confidence: high | medium | low
+Set status: ok only after you have verified the work (file/diff/test evidence) — unverified claims must use partial or failed.`;
 
 /**
  * raw 텍스트에서 HANDOFF 블록을 파싱한다.

package/hub/team/headless.mjs

@@ -18,7 +18,7 @@ import {
 import { createRequire } from "node:module";
 import net from "node:net";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { requestJson } from "../bridge.mjs";
 import { escapePwshSingleQuoted } from "../cli-adapter-base.mjs";
@@ -26,6 +26,7 @@ import { getMaxSpawnPerSec } from "../lib/spawn-trace.mjs";
 import { IS_WINDOWS } from "../platform.mjs";
 import { getBackend } from "./backend.mjs";
 import {
+  buildDaemonControlAuth,
   buildDaemonExecDispatchPayload,
   deriveClaudeDaemonPaths as deriveClaudeControlPaths,
   dispatchClaudeDaemonJob,
@@ -255,7 +256,7 @@ function unregisterHeadlessSynapseWorker(workerId) {
 /** MCP 프로필별 프롬프트 힌트 (tfx-route.sh resolve_mcp_policy의 경량 미러) */
 const MCP_PROFILE_HINTS = {
   implement:
-    "You have full filesystem read/write access. Implement changes directly.",
+    "You have full filesystem read/write access. Implement changes directly. After changes, run the narrowest relevant test/lint for the files you touched; if none can run, state why and the next-best check.",
   analyze:
     "Focus on reading and analyzing the codebase. Prefer analysis over modification.",
   review: "Review the code for quality, security, and correctness.",
@@ -301,22 +302,31 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   // contextFile 처리: 32KB(32768 bytes) 초과 시 UTF-8 안전 절단
   let contextPrefix = "";
   if (contextFile && existsSync(contextFile)) {
+    const contextSource = resolve(contextFile);
     let ctx = readFileSync(contextFile, "utf8");
+    let truncated = false;
     if (Buffer.byteLength(ctx, "utf8") > 32768) {
       ctx = Buffer.from(ctx).subarray(0, 32768).toString("utf8");
+      truncated = true;
+    }
+    if (truncated) {
+      ctx = `${ctx}\n[... truncated at 32KB]`;
     }
     if (ctx.length > 0) {
-      contextPrefix = `<prior_context>\n${ctx}\n</prior_context>\n\n`;
+      contextPrefix = `<prior_context source="${contextSource}" truncated="${truncated ? "true" : "false"}">\n${ctx}\n</prior_context>\nBase your work on the prior_context above; if it conflicts with the task below, the task wins.\n\n`;
     }
   }
 
   const mcpHint =
     mcp && MCP_PROFILE_HINTS[mcp]
-      ? ` [MCP: ${mcp}] ${MCP_PROFILE_HINTS[mcp]}`
+      ? `\n\n[MCP: ${mcp}]\n${MCP_PROFILE_HINTS[mcp]}`
       : "";
+  const workspaceHint = cwd
+    ? `\n\n[workspace] root(절대경로): ${resolve(cwd)}. 모든 상대경로는 이 루트 기준. 파일 쓰기/커밋 전 \`git rev-parse --show-toplevel\` 이 이 root 와 일치하는지 확인하고 불일치 시 중단·보고.`
+    : "";
   // P2: HANDOFF 지시를 프롬프트에 삽입 (워커가 구조화된 handoff 블록을 출력하도록)
   const handoffHint = handoff ? `\n\n${HANDOFF_INSTRUCTION_SHORT}` : "";
-  const fullPrompt = `${contextPrefix}${prompt}${mcpHint}${handoffHint}`;
+  const fullPrompt = `${contextPrefix}${prompt}${mcpHint}${workspaceHint}${handoffHint}`;
 
   // 보안: 프롬프트를 임시 파일에 쓰고 파일 참조로 전달 (셸 주입 방지).
   // 이전 구현은 `"$(cat 'PATH')"` shell-expansion expression 을 만들어
@@ -1064,9 +1074,14 @@ export async function cleanupDaemonDispatches(dispatches) {
         }).catch(() => {});
       }
       if (dispatch.controlSock && dispatch.daemonShort) {
-        await killDaemonJob(dispatch.controlSock, dispatch.daemonShort).catch(
-          () => {},
-        );
+        const controlAuth = await buildDaemonControlAuth(
+          dispatch.daemonPaths?.configDir,
+        ).catch(() => ({}));
+        await killDaemonJob(
+          dispatch.controlSock,
+          dispatch.daemonShort,
+          controlAuth,
+        ).catch(() => {});
       }
     }),
   );
@@ -1244,9 +1259,16 @@ async function waitForDaemonCompletion(
         dispatch.daemonCompletionMatched = true;
         cleanupDaemonDispatches([dispatch]).catch(() => {});
       } else {
-        killDaemonJob(dispatch.controlSock, dispatch.daemonShort).catch(
-          () => {},
-        );
+        buildDaemonControlAuth(dispatch.daemonPaths?.configDir)
+          .catch(() => ({}))
+          .then((controlAuth) =>
+            killDaemonJob(
+              dispatch.controlSock,
+              dispatch.daemonShort,
+              controlAuth,
+            ),
+          )
+          .catch(() => {});
       }
       resolve(finalCompletion);
     };