elanous 0.2.43 → 0.2.44

package/src/research/axis-fanout.ts

@@ -4,6 +4,7 @@ import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-re
 import { getAvailableResearchWebSearchProviders } from '../web-search/index.js';
 import type { WebSearchHit, WebSearchProvider } from '../web-search/provider.js';
 import { debug } from '../debug/log.js';
+import { dispatchWebFetch } from '../skills/tools/webfetch.js';
 
 const RESEARCH_SEARCH_ENGINES = ['exa', 'firecrawl'] as const;
 const RESEARCH_WEB_FALLBACK_IDS = ['exa', 'firecrawl'] as const;
@@ -42,8 +43,9 @@ export type AxisSearch = (query: string, signal?: AbortSignal, context?: AxisSea
 
 export interface AxisFanoutDeps {
   search?: AxisSearch;
+  fetchPage?: (url: string, question: BloomResearchQuestion, signal?: AbortSignal) => Promise<{ url: string; output: string }>;
   signal?: AbortSignal;
-  admitToolCall?: (toolName: 'OmniSearch') => boolean;
+  admitToolCall?: (toolName: 'OmniSearch' | 'WebFetch') => boolean;
 }
 
 interface ProviderHealth {
@@ -201,15 +203,34 @@ export async function fanOutAxisEvidence(
     throw new Error('research axis question IDs must be unique');
   }
   const search = deps.search ?? createResearchAxisSearcher();
-  const settled = await Promise.allSettled(plan.map(call => {
+  const fetchPage = deps.fetchPage ?? (!deps.search
+    ? async (url: string, question: BloomResearchQuestion, signal?: AbortSignal) =>
+      dispatchWebFetch({ url, prompt: question.prompt }, { signal })
+    : undefined);
+  const fetchedQuestions = new Set<string>();
+  const settled = await Promise.allSettled(plan.map(async call => {
     if (deps.admitToolCall && !deps.admitToolCall('OmniSearch')) {
-      return Promise.resolve({ hits: [], errors: ['research tool budget reached'] } satisfies AxisSearchResult);
+      return { hits: [], errors: ['research tool budget reached'] } satisfies AxisSearchResult;
     }
     const question = questions.find(candidate => candidate.id === call.questionId)!;
-    return search(call.query, deps.signal, {
+    const raw = await search(call.query, deps.signal, {
       questionPrompt: question.prompt,
       requestedWindow: question.requestedWindow,
     });
+    const response = Array.isArray(raw) ? { hits: raw, errors: [] } : raw;
+    if (!fetchPage || response.hits.length === 0 || fetchedQuestions.has(question.id)) return response;
+    fetchedQuestions.add(question.id);
+    if (deps.admitToolCall && !deps.admitToolCall('WebFetch')) return response;
+    try {
+      const page = await fetchPage(response.hits[0]!.url, question, deps.signal);
+      return { ...response, fetchedPage: page };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      debug.log('research.search', 'native-fetch-failed', {
+        questionId: question.id, reason: message.slice(0, 200),
+      }, { level: 'warn' });
+      return response;
+    }
   }));
   const axes: AxisEvidenceGroup[] = questions.map(question => ({ questionId: question.id, evidence: [] }));
   const groups = new Map(axes.map(axis => [axis.questionId, axis]));
@@ -226,10 +247,24 @@ export async function fanOutAxisEvidence(
     const group = groups.get(call.questionId)!;
     const question = byQuestion.get(call.questionId)!;
     if (outcome.status === 'fulfilled') {
-      const response = Array.isArray(outcome.value) ? { hits: outcome.value, errors: [] } : outcome.value;
+      const response = outcome.value;
       if (response.hits.length === 0 && response.errors.length === 0) {
         group.evidence.push({ ...failedEvidence(question, call.query, 'no hits returned'), outcome: 'partial' });
       }
+      const fetchedPage = 'fetchedPage' in response ? response.fetchedPage : undefined;
+      if (fetchedPage) {
+        const content = fetchedPage.output;
+        const excerpt = Array.from(content).slice(0, 8_000).join('');
+        group.evidence.push({
+          questionId: question.id,
+          sourceKind: 'web-fetch',
+          source: fetchedPage.url,
+          ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+          content: excerpt,
+          outcome: excerpt ? 'complete' : 'partial',
+          truncated: Array.from(content).length > 8_000,
+        });
+      }
       for (const hit of response.hits) {
         try {
           group.evidence.push(evidenceFromHit(question, hit));

package/src/research/lenses/second-order.ts

@@ -0,0 +1,312 @@
+/** Chain order a synthesis step lands in: what happens first, what that causes, what that settles. */
+export type SecondOrderOrder = 'primary' | 'secondary' | 'tertiary';
+
+export interface SecondOrderLensStage {
+  order: SecondOrderOrder;
+  label: string;
+  horizonDays: number;
+  purpose: string;
+}
+
+/** Public lens definition: what the T2 second-order lens is and which orders it fans a synthesis into. */
+export interface SecondOrderLensDefinition {
+  id: string;
+  cell: string;
+  tier: string;
+  rfc: string;
+  description: string;
+  stages: readonly SecondOrderLensStage[];
+}
+
+/** Public verification format attached to every secondary effect. */
+export interface SecondOrderVerificationNode {
+  claim: string;
+  scenarioCondition: string | null;
+  metric: string | null;
+  expectedValue: number | null;
+  threshold: number | null;
+  unit: string | null;
+  windowDays: number;
+  falsifiable: boolean | null;
+  measurementStatus: 'unmeasured' | 'needs-operationalization';
+  evidenceSource: string | null;
+}
+
+export interface SecondOrderEvidenceFact {
+  questionId: string;
+  question: string;
+  content: string;
+  source: string;
+  outcome: 'complete' | 'partial' | 'failed';
+  observedWindow?: string;
+  units?: string;
+}
+
+export interface SecondOrderChainNode {
+  id: string;
+  order: SecondOrderOrder;
+  orderIndex: 1 | 2 | 3;
+  statement: string;
+  horizonDays: number;
+  derivedFrom: readonly string[];
+  verification: SecondOrderVerificationNode | null;
+}
+
+/** Public result-chain format: primary → secondary → tertiary, with secondary effects verified. */
+export interface SecondOrderResultChain {
+  lensId: string;
+  question: string;
+  orderStages: readonly SecondOrderLensStage[];
+  nodes: readonly SecondOrderChainNode[];
+}
+
+export type SecondOrderTriggerKind = 'decision' | 'forecast' | 'none';
+
+export interface SecondOrderTriggerDecision {
+  triggered: boolean;
+  kind: SecondOrderTriggerKind;
+  score: number;
+  matchedSignals: readonly string[];
+  reason: string;
+}
+
+export interface SecondOrderLensInput {
+  question: string;
+  synthesis: readonly string[];
+  /** IDs must align with synthesis; evidence is joined by questionId, never by flat-array position. */
+  synthesisQuestionIds?: readonly string[];
+  evidenceFacts?: readonly SecondOrderEvidenceFact[];
+}
+
+export interface SecondOrderLensResult {
+  lens: SecondOrderLensDefinition;
+  trigger: SecondOrderTriggerDecision;
+  chain: SecondOrderResultChain | null;
+}
+
+/** Injection seam lets a host supply private trigger calibration without shipping it here. */
+export type SecondOrderTriggerClassifier = (question: string) => SecondOrderTriggerDecision;
+
+export const SECOND_ORDER_LENS: SecondOrderLensDefinition = {
+  id: 'second-order',
+  cell: 'THINK-LENS-T2-SECOND-ORDER',
+  tier: 'T2',
+  rfc: 'RFC-PRO §2',
+  description: '결정·예측 질문에서 6단 종합을 1차 → 2차 → 3차 결과 사슬로 펼치고, 2차 효과마다 검증 노드를 붙인다.',
+  stages: [
+    {
+      order: 'primary',
+      label: '1차 결과',
+      horizonDays: 30,
+      purpose: '결정이나 예측이 직접 만드는 즉시 효과',
+    },
+    {
+      order: 'secondary',
+      label: '2차 결과',
+      horizonDays: 180,
+      purpose: '1차 효과가 다른 주체로 전이되며 생기는 효과 — 검증 노드가 붙는 자리',
+    },
+    {
+      order: 'tertiary',
+      label: '3차 결과',
+      horizonDays: 540,
+      purpose: '2차 효과가 구조·규범·시장에 정착하며 생기는 효과',
+    },
+  ],
+};
+
+const DECISION_QUESTION_FORM = /(?:해야\s*(?:할까|하나|할지)|(?:고르|선택|결정|전환|도입|투자|진입|매수|매도)(?:해야\s*(?:할까|하나|할지)|할까|할지\s*(?:말지|여부)))|\b(?:should\s+(?:i|we)|whether\s+to|choose\s+between|decide\s+whether)\b/i;
+const FORECAST_QUESTION_FORM = /(?:얼마나\s+[^?\n]{0,80}(?:될|오를|내릴|늘어날|줄어들|바뀔|변할)|(?:언제|몇)\s+[^?\n]{0,80}(?:될|오를|내릴|늘어날|줄어들|바뀔)|어떻게\s+(?:될까|변할까))|\b(?:how\s+much|how\s+many)\s+(?:will|might|could|is\s+expected\s+to|is\s+projected\s+to)\b.{0,120}\b(?:rise|fall|grow|shrink|change|cost|be)\b|\b(?:when\s+will|what\s+will)\b.{0,120}\b(?:rise|fall|grow|shrink|change|cost|be)\b|\bwill\s+[^?\n]{1,120}\b(?:increase|decrease|rise|fall|grow|shrink|change|cost|remain|reach|exceed|decline)\b/i;
+
+/** Decide whether a question is a decision or a forecast, i.e. whether the second-order lens applies. */
+export function detectSecondOrderTrigger(question: string): SecondOrderTriggerDecision {
+  const text = requireText(question, 'question').toLowerCase();
+  if (!/[?？]\s*$/u.test(text)) return noTrigger();
+  const decision = DECISION_QUESTION_FORM.exec(text);
+  const forecast = FORECAST_QUESTION_FORM.exec(text);
+  const kind: SecondOrderTriggerKind = decision ? 'decision' : forecast ? 'forecast' : 'none';
+  const score = kind === 'none' ? 0 : 1;
+  const matchedSignals = Object.freeze(kind === 'decision' ? ['decision-form'] : kind === 'forecast' ? ['forecast-form'] : []);
+  if (kind === 'none') {
+    return {
+      triggered: false,
+      kind: 'none',
+      score,
+      matchedSignals,
+      reason: '질문이 결정이나 예측이 아니라 결과 사슬을 펼치지 않는다',
+    };
+  }
+  return {
+    triggered: true,
+    kind,
+    score,
+    matchedSignals,
+    reason: kind === 'decision'
+      ? '결정 질문이므로 1차 → 2차 → 3차 결과 사슬을 펼친다'
+      : '예측 질문이므로 1차 → 2차 → 3차 결과 사슬을 펼친다',
+  };
+}
+
+function noTrigger(): SecondOrderTriggerDecision {
+  return {
+    triggered: false,
+    kind: 'none',
+    score: 0,
+    matchedSignals: Object.freeze([]),
+    reason: '결정·예측 질문형이 아니므로 결과 사슬을 펼치지 않는다',
+  };
+}
+
+/** Expand synthesis steps into a primary → secondary → tertiary chain with a verification node on each secondary effect. */
+export function buildSecondOrderResultChain(input: SecondOrderLensInput): SecondOrderResultChain {
+  const question = requireText(input.question, 'question');
+  const steps = input.synthesis.map((step, index) => requireText(step, `synthesis[${index}]`));
+  if (input.evidenceFacts?.length && input.synthesisQuestionIds?.length !== steps.length) {
+    throw new Error('synthesisQuestionIds must align with synthesis when evidenceFacts are supplied');
+  }
+  if (steps.length < SECOND_ORDER_LENS.stages.length) {
+    throw new Error('synthesis requires at least three steps to expand into a result chain');
+  }
+
+  const buckets = splitIntoOrders(steps, SECOND_ORDER_LENS.stages.length);
+  const nodes: SecondOrderChainNode[] = [];
+  let previousIds: string[] = [];
+  for (const [stageIndex, stage] of SECOND_ORDER_LENS.stages.entries()) {
+    const stageIds: string[] = [];
+    for (const [stepIndex, statement] of buckets[stageIndex]!.entries()) {
+      const inputIndex = buckets.slice(0, stageIndex).reduce((count, bucket) => count + bucket.length, 0) + stepIndex;
+      const questionId = input.synthesisQuestionIds?.[inputIndex];
+      const fact = questionId ? combineQuestionEvidence(questionId, input.evidenceFacts ?? []) : undefined;
+      const id = `${stage.order}-${stepIndex + 1}`;
+      stageIds.push(id);
+      const parentIndex = stageIndex === 0 ? -1 : Math.min(stepIndex, previousIds.length - 1);
+      const parentId = parentIndex >= 0 ? previousIds[parentIndex] : undefined;
+      const parent = parentId ? nodes.find((node) => node.id === parentId) : undefined;
+      const outputStatement = fact
+        ? makeOutcomeHypothesis(stage.order, question, fact, parent?.statement)
+        : stage.order === 'primary'
+          ? `1차 가설: ${statement}`
+          : `${stage.order === 'secondary' ? '2차' : '3차'} 가설: ${parent?.statement ?? '앞 단계 결과'}가 이어지면 ${statement}라는 후속 결과가 생길 수 있다.`;
+      nodes.push({
+        id,
+        order: stage.order,
+        orderIndex: (stageIndex + 1) as 1 | 2 | 3,
+        statement: outputStatement,
+        horizonDays: stage.horizonDays,
+        derivedFrom: Object.freeze(parentId ? [parentId] : []),
+        verification: stage.order === 'secondary'
+          ? buildVerificationNode(outputStatement, fact, stepIndex)
+          : null,
+      });
+    }
+    previousIds = stageIds;
+  }
+
+  return {
+    lensId: SECOND_ORDER_LENS.id,
+    question,
+    orderStages: SECOND_ORDER_LENS.stages,
+    nodes: Object.freeze(nodes),
+  };
+}
+
+/** Run the lens: the trigger decides whether a chain is produced at all. */
+export function applySecondOrderLens(
+  input: SecondOrderLensInput,
+  classifyTrigger: SecondOrderTriggerClassifier = detectSecondOrderTrigger,
+): SecondOrderLensResult {
+  const trigger = classifyTrigger(input.question);
+  if (!trigger.triggered) return { lens: SECOND_ORDER_LENS, trigger, chain: null };
+  return { lens: SECOND_ORDER_LENS, trigger, chain: buildSecondOrderResultChain(input) };
+}
+
+function buildVerificationNode(statement: string, fact: SecondOrderEvidenceFact | undefined, index: number): SecondOrderVerificationNode {
+  const metric = fact?.outcome === 'complete' ? extractObservableMetric(fact.content) : null;
+  const windowDays = 90 * (index + 1);
+  const scenarioCondition = metric && fact
+    ? `${fact.observedWindow ? `${fact.observedWindow} 기준선` : '확인 가능한 기준선'}과 ${windowDays}일 뒤 ${metric}을 비교한다. 판정 임계값은 아직 정하지 않았다.`
+    : null;
+  return {
+    claim: statement,
+    scenarioCondition,
+    metric,
+    expectedValue: null,
+    threshold: null,
+    unit: fact?.units ?? null,
+    windowDays,
+    falsifiable: null,
+    measurementStatus: metric ? 'needs-operationalization' : 'unmeasured',
+    evidenceSource: fact?.source ?? null,
+  };
+}
+
+function splitIntoOrders(steps: readonly string[], orderCount: number): string[][] {
+  const base = Math.floor(steps.length / orderCount);
+  const remainder = steps.length % orderCount;
+  const buckets: string[][] = [];
+  let cursor = 0;
+  for (let index = 0; index < orderCount; index += 1) {
+    const size = base + (index < remainder ? 1 : 0);
+    buckets.push(steps.slice(cursor, cursor + size));
+    cursor += size;
+  }
+  return buckets;
+}
+
+function makeOutcomeHypothesis(
+  order: SecondOrderOrder,
+  question: string,
+  fact: SecondOrderEvidenceFact,
+  parentStatement?: string,
+): string {
+  const detail = compactEvidence(fact.content);
+  const citation = `[${fact.questionId}; ${fact.source}; ${fact.outcome}]`;
+  if (fact.outcome !== 'complete') {
+    return `${order === 'primary' ? '1차' : order === 'secondary' ? '2차' : '3차'} 가설 미작성: ${fact.question}에 대한 완전한 근거를 확보하지 못했다 (${fact.outcome}; ${citation}).`;
+  }
+  if (order === 'primary') return `1차 가설: 「${question}」의 직접 효과 후보는 「${detail}」이다. 근거 ${citation}`;
+  if (order === 'secondary') return `2차 가설: 「${parentStatement ?? '직접 결과'}」가 이어질 경우 「${detail}」라는 후속 효과가 생길 수 있다. 근거 ${citation}`;
+  return `3차 가설: 「${parentStatement ?? '2차 효과'}」가 지속될 경우 「${detail}」라는 장기 결과로 이어질 수 있다. 근거 ${citation}`;
+}
+
+function compactEvidence(value: string): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length > 180 ? `${normalized.slice(0, 177)}…` : normalized;
+}
+
+function combineQuestionEvidence(questionId: string, evidenceFacts: readonly SecondOrderEvidenceFact[]): SecondOrderEvidenceFact | undefined {
+  const matching = evidenceFacts.filter((fact) => fact.questionId === questionId);
+  if (!matching.length) return undefined;
+  const complete = matching.filter((fact) => fact.outcome === 'complete');
+  const selected = complete.length ? complete : matching;
+  const units = [...new Set(selected.map((fact) => fact.units).filter((unit): unit is string => Boolean(unit)))].join(', ');
+  const observedWindow = [...new Set(selected.map((fact) => fact.observedWindow).filter((window): window is string => Boolean(window)))].join(', ');
+  return {
+    questionId,
+    question: selected[0]!.question,
+    content: selected.map((fact) => fact.content).join(' · '),
+    source: [...new Set(selected.map((fact) => fact.source))].join(', '),
+    outcome: complete.length ? 'complete' : selected.some((fact) => fact.outcome === 'partial') ? 'partial' : 'failed',
+    ...(observedWindow ? { observedWindow } : {}),
+    ...(units ? { units } : {}),
+  };
+}
+
+function extractObservableMetric(value: string): string | null {
+  const patterns = [
+    /(?:응답\s*시간|처리\s*시간|처리량|대기\s*시간|전환율|이탈률|잔존율|오류율|정확도|매출|수익|비용|수출액|수출량|문의\s*건수|사용자\s*수|판매량|생산성|파이프라인)/iu,
+    /\b(?:response time|processing time|wait time|conversion rate|churn rate|retention rate|error rate|accuracy|revenue|cost|export volume|inquiry count|user count|sales volume|productivity|pipeline|adoption rate|demand)\b/iu,
+  ];
+  for (const pattern of patterns) {
+    const match = value.match(pattern);
+    if (match?.[0]) return match[0].replace(/\s+/g, ' ').trim();
+  }
+  return null;
+}
+
+function requireText(value: unknown, field: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new Error(`${field} must not be empty`);
+  }
+  return value.trim();
+}

package/src/self-dev/dev-cli.ts

@@ -930,7 +930,9 @@ export function startDraftTriage(
         const inventory = inventories.find((entry) => entry.repository === repository)?.snapshot;
         const enriched = { ...draft, branch: draft.branch ?? '', ...inventoryByUrl.get(draft.url!) };
         if ((!inventory || !inventoryByUrl.has(draft.url!)) && !IN_TEST_PROCESS()) { unobservedDrafts.push(draft.number); continue; }
-        const decision = decideDraft({ draft: enriched, runStatus: resolvedStatus, mergedTwins: inventory?.merged ?? [], ageHours: (nowMs() - draft.openedAtMs) / 3_600_000, liveBranches });
+        const triageNow = nowMs();
+        const decision = decideDraft({ draft: enriched, now: new Date(triageNow), runStatus: resolvedStatus,
+          mergedTwins: inventory?.merged ?? [], ageHours: (triageNow - draft.openedAtMs) / 3_600_000, liveBranches });
         if (decision.reason.startsWith('superseded-by')) decisions.superseded += 1;
         else if (decision.reason === 'stale-ended-run') decisions.staleEndedRun += 1;
         else if (decision.reason.startsWith('label:')) decisions.humanApproval += 1;   // approval-waiting or human «keep»

package/src/self-dev/draft-sweep.ts

@@ -1,6 +1,6 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { assessDraftTriage, decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, laterMergedTwins, sameGoalPr, PROTECTED_LABELS, type DraftTriageAssessment, type DraftTriagePr, type DraftTriageReviewState } from './draft-triage-rules.js';
+import { assessDraftTriage, decideDraft, draftClaimComment, draftClaimState, draftIntentHoldReason, draftIntentHoldRejection, draftReleaseComment, harvestDeferredMarker, laterMergedTwins, parseDraftIntentHold, sameGoalPr, PROTECTED_LABELS, type DraftTriageAssessment, type DraftTriagePr, type DraftTriageReviewState } from './draft-triage-rules.js';
 import { cellIdFromBody } from '../pr-tool/census.js';
 import { RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { cardPrNumber, draftTaskOwner, type TaskCard } from '../task-agent/task-hand.js';
@@ -659,12 +659,14 @@ export function resolveDraftSweepCloseCap(input: { flag?: unknown; config?: unkn
 export async function supersedeDraftsOnMerge(input: {
   repository: string;
   merged: SweepMergedPr & { createdAt: string; mergedAt: string };
+  now?: Date;
   /** `pr land` and HQ train invoke only the explicit same-cell successor path. */
   onlyExplicitSameCell?: boolean;
   adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listLiveBranches' | 'getRunStatus' | 'setLabels' | 'closeDraft'>
     & Pick<Partial<DraftSweepAdapters>, 'getLatestFileChanges' | 'getPrFiles' | 'commentDraft' | 'listIssueComments'>;
 }): Promise<{ closed: number[]; kept: number[] }> {
   const { repository, merged, adapters } = input;
+  const now = input.now ?? new Date();
   const closed: number[] = [];
   const kept: number[] = [];
   let drafts: SweepDraft[] = [];
@@ -691,6 +693,7 @@ export async function supersedeDraftsOnMerge(input: {
       const old = drafts.find((draft) => draft.number === explicitOld);
       if (old && cellIdFromBody(old.body ?? '') === mergedCell
         && Date.parse(old.createdAt) < Date.parse(merged.mergedAt)
+        && !parseDraftIntentHold(old.body, now)
         && !old.labels.some((label) => PROTECTED_LABELS.has(label))
         && PR_LABELS.filter((label) => label.axis === 'state' && old.labels.includes(label.name)).length <= 1) {
         const marker = `<!-- elanous:same-cell-superseded #${old.number} -> #${merged.number} -->`;
@@ -745,7 +748,7 @@ export async function supersedeDraftsOnMerge(input: {
         kept.push(draft.number);
         continue;
       }
-      const decision = decideDraft({ draft, runStatus: statuses.get(draft.number),
+      const decision = decideDraft({ draft, now, runStatus: statuses.get(draft.number),
         mergedTwins: [landed], liveBranches, ageHours: NaN });
       if (decision.action !== 'close' || !decision.reason.startsWith(`superseded-by #${merged.number}`)
         || PR_LABELS.filter((entry) => entry.axis === 'state' && draft.labels.includes(entry.name)).length > 1
@@ -1345,6 +1348,16 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ...(claimWriteFailed ? { error: claimWriteError, ...(claimPartialApplied ? { partialApplied: true } : {}) } : {}) });
       continue;
     }
+    // DRAFT-ZERO's failed-run harvest evidence remains the strongest explicit hold; this intent marker
+    // must not rewrite its reason or mask the harvest classification.
+    if (runStatus === 'failed' && harvestDeferredMarker(draft.body)) {
+      record({ number: draft.number, action: 'keep', reason: 'harvest-deferred', applied: false });
+      continue;
+    }
+    const intentHoldRejection = draftIntentHoldRejection(draft.body, now);
+    if (intentHoldRejection) {
+      try { debug.log('self-dev.draft-sweep', 'intent-hold-rejected', { pr: draft.number, reason: intentHoldRejection }); } catch { /* fail-soft */ }
+    }
     if (draft.labels.includes(releaseHoldLabel ?? '') || draft.labels.includes(RELEASE_PATH_LABEL)
       || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
       const held = draft.labels.includes(keepLabel ?? '') ? keepLabel
@@ -1352,6 +1365,19 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       record({ number: draft.number, action: 'keep', reason: `label:${held}`, applied: false });
       continue;
     }
+    // Outside-harness drafts keep their established jurisdiction reason, even when they carry a valid marker.
+    if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
+      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
+      continue;
+    }
+    const intentHold = parseDraftIntentHold(draft.body, now);
+    if (intentHold) {
+      const reason = draftIntentHoldReason(intentHold);
+      record({ number: draft.number, action: 'keep', reason, applied: false });
+      try { debug.log('self-dev.draft-sweep', 'intent-hold-kept', { pr: draft.number, owner: intentHold.owner,
+        reason: intentHold.reason, expiresAt: intentHold.expiresAt }); } catch { /* fail-soft */ }
+      continue;
+    }
     const claimState = contradiction ? 'unclaimed' : draftClaimState(draft, now);
     const isClaimed = claimState !== 'unclaimed';
     const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
@@ -1368,7 +1394,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const cellNewer = contradiction || lineageNewer ? undefined : newerSameCellDraft(draft, drafts);
     const duplicateNewer = lineageNewer ?? cellNewer;
     if (duplicateNewer) {
-      const base = decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      const base = decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
         finalRunResult, ageHours: runStatus ? ageHours : idleHours });
       if (!base.reason.startsWith('label:') && !base.reason.startsWith('superseded-by #') && !base.reason.startsWith('duplicate-of-open #')) {
         const runLive = isLiveDraftRun(runStatus, draft.branch, liveBranches);
@@ -1457,7 +1483,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     // An unobserved claim may still have a merged twin: liveness/holds retain their priority,
     // but a superseded draft must not be hidden by the six-hour claim window.
-    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+    const mergedDecision = isClaimed ? decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
       finalRunResult, ageHours: idleHours }) : undefined;
     const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true
       || mergedDecision?.reason.startsWith('duplicate-of-open #') === true;
@@ -1509,12 +1535,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       }
       continue;
     }
-    // Unlabelled non-harness drafts are outside the sweeper's jurisdiction.
-    if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
-      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
-      continue;
-    }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
       finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     const fallback = decision.reason === 'unobserved' || decision.reason === 'stale-unobserved'
       || decision.reason === 'recent' || decision.reason.startsWith('recent (') || decision.reason.startsWith('stale-ended-run');

package/src/self-dev/draft-triage-rules.ts

@@ -23,12 +23,64 @@ export function draftClaimRecordLive(at: string, now: Date): boolean {
   return Number.isFinite(updated) && (now.getTime() - updated) / 3_600_000 < CLAIM_IDLE_HOURS;
 }
 
+export interface DraftIntentHold {
+  readonly owner: string;
+  readonly reason: string;
+  readonly expiresAt: string;
+}
+
+function inspectDraftIntentHold(body: string | undefined, now = new Date()): { hold?: DraftIntentHold; rejection?: string } {
+  if (!body || !body.includes('<!-- elanous:draft-intent-hold')) return {};
+  if (!Number.isFinite(now.getTime())) return { rejection: 'invalid-sweep-time' };
+  const matches = [...body.matchAll(/<!-- elanous:draft-intent-hold ([\s\S]*?) -->/g)];
+  const markerStarts = body.match(/<!-- elanous:draft-intent-hold\b/g) ?? [];
+  if (matches.length !== 1 || markerStarts.length !== 1) return { rejection: 'marker-count-or-termination' };
+  const raw = matches[0]![1]!;
+  let value: unknown;
+  try { value = JSON.parse(raw); } catch { return { rejection: 'invalid-json' }; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return { rejection: 'invalid-shape' };
+  const row = value as Record<string, unknown>;
+  if (Object.keys(row).length !== 3 || !Object.hasOwn(row, 'owner') || !Object.hasOwn(row, 'reason') || !Object.hasOwn(row, 'expiresAt')) {
+    return { rejection: 'invalid-fields' };
+  }
+  const { owner, reason, expiresAt } = row;
+  if (typeof owner !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(owner)
+    || typeof reason !== 'string' || !reason.trim() || reason !== reason.trim() || reason.length > 240
+    || /[\r\n;=]/.test(reason) || reason.includes('-->')
+    || typeof expiresAt !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(expiresAt)) {
+    return { rejection: 'invalid-fields' };
+  }
+  // Compare against the one writer-defined field order. JSON.stringify(parsedObject) alone preserves
+  // incoming key order and would silently accept alternate serializations or duplicate keys.
+  if (JSON.stringify({ owner, reason, expiresAt }) !== raw) return { rejection: 'noncanonical-json' };
+  const expiry = Date.parse(expiresAt);
+  if (!Number.isFinite(expiry) || new Date(expiry).toISOString() !== expiresAt) return { rejection: 'invalid-expiry' };
+  if (expiry <= now.getTime()) return { rejection: 'expired' };
+  return { hold: { owner, reason: reason.trim(), expiresAt } };
+}
+
+/** Only one canonical, complete, unexpired body marker is a hold; malformed or ambiguous markers fail open to normal triage. */
+export function parseDraftIntentHold(body: string | undefined, now = new Date()): DraftIntentHold | undefined {
+  return inspectDraftIntentHold(body, now).hold;
+}
+
+/** Diagnostic for a present but rejected hold marker; absence is not an error. */
+export function draftIntentHoldRejection(body: string | undefined, now = new Date()): string | undefined {
+  return inspectDraftIntentHold(body, now).rejection;
+}
+
+export function draftIntentHoldReason(hold: DraftIntentHold): string {
+  return `intent-hold owner=${hold.owner}; reason=${hold.reason}; expiresAt=${hold.expiresAt}`;
+}
+
 export interface DraftTriagePr {
   number: number;
   title?: string;
   branch: string;
   labels?: readonly string[];
   body?: string;
+  /** Last PR update (push, label, comment); absence is not an expiry timestamp. */
+  updatedAt?: string;
   mergeCommitMessage?: string;
   landingVerifiedComments?: readonly string[];
   createdAt?: string;
@@ -109,7 +161,8 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
   const clock = now.getTime();
   const ageHours = Number.isFinite(latestCommit) && Number.isFinite(clock) ? (clock - latestCommit) / 3_600_000 : NaN;
   const protectedLabel = (draft.labels ?? []).find((name) => CLOSE_PROTECTED_LABELS.has(name));
-  const protectedState = Boolean(protectedLabel);
+  const intentHold = parseDraftIntentHold(draft.body, now);
+  const protectedState = Boolean(protectedLabel || intentHold);
   const running = input.runStatus === 'running' || input.runStatus === 'probable-running'
     || (draft.labels ?? []).includes('elanous:running');
   const cellComplete = input.cellStatus === 'green' || input.cellStatus === 'done';
@@ -146,7 +199,8 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
       : { state: 'unknown', evidence: '현재 adapter는 같은 칸 병합 PR과 이 초안의 대체 관계를 증명하지 않음; follow-up 필요' },
     'newer-same-card': { state: input.newerSameCellSameCard === undefined ? 'unknown' : input.newerSameCellSameCard ? 'yes' : 'no', evidence: `${input.newerSameCellSameCard === undefined ? '같은 칸·카드 새 draft 관계 미관측' : `same-cell-same-card-newer=${input.newerSameCellSameCard}`}; 관측 표지이며 대체 증거가 아님` },
     'idle-48h': { state: Number.isFinite(ageHours) ? (idle48h ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(ageHours) ? `head age=${ageHours.toFixed(1)}h` : 'head commit 시각 미관측' },
-    protected: { state: protectedState ? 'yes' : 'no', evidence: protectedLabel ? `보호 표지=${protectedLabel}` : '보호 표지 없음' },
+    protected: { state: protectedState ? 'yes' : 'no', evidence: protectedLabel ? `보호 표지=${protectedLabel}`
+      : intentHold ? draftIntentHoldReason(intentHold) : '보호 표지 없음' },
     'recent-commit': { state: Number.isFinite(latestCommit) ? (recentCommit ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(latestCommit) ? `last commit=${draft.latestCommitAt}; cutoff=09:30 KST` : 'head commit 시각 미관측' },
     running: { state: running ? 'yes' : runNotRunning ? 'no' : 'unknown', evidence: running ? `run=${input.runStatus ?? 'elanous:running'}` : runNotRunning ? `종결 run=${input.runStatus}` : `run 상태 미관측${input.runStatus ? ` (${input.runStatus})` : ''}` },
     'owner-confirmed': { state: input.ownerConfirmed === undefined ? 'unknown' : input.ownerConfirmed ? 'yes' : 'no', evidence: input.ownerConfirmed === undefined ? '소유자 출처 미관측' : input.ownerConfirmed ? '고유 카드 또는 활성 claim owner 확인' : '고유 소유자 없음' },
@@ -161,6 +215,7 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
 
 export interface DraftTriageInput {
   draft: DraftTriagePr;
+  now?: Date;
   runStatus: string | undefined;
   mergedTwins: readonly DraftTriagePr[];
   openDrafts?: readonly DraftTriagePr[];
@@ -251,10 +306,12 @@ export function harvestDeferredMarker(body: string | undefined): boolean {
     && rows.length > 0 && rows.every((value) => value === HARVEST_DEFERRED_MARKER_VALUE);
 }
 
-export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
+export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult, now = new Date() }: DraftTriageInput): DraftDecision {
   // DRAFT-ZERO — a verified harvest-deferred marker is the strongest hold: it outranks protected labels
   // and every close rule, so a failed run's harvestable draft survives the sweep for harvest.
   if (runStatus === 'failed' && harvestDeferredMarker(draft.body)) return { action: 'keep', reason: 'harvest-deferred' };
+  const intentHold = parseDraftIntentHold(draft.body, now);
+  if (intentHold) return { action: 'keep', reason: draftIntentHoldReason(intentHold) };
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
   if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)