nawabari 0.9.2 → 0.10.2

package/dist/session-registry.d.ts

@@ -222,12 +222,19 @@ export type GarbageCollectEligibility = "eligible" | "ineligible" | "ambiguous";
 export type GarbageCollectSuspicionReason = "none" | "elapsed-age" | "explicit-lifecycle-state" | "missing-worktree" | "ambiguous-physical-state";
 export type GarbageCollectEligibilityReason = "not-suspected" | "age-only" | "explicit-stale-state" | "explicit-closing-state" | "prunable-missing-worktree" | "physical-state-ambiguous";
 /** Bounded machine-readable GC assessment. Session identity stays flat for API compatibility. */
-export interface GarbageCollectCandidate extends SessionRecord {
+export interface GarbageCollectAssessment extends SessionRecord {
     readonly physicalState: string;
     readonly suspicion: GarbageCollectSuspicion;
     readonly suspicionReason: GarbageCollectSuspicionReason;
     readonly destructiveEligibility: GarbageCollectEligibility;
     readonly destructiveEligibilityReason: GarbageCollectEligibilityReason;
+}
+/**
+ * A GC result adds lifecycle actions to the assessment. Diagnostics use the
+ * assessment alone so inspect has one canonical lifecycle projection rather
+ * than a copied nested projection.
+ */
+export interface GarbageCollectCandidate extends GarbageCollectAssessment {
     /** Canonical read-only lifecycle projection for this GC observation. */
     readonly lifecycle?: SessionLifecycleClassification;
     /** Typed caller actions projected from the same lifecycle snapshot. */
@@ -312,7 +319,7 @@ export interface SessionDiagnostic {
     /** All bounded actions available for the observed state, in deterministic order. */
     readonly nextActions: readonly SessionLifecycleAction[];
     readonly integrationEvidence: SessionDiagnosticIntegrationEvidence;
-    readonly garbageCollection: GarbageCollectCandidate;
+    readonly garbageCollection: GarbageCollectAssessment;
     /** Canonical termination/recovery projection; additive for old consumers. */
     readonly lifecycle?: SessionLifecycleClassification;
 }
@@ -619,12 +626,13 @@ export declare class SessionRegistry {
     private readonly protectedBranchNames;
     private readonly protectedWorktreePaths;
     private readonly worktreeRoot;
+    private readonly worktreeRootIsDefault;
     private readonly staleAfterMs;
     private readonly lockStaleAfterMs;
     private readonly lockMetadataGraceMs;
     private readonly lock;
     constructor(options?: SessionRegistryOptions);
-    /** Resolved repository-local root used for default managed session worktrees. */
+    /** Resolved managed root used for default session worktrees. */
     get managedWorktreeRoot(): string;
     read(): readonly SessionRecord[];
     list(): readonly SessionRecord[];

package/dist/session-registry.js

@@ -75,6 +75,7 @@ export class SessionRegistry {
     protectedBranchNames;
     protectedWorktreePaths;
     worktreeRoot;
+    worktreeRootIsDefault;
     staleAfterMs;
     lockStaleAfterMs;
     lockMetadataGraceMs;
@@ -88,7 +89,14 @@ export class SessionRegistry {
         this.defaultBranchName = options.defaultBranchName;
         this.protectedBranchNames = Object.freeze([...(options.protectedBranchNames ?? [])]);
         this.protectedWorktreePaths = Object.freeze([...(options.protectedWorktreePaths ?? [])]);
-        this.worktreeRoot = resolveManagedWorktreeRoot(options.worktreeRoot ?? path.dirname(this.repository.worktreePath));
+        const configuredWorktreeRoot = options.worktreeRoot;
+        this.worktreeRootIsDefault = configuredWorktreeRoot === undefined;
+        if (configuredWorktreeRoot === undefined) {
+            this.worktreeRoot = defaultManagedWorktreeRoot(this.repository.worktreePath);
+        }
+        else {
+            this.worktreeRoot = resolveManagedWorktreeRoot(configuredWorktreeRoot);
+        }
         this.staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
         this.lockStaleAfterMs = options.lockStaleAfterMs ?? this.lockTimeoutMs;
         this.lockMetadataGraceMs = options.lockMetadataGraceMs ?? DEFAULT_LOCK_METADATA_GRACE_MS;
@@ -117,7 +125,7 @@ export class SessionRegistry {
             metadataGraceMs: this.lockMetadataGraceMs,
         });
     }
-    /** Resolved repository-local root used for default managed session worktrees. */
+    /** Resolved managed root used for default session worktrees. */
     get managedWorktreeRoot() {
         return this.worktreeRoot;
     }
@@ -1753,8 +1761,8 @@ export class SessionRegistry {
                 if (assessment.terminalOperation === "discard")
                     return false;
                 // Eligibility is evaluated from the GC authority's own bounded
-                // evidence. Full cleanup blockers remain on `assessment.lifecycle`
-                // and are applied by the existing preflight below.
+                // evidence. Full cleanup blockers are applied by the existing
+                // preflight below.
                 const gcLifecycle = projectGarbageCollectAuthorization(assessment);
                 if (assessment.destructiveEligibility === "eligible" &&
                     (gcLifecycle.destructiveCleanupEligible || assessment.physicalState === "prunable-missing")) {
@@ -2624,8 +2632,7 @@ export class SessionRegistry {
                 phase: "termination",
             });
             const nextActions = projectSessionLifecycleActions({ classification: lifecycle, sessionId: record.sessionId });
-            const garbageCollection = closedGarbageCollectionAssessment(record, now);
-            const projectedGarbageCollection = projectGarbageCollectCandidateLifecycle(garbageCollection, lifecycle, []);
+            const garbageCollection = closedGarbageCollectionAssessment(record);
             return Object.freeze({
                 schemaVersion: SESSION_DIAGNOSTIC_SCHEMA_VERSION,
                 operation: "diagnostic",
@@ -2644,7 +2651,7 @@ export class SessionRegistry {
                 ...(nextActions.length === 0 ? {} : { nextAction: nextActions[0] }),
                 nextActions,
                 integrationEvidence: Object.freeze(integrationEvidence),
-                garbageCollection: projectedGarbageCollection,
+                garbageCollection,
                 lifecycle,
             });
         }
@@ -2677,7 +2684,6 @@ export class SessionRegistry {
             ageSuspicious: Date.parse(now) - Date.parse(record.updatedAt) >= this.staleAfterMs,
             phase: "termination",
         });
-        garbageCollection = projectGarbageCollectCandidateLifecycle(garbageCollection, lifecycle, blockers);
         const safeActions = blockers.length > 0
             ? sortStrings(Array.from(new Set(blockers.flatMap((blocker) => blocker.safeActions))))
             : closeReadiness === "ready"
@@ -3019,7 +3025,17 @@ export class SessionRegistry {
             : options.worktreeRoot !== undefined
                 ? resolveManagedWorktreeRoot(options.worktreeRoot)
                 : this.worktreeRoot;
-        const requestedWorktreePath = resolveProvisionedWorktreePath(options.worktreePath ?? path.join(effectiveRoot, `${path.basename(this.repository.worktreePath)}-${sessionId}`), effectiveRoot);
+        const legacyRoot = path.dirname(this.repository.worktreePath);
+        const legacyCompatibilityEnabled = this.worktreeRootIsDefault && options.worktreeRoot === undefined;
+        const defaultRootSelected = legacyCompatibilityEnabled &&
+            (options.worktreePath === undefined ||
+                !path.isAbsolute(options.worktreePath) ||
+                isPathInside(this.worktreeRoot, path.resolve(options.worktreePath)));
+        if (defaultRootSelected)
+            ensureManagedWorktreeRoot(this.worktreeRoot);
+        const requestedWorktreePath = options.worktreePath === undefined
+            ? resolveProvisionedWorktreePath(path.join(effectiveRoot, `${path.basename(this.repository.worktreePath)}-${sessionId}`), effectiveRoot)
+            : resolveProvisionedWorktreePathWithLegacyCompatibility(options.worktreePath, effectiveRoot, legacyCompatibilityEnabled ? legacyRoot : undefined);
         const defaultWorktreePath = worktrees.find((worktree) => !worktree.prunable)?.worktreePath ?? this.repository.worktreePath;
         const configuredProtectedWorktrees = [
             ...this.protectedWorktreePaths,
@@ -3359,17 +3375,6 @@ function assessGarbageCollection(record, now, staleAfterMs, worktrees) {
         destructiveEligibility = "ineligible";
         destructiveEligibilityReason = "age-only";
     }
-    const lifecycle = projectGarbageCollectAuthorization({
-        state: record.state,
-        physicalState: worktreeState.kind,
-        terminalOperation: record.terminalOperation,
-        suspicion,
-        destructiveEligibility,
-    });
-    const nextActions = projectSessionLifecycleActions({
-        classification: lifecycle,
-        sessionId: record.sessionId,
-    });
     return Object.freeze({
         ...cloneSessionRecord(record),
         physicalState: worktreeState.kind,
@@ -3377,8 +3382,6 @@ function assessGarbageCollection(record, now, staleAfterMs, worktrees) {
         suspicionReason,
         destructiveEligibility,
         destructiveEligibilityReason,
-        lifecycle,
-        nextActions,
     });
 }
 /** Evaluate GC's independent authorization through the canonical machine. */
@@ -3394,18 +3397,7 @@ function projectGarbageCollectAuthorization(candidate) {
         phase: "termination",
     });
 }
-function closedGarbageCollectionAssessment(record, now) {
-    const lifecycle = classifySessionLifecycle({
-        sessionState: record.state,
-        physicalState: "closed",
-        closeReadiness: "ready",
-        terminalOperation: record.terminalOperation,
-        phase: "termination",
-    });
-    const nextActions = projectSessionLifecycleActions({
-        classification: lifecycle,
-        sessionId: record.sessionId,
-    });
+function closedGarbageCollectionAssessment(record) {
     return Object.freeze({
         ...cloneSessionRecord(record),
         physicalState: "closed",
@@ -3413,8 +3405,6 @@ function closedGarbageCollectionAssessment(record, now) {
         suspicionReason: "none",
         destructiveEligibility: "ineligible",
         destructiveEligibilityReason: "not-suspected",
-        lifecycle,
-        nextActions,
     });
 }
 function isDestructiveGcEligible(record, worktrees) {
@@ -3576,15 +3566,6 @@ function toCleanupBlocker(error) {
         recoveryHints: Object.freeze(recoveryHints),
     });
 }
-/** Keep the nested GC assessment on the same observed lifecycle snapshot. */
-function projectGarbageCollectCandidateLifecycle(candidate, lifecycle, blockers) {
-    const nextActions = projectSessionLifecycleActions({
-        classification: lifecycle,
-        sessionId: candidate.sessionId,
-        blockers,
-    });
-    return Object.freeze({ ...candidate, lifecycle, nextActions });
-}
 function toDiagnosticBlocker(error) {
     const blocker = toCleanupBlocker(error);
     return Object.freeze({
@@ -3949,9 +3930,18 @@ function runMutationGit(git, args, cwd, phase, failureCode) {
             ...(error instanceof SessionRegistryError ? error.details : {}),
             ...(error instanceof SessionRegistryError ? { gitCode: error.code } : {}),
         };
+        if (failureCode === "COMMIT_FAILED" && isMissingGitIdentityFailure(details.stderr)) {
+            throw new SessionRegistryError(failureCode, `${phase} Git operation failed: Git author identity (user.name/user.email) is unavailable`, {
+                ...details,
+                hint: "Set repository-local identity with `git config user.name`/`git config user.email`, or configure the host's global Git identity before starting the session.",
+            }, error);
+        }
         throw new SessionRegistryError(failureCode, `${phase} Git operation failed`, details, error);
     }
 }
+function isMissingGitIdentityFailure(stderr) {
+    return typeof stderr === "string" && /Please tell me who you are|unable to auto-detect email address/u.test(stderr);
+}
 /**
  * Reconcile a bounded commit transport failure against the only authoritative
  * local commit evidence: HEAD and the paths recorded by that HEAD.  A
@@ -4467,6 +4457,23 @@ function generateUniqueSessionId(records, idGenerator) {
     }
     throw new SessionRegistryError("SESSION_ID_COLLISION", `Could not generate a unique session ID after ${MAX_ID_GENERATION_ATTEMPTS} attempts`, { attempts: MAX_ID_GENERATION_ATTEMPTS });
 }
+function defaultManagedWorktreeRoot(repositoryWorktreePath) {
+    const resolved = path.resolve(path.dirname(repositoryWorktreePath), ".nawabari", "worktrees");
+    assertNoSymlinkPath(resolved);
+    return resolved;
+}
+function ensureManagedWorktreeRoot(candidate) {
+    try {
+        assertNoSymlinkPath(candidate);
+        fs.mkdirSync(candidate, { recursive: true, mode: 0o700 });
+        return resolveManagedWorktreeRoot(candidate);
+    }
+    catch (error) {
+        if (error instanceof SessionRegistryError)
+            throw error;
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Could not create managed worktree root: ${candidate}`, { worktree: candidate }, error);
+    }
+}
 function resolveManagedWorktreeRoot(candidate) {
     if (candidate.includes("\u0000") || candidate.trim().length === 0) {
         throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Invalid managed worktree root: ${candidate}`, {
@@ -4489,6 +4496,15 @@ function resolveManagedWorktreeRoot(candidate) {
         throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Could not resolve managed worktree root: ${resolved}`, { worktree: resolved }, error);
     }
 }
+function resolveProvisionedWorktreePathWithLegacyCompatibility(candidate, managedRoot, legacyRoot) {
+    if (legacyRoot !== undefined && path.isAbsolute(candidate)) {
+        const resolved = path.resolve(candidate);
+        if (!isPathInside(managedRoot, resolved) && isPathInside(legacyRoot, resolved)) {
+            return resolveProvisionedWorktreePath(candidate, legacyRoot);
+        }
+    }
+    return resolveProvisionedWorktreePath(candidate, managedRoot);
+}
 function resolveProvisionedWorktreePath(candidate, managedRoot) {
     if (candidate.includes("\u0000") || candidate.trim().length === 0) {
         throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Invalid worktree path: ${candidate}`, {