@tyhld/conductor 0.12.172 → 0.12.174

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.js CHANGED
@@ -27,6 +27,7 @@ import { createCentralPorts } from './build-central.js';
27
27
  import { drainReport, readDrain } from './autoupdate-flags.js';
28
28
  import { runSelfcheckCommand } from './selfcheck.js';
29
29
  import { runAutoupdateCommand } from './autoupdate.js';
30
+ import { clearUsageHold, holdFilePath, readUsageHold } from './usage-limit.js';
30
31
  import { BUILD_NUDGE_NAME, REQUIRED_ENV, createBuildRunner, createMemoStore, loadBuildRunnerConfig, } from './build-runner.js';
31
32
  /**
32
33
  * relay の状態の参照(生存報告に「いま配れるか」を載せるため)。
@@ -317,7 +318,9 @@ async function start(args) {
317
318
  relayStateForReport = hState.relay;
318
319
  // ★回収の道から「いま追っている便」を除くための参照(便 6ebba0d0)。
319
320
  headlessStateForReport = hState;
320
- const hCfg = { ...cfg, workDir };
321
+ // ★便ごとの作業場所で職人を起こす(便 27a9fb19・既定オン)。この PC で切るときだけ off。
322
+ const jobWorkDir = (process.env.CONDUCTOR_JOB_WORKTREE ?? '').trim().toLowerCase() !== 'off';
323
+ const hCfg = { ...cfg, workDir, jobWorkDir };
321
324
  relayRunner = createRelayRunner({
322
325
  tick: () => headlessTick(hCfg, hState, {
323
326
  onCentralReconnect: () => {
@@ -506,6 +509,7 @@ function printUsage() {
506
509
  ' conductor selfcheck [--trigger <daily|after-conductor|after-claude|after-rollback|manual|candidate>] [--json] [--no-send]',
507
510
  ' この機の自己診断(副作用なし・結果は手元の控えと管制へ)',
508
511
  ' conductor autoupdate [--boot] 自社PCの更新係(鍵が無い機では何もしない・systemd から呼ぶ)',
512
+ ' conductor resume-delivery Claude の利用上限で止めた配達を今すぐ再開する(アカウントを切り替えたとき)',
509
513
  '',
510
514
  '見るだけの画面(conductor view = kc 現場名):',
511
515
  ' いま職人が何をしているかを、やさしい日本語で見るだけの画面です。',
@@ -599,6 +603,22 @@ async function main() {
599
603
  // ★更新係(便 29babc5d・A3)。鍵(~/.tyhld/bin/autoupdate/enabled)が無い機では何もしない。
600
604
  process.exit(await runAutoupdateCommand(process.argv.slice(3)));
601
605
  break;
606
+ case 'resume-delivery': {
607
+ // ★Claude の利用上限で止めた配達を、今すぐ再開する(便 27a9fb19)。
608
+ // アカウントを切り替えたときに人が打つ。札(PC で1つのファイル)を外すだけ。
609
+ const h = readUsageHold();
610
+ if (h.state === 'none') {
611
+ console.log('[conductor] 利用上限の札はありません(配達は止まっていません)。');
612
+ }
613
+ else if (clearUsageHold()) {
614
+ console.log('[conductor] 利用上限の札を外しました。次の周(約15秒以内)から配達を再開します。');
615
+ }
616
+ else {
617
+ console.error(`[conductor] 札を外せませんでした: ${holdFilePath()}`);
618
+ process.exit(1);
619
+ }
620
+ break;
621
+ }
602
622
  case 'view':
603
623
  // ★見るだけの画面。職人も tmux も relay も起動せず、入力も受け付けない。
604
624
  // 既定は「開いたまま流れ続ける」ので、Ctrl+C まで戻らない(--once は1回で戻る)。
package/dist/headless.js CHANGED
@@ -21,6 +21,8 @@ import path from 'node:path';
21
21
  import os from 'node:os';
22
22
  import { CENTRAL_BUSY_HOLD_MAX_MS, RELAY_DELIVER_MAX, RELAY_FETCH_TIMEOUT_MS, RELAY_HEARTBEAT_INTERVAL_MS, RELAY_RESTORE_ORPHANS_ENABLED, ackResumeSignal, buildAnchor, buildSendText, canDeliver, completeWithReportOutcome, createRelayState, deliverJobEndFacts, deliveryReport, fetchCommand, fetchCommandState, fetchCommandStatus, fetchControlWithUpdate, fetchOrphans, flushPendingJobEndFacts, isTerminalCommandStatus, kindOf, markDelivered, noteCentralDown, noteCentralUp, noteDrain, noteReadiness, patchStatus, pruneLogLine, pruneStaleWorktrees, recoverStuckProcessedReports, reconnectDelayMs, WAIT_CLOSED_STATUS, FINISH_GATE_KINDS, reportDelivery, selectOrphanToRestore, sendHeartbeat, } from './relay.js';
23
23
  import { claudePinPath, readClaudePinLine, } from './autoupdate-flags.js';
24
+ import { cleanupJobWorkDir, jobWorkDirGuide, prepareJobWorkDir, stayInRepoDir, } from './job-workdir.js';
25
+ import { authHoldHit, clearUsageHold, detectUsageLimit, formatJst, mergeUsageLimit, placeUsageHold, readUsageHold, saveLimitResume, takeLimitResume, usageHoldNotice, usageLimitLabel, } from './usage-limit.js';
24
26
  const log = (msg) => {
25
27
  console.log(`[headless] ${msg}`);
26
28
  };
@@ -813,6 +815,10 @@ export function parseFinishGateResidue(raw) {
813
815
  const facts = reasons.length > 0 ? { exhausted: true, reasons: reasons, counts } : null;
814
816
  return { text: line.slice(0, 500), facts };
815
817
  }
818
+ /** やり直しの上限に数える試行番号(★利用上限で待ちに戻した分を引く・便 27a9fb19)。 */
819
+ export function countedAttempt(state, commandId, attempt) {
820
+ return attempt - (state.limitCredits?.get(commandId) ?? 0);
821
+ }
816
822
  /**
817
823
  * いま画面なし方式が追っている便の指示ID(★回収の道から除く物・便 6ebba0d0 の b)。
818
824
  *
@@ -1273,12 +1279,22 @@ resumeNote) {
1273
1279
  return null;
1274
1280
  }
1275
1281
  log(`claude bin=${claudeBin} version=${claudeVersion ?? 'unknown'}`);
1282
+ // ★職人へ渡す前に、フォルダが消えた作業場所の登録を片付ける(便 0204a1b9)。失敗しても起動は続ける。
1283
+ log(pruneLogLine(cfg.site, cfg.workDir, pruneStaleWorktrees(cfg.workDir)));
1284
+ // ★職人を起こす場所を決める(便 27a9fb19)。リポの元の場所には記録されない秘密のファイルが在り、
1285
+ // そこで動かすと番人が(正しく)止めて便が途中で終わる。だから便ごとの作業場所で起こす。
1286
+ // 作れない現場は今までどおり元の場所で起こし、理由をログに残す。★番人の判定は1つも変えない。
1287
+ const work = cfg.jobWorkDir === false
1288
+ ? stayInRepoDir(cfg.workDir, 'この PC の設定で便ごとの作業場所を使わない(CONDUCTOR_JOB_WORKTREE=off)')
1289
+ : prepareJobWorkDir({ repoDir: cfg.workDir, site: cfg.site, commandId: cmd.id, isResume });
1290
+ log(`site=${cfg.site} id=${cmd.id} ${work.note}`);
1276
1291
  const env = { ...process.env };
1277
1292
  delete env.CLAUDECODE;
1278
1293
  delete env.ANTHROPIC_API_KEY;
1279
1294
  env.CONDUCTOR_SITE = cfg.site;
1280
1295
  env.CONDUCTOR_MACHINE = cfg.machine;
1281
- env.CONDUCTOR_WORK_DIR = cfg.workDir;
1296
+ // ★職人が実際に居る場所を渡す(番人の「作業場所の中か」の物差しが、職人の居る場所と合うように)。
1297
+ env.CONDUCTOR_WORK_DIR = work.dir;
1282
1298
  // ★職人の PATH の先頭に、中継を動かしている node の bin と claude の bin を足す
1283
1299
  // (便 24c9b6b6・e9276b86)。決め方は buildWorkerPath の説明を見ること。
1284
1300
  env.PATH = buildWorkerPath(env.PATH, claudeBin);
@@ -1303,12 +1319,10 @@ resumeNote) {
1303
1319
  else {
1304
1320
  args.push('--session-id', sessionId);
1305
1321
  }
1306
- // ★職人へ渡す前に、フォルダが消えた作業場所の登録を片付ける(便 0204a1b9)。失敗しても起動は続ける。
1307
- log(pruneLogLine(cfg.site, cfg.workDir, pruneStaleWorktrees(cfg.workDir)));
1308
1322
  let proc;
1309
1323
  try {
1310
1324
  proc = spawn(claudeBin, args, {
1311
- cwd: cfg.workDir,
1325
+ cwd: work.dir,
1312
1326
  env,
1313
1327
  stdio: ['pipe', 'pipe', 'pipe'],
1314
1328
  });
@@ -1316,6 +1330,9 @@ resumeNote) {
1316
1330
  catch (err) {
1317
1331
  lastSpawnError = `claude の起動に失敗しました (${claudeBin}): ${err instanceof Error ? err.message : String(err)}`;
1318
1332
  log(`ERROR ${lastSpawnError}`);
1333
+ // ★作ったばかりの作業場所は残さない(同じ便の続きでも、職人は1文字も書いていない)。
1334
+ if (work.worktree && !work.reused)
1335
+ log(`site=${cfg.site} id=${cmd.id} ${cleanupJobWorkDir(work).note}`);
1319
1336
  return null;
1320
1337
  }
1321
1338
  const logs = openRunLogs(cmd.id, attempt);
@@ -1346,6 +1363,8 @@ resumeNote) {
1346
1363
  lastStopCheckAt: Date.now(),
1347
1364
  stderrBuf: '',
1348
1365
  authErrorDetected: false,
1366
+ usageLimit: null,
1367
+ workDir: work,
1349
1368
  stdoutLog: logs?.stdoutLog ?? null,
1350
1369
  stderrLog: logs?.stderrLog ?? null,
1351
1370
  eventsLog: logs?.eventsLog ?? null,
@@ -1382,9 +1401,11 @@ resumeNote) {
1382
1401
  proc.stdin.on('error', (err) => {
1383
1402
  noteHandoffFailed(`職人の処理へ本文を渡せませんでした(標準入力: ${err.message})`);
1384
1403
  });
1404
+ // ★便ごとの作業場所で起こすときだけ、その場所を本文に添える(便 27a9fb19)。今までどおりの便は1文字も変わらない。
1405
+ const guide = jobWorkDirGuide(work);
1385
1406
  const text = isResume
1386
1407
  ? buildResumePrompt(resumeNote)
1387
- : buildSendText(cmd.body, cfg.site, buildAnchor(cmd.id), kindOf(cfg));
1408
+ : buildSendText(guide ? `${cmd.body}\n\n${guide}` : cmd.body, cfg.site, buildAnchor(cmd.id), kindOf(cfg));
1388
1409
  try {
1389
1410
  // ★書き出しが本当に流れ切ってから 'done' にする(返事を待たずに「渡せた」と言わない)。
1390
1411
  proc.stdin.write(text, (err) => {
@@ -1415,6 +1436,10 @@ resumeNote) {
1415
1436
  if (!job.authErrorDetected && detectStreamAuthError(parsed)) {
1416
1437
  job.authErrorDetected = true;
1417
1438
  }
1439
+ // ★Claude の利用上限に当たった印(便 27a9fb19)。読めた物を重ねて持つ。
1440
+ const limit = detectUsageLimit(parsed);
1441
+ if (limit !== null)
1442
+ job.usageLimit = mergeUsageLimit(job.usageLimit ?? null, limit);
1418
1443
  for (const event of streamEventsFromLine(parsed, attempt)) {
1419
1444
  // ★1便あたりの件数に上限を持つ(生の記録の全量は PC の外へ送らない)。
1420
1445
  if (job.eventsSent >= EVENT_MAX_PER_JOB)
@@ -1525,6 +1550,27 @@ export async function flushEvents(cfg, job) {
1525
1550
  // ─────────────────────────────────────────────────────────────────────────────
1526
1551
  // 実行中ジョブの監視
1527
1552
  // ─────────────────────────────────────────────────────────────────────────────
1553
+ /**
1554
+ * 便が終わった(★もう続きから起こさない)ときに、便ごとの作業場所を片付ける(便 27a9fb19)。
1555
+ * ★記録していない変更・送っていない記録が残っていれば消さず、場所と理由を管制へ1回知らせる。
1556
+ * ★続きから起こす便(自動再開・利用上限の待ち)では呼ばない=同じ場所で続きを起こすため。
1557
+ */
1558
+ async function finishJobWorkDir(cfg, job) {
1559
+ const w = job.workDir;
1560
+ if (w === undefined || !w.worktree)
1561
+ return;
1562
+ job.workDir = undefined; // 二重に片付けない
1563
+ const r = cleanupJobWorkDir(w);
1564
+ log(`site=${cfg.site} id=${job.commandId} ${r.note}`);
1565
+ if (!r.removed) {
1566
+ await sendCommandEvents(cfg, job.commandId, [{
1567
+ type: 'progress',
1568
+ text: r.note.slice(0, EVENT_TEXT_MAX),
1569
+ at: new Date().toISOString(),
1570
+ attempt: job.attempt,
1571
+ }]);
1572
+ }
1573
+ }
1528
1574
  /**
1529
1575
  * 実行中のジョブを1tick分チェックする。
1530
1576
  * 完了・停止・タイムアウト・生存通知・イベントフラッシュを処理する。
@@ -1553,6 +1599,18 @@ async function checkRunningJob(cfg, state) {
1553
1599
  ...(detail !== undefined ? { detail } : {}),
1554
1600
  });
1555
1601
  };
1602
+ // ★Claude の利用上限で終わった便か(便 27a9fb19)。
1603
+ // 上限の印が出て、報告を出せずに終わった便だけ(報告まで出せた便は、ふつうに終わった便)。
1604
+ // 本文を渡せなかった・時間切れ・止められた・片づけただけ の便は、それぞれの後始末に任せる。
1605
+ const usageHit = job.usageLimit != null
1606
+ && job.bodyHandoff !== 'failed' && !job.timedOut && !job.stopped && !job.reapedAfterFinish
1607
+ && !reportDelivery(job.commandId).delivered
1608
+ ? job.usageLimit
1609
+ : null;
1610
+ const usageDetail = usageHit === null
1611
+ ? null
1612
+ : `Claude の${usageLimitLabel(usageHit.limitType)}に当たって終わりました(失敗にせず待ちに戻します)` +
1613
+ (usageHit.text ? `: ${usageHit.text}` : '');
1556
1614
  // ★再開するかもしれない便だけ、終わりの事実を届ける前に「停止の依頼」を1回確かめる
1557
1615
  // (けいさん決定 2026-10-07・便 fbdd7482)。
1558
1616
  //
@@ -1635,6 +1693,8 @@ async function checkRunningJob(cfg, state) {
1635
1693
  // ★停止の依頼が無いのに外から終了した便(便 fbdd7482)。「止めました」とは書かず、
1636
1694
  // 原因不明の終了として残す(扱いは今までどおり=再開・上限3回)。
1637
1695
  ?? (unknownExternalEnd ? unknownExternalEndDetail(job.exitCode, job.exitSignal) : null)
1696
+ // ★利用上限で終わった便(便 27a9fb19)。異常終了とは別の理由だと分かる一言を載せる。
1697
+ ?? usageDetail
1638
1698
  ?? delivery.note
1639
1699
  ?? `attempt ${job.attempt}/${HEADLESS_MAX_ATTEMPTS}`,
1640
1700
  // ★上限に達して「途中で終わった」便だけに付ける(管制が機械で見分けられる形)。
@@ -1654,6 +1714,7 @@ async function checkRunningJob(cfg, state) {
1654
1714
  await patchStatus(cfg, job.commandId, 'failed', reason.slice(0, EVENT_TEXT_MAX));
1655
1715
  rs.abandoned.add(job.commandId);
1656
1716
  noteLastJob('timeout', reason);
1717
+ await finishJobWorkDir(cfg, job);
1657
1718
  state.job = null;
1658
1719
  rs.lastHeartbeatAt = null;
1659
1720
  log(`WARN site=${cfg.site} id=${job.commandId} ${reason}`);
@@ -1672,6 +1733,7 @@ async function checkRunningJob(cfg, state) {
1672
1733
  noteLastJob('stopped', '管制から止めました');
1673
1734
  // ★畳んだ便は、もう拾い直す対象ではない(手元の記録は役目を終えた)。
1674
1735
  clearStopRequested(cfg.site, job.commandId);
1736
+ await finishJobWorkDir(cfg, job);
1675
1737
  state.job = null;
1676
1738
  rs.lastHeartbeatAt = null;
1677
1739
  log(`site=${cfg.site} id=${job.commandId} 停止の依頼で停止しました(再開しません)`);
@@ -1686,11 +1748,43 @@ async function checkRunningJob(cfg, state) {
1686
1748
  // (片づけの終了コードは 0 ではないので、落ちると再開の道へ入ってしまう)。
1687
1749
  const detail = reapedAfterFinishDetail(job.exitCode, job.exitSignal);
1688
1750
  noteLastJob('done', detail);
1751
+ await finishJobWorkDir(cfg, job);
1689
1752
  state.job = null;
1690
1753
  rs.lastHeartbeatAt = null;
1691
1754
  log(`site=${cfg.site} id=${job.commandId} 畳みます(${detail})`);
1692
1755
  return;
1693
1756
  }
1757
+ if (usageHit !== null) {
1758
+ // ★Claude の利用上限で終わった便(便 27a9fb19)。便の中身のせいではないので failed にしない。
1759
+ // ① PC で1つの札を置き、この PC へのほかの便の配達も止める(上限が戻る時刻まで)。
1760
+ // ② この便は管制で「待ち(queued)」に戻す。★書けなければ次の周で書き直す(requeuePending)。
1761
+ // ③ 次に配るときは、上限に当たった回の会話の続きから起こす(控えを手元に残す)。
1762
+ // ④ 札を新しく置いたときだけ、管制へ1回知らせる。
1763
+ // ★作業場所は片付けない(続きを同じ場所で起こすため)。やり直しの回数も使わせない。
1764
+ const placed = placeUsageHold(usageHit, { site: cfg.site, commandId: job.commandId });
1765
+ saveLimitResume(cfg.site, { commandId: job.commandId, sessionId: job.sessionId, attempt: job.attempt });
1766
+ state.attempts.set(job.commandId, job.attempt);
1767
+ if (!(await patchStatus(cfg, job.commandId, 'queued'))) {
1768
+ (state.requeuePending ??= new Set()).add(job.commandId);
1769
+ }
1770
+ if (placed.created) {
1771
+ await sendCommandEvents(cfg, job.commandId, [{
1772
+ type: 'progress',
1773
+ text: usageHoldNotice(placed.hold, cfg.machine).slice(0, EVENT_TEXT_MAX),
1774
+ at: new Date().toISOString(),
1775
+ attempt: job.attempt,
1776
+ }]);
1777
+ }
1778
+ const detail = `${usageDetail ?? ''}・再開予定 ${formatJst(placed.hold.resumeAtMs)}(日本時間)`;
1779
+ // ★札(outcome)は増やさない(便 f20dd761 の決め)。止めて待たせた事実は 'stopped'、中身は detail で言う。
1780
+ noteLastJob('stopped', detail);
1781
+ state.job = null;
1782
+ rs.lastHeartbeatAt = null;
1783
+ log(`WARN site=${cfg.site} id=${job.commandId} Claude の利用上限 → 失敗にせず待ちに戻し、` +
1784
+ `この PC の配達を ${formatJst(placed.hold.resumeAtMs)}(日本時間)まで止めます` +
1785
+ `(管制への知らせ: ${placed.created ? '送った' : '既に送った待ちの続き'})`);
1786
+ return;
1787
+ }
1694
1788
  if (isAuthError(job)) {
1695
1789
  // 認証エラー → 再試行しない
1696
1790
  const detail = job.authErrorDetected
@@ -1703,13 +1797,30 @@ async function checkRunningJob(cfg, state) {
1703
1797
  at: new Date().toISOString(),
1704
1798
  attempt: job.attempt,
1705
1799
  }]);
1706
- // ★中央へ failed を返す(次の便が止まらないように)
1707
- await patchStatus(cfg, job.commandId, 'failed', authMsg);
1708
- rs.abandoned.add(job.commandId);
1709
- noteLastJob('auth_error', authMsg);
1800
+ // ★ログイン切れは便の中身ではなく PC の状態(便 6d0b403f・実地 2026-10-28 に3便続けて failed)。
1801
+ // 利用上限と同じく、この便は failed にせず「待ち」に戻し、PC で1つの札でほかの便の配達も止める。
1802
+ // ★続きからではなく新しい会話で起こし直す(fresh)。やり直しの回数も使わせない。
1803
+ // ★作業場所は片付ける(新しい会話は新しい作業場所で起こす。変更が残っていれば消さずに残る)。
1804
+ const placed = placeUsageHold(authHoldHit(detail), { site: cfg.site, commandId: job.commandId });
1805
+ saveLimitResume(cfg.site, { commandId: job.commandId, sessionId: '', attempt: job.attempt, fresh: true });
1806
+ state.attempts.set(job.commandId, job.attempt);
1807
+ if (!(await patchStatus(cfg, job.commandId, 'queued'))) {
1808
+ (state.requeuePending ??= new Set()).add(job.commandId);
1809
+ }
1810
+ if (placed.created) {
1811
+ await sendCommandEvents(cfg, job.commandId, [{
1812
+ type: 'progress',
1813
+ text: usageHoldNotice(placed.hold, cfg.machine).slice(0, EVENT_TEXT_MAX),
1814
+ at: new Date().toISOString(),
1815
+ attempt: job.attempt,
1816
+ }]);
1817
+ }
1818
+ noteLastJob('auth_error', `${authMsg}・失敗にせず待ちに戻しました(試し直し ${formatJst(placed.hold.resumeAtMs)} 日本時間)`);
1819
+ await finishJobWorkDir(cfg, job);
1710
1820
  state.job = null;
1711
1821
  rs.lastHeartbeatAt = null;
1712
- log(`WARN site=${cfg.site} id=${job.commandId} 認証エラー → 再試行しない`);
1822
+ log(`WARN site=${cfg.site} id=${job.commandId} 認証エラー → 失敗にせず待ちに戻し、` +
1823
+ `この PC の配達を ${formatJst(placed.hold.resumeAtMs)}(日本時間)まで止めます`);
1713
1824
  return;
1714
1825
  }
1715
1826
  if (job.exitCode === 0) {
@@ -1727,6 +1838,7 @@ async function checkRunningJob(cfg, state) {
1727
1838
  state.doneWriteTries?.delete(job.commandId);
1728
1839
  log(`site=${cfg.site} id=${job.commandId} 畳みます(exit=0, attempt ${job.attempt}・${settle.detail})`);
1729
1840
  noteLastJob('done', settle.detail);
1841
+ await finishJobWorkDir(cfg, job);
1730
1842
  state.job = null;
1731
1843
  rs.lastHeartbeatAt = null;
1732
1844
  return;
@@ -1753,6 +1865,7 @@ async function checkRunningJob(cfg, state) {
1753
1865
  rs.abandoned.add(job.commandId);
1754
1866
  state.doneWriteTries.delete(job.commandId);
1755
1867
  noteLastJob('failed', reason);
1868
+ await finishJobWorkDir(cfg, job);
1756
1869
  state.job = null;
1757
1870
  rs.lastHeartbeatAt = null;
1758
1871
  log(`ERROR site=${cfg.site} id=${job.commandId} ${reason}`);
@@ -1773,7 +1886,8 @@ async function checkRunningJob(cfg, state) {
1773
1886
  attempt: job.attempt,
1774
1887
  }]);
1775
1888
  const nextAttempt = (state.attempts.get(job.commandId) ?? job.attempt) + 1;
1776
- if (nextAttempt > HEADLESS_MAX_ATTEMPTS) {
1889
+ // ★利用上限で待ちに戻した分は、やり直しの回数に数えない(便 27a9fb19)。
1890
+ if (countedAttempt(state, job.commandId, nextAttempt) > HEADLESS_MAX_ATTEMPTS) {
1777
1891
  log(`WARN site=${cfg.site} id=${job.commandId} 試行回数上限(${HEADLESS_MAX_ATTEMPTS}) → 放棄`);
1778
1892
  // ★中央へ failed を返す(次の便が止まらないように)
1779
1893
  const failReason = maskSecrets(`${HEADLESS_MAX_ATTEMPTS}回すべて異常終了 (最後: exit=${job.exitCode}, signal=${job.exitSignal})` +
@@ -1787,6 +1901,7 @@ async function checkRunningJob(cfg, state) {
1787
1901
  }]);
1788
1902
  rs.abandoned.add(job.commandId);
1789
1903
  noteLastJob('failed', failReason);
1904
+ await finishJobWorkDir(cfg, job);
1790
1905
  }
1791
1906
  else {
1792
1907
  // ★ pendingRetry に詰めて、次の tick で実際に spawn する(fetchCommand は sent を返さない)
@@ -2425,6 +2540,33 @@ export async function recoverStuckCommands(cfg, opts = {}) {
2425
2540
  // ─────────────────────────────────────────────────────────────────────────────
2426
2541
  // headless tick(relayTick の headless 版)
2427
2542
  // ─────────────────────────────────────────────────────────────────────────────
2543
+ /**
2544
+ * Claude の利用上限の札を見る(便 27a9fb19)。返り true=配ってよい。
2545
+ * ★札は PC で1つ(現場ごとの配り役が同じファイルを見る)。時刻を過ぎた札は外す。
2546
+ * ★置かれた/外れたの変わり目だけ1行出す(毎周は出さない)。
2547
+ */
2548
+ export function noteUsageHold(state, site, now = Date.now()) {
2549
+ const h = readUsageHold(now);
2550
+ if (h.state === 'active') {
2551
+ if (state.lastUsageHold !== true) {
2552
+ log(`site=${site} Claude の${usageLimitLabel(h.hold.limitType)}の札があるため、この PC へ便を配りません` +
2553
+ `(再開予定 ${formatJst(h.hold.resumeAtMs)} 日本時間・走っている便は止めません・積まれた便は管制で待ちます。` +
2554
+ '今すぐ再開するには `conductor resume-delivery`)');
2555
+ }
2556
+ state.lastUsageHold = true;
2557
+ noteReadiness(state.relay, 'halted', null, now);
2558
+ return false;
2559
+ }
2560
+ if (h.state === 'expired') {
2561
+ clearUsageHold();
2562
+ log(`site=${site} Claude の${usageLimitLabel(h.hold.limitType)}の待ちの時刻を過ぎたので、札を外して配達を再開します`);
2563
+ }
2564
+ else if (state.lastUsageHold === true) {
2565
+ log(`site=${site} Claude の利用上限の札が外れました。配達を再開します`);
2566
+ }
2567
+ state.lastUsageHold = false;
2568
+ return true;
2569
+ }
2428
2570
  /**
2429
2571
  * headless 方式の1tick。relayTick の代わりに createRelayRunner へ渡す。
2430
2572
  *
@@ -2498,6 +2640,18 @@ export async function headlessTick(cfg, state, hooks) {
2498
2640
  trackedIds: [...headlessTrackedCommandIds(state), ...resumeGuard],
2499
2641
  state,
2500
2642
  });
2643
+ // ── 利用上限で待ちに戻す書き込みの書き直し(便 27a9fb19)──
2644
+ // ★停止トグルの確認より後に置く=止められている現場では外へ出ない。
2645
+ for (const id of [...(state.requeuePending ?? [])]) {
2646
+ if (await patchStatus(cfg, id, 'queued'))
2647
+ state.requeuePending?.delete(id);
2648
+ }
2649
+ // ── Claude の利用上限の札(便 27a9fb19)──
2650
+ // 札が在るあいだは、この PC へ便を配らない(新しい便・自動再開・再開の合図のどれも)。
2651
+ // ★走っている便(state.job)は上で済んでいる=止めない。便は管制で待つだけで、失われない。
2652
+ // 時刻を過ぎた札は外して、この周から配達を再開する。
2653
+ if (!noteUsageHold(state, cfg.site))
2654
+ return;
2501
2655
  // ── 異常終了後の自動再開(pendingRetry)──
2502
2656
  if (state.pendingRetry !== null) {
2503
2657
  const retry = state.pendingRetry;
@@ -2564,20 +2718,34 @@ export async function headlessTick(cfg, state, hooks) {
2564
2718
  log(`WARN site=${cfg.site} id=${cmd.id} 配達回数上限(${RELAY_DELIVER_MAX}) → 以後配達しない`);
2565
2719
  return;
2566
2720
  }
2721
+ // ── 利用上限で待ちに戻した便の続き(便 27a9fb19)──
2722
+ // 上限に当たった回の会話の続きから起こす。★やり直しの回数には数えない(limitCredits)。
2723
+ const limited = takeLimitResume(cfg.site, cmd.id);
2724
+ if (limited !== null) {
2725
+ const credits = state.limitCredits ??= new Map();
2726
+ credits.set(cmd.id, (credits.get(cmd.id) ?? 0) + 1);
2727
+ state.attempts.set(cmd.id, Math.max(state.attempts.get(cmd.id) ?? 0, limited.attempt));
2728
+ }
2567
2729
  // ── 試行回数 ──
2568
2730
  const attempt = (state.attempts.get(cmd.id) ?? 0) + 1;
2569
2731
  state.attempts.set(cmd.id, attempt);
2570
- if (attempt > HEADLESS_MAX_ATTEMPTS) {
2732
+ if (countedAttempt(state, cmd.id, attempt) > HEADLESS_MAX_ATTEMPTS) {
2571
2733
  rs.abandoned.add(cmd.id);
2572
2734
  log(`WARN site=${cfg.site} id=${cmd.id} 試行回数上限(${HEADLESS_MAX_ATTEMPTS}) → 放棄`);
2573
2735
  return;
2574
2736
  }
2575
2737
  // ── claude -p を起動 ──
2576
- const isResume = attempt > 1;
2738
+ // ★ログイン切れで待ちに戻した便は、新しい会話で起こし直す(便 6d0b403f)。
2739
+ // 会話IDは試行番号ごとに別なので、前の回と重ならない。
2740
+ const freshAfterHold = limited?.fresh === true;
2741
+ const isResume = attempt > 1 && !freshAfterHold;
2577
2742
  // resume: 前回のセッション ID を渡す。fresh start: 新しいセッション ID を作る。
2578
- const sessionId = isResume
2579
- ? sessionIdForCommand(cmd.id, attempt - 1)
2580
- : sessionIdForCommand(cmd.id, attempt);
2743
+ // ★利用上限の続きは、上限に当たった回の会話IDそのものを使う(便 27a9fb19)。
2744
+ const sessionId = limited !== null && !freshAfterHold
2745
+ ? limited.sessionId
2746
+ : isResume
2747
+ ? sessionIdForCommand(cmd.id, attempt - 1)
2748
+ : sessionIdForCommand(cmd.id, attempt);
2581
2749
  const job = spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume);
2582
2750
  if (job === null) {
2583
2751
  // ★起動失敗を管制へ知らせる(「起動しました」とは言わない)
@@ -2598,6 +2766,7 @@ export async function headlessTick(cfg, state, hooks) {
2598
2766
  if (job.bodyHandoff === 'failed') {
2599
2767
  const why = job.bodyHandoffError ?? '職人の処理へ本文を渡せませんでした';
2600
2768
  await stopJob(job);
2769
+ await finishJobWorkDir(cfg, job);
2601
2770
  await patchStatus(cfg, cmd.id, 'failed', why.slice(0, EVENT_TEXT_MAX));
2602
2771
  await sendCommandEvents(cfg, cmd.id, [{
2603
2772
  type: 'error',
@@ -0,0 +1,245 @@
1
+ /**
2
+ * 便ごとの作業場所(git worktree)を作る・片付ける(便 27a9fb19・えふさん決定 2026-11-04)。
3
+ *
4
+ * 【なぜ要るか(実地 便 e0796fcd)】
5
+ * これまで画面なし方式の職人は、リポの元の場所(~/projects/<現場>)で起きていた。
6
+ * そこには記録されない秘密のファイル(.npmrc など)が在るので、職人が python3 などを動かすと
7
+ * 番人が「秘密のファイルが在る場所で動かした」と正しく止め、便が途中で終わっていた。
8
+ * ★番人は正しい(緩めない)。直すのは配り方の側=職人を秘密のファイルが無い場所で起こす。
9
+ *
10
+ * 【決め】
11
+ * ・便を渡す前に、その現場のリポから `git worktree add --detach` で
12
+ * /tmp/claude-<uid>/conductor-job-<現場>-<便ID> を作る(最新の origin の既定の枝が元)。
13
+ * ★枝を作らない(--detach)=リポの元の場所の未記録の変更・ほかの枝には1バイトも触らない。
14
+ * ・同じ便の続き(自動再開・利用上限の後の配り直し)は、同じ作業場所を使い直す
15
+ * (Claude Code の会話の記録は起きた場所ごとに分かれるので、場所が変わると続きから起こせない)。
16
+ * ・リポの元の場所の `.claude/settings.local.json`(記録されない守り)と、記録されていない
17
+ * `.claude/settings.json` は、作業場所へ写す=★守りは1つも落とさない
18
+ * (作業場所には記録された物しか無いので、写さないと現場ごとの守りが外れる)。
19
+ * ・便が終わったら片付ける。★記録していない変更・送っていない記録が残っていれば消さない
20
+ * (理由を返す=呼び出し側が報告に残す)。消すのは `git worktree remove`(--force なし)だけ。
21
+ * ・作れない現場(リポでない・origin の枝が無い・同じ名前の物が既に在る など)は
22
+ * 今までどおりリポの元の場所で起こし、理由を返す(呼び出し側が記録する)。
23
+ *
24
+ * ★番人の判定・禁止の一覧は1行も変えていない(この部品は配り役の中だけで動く)。
25
+ */
26
+ import { spawnSync } from 'node:child_process';
27
+ import { copyFileSync, existsSync, mkdirSync, realpathSync, unlinkSync } from 'node:fs';
28
+ import path from 'node:path';
29
+ /** 取り寄せ・作業場所づくりの上限時間(無応答の通信で配り役の輪を長く止めない)。 */
30
+ export const JOB_WORKDIR_GIT_TIMEOUT_MS = 120_000;
31
+ /** 作業場所へ写す守りの設定(★リポの元の場所の `.claude/` の下の名前)。 */
32
+ export const JOB_WORKDIR_SETTINGS_FILES = ['settings.json', 'settings.local.json'];
33
+ /** 作業場所の名前の頭(★便IDが入る。片付けの見回りはこの頭で見分ける)。 */
34
+ export const JOB_WORKDIR_PREFIX = 'conductor-job-';
35
+ export const defaultGitRun = (args, opts) => {
36
+ const r = spawnSync('git', args, {
37
+ encoding: 'utf8',
38
+ timeout: opts?.timeoutMs ?? 30_000,
39
+ // ★人に問い合わせる画面を出さない(配り役は人の居ない常駐)。
40
+ env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
41
+ });
42
+ return {
43
+ status: r.status,
44
+ stdout: r.stdout ?? '',
45
+ stderr: (r.stderr ?? '') || (r.error ? r.error.message : ''),
46
+ };
47
+ };
48
+ /** 作業場所を置く根(★職人の囲いが書ける /tmp/claude-<uid>)。試験では環境変数で差し替える。 */
49
+ export function jobDirRoot(env = process.env) {
50
+ const override = (env.CONDUCTOR_JOB_DIR_ROOT ?? '').trim();
51
+ if (override)
52
+ return override;
53
+ const uid = typeof process.getuid === 'function' ? process.getuid() : 1000;
54
+ return path.join('/tmp', `claude-${uid}`);
55
+ }
56
+ /** 便ごとの作業場所の道(★純粋関数)。名前に使えない文字しか無ければ null。 */
57
+ export function jobWorkDirPath(site, commandId, root = jobDirRoot()) {
58
+ const safeSite = String(site ?? '').replace(/[^A-Za-z0-9_.-]/g, '').replace(/^\.+/, '');
59
+ const safeId = String(commandId ?? '').replace(/[^A-Za-z0-9_-]/g, '');
60
+ if (!safeSite || !safeId)
61
+ return null;
62
+ return path.join(root, `${JOB_WORKDIR_PREFIX}${safeSite}-${safeId}`);
63
+ }
64
+ /** 今までどおりリポの元の場所で起こす決まり(★純粋関数)。 */
65
+ export function stayInRepoDir(repoDir, why) {
66
+ return {
67
+ dir: repoDir,
68
+ repoDir,
69
+ worktree: false,
70
+ reused: false,
71
+ base: null,
72
+ copiedSettings: [],
73
+ note: `リポの元の場所で起こします(${why})`,
74
+ };
75
+ }
76
+ function tail(s, n = 200) {
77
+ const t = s.trim().replace(/\s+/g, ' ');
78
+ return t.length > n ? t.slice(-n) : t;
79
+ }
80
+ function samePath(a, b) {
81
+ try {
82
+ return realpathSync(a) === realpathSync(b);
83
+ }
84
+ catch {
85
+ return path.resolve(a) === path.resolve(b);
86
+ }
87
+ }
88
+ /** dir がリポ repoDir に登録された作業場所か(`git worktree list` で見る)。 */
89
+ function isRegisteredWorktree(repoDir, dir, git) {
90
+ const r = git(['-C', repoDir, 'worktree', 'list', '--porcelain']);
91
+ if (r.status !== 0)
92
+ return false;
93
+ return r.stdout
94
+ .split('\n')
95
+ .filter((l) => l.startsWith('worktree '))
96
+ .some((l) => samePath(l.slice('worktree '.length).trim(), dir));
97
+ }
98
+ /** リポの元の場所の守りの設定を作業場所へ写す(★記録された物=作業場所に既に在る物は写さない)。 */
99
+ function copySettings(repoDir, dir) {
100
+ const copied = [];
101
+ for (const name of JOB_WORKDIR_SETTINGS_FILES) {
102
+ const src = path.join(repoDir, '.claude', name);
103
+ const dst = path.join(dir, '.claude', name);
104
+ if (!existsSync(src) || existsSync(dst))
105
+ continue;
106
+ try {
107
+ mkdirSync(path.dirname(dst), { recursive: true });
108
+ copyFileSync(src, dst);
109
+ copied.push(name);
110
+ }
111
+ catch {
112
+ // 写せなかった物は呼び出し側で「作業場所を使わない」に倒す(守りを落としたまま起こさない)。
113
+ throw new Error(`守りの設定(.claude/${name})を作業場所へ写せませんでした`);
114
+ }
115
+ }
116
+ return copied;
117
+ }
118
+ /**
119
+ * 職人を起こす場所を決める(★必要なら作業場所を作る)。例外は投げない。
120
+ *
121
+ * isResume … 前の会話の続きから起こすか。続きなのに作業場所が無いときは、前の会話が
122
+ * リポの元の場所で起きている(この直しより前に始まった便)ので、今までどおり元の場所で起こす。
123
+ */
124
+ export function prepareJobWorkDir(opts) {
125
+ const git = opts.git ?? defaultGitRun;
126
+ const repoDir = opts.repoDir;
127
+ const fallback = (why) => stayInRepoDir(repoDir, why);
128
+ const target = jobWorkDirPath(opts.site, opts.commandId, opts.root ?? jobDirRoot());
129
+ if (target === null)
130
+ return fallback('現場名か便IDに使えない文字しか無い');
131
+ if (existsSync(target)) {
132
+ if (!isRegisteredWorktree(repoDir, target, git)) {
133
+ // ★この配り役が作った物ではないかもしれないので、触らない。
134
+ return fallback(`同じ名前の物が既に在り、このリポの作業場所ではない: ${target}`);
135
+ }
136
+ try {
137
+ const copied = copySettings(repoDir, target);
138
+ return {
139
+ dir: target, repoDir, worktree: true, reused: true, base: null, copiedSettings: copied,
140
+ note: `同じ便の作業場所を使い直します: ${target}`,
141
+ };
142
+ }
143
+ catch (err) {
144
+ return fallback(err instanceof Error ? err.message : String(err));
145
+ }
146
+ }
147
+ if (opts.isResume)
148
+ return fallback('前の会話はリポの元の場所で起きている(続きはその場所でしか起こせない)');
149
+ const top = git(['-C', repoDir, 'rev-parse', '--show-toplevel']);
150
+ if (top.status !== 0 || !samePath(top.stdout.trim(), repoDir)) {
151
+ return fallback('リポではない(git の作業場所の根ではない)');
152
+ }
153
+ // 最新を取り寄せる。★失敗しても手元の origin の枝で続ける(取り寄せの失敗で便を止めない)。
154
+ const fetched = git(['-C', repoDir, 'fetch', 'origin', '--quiet'], { timeoutMs: JOB_WORKDIR_GIT_TIMEOUT_MS });
155
+ const fetchNote = fetched.status === 0 ? '' : `・取り寄せに失敗したので手元の origin の枝を使います(${tail(fetched.stderr)})`;
156
+ let base = null;
157
+ for (const ref of ['origin/HEAD', 'origin/main']) {
158
+ if (git(['-C', repoDir, 'rev-parse', '--verify', '--quiet', `refs/remotes/${ref}`]).status === 0) {
159
+ base = ref;
160
+ break;
161
+ }
162
+ }
163
+ if (base === null)
164
+ return fallback('origin の既定の枝(origin/HEAD・origin/main)が無い');
165
+ try {
166
+ mkdirSync(path.dirname(target), { recursive: true });
167
+ }
168
+ catch (err) {
169
+ return fallback(`作業場所の置き場を作れない(${err instanceof Error ? err.message : String(err)})`);
170
+ }
171
+ const added = git(['-C', repoDir, 'worktree', 'add', '--detach', target, base], {
172
+ timeoutMs: JOB_WORKDIR_GIT_TIMEOUT_MS,
173
+ });
174
+ if (added.status !== 0)
175
+ return fallback(`作業場所を作れない(${tail(added.stderr)})`);
176
+ try {
177
+ const copied = copySettings(repoDir, target);
178
+ return {
179
+ dir: target, repoDir, worktree: true, reused: false, base, copiedSettings: copied,
180
+ note: `便ごとの作業場所で起こします: ${target}(元: ${base})${fetchNote}`,
181
+ };
182
+ }
183
+ catch (err) {
184
+ // ★守りを写せない作業場所では起こさない。作ったばかりの作業場所は片付ける。
185
+ git(['-C', repoDir, 'worktree', 'remove', target]);
186
+ return fallback(err instanceof Error ? err.message : String(err));
187
+ }
188
+ }
189
+ /**
190
+ * 便の作業場所を片付ける。例外は投げない。
191
+ * ★記録していない変更・送っていない記録が残っていれば消さない(場所と理由を返す)。
192
+ * ★`--force` は使わない(git が「きれいでない」と言う物は消さない)。
193
+ */
194
+ export function cleanupJobWorkDir(w, git = defaultGitRun) {
195
+ if (!w.worktree)
196
+ return { removed: false, note: 'リポの元の場所で起こした便(片付ける作業場所はありません)' };
197
+ if (!existsSync(w.dir)) {
198
+ git(['-C', w.repoDir, 'worktree', 'prune']);
199
+ return { removed: true, note: `作業場所は既にありません: ${w.dir}` };
200
+ }
201
+ // 写した守りの設定は、配り役が置いた物なので先に外す(職人の変更と数えない)。
202
+ // ★使い直した作業場所では前の回に写した物が残っているので、名前で見る:
203
+ // 作業場所で記録されていない(=写した)物だけを外す。記録された物には触らない。
204
+ for (const name of JOB_WORKDIR_SETTINGS_FILES) {
205
+ const rel = path.join('.claude', name);
206
+ if (!existsSync(path.join(w.dir, rel)))
207
+ continue;
208
+ if (git(['-C', w.dir, 'ls-files', '--error-unmatch', '--', rel]).status === 0)
209
+ continue;
210
+ try {
211
+ unlinkSync(path.join(w.dir, rel));
212
+ }
213
+ catch { /* 外せなければ下の状態確認が残す側に倒す */ }
214
+ }
215
+ const keep = (why) => ({
216
+ removed: false,
217
+ note: `作業場所を消さずに残しました(${why}): ${w.dir}`,
218
+ });
219
+ const st = git(['-C', w.dir, 'status', '--porcelain']);
220
+ if (st.status !== 0)
221
+ return keep(`状態を確かめられない: ${tail(st.stderr)}`);
222
+ if (st.stdout.trim().length > 0)
223
+ return keep('記録していない変更が残っている');
224
+ const unpushed = git(['-C', w.dir, 'rev-list', '-n', '1', 'HEAD', '--not', '--remotes']);
225
+ if (unpushed.status !== 0)
226
+ return keep(`送ったかを確かめられない: ${tail(unpushed.stderr)}`);
227
+ if (unpushed.stdout.trim().length > 0)
228
+ return keep('送っていない記録が残っている');
229
+ const rm = git(['-C', w.repoDir, 'worktree', 'remove', w.dir]);
230
+ if (rm.status !== 0)
231
+ return keep(`git が消せないと言った: ${tail(rm.stderr)}`);
232
+ return { removed: true, note: `作業場所を片付けました: ${w.dir}` };
233
+ }
234
+ /**
235
+ * 職人へ渡す本文に添える「作業場所」の段(★純粋関数)。今までどおりの便では空文字。
236
+ * ★職人の鉄則にも同じことを書いてある(鉄則1)。便ごとに変わる値(場所)だけをここで渡す。
237
+ */
238
+ export function jobWorkDirGuide(w) {
239
+ if (!w.worktree)
240
+ return '';
241
+ return (`【作業場所】この便は配り役が作った便ごとの作業場所 ${w.dir} で起きています` +
242
+ `(最新の origin の既定の枝・枝は未作成)。cd は不要。リポの元の場所 ${w.repoDir} では命令を動かさない。` +
243
+ `枝は \`git switch -c <作業ブランチ名> --no-track origin/main\` で切る(新しい worktree は作らない)。` +
244
+ `便が終わると配り役が片付けます(記録していない変更・送っていない記録が残っていれば残します)。`);
245
+ }
package/dist/relay.js CHANGED
@@ -2914,7 +2914,11 @@ export function buildSendText(body, site, anchor, kind = 'claude', context) {
2914
2914
  // ★Codex の職人には Codex にできることだけを頼む全文を付ける(便 cfa9eeec・codexCompletionGuide)。
2915
2915
  // 鉄則(~/.claude/skills)は Codex には届かないので、全文で渡すのは今までどおり。
2916
2916
  const guide = kind === 'codex' ? codexCompletionGuide(site, commandId) : shortCompletionLine(site, commandId);
2917
- const full = `${body}\n\n${dispatchContextBlock(context)}${guide}` +
2917
+ // ★Claude の職人には、どのチャットの便にも同じ「共通の型」を付ける(便 6d0b403f)。
2918
+ // 各チャットの本文に頼らず、途中で止まる書き方を最初から選ばせないため。正本は鉄則の同名の節。
2919
+ // ★Codex には付けない(鉄則も Read の道具も届かないので、書いてある道具が使えない)。
2920
+ const common = kind === 'codex' ? '' : `${craftCommonBlock()}\n\n`;
2921
+ const full = `${body}\n\n${dispatchContextBlock(context)}${common}${guide}` +
2918
2922
  // アンカー(管理用ジョブ印)は必ず本文の最後に置く。完了検出の境界として使う。
2919
2923
  `(管理用ジョブ印・変更不要: ${anchor})`;
2920
2924
  // 改行(と連続改行)を空白1個に潰し、前後を整える。
@@ -2939,6 +2943,34 @@ export function dispatchContextBlock(context) {
2939
2943
  }
2940
2944
  return lines.length > 0 ? `${lines.join('\n')}\n\n` : '';
2941
2945
  }
