@phren/cli 0.1.10 → 0.1.12

package/dist/cli/hooks-session.js

@@ -428,8 +428,13 @@ async function runBestEffortGit(args, cwd) {
 }
 async function countUnsyncedCommits(cwd) {
     const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-    if (!upstream.ok || !upstream.output)
-        return 0;
+    if (!upstream.ok || !upstream.output) {
+        const allCommits = await runBestEffortGit(["rev-list", "--count", "HEAD"], cwd);
+        if (!allCommits.ok || !allCommits.output)
+            return 0;
+        const parsed = Number.parseInt(allCommits.output.trim(), 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
     const ahead = await runBestEffortGit(["rev-list", "--count", `${upstream.output.trim()}..HEAD`], cwd);
     if (!ahead.ok || !ahead.output)
         return 0;
@@ -1156,17 +1161,51 @@ export async function handleHookContext() {
                 parts.push("");
             }
         }
+        // Collect pinned tasks across ALL projects (excluding Done)
+        const allTaskRows = queryRows(db, "SELECT project, content FROM docs WHERE type = 'task'", []);
+        const pinnedFromOtherProjects = [];
+        if (allTaskRows) {
+            for (const row of allTaskRows) {
+                const taskProject = row[0];
+                if (taskProject === project)
+                    continue;
+                const content = row[1];
+                const pinned = content.split("\n")
+                    .filter(l => l.startsWith("- [ ] ") && /\[pinned\]/i.test(l))
+                    .map(l => `[${taskProject}] ${l}`);
+                pinnedFromOtherProjects.push(...pinned);
+            }
+        }
+        // Active project tasks — pinned float to top, exclude Done
         const taskRow = queryRows(db, "SELECT content FROM docs WHERE project = ? AND type = 'task'", [project]);
+        const pinnedItems = [];
+        const otherItems = [];
         if (taskRow) {
             const content = taskRow[0][0];
-            const activeItems = content.split("\n").filter(l => l.startsWith("- "));
-            const filtered = filterTaskByPriority(activeItems);
-            const trimmed = filtered.slice(0, 5);
-            if (trimmed.length > 0) {
+            const allItems = content.split("\n").filter(l => l.startsWith("- [ ] "));
+            for (const item of allItems) {
+                if (/\[pinned\]/i.test(item)) {
+                    pinnedItems.push(item);
+                }
+                else {
+                    otherItems.push(item);
+                }
+            }
+        }
+        const filteredOther = filterTaskByPriority(otherItems);
+        const allPinned = [...pinnedItems, ...pinnedFromOtherProjects].slice(0, 10);
+        const remaining = Math.max(0, 5 - allPinned.length);
+        const trimmedOther = filteredOther.slice(0, remaining);
+        if (allPinned.length > 0 || trimmedOther.length > 0) {
+            if (allPinned.length > 0) {
+                parts.push("## Pinned tasks");
+                parts.push(allPinned.join("\n"));
+            }
+            if (trimmedOther.length > 0) {
                 parts.push("## Active tasks");
-                parts.push(trimmed.join("\n"));
-                parts.push("");
+                parts.push(trimmedOther.join("\n"));
             }
+            parts.push("");
         }
     }
     else {

package/dist/cli/team.js

@@ -7,6 +7,7 @@ import * as path from "path";
 import { execFileSync } from "child_process";
 import { getPhrenPath } from "../shared.js";
 import { isValidProjectName } from "../utils.js";
+import { addProjectToProfile, resolveActiveProfile } from "../profile-store.js";
 import { addStoreToRegistry, findStoreByName, generateStoreId, readTeamBootstrap, updateStoreProjects, } from "../store-registry.js";
 const EXEC_TIMEOUT_MS = 30_000;
 function getOptionValue(args, name) {
@@ -243,6 +244,17 @@ async function handleTeamAddProject(args) {
     if (!currentProjects.includes(projectName)) {
         updateStoreProjects(phrenPath, storeName, [...currentProjects, projectName]);
     }
+    // Add project to active profile so it's visible to profile-filtered operations
+    const activeProfile = resolveActiveProfile(phrenPath);
+    if (activeProfile.ok && activeProfile.data) {
+        const addResult = addProjectToProfile(phrenPath, activeProfile.data, projectName);
+        if (!addResult.ok) {
+            throw new Error(addResult.error);
+        }
+    }
+    else if (!activeProfile.ok && activeProfile.code !== "FILE_NOT_FOUND") {
+        throw new Error(activeProfile.error);
+    }
     console.log(`Added project "${projectName}" to team store "${storeName}"`);
     console.log(`  Path: ${projectDir}`);
     console.log(`  Journal: ${journalDir}`);

package/dist/cli-hooks-git.js

@@ -123,8 +123,15 @@ export async function runBestEffortGit(args, cwd) {
 }
 export async function countUnsyncedCommits(cwd) {
     const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-    if (!upstream.ok || !upstream.output)
-        return 0;
+    if (!upstream.ok || !upstream.output) {
+        // No upstream tracking branch — count all local commits as unsynced
+        // so the warning at the call site fires instead of silently returning 0
+        const allCommits = await runBestEffortGit(["rev-list", "--count", "HEAD"], cwd);
+        if (!allCommits.ok || !allCommits.output)
+            return 0;
+        const parsed = Number.parseInt(allCommits.output.trim(), 10);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
     const ahead = await runBestEffortGit(["rev-list", "--count", `${upstream.output.trim()}..HEAD`], cwd);
     if (!ahead.ok || !ahead.output)
         return 0;

package/dist/cli-hooks-stop.js

@@ -435,32 +435,20 @@ export async function handleHookStop() {
             return;
         }
         // Check if HEAD has an upstream tracking branch before attempting sync.
-        // Detached HEAD or branches without upstream would cause silent push failures.
+        // If no upstream is set but a remote exists, auto-set it to avoid silent push failures.
         const upstream = await runBestEffortGit(["rev-parse", "--abbrev-ref", "@{upstream}"], phrenPath);
         if (!upstream.ok || !upstream.output) {
-            const unsyncedCommits = await countUnsyncedCommits(phrenPath);
-            const noUpstreamDetail = "commit created; no upstream tracking branch";
-            finalizeTaskSession({
-                phrenPath,
-                sessionId: taskSessionId,
-                status: "no-upstream",
-                detail: noUpstreamDetail,
-            });
-            updateRuntimeHealth(phrenPath, {
-                lastStopAt: now,
-                lastAutoSave: { at: now, status: "no-upstream", detail: noUpstreamDetail },
-                lastSync: {
-                    lastPushAt: now,
-                    lastPushStatus: "no-upstream",
-                    lastPushDetail: noUpstreamDetail,
-                    unsyncedCommits,
-                },
-            });
-            appendAuditLog(phrenPath, "hook_stop", "status=no-upstream");
-            if (unsyncedCommits > 3) {
-                process.stderr.write(`phren: ${unsyncedCommits} unsynced commits — no upstream tracking branch.\n`);
+            // Try to auto-set upstream: get current branch and set tracking to origin/<branch>
+            const branch = await runBestEffortGit(["rev-parse", "--abbrev-ref", "HEAD"], phrenPath);
+            if (branch.ok && branch.output) {
+                const branchName = branch.output.trim();
+                const setUpstream = await runBestEffortGit(["branch", "--set-upstream-to", `origin/${branchName}`, branchName], phrenPath);
+                if (!setUpstream.ok) {
+                    // Upstream auto-set failed — log and continue to sync anyway
+                    logger.debug("hookStop", `failed to auto-set upstream for ${branchName}`);
+                }
             }
-            return;
+            // Fall through to scheduleBackgroundSync instead of returning early
         }
         const unsyncedCommits = await countUnsyncedCommits(phrenPath);
         const scheduled = scheduleBackgroundSync(phrenPath);