elanous 0.2.11 → 0.2.13

package/src/task-orchestrator/surfaces/pod-pool.ts

@@ -19,7 +19,7 @@ import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
 import { predecessorState, type PredecessorState } from '../../pod-lease/dependency-state.js';
-import { HostPoolLease } from '../../pod-lease/host-lease.js';
+import { HostPoolLease, leaseHasPendingPod } from '../../pod-lease/host-lease.js';
 import { measurePoolLease, recommendConcurrency, type PoolDnsProbe, type PoolLeaseRecommendation } from './pod-lease.js';
 
 export interface PodPoolMember {
@@ -143,6 +143,10 @@ export function genericConfigPodPool(config: { pod?: { pool?: string }; harness?
 }
 
 /** 노드 자리 배분 — 우선순위 순서로 첫 빈 자리. 순수(시각·대기는 호출자가). */
+export function podPoolHostLease(members: readonly PodPoolMember[]): HostPoolLease {
+  return new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+}
+
 export class PodPoolScheduler {
   private readonly inflight = new Map<string, number>();
   private readonly admission: PodLeaseAdmission;
@@ -157,7 +161,7 @@ export class PodPoolScheduler {
   constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
     this.pollMs = options.pollMs ?? 15_000;
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
-    this.hostLease = options.hostLease ?? new HostPoolLease([...members.map((m) => `${m.context}@${m.sshHost ?? ''}`)].sort().join(','));
+    this.hostLease = options.hostLease ?? podPoolHostLease(members);
     const measureStatus = options.status ?? (() => {
       const measure = measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) });
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
@@ -166,9 +170,13 @@ export class PodPoolScheduler {
     this.admission = new PodLeaseAdmission({ status: async () => {
       const measured = await measureStatus();
       this.lastRaw = measured;
-      // Launches admitted by other processes on this host but not yet visible as Jobs hold free slots too.
-      const others = measured.recommended === null ? 0 : this.hostLease.othersPending();
-      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others) };
+      const pendingJobs = measured.pendingJobs ?? [];
+      const ownStart = this.hostLease.selfStart();
+      const transferId = process.env.ELANOUS_POD_RESERVED_LEASE;
+      const transferIsOther = !!transferId && this.hostLease.reservationIsOther(transferId);
+      const others = measured.recommended === null ? 0 : this.hostLease.live().filter((r) =>
+        (r.pid !== process.pid || r.startedAt !== ownStart) && !leaseHasPendingPod(r, pendingJobs)).length;
+      const decision = measured.recommended === null ? measured : { ...measured, recommended: Math.max(0, measured.recommended - others + (transferIsOther ? 1 : 0)) };
       // An unknown reading cannot erase permits already granted: on recovery,
       // the first healthy recommendation must still account for their slots.
       if (decision.recommended === null) return decision;
@@ -181,19 +189,28 @@ export class PodPoolScheduler {
     }, ...(options.pollMs ? { pollMs: options.pollMs } : {}), dependencyMerged: options.dependencyMerged ?? ((after, signal) => predecessorState(after, {}, signal)) });
   }
   /** FIFO gate within this process, then a host lease so independent CLI processes cannot over-admit the same pool. */
-  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: () => void }> {
+  async acquireAdmission(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease & { applied: (job: string, context: string, namespace: string) => void; observed: () => void }> {
     const local = await this.acquireLocalAdmission(signal, after);
     try {
       for (;;) {
         if (signal?.aborted) throw new Error('pod lease admission aborted');
         const free = this.lastRaw?.recommended ?? null;
-        // Same check as the local gate, but atomic across processes: other unapplied leases must stay under the free slots.
-        const lease = free !== null && free > 0 ? this.hostLease.tryReserve((others) => others < free) : null;
+        // Same check as the local gate, but atomic across processes: other authoring and pre-Running leases hold slots.
+        const reservedId = process.env.ELANOUS_POD_RESERVED_LEASE;
+        const transferred = reservedId ? this.hostLease.claim(reservedId) : null;
+        if (reservedId && !transferred) throw new Error('pod lease: authoring reservation could not be transferred');
+        if (transferred) delete process.env.ELANOUS_POD_RESERVED_LEASE;
+        const pendingJobs = this.lastRaw?.pendingJobs ?? [];
+        const lease = transferred ?? (free !== null && free > 0 ? this.hostLease.tryReserve((others) =>
+          others - this.hostLease.live().filter((r) => leaseHasPendingPod(r, pendingJobs) &&
+            (r.pid !== process.pid || r.startedAt !== this.hostLease.selfStart())).length < free) : null);
         if (lease) {
           let hostReleased = false;
           const releaseHost = () => { if (!hostReleased) { hostReleased = true; lease(); } };
-          // Once the Job is applied the cluster measurement counts it — the host lease would double count.
-          return Object.assign(() => { releaseHost(); local(); }, { applied: releaseHost });
+          return Object.assign(() => { releaseHost(); local(); }, {
+            applied: (job: string, context: string, namespace: string) => lease.applied(job, context, namespace),
+            observed: releaseHost,
+          });
         }
         await new Promise<void>((resolve, reject) => {
           const timer = setTimeout(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, this.pollMs);

package/src/task-orchestrator/surfaces/self-implement-pod.ts

@@ -58,6 +58,9 @@ import { envLiteral } from '../../platform/env-literal.js';
 import { LLM_TIER_MAP_BY_PROVIDER, lookupLlmTierSpec, type LlmTierProvider } from '../../model-tier/llm-tier-map.js';
 import { parseSelfImplementJson, type SelfImplementJobDone, type SelfImplementJobSpawn } from './self-implement.js';
 import { codexQuotaPolicyFromConfig } from '../../oauth/codex-account-store.js';
+import { goalTypeOf } from '../../../scripts/measure-pod-memory-by-goal.js';
+import { readPodMemoryAdvice, type PodMemoryAdvice } from '../../cli/pod-memory-advice.js';
+import { getUserConfig } from '../../user-config.js';
 
 export type Kubectl = (args: readonly string[], input?: string) => { status: number | null; stdout: string; stderr: string };
 
@@ -132,6 +135,10 @@ export interface PodSpawnOptions {
   env?: NodeJS.ProcessEnv;
   /** Detail switch file (test injection; defaults to the host's local/production selection). */
   liveDetailFile?: string;
+  /** Test seam for the opt-in user configuration; otherwise read the active user config. */
+  adviseDefaults?: boolean;
+  /** Test seam for the read-only measured advice. */
+  memoryAdvice?: () => PodMemoryAdvice;
 }
 
 export function defaultKubectl(args: readonly string[], input?: string): { status: number | null; stdout: string; stderr: string } {
@@ -411,7 +418,7 @@ export const POD_MEMORY_HIGH_DEFAULT = '32Gi';
 export const POD_MEMORY_LITE_DEFAULT = '2Gi';
 export const POD_MEMORY_TIERS = ['lite', 'standard', 'high'] as const;
 export type PodMemoryTier = (typeof POD_MEMORY_TIERS)[number];
-export type PodMemorySource = 'option' | 'goal-line' | 'pwa-auto' | 'default' | 'parent-goal-line' | 'parent-pwa-auto';
+export type PodMemorySource = 'option' | 'goal-line' | 'pwa-auto' | 'default' | 'parent-goal-line' | 'parent-pwa-auto' | 'advise';
 const PWA_PATH = /(?:^|[\s`'"(,·])apps\/pwa\//m;
 const GOAL_LINE = /^[ \t]*(?:Pod 메모리|pod-memory)[ \t]*:[ \t]*(lite|standard|high)[ \t]*\r?$/im;
 
@@ -436,6 +443,12 @@ export function goalTouchesPwa(feature: string): boolean {
   return PWA_PATH.test(feature);
 }
 
+/** A launch-time warning, not a memory-tier override or a test-command parser. */
+export function broadPodTestWarning(goal: string): string | null {
+  const broad = /(?:전체\s*(?:시험|테스트)|(?:full|whole|entire|all)\s+(?:test|suite)|(?:전체|모든)\s*(?:test|suite)|\bbun\s+test\s+(?:[\w./-]+\/|[\w./-]+(?<!\.[cm]?[jt]sx?))(?:\s|$)|\bbun\s+test\s*(?:$|[;&|]))/imu.test(goal);
+  return broad ? '[pod] 넓은 시험 골 경고: 10-04 W10b 32Gi OOM — 넓은 bun test 한 프로세스가 16GB+ 사용; 바꾼 시험 파일만 지정해 실행하세요.' : null;
+}
+
 export function parsePodMemoryTier(v: string | undefined): PodMemoryTier | null {
   const t = v?.trim().toLowerCase();
   return t && (POD_MEMORY_TIERS as readonly string[]).includes(t) ? (t as PodMemoryTier) : null;
@@ -447,14 +460,21 @@ function memoryGi(v: string): number | null {
   return m[2] === 'Gi' ? Number(m[1]) : Number(m[1]) / 1024;
 }
 
-export function podMemoryLimitFor(feature: string, env: NodeJS.ProcessEnv | Readonly<Record<string, string | undefined>>, parentGoal?: string): { limit: string; tier: PodMemoryTier; source: PodMemorySource } {
+export function podMemoryLimitFor(feature: string, env: NodeJS.ProcessEnv | Readonly<Record<string, string | undefined>>, parentGoal?: string, advice?: PodMemoryAdvice): { limit: string; tier: PodMemoryTier; source: PodMemorySource } {
   const option = parsePodMemoryTier(env.ELANOUS_POD_MEMORY_TIER);
   const line = parsePodMemoryTier(GOAL_LINE.exec(feature)?.[1]);
-  const parentLine = !option && !line && !goalTouchesPwa(feature) ? parsePodMemoryTier(GOAL_LINE.exec(parentGoal ?? '')?.[1]) : null;
+  const parentLine = !option && !line ? parsePodMemoryTier(GOAL_LINE.exec(parentGoal ?? '')?.[1]) : null;
+  const goalType = advice && !option && !line && !parentLine
+    ? (broadPodTestWarning(feature) ? 'test' : goalTypeOf(feature))
+      ?? (parentGoal ? (broadPodTestWarning(parentGoal) ? 'test' : goalTypeOf(parentGoal)) : null)
+    : null;
+  const recommendation = advice?.byGoalType.find((entry) => entry.goalType === goalType && entry.evidence.runs > 0)?.recommended;
   const [tier, source]: [PodMemoryTier, PodMemorySource] = option ? [option, 'option']
     : line ? [line, 'goal-line']
+    // 조각 자신의 PWA 경로가 부모 줄·실측 권고보다 먼저다 — 부모 «standard» 가 PWA 조각을 16Gi 로 내리면 OOM(POD7 · #23569 순서 회귀)
     : goalTouchesPwa(feature) ? ['high', 'pwa-auto']
     : parentLine ? [parentLine, 'parent-goal-line']
+    : recommendation ? [recommendation, 'advise']
     : parentGoal && goalTouchesPwa(parentGoal) ? ['high', 'parent-pwa-auto']
     : ['standard', 'default'];
   if (tier === 'lite') return { limit: env.ELANOUS_POD_MEMORY_LITE?.trim() || POD_MEMORY_LITE_DEFAULT, tier, source };
@@ -634,7 +654,6 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
   const hostSupervised = options.hostSupervised ?? true;
   return (input) => {
     const name = podJobName(input.spaceId);
-    const featureMemory = podMemoryLimitFor(input.feature, env);
     let parentGoal: string | undefined;
     let parentGoalUnreadable = false;
     let inheritedFrom: string | undefined;
@@ -652,7 +671,14 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         inheritedFrom = withinRoot;
       } catch { parentGoalUnreadable = true; }
     }
-    const { limit: selectedMemoryLimit, tier: memoryTier, source: memorySource } = parentGoal === undefined ? featureMemory : podMemoryLimitFor(input.feature, env, parentGoal);
+    let advice: PodMemoryAdvice | undefined;
+    const explicitMemory = Boolean(parsePodMemoryTier(env.ELANOUS_POD_MEMORY_TIER) || GOAL_LINE.test(input.feature) || GOAL_LINE.test(parentGoal ?? ''));
+    const useAdvice = options.adviseDefaults ?? getUserConfig().pod?.memory?.adviseDefaults === true;
+    if (useAdvice && !explicitMemory) {
+      try { advice = (options.memoryAdvice ?? readPodMemoryAdvice)(); }
+      catch (error) { debug.log('self-implement.pod', 'memory-advice-unavailable', { spaceId: input.spaceId, reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' }); }
+    }
+    const { limit: selectedMemoryLimit, tier: memoryTier, source: memorySource } = podMemoryLimitFor(input.feature, env, parentGoal, advice);
     for (const [where, text] of [['feature', input.feature], ['parent-goal', parentGoal]] as const) {
       if (text && text.split(/\r?\n/u).some((line) => /Pod 메모리/u.test(line) && !GOAL_LINE.test(line))) {
         const reason = '한 줄 단독 `Pod 메모리: high|standard` 형식이 아님';
@@ -660,6 +686,8 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         debug.log('self-implement.pod', 'memory-directive-ignored', { spaceId: input.spaceId, where, reason }, { level: 'warn' });
       }
     }
+    const broadTestWarning = broadPodTestWarning(`${input.feature}\n${parentGoal ?? ''}`);
+    if (broadTestWarning) console.warn(broadTestWarning);
     let memoryLimit = selectedMemoryLimit;
     const after = input.after ?? podPredecessorFor(input.feature, env, parentGoal);
     if (after !== undefined) debug.log('self-implement.pod', 'predecessor', { spaceId: input.spaceId, after, source: input.after !== undefined ? 'input' : 'goal-or-option' });
@@ -708,7 +736,7 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
       if (recoveryError) return { exitCode: 1, output: '', error: { code: 'pod-oom-recovery', message: recoveryError } };
       // Each Job attempt has its own host lease; releasing the first after OOM lets the retry
       // compete with other processes for the newly measured capacity before applying another Job.
-      let releaseAdmission: ((() => void) & { applied?: () => void }) | undefined;
+      let releaseAdmission: ((() => void) & { applied?: (job: string, context: string, namespace: string) => void; observed?: () => void }) | undefined;
       try {
       // Every attempt, including an OOM retry, must acquire a pool slot before applying a Job.
       const acquireSlot = async (): Promise<PodPoolMember | null> => {
@@ -1059,6 +1087,7 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         const job = podJobManifest({ name, namespace, image: jobImage, ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}), repoUrl, ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), args, passEnv: jobPassEnv, deadlineSeconds: options.deadlineSeconds ?? POD_JOB_DEADLINE_SECONDS, ...(goalDoc ? { goalDoc } : {}), runId: launchRunId, ...(parentRunId ? { parentRunId } : {}), ...(jobArmEnv ? { armEnv: jobArmEnv } : {}), hostId: resolveHostId(env), skillEnvs: Object.keys(skillEnvs), memoryLimit, imageCommit: options.imageCommit !== undefined ? options.imageCommit : options.kubectl ? null : podImageFreshness({ image }).imageCommit, ...(grok ? { grokCredential: 'grokAuth' in creds && creds.grokAuth ? 'subscription' as const : 'api_key' as const } : {}), ...(codexAccounts ? { codexAccounts } : {}), ...(hostRefresh ? { appCredential: true } : {}), execution: { key: executionKey, attempt: oomRetried ? 2 : 1 }, hostLeaseAdmitted: !!releaseAdmission });   // kubectl 주입(=시험)이면 docker 를 부르지 않는다
         const a = kubectl(['apply', '-f', '-'], JSON.stringify(job));
         if (a.status !== 0) { cleanupSecret(); return { exitCode: 1, output: a.stderr, error: { code: 'pod-apply', message: a.stderr.trim() } }; }
+        releaseAdmission?.applied?.(name, context, namespace);
         if (options.source?.kind === 'bundle') {
           const podName = await waitForRunningPod(kubectl, namespace, name, sleep);
           if (!podName) {
@@ -1066,6 +1095,8 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
             cleanupSecret();
             return { exitCode: 1, output: '', error: { code: 'pod-source', message: `Pod for ${name} did not become Running` } };
           }
+          releaseAdmission?.observed?.();
+          if (releaseAdmission) delete releaseAdmission.observed;
           const copied = kubectl(['cp', options.source.bundlePath, `${podName}:/tmp/source.bundle`, '-c', 'child', '-n', namespace]);
           if (copied.status !== 0) {
             debug.log('self-implement.pod', 'source-mismatch', { job: name, kind: 'bundle', headCommit: options.source.headCommit });
@@ -1098,7 +1129,6 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         }
         writePodFragment({ spaceId: input.spaceId, context, namespace, job: name, inboxDir: POD_CONTROL_INBOX_DIR, ...(liveChildRunId === normalizeRunId(liveChildRunId) ? { runId: liveChildRunId } : {}), ...(parentRunId && normalizeRunId(parentRunId) === parentRunId ? { parentRunId } : {}) }, env);
         recorded = true;
-        releaseAdmission?.applied?.();
         debug.log('self-implement.pod', 'job-applied', { job: name, namespace, ...(member ? { context: member.context } : {}), image: jobImage, spaceId: input.spaceId, passEnv, extraArgs: options.extraArgs ?? [], ...(options.armEnv?.ELANOUS_ARM_ID ? { armId: options.armEnv.ELANOUS_ARM_ID } : {}) });
         let state: 'complete' | 'failed' | 'aborted' = 'failed';
         let failedReason = '';
@@ -1114,8 +1144,9 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
           }
           const g = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[*].type}']);
           const types = g.stdout;
-          if (/Complete|SuccessCriteriaMet/.test(types)) { state = 'complete'; break; }
+          if (/Complete|SuccessCriteriaMet/.test(types)) { releaseAdmission?.observed?.(); state = 'complete'; break; }
           if (/Failed|FailureTarget/.test(types)) {
+            releaseAdmission?.observed?.();
             state = 'failed';
             const reason = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[?(@.type=="Failed")].reason}']);
             failedReason = reason.status === 0 ? reason.stdout.trim() : '';
@@ -1135,6 +1166,13 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
             debug.log('self-implement.pod', 'container-terminated', { job: name, container: 'child', reason: containerReason, exitCode: containerExitCode, jobReason: failedReason || null, memoryLimit });
             break;
           }
+          if (releaseAdmission?.observed) {
+            const podPhase = kubectl(['-n', namespace, 'get', 'pods', '-l', `job-name=${name}`, '-o', 'jsonpath={.items[*].status.phase}']);
+            if (podPhase.status === 0 && /\b(?:Running|Succeeded|Failed)\b/.test(podPhase.stdout)) {
+              releaseAdmission.observed();
+              delete releaseAdmission.observed;
+            }
+          }
           if (ghTokenExpiresAt !== null && ghTokenExpiresAt - now() <= 10 * 60_000) {
             try {
               const fresh = await issueVerifiedAppCredential();

package/src/telegram-commands.ts

@@ -46,6 +46,9 @@ import { classifyIntake } from './ad-pipeline/intake.js';
 import { createAdPipelineDeps, runAdPipeline } from './ad-pipeline/run.js';
 import { projectCommand } from './telegram-project-command.js';
 import { telegramNowSlash } from './context-bus/context-now-surfaces.js';
+import { createWishCard } from './intake-plane/wish-card.js';
+import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
+import { CardStore } from './task-cards/card-store.js';
 import type { ContextNowDeps } from './context-bus/context-now.js';
 
 /** How many prior user/assistant turns to pass into `executeSkill` as
@@ -155,6 +158,7 @@ export interface TgCommandContext {
   userConfig: UserConfig;
   /** All registered commands — used by `/help` to enumerate. */
   allCommands: TgSlashCommand[];
+  sendButtons?: (text: string, buttons: Array<Array<{ text: string; data: string }>>) => Promise<void>;
   /** When the caller posted a placeholder for a streaming command,
    *  the streamer edits it in-place as the handler accumulates
    *  output. Undefined for instant commands. Handlers must tolerate
@@ -590,6 +594,23 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
       },
     },
     projectCommand(),
+    {
+      name: 'wish',
+      description: '소원을 카드로 남기기',
+      handler: async (args, ctx, { userConfig }) => {
+        if (String(ctx.userId) !== telegramDecisionOwner(userConfig) || ctx.chatId !== ctx.userId || !ctx.isDm) {
+          return '대표만 쓸 수 있습니다';
+        }
+        if (args.length === 0) return '/wish <소원 한 줄>';
+        const store = new CardStore();
+        try {
+          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}` }, store);
+          return `소원 카드로 남겼습니다 — ${card.title} (카드 ${card.cardId.slice(0, 8)})`;
+        } finally {
+          store.close();
+        }
+      },
+    },
     {
       name: 'fork',
       description: 'Fork the current chat session (or /fork <prefix>) and continue HERE on the fork · time-travel: /fork before:N',

package/src/telegram-dispatch-forward.ts

@@ -42,7 +42,7 @@ export function defaultBaseUrl(deps: { runtime?: () => ReturnType<typeof readNex
   return `http://${host}:${rt.httpPort}`;
 }
 
-function defaultToken(): string | null {
+export function defaultToken(): string | null {
   const p = join(getElanousConfigDir(), 'acp-token');
   try { return existsSync(p) ? readFileSync(p, 'utf-8').trim() || null : null; } catch { return null; }
 }

package/src/telegram-fabric-plan.ts

@@ -0,0 +1,90 @@
+import { defaultBaseUrl, defaultToken } from './telegram-dispatch-forward.js';
+import type { FabricPlan } from './self-dev/fabric-plan-core.js';
+import type { TelegramBot, TgIncoming } from './telegram.js';
+
+export interface TelegramFabricPlanDeps {
+  fetchImpl?: typeof fetch;
+  baseUrl?: () => string | null;
+  token?: () => string | null;
+}
+
+/** Only a successful daemon draft is offered for approval; no execution endpoint is called here. */
+export function attachTelegramFabricPlan(
+  bot: Pick<TelegramBot, 'isOwnerAllowed' | 'sendMessage' | 'sendInlineKeyboard' | 'onCallbackQuery' | 'answerCallbackQuery'>,
+  deps: TelegramFabricPlanDeps = {},
+): (ctx: TgIncoming) => Promise<boolean> {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const pending = new Map<string, { chatId: number; userId: number; threadId?: number; messageId: number }>();
+  const endpoint = (path: string): { url: string; token: string | null } => {
+    const base = (deps.baseUrl ?? defaultBaseUrl)();
+    if (!base) throw new Error('데몬에 연결할 수 없습니다');
+    return { url: `${base}${path}`, token: (deps.token ?? defaultToken)() };
+  };
+  const post = async (path: string, body?: unknown): Promise<unknown> => {
+    const { url, token } = endpoint(path);
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    if (!response.ok) throw new Error(`데몬 응답 ${response.status}`);
+    return response.json();
+  };
+
+  bot.onCallbackQuery(async (q) => {
+    const match = /^fabric:(approve|edit):([a-f0-9-]{36})$/i.exec(q.data);
+    if (!match) return;
+    const planId = match[2]!;
+    const original = pending.get(planId);
+    if (!original || !bot.isOwnerAllowed(q.userId) || q.userId !== original.userId
+      || q.chatId !== original.chatId || q.threadId !== original.threadId || q.messageId !== original.messageId) {
+      await bot.answerCallbackQuery(q.id, { text: '이 초안의 요청자만 선택할 수 있습니다' });
+      return;
+    }
+    if (match[1] === 'edit') {
+      pending.delete(planId);
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(original.chatId, '고칠 내용을 반영해 «아크: <복합 문장>»으로 다시 보내세요. 이 초안은 승인되지 않았습니다.', { threadId: original.threadId });
+      return;
+    }
+    try {
+      await post(`/v1/fabric/plans/${planId}/approve`);
+      pending.delete(planId);
+      await bot.answerCallbackQuery(q.id, { text: '승인되었습니다' });
+      await bot.sendMessage(original.chatId, `아크 초안 ${planId} 승인됨 — 실행은 별도 단계입니다.`, { threadId: original.threadId });
+    } catch (error) {
+      await bot.answerCallbackQuery(q.id, { text: `승인 실패: ${error instanceof Error ? error.message : String(error)}` });
+    }
+  });
+
+  return async (ctx) => {
+    if (ctx.attachments.length || ctx.video || !ctx.text.startsWith('아크:')) return false;
+    const request = ctx.text.slice('아크:'.length).trim();
+    if (!request || request.includes('\n')) {
+      await bot.sendMessage(ctx.chatId, '«아크: <복합 문장>» 한 줄로 보내세요.', { replyTo: ctx.messageId, threadId: ctx.threadId });
+      return true;
+    }
+    try {
+      const body = await post('/v1/fabric/decompose', { request }) as { plan?: FabricPlan };
+      const plan = body.plan;
+      if (!plan || plan.status !== 'draft' || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(plan.id)
+        || !Array.isArray(plan.nodes) || plan.nodes.length === 0) throw new Error('초안 형식 오류');
+      const steps = plan.nodes.map((node, i) => `${i + 1}. ${node.title}`).join('\n');
+      const preview = `아크 초안 · 실행 전 검토\n${steps}`;
+      const reply = { replyTo: ctx.messageId, threadId: ctx.threadId };
+      for (let offset = 0; offset + 4000 < preview.length; offset += 4000) {
+        const sent = await bot.sendMessage(ctx.chatId, preview.slice(offset, offset + 4000), reply);
+        if (sent?.messageId === undefined) throw new Error('단계 미리보기를 전부 전달하지 못했습니다 — 승인 불가');
+      }
+      const finalOffset = Math.floor((preview.length - 1) / 4000) * 4000;
+      const sent = await bot.sendInlineKeyboard(ctx.chatId, preview.slice(finalOffset), [[
+        { text: '승인', data: `fabric:approve:${plan.id}` },
+        { text: '고치기', data: `fabric:edit:${plan.id}` },
+      ]], reply);
+      if (sent?.messageId !== undefined) pending.set(plan.id, { chatId: ctx.chatId, userId: ctx.userId, threadId: ctx.threadId, messageId: sent.messageId });
+    } catch (error) {
+      await bot.sendMessage(ctx.chatId, `아크 초안 생성 실패: ${error instanceof Error ? error.message : String(error)}`, { replyTo: ctx.messageId, threadId: ctx.threadId });
+    }
+    return true;
+  };
+}

package/src/telegram-project-command.ts

@@ -1,7 +1,10 @@
 import { debug } from './debug/log.js';
 import { getProject, listProjects, type Project } from './project/project-store.js';
 import { findSessionByTelegramChat, updateSessionMeta } from './session/index.js';
+import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
+import type { TelegramBot } from './telegram.js';
 import type { TgSlashCommand } from './telegram-commands.js';
+import type { UserConfig } from './user-config.js';
 
 export interface TelegramProjectCommandDeps {
   list: () => Project[];
@@ -19,7 +22,7 @@ export function projectCommand(deps: TelegramProjectCommandDeps = {
   return {
     name: 'project',
     description: '이 대화의 프로젝트 보기·옮기기',
-    handler: async (args, ctx) => {
+    handler: async (args, ctx, ctxOptions) => {
       const session = deps.findSession(ctx.chatId, ctx.threadId, ctx.botId);
       if (!session) {
         debug.log('telegram.project', 'rejected', { projects: [], reason: 'no-session' });
@@ -28,13 +31,38 @@ export function projectCommand(deps: TelegramProjectCommandDeps = {
 
       if (args.length === 0) {
         const current = session.projectId ? deps.find(session.projectId) : null;
-        const projects = deps.list().sort((a, b) => a.name.localeCompare(b.name)).slice(0, 20);
-        debug.log('telegram.project', 'listed', { projects: projects.map(p => ({ id: p.id, name: p.name })) });
+        const projects = deps.list().sort((a, b) => a.name.localeCompare(b.name));
+        debug.log('telegram.project', 'listed', { projects: projects.slice(0, 20).map(p => ({ id: p.id, name: p.name })) });
+        if (ctx.isDm && ctx.chatId === ctx.userId
+          && String(ctx.userId) === telegramDecisionOwner(ctxOptions.userConfig) && ctxOptions.sendButtons) {
+          const eligible = projects.filter(p => {
+            const bytes = Buffer.byteLength(`prj:${p.id}`, 'utf8');
+            if (bytes <= 64) return true;
+            debug.log('telegram.project', 'button-rejected', { reason: 'callback-data-too-long', projectId: p.id, bytes });
+            return false;
+          });
+          const visible = eligible.slice(0, 7);
+          if (current && eligible.some(p => p.id === current.id) && !visible.some(p => p.id === current.id)) {
+            visible[visible.length - 1] = current;
+          }
+          const buttons = visible.map(p => ({ text: `${p.id === current?.id ? '✓ ' : ''}${p.name}`, data: `prj:${p.id}` }));
+          buttons.push({ text: `${session.projectId ? '' : '✓ '}받은 대화로`, data: 'prj:-' });
+          const rows: Array<Array<{ text: string; data: string }>> = [];
+          for (let i = 0; i < buttons.length; i += 2) rows.push(buttons.slice(i, i + 2));
+          try {
+            await ctxOptions.sendButtons('프로젝트를 선택하세요', rows);
+            return;
+          } catch (err) {
+            debug.log('telegram.project', 'button-rejected', {
+              reason: 'send-failed', error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
         return [
           `지금 대화의 프로젝트: ${current?.name ?? '받은 대화(프로젝트 없음)'}`,
           '',
           '프로젝트 목록:',
-          ...projects.map(p => `• ${p.name}`),
+          ...projects.slice(0, 20).map(p => `• ${p.name}`),
           '',
           '옮기려면 /project <이름>',
         ].join('\n');
@@ -69,3 +97,55 @@ export function projectCommand(deps: TelegramProjectCommandDeps = {
     },
   };
 }
+
+export function attachTelegramProjectButtons(
+  bot: Pick<TelegramBot, 'botId' | 'onCallbackQuery' | 'sendMessage' | 'answerCallbackQuery'>,
+  cfg: UserConfig,
+  deps: TelegramProjectCommandDeps = {
+    list: listProjects,
+    find: getProject,
+    update: updateSessionMeta,
+    findSession: findSessionByTelegramChat,
+  },
+): () => void {
+  const owner = telegramDecisionOwner(cfg);
+  return bot.onCallbackQuery(async q => {
+    if (!q.data.startsWith('prj:')) return;
+    if (!owner || String(q.userId) !== owner) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-owner', userId: q.userId, chatId: q.chatId });
+      await bot.answerCallbackQuery(q.id, { text: '권한이 없습니다' });
+      return;
+    }
+    if (q.chatId === undefined || q.chatId !== q.userId || q.threadId !== undefined) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-private-chat', userId: q.userId, chatId: q.chatId });
+      await bot.answerCallbackQuery(q.id, { text: '개인 대화에서만 고를 수 있습니다' });
+      return;
+    }
+    const chatId = q.chatId;
+    const session = deps.findSession(chatId, q.threadId, bot.botId);
+    if (!session) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'no-session', chatId });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '아직 이 채팅에 대화가 없습니다 — 한 마디 보낸 뒤 다시');
+      return;
+    }
+    if (q.data === 'prj:-') {
+      deps.update(session.id, m => { delete m.projectId; });
+      debug.log('telegram.project', 'button-cleared', { chatId, sessionId: session.id });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '받은 대화로 옮겼습니다');
+      return;
+    }
+    const project = deps.find(q.data.slice(4));
+    if (!project) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-found', chatId, projectId: q.data.slice(4) });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '그 이름의 프로젝트가 없습니다 — /project 로 목록 보기');
+      return;
+    }
+    deps.update(session.id, m => { m.projectId = project.id; });
+    debug.log('telegram.project', 'button-moved', { chatId, sessionId: session.id, projectId: project.id });
+    await bot.answerCallbackQuery(q.id);
+    await bot.sendMessage(chatId, `지금 프로젝트: ${project.name}`);
+  });
+}