2946
+ /** 鉄則(conductor-craftsman の SKILL.md)の中の、共通の型の正本の見出し。 */
2947
+ export const CRAFT_COMMON_HEADING = '## 途中で止まらない書き方(全便の共通の型)';
2948
+ /**
2949
+ * どのチャットの便にも配り役が付ける「共通の型」(便 6d0b403f・えふさん決定 2026-11-04)。
2950
+ *
2951
+ * 【なぜ要るか】直近30日、途中で止まった便の多くは便の中身ではなく「止まりやすい書き方」だった
2952
+ * (元の場所を名指しした cd+grep を $(...) の中で動かした e879cf84/元の場所で python3 を動かした
2953
+ * e0796fcd/禁止のパイプ・grep を使った 62475b9e)。チャットごとに本文へ書き足していたので、
2954
+ * 書き忘れた便・書き方の違う便で同じ止まり方がくり返された。
2955
+ * 【決め】要点だけを全便に付ける。言い切りの正本は鉄則の CRAFT_COMMON_HEADING の節
2956
+ * (試験 craft-common-block が、ここに書いた項がすべて鉄則にもあることを確かめる)。
2957
+ * ★番人の判定は1つも変えない。止まらない書き方を最初から選ばせるだけ。
2958
+ */
2959
+ export const CRAFT_COMMON_ITEMS = [
2960
+ 'リポの元の場所(~/projects/<現場>)を命令に書かない。本文に元の場所が書かれていても、【作業場所】の段があればその場所へ読み替える',
2961
+ 'cd は起動した場所へ戻されることがある(Shell cwd was reset)。以後は絶対パス・git -C <場所>・npm --prefix <場所> で打つ',
2962
+ '$(...) の中に場所を書かない(値が要るときは先にその命令だけを打ち、出た値をそのまま書く)',
2963
+ 'ファイルの中身・一覧を読むのは Read の道具・ls・git ls-files。python3 -c・node -e・cat で読まない',
2964
+ '探すのは場所を名指しした git grep -n -e <語> -- <フォルダかファイル>。パイプ(|)・grep -r・rg・awk は使わない',
2965
+ '背景の調べ役(サブエージェント)は使わない(調べ役の命令も同じ番人に掛かり、1回の danger で便全体が止まる)',
2966
+ 'CI を待つのは gh run watch <実行ID> --exit-status を1回(繰り返しと sleep で待たない)',
2967
+ '番人に danger で止められたら別の道具へ替えず、止められた命令の全文と番人の文を報告に書いて終える',
2968
+ ];
2969
+ export function craftCommonBlock() {
2970
+ return (`【共通の型(配り役が全便に付ける・正本は鉄則の「途中で止まらない書き方」)】` +
2971
+ CRAFT_COMMON_ITEMS.map((s, i) => `${'①②③④⑤⑥⑦⑧⑨'[i]}${s}。`).join('') +
2972
+ `★便の本文の決まりがこれより厳しければ、本文に従う。`);
2973
+ }
2942
2974
  /** 鉄則(conductor-craftsman の SKILL.md)の中の、便の終え方の見出し。1行の案内はここを指す。 */
