@brawnen/agent-harness-cli 0.1.0 → 0.1.2

package/src/lib/output-policy.js

@@ -199,22 +199,22 @@ function matchesArtifactCondition(condition, taskContext) {
       return inferCrossModuleChange(taskContext.scope);
     }
     if (normalized === "public_contract_changed") {
-      return hasKeyword(taskContext.goal, ["api", "schema", "接口", "契约", "协议", "contract"]);
+      return hasKeyword(taskContext.goal, ["public contract", "api schema", "schema change", "breaking change", "接口契约", "公开契约", "兼容性变更"]);
     }
     if (normalized === "reusable_decision") {
-      return hasKeyword(taskContext.goal, ["复用", "通用", "shared", "reusable"]);
+      return hasKeyword(taskContext.goal, ["复用决策", "通用方案", "shared decision", "reusable decision", "通用能力"]);
     }
     if (normalized === "architectural_decision") {
-      return hasKeyword(taskContext.goal, ["架构", "architecture", "协议", "adapter", "hook"]);
+      return hasKeyword(taskContext.goal, ["架构决策", "architecture decision", "架构边界", "runtime boundary"]);
     }
     if (normalized === "policy_change") {
-      return hasKeyword(taskContext.goal, ["策略", "policy", "规则"]);
+      return hasKeyword(taskContext.goal, ["治理策略", "policy as code", "policy change", "策略变更"]);
     }
     if (normalized === "protocol_change") {
-      return hasKeyword(taskContext.goal, ["协议", "protocol"]);
+      return hasKeyword(taskContext.goal, ["协议变更", "protocol change", "schema migration"]);
     }
     if (normalized === "host_adapter_contract_change") {
-      return hasKeyword(taskContext.goal, ["adapter", "适配", "hook", "codex", "claude", "gemini"]);
+      return hasKeyword(taskContext.goal, ["adapter contract", "host contract", "适配器契约", "宿主契约"]);
     }
     return false;
   }

package/src/lib/runtime-paths.js

@@ -4,6 +4,13 @@ import path from "node:path";
 export const DEFAULT_RUNTIME_DIR = ".harness";
 export const LEGACY_RUNTIME_DIR = "harness";
 
