@tyhld/conductor 0.12.172 → 0.12.173
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 +21 -1
- package/dist/headless.js +160 -10
- package/dist/job-workdir.js +245 -0
- package/dist/relay.js +3 -1
- package/dist/usage-limit.js +262 -0
- package/package.json +1 -1
- package/skills/conductor-craftsman/SKILL.md +7 -0
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
|
-
|
|
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 { 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
|
-
|
|
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:
|
|
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
|
|
@@ -1707,6 +1801,7 @@ async function checkRunningJob(cfg, state) {
|
|
|
1707
1801
|
await patchStatus(cfg, job.commandId, 'failed', authMsg);
|
|
1708
1802
|
rs.abandoned.add(job.commandId);
|
|
1709
1803
|
noteLastJob('auth_error', authMsg);
|
|
1804
|
+
await finishJobWorkDir(cfg, job);
|
|
1710
1805
|
state.job = null;
|
|
1711
1806
|
rs.lastHeartbeatAt = null;
|
|
1712
1807
|
log(`WARN site=${cfg.site} id=${job.commandId} 認証エラー → 再試行しない`);
|
|
@@ -1727,6 +1822,7 @@ async function checkRunningJob(cfg, state) {
|
|
|
1727
1822
|
state.doneWriteTries?.delete(job.commandId);
|
|
1728
1823
|
log(`site=${cfg.site} id=${job.commandId} 畳みます(exit=0, attempt ${job.attempt}・${settle.detail})`);
|
|
1729
1824
|
noteLastJob('done', settle.detail);
|
|
1825
|
+
await finishJobWorkDir(cfg, job);
|
|
1730
1826
|
state.job = null;
|
|
1731
1827
|
rs.lastHeartbeatAt = null;
|
|
1732
1828
|
return;
|
|
@@ -1753,6 +1849,7 @@ async function checkRunningJob(cfg, state) {
|
|
|
1753
1849
|
rs.abandoned.add(job.commandId);
|
|
1754
1850
|
state.doneWriteTries.delete(job.commandId);
|
|
1755
1851
|
noteLastJob('failed', reason);
|
|
1852
|
+
await finishJobWorkDir(cfg, job);
|
|
1756
1853
|
state.job = null;
|
|
1757
1854
|
rs.lastHeartbeatAt = null;
|
|
1758
1855
|
log(`ERROR site=${cfg.site} id=${job.commandId} ${reason}`);
|
|
@@ -1773,7 +1870,8 @@ async function checkRunningJob(cfg, state) {
|
|
|
1773
1870
|
attempt: job.attempt,
|
|
1774
1871
|
}]);
|
|
1775
1872
|
const nextAttempt = (state.attempts.get(job.commandId) ?? job.attempt) + 1;
|
|
1776
|
-
|
|
1873
|
+
// ★利用上限で待ちに戻した分は、やり直しの回数に数えない(便 27a9fb19)。
|
|
1874
|
+
if (countedAttempt(state, job.commandId, nextAttempt) > HEADLESS_MAX_ATTEMPTS) {
|
|
1777
1875
|
log(`WARN site=${cfg.site} id=${job.commandId} 試行回数上限(${HEADLESS_MAX_ATTEMPTS}) → 放棄`);
|
|
1778
1876
|
// ★中央へ failed を返す(次の便が止まらないように)
|
|
1779
1877
|
const failReason = maskSecrets(`${HEADLESS_MAX_ATTEMPTS}回すべて異常終了 (最後: exit=${job.exitCode}, signal=${job.exitSignal})` +
|
|
@@ -1787,6 +1885,7 @@ async function checkRunningJob(cfg, state) {
|
|
|
1787
1885
|
}]);
|
|
1788
1886
|
rs.abandoned.add(job.commandId);
|
|
1789
1887
|
noteLastJob('failed', failReason);
|
|
1888
|
+
await finishJobWorkDir(cfg, job);
|
|
1790
1889
|
}
|
|
1791
1890
|
else {
|
|
1792
1891
|
// ★ pendingRetry に詰めて、次の tick で実際に spawn する(fetchCommand は sent を返さない)
|
|
@@ -2425,6 +2524,33 @@ export async function recoverStuckCommands(cfg, opts = {}) {
|
|
|
2425
2524
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
2426
2525
|
// headless tick(relayTick の headless 版)
|
|
2427
2526
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
2527
|
+
/**
|
|
2528
|
+
* Claude の利用上限の札を見る(便 27a9fb19)。返り true=配ってよい。
|
|
2529
|
+
* ★札は PC で1つ(現場ごとの配り役が同じファイルを見る)。時刻を過ぎた札は外す。
|
|
2530
|
+
* ★置かれた/外れたの変わり目だけ1行出す(毎周は出さない)。
|
|
2531
|
+
*/
|
|
2532
|
+
export function noteUsageHold(state, site, now = Date.now()) {
|
|
2533
|
+
const h = readUsageHold(now);
|
|
2534
|
+
if (h.state === 'active') {
|
|
2535
|
+
if (state.lastUsageHold !== true) {
|
|
2536
|
+
log(`site=${site} Claude の${usageLimitLabel(h.hold.limitType)}の札があるため、この PC へ便を配りません` +
|
|
2537
|
+
`(再開予定 ${formatJst(h.hold.resumeAtMs)} 日本時間・走っている便は止めません・積まれた便は管制で待ちます。` +
|
|
2538
|
+
'今すぐ再開するには `conductor resume-delivery`)');
|
|
2539
|
+
}
|
|
2540
|
+
state.lastUsageHold = true;
|
|
2541
|
+
noteReadiness(state.relay, 'halted', null, now);
|
|
2542
|
+
return false;
|
|
2543
|
+
}
|
|
2544
|
+
if (h.state === 'expired') {
|
|
2545
|
+
clearUsageHold();
|
|
2546
|
+
log(`site=${site} Claude の${usageLimitLabel(h.hold.limitType)}の待ちの時刻を過ぎたので、札を外して配達を再開します`);
|
|
2547
|
+
}
|
|
2548
|
+
else if (state.lastUsageHold === true) {
|
|
2549
|
+
log(`site=${site} Claude の利用上限の札が外れました。配達を再開します`);
|
|
2550
|
+
}
|
|
2551
|
+
state.lastUsageHold = false;
|
|
2552
|
+
return true;
|
|
2553
|
+
}
|
|
2428
2554
|
/**
|
|
2429
2555
|
* headless 方式の1tick。relayTick の代わりに createRelayRunner へ渡す。
|
|
2430
2556
|
*
|
|
@@ -2498,6 +2624,18 @@ export async function headlessTick(cfg, state, hooks) {
|
|
|
2498
2624
|
trackedIds: [...headlessTrackedCommandIds(state), ...resumeGuard],
|
|
2499
2625
|
state,
|
|
2500
2626
|
});
|
|
2627
|
+
// ── 利用上限で待ちに戻す書き込みの書き直し(便 27a9fb19)──
|
|
2628
|
+
// ★停止トグルの確認より後に置く=止められている現場では外へ出ない。
|
|
2629
|
+
for (const id of [...(state.requeuePending ?? [])]) {
|
|
2630
|
+
if (await patchStatus(cfg, id, 'queued'))
|
|
2631
|
+
state.requeuePending?.delete(id);
|
|
2632
|
+
}
|
|
2633
|
+
// ── Claude の利用上限の札(便 27a9fb19)──
|
|
2634
|
+
// 札が在るあいだは、この PC へ便を配らない(新しい便・自動再開・再開の合図のどれも)。
|
|
2635
|
+
// ★走っている便(state.job)は上で済んでいる=止めない。便は管制で待つだけで、失われない。
|
|
2636
|
+
// 時刻を過ぎた札は外して、この周から配達を再開する。
|
|
2637
|
+
if (!noteUsageHold(state, cfg.site))
|
|
2638
|
+
return;
|
|
2501
2639
|
// ── 異常終了後の自動再開(pendingRetry)──
|
|
2502
2640
|
if (state.pendingRetry !== null) {
|
|
2503
2641
|
const retry = state.pendingRetry;
|
|
@@ -2564,10 +2702,18 @@ export async function headlessTick(cfg, state, hooks) {
|
|
|
2564
2702
|
log(`WARN site=${cfg.site} id=${cmd.id} 配達回数上限(${RELAY_DELIVER_MAX}) → 以後配達しない`);
|
|
2565
2703
|
return;
|
|
2566
2704
|
}
|
|
2705
|
+
// ── 利用上限で待ちに戻した便の続き(便 27a9fb19)──
|
|
2706
|
+
// 上限に当たった回の会話の続きから起こす。★やり直しの回数には数えない(limitCredits)。
|
|
2707
|
+
const limited = takeLimitResume(cfg.site, cmd.id);
|
|
2708
|
+
if (limited !== null) {
|
|
2709
|
+
const credits = state.limitCredits ??= new Map();
|
|
2710
|
+
credits.set(cmd.id, (credits.get(cmd.id) ?? 0) + 1);
|
|
2711
|
+
state.attempts.set(cmd.id, Math.max(state.attempts.get(cmd.id) ?? 0, limited.attempt));
|
|
2712
|
+
}
|
|
2567
2713
|
// ── 試行回数 ──
|
|
2568
2714
|
const attempt = (state.attempts.get(cmd.id) ?? 0) + 1;
|
|
2569
2715
|
state.attempts.set(cmd.id, attempt);
|
|
2570
|
-
if (attempt > HEADLESS_MAX_ATTEMPTS) {
|
|
2716
|
+
if (countedAttempt(state, cmd.id, attempt) > HEADLESS_MAX_ATTEMPTS) {
|
|
2571
2717
|
rs.abandoned.add(cmd.id);
|
|
2572
2718
|
log(`WARN site=${cfg.site} id=${cmd.id} 試行回数上限(${HEADLESS_MAX_ATTEMPTS}) → 放棄`);
|
|
2573
2719
|
return;
|
|
@@ -2575,9 +2721,12 @@ export async function headlessTick(cfg, state, hooks) {
|
|
|
2575
2721
|
// ── claude -p を起動 ──
|
|
2576
2722
|
const isResume = attempt > 1;
|
|
2577
2723
|
// resume: 前回のセッション ID を渡す。fresh start: 新しいセッション ID を作る。
|
|
2578
|
-
|
|
2579
|
-
|
|
2580
|
-
|
|
2724
|
+
// ★利用上限の続きは、上限に当たった回の会話IDそのものを使う(便 27a9fb19)。
|
|
2725
|
+
const sessionId = limited !== null
|
|
2726
|
+
? limited.sessionId
|
|
2727
|
+
: isResume
|
|
2728
|
+
? sessionIdForCommand(cmd.id, attempt - 1)
|
|
2729
|
+
: sessionIdForCommand(cmd.id, attempt);
|
|
2581
2730
|
const job = spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume);
|
|
2582
2731
|
if (job === null) {
|
|
2583
2732
|
// ★起動失敗を管制へ知らせる(「起動しました」とは言わない)
|
|
@@ -2598,6 +2747,7 @@ export async function headlessTick(cfg, state, hooks) {
|
|
|
2598
2747
|
if (job.bodyHandoff === 'failed') {
|
|
2599
2748
|
const why = job.bodyHandoffError ?? '職人の処理へ本文を渡せませんでした';
|
|
2600
2749
|
await stopJob(job);
|
|
2750
|
+
await finishJobWorkDir(cfg, job);
|
|
2601
2751
|
await patchStatus(cfg, cmd.id, 'failed', why.slice(0, EVENT_TEXT_MAX));
|
|
2602
2752
|
await sendCommandEvents(cfg, cmd.id, [{
|
|
2603
2753
|
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
|
@@ -5203,7 +5203,9 @@ export async function fetchCommand(cfg) {
|
|
|
5203
5203
|
* 呼び出し側は追跡を畳んでよい。false(=次の周でやり直す)に倒すと、画面なし方式が
|
|
5204
5204
|
* 上限回数のあとに `failed` を書いてしまい、待ちの便を殺す。
|
|
5205
5205
|
*/
|
|
5206
|
-
export async function patchStatus(cfg, id,
|
|
5206
|
+
export async function patchStatus(cfg, id,
|
|
5207
|
+
// ★'queued' は利用上限で便を「待ち」に戻すときだけ使う(便 27a9fb19・管制は PATCH で受ける値)。
|
|
5208
|
+
status, report) {
|
|
5207
5209
|
if (status === 'done') {
|
|
5208
5210
|
const held = await fetchCommandStatus(cfg, id);
|
|
5209
5211
|
if (isWaitClosedCommandStatus(held)) {
|
|
@@ -0,0 +1,262 @@
|
|
|
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 (usableResetsAt(hit, now))
|
|
104
|
+
return hit.resetsAtMs + USAGE_LIMIT_MARGIN_MS;
|
|
105
|
+
return now + USAGE_LIMIT_DEFAULT_WAIT_MS;
|
|
106
|
+
}
|
|
107
|
+
/** 上限の種類の日本語。 */
|
|
108
|
+
export function usageLimitLabel(limitType) {
|
|
109
|
+
switch (limitType) {
|
|
110
|
+
case 'seven_day':
|
|
111
|
+
case 'seven_day_opus':
|
|
112
|
+
case 'seven_day_sonnet':
|
|
113
|
+
return '週の上限';
|
|
114
|
+
case 'five_hour':
|
|
115
|
+
return '5時間の上限';
|
|
116
|
+
default:
|
|
117
|
+
return '利用上限';
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
/** 日本時間の「11/04 11:01」の形。 */
|
|
121
|
+
export function formatJst(ms) {
|
|
122
|
+
const parts = new Intl.DateTimeFormat('ja-JP', {
|
|
123
|
+
timeZone: 'Asia/Tokyo', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hour12: false,
|
|
124
|
+
}).formatToParts(new Date(ms));
|
|
125
|
+
const get = (t) => parts.find((p) => p.type === t)?.value ?? '';
|
|
126
|
+
return `${get('month')}/${get('day')} ${get('hour')}:${get('minute')}`;
|
|
127
|
+
}
|
|
128
|
+
export function stateDir() {
|
|
129
|
+
return path.join(os.homedir(), '.local', 'state', 'conductor');
|
|
130
|
+
}
|
|
131
|
+
/** 札の場所(PC で1つ)。 */
|
|
132
|
+
export function holdFilePath() {
|
|
133
|
+
return process.env.CONDUCTOR_USAGE_HOLD_FILE || path.join(stateDir(), 'usage-limit-hold.json');
|
|
134
|
+
}
|
|
135
|
+
/**
|
|
136
|
+
* 札を読む。★読めない・壊れているときは、置かれた時刻から既定の待ちの間だけ「在る」と扱う
|
|
137
|
+
* (迷ったら配らない側。ただし永久には止めない)。
|
|
138
|
+
*/
|
|
139
|
+
export function readUsageHold(now = Date.now(), file = holdFilePath()) {
|
|
140
|
+
let mtime;
|
|
141
|
+
try {
|
|
142
|
+
mtime = statSync(file).mtimeMs;
|
|
143
|
+
}
|
|
144
|
+
catch {
|
|
145
|
+
return { state: 'none' };
|
|
146
|
+
}
|
|
147
|
+
let hold;
|
|
148
|
+
try {
|
|
149
|
+
const v = JSON.parse(readFileSync(file, 'utf8'));
|
|
150
|
+
if (typeof v.resumeAtMs !== 'number' || !Number.isFinite(v.resumeAtMs))
|
|
151
|
+
throw new Error('bad');
|
|
152
|
+
hold = {
|
|
153
|
+
resumeAtMs: v.resumeAtMs,
|
|
154
|
+
since: typeof v.since === 'number' ? v.since : mtime,
|
|
155
|
+
limitType: typeof v.limitType === 'string' ? v.limitType : null,
|
|
156
|
+
site: typeof v.site === 'string' ? v.site : '',
|
|
157
|
+
commandId: typeof v.commandId === 'string' ? v.commandId : '',
|
|
158
|
+
resetsKnown: v.resetsKnown === true,
|
|
159
|
+
};
|
|
160
|
+
}
|
|
161
|
+
catch {
|
|
162
|
+
hold = brokenHold(mtime);
|
|
163
|
+
}
|
|
164
|
+
return hold.resumeAtMs > now ? { state: 'active', hold } : { state: 'expired', hold };
|
|
165
|
+
}
|
|
166
|
+
function brokenHold(since) {
|
|
167
|
+
return {
|
|
168
|
+
resumeAtMs: since + USAGE_LIMIT_DEFAULT_WAIT_MS,
|
|
169
|
+
since,
|
|
170
|
+
limitType: null,
|
|
171
|
+
site: '',
|
|
172
|
+
commandId: '',
|
|
173
|
+
resetsKnown: false,
|
|
174
|
+
};
|
|
175
|
+
}
|
|
176
|
+
function writeHold(hold, file) {
|
|
177
|
+
mkdirSync(path.dirname(file), { recursive: true });
|
|
178
|
+
const tmp = `${file}.${process.pid}.tmp`;
|
|
179
|
+
writeFileSync(tmp, JSON.stringify(hold) + '\n');
|
|
180
|
+
renameSync(tmp, file);
|
|
181
|
+
}
|
|
182
|
+
/**
|
|
183
|
+
* 札を置く。返りの created が true のときだけ、呼び出し側は管制へ知らせる(★1回だけ)。
|
|
184
|
+
* ★既に待っている間に別の現場の便が当たったときは、遅い方の時刻へ伸ばすだけ(知らせない)。
|
|
185
|
+
*/
|
|
186
|
+
export function placeUsageHold(hit, ctx, now = Date.now(), file = holdFilePath()) {
|
|
187
|
+
const resumeAtMs = usageResumeAtMs(hit, now);
|
|
188
|
+
const resetsKnown = usableResetsAt(hit, now);
|
|
189
|
+
const cur = readUsageHold(now, file);
|
|
190
|
+
if (cur.state === 'active') {
|
|
191
|
+
if (cur.hold.resumeAtMs >= resumeAtMs)
|
|
192
|
+
return { created: false, hold: cur.hold };
|
|
193
|
+
const longer = { ...cur.hold, resumeAtMs, resetsKnown, limitType: hit.limitType ?? cur.hold.limitType };
|
|
194
|
+
try {
|
|
195
|
+
writeHold(longer, file);
|
|
196
|
+
}
|
|
197
|
+
catch { /* 書けなくても今の札で止まっている */ }
|
|
198
|
+
return { created: false, hold: longer };
|
|
199
|
+
}
|
|
200
|
+
const hold = {
|
|
201
|
+
resumeAtMs, since: now, limitType: hit.limitType, site: ctx.site, commandId: ctx.commandId, resetsKnown,
|
|
202
|
+
};
|
|
203
|
+
writeHold(hold, file);
|
|
204
|
+
return { created: true, hold };
|
|
205
|
+
}
|
|
206
|
+
/** 札を外す。返り true=外した(在った)。 */
|
|
207
|
+
export function clearUsageHold(file = holdFilePath()) {
|
|
208
|
+
try {
|
|
209
|
+
unlinkSync(file);
|
|
210
|
+
return true;
|
|
211
|
+
}
|
|
212
|
+
catch {
|
|
213
|
+
return false;
|
|
214
|
+
}
|
|
215
|
+
}
|
|
216
|
+
/** 管制へ1回だけ送る知らせの文。 */
|
|
217
|
+
export function usageHoldNotice(hold, machine) {
|
|
218
|
+
const when = formatJst(hold.resumeAtMs);
|
|
219
|
+
const how = hold.resetsKnown ? `上限が戻る時刻に合わせて ${when}(日本時間)に` : `戻る時刻が読めないので ${when}(日本時間)に`;
|
|
220
|
+
return (`Claude の${usageLimitLabel(hold.limitType)}に当たりました。PC「${machine}」への配達を止め、この便は失敗にせず待ちに戻しました。` +
|
|
221
|
+
`${how}自動で配達を再開します。アカウントを切り替えたときは、その PC で \`conductor resume-delivery\` を打つと今すぐ再開します。`);
|
|
222
|
+
}
|
|
223
|
+
export function limitResumePath(site) {
|
|
224
|
+
const safe = String(site ?? '').replace(/[^A-Za-z0-9_.-]/g, '_');
|
|
225
|
+
return path.join(stateDir(), `usage-limit-resume-${safe}.json`);
|
|
226
|
+
}
|
|
227
|
+
function readResumeList(site) {
|
|
228
|
+
try {
|
|
229
|
+
const v = JSON.parse(readFileSync(limitResumePath(site), 'utf8'));
|
|
230
|
+
if (!Array.isArray(v))
|
|
231
|
+
return [];
|
|
232
|
+
return v.filter((r) => r !== null && typeof r === 'object'
|
|
233
|
+
&& typeof r.commandId === 'string'
|
|
234
|
+
&& typeof r.sessionId === 'string'
|
|
235
|
+
&& typeof r.attempt === 'number');
|
|
236
|
+
}
|
|
237
|
+
catch {
|
|
238
|
+
return [];
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
/** 控えを残す(★同じ便は1件だけ・20件まで)。中継が立ち上げ直しても続きから起こせるようにファイルに置く。 */
|
|
242
|
+
export function saveLimitResume(site, rec) {
|
|
243
|
+
const kept = readResumeList(site).filter((r) => r.commandId !== rec.commandId);
|
|
244
|
+
kept.push({ commandId: rec.commandId, sessionId: rec.sessionId, attempt: rec.attempt });
|
|
245
|
+
try {
|
|
246
|
+
mkdirSync(stateDir(), { recursive: true });
|
|
247
|
+
writeFileSync(limitResumePath(site), JSON.stringify(kept.slice(-20)) + '\n');
|
|
248
|
+
}
|
|
249
|
+
catch { /* 残せなくても便は待ちに戻っている(次は今までどおりの起こし方になる) */ }
|
|
250
|
+
}
|
|
251
|
+
/** 控えを取り出して消す。無ければ null。 */
|
|
252
|
+
export function takeLimitResume(site, commandId) {
|
|
253
|
+
const list = readResumeList(site);
|
|
254
|
+
const hit = list.find((r) => r.commandId === commandId) ?? null;
|
|
255
|
+
if (hit === null)
|
|
256
|
+
return null;
|
|
257
|
+
try {
|
|
258
|
+
writeFileSync(limitResumePath(site), JSON.stringify(list.filter((r) => r.commandId !== commandId)) + '\n');
|
|
259
|
+
}
|
|
260
|
+
catch { /* 消せなくても二重に使うだけ(続きから起こすのは同じ会話) */ }
|
|
261
|
+
return hit;
|
|
262
|
+
}
|
package/package.json
CHANGED
|
@@ -18,6 +18,13 @@ 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
|
+
- ★**便ごとの作業場所で起きたとき(えふさん決定 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 で切っている等)は、今までどおりこの項の残りのとおり。
|
|
21
28
|
- ★**手元の作業場所で枝を切り替えられないとき**(はじめから在る変更が切り替えとぶつかる等)は、`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)。
|
|
22
29
|
- ★**リポ全体の差分が「読めないファイル」で落ちたとき**(`unsupported file type` / `cannot hash <名前>` が出る/`.npmrc` のような設定が身に覚えなく `M` で出る)。**これは壊れていない。**
|
|
23
30
|
秘密に分類されたファイルは職人から中身を隠してあるので、git がそのファイルを数えられないだけ。**中身を見に行く方へ回らない。**
|