2943
2975
  export const CRAFTSMAN_FINISH_HEADING = '## 便の終え方';
2944
2976
  /**
@@ -5203,7 +5235,9 @@ export async function fetchCommand(cfg) {
5203
5235
  * 呼び出し側は追跡を畳んでよい。false(=次の周でやり直す)に倒すと、画面なし方式が
5204
5236
  * 上限回数のあとに `failed` を書いてしまい、待ちの便を殺す。
5205
5237
  */
5206
- export async function patchStatus(cfg, id, status, report) {
5238
+ export async function patchStatus(cfg, id,
5239
+ // ★'queued' は利用上限で便を「待ち」に戻すときだけ使う(便 27a9fb19・管制は PATCH で受ける値)。
5240
+ status, report) {
5207
5241
  if (status === 'done') {
5208
5242
  const held = await fetchCommandStatus(cfg, id);
5209
5243
  if (isWaitClosedCommandStatus(held)) {
@@ -0,0 +1,292 @@
1
+ /**
2
+ * Claude の利用上限(週・5時間など)に当たったときの「待ち」(便 27a9fb19・えふさん決定 2026-11-04)。
3
+ *
4
+ * 【なぜ要るか(実地 2026-11-03 22:33 JST〜)】
5
+ * PC の Claude の週の上限に当たると、職人(claude -p)は起動して約1秒で終了コード1で終わる。
6
+ * 配り役はこれを「異常終了」と数えて3回やり直し、3回とも同じ理由で落ちて failed にしていた。
7
+ * その夜、配られた便が10件、中身なしで failed になり、全部を人が出し直した。
8
+ * ★便の中身の問題ではなく、配り方の問題(上限が戻るまで待てばよい)。
9
+ *
10
+ * 【実物の形(便 39be3b73 の attempt-2.jsonl・2026-11-03 実測)】
11
+ * {"type":"rate_limit_event","rate_limit_info":{"status":"rejected","resetsAt":1793757600,
12
+ * "rateLimitType":"seven_day",...}}
13
+ * {"type":"assistant","error":"rate_limit","message":{"content":[{"type":"text",
14
+ * "text":"You've hit your weekly limit · resets 11am (Asia/Tokyo)"}]},...}
15
+ * {"type":"result","is_error":true,"api_error_status":429,"result":"You've hit your weekly limit · ..."}
16
+ * ★上限が戻る時刻は rate_limit_event の resetsAt(秒)で機械で読める。文を読み解く必要は無い。
17
+ *
18
+ * 【決め】
19
+ * ・上限の印が出て、報告を出せずに終わった便は、failed にせず管制で「待ち(queued)」に戻す。
20
+ * ・この PC の配達を止める札(このファイルの holdFilePath)を置く。★現場ごとの配り役は別の処理なので、
21
+ * PC で1つのファイルにする(入れ替え待ちの札=drain と同じ考え方)。
22
+ * ・戻る時刻が読めればその時刻+少しの余裕まで、読めなければ USAGE_LIMIT_DEFAULT_WAIT_MS 待つ。
23
+ * 時刻を過ぎた札は、次に見た配り役が外して配達を再開する。
24
+ * ・人がアカウントを切り替えたら `conductor resume-delivery` で札を外せば、その場で再開する。
25
+ * ・管制へ知らせるのは札を新しく置いた1回だけ(同じ待ちの間は2回目を送らない)。
26
+ * ・★上限以外の理由で早く終わった便は今までどおり(再開・上限3回・failed)。
27
+ */
28
+ import { mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
29
+ import os from 'node:os';
30
+ import path from 'node:path';
31
+ /** 戻る時刻が読めないときに待つ長さ。 */
32
+ export const USAGE_LIMIT_DEFAULT_WAIT_MS = 30 * 60_000;
33
+ /** 戻る時刻に足す余裕(時刻ちょうどに配ると、まだ戻っていないことがある)。 */
34
+ export const USAGE_LIMIT_MARGIN_MS = 60_000;
35
+ /** 戻る時刻として信じる上限(これより先の値は読み違いとみなし、既定の待ちにする)。 */
36
+ export const USAGE_LIMIT_MAX_WAIT_MS = 8 * 24 * 60 * 60_000;
37
+ /**
38
+ * 上限に当たったと分かる文(★resetsAt が読めない形のための保険)。
39
+ * 実物: "You've hit your weekly limit · resets 11am (Asia/Tokyo)"
40
+ */
41
+ export const USAGE_LIMIT_TEXT_RE = /\b(?:you['’]ve|you have)\s+(?:hit|reached)\s+your\s+(?:[\w-]+\s+)?(?:usage\s+)?limit\b|\busage limit reached\b/i;
42
+ function firstText(content) {
43
+ if (!Array.isArray(content))
44
+ return null;
45
+ for (const b of content) {
46
+ if (b !== null && typeof b === 'object' && b.type === 'text') {
47
+ const t = String(b.text ?? '').trim();
48
+ if (t)
49
+ return t;
50
+ }
51
+ }
52
+ return null;
53
+ }
54
+ /**
55
+ * stream-json の1行から「上限に当たった」印を読む(★純粋関数)。無ければ null。
56
+ * ★`allowed`・`allowed_warning` の知らせ(まだ使える)は拾わない。拾うのは `rejected` だけ。
57
+ * ★一時的な混雑(429 の rate_limit_error)は Claude Code が自分でやり直すので、上限の文が無い限り拾わない。
58
+ */
59
+ export function detectUsageLimit(parsed) {
60
+ if (parsed.type === 'rate_limit_event') {
61
+ const info = parsed.rate_limit_info;
62
+ if (!info || info.status !== 'rejected')
63
+ return null;
64
+ const sec = Number(info.resetsAt);
65
+ return {
66
+ limitType: typeof info.rateLimitType === 'string' ? info.rateLimitType : null,
67
+ resetsAtMs: Number.isFinite(sec) && sec > 0 ? sec * 1000 : null,
68
+ text: null,
69
+ };
70
+ }
71
+ if (parsed.type === 'assistant') {
72
+ const msg = parsed.message;
73
+ const text = firstText(msg?.content);
74
+ if (text !== null && USAGE_LIMIT_TEXT_RE.test(text)) {
75
+ return { limitType: null, resetsAtMs: null, text };
76
+ }
77
+ return null;
78
+ }
79
+ if (parsed.type === 'result' && parsed.is_error === true) {
80
+ const text = String(parsed.result ?? '').trim();
81
+ if (USAGE_LIMIT_TEXT_RE.test(text))
82
+ return { limitType: null, resetsAtMs: null, text };
83
+ }
84
+ return null;
85
+ }
86
+ /** 読めた物を重ねる(★後から読めた値で、先に読めた値を消さない)。 */
87
+ export function mergeUsageLimit(prev, next) {
88
+ if (prev === null)
89
+ return { ...next };
90
+ return {
91
+ limitType: next.limitType ?? prev.limitType,
92
+ resetsAtMs: next.resetsAtMs ?? prev.resetsAtMs,
93
+ text: next.text ?? prev.text,
94
+ };
95
+ }
96
+ /** 上限が戻る時刻を信じてよいか(★純粋関数)。過ぎた時刻・遠すぎる時刻は信じない。 */
97
+ export function usableResetsAt(hit, now) {
98
+ const r = hit.resetsAtMs;
99
+ return r !== null && r > now && r - now <= USAGE_LIMIT_MAX_WAIT_MS;
100
+ }
101
+ /** 配達を再開する時刻(ms)を決める(★純粋関数)。 */
102
+ export function usageResumeAtMs(hit, now) {
103
+ if (hit.limitType === AUTH_HOLD_TYPE)
104
+ return now + AUTH_HOLD_WAIT_MS;
105
+ if (usableResetsAt(hit, now))
106
+ return hit.resetsAtMs + USAGE_LIMIT_MARGIN_MS;
107
+ return now + USAGE_LIMIT_DEFAULT_WAIT_MS;
108
+ }
109
+ /**
110
+ * ログイン切れの札の種類(便 6d0b403f)。
111
+ *
112
+ * 【なぜ要るか(実地)】2026-10-28 09:05〜09:12 JST、FshimaNP の Claude のログインが切れていて、
113
+ * 配られた便が3件(39c1a84e・6ec694a3・d9a849ca)続けて起動後約7秒で auth_error の failed になった。
114
+ * 2026-11-02 の TYHLD-GOTO(3790d74b)も同じ。ログイン切れは便の中身ではなく PC の状態なので、
115
+ * 利用上限と同じく「この便は待ちに戻し、その PC への配達を止める」。
116
+ * 【決め】戻る時刻は分からない(人がログインし直すまで)。AUTH_HOLD_WAIT_MS ごとに1便だけ試し直す
117
+ * (ログインし直していれば、そのまま配達が戻る)。人は `conductor resume-delivery` で今すぐ戻せる。
118
+ * ★待ちに戻した便は、新しい会話で起こし直す(ログイン切れの回の会話は残っていないことがあるため)。
119
+ */
120
+ export const AUTH_HOLD_TYPE = 'auth';
121
+ /** ログイン切れのとき、試し直すまで待つ長さ。 */
122
+ export const AUTH_HOLD_WAIT_MS = 60 * 60_000;
123
+ /** ログイン切れを「待ちの札」の形にする(★純粋関数)。戻る時刻は読めないので null。 */
124
+ export function authHoldHit(text = null) {
125
+ return { limitType: AUTH_HOLD_TYPE, resetsAtMs: null, text };
126
+ }
127
+ /** 上限の種類の日本語。 */
128
+ export function usageLimitLabel(limitType) {
129
+ switch (limitType) {
130
+ case AUTH_HOLD_TYPE:
131
+ return 'ログイン切れ';
132
+ case 'seven_day':
133
+ case 'seven_day_opus':
134
+ case 'seven_day_sonnet':
135
+ return '週の上限';
136
+ case 'five_hour':
137
+ return '5時間の上限';
138
+ default:
139
+ return '利用上限';
140
+ }
141
+ }
142
+ /** 日本時間の「11/04 11:01」の形。 */
143
+ export function formatJst(ms) {
144
+ const parts = new Intl.DateTimeFormat('ja-JP', {
145
+ timeZone: 'Asia/Tokyo', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hour12: false,
146
+ }).formatToParts(new Date(ms));
147
+ const get = (t) => parts.find((p) => p.type === t)?.value ?? '';
148
+ return `${get('month')}/${get('day')} ${get('hour')}:${get('minute')}`;
149
+ }
150
+ export function stateDir() {
151
+ return path.join(os.homedir(), '.local', 'state', 'conductor');
152
+ }
153
+ /** 札の場所(PC で1つ)。 */
154
+ export function holdFilePath() {
155
+ return process.env.CONDUCTOR_USAGE_HOLD_FILE || path.join(stateDir(), 'usage-limit-hold.json');
156
+ }
157
+ /**
158
+ * 札を読む。★読めない・壊れているときは、置かれた時刻から既定の待ちの間だけ「在る」と扱う
159
+ * (迷ったら配らない側。ただし永久には止めない)。
160
+ */
161
+ export function readUsageHold(now = Date.now(), file = holdFilePath()) {
162
+ let mtime;
163
+ try {
164
+ mtime = statSync(file).mtimeMs;
165
+ }
166
+ catch {
167
+ return { state: 'none' };
168
+ }
169
+ let hold;
170
+ try {
171
+ const v = JSON.parse(readFileSync(file, 'utf8'));
172
+ if (typeof v.resumeAtMs !== 'number' || !Number.isFinite(v.resumeAtMs))
173
+ throw new Error('bad');
174
+ hold = {
175
+ resumeAtMs: v.resumeAtMs,
176
+ since: typeof v.since === 'number' ? v.since : mtime,
177
+ limitType: typeof v.limitType === 'string' ? v.limitType : null,
178
+ site: typeof v.site === 'string' ? v.site : '',
179
+ commandId: typeof v.commandId === 'string' ? v.commandId : '',
180
+ resetsKnown: v.resetsKnown === true,
181
+ };
182
+ }
183
+ catch {
184
+ hold = brokenHold(mtime);
185
+ }
186
+ return hold.resumeAtMs > now ? { state: 'active', hold } : { state: 'expired', hold };
187
+ }
188
+ function brokenHold(since) {
189
+ return {
190
+ resumeAtMs: since + USAGE_LIMIT_DEFAULT_WAIT_MS,
191
+ since,
192
+ limitType: null,
193
+ site: '',
194
+ commandId: '',
195
+ resetsKnown: false,
196
+ };
197
+ }
198
+ function writeHold(hold, file) {
199
+ mkdirSync(path.dirname(file), { recursive: true });
200
+ const tmp = `${file}.${process.pid}.tmp`;
201
+ writeFileSync(tmp, JSON.stringify(hold) + '\n');
202
+ renameSync(tmp, file);
203
+ }
204
+ /**
205
+ * 札を置く。返りの created が true のときだけ、呼び出し側は管制へ知らせる(★1回だけ)。
206
+ * ★既に待っている間に別の現場の便が当たったときは、遅い方の時刻へ伸ばすだけ(知らせない)。
207
+ */
208
+ export function placeUsageHold(hit, ctx, now = Date.now(), file = holdFilePath()) {
209
+ const resumeAtMs = usageResumeAtMs(hit, now);
210
+ const resetsKnown = usableResetsAt(hit, now);
211
+ const cur = readUsageHold(now, file);
212
+ if (cur.state === 'active') {
213
+ if (cur.hold.resumeAtMs >= resumeAtMs)
214
+ return { created: false, hold: cur.hold };
215
+ const longer = { ...cur.hold, resumeAtMs, resetsKnown, limitType: hit.limitType ?? cur.hold.limitType };
216
+ try {
217
+ writeHold(longer, file);
218
+ }
219
+ catch { /* 書けなくても今の札で止まっている */ }
220
+ return { created: false, hold: longer };
221
+ }
222
+ const hold = {
223
+ resumeAtMs, since: now, limitType: hit.limitType, site: ctx.site, commandId: ctx.commandId, resetsKnown,
224
+ };
225
+ writeHold(hold, file);
226
+ return { created: true, hold };
227
+ }
228
+ /** 札を外す。返り true=外した(在った)。 */
229
+ export function clearUsageHold(file = holdFilePath()) {
230
+ try {
231
+ unlinkSync(file);
232
+ return true;
233
+ }
234
+ catch {
235
+ return false;
236
+ }
237
+ }
238
+ /** 管制へ1回だけ送る知らせの文。 */
239
+ export function usageHoldNotice(hold, machine) {
240
+ const when = formatJst(hold.resumeAtMs);
241
+ if (hold.limitType === AUTH_HOLD_TYPE) {
242
+ return (`PC「${machine}」の Claude のログインが切れています。この PC への配達を止め、この便は失敗にせず待ちに戻しました。` +
243
+ `その PC で claude にログインし直してから \`conductor resume-delivery\` を打つと今すぐ再開します` +
244
+ `(打たなくても ${when}(日本時間)に1便だけ試し直します)。`);
245
+ }
246
+ const how = hold.resetsKnown ? `上限が戻る時刻に合わせて ${when}(日本時間)に` : `戻る時刻が読めないので ${when}(日本時間)に`;
247
+ return (`Claude の${usageLimitLabel(hold.limitType)}に当たりました。PC「${machine}」への配達を止め、この便は失敗にせず待ちに戻しました。` +
248
+ `${how}自動で配達を再開します。アカウントを切り替えたときは、その PC で \`conductor resume-delivery\` を打つと今すぐ再開します。`);
249
+ }
250
+ export function limitResumePath(site) {
251
+ const safe = String(site ?? '').replace(/[^A-Za-z0-9_.-]/g, '_');
252
+ return path.join(stateDir(), `usage-limit-resume-${safe}.json`);
253
+ }
254
+ function readResumeList(site) {
255
+ try {
256
+ const v = JSON.parse(readFileSync(limitResumePath(site), 'utf8'));
257
+ if (!Array.isArray(v))
258
+ return [];
259
+ return v.filter((r) => r !== null && typeof r === 'object'
260
+ && typeof r.commandId === 'string'
261
+ && typeof r.sessionId === 'string'
262
+ && typeof r.attempt === 'number');
263
+ }
264
+ catch {
265
+ return [];
266
+ }
267
+ }
268
+ /** 控えを残す(★同じ便は1件だけ・20件まで)。中継が立ち上げ直しても続きから起こせるようにファイルに置く。 */
269
+ export function saveLimitResume(site, rec) {
270
+ const kept = readResumeList(site).filter((r) => r.commandId !== rec.commandId);
271
+ kept.push({
272
+ commandId: rec.commandId, sessionId: rec.sessionId, attempt: rec.attempt,
273
+ ...(rec.fresh === true ? { fresh: true } : {}),
274
+ });
275
+ try {
276
+ mkdirSync(stateDir(), { recursive: true });
277
+ writeFileSync(limitResumePath(site), JSON.stringify(kept.slice(-20)) + '\n');
278
+ }
279
+ catch { /* 残せなくても便は待ちに戻っている(次は今までどおりの起こし方になる) */ }
280
+ }
281
+ /** 控えを取り出して消す。無ければ null。 */
282
+ export function takeLimitResume(site, commandId) {
283
+ const list = readResumeList(site);
284
+ const hit = list.find((r) => r.commandId === commandId) ?? null;
285
+ if (hit === null)
286
+ return null;
287
+ try {
288
+ writeFileSync(limitResumePath(site), JSON.stringify(list.filter((r) => r.commandId !== commandId)) + '\n');
289
+ }
290
+ catch { /* 消せなくても二重に使うだけ(続きから起こすのは同じ会話) */ }
291
+ return hit;
292
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@tyhld/conductor",
3
- "version": "0.12.172",
3
+ "version": "0.12.174",
4
4
  "description": "采配くん管制の見守りアプリ(conductor-agent)。各PCで常駐し、中央(devlog-tracker)へ定期的に生存報告(heartbeat)を送る常駐CLI。",
5
5
  "type": "module",
6
6
  "bin": {
@@ -18,7 +18,14 @@ description: 采配くんの便(プロンプト末尾に CONDUCTOR_JOB:<id>
18
18
 
19
19
  1. **着手時の確認と枝分かれ** — `git status && git log --oneline -3 && git stash list` を確認してから main を最新化し、新ブランチを切る。
20
20
  - ★**枝は最新の `origin/main` から切る(手元の `main` から切らない・えふさん決定 2026-10-26)。** `git fetch origin` を1回打ち、`git switch -c <作業ブランチ名> --no-track origin/main`(鉄則7-⓪の形)。手元の `main` は古いまま置かれていることがある(実地 便 613837fd:275件遅れ)ので、そこから切ると古い土台の上で作業することになる。
21
- - ★**手元の作業場所で枝を切り替えられないとき**(はじめから在る変更が切り替えとぶつかる等)は、`git worktree add -b <作業ブランチ名> --no-track /tmp/claude-1000/<便IDを入れた名前> origin/main` で**別の作業場所**を作り、以後はそこで作業する(cd はその作業場所へ1回だけ=鉄則2)。終わったら `git worktree remove /tmp/claude-1000/<便IDを入れた名前>` で片付ける。★はじめから在る変更を退避(stash)・強制(`-f`・`--force`)・上書きして切り替えない(実地 便 934fca62 → dd5fe11a)。★これは便の作業場所の話で、空振り確認には worktree を使わない(鉄則13)。
21
+ - ★**便ごとの作業場所で起きたとき(えふさん決定 2026-11-04・便 27a9fb19)。** 画面なし方式の配り役は、便を渡す前に現場のリポから `git worktree` で `/tmp/claude-1000/conductor-job-<現場>-<便ID>` を作り(最新の origin の既定の枝・枝は未作成)、**職人をそこで起こす**。便の本文に `【作業場所】…` の段が付いていればこの形。
22
+ - **cd は不要**(もう作業場所に居る)。**リポの元の場所(`~/projects/<現場>`)では命令を動かさない**(記録されない秘密のファイルが在るので、そこで python3 などを動かすと番人が正しく止める=実地 便 e0796fcd)。
23
+ - 枝は `git switch -c <作業ブランチ名> --no-track origin/main` で切る。**新しい worktree は作らない**(下の「切り替えられないとき」の形は要らない)。
24
+ - 部品(`node_modules` 等)は作業場所に無いので、「手元で流す検査」⑤の命令で入れる(置き場は `/tmp/claude-1000` の下)。
25
+ - 守りの設定(`.claude/settings.local.json` など)は配り役が作業場所へ写してある=**触らない・記録に入れない**(`git status` に `?? .claude/` と出ても、はじめから在る物として扱う)。
26
+ - 便が終わると配り役が作業場所を片付ける。**記録していない変更・送っていない記録が残っていれば消さずに残す**ので、終える前に push まで済ませる(鉄則7)。
27
+ - ★便の本文に `【作業場所】` の段が無い便(tmux 方式・リポでない現場・この PC で切っている等)は、今までどおりこの項の残りのとおり。
28
+ - ★**手元の作業場所で枝を切り替えられないとき**(はじめから在る変更が切り替えとぶつかる等)は、`git worktree add -b <作業ブランチ名> --no-track /tmp/claude-1000/<便IDを入れた名前> origin/main` で**別の作業場所**を作り、以後はそこで作業する(cd はその作業場所へ1回だけ=鉄則2)。★cd は起動した場所へ戻されることがある(`Shell cwd was reset`=実地 便 e0796fcd)ので、以後の命令は絶対パス・`git -C <作業場所>`・`npm --prefix <作業場所>` で場所を名指しして打つ(「途中で止まらない書き方」の (2))。終わったら `git worktree remove /tmp/claude-1000/<便IDを入れた名前>` で片付ける。★はじめから在る変更を退避(stash)・強制(`-f`・`--force`)・上書きして切り替えない(実地 便 934fca62 → dd5fe11a)。★これは便の作業場所の話で、空振り確認には worktree を使わない(鉄則13)。
22
29
  - ★**リポ全体の差分が「読めないファイル」で落ちたとき**(`unsupported file type` / `cannot hash <名前>` が出る/`.npmrc` のような設定が身に覚えなく `M` で出る)。**これは壊れていない。**
23
30
  秘密に分類されたファイルは職人から中身を隠してあるので、git がそのファイルを数えられないだけ。**中身を見に行く方へ回らない。**
24
31
  - ① そのファイルを**触らない・開かない・`git diff` の対象にしない**。「読めるようにする」方向へ回避しない(鉄則4)。
@@ -26,7 +33,7 @@ description: 采配くんの便(プロンプト末尾に CONDUCTOR_JOB:<id>
26
33
  - ③ `M` と出ていても、**自分が触っていなければ触っていない**。★職人には本当に変わったかを確かめられない。`git status --porcelain -- <そのファイル>` の**表示だけ**を報告に書き、**中身は1文字も書かない**。
27
34
  - ④ **コミットに含めない**(`git add` は対象を名指しする=`git add -A` を使わない)。★`git commit -a`・`-am`・`--all` も同じ「まとめて全部を入れる」形なので使わない(番人が止める)。**ファイルを名指しで `git add` してから `git commit -m …`**(便 4cf71dde:着手前から `M` だった `.claude/settings.json` が、空振り確認の `git commit -a` で手元の記録に入った)。
28
35
  - ⑤ それで進めないときだけ、回避せず**人の手番として報告して止まる**。
29
- 2. **cd は1回だけ** — cd は作業開始時に1回だけ実行する。以後 cd を `&&` で他コマンドと連結しない・リダイレクトと混ぜない。
36
+ 2. **cd は1回だけ** — cd は作業開始時に1回だけ実行する。以後 cd を `&&` で他コマンドと連結しない・リダイレクトと混ぜない。★cd が起動した場所へ戻されたとき(`Shell cwd was reset`)は打ち直さず、以後は絶対パス・`git -C <場所>` で打つ(「途中で止まらない書き方」の (2))。
30
37
  3. **持ち場の外に出ない** — 指示された作業ディレクトリの外を変更しない。
31
38
  4. **壁に当たったら止まる** — サンドボックス制約・保護されたパスに当たったら回避せず中断して報告する(★通信で塞がれたときの読み方は鉄則12)。
32
39
  5. **エージェント設定に書き込まない** — `.mcp.json`、`.claude/` 配下、hooks 等のエージェント設定パスには書き込まない。
@@ -287,6 +294,30 @@ description: 采配くんの便(プロンプト末尾に CONDUCTOR_JOB:<id>
287
294
  - ★**止まるのは「行き先が分からない形」と「保護ブランチを狙う形」**(実測 便 6e8d85e6)。場所を指す旗を付けても枝を名指しした形(`git -C <場所> push origin <作業ブランチ名>`)は止まらないので、「場所を指す旗が付いているか」で安全を判断しない。
288
295
  - ★**強い上書き(`--force`/`-f`/`--force-with-lease`/先頭が `+` の参照指定)は、旗の位置を問わず止まる。** 旗を末尾や中間に置く形・短い旗をまとめた形(`-fu`)・`git` と `push` の間に場所や設定を指す旗を挟む形・`+` を引用符で囲う形・つないだ行や包みの中に書いた形も、すべて止まる(便 e619bd86 で語の並びを見る判定に替えた。それまでは挟む形と引用符で囲う形が素通りしていた=実地 便 6e8d85e6)。**そもそも強い上書きは打たない**(便の本文の「force-push と reset はしない」)。
289
296
 
297
+ ## 途中で止まらない書き方(全便の共通の型)
298
+
299
+ どのチャットが出した便にも、配り役が本文の後ろに `【共通の型(配り役が全便に付ける…)】` の段を付ける(えふさん決定 2026-11-04・便 6d0b403f)。その段の各項の正本がこの節。★各チャットの便の本文に同じことが書かれていなくても、この節のとおりにする。★本文の決まりがこれより厳しければ本文に従う。★番人の判定は1つも変えていない(止まらない書き方を最初から選ぶための節で、止められた後に回避する根拠にはしない=上の節の①〜⑦がそのまま掛かる)。
300
+
301
+ 直近30日(2026-10-05〜11-04)に途中で止まった便を、どのチャットの便かを問わず集めて、職人の側で防げる形だけをここに寄せた。
302
+
303
+ - (1) **リポの元の場所(~/projects/<現場>)を命令に書かない。本文に元の場所が書かれていても、`【作業場所】`の段があればその場所へ読み替える。**
304
+ - 止まった例(便 e879cf84): 背景の調べ役が `cd /home/…/projects/mebukia && grep …` を `$(...)` の中で動かし、`danger: secret file (.npmrc) inside …/mebukia read without naming it by grep` で便全体が止まった。元の場所には記録されない秘密のファイルが在るので、番人が正しく止める。
305
+ - 代わりに: `【作業場所】` の場所(無ければ自分で作った作業場所)を絶対パスで名指しする。
306
+ - (2) **cd は起動した場所へ戻されることがある(`Shell cwd was reset`)。以後は絶対パス・`git -C <場所>`・`npm --prefix <場所>` で打つ。**
307
+ - 止まった例(便 e0796fcd): 職人は鉄則1のとおり `/tmp/claude-1000/wt-…` を作って cd したが、Claude Code がシェルの今いる場所を起動した場所(リポの元の場所)へ戻したので、素の `python3` が元の場所で動き `danger: secret file (.npmrc) inside …/TYHLD-platform copied inside python3` で止まった(便 27a9fb19 の重大発見1)。
308
+ - 代わりに: 自分で作った作業場所では、`cd` が効いたと思わずに、命令ごとに場所を名指しする(`git -C /tmp/claude-1000/<名前> status`・`npm --prefix /tmp/claude-1000/<名前> ci …`・`node --test /tmp/claude-1000/<名前>/test/<変えた所>.test.ts`)。配り役が作業場所で起こした便(`【作業場所】` の段がある便)は、戻る先が作業場所なのでこの心配は無い。
309
+ - (3) **`$(...)` の中に場所を書かない(値が要るときは先にその命令だけを打ち、出た値をそのまま書く)。** 番人は `$(...)` の中を読み切れないと、作業場所(リポの根)を探したものとして測る(番人の文に `(書かれた場所を読み切れないので作業場所として判定)(inside command substitution)` と出る)。
310
+ - 代わりに: 値が要るときは、先にその命令だけを1回打ち、出た値をそのまま次の命令に書く。
311
+ - (4) **ファイルの中身・一覧を読むのは Read の道具・`ls`・`git ls-files`。`python3 -c`・`node -e`・`cat` で読まない。** 小さな台本は読む場所を番人に確かめさせない形になり、元の場所や秘密のファイルに触れると `danger` で止まる。
312
+ - (5) **探すのは場所を名指しした `git grep -n -e <語> -- <フォルダかファイル>`。パイプ(`|`)・`grep -r`・`rg`・`awk` は使わない。**
313
+ - 止まった例(便 62475b9e・e0796fcd): 便の本文が禁じたパイプ・grep を使い、`discipline` で打ち直しになった(便の本文の違反として報告に残った)。
314
+ - 代わりに: リポの中は `git grep -n -e 語 -- src docs`、リポの外(試験の出力・CI の記録)は Read の道具。
315
+ - (6) **背景の調べ役(サブエージェント)は使わない(調べ役の命令も同じ番人に掛かり、1回の danger で便全体が止まる)。** 調べ役が1回 `danger` に当たると、その便の残りがすべて止まる(便 e879cf84・上の節の「`danger` で止められた後」)。調べ役は鉄則も便の本文の決まりも読まずに動く。
316
+ - (7) **CI を待つのは `gh run watch <実行ID> --exit-status` を1回(繰り返しと sleep で待たない)。** 待ちの形は上の節のとおり。
317
+ - (8) **番人に `danger` で止められたら別の道具へ替えず、止められた命令の全文と番人の文を報告に書いて終える**(鉄則4・上の節の⑤-2)。
318
+
319
+ ★**職人の側では防げない止まり方は、配り役が受け持つ**(職人は何もしなくてよい): Claude の利用上限(便 27a9fb19)とログイン切れ(便 6d0b403f)に当たった便は、失敗にせず待ちに戻し、その PC への配達を止める。便ごとの作業場所で起こす(便 27a9fb19)。
320
+
290
321
  ## 便の終え方
291
322
 
292
323
  便の最後には、配達役が付けた1行「【便の終え方】…報告の置き場: ~/最終行: DONE:<現場> とだけ出力/完了の知らせ: conductor_complete を commandId="<指示ID>" で1回だけ」と、管理用ジョブ印 `CONDUCTOR_JOB:<指示ID>` がある。作業がすべて終わったら、この節のとおりに次の順で終える(便 a5306df2:以前は便ごとに付いていた全文を、ここへ寄せた)。