+const STRONG_PROJECT_ROOT_MARKERS = [
+  "harness.yaml",
+  ".codex/hooks.json",
+  ".claude/settings.json",
+  ".gemini/settings.json"
+];
+
 export function resolveRuntimeDirName(cwd, options = {}) {
   const preferExisting = options.preferExisting !== false;
   if (preferExisting) {
@@ -17,6 +24,26 @@ export function resolveRuntimeDirName(cwd, options = {}) {
   return DEFAULT_RUNTIME_DIR;
 }
 
+export function resolveHarnessProjectRoot(cwd) {
+  const fallback = path.resolve(cwd || process.cwd());
+  let current = fallback;
+  let bestCandidate = null;
+
+  while (true) {
+    const score = getProjectRootScore(current);
+    if (score > 0 && (!bestCandidate || score > bestCandidate.score)) {
+      bestCandidate = { path: current, score };
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return bestCandidate?.path ?? fallback;
+    }
+
+    current = parent;
+  }
+}
+
 export function runtimePath(cwd, ...segments) {
   return path.join(cwd, resolveRuntimeDirName(cwd), ...segments);
 }
@@ -44,3 +71,15 @@ export function runtimeRelativeCandidates(...segments) {
 export function hasRuntimeSetup(cwd) {
   return runtimeRelativeCandidates().some((relativePath) => fs.existsSync(path.join(cwd, relativePath)));
 }
+
+function getProjectRootScore(cwd) {
+  if (STRONG_PROJECT_ROOT_MARKERS.some((relativePath) => fs.existsSync(path.join(cwd, relativePath)))) {
+    return 2;
+  }
+
+  if (fs.existsSync(path.join(cwd, DEFAULT_RUNTIME_DIR)) || fs.existsSync(path.join(cwd, LEGACY_RUNTIME_DIR))) {
+    return 1;
+  }
+
+  return 0;
+}

package/src/lib/task-core.js

@@ -25,6 +25,45 @@ const CONTINUE_KEYWORDS = [
   "follow-up"
 ];
 
+const AFFIRMATIVE_SHORT_REPLIES = [
+  "ok", "okay", "好", "好的", "嗯", "对", "是的", "可以",
+  "行", "没问题", "同意", "确认", "yes", "yep", "sure", "lgtm",
+  "先这样", "就这样", "开始吧", "搞起", "go"
+];
+
+const TASK_REFERENCE_KEYWORDS = [
+  "刚才那个",
+  "刚才这个",
+  "刚才的任务",
+  "这个任务",
+  "这个问题",
+  "这个方案",
+  "当前任务",
+  "前面那个"
+];
+
+const TASK_REPLY_PREFIXES = [
+  "先做",
+  "先看",
+  "先把",
+  "先",
+  "再",
+  "然后",
+  "接着",
+  "列一下",
+  "看一下",
+  "看看",
+  "全部",
+  "只",
+  "统一",
+  "收敛成",
+  "按这个",
+  "就按这个",
+  "好，",
+  "好,",
+  "那就"
+];
+
 const NEW_TASK_KEYWORDS = [
   "新任务",
   "另一个问题",
@@ -53,7 +92,6 @@ const MANUAL_CONFIRMATION_KEYWORDS = [
   "允许继续",
   "就按这个做",
   "按这个做",
-  "继续",
   "go ahead",
   "proceed"
 ];
@@ -94,8 +132,13 @@ export function buildTaskDraftFromInput(sourceInput, options = {}) {
   const riskLevel = inferRiskLevel(input, riskSignals);
   const intent = options.intent ?? inferIntent(input);
   const mode = options.mode ?? (intent === "explore" ? "explore" : "delivery");
-  const nextAction = openQuestions.length > 0 ? "clarify" : "plan";
-  const derivedState = openQuestions.length > 0 ? "needs_clarification" : "planned";
+  const hasOpenQuestions = openQuestions.length > 0;
+  const nextAction = hasOpenQuestions
+    ? (riskLevel === "high" ? "clarify" : "observe")
+    : "plan";
+  const derivedState = hasOpenQuestions
+    ? (riskLevel === "high" ? "needs_clarification" : "draft")
+    : "planned";
 
   return {
     schema_version: "0.3",
@@ -241,11 +284,11 @@ export function autoIntakePrompt(cwd, prompt) {
   }
 
   const decision = classifyPromptAgainstTask(input, activeTask);
-  if (decision.type === "continue") {
+  if (decision.type === "continue" || decision.type === "provisional_continue") {
     return {
       action: "continue",
       task: activeTask,
-      additionalContext: buildCurrentTaskContext(activeTask),
+      additionalContext: "",
       decision
     };
   }
@@ -281,13 +324,11 @@ export function buildCurrentTaskContext(taskState) {
   }
 
   const goal = taskState?.confirmed_contract?.goal ?? taskState?.task_draft?.goal ?? "未定义目标";
-  const nextAction = deriveNextAction(taskState);
-  const currentState = taskState?.current_state ?? "unknown";
   const blockingQuestion = Array.isArray(taskState?.open_questions) && taskState.open_questions.length > 0
-    ? ` 当前阻断问题：${taskState.open_questions[0]}`
+    ? ` 阻断：${taskState.open_questions[0]}`
     : "";
 
-  return `当前 active task: ${taskState.task_id}。目标：${goal}。当前状态：${currentState}。下一步动作：${nextAction}。${blockingQuestion}`.trim();
+  return `当前任务 ${taskState.task_id}：${goal}。${blockingQuestion}`.trim();
 }
 
 export function buildNewTaskContext(taskState) {
@@ -296,7 +337,7 @@ export function buildNewTaskContext(taskState) {
   }
 
   const draft = taskState.task_draft ?? {};
-  return `已自动创建新任务 ${taskState.task_id}。intent=${draft.intent}，goal=${draft.goal}，next_action=${draft.next_action}。请先按该任务继续。`;
+  return `已切换到新任务 ${taskState.task_id}：${draft.goal}。`;
 }
 
 export function classifyUserOverridePrompt(prompt) {
@@ -389,20 +430,53 @@ function classifyPromptAgainstTask(prompt, activeTask) {
     });
   }
 
+  if (isAffirmativeShortReply(normalizedPrompt)) {
+    return buildDecision("continue", {
+      reasonCode: "affirmative_short_reply",
+      reason: "输入为确认性短回复，视为延续当前任务。",
+      matchedSignals: ["affirmative_short_reply"],
+      confidence: "medium"
+    });
+  }
+
+  const matchedTaskReference = TASK_REFERENCE_KEYWORDS.find((keyword) => normalizedPrompt.includes(keyword));
+  if (matchedTaskReference) {
+    return buildDecision("continue", {
+      reasonCode: "matched_task_reference",
+      reason: `输入命中当前任务指代：${matchedTaskReference}。`,
+      matchedSignals: [`task_reference:${matchedTaskReference}`],
+      confidence: "medium"
+    });
+  }
+
+  if (isLikelyTaskReply(normalizedPrompt)) {
+    return buildDecision("provisional_continue", {
+      reasonCode: "likely_task_reply",
+      reason: "输入更像是当前任务内的步骤选择或简短回复，先续接当前任务观察。",
+      matchedSignals: ["likely_task_reply"],
+      confidence: "low"
+    });
+  }
+
   const ambiguous = isAmbiguousPrompt(prompt);
   if (ambiguous) {
     const matchedHighRiskKeyword = findMatchedKeyword(normalizedPrompt, HIGH_RISK_KEYWORDS);
     const highRisk = Boolean(matchedHighRiskKeyword);
-    return buildDecision("clarify", {
-      block: highRisk,
-      reasonCode: highRisk ? "ambiguous_high_risk_prompt" : "ambiguous_prompt",
-      reason: highRisk
-        ? "当前输入任务归属不明且包含高风险信号。先澄清是在延续旧任务还是新任务，再继续执行。"
-        : "当前输入无法可靠判断是在延续旧任务还是新任务。先向用户澄清任务归属，再继续执行。",
-      matchedSignals: highRisk
-        ? [`high_risk_keyword:${matchedHighRiskKeyword}`, "ambiguous_prompt"]
-        : ["ambiguous_prompt"],
-      confidence: highRisk ? "high" : "low"
+    if (highRisk) {
+      return buildDecision("clarify", {
+        block: true,
+        reasonCode: "ambiguous_high_risk_prompt",
+        reason: "输入任务归属不明且含高风险信号，请先澄清。",
+        matchedSignals: [`high_risk_keyword:${matchedHighRiskKeyword}`, "ambiguous_prompt"],
+        confidence: "high"
+      });
+    }
+
+    return buildDecision("provisional_continue", {
+      reasonCode: "ambiguous_low_risk_continue",
+      reason: "输入较短且无高风险信号，先按当前任务续接并观察。",
+      matchedSignals: ["ambiguous_prompt", "low_risk"],
+      confidence: "low"
     });
   }
 
@@ -428,6 +502,16 @@ function isAmbiguousPrompt(prompt) {
   return ["看一下这个", "有个问题", "帮我处理一下", "处理下", "看看这个"].some((text) => normalized.includes(text));
 }
 
+function isAffirmativeShortReply(normalizedPrompt) {
+  const trimmed = normalizedPrompt.trim();
+  return AFFIRMATIVE_SHORT_REPLIES.some((reply) => trimmed === reply);
+}
+
+function isLikelyTaskReply(normalizedPrompt) {
+  const trimmed = normalizedPrompt.trim();
+  return TASK_REPLY_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+
 function inferIntent(input) {
   const normalized = input.toLowerCase();
   if (EXPLORE_KEYWORDS.some((keyword) => normalized.includes(keyword))) {

package/src/runtime-host/index.js

@@ -0,0 +1,57 @@
+import { getActiveTask, resolveActiveTaskId, updateTaskState } from "../lib/state-store.js";
+
+export {
+  blockDecision,
+  buildManualFallbackContext,
+  continueDecision,
+  handleAfterTool,
+  handleBeforeTool,
+  handleCompletionGate,
+  handlePromptSubmit,
+  handleSessionStart,
+  normalizeHarnessToolName
+} from "../lib/hook-core.js";
+export { buildClaudeHookOutput, resolveClaudeCompletionMessage } from "../lib/hook-io/claude.js";
+export { buildCodexHookOutput, resolveCodexCompletionMessage } from "../lib/hook-io/codex.js";
+export {
+  buildGeminiHookOutput,
+  resolveGeminiCompletionMessage,
+  resolveGeminiToolCommand,
+  resolveGeminiToolExitCode,
+  resolveGeminiToolName,
+  resolveGeminiToolOutput,
+  resolveGeminiToolPath
+} from "../lib/hook-io/gemini.js";
+
+export function appendMinimalToolEvidence({
+  content = null,
+  cwd,
+  exitCode = 0,
+  toolName = null,
+  type = "command_result"
+}) {
+  const taskId = resolveActiveTaskId(cwd);
+  const activeTask = getActiveTask(cwd);
+
+  if (!taskId || !activeTask || ["done", "failed", "suspended"].includes(activeTask.current_state)) {
+    return false;
+  }
+
+  const safeToolName = typeof toolName === "string" && toolName.trim().length > 0
+    ? toolName.trim()
+    : "<unknown tool>";
+  const evidenceContent = typeof content === "string" && content.trim().length > 0
+    ? content.trim()
+    : `Tool: ${safeToolName}`;
+
+  updateTaskState(cwd, taskId, {
+    evidence: [{
+      content: evidenceContent,
+      exit_code: typeof exitCode === "number" ? exitCode : 0,
+      timestamp: new Date().toISOString(),
+      type
+    }]
+  });
+
+  return true;